sneakoscope 8.3.0 → 8.3.2

package/README.md

@@ -22,13 +22,13 @@ 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 8.3.0** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
+This README documents package **SKS 8.3.2** — 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).
 
-## What 8.2.0 Ships
+## What 8.3.1 Ships
 
-| Problem | 8.2.0 behavior |
+| Problem | 8.3.1 behavior |
 | --- | --- |
 | Overview mixed Menu Bar, installed SKS, and cached registry versions | Each value is labeled by authority, stale or unavailable probes remain explicit, and Refresh forces a bounded update-status refresh. |
 | Naruto stopped creating children after its first wave | The root parent records settled waves, recovers open-thread capacity, rescans the ready DAG, and can launch later direct-child waves under the same workflow run. |
@@ -39,6 +39,8 @@ Use the official latest stable SKS and Codex CLI releases. The Codex compatibili
 | Codex routing was split across legacy provider paths | One local Desktop Bridge is the managed routing runtime; Codex-LB and OpenRouter are simultaneous credential profiles. |
 | Requests could be coupled to a provider mode or weak model heuristic | The combined catalog's explicit route index resolves provider/model pairs with `fallback: none`; missing or ambiguous routes block. |
 | Transport verification was confused with deep evidence | Capability v3 records scope, stage, requested level, execution, and readiness separately; unattempted deep work is not a transport failure. |
+| The Menu Bar could terminate with Codex and miss the next Codex launch | A launchd-resident observer remains alive, follows Codex visibility without terminating, and migrates the legacy quit preference. |
+| A partial Provider repair could look successful because the CLI exited zero | The Center validates the structured command status, records partial repair as needing action, and shows capability issues before verified diagnostic rows. |
 
 ## Install In One Command
 

package/config/skills-hash-ledger.v1.json

@@ -65,6 +65,7 @@
     {
       "canonical_name": "sks-computer-use-fast",
       "trusted_sha256": [
+        "57e4c1d04ae785b0a53711e53210f2ddabd6131041b97edb4b6d99f18b24155e",
         "b270d82e4057934d7f92ed4241d4ae86e22d0a9a08bceba1aa179d7535bda042",
         "b8736b2621398dfc85f7a2ff35d7a2fc728db0dfc0e964de69aebff93b5ed897"
       ]
@@ -79,6 +80,7 @@
     {
       "canonical_name": "sks-cu",
       "trusted_sha256": [
+        "be9a3eb7197483693f354e5f7e5a8eb2c0dc0209597cea53479e2e803ad39479",
         "fc6ed807d0299dd56441738d9388787b1dd857dab9bb4c31a11f7d9b90b424d0",
         "da480ba03208d4888df1e97bbec6d80d608dafad0e33c2b1c72266e1860476a8"
       ]
@@ -148,6 +150,7 @@
     {
       "canonical_name": "sks-from-chat-img",
       "trusted_sha256": [
+        "1cf6b9494829216c27c0778cecd825698c37a6a6dbde67a2a79dd957a32c24cc",
         "be2f0ec42839c0c8ec09c4bfbb99e3c57d6ffe1b8253c2ebbf894200cf8dbf40",
         "583c41f46a7355d8c0c87472ea83573695d04341822eb9adcea822ed3311809f"
       ]

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "8.3.0",
+  "package_version": "8.3.2",
   "skills": [
     {
       "canonical_name": "sks",
@@ -82,8 +82,9 @@
     {
       "canonical_name": "sks-computer-use-fast",
       "type": "official",
-      "content_sha256": "b270d82e4057934d7f92ed4241d4ae86e22d0a9a08bceba1aa179d7535bda042",
+      "content_sha256": "57e4c1d04ae785b0a53711e53210f2ddabd6131041b97edb4b6d99f18b24155e",
       "hash_history": [
+        "b270d82e4057934d7f92ed4241d4ae86e22d0a9a08bceba1aa179d7535bda042",
         "b8736b2621398dfc85f7a2ff35d7a2fc728db0dfc0e964de69aebff93b5ed897"
       ],
       "deprecated_aliases": []
@@ -100,8 +101,9 @@
     {
       "canonical_name": "sks-cu",
       "type": "official",
-      "content_sha256": "fc6ed807d0299dd56441738d9388787b1dd857dab9bb4c31a11f7d9b90b424d0",
+      "content_sha256": "be9a3eb7197483693f354e5f7e5a8eb2c0dc0209597cea53479e2e803ad39479",
       "hash_history": [
+        "fc6ed807d0299dd56441738d9388787b1dd857dab9bb4c31a11f7d9b90b424d0",
         "da480ba03208d4888df1e97bbec6d80d608dafad0e33c2b1c72266e1860476a8"
       ],
       "deprecated_aliases": []
@@ -188,8 +190,9 @@
     {
       "canonical_name": "sks-from-chat-img",
       "type": "official",
-      "content_sha256": "be2f0ec42839c0c8ec09c4bfbb99e3c57d6ffe1b8253c2ebbf894200cf8dbf40",
+      "content_sha256": "1cf6b9494829216c27c0778cecd825698c37a6a6dbde67a2a79dd957a32c24cc",
       "hash_history": [
+        "be2f0ec42839c0c8ec09c4bfbb99e3c57d6ffe1b8253c2ebbf894200cf8dbf40",
         "583c41f46a7355d8c0c87472ea83573695d04341822eb9adcea822ed3311809f"
       ],
       "deprecated_aliases": []

package/dist/core/codex-app/menubar/config.js

@@ -4,18 +4,18 @@ import { readJson, runProcess, which, writeJsonAtomic } from '../../fsx.js';
 export async function readMenuBarConfig(configPath) {
     const value = await readJson(configPath, null);
     return {
-        schema: 'sks.sks-menubar-config.v1',
+        schema: 'sks.sks-menubar-config.v2',
         codex_bundle_id: typeof value?.codex_bundle_id === 'string' && value.codex_bundle_id.trim()
             ? value.codex_bundle_id.trim() : null,
-        quit_with_codex: value?.quit_with_codex === true
+        follow_codex_lifecycle: value?.follow_codex_lifecycle === true || value?.quit_with_codex === true
     };
 }
 export async function writeDefaultMenuBarConfig(configPath, codexBundleId) {
     const previous = await readMenuBarConfig(configPath);
     const value = {
-        schema: 'sks.sks-menubar-config.v1',
+        schema: 'sks.sks-menubar-config.v2',
         codex_bundle_id: codexBundleId || previous.codex_bundle_id,
-        quit_with_codex: previous.quit_with_codex
+        follow_codex_lifecycle: previous.follow_codex_lifecycle
     };
     await writeJsonAtomic(configPath, value);
     return value;

package/dist/core/codex-app/menubar/constants.js

@@ -6,12 +6,13 @@ export const MENU_ITEMS = [
     'Pending approvals',
     'Check for Updates',
     'View Last Operation',
-    'Quit SKS Menu'
+    'Hide Until Codex Opens'
 ];
 export const NATIVE_SOURCE_FILES = [
     'main.swift',
     'AppDelegate.swift',
     'StatusItemController.swift',
+    'CodexLifecyclePolicy.swift',
     'ControlCenterWindowController.swift',
     'SidebarItem.swift',
     'ControlKit.swift',

package/dist/core/codex-app/menubar/global-install.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { exists, nowIso, readJson, readText, runProcess, writeJsonAtomic } from '../../fsx.js';
 import { ensureConfinedDirectory, inspectConfinedPath, removeManagedPathVerified } from '../../managed-path-safety.js';
+import { realUserHome } from './installer/runtime.js';
 const MENU_BAR_EXECUTABLE_SUFFIX = path.join('SKSMenuBar.app', 'Contents', 'MacOS', 'SKSMenuBar');
 const MENU_BAR_PROCESS_DISCOVERY_TIMEOUT_MS = 5_000;
 export function projectMenuBarDuplicateInstallDirs(input) {
@@ -21,6 +22,8 @@ export async function verifiedProjectMenuBarDuplicateExecutablePaths(input) {
     const executables = [];
     const candidates = await discoverProjectMenuBarDuplicateCandidates(input);
     for (const candidate of candidates.inspected) {
+        if (isOutsideScopeReapingRefused(candidate, root, home))
+            continue;
         const confinementRoot = confinementRootForCandidate(root, home, candidate);
         const state = await inspectConfinedPath(confinementRoot, candidate).catch(() => null);
         if (!state?.exists || state.leafSymlink || !state.stat?.isDirectory())
@@ -96,6 +99,11 @@ export async function cleanupProjectMenuBarDuplicates(input) {
     const blockers = [];
     const warnings = [];
     for (const candidate of inspected) {
+        if (isOutsideScopeReapingRefused(candidate, root, input.paths.home)) {
+            preserved.push(candidate);
+            warnings.push(`menubar_project_duplicate_outside_scope_preserved:${candidate}`);
+            continue;
+        }
         const confinementRoot = confinementRootForCandidate(root, input.paths.home, candidate);
         const state = await inspectConfinedPath(confinementRoot, candidate).catch(() => null);
         if (!state) {
@@ -254,6 +262,14 @@ function duplicateInstallDirForExecutable(executablePath, canonicalInstallDir) {
         return null;
     return executable.slice(0, -suffix.length);
 }
+function isOutsideScopeReapingRefused(candidateInput, rootInput, homeInput) {
+    const candidate = path.resolve(candidateInput);
+    const root = path.resolve(rootInput);
+    const home = path.resolve(homeInput);
+    if (isWithin(root, candidate) || isWithin(home, candidate))
+        return false;
+    return home !== realUserHome();
+}
 function confinementRootForCandidate(rootInput, homeInput, candidate) {
     const root = path.resolve(rootInput);
     const home = path.resolve(homeInput);

package/dist/core/codex-app/menubar/installer.js

@@ -6,7 +6,7 @@ import { aggregateFileHashes, createSksMenuBarBuildStamp, menuBarBuildStampsEqua
 import { SKS_MENUBAR_LABEL } from './constants.js';
 import { resolveCodexBundleId, writeDefaultMenuBarConfig } from './config.js';
 import { applyMenuBarGenerationTransaction, commitMenuBarGenerationTransaction, installGenerationPairs, MenuBarGenerationTransactionError, recoverMenuBarGenerationTransaction, rollbackGenerationPairs } from './generation-transaction.js';
-import { launchAgentSource, launchMenuBar, inspectRunningMenuBarProcess, seedMenuBarPreferredPosition, stopMenuBarForReplacement, terminateMenuBarProcesses } from './launch-agent.js';
+import { launchAgentSource, launchMenuBar, inspectRunningMenuBarProcess, menuBarLaunchdTouchAllowed, seedMenuBarPreferredPosition, stopMenuBarForReplacement, terminateMenuBarProcesses } from './launch-agent.js';
 import { cleanupProjectMenuBarDuplicates, verifiedProjectMenuBarDuplicateExecutablePaths } from './global-install.js';
 import { cleanupRetiredRemoteBridgeLaunchAgent, quarantineRetiredRemoteBridgeBindings } from './migration.js';
 import { sksMenuBarPaths } from './paths.js';
@@ -114,6 +114,11 @@ export async function installSksMenuBar(opts = {}) {
         return blocked('sks_entry_unresolved');
     if (targetCheck.project_local)
         warnings.push('sks_entry_project_local');
+    const macosProtectedRoots = ['Desktop', 'Documents', 'Downloads']
+        .map((dir) => `${path.join(paths.home, dir)}${path.sep}`);
+    if (targetCheck.resolved && macosProtectedRoots.some((root) => targetCheck.resolved.startsWith(root))) {
+        warnings.push('sks_entry_macos_protected_folder');
+    }
     const previousActionScript = await readText(paths.action_script_path, '');
     const previousLaunchAgent = await readText(paths.launch_agent_path, '');
     const previousRaw = await readJson(paths.build_stamp_path, null);
@@ -256,7 +261,15 @@ export async function installSksMenuBar(opts = {}) {
     });
     const mustStopCanonical = !upToDate || (launchWanted && launchAllowed);
     let canonicalStopped = false;
-    if (mustStopCanonical) {
+    if (mustStopCanonical && !menuBarLaunchdTouchAllowed(paths, env)) {
+        const stopped = await terminateMenuBarProcesses([paths.executable_path, ...duplicateExecutablePaths], env);
+        if (!stopped.ok) {
+            return blocked('menubar_stop_before_replace_failed', `Remaining PIDs: ${stopped.remaining_pids.join(',')}`);
+        }
+        warnings.push('launchd_stop_skipped_non_user_home');
+        actions.push('verified canonical/project duplicate processes stopped without touching the user launchd service');
+    }
+    else if (mustStopCanonical) {
         const stopped = await stopMenuBarForReplacement({
             launchctl,
             paths,

package/dist/core/codex-app/menubar/launch-agent.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { exists, readJson, runProcess, which, writeJsonAtomic } from '../../fsx.js';
 import { CONTROL_CENTER_DOMAIN, CONTROL_CENTER_PREFERRED_POSITION, SKS_MENUBAR_LABEL } from './constants.js';
+import { realUserHome } from './installer/runtime.js';
 export function launchAgentSource(executablePath, installDir) {
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -9,11 +10,15 @@ export function launchAgentSource(executablePath, installDir) {
 <key>Label</key><string>${SKS_MENUBAR_LABEL}</string>
 <key>ProgramArguments</key><array><string>${xml(executablePath)}</string></array>
 <key>RunAtLoad</key><true/>
+<key>KeepAlive</key><true/>
 <key>ProcessType</key><string>Interactive</string>
 <key>StandardOutPath</key><string>${xml(path.join(installDir, 'menubar.out.log'))}</string>
 <key>StandardErrorPath</key><string>${xml(path.join(installDir, 'menubar.err.log'))}</string>
 </dict></plist>\n`;
 }
+export function menuBarLaunchdTouchAllowed(paths, env) {
+    return Boolean(env.SKS_MENUBAR_LAUNCHCTL) || path.resolve(paths.home) === realUserHome();
+}
 export async function seedMenuBarPreferredPosition(env) {
     const defaults = env.SKS_MENUBAR_DEFAULTS || await which('defaults').catch(() => null) || '/usr/bin/defaults';
     const writes = [
@@ -304,15 +309,24 @@ export async function removeLaunchAgent(paths, env) {
     const actions = [];
     const warnings = [];
     const blockers = [];
-    const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
-    const stopped = await stopMenuBarForReplacement({
-        launchctl,
-        paths,
-        executablePaths: [paths.executable_path],
-        env
-    });
-    if (!stopped.ok)
-        blockers.push(stopped.error || 'menubar_process_stop_failed');
+    if (menuBarLaunchdTouchAllowed(paths, env)) {
+        const launchctl = env.SKS_MENUBAR_LAUNCHCTL || await which('launchctl').catch(() => null) || '/bin/launchctl';
+        const stopped = await stopMenuBarForReplacement({
+            launchctl,
+            paths,
+            executablePaths: [paths.executable_path],
+            env
+        });
+        if (!stopped.ok)
+            blockers.push(stopped.error || 'menubar_process_stop_failed');
+    }
+    else {
+        const terminated = await terminateMenuBarProcesses([paths.executable_path], env);
+        if (!terminated.ok)
+            blockers.push('menubar_process_stop_failed');
+        else
+            warnings.push('launchd_stop_skipped_non_user_home');
+    }
     if (blockers.length > 0)
         return { actions, warnings, blockers };
     await fs.rm(paths.launch_agent_path, { force: true }).catch((error) => blockers.push(`remove_launch_agent_failed:${String(error)}`));

package/dist/core/codex-app/menubar/rollback.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { readJson, sha256, which } from '../../fsx.js';
 import { applyMenuBarGenerationTransaction, commitMenuBarGenerationTransaction, installGenerationPairs, MenuBarGenerationTransactionError, recoverMenuBarGenerationTransaction, rollbackGenerationPairs } from './generation-transaction.js';
-import { launchMenuBar, stopMenuBarForReplacement } from './launch-agent.js';
+import { launchMenuBar, menuBarLaunchdTouchAllowed, stopMenuBarForReplacement, terminateMenuBarProcesses } from './launch-agent.js';
 import { sksMenuBarPaths } from './paths.js';
 import { aggregateFileHashes } from './build-stamp.js';
 import { inspectInstalledResources } from './resources.js';
@@ -286,7 +286,7 @@ export async function rollbackSksMenuBar(opts = {}) {
     else {
         transaction = committed;
     }
-    if (opts.launch === false || env.SKS_SKIP_SKS_MENUBAR_LAUNCH === '1') {
+    if (opts.launch === false || env.SKS_SKIP_SKS_MENUBAR_LAUNCH === '1' || !menuBarLaunchdTouchAllowed(paths, env)) {
         return result('rolled_back_launch_skipped', true, verificationBefore.package_version, replacedStamp?.package_version || null, verificationBefore, verificationAfter, { requested: false, method: 'skipped', ok: true }, [], warnings);
     }
     const launch = await launchMenuBar({
@@ -307,6 +307,16 @@ export async function rollbackSksMenuBar(opts = {}) {
     async function stopBeforeReplacement() {
         if (replacementStopped)
             return null;
+        if (!menuBarLaunchdTouchAllowed(paths, env)) {
+            const terminated = await terminateMenuBarProcesses([paths.executable_path], env);
+            if (!terminated.ok) {
+                return result('failed', false, null, null, null, null, { requested: false, method: 'none', ok: false, error: 'menubar_rollback_stop_failed' }, ['menubar_rollback_stop_failed'], warnings);
+            }
+            replacementStopped = true;
+            warnings.push('launchd_stop_skipped_non_user_home');
+            actions.push('verified process termination without touching the user launchd service before journaled rollback replacement');
+            return null;
+        }
         const stopped = await stopMenuBarForReplacement({
             launchctl,
             paths,

package/dist/core/codex-lb/combined-catalog/normalize.js

@@ -44,7 +44,8 @@ export function normalizeProviderCatalog(input) {
             supported_in_api: row?.supported_in_api !== false,
             capabilities,
             source_catalog_generation: input.generation || 'unknown',
-            route_key: `openrouter:${publicId}`
+            route_key: `openrouter:${publicId}`,
+            ...codexModelInfoFields(publicId, null, { tools: capabilities.includes('tools') })
         });
     }).filter(isModel);
     if (models.length === 0)
@@ -119,7 +120,11 @@ function normalizeCodexLbBridgeCatalogModels(payload, sourceCatalogGeneration) {
                 supported_in_api: row.supported_in_api !== false,
                 capabilities: unique(capabilities).sort(),
                 source_catalog_generation: sourceCatalogGeneration,
-                route_key: `codex-lb:${publicId.toLowerCase()}`
+                route_key: `codex-lb:${publicId.toLowerCase()}`,
+                ...codexModelInfoFields(publicId, row, {
+                    tools: row.supports_tools === true || row.supports_tool_choice === true
+                }),
+                ...(typeof row.priority === 'number' ? {} : { priority: 100 })
             });
         }
         catch (error) {
@@ -146,6 +151,32 @@ function sanitizeCodexLbModelRow(row, index) {
 function isPlainObject(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
+export function codexModelInfoFields(slug, row, fallback) {
+    const summaries = typeof row?.supports_reasoning_summary_parameter === 'boolean'
+        ? row.supports_reasoning_summary_parameter
+        : row?.supports_reasoning_summaries !== false;
+    return {
+        slug,
+        supported_reasoning_levels: Array.isArray(row?.supported_reasoning_levels)
+            ? row.supported_reasoning_levels.map(String)
+            : [],
+        shell_type: typeof row?.shell_type === 'string' && row.shell_type ? row.shell_type : 'shell_command',
+        visibility: typeof row?.visibility === 'string' && row.visibility ? row.visibility : 'list',
+        priority: typeof row?.priority === 'number' && Number.isFinite(row.priority) ? row.priority : 1,
+        base_instructions: typeof row?.base_instructions === 'string' ? row.base_instructions : '',
+        supports_reasoning_summary_parameter: summaries,
+        support_verbosity: row?.support_verbosity === true,
+        truncation_policy: isPlainObject(row?.truncation_policy)
+            ? row.truncation_policy
+            : { mode: 'tokens', limit: 10_000 },
+        supports_parallel_tool_calls: typeof row?.supports_parallel_tool_calls === 'boolean'
+            ? row.supports_parallel_tool_calls
+            : fallback.tools,
+        experimental_supported_tools: Array.isArray(row?.experimental_supported_tools)
+            ? row.experimental_supported_tools.map(String)
+            : []
+    };
+}
 function providerCode(providerId) {
     return providerId === 'codex-lb' ? 'codex_lb' : 'openrouter';
 }
@@ -162,7 +193,10 @@ function canonicalModel(model) {
         supported_in_api: model.supported_in_api !== false,
         capabilities: unique(model.capabilities).sort(),
         source_catalog_generation: String(model.source_catalog_generation || 'unknown'),
-        route_key: `${model.provider_id}:${publicId}`
+        route_key: `${model.provider_id}:${publicId}`,
+        ...codexModelInfoFields(publicId, model, {
+            tools: model.capabilities.includes('tools')
+        })
     };
 }
 function isModel(value) {

package/dist/core/codex-lb/combined-catalog/shared.js

@@ -3,8 +3,14 @@ export function safeErrorCode(error, fallback) {
     return /^[a-z0-9_:-]{1,160}$/i.test(message) ? message : fallback;
 }
 export function compareModels(left, right) {
+    if (left.provider_id !== right.provider_id) {
+        if (left.provider_id === 'codex-lb')
+            return -1;
+        if (right.provider_id === 'codex-lb')
+            return 1;
+        return left.provider_id.localeCompare(right.provider_id);
+    }
     return left.public_id.localeCompare(right.public_id)
-        || left.provider_id.localeCompare(right.provider_id)
         || left.upstream_model.localeCompare(right.upstream_model);
 }
 export function unique(values) {

package/dist/core/codex-lb/desktop-bridge/header-policy.js

@@ -6,8 +6,9 @@ const REQUEST_HEADER_ALLOWLIST = new Set([
     'accept', 'accept-encoding', 'cache-control', 'content-encoding', 'content-length', 'content-type',
 ]);
 const CODEX_LOCAL_HEADERS = new Set([
-    'thread-id', 'session-id', 'x-client-request-id', 'x-codex-installation-id',
-    'x-codex-turn-metadata', 'x-codex-window-id', 'originator',
+    'thread-id', 'thread_id', 'session-id', 'session_id', 'x-client-request-id',
+    'x-codex-installation-id', 'x-codex-turn-metadata', 'x-codex-window-id',
+    'originator', 'openai-beta',
 ]);
 const NEVER_FORWARD_FROM_CLIENT = new Set([
     'authorization', 'cookie', 'forwarded', 'proxy-authorization', 'x-api-key', 'x-codex-lb-api-key',
@@ -43,7 +44,8 @@ export function buildProviderUpstreamHeaders(inbound, context, upstreamHost) {
         if (rawValue === undefined)
             continue;
         const name = rawName.toLowerCase();
-        const providerAllowed = context.providerId === 'openrouter' && OPENROUTER_CLIENT_HEADERS.has(name);
+        const providerAllowed = (context.providerId === 'openrouter' && OPENROUTER_CLIENT_HEADERS.has(name))
+            || (context.providerId === 'codex-lb' && CODEX_LOCAL_HEADERS.has(name));
         if (!REQUEST_HEADER_ALLOWLIST.has(name) && !providerAllowed)
             continue;
         result[name] = rawValue;

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

@@ -1,11 +1,44 @@
 import http, {} from 'node:http';
 import https from 'node:https';
+import zlib from 'node:zlib';
 import { pipeline } from 'node:stream/promises';
 import { buildProviderUpstreamHeaders, rewriteResponseHeaders } from './header-policy.js';
 import { resolveAndBindDesktopBridgeRouteContext, resolveCodexSessionIdentity, resolveDesktopBridgeTarget, safeBridgeErrorCode, singleBridgeHeader } from './security.js';
 import { desktopBridgeListenOrigin } from './state.js';
 import { DesktopBridgeError } from './types.js';
 const MAX_UPSTREAM_ERROR_BODY_BYTES = 1024 * 1024;
+function decodeBridgeRequestBody(body, encoding, maximum) {
+    const options = { maxOutputLength: maximum };
+    try {
+        switch (encoding) {
+            case 'gzip':
+            case 'x-gzip':
+                return zlib.gunzipSync(body, options);
+            case 'deflate':
+                try {
+                    return zlib.inflateSync(body, options);
+                }
+                catch {
+                    return zlib.inflateRawSync(body, options);
+                }
+            case 'br':
+                return zlib.brotliDecompressSync(body, options);
+            case 'zstd': {
+                const zstd = zlib.zstdDecompressSync;
+                if (!zstd)
+                    throw new DesktopBridgeError('bridge_request_encoding_unsupported');
+                return zstd(body, options);
+            }
+            default:
+                throw new DesktopBridgeError('bridge_request_encoding_unsupported');
+        }
+    }
+    catch (error) {
+        if (error instanceof DesktopBridgeError)
+            throw error;
+        throw new DesktopBridgeError('bridge_responses_body_invalid_json');
+    }
+}
 function bodyCarriesModel(rawUrl) {
     const pathname = new URL(String(rawUrl || '/'), 'http://bridge.invalid').pathname;
     return pathname === '/backend-api/codex/responses' || pathname === '/api/v1/responses' || pathname === '/v1/responses';
@@ -40,10 +73,18 @@ export async function prepareDesktopBridgeRequest(req, config) {
     const pathname = new URL(String(req.url || '/'), 'http://bridge.invalid').pathname;
     let body = null;
     let payload = null;
+    let contentEncodingStripped = false;
     if (bodyCarriesModel(req.url)) {
-        body = await readBoundedBody(req, config.maxRequestBodyBytes ?? 16 * 1024 * 1024);
+        const maximum = config.maxRequestBodyBytes ?? 16 * 1024 * 1024;
+        body = await readBoundedBody(req, maximum);
+        const encoding = String(req.headers['content-encoding'] || '').trim().toLowerCase();
+        let decoded = body;
+        if (encoding && encoding !== 'identity') {
+            decoded = decodeBridgeRequestBody(body, encoding, maximum);
+            contentEncodingStripped = true;
+        }
         try {
-            const parsed = JSON.parse(body.toString('utf8'));
+            const parsed = JSON.parse(decoded.toString('utf8'));
             if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
                 throw new Error();
             payload = parsed;
@@ -51,6 +92,8 @@ export async function prepareDesktopBridgeRequest(req, config) {
         catch {
             throw new DesktopBridgeError('bridge_responses_body_invalid_json');
         }
+        if (contentEncodingStripped)
+            body = decoded;
     }
     const headerModel = singleBridgeHeader(req.headers, 'x-sks-model');
     const model = typeof payload?.model === 'string' ? payload.model : headerModel;
@@ -64,7 +107,7 @@ export async function prepareDesktopBridgeRequest(req, config) {
         body = Buffer.from(JSON.stringify(payload));
     }
     const credential = await resolveCredential(config, route);
-    return { body, route, credential };
+    return { body, route, credential, contentEncodingStripped };
 }
 function connectTimeout(request, config) {
     request.once('socket', (socket) => {
@@ -121,6 +164,8 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             headers['content-length'] = String(request.body.length);
         else
             delete headers['content-length'];
+        if (request.contentEncodingStripped)
+            delete headers['content-encoding'];
         await new Promise((resolve, reject) => {
             let responseStarted = false;
             let settled = false;

package/dist/core/codex-lb/desktop-bridge/server.js

@@ -117,16 +117,22 @@ function writeBridgeRejection(res, error) {
     res.end(JSON.stringify({ error: { type: 'sks_bridge_rejection', code, message: code } }));
 }
 function writeUpgradeRejection(socket, error) {
-    if (socket.destroyed)
+    socket.on('error', () => undefined);
+    if (socket.destroyed || socket.writableEnded)
         return;
     const code = safeBridgeErrorCode(error);
     const status = rejectionStatus(code);
-    socket.end(`HTTP/1.1 ${status} ${rejectionStatusText(status)}\r\n`
-        + 'Content-Type: application/json\r\n'
-        + 'Cache-Control: no-store\r\n'
-        + 'Connection: close\r\n'
-        + '\r\n'
-        + JSON.stringify({ error: { type: 'sks_bridge_rejection', code, message: code } }));
+    try {
+        socket.end(`HTTP/1.1 ${status} ${rejectionStatusText(status)}\r\n`
+            + 'Content-Type: application/json\r\n'
+            + 'Cache-Control: no-store\r\n'
+            + 'Connection: close\r\n'
+            + '\r\n'
+            + JSON.stringify({ error: { type: 'sks_bridge_rejection', code, message: code } }));
+    }
+    catch {
+        socket.destroy();
+    }
 }
 function writeDiagnosticHealth(req, res, input) {
     if (req.method !== 'GET')

package/dist/core/codex-lb/desktop-bridge-migration/historical-config.js

@@ -28,8 +28,9 @@ export function inspectHistoricalDesktopBridgeIntent(configText) {
         blockers.push('historical_provider_marker_invalid');
     if (nativeBridge && compatBridge)
         blockers.push('historical_desktop_marker_conflict');
-    if (nativeBridge && selectedProvider !== 'openai')
+    if (nativeBridge && selectedProvider !== null && selectedProvider !== 'openai') {
         blockers.push('historical_native_bridge_selection_mismatch');
+    }
     if (compatBridge && selectedProvider !== 'codex-lb')
         blockers.push('historical_compat_bridge_selection_mismatch');
     if (managedCodexLbSelection && selectedProvider !== 'codex-lb') {