sneakoscope 9.0.5 → 9.1.0

package/README.md

@@ -22,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 -->
 
-This README documents package **SKS 9.0.5** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
+This README documents package **SKS 9.1.0** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
 
 Use the official latest stable SKS and Codex CLI releases. The Codex compatibility SSOT is always the **current latest stable** host; capability probes measure what that host can actually do. Product docs do not crown a fixed `0.x.y` string as SSOT (release pins and schema directories are measured artifacts for the current package, not a permanent product version claim). Menu Bar / Center induce updates to the latest stable build. Run `sks update-check` for what is installed and read the capability report for what is supported. Install SSOT is npm `sneakoscope@latest`; PATH `sks` and Menu Bar stamped generation must match that version or gates fail. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it (Codex official multi-agent wrap-only; SKS does not reimplement a parallel runtime). Local code search is mode-separated (`sks search files|text|structure|symbol|context`); `context` is answered by the compiled TriWiki Context Graph (`context-graph.json` is exhaustive authority; `context-pack.json` and managed `AGENTS.md` are bounded projections) — see [docs/architecture/context-graph.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/architecture/context-graph.md) and [docs/PRODUCT-CONTRACT.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/PRODUCT-CONTRACT.md). See [CHANGELOG.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/CHANGELOG.md).
 

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "9.0.5"
+version = "9.1.0"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

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

package/dist/cli/router.js

@@ -302,6 +302,9 @@ export function safeReadOnlySubcommand(command, args) {
     if (command === 'mcp' && sub === 'config' && ['list', 'test', 'backups', 'show'].includes(nested)) {
         return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
     }
+    if (command === 'codex-app' && sub === 'context-1m' && (nested === 'status' || nested === '' || nested.startsWith('--'))) {
+        return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
+    }
     if (command === 'remote' && ['readiness', 'status', 'show'].includes(sub)) {
         return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
     }

package/dist/commands/codex-app.js

@@ -16,6 +16,35 @@ export async function run(_command, args = []) {
     const action = args[0] || 'check';
     if (action === 'restart')
         return printCodexAppResult(args, await restartCodexApp());
+    if (action === 'context-1m') {
+        const { codexContext1mCommand } = await import('../core/codex-app/codex-context-window.js');
+        const result = await codexContext1mCommand(args.slice(1));
+        if (flag(args, '--json')) {
+            printJson(result);
+            if (!result.ok)
+                process.exitCode = 1;
+            return;
+        }
+        console.log(`Codex 1M Context: ${result.enabled ? 'enabled' : 'disabled'}`);
+        console.log(`Config: ${result.config_path}`);
+        console.log(`Model: ${result.model || 'not set'} (documented for ${result.expected_model})`);
+        for (const [key, target] of Object.entries(result.target)) {
+            const state = result.keys[key];
+            const detail = state?.present ? `${state.value ?? 'unparsed'}${state.managed ? ' (SKS-managed)' : ''}` : 'not set';
+            console.log(`${key}: ${detail} · target ${target}`);
+        }
+        if (result.restart)
+            console.log(`Restart: ${result.restart.status}${result.restart.reason ? ` (${result.restart.reason})` : ''}`);
+        for (const note of result.notes)
+            console.log(`Note: ${note}`);
+        for (const warning of result.warnings)
+            console.log(`- warning: ${warning}`);
+        for (const blocker of result.blockers)
+            console.log(`- blocker: ${blocker}`);
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
     if (action === 'remote-control' || action === 'remote')
         return codexAppRemoteControlCommand(args.slice(1));
     if (action === 'harness-matrix') {
@@ -108,7 +137,7 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    console.error('Usage: sks codex-app check|status|restart|harness-matrix|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|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('Usage: sks codex-app check|status|restart|context-1m [status|on|off] [--no-restart]|harness-matrix|skill-sync|agent-role-sync|init-deep|hook-lifecycle|execution-profile|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('Provider routing moved to: sks bridge provider configure|validate|enable; sks bridge catalog sync; sks bridge route set-default.');
     process.exitCode = 1;
 }

package/dist/commands/doctor.js

@@ -7,10 +7,8 @@ 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 { desktopBridgeStatusV3, executeDesktopBridgeCommandV3 } from '../core/codex-lb/desktop-controller-v3.js';
-import { bootstrapExistingDesktopBridgeService, desktopBridgeServiceStatus } from '../core/codex-lb/desktop-service.js';
-import { desktopBridgeRuntimeVersion, desktopBridgeRuntimeVersionStale } from '../core/codex-lb/desktop-bridge/state.js';
-import { PACKAGE_VERSION } from '../core/version.js';
+import { desktopBridgeStatusV3 } from '../core/codex-lb/desktop-controller-v3.js';
+import { repairDoctorDesktopBridgeCatalog } from '../core/doctor/desktop-bridge-catalog-repair.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';
@@ -37,29 +35,7 @@ export { buildCodexAppUiDiagnosticFailure, buildRuntimeReadiness, formatCodexDoc
 export function doctorArgWarnings(args = []) {
     return baseDoctorArgWarnings(args);
 }
-export async function restartStaleDesktopBridgeRuntime(input) {
-    if (process.env.SKS_TEST_ISOLATION === '1' || process.env.SKS_RELEASE_UPGRADE_SMOKE === '1') {
-        return { restarted: false, warnings: [], blockers: [] };
-    }
-    const service = await desktopBridgeServiceStatus({ home: input.home }).catch(() => null);
-    if (!service?.running || !desktopBridgeRuntimeVersionStale(service.state)) {
-        return { restarted: false, warnings: [], blockers: [] };
-    }
-    const running = desktopBridgeRuntimeVersion(service.state) || 'pre-8.6.2';
-    if (!input.fix) {
-        return {
-            restarted: false,
-            warnings: [],
-            blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`]
-        };
-    }
-    const restarted = await bootstrapExistingDesktopBridgeService({ home: input.home }).catch(() => null);
-    const nowRunning = restarted?.running === true && !desktopBridgeRuntimeVersionStale(restarted.state);
-    return nowRunning
-        ? { restarted: true, warnings: [`desktop_bridge_runtime_restarted:${running}:${PACKAGE_VERSION}`], blockers: [] }
-        : { restarted: false, warnings: [], blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`] };
-}
-export const CATALOG_REPAIR_MAX_ATTEMPTS = 2;
+export { CATALOG_REPAIR_MAX_ATTEMPTS, repairDoctorDesktopBridgeCatalog, restartStaleDesktopBridgeRuntime } from '../core/doctor/desktop-bridge-catalog-repair.js';
 export function deferCommandAliasCleanupToMigrationReceipt(result) {
     const observedBlockers = Array.isArray(result?.blockers)
         ? result.blockers.map(String).filter(Boolean)
@@ -214,19 +190,41 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         status: 'failed',
         error: err?.message || String(err)
     }));
-    const menuBar = await installMenuBarImpl({
-        home,
-        root: home,
-        apply: true,
-        launch: !sksMenuBarRestartDeferred(doctorEnv),
-        env: doctorEnv,
-        quiet: flag(args, '--json') || flag(args, '--machine-only')
-    }).catch((err) => ({
-        schema: 'sks.codex-app-sks-menubar.v1',
+    const doctorProfile = doctorProfileFromArgs(args, true);
+    const menuBarPolicy = doctorMenuBarInstallPolicy(args, true, doctorEnv);
+    const menuBar = menuBarPolicy.phase_enabled
+        ? await installMenuBarImpl({
+            home,
+            root: home,
+            apply: true,
+            launch: !sksMenuBarRestartDeferred(doctorEnv),
+            env: doctorEnv,
+            quiet: flag(args, '--json') || flag(args, '--machine-only')
+        }).catch((err) => ({
+            schema: 'sks.codex-app-sks-menubar.v1',
+            ok: false,
+            status: 'blocked',
+            blockers: [err?.message || String(err)],
+            warnings: []
+        }))
+        : {
+            schema: 'sks.codex-app-sks-menubar.v1',
+            ok: true,
+            status: 'skipped_by_profile',
+            skipped: true,
+            blockers: [],
+            warnings: [`sks_menubar_phase_skipped_for_profile:${doctorProfile}`]
+        };
+    const desktopBridgeRepairImpl = deps.desktopBridgeRepairImpl || repairDoctorDesktopBridgeCatalog;
+    const desktopBridgeRepair = await desktopBridgeRepairImpl({ fix: true }).catch((err) => ({
+        id: 'desktop_bridge_catalog_repair',
         ok: false,
-        status: 'blocked',
-        blockers: [err?.message || String(err)],
-        warnings: []
+        repaired: false,
+        required_for_ready: false,
+        manual_required: false,
+        warnings: [],
+        blockers: [`desktop_bridge_catalog_repair_failed:${err?.message || String(err)}`],
+        rollback_evidence: 'combined_catalog_previous_generation_preserved'
     }));
     const desktopBridge = await inspectDoctorDesktopBridgeStatus({
         home,
@@ -238,15 +236,54 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
     const globalFastModeReady = globalFastMode?.status !== 'failed'
         && globalFastMode?.ok !== false;
     const menuBarReady = menuBar?.ok !== false;
-    const blockers = [...new Set([
+    const migrationScopeBlockers = [...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'}`] : []),
-            ...(!menuBarReady ? (menuBar?.blockers || ['sks_menubar_repair_failed']) : []),
+            ...(!globalFastModeReady ? [`global_fast_mode_repair_failed:${globalFastMode?.error || globalFastMode?.status || 'unknown'}`] : [])
+        ].map(String).filter(Boolean))];
+    const bridgeBlockers = [...new Set([
+            ...(desktopBridgeRepair?.ok === false
+                ? (desktopBridgeRepair?.blockers?.length ? desktopBridgeRepair.blockers : ['desktop_bridge_catalog_repair_failed'])
+                : []),
             ...(desktopBridge.ok === false
                 ? (desktopBridge.blockers || ['desktop_bridge_unavailable'])
                 : [])
         ].map(String).filter(Boolean))];
+    const bridgeReadinessRequired = doctorProfileRequiresDesktopBridgeReadiness(doctorProfile);
+    let migrationReceipt = null;
+    if (doctorProfile === 'migration') {
+        const writeReceiptImpl = deps.writeProjectUpdateMigrationReceiptImpl || writeProjectUpdateMigrationReceipt;
+        migrationReceipt = await writeReceiptImpl({
+            root: home,
+            source: `doctor-${doctorProfile}`,
+            blockers: migrationScopeBlockers,
+            warnings: ['global_only_home_scope_migration_receipt'],
+            ...(migrationScopeBlockers.length ? { status: 'blocked' } : {})
+        }).catch((err) => ({
+            schema: 'sks.project-migration-receipt.v2',
+            status: 'blocked',
+            sks_version: null,
+            root: home,
+            source: `doctor-${doctorProfile}`,
+            generated_at: new Date().toISOString(),
+            blockers: [`migration_receipt_failed:${err?.message || String(err)}`],
+            warnings: []
+        }));
+    }
+    const migrationReceiptBlockers = migrationReceipt && !isUpdateMigrationReceiptCurrent(migrationReceipt)
+        ? ((migrationReceipt.blockers || []).length ? migrationReceipt.blockers : ['global_migration_receipt_not_current'])
+        : [];
+    const blockers = [...new Set([
+            ...migrationScopeBlockers,
+            ...(!menuBarReady ? (menuBar?.blockers || ['sks_menubar_repair_failed']) : []),
+            ...(bridgeReadinessRequired ? bridgeBlockers : []),
+            ...migrationReceiptBlockers
+        ].map(String).filter(Boolean))];
+    const warnings = [...new Set([
+            ...(!bridgeReadinessRequired ? bridgeBlockers.map((blocker) => `migration_optional_blocker:${blocker}`) : []),
+            ...(desktopBridgeRepair?.warnings || []),
+            ...(desktopBridge?.warnings || [])
+        ].map(String).filter(Boolean))];
     const ok = blockers.length === 0;
     const projectRootAliasDetected = path.resolve(root) === home;
     return {
@@ -257,6 +294,7 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         diagnostic_depth: 'global-only',
         global_only: true,
         install_scope: 'global',
+        doctor_profile: doctorProfile,
         root,
         home,
         project_root_alias_detected: projectRootAliasDetected,
@@ -268,20 +306,26 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
             'project_supabase_mcp_repair',
             'project_hook_trust_repair',
             'project_command_alias_cleanup',
-            'project_migration_receipt'
+            ...(migrationReceipt ? [] : ['project_migration_receipt'])
         ],
         skills: { global: globalSkills, project: { skipped: true, reason: 'global_only_doctor' } },
         current_public_surface: currentSurface,
         codex_app_fast_mode: globalFastMode,
         openrouter_provider: desktopBridge.providers?.openrouter || null,
         sks_menubar: menuBar,
+        desktop_bridge_repair: desktopBridgeRepair,
         desktop_bridge: desktopBridge,
+        ...(migrationReceipt ? { migration_receipt: migrationReceipt } : {}),
         blockers,
+        warnings,
         next_actions: [
             ...(projectRootAliasDetected
                 ? ['Project checks were skipped because this directory is your home folder. Run them from your project: cd <your-project> && sks doctor --fix']
                 : []),
             ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : []),
+            ...(!bridgeReadinessRequired && bridgeBlockers.length
+                ? ['Desktop Bridge still reports blockers: run `sks doctor --fix` to repair the bridge catalog.']
+                : []),
             'Run `sks doctor --fix --json` from a specific project directory when project-scoped repair is required.'
         ]
     };
@@ -300,10 +344,19 @@ async function runDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         printJson(result);
     }
     else {
+        const bridgeRepair = result.desktop_bridge_repair;
         console.log(`SKS Doctor global repair: ${result.ok ? 'ok' : 'blocked'}`);
         console.log(`Global skills: ${result.skills.global?.error ? 'blocked' : 'reconciled'}`);
         console.log(`SKS menu bar: ${result.sks_menubar?.status || (result.sks_menubar?.ok ? 'ok' : 'blocked')}`);
+        console.log(`Desktop Bridge repair: ${bridgeRepair?.skipped_reason
+            ? bridgeRepair.skipped_reason
+            : bridgeRepair?.repaired
+                ? 'repaired'
+                : bridgeRepair?.ok === false ? 'failed' : 'nothing_to_repair'}`);
         console.log(`Desktop Bridge: ${result.desktop_bridge.ok ? 'ready' : 'blocked'} (${result.desktop_bridge.status?.readiness?.state || 'unavailable'})`);
+        if (result.migration_receipt) {
+            console.log(`Migration receipt: ${result.migration_receipt.status} (${result.home})`);
+        }
         for (const blocker of result.blockers)
             console.log(`- blocker: ${blocker}`);
         for (const action of result.next_actions)
@@ -1027,61 +1080,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
                 {
                     id: 'desktop_bridge_catalog_repair',
                     required_for_ready: false,
-                    run: async () => {
-                        const base = {
-                            id: 'desktop_bridge_catalog_repair',
-                            required_for_ready: false,
-                            manual_required: false,
-                            warnings: [],
-                            rollback_evidence: 'combined_catalog_previous_generation_preserved'
-                        };
-                        try {
-                            const bridgeHome = path.resolve(process.env.HOME || os.homedir());
-                            const restarted = await restartStaleDesktopBridgeRuntime({
-                                home: bridgeHome,
-                                fix: doctorFix,
-                            });
-                            const status = await desktopBridgeStatusV3({ home: bridgeHome, env: process.env });
-                            const blockers = (status?.readiness?.blockers || []).map(String);
-                            const stale = blockers.filter((blocker) => blocker.endsWith('_catalog_stale'));
-                            if (!status?.management?.managed || stale.length === 0) {
-                                return {
-                                    ...base,
-                                    ok: restarted.blockers.length === 0,
-                                    repaired: restarted.restarted,
-                                    warnings: restarted.warnings,
-                                    blockers: restarted.blockers
-                                };
-                            }
-                            const attempts = [];
-                            let syncedAndVerified = false;
-                            for (let attempt = 1; attempt <= CATALOG_REPAIR_MAX_ATTEMPTS; attempt += 1) {
-                                const sync = await executeDesktopBridgeCommandV3({ operation: 'catalog.sync' }, { home: bridgeHome, env: process.env });
-                                const commandOk = sync?.ok === true && sync?.execution?.ok === true;
-                                const after = await desktopBridgeStatusV3({ home: bridgeHome, env: process.env });
-                                const stillStale = (after?.readiness?.blockers || [])
-                                    .map(String).filter((blocker) => blocker.endsWith('_catalog_stale'));
-                                if (commandOk && stillStale.length === 0) {
-                                    syncedAndVerified = true;
-                                    break;
-                                }
-                                attempts.push(`catalog_sync_attempt_${attempt}:${commandOk ? `still_stale:${stillStale.join(',')}` : (sync?.execution?.blockers || ['failed']).map(String).join(',')}`);
-                            }
-                            return {
-                                ...base,
-                                ok: syncedAndVerified && restarted.blockers.length === 0,
-                                repaired: syncedAndVerified || restarted.restarted,
-                                warnings: [...restarted.warnings, ...(syncedAndVerified ? attempts : [])],
-                                blockers: [
-                                    ...(syncedAndVerified ? [] : ['desktop_bridge_catalog_still_stale_after_repair', ...attempts]),
-                                    ...restarted.blockers
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            return { ...base, ok: false, repaired: false, blockers: [String(error?.message || 'desktop_bridge_catalog_sync_failed')] };
-                        }
-                    }
+                    run: async () => repairDoctorDesktopBridgeCatalog({ fix: doctorFix })
                 }
             ].filter((phase) => doctorPhaseIds.includes(phase.id))
         }).catch((err) => ({

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "9.0.5",
+  "package_version": "9.1.0",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/codex-app/codex-context-window.js

@@ -0,0 +1,227 @@
+import { exists, readText } from '../fsx.js';
+import { escapeRegExp } from '../text/regex.js';
+import { safeWriteCodexConfigToml } from '../codex-runtime/codex-desktop-config-policy.js';
+import { codexUserConfigPath, readTopLevelTomlString } from './codex-model-catalog.js';
+import { isCodexAppRunningByBundleId } from './menubar/config.js';
+import { restartCodexApp } from './codex-app-restart.js';
+export const CODEX_CONTEXT_1M_SCHEMA = 'sks.codex-context-1m.v1';
+export const CODEX_CONTEXT_1M_MARKER = 'sks-codex-context-1m';
+export const CODEX_CONTEXT_1M_TARGETS = {
+    model_context_window: 1_000_000,
+    model_auto_compact_token_limit: 900_000
+};
+export const CODEX_CONTEXT_1M_MODEL = 'gpt-5.6-sol';
+const MANAGED_KEYS = Object.keys(CODEX_CONTEXT_1M_TARGETS);
+function topLevelRegionEnd(lines) {
+    const first = lines.findIndex((line) => /^\s*\[.+\]\s*$/.test(line));
+    return first === -1 ? lines.length : first;
+}
+function managedLine(key, previous) {
+    return `${key} = ${CODEX_CONTEXT_1M_TARGETS[key]} # ${CODEX_CONTEXT_1M_MARKER} prev=${previous}`;
+}
+function inspectKeyLines(lines, key) {
+    const end = topLevelRegionEnd(lines);
+    const keyPattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
+    const managedPattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(\\d+)\\s*#\\s*${escapeRegExp(CODEX_CONTEXT_1M_MARKER)}\\s+prev=(unset|\\d+)\\s*$`);
+    const valuePattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(\\d+)\\s*(?:#.*)?$`);
+    let state = null;
+    let duplicate = false;
+    for (let index = 0; index < end; index += 1) {
+        const line = lines[index] || '';
+        if (!keyPattern.test(line))
+            continue;
+        if (state) {
+            duplicate = true;
+            continue;
+        }
+        const managed = line.match(managedPattern);
+        const value = line.match(valuePattern);
+        state = {
+            present: true,
+            managed: Boolean(managed),
+            value: managed ? Number(managed[1]) : value ? Number(value[1]) : null,
+            previous: managed ? (managed[2] === 'unset' ? 'unset' : Number(managed[2])) : null,
+            duplicate: false,
+            lineIndex: index
+        };
+    }
+    if (!state)
+        return { present: false, managed: false, value: null, previous: null, duplicate: false, lineIndex: -1 };
+    return { ...state, duplicate };
+}
+export function inspectCodexContext1m(text) {
+    const lines = String(text || '').split('\n');
+    const warnings = [];
+    const keys = {};
+    for (const key of MANAGED_KEYS) {
+        const { lineIndex: _lineIndex, ...state } = inspectKeyLines(lines, key);
+        keys[key] = state;
+        if (state.duplicate)
+            warnings.push(`codex_context_duplicate_key:${key}`);
+        if (state.managed && state.value !== CODEX_CONTEXT_1M_TARGETS[key])
+            warnings.push(`codex_context_managed_value_drift:${key}`);
+    }
+    const enabled = MANAGED_KEYS.every((key) => keys[key].managed && keys[key].value === CODEX_CONTEXT_1M_TARGETS[key]);
+    return { enabled, model: readTopLevelTomlString(String(text || ''), 'model'), keys, warnings };
+}
+export function enableCodexContext1m(text) {
+    const source = String(text || '');
+    const lines = source.split('\n');
+    const blockers = [];
+    const previous = {};
+    for (const key of MANAGED_KEYS) {
+        const state = inspectKeyLines(lines, key);
+        if (state.duplicate)
+            blockers.push(`codex_context_duplicate_key:${key}`);
+        if (state.present && !state.managed && state.value === null)
+            blockers.push(`codex_context_unparseable_value:${key}`);
+    }
+    if (blockers.length)
+        return { next: source, changed: false, previous: {}, restored: {}, blockers, warnings: [] };
+    for (const key of MANAGED_KEYS) {
+        const state = inspectKeyLines(lines, key);
+        if (state.present) {
+            const prior = state.managed ? (state.previous ?? 'unset') : state.value;
+            previous[key] = prior;
+            lines[state.lineIndex] = managedLine(key, prior);
+        }
+        else {
+            previous[key] = 'unset';
+            lines.splice(topLevelRegionEnd(lines), 0, managedLine(key, 'unset'));
+        }
+    }
+    const next = lines.join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
+    return { next, changed: next !== source, previous, restored: {}, blockers: [], warnings: [] };
+}
+export function disableCodexContext1m(text) {
+    const source = String(text || '');
+    const lines = source.split('\n');
+    const warnings = [];
+    const restored = {};
+    for (const key of MANAGED_KEYS) {
+        const state = inspectKeyLines(lines, key);
+        if (state.duplicate) {
+            return { next: source, changed: false, previous: {}, restored: {}, blockers: [`codex_context_duplicate_key:${key}`], warnings: [] };
+        }
+        if (!state.present)
+            continue;
+        if (!state.managed) {
+            warnings.push(`codex_context_unmanaged_key_left:${key}`);
+            continue;
+        }
+        const prior = state.previous ?? 'unset';
+        restored[key] = prior;
+        if (prior === 'unset')
+            lines.splice(state.lineIndex, 1);
+        else
+            lines[state.lineIndex] = `${key} = ${prior}`;
+    }
+    const next = lines.join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
+    return { next, changed: next !== source, previous: {}, restored, blockers: [], warnings };
+}
+export function normalizeCodexContext1mAction(value) {
+    const text = String(value || 'status').toLowerCase();
+    if (['on', 'enable', 'enabled', '1m'].includes(text))
+        return 'on';
+    if (['off', 'disable', 'disabled', 'default'].includes(text))
+        return 'off';
+    return 'status';
+}
+export async function codexContext1mCommand(args = [], opts = {}) {
+    const env = opts.env || process.env;
+    const action = normalizeCodexContext1mAction(args[0]);
+    const noRestart = args.includes('--no-restart');
+    const configPath = codexUserConfigPath({ env, ...(opts.home ? { home: opts.home } : {}) });
+    const before = String(await readText(configPath, ''));
+    const fileExists = await exists(configPath);
+    const blockers = [];
+    const warnings = [];
+    let write = null;
+    let changed = false;
+    let afterText = before;
+    let mutation = null;
+    if (action === 'on' || action === 'off') {
+        mutation = action === 'on' ? enableCodexContext1m(before) : disableCodexContext1m(before);
+        blockers.push(...mutation.blockers);
+        warnings.push(...mutation.warnings);
+        if (!blockers.length && mutation.changed) {
+            write = await safeWriteCodexConfigToml(configPath, before, mutation.next, 'codex-context-1m', {
+                verifyUnchangedBeforeWrite: true,
+                expectedBeforeExists: fileExists
+            });
+            if (!write.ok) {
+                blockers.push(`codex_config_write_${write.status}`);
+            }
+            else {
+                changed = write.changed;
+                afterText = write.expected_after?.text ?? mutation.next;
+            }
+        }
+    }
+    const inspection = inspectCodexContext1m(afterText);
+    warnings.push(...inspection.warnings);
+    if (action === 'on' || inspection.enabled) {
+        if (!inspection.model)
+            warnings.push('codex_context_model_line_missing');
+        else if (inspection.model !== CODEX_CONTEXT_1M_MODEL)
+            warnings.push(`codex_context_active_model_not_${CODEX_CONTEXT_1M_MODEL}:${inspection.model}`);
+    }
+    let restart = null;
+    if ((action === 'on' || action === 'off') && !blockers.length) {
+        restart = await maybeRestartCodexApp({
+            env,
+            changed,
+            noRestart,
+            ...(opts.root === undefined ? {} : { root: opts.root }),
+            ...(opts.isRunningImpl === undefined ? {} : { isRunningImpl: opts.isRunningImpl }),
+            ...(opts.restartImpl === undefined ? {} : { restartImpl: opts.restartImpl })
+        });
+        if (restart.attempted && !restart.ok)
+            warnings.push('codex_restart_failed_manual_restart_required');
+    }
+    return {
+        schema: CODEX_CONTEXT_1M_SCHEMA,
+        ok: blockers.length === 0,
+        action,
+        enabled: inspection.enabled,
+        config_path: configPath,
+        model: inspection.model,
+        expected_model: CODEX_CONTEXT_1M_MODEL,
+        target: { ...CODEX_CONTEXT_1M_TARGETS },
+        keys: inspection.keys,
+        previous: mutation && action === 'on' ? mutation.previous : null,
+        restored: mutation && action === 'off' ? mutation.restored : null,
+        changed,
+        write: write ? { status: write.status, backup_path: write.backup_path } : null,
+        restart,
+        blockers,
+        warnings,
+        notes: [
+            'Only new Codex sessions pick up context-window changes; existing conversations keep their previous limits.',
+            'Requests with more than 272K input tokens are billed at the long-context rate (2x input / 1.5x output) for the entire request.'
+        ],
+        cli_commands: {
+            status: 'sks codex-app context-1m status',
+            on: 'sks codex-app context-1m on',
+            off: 'sks codex-app context-1m off'
+        }
+    };
+}
+async function maybeRestartCodexApp(input) {
+    const skippedOutcome = (reason) => ({ attempted: false, running: null, status: 'skipped', reason, ok: true, blockers: [] });
+    if (input.noRestart)
+        return skippedOutcome('no_restart_flag');
+    if (!input.changed)
+        return skippedOutcome('config_unchanged');
+    if (input.env.SKS_SKIP_CODEX_APP_RESTART === '1')
+        return skippedOutcome('SKS_SKIP_CODEX_APP_RESTART');
+    if (process.platform !== 'darwin')
+        return skippedOutcome('not_macos');
+    const bundleId = String(input.env.SKS_CODEX_APP_BUNDLE_ID || 'com.openai.codex');
+    const running = await (input.isRunningImpl || isCodexAppRunningByBundleId)(bundleId, input.env);
+    if (!running) {
+        return { attempted: false, running: false, status: 'skipped', reason: 'codex_not_running', ok: true, blockers: [] };
+    }
+    const result = await (input.restartImpl || restartCodexApp)({ env: input.env, ...(input.root ? { root: input.root } : {}) });
+    return { attempted: true, running: true, status: result.status, reason: null, ok: result.ok, blockers: result.blockers };
+}

package/dist/core/codex-lb/desktop-bridge/http-forward.js

@@ -274,7 +274,13 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                 const statusCode = response.statusCode || 502;
                 if (statusCode >= 400) {
                     void readRedactedUpstreamError(response).then(({ body, upstreamCode, upstreamType }) => {
-                        const transientMislabel = statusCode === 404 && upstreamType === 'upstream_error' && !upstreamCode;
+                        const transientMislabel = statusCode === 404
+                            && (upstreamType === 'upstream_error' || upstreamCode === 'upstream_error');
+                        if (transientMislabel && replayable && !useFreshConnection) {
+                            responseStarted = true;
+                            finish(new StalePooledSocketFailure(new DesktopBridgeError('bridge_upstream_transient_mislabel')));
+                            return;
+                        }
                         const clientStatus = transientMislabel ? 503 : statusCode;
                         logHttpRejection({
                             code: transientMislabel

package/dist/core/commands/basic-cli.js

@@ -255,6 +255,11 @@ export async function updateCommand(sub = 'now', args = []) {
         console.log(`New version: ${result.new_version}`);
     if (result.project_receipt)
         console.log(`Migration receipt: ${result.project_receipt.root} (${result.migration_current ? 'current' : 'not current'})`);
+    for (const warning of (result.project_receipt?.optional_warnings || [])
+        .filter((entry) => String(entry).includes('sks doctor --fix'))
+        .slice(0, 3)) {
+        console.log(`Follow-up: ${warning}`);
+    }
     if (result.sks_menubar)
         console.log(`SKS menu bar: ${result.sks_menubar.status}${result.sks_menubar.app_path ? ` (${result.sks_menubar.app_path})` : ''}`);
     if (result.operation_receipt_path)

package/dist/core/doctor/desktop-bridge-catalog-repair.js

@@ -0,0 +1,102 @@
+import os from 'node:os';
+import path from 'node:path';
+import { desktopBridgeStatusV3, executeDesktopBridgeCommandV3 } from '../codex-lb/desktop-controller-v3.js';
+import { bootstrapExistingDesktopBridgeService, desktopBridgeServiceStatus } from '../codex-lb/desktop-service.js';
+import { desktopBridgeRuntimeVersion, desktopBridgeRuntimeVersionStale } from '../codex-lb/desktop-bridge/state.js';
+import { PACKAGE_VERSION } from '../version.js';
+export async function restartStaleDesktopBridgeRuntime(input) {
+    if (process.env.SKS_TEST_ISOLATION === '1' || process.env.SKS_RELEASE_UPGRADE_SMOKE === '1') {
+        return { restarted: false, warnings: [], blockers: [] };
+    }
+    const service = await desktopBridgeServiceStatus({ home: input.home }).catch(() => null);
+    if (!service?.running || !desktopBridgeRuntimeVersionStale(service.state)) {
+        return { restarted: false, warnings: [], blockers: [] };
+    }
+    const running = desktopBridgeRuntimeVersion(service.state) || 'pre-8.6.2';
+    if (!input.fix) {
+        return {
+            restarted: false,
+            warnings: [],
+            blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`]
+        };
+    }
+    const restarted = await bootstrapExistingDesktopBridgeService({ home: input.home }).catch(() => null);
+    const nowRunning = restarted?.running === true && !desktopBridgeRuntimeVersionStale(restarted.state);
+    return nowRunning
+        ? { restarted: true, warnings: [`desktop_bridge_runtime_restarted:${running}:${PACKAGE_VERSION}`], blockers: [] }
+        : { restarted: false, warnings: [], blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`] };
+}
+export const CATALOG_REPAIR_MAX_ATTEMPTS = 2;
+export async function repairDoctorDesktopBridgeCatalog(input, deps = {}) {
+    const base = {
+        id: 'desktop_bridge_catalog_repair',
+        required_for_ready: false,
+        manual_required: false,
+        warnings: [],
+        rollback_evidence: 'combined_catalog_previous_generation_preserved'
+    };
+    const usingRealImpls = !deps.restartStaleDesktopBridgeRuntimeImpl
+        && !deps.desktopBridgeStatusImpl
+        && !deps.executeDesktopBridgeCommandImpl;
+    if (usingRealImpls
+        && (process.env.NODE_TEST_CONTEXT !== undefined
+            || process.env.SKS_TEST_ISOLATION === '1'
+            || process.env.SKS_RELEASE_UPGRADE_SMOKE === '1')) {
+        return {
+            ...base,
+            ok: true,
+            repaired: false,
+            blockers: [],
+            skipped_reason: 'desktop_bridge_catalog_repair_skipped_under_tests'
+        };
+    }
+    const restartImpl = deps.restartStaleDesktopBridgeRuntimeImpl || restartStaleDesktopBridgeRuntime;
+    const statusImpl = deps.desktopBridgeStatusImpl || desktopBridgeStatusV3;
+    const executeImpl = deps.executeDesktopBridgeCommandImpl || executeDesktopBridgeCommandV3;
+    try {
+        const bridgeHome = path.resolve(process.env.HOME || os.homedir());
+        const restarted = await restartImpl({
+            home: bridgeHome,
+            fix: input.fix
+        });
+        const status = await statusImpl({ home: bridgeHome, env: process.env });
+        const blockers = (status?.readiness?.blockers || []).map(String);
+        const stale = blockers.filter((blocker) => blocker.endsWith('_catalog_stale'));
+        if (!status?.management?.managed || stale.length === 0) {
+            return {
+                ...base,
+                ok: restarted.blockers.length === 0,
+                repaired: restarted.restarted,
+                warnings: restarted.warnings,
+                blockers: restarted.blockers
+            };
+        }
+        const attempts = [];
+        let syncedAndVerified = false;
+        for (let attempt = 1; attempt <= CATALOG_REPAIR_MAX_ATTEMPTS; attempt += 1) {
+            const sync = await executeImpl({ operation: 'catalog.sync' }, { home: bridgeHome, env: process.env });
+            const commandOk = sync?.ok === true && sync?.execution?.ok === true;
+            const after = await statusImpl({ home: bridgeHome, env: process.env });
+            const stillStale = (after?.readiness?.blockers || [])
+                .map(String).filter((blocker) => blocker.endsWith('_catalog_stale'));
+            if (commandOk && stillStale.length === 0) {
+                syncedAndVerified = true;
+                break;
+            }
+            attempts.push(`catalog_sync_attempt_${attempt}:${commandOk ? `still_stale:${stillStale.join(',')}` : (sync?.execution?.blockers || ['failed']).map(String).join(',')}`);
+        }
+        return {
+            ...base,
+            ok: syncedAndVerified && restarted.blockers.length === 0,
+            repaired: syncedAndVerified || restarted.restarted,
+            warnings: [...restarted.warnings, ...(syncedAndVerified ? attempts : [])],
+            blockers: [
+                ...(syncedAndVerified ? [] : ['desktop_bridge_catalog_still_stale_after_repair', ...attempts]),
+                ...restarted.blockers
+            ]
+        };
+    }
+    catch (error) {
+        return { ...base, ok: false, repaired: false, blockers: [String(error?.message || 'desktop_bridge_catalog_sync_failed')] };
+    }
+}

package/dist/core/routes.js

@@ -644,7 +644,7 @@ export const COMMAND_CATALOG = [
     { name: 'uninstall', usage: 'sks uninstall [--dry-run] [--yes] [--keep-config] [--keep-data] [--purge-projects] [--json]', description: 'Remove SKS global skills, hooks, menu bar, state, temp files, and optional project residue while preserving user-owned content by default.' },
     { name: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm and Codex CLI readiness; pass --yes to repair missing Codex CLI tooling when supported.' },
     { name: 'codex', usage: 'sks codex compatibility|version|update-status [--refresh]|update|doctor|schema|current [--json]', description: 'Check Codex CLI compatibility/version/update status, run the official `codex update`, and inspect current manifest, capability, and hook-schema evidence.' },
-    { name: 'codex-app', usage: 'sks codex-app [check|status|restart|product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App integration, Desktop Bridge readiness, Product Design plugin readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI remote-control availability. Provider routing is managed only by sks bridge.' },
+    { name: 'codex-app', usage: 'sks codex-app [check|status|restart|context-1m [status|on|off]|product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App integration, Desktop Bridge readiness, Product Design plugin readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, Codex CLI remote-control availability, and the opt-in GPT-5.6 Sol 1M context window toggle with automatic Codex restart. Provider routing is managed only by sks bridge.' },
     { name: 'codex-native', usage: 'sks codex-native status|feature-broker|invocation-plan|init-deep [--json]', description: 'Inspect Codex Native feature broker readiness, invocation routing, pattern evidence, and managed memory setup.' },
     { name: 'hooks', usage: 'sks hooks explain|status|trust-report|replay|codex-validate|warning-check ... [--json]', description: 'Explain Codex hook events, validate current vendored event output schemas, replay fixtures, and enforce warning-zero SKS hook policies.' },
     { name: 'remote', usage: 'sks remote readiness|machines|worker ... [--json]', description: 'Inspect official Codex Remote readiness and the allowlisted proof-aware SSH stdio worker surface.' },

package/dist/core/update/update-migration-state/current-public-surface-stage.js

@@ -0,0 +1,67 @@
+import os from 'node:os';
+import path from 'node:path';
+export async function runCurrentPublicSurfaceReconcileStage(root) {
+    const [{ runDoctorCommandAliasCleanup }, { migrateSksProfilesToPerFile }, { cleanupRetiredRemoteBridgeLaunchAgent, quarantineRetiredRemoteBridgeBindings }] = await Promise.all([
+        import('../../doctor/command-alias-cleanup.js'),
+        import('../../auto-review.js'),
+        import('../../codex-app/menubar/migration.js')
+    ]);
+    const home = path.resolve(process.env.HOME || os.homedir());
+    const globalRuntimeRoot = path.resolve(process.env.SKS_GLOBAL_ROOT || path.join(home, '.sneakoscope-global'));
+    const publicSurface = await runDoctorCommandAliasCleanup({
+        root,
+        home,
+        globalRuntimeRoot,
+        fix: true,
+        managedGenerationAlreadyConverged: true
+    });
+    const profileMigration = await migrateSksProfilesToPerFile({ env: process.env }).catch((err) => ({
+        error: err?.message || String(err),
+        retired_profile_table_count: 0,
+        retired_profile_file_removed_count: 0
+    }));
+    const retiredLaunchAgent = await cleanupRetiredRemoteBridgeLaunchAgent({ home, env: process.env });
+    const retiredBindings = await quarantineRetiredRemoteBridgeBindings(root);
+    const remainingCount = Number(publicSurface.cleanup?.remaining_count || 0)
+        + Number(publicSurface.cleanup?.managed_runtime?.remaining_managed_artifact_count || 0)
+        + Number(publicSurface.cleanup?.project_guidance?.remaining_count || 0);
+    const blockers = [
+        ...(publicSurface.ok === true ? [] : ['public_surface_reconcile_failed']),
+        ...(retiredLaunchAgent.ok ? [] : retiredLaunchAgent.blockers),
+        ...(retiredBindings.ok ? [] : retiredBindings.blockers),
+        ...(profileMigration.error ? [`retired_profile_migration_failed:${profileMigration.error}`] : []),
+        ...(remainingCount > 0 ? [`public_surface_remaining:${remainingCount}`] : [])
+    ];
+    return {
+        ok: blockers.length === 0,
+        status: blockers.length ? 'failed' : 'ok',
+        actions: [
+            'reconciled_current_public_surface',
+            ...(retiredLaunchAgent.status === 'removed' ? ['retired_remote_bridge_launch_agent_removed'] : []),
+            ...(retiredBindings.status === 'quarantined' ? ['retired_remote_bridge_bindings_quarantined'] : [])
+        ],
+        blockers,
+        warnings: [
+            ...(publicSurface.warnings || []),
+            ...retiredLaunchAgent.warnings,
+            ...retiredBindings.warnings
+        ],
+        detail: {
+            removed_skill_count: Number(publicSurface.cleanup?.removed_count || 0),
+            quarantined_skill_collision_count: Number(publicSurface.cleanup?.preserved_user_collision_count || 0),
+            removed_runtime_artifact_count: Number(publicSurface.cleanup?.managed_runtime?.removed_managed_artifact_count || 0),
+            quarantined_runtime_collision_count: Number(publicSurface.cleanup?.managed_runtime?.preserved_user_file_count || 0),
+            reconciled_guidance_count: Number(publicSurface.cleanup?.project_guidance?.reconciled_count || 0),
+            quarantined_guidance_collision_count: Number(publicSurface.cleanup?.project_guidance?.preserved_user_file_count || 0),
+            removed_retired_role_count: 0,
+            quarantined_retired_role_collision_count: 0,
+            retired_profile_table_count: Number(profileMigration.retired_profile_table_count || 0),
+            retired_profile_file_removed_count: Number(profileMigration.retired_profile_file_removed_count || 0),
+            retired_remote_bridge_launch_agent_status: retiredLaunchAgent.status,
+            retired_remote_bridge_binding_status: retiredBindings.status,
+            retired_remote_bridge_binding_count: retiredBindings.retired_binding_count,
+            retired_remote_bridge_binding_quarantine_path: retiredBindings.quarantine_path,
+            remaining_count: remainingCount
+        }
+    };
+}

package/dist/core/update/update-migration-state/desktop-bridge-catalog-repair-stage.js

@@ -0,0 +1,45 @@
+import os from 'node:os';
+import path from 'node:path';
+import { exists } from '../../fsx.js';
+import { desktopBridgeServicePaths } from '../../codex-lb/desktop-service.js';
+import { repairDoctorDesktopBridgeCatalog } from '../../doctor/desktop-bridge-catalog-repair.js';
+export async function runDesktopBridgeCatalogRepairStage() {
+    const skip = (reason) => ({ ok: true, status: 'ok', actions: [reason], blockers: [], warnings: [] });
+    if (process.platform !== 'darwin')
+        return skip('desktop_bridge_catalog_repair_not_macos');
+    if (process.env.NODE_TEST_CONTEXT !== undefined)
+        return skip('desktop_bridge_catalog_repair_skipped_under_tests');
+    if (process.env.SKS_TEST_ISOLATION === '1')
+        return skip('desktop_bridge_catalog_repair_skipped_under_tests');
+    if (process.env.SKS_SKIP_BRIDGE_CATALOG_REPAIR === '1')
+        return skip('desktop_bridge_catalog_repair_disabled');
+    const home = path.resolve(process.env.HOME || os.homedir());
+    if (!(await exists(desktopBridgeServicePaths(home).settings_path))) {
+        return skip('desktop_bridge_catalog_repair_no_managed_bridge');
+    }
+    const repair = await repairDoctorDesktopBridgeCatalog({ fix: true }).catch((error) => ({
+        ok: false,
+        repaired: false,
+        warnings: [],
+        blockers: [`desktop_bridge_catalog_repair_failed:${error?.message || String(error)}`]
+    }));
+    if (repair.ok) {
+        return {
+            ok: true,
+            status: 'ok',
+            actions: [repair.repaired ? 'desktop_bridge_catalog_repaired' : 'desktop_bridge_catalog_clean'],
+            blockers: [],
+            warnings: repair.warnings || []
+        };
+    }
+    return {
+        ok: true,
+        status: 'ok',
+        actions: [],
+        blockers: [],
+        warnings: [
+            ...(repair.blockers || []).map((blocker) => `desktop_bridge_catalog_repair_incomplete:${blocker}`),
+            'Desktop Bridge catalog still needs repair: run `sks doctor --fix`'
+        ]
+    };
+}

package/dist/core/update/update-migration-state.js

@@ -10,6 +10,8 @@ import { enforceRetention } from '../retention.js';
 import { COMMANDS } from '../../cli/command-registry.js';
 import { reconcileLegacyManagedGeneration } from '../init/legacy-generation-convergence.js';
 import { runConfigFastModeNormalizeStage } from './update-migration-state/fast-mode-config.js';
+import { runCurrentPublicSurfaceReconcileStage } from './update-migration-state/current-public-surface-stage.js';
+import { runDesktopBridgeCatalogRepairStage } from './update-migration-state/desktop-bridge-catalog-repair-stage.js';
 import { runDesktopBridgeRestageStage } from './update-migration-state/desktop-bridge-restage.js';
 import { runSessionStateSplitStage } from './update-migration-state/session-state-split.js';
 import { runHookTrustRefreshStage, runOtherHarnessCleanupStage } from './update-migration-state/simple-stages.js';
@@ -264,73 +266,13 @@ const UPDATE_MIGRATION_STAGES = [
         id: 'desktop-bridge-restage',
         min_from_version: '0.0.0',
         run: runDesktopBridgeRestageStage
+    },
+    {
+        id: 'desktop-bridge-catalog-repair',
+        min_from_version: '0.0.0',
+        run: runDesktopBridgeCatalogRepairStage
     }
 ];
-async function runCurrentPublicSurfaceReconcileStage(root) {
-    const [{ runDoctorCommandAliasCleanup }, { migrateSksProfilesToPerFile }, { cleanupRetiredRemoteBridgeLaunchAgent, quarantineRetiredRemoteBridgeBindings }] = await Promise.all([
-        import('../doctor/command-alias-cleanup.js'),
-        import('../auto-review.js'),
-        import('../codex-app/menubar/migration.js')
-    ]);
-    const home = path.resolve(process.env.HOME || os.homedir());
-    const globalRuntimeRoot = path.resolve(process.env.SKS_GLOBAL_ROOT || path.join(home, '.sneakoscope-global'));
-    const publicSurface = await runDoctorCommandAliasCleanup({
-        root,
-        home,
-        globalRuntimeRoot,
-        fix: true,
-        managedGenerationAlreadyConverged: true
-    });
-    const profileMigration = await migrateSksProfilesToPerFile({ env: process.env }).catch((err) => ({
-        error: err?.message || String(err),
-        retired_profile_table_count: 0,
-        retired_profile_file_removed_count: 0
-    }));
-    const retiredLaunchAgent = await cleanupRetiredRemoteBridgeLaunchAgent({ home, env: process.env });
-    const retiredBindings = await quarantineRetiredRemoteBridgeBindings(root);
-    const remainingCount = Number(publicSurface.cleanup?.remaining_count || 0)
-        + Number(publicSurface.cleanup?.managed_runtime?.remaining_managed_artifact_count || 0)
-        + Number(publicSurface.cleanup?.project_guidance?.remaining_count || 0);
-    const blockers = [
-        ...(publicSurface.ok === true ? [] : ['public_surface_reconcile_failed']),
-        ...(retiredLaunchAgent.ok ? [] : retiredLaunchAgent.blockers),
-        ...(retiredBindings.ok ? [] : retiredBindings.blockers),
-        ...(profileMigration.error ? [`retired_profile_migration_failed:${profileMigration.error}`] : []),
-        ...(remainingCount > 0 ? [`public_surface_remaining:${remainingCount}`] : [])
-    ];
-    return {
-        ok: blockers.length === 0,
-        status: blockers.length ? 'failed' : 'ok',
-        actions: [
-            'reconciled_current_public_surface',
-            ...(retiredLaunchAgent.status === 'removed' ? ['retired_remote_bridge_launch_agent_removed'] : []),
-            ...(retiredBindings.status === 'quarantined' ? ['retired_remote_bridge_bindings_quarantined'] : [])
-        ],
-        blockers,
-        warnings: [
-            ...(publicSurface.warnings || []),
-            ...retiredLaunchAgent.warnings,
-            ...retiredBindings.warnings
-        ],
-        detail: {
-            removed_skill_count: Number(publicSurface.cleanup?.removed_count || 0),
-            quarantined_skill_collision_count: Number(publicSurface.cleanup?.preserved_user_collision_count || 0),
-            removed_runtime_artifact_count: Number(publicSurface.cleanup?.managed_runtime?.removed_managed_artifact_count || 0),
-            quarantined_runtime_collision_count: Number(publicSurface.cleanup?.managed_runtime?.preserved_user_file_count || 0),
-            reconciled_guidance_count: Number(publicSurface.cleanup?.project_guidance?.reconciled_count || 0),
-            quarantined_guidance_collision_count: Number(publicSurface.cleanup?.project_guidance?.preserved_user_file_count || 0),
-            removed_retired_role_count: 0,
-            quarantined_retired_role_collision_count: 0,
-            retired_profile_table_count: Number(profileMigration.retired_profile_table_count || 0),
-            retired_profile_file_removed_count: Number(profileMigration.retired_profile_file_removed_count || 0),
-            retired_remote_bridge_launch_agent_status: retiredLaunchAgent.status,
-            retired_remote_bridge_binding_status: retiredBindings.status,
-            retired_remote_bridge_binding_count: retiredBindings.retired_binding_count,
-            retired_remote_bridge_binding_quarantine_path: retiredBindings.quarantine_path,
-            remaining_count: remainingCount
-        }
-    };
-}
 export async function runUpdateMigrationStages(root, opts = {}) {
     const fromVersion = opts.fromVersion || null;
     const runs = [];

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '9.0.5';
+export const PACKAGE_VERSION = '9.1.0';

package/dist/native/sks-menubar/Sources/ControlCenterWindowController.swift

@@ -30,7 +30,7 @@ final class ControlCenterWindowController: NSWindowController, NSTableViewDataSo
             .providers: ProvidersViewController(processClient: processClient, operations: operations),
             .remoteCoding: RemoteCodingViewController(),
             .diagnostics: DiagnosticsViewController(processClient: processClient, operations: operations),
-            .settings: SettingsViewController(notifications: notifications)
+            .settings: SettingsViewController(processClient: processClient, operations: operations, notifications: notifications)
         ]
         let window = NSWindow(
             contentRect: NSRect(x: 0, y: 0, width: 860, height: 560),

package/dist/native/sks-menubar/Sources/SettingsViewController.swift

@@ -8,22 +8,41 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
         case malformed
     }
 
+    private let processClient: ProcessClient
+    private let operations: OperationCoordinator
     private let notifications: NotificationCoordinator
     private let followCodexLifecycle = NSButton(checkboxWithTitle: "Show SKS Menu only while Codex is running", target: nil, action: nil)
     private let status = NativeView.detail("Settings use the native app configuration file.")
+    private let contextStatus = NativeView.detail("Codex 1M context: checking current state…")
     private var notificationButton: NSButton!
-    init(notifications: NotificationCoordinator) { self.notifications = notifications; super.init(nibName: nil, bundle: nil) }
+    private var contextToggleButton: NSButton!
+    private var contextEnabled: Bool?
+    private var contextBusy = false
+    private var contextGeneration = 0
+    init(processClient: ProcessClient, operations: OperationCoordinator, notifications: NotificationCoordinator) {
+        self.processClient = processClient
+        self.operations = operations
+        self.notifications = notifications
+        super.init(nibName: nil, bundle: nil)
+    }
     required init?(coder: NSCoder) { nil }
 
     override func loadView() {
         followCodexLifecycle.target = self; followCodexLifecycle.action = #selector(save)
         followCodexLifecycle.setAccessibilityLabel("Show SKS Menu only while Codex is running")
         notificationButton = NativeView.button("Enable Notifications", target: self, action: #selector(enableNotifications))
+        contextToggleButton = NativeView.button("Enable 1M Context", target: self, action: #selector(toggleContext1m))
+        contextToggleButton.isEnabled = false
         let lifecycleCard = NativeView.card(
             title: "Codex lifecycle",
             subtitle: "On keeps a lightweight observer running, hides the icon when Codex is closed, and shows it automatically when Codex opens.",
             views: [followCodexLifecycle]
         )
+        let contextCard = NativeView.card(
+            title: "Codex 1M Context",
+            subtitle: "Opt Codex into the documented 1,000,000-token context window for GPT-5.6 Sol (model_context_window = 1000000, model_auto_compact_token_limit = 900000 in ~/.codex/config.toml). Requests beyond 272K input tokens bill the entire request at the long-context rate, only new sessions pick up the change, and Codex restarts automatically when it is running. Off restores the previous value.",
+            views: [NativeView.row([contextToggleButton]), contextStatus]
+        )
         let notificationsCard = NativeView.card(
             title: "Notifications",
             subtitle: "Operation results always stay available in Control Center, even when notifications are denied.",
@@ -31,11 +50,12 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
         )
         view = NativeView.page([
             ControlKit.header("Settings", "These options stay on this Mac. Notification permission and Codex lifecycle behavior never leave the machine."),
-            lifecycleCard, notificationsCard
+            lifecycleCard, contextCard, notificationsCard
         ])
     }
 
     func refreshOnAppear() {
+        refreshContext1m()
         let configResult = readConfig()
         switch configResult {
         case .loaded(let config):
@@ -67,6 +87,101 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
         }
     }
 
+    private func refreshContext1m(preserveStatusText: Bool = false) {
+        contextGeneration += 1
+        let requestGeneration = contextGeneration
+        processClient.run(["codex-app", "context-1m", "status", "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
+            guard let self = self, self.contextGeneration == requestGeneration, !self.contextBusy else { return }
+            guard let json = self.json(result.output),
+                  json["schema"] as? String == "sks.codex-context-1m.v1",
+                  json["ok"] as? Bool == true,
+                  let enabled = json["enabled"] as? Bool else {
+                self.contextEnabled = nil
+                self.contextToggleButton.isEnabled = false
+                if !preserveStatusText {
+                    self.contextStatus.stringValue = "Codex 1M context state unavailable · update SKS, then reopen Settings."
+                    self.contextStatus.textColor = .systemOrange
+                }
+                return
+            }
+            self.contextEnabled = enabled
+            self.contextToggleButton.isEnabled = true
+            self.contextToggleButton.title = enabled ? "Disable 1M Context" : "Enable 1M Context"
+            guard !preserveStatusText else { return }
+            let model = json["model"] as? String
+            var text = enabled
+                ? "Enabled · window 1,000,000 · auto-compact 900,000 · applies to new sessions only."
+                : "Disabled · Codex uses its tuned default context window."
+            var tone: NSColor = enabled ? .systemGreen : .secondaryLabelColor
+            if enabled, let model = model, model != "gpt-5.6-sol" {
+                text += " Active model is \(model); the 1M window is documented for gpt-5.6-sol."
+                tone = .systemOrange
+            }
+            self.contextStatus.stringValue = text
+            self.contextStatus.textColor = tone
+        }
+    }
+
+    @objc private func toggleContext1m() {
+        guard !contextBusy, let enabled = contextEnabled else { return }
+        let verb = enabled ? "off" : "on"
+        guard let snapshot = operations.begin(
+            kind: "codex-context-1m",
+            mutationGroup: "codex-config",
+            summary: enabled ? "Disable Codex 1M context" : "Enable Codex 1M context"
+        ) else {
+            contextStatus.stringValue = "Another guarded mutation is running. Try again after it completes."
+            contextStatus.textColor = .systemOrange
+            return
+        }
+        contextBusy = true
+        contextToggleButton.isEnabled = false
+        contextStatus.stringValue = enabled ? "Disabling 1M context…" : "Enabling 1M context and restarting Codex if it is running…"
+        contextStatus.textColor = .secondaryLabelColor
+        _ = operations.update(snapshot, state: .running, stage: "applying", progress: nil, summary: contextStatus.stringValue)
+        processClient.run(["codex-app", "context-1m", verb, "--json"], timeout: NativeView.mutationTimeout) { [weak self] result in
+            guard let self = self else { return }
+            self.contextBusy = false
+            self.contextToggleButton.isEnabled = true
+            let json = self.json(result.output)
+            let ok = result.code == 0
+                && json?["schema"] as? String == "sks.codex-context-1m.v1"
+                && json?["ok"] as? Bool == true
+            let summary: String
+            if ok {
+                let restart = json?["restart"] as? [String: Any]
+                let applied = verb == "on" ? "1M context enabled" : "1M context disabled"
+                if restart?["status"] as? String == "restarted" {
+                    summary = "\(applied) · Codex restarted — start a new session to apply it."
+                } else if restart?["reason"] as? String == "codex_not_running" {
+                    summary = "\(applied) · Codex is not running — the change applies on its next launch."
+                } else if restart?["reason"] as? String == "config_unchanged" {
+                    summary = "\(applied) · configuration already matched; nothing restarted."
+                } else {
+                    summary = "\(applied) · restart Codex manually, then start a new session."
+                }
+            } else {
+                let blocker = (json?["blockers"] as? [String])?.first
+                summary = blocker.map { "1M context change failed · \($0)" } ?? "1M context change failed · unexpected CLI response."
+            }
+            _ = self.operations.update(snapshot, state: ok ? .succeeded : .failed, stage: "complete", progress: 1, summary: summary)
+            self.contextStatus.stringValue = summary
+            self.contextStatus.textColor = ok ? .systemGreen : .systemRed
+            self.refreshContext1m(preserveStatusText: true)
+        }
+    }
+
+    private func json(_ text: String) -> [String: Any]? {
+        guard let data = text.data(using: .utf8) else { return nil }
+        if let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] { return object }
+        // Child processes may print banner lines before JSON; prefer the last
+        // top-level object payload, matching the Overview parser.
+        guard let start = text.range(of: "{", options: [.backwards])?.lowerBound else { return nil }
+        let slice = String(text[start...])
+        guard let sliced = slice.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: sliced) as? [String: Any]
+    }
+
     @objc private func enableNotifications() {
         if notifications.authorizationDenied {
             guard openSystemSettings() else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "9.0.5",
+  "version": "9.1.0",
   "description": "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.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",