sneakoscope 8.3.2 → 8.6.0

package/dist/core/codex/codex-project-config-policy.js

@@ -118,20 +118,8 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
     let backupPath = null;
     let userConfigPath = null;
     let profileConfigPath = null;
-    if (opts.apply && changed) {
-        backupPath = `${configPath}.bak-${Date.now().toString(36)}`;
-        await ensureDir(path.dirname(configPath));
-        await fsp.copyFile(configPath, backupPath);
-        await cleanupCodexConfigBackups(configPath, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
-        await writeCodexConfigGuarded({
-            root,
-            configPath,
-            before: String(original || ''),
-            cause: 'codex-project-config-policy',
-            mutate: () => projectText
-        });
-        actions.push('project_config_rewritten_with_backup');
-    }
+    const writeBlockers = [];
+    let machineLocalMoved = true;
     if (opts.apply && split.machine_text.trim()) {
         await ensureDir(codexHome);
         userConfigPath = codexHomeConfigPath;
@@ -139,15 +127,39 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
         const machineText = preserveExistingGlobalFastModeConfig(String(currentUser || ''), split.machine_text);
         const dedupedUser = removeConfigIds(String(currentUser || ''), configIds(machineText));
         const commentLine = `# SKS moved machine-local Codex config from ${path.relative(root, configPath) || configPath} at ${nowIso()}`;
-        const mergedUser = mergeMachineLocalIntoUserConfig(dedupedUser, machineText.trim(), commentLine);
-        await writeCodexConfigGuarded({
+        const mergedUser = mergeMachineLocalIntoUserConfig(stripSksMovedComments(dedupedUser), machineText.trim(), commentLine);
+        const homeWrite = await writeCodexConfigGuarded({
             root,
             configPath: userConfigPath,
             before: String(currentUser || ''),
             cause: 'codex-project-config-policy-machine-local',
             mutate: () => mergedUser
         });
-        actions.push('machine_local_keys_moved_to_codex_home_config');
+        machineLocalMoved = homeWrite.ok;
+        if (homeWrite.ok)
+            actions.push('machine_local_keys_moved_to_codex_home_config');
+        else
+            writeBlockers.push(`machine_local_move_refused:${homeWrite.status}`);
+    }
+    if (opts.apply && changed && machineLocalMoved) {
+        backupPath = `${configPath}.bak-${Date.now().toString(36)}`;
+        await ensureDir(path.dirname(configPath));
+        await fsp.copyFile(configPath, backupPath);
+        await cleanupCodexConfigBackups(configPath, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
+        const projectWrite = await writeCodexConfigGuarded({
+            root,
+            configPath,
+            before: String(original || ''),
+            cause: 'codex-project-config-policy',
+            mutate: () => projectText
+        });
+        if (projectWrite.ok)
+            actions.push('project_config_rewritten_with_backup');
+        else
+            writeBlockers.push(`project_config_write_refused:${projectWrite.status}`);
+    }
+    else if (opts.apply && changed) {
+        writeBlockers.push('project_config_rewrite_skipped_machine_local_move_refused');
     }
     if (profileName)
         actions.push('legacy_project_profile_selector_removed');
@@ -157,7 +169,7 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
         root,
         config_path: configPath,
         codex_home: codexHome,
-        ok: parseSmoke.ok && split.blockers.length === 0,
+        ok: parseSmoke.ok && split.blockers.length === 0 && writeBlockers.length === 0,
         changed,
         applied: opts.apply === true,
         backup_path: backupPath,
@@ -175,7 +187,11 @@ export async function splitCodexProjectConfigPolicy(rootInput = process.cwd(), o
         deprecated_approval_policy_fixed: split.deprecated_approval_policy_fixed,
         actions,
         parse_smoke: parseSmoke,
-        blockers: [...split.blockers, ...(parseSmoke.ok ? [] : ['project_config_rewrite_parse_smoke_failed'])]
+        blockers: [
+            ...split.blockers,
+            ...writeBlockers,
+            ...(parseSmoke.ok ? [] : ['project_config_rewrite_parse_smoke_failed'])
+        ]
     };
     if (opts.writeReport !== false)
         await writeJsonAtomic(reportPath, { ...report, report_path: reportPath });
@@ -201,28 +217,36 @@ export async function repairCodexConfigStructure(configPathInput, opts = {}) {
     }
     const hoist = hoistMisplacedMachineLocalKeys(String(original));
     let backupPath = null;
+    let applied = false;
+    const writeBlockers = [];
     if (opts.apply && hoist.changed) {
         backupPath = `${configPath}.struct-bak-${Date.now().toString(36)}`;
         await ensureDir(path.dirname(configPath));
         await fsp.copyFile(configPath, backupPath);
         await cleanupCodexConfigBackups(configPath, { keepPerTag: 3, maxAgeMs: 30 * 24 * 60 * 60 * 1000 }).catch(() => undefined);
-        await writeCodexConfigGuarded({
+        const guarded = await writeCodexConfigGuarded({
             configPath,
             before: String(original || ''),
             cause: 'codex-config-structure-repair',
             mutate: () => hoist.text
         });
+        applied = guarded.ok;
+        if (!guarded.ok)
+            writeBlockers.push(`config_write_guard:${guarded.status}`);
     }
     const parseSmoke = tomlRewriteSmoke(hoist.text);
     return {
         config_path: configPath,
-        ok: parseSmoke.ok,
-        status: hoist.changed ? (opts.apply ? 'structure_repaired' : 'structure_repair_available') : 'structure_ok',
+        ok: parseSmoke.ok && writeBlockers.length === 0,
+        status: hoist.changed
+            ? (applied ? 'structure_repaired' : opts.apply ? 'structure_repair_refused' : 'structure_repair_available')
+            : 'structure_ok',
         changed: hoist.changed,
-        applied: opts.apply === true && hoist.changed,
+        applied,
         hoisted_keys: hoist.hoisted_keys,
         backup_path: backupPath,
-        parse_smoke: parseSmoke
+        parse_smoke: parseSmoke,
+        blockers: writeBlockers
     };
 }
 function isCodexConfigToml(file) {
@@ -451,12 +475,6 @@ function tomlRewriteSmoke(text) {
         invalid_table_header: badHeader || null
     };
 }
-function profileTableBody(blocks, profile) {
-    const block = blocks.find((item) => item.table === `profiles.${profile}`);
-    if (!block)
-        return '';
-    return block.text.split('\n').filter((line) => !/^\s*\[/.test(line)).join('\n');
-}
 function configIds(text) {
     const ids = { keys: new Set(), tables: new Set() };
     for (const block of tomlBlocks(text)) {
@@ -512,6 +530,12 @@ function mergeMachineLocalIntoUserConfig(userText, machineText, commentLine) {
     }
     return normalizeProjectText(sections.join('\n\n'));
 }
+function stripSksMovedComments(text) {
+    return normalizeProjectText(String(text || '')
+        .split('\n')
+        .filter((line) => !/^\s*#\s*SKS moved machine-local Codex config\b/i.test(line))
+        .join('\n'));
+}
 function collectTomlSections(text, preamble, tables) {
     for (const block of tomlBlocks(text)) {
         if (block.table)

package/dist/core/codex/codex-startup-config-postcheck.js

@@ -16,9 +16,14 @@ export async function postcheckCodexStartupConfig(input) {
     const rolePlan = await installOfficialSubagentAgentConfigs(root, { apply: false });
     const tomlSmoke = tomlSyntaxSmoke(text);
     const orphanChildTables = orphanMcpChildTables(text);
+    const multiAgentV2Disabled = officialConfig.multiAgentV2.enabled === false;
     const blockers = [
         ...(!configPresent ? ['project_official_subagent_config_missing'] : []),
         ...(!tomlValidation.ok ? ['project_official_subagent_config_toml_parse_failed'] : []),
+        ...(multiAgentV2Disabled ? ['official_subagent_multi_agent_v2_disabled'] : []),
+        ...(multiAgentV2Disabled && officialConfig.enabled === false
+            ? ['official_subagent_agents_disabled']
+            : []),
         ...officialConfig.blockers.map((item) => `official_subagent_config:${item}`),
         ...rolePlan.missing.map((file) => `missing_official_subagent_agent:${file}`),
         ...rolePlan.stale.map((file) => `stale_official_subagent_agent:${file}`),

package/dist/core/codex-app/codex-app-fast-ui-repair.js

@@ -17,7 +17,8 @@ export async function repairCodexAppFastUi(root = process.cwd(), input = {}) {
     const candidates = [
         { scope: 'project', file: path.join(resolvedRoot, '.codex', 'config.toml'), mode: 'project_forbidden_keys' },
         { scope: 'codex_home', file: path.join(home, 'config.toml'), mode: 'sks_caused_host_owned_keys' }
-    ];
+    ].filter((candidate) => candidate.mode !== 'project_forbidden_keys'
+        || path.resolve(candidate.file) !== path.resolve(home, 'config.toml'));
     const actions = [];
     const detectedProjectLocalForbiddenKeys = [];
     const unsafeReasons = [];

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

@@ -24,6 +24,7 @@ export const NATIVE_SOURCE_FILES = [
     'ProvidersReliability.swift',
     'ProvidersRoutingTruth.swift',
     'ProvidersOpenRouter.swift',
+    'ProvidersModelExposure.swift',
     'ProvidersBridgeCatalog.swift',
     'RemoteCodingViewController.swift',
     'DiagnosticsViewController.swift',

package/dist/core/codex-hooks/codex-hook-state-writer.js

@@ -160,6 +160,8 @@ function upsertTomlTable(text, table, block) {
             break;
         }
     }
+    while (end > start + 1 && !String(lines[end - 1] || '').trim())
+        end -= 1;
     lines.splice(start, end - start, ...blockLines);
     return lines.join('\n').replace(/\n{3,}/g, '\n\n');
 }

package/dist/core/codex-lb/codex-lb-env.js

@@ -135,6 +135,7 @@ export async function readCodexLbModelCatalog(opts = {}) {
             ok: false,
             status: 'blocked',
             models: [],
+            model_rows: [],
             model_efforts: {},
             http_status: null,
             blockers: loaded.missing.length ? loaded.missing.map((item) => `codex_lb_missing:${item}`) : ['codex_lb_not_configured']
@@ -147,6 +148,7 @@ export async function readCodexLbModelCatalog(opts = {}) {
             ok: false,
             status: 'blocked',
             models: [],
+            model_rows: [],
             model_efforts: {},
             http_status: null,
             blockers: [transportBlocker]
@@ -167,6 +169,7 @@ export async function readCodexLbModelCatalog(opts = {}) {
             ok: false,
             status: 'blocked',
             models: [],
+            model_rows: [],
             model_efforts: {},
             http_status: null,
             blockers: [`codex_lb_${safeBridgeErrorCode(error).replace(/^bridge_/, '')}`]
@@ -175,15 +178,17 @@ export async function readCodexLbModelCatalog(opts = {}) {
     try {
         const timeoutMs = Math.max(250, Number(opts.timeoutMs || 5000));
         const modelsUrl = new URL(`${loaded.base_url}/models`);
-        const response = opts.fetchImpl
-            ? await fetchImpl(modelsUrl, {
+        const request = async (url) => (opts.fetchImpl
+            ? await fetchImpl(url, {
                 headers: gatewayHeaders,
                 redirect: 'error',
                 signal: AbortSignal.timeout(timeoutMs)
             })
-            : await requestPinnedCodexLbCatalog(modelsUrl, remote, gatewayHeaders, timeoutMs);
+            : await requestPinnedCodexLbCatalog(url, remote, gatewayHeaders, timeoutMs));
+        const response = await request(modelsUrl);
         const payload = await response.json().catch(() => null);
         const models = normalizeCodexLbModelCatalogPayload(payload);
+        const modelRows = codexLbModelCatalogRows(payload);
         const apiEfforts = normalizeCodexModelEffortCatalogPayload(payload);
         const cachePath = path.join(String(process.env.CODEX_HOME || path.join(os.homedir(), '.codex')), 'models_cache.json');
         const cachePayload = await readJson(cachePath, null).catch(() => null);
@@ -195,6 +200,7 @@ export async function readCodexLbModelCatalog(opts = {}) {
             ok,
             status: ok ? 'ready' : 'blocked',
             models,
+            model_rows: modelRows,
             model_efforts: modelEfforts,
             http_status: response.status,
             blockers: [
@@ -209,6 +215,7 @@ export async function readCodexLbModelCatalog(opts = {}) {
             ok: false,
             status: 'blocked',
             models: [],
+            model_rows: [],
             model_efforts: {},
             http_status: null,
             blockers: ['codex_lb_model_catalog_unavailable']
@@ -287,6 +294,21 @@ export function normalizeCodexLbModelCatalogPayload(payload) {
         .filter(Boolean);
     return [...new Set(models)];
 }
+export function codexLbModelCatalogRows(payload) {
+    const rows = Array.isArray(payload?.models) ? payload.models : Array.isArray(payload?.data) ? payload.data : [];
+    const seen = new Set();
+    const preserved = [];
+    for (const row of rows) {
+        if (!row || typeof row !== 'object' || Array.isArray(row))
+            continue;
+        const slug = String(row.id || row.model || row.slug || row.name || '').trim();
+        if (!slug || seen.has(slug))
+            continue;
+        seen.add(slug);
+        preserved.push({ ...row, slug });
+    }
+    return preserved;
+}
 export function normalizeCodexLbBaseUrl(input = '') {
     let host = String(input || '').trim();
     if (!host)

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

@@ -2,14 +2,18 @@ import { buildBridgeRouteIndex, sha256Stable } from '../route-index.js';
 import { COMBINED_BRIDGE_CATALOG_SCHEMA } from './contracts.js';
 import { normalizeProviderCatalog, providerCatalogStatus, routeProviderState } from './normalize.js';
 import { compareModels, unique } from './shared.js';
+import { applyBridgeModelSelection, availableModelRows, emptyBridgeModelSelection } from './model-selection.js';
 export function buildCombinedBridgeCatalog(registry, options) {
     const createdAt = options.created_at || new Date().toISOString();
     const normalized = {
         'codex-lb': normalizeProviderCatalog(options.catalogs['codex-lb']),
         openrouter: normalizeProviderCatalog(options.catalogs.openrouter)
     };
-    const models = [...normalized['codex-lb'].models, ...normalized.openrouter.models]
+    const selection = options.selection || emptyBridgeModelSelection(createdAt);
+    const allModels = [...normalized['codex-lb'].models, ...normalized.openrouter.models]
         .sort(compareModels);
+    const availableOpenRouterModels = availableModelRows(allModels, selection);
+    const models = options.selection ? applyBridgeModelSelection(allModels, selection) : allModels;
     const routeBuild = buildBridgeRouteIndex({
         models,
         providers: {
@@ -81,6 +85,7 @@ export function buildCombinedBridgeCatalog(registry, options) {
         route_index: routeBuild.route_index,
         status,
         blockers,
-        warnings: status.warnings
+        warnings: status.warnings,
+        available_openrouter_models: availableOpenRouterModels
     };
 }

package/dist/core/codex-lb/combined-catalog/model-selection.js

@@ -0,0 +1,71 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { writeJsonAtomic } from '../../fsx.js';
+export const BRIDGE_MODEL_SELECTION_SCHEMA = 'sks.bridge-model-selection.v1';
+export const BRIDGE_MODEL_SELECTION_FILENAME = 'sks-bridge-model-selection.json';
+export const BRIDGE_AVAILABLE_MODELS_FILENAME = 'sks-bridge-available-models.json';
+export const MAX_SELECTED_OPENROUTER_MODELS = 64;
+export function bridgeModelSelectionPath(home) {
+    return path.join(path.resolve(home), '.codex', 'sks', BRIDGE_MODEL_SELECTION_FILENAME);
+}
+export function bridgeAvailableModelsPath(home) {
+    return path.join(path.resolve(home), '.codex', 'sks', BRIDGE_AVAILABLE_MODELS_FILENAME);
+}
+export function emptyBridgeModelSelection(now) {
+    return { schema: BRIDGE_MODEL_SELECTION_SCHEMA, updated_at: now, openrouter: { mode: 'selected', public_ids: [] } };
+}
+export function normalizeBridgeModelSelection(value, now) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return emptyBridgeModelSelection(now);
+    const row = value;
+    if (row.schema !== BRIDGE_MODEL_SELECTION_SCHEMA)
+        return emptyBridgeModelSelection(now);
+    const openrouter = row.openrouter && typeof row.openrouter === 'object' && !Array.isArray(row.openrouter)
+        ? row.openrouter
+        : {};
+    const ids = Array.isArray(openrouter.public_ids)
+        ? openrouter.public_ids.map((id) => String(id || '').trim()).filter(Boolean)
+        : [];
+    return {
+        schema: BRIDGE_MODEL_SELECTION_SCHEMA,
+        updated_at: typeof row.updated_at === 'string' && row.updated_at ? row.updated_at : now,
+        openrouter: { mode: 'selected', public_ids: [...new Set(ids)].sort().slice(0, MAX_SELECTED_OPENROUTER_MODELS) }
+    };
+}
+export async function readBridgeModelSelection(home, now = new Date().toISOString()) {
+    return (await readBridgeModelSelectionState(home, now)).selection;
+}
+export async function readBridgeModelSelectionState(home, now = new Date().toISOString()) {
+    try {
+        const raw = await fsp.readFile(bridgeModelSelectionPath(home), 'utf8');
+        return { selection: normalizeBridgeModelSelection(JSON.parse(raw), now), stored: true };
+    }
+    catch {
+        return { selection: emptyBridgeModelSelection(now), stored: false };
+    }
+}
+export async function writeBridgeModelSelection(home, selection) {
+    await writeJsonAtomic(bridgeModelSelectionPath(home), selection, { mode: 0o600 });
+}
+export function applyBridgeModelSelection(models, selection) {
+    const selected = new Set(selection.openrouter.public_ids);
+    return models.filter((model) => model.provider_id !== 'openrouter' || selected.has(model.public_id));
+}
+export function availableModelRows(models, selection) {
+    const selected = new Set(selection.openrouter.public_ids);
+    return models
+        .filter((model) => model.provider_id === 'openrouter')
+        .map((model) => ({
+        public_id: model.public_id,
+        display_name: model.display_name,
+        selected: selected.has(model.public_id)
+    }))
+        .sort((left, right) => left.display_name.localeCompare(right.display_name));
+}
+export function pruneSelection(selection, available) {
+    const known = new Set(available.map((row) => row.public_id));
+    const kept = selection.openrouter.public_ids.filter((id) => known.has(id));
+    if (kept.length === selection.openrouter.public_ids.length)
+        return selection;
+    return { ...selection, openrouter: { mode: 'selected', public_ids: kept } };
+}

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

@@ -30,9 +30,10 @@ export function normalizeProviderCatalog(input) {
         if (!publicId || !upstreamModel)
             return null;
         const features = row?.features && typeof row.features === 'object' ? row.features : {};
+        const reasoning = features.reasoning === true;
         const capabilities = [
             ...(features.tools === true ? ['tools'] : []),
-            ...(features.reasoning === true ? ['reasoning'] : []),
+            ...(reasoning ? ['reasoning'] : []),
             ...(features.vision === true ? ['vision'] : []),
             ...(features.audio === true ? ['audio'] : [])
         ];
@@ -45,7 +46,11 @@ export function normalizeProviderCatalog(input) {
             capabilities,
             source_catalog_generation: input.generation || 'unknown',
             route_key: `openrouter:${publicId}`,
-            ...codexModelInfoFields(publicId, null, { tools: capabilities.includes('tools') })
+            ...(reasoning ? { default_reasoning_level: OPENROUTER_DEFAULT_REASONING_LEVEL } : {}),
+            ...codexModelInfoFields(publicId, {
+                supported_reasoning_levels: reasoning ? openRouterReasoningLevels() : [],
+                supports_reasoning_summary_parameter: reasoning
+            }, { tools: capabilities.includes('tools') })
         });
     }).filter(isModel);
     if (models.length === 0)
@@ -113,6 +118,7 @@ function normalizeCodexLbBridgeCatalogModels(payload, sourceCatalogGeneration) {
                 ...(row.supports_audio === true || row.audio === true ? ['audio'] : [])
             ];
             models.push({
+                ...row,
                 public_id: publicId,
                 provider_id: 'codex-lb',
                 upstream_model: publicId,
@@ -151,6 +157,16 @@ function sanitizeCodexLbModelRow(row, index) {
 function isPlainObject(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }
+export const OPENROUTER_REASONING_LEVELS = [
+    { effort: 'low', description: 'Fast responses with lighter reasoning' },
+    { effort: 'medium', description: 'Balances speed and reasoning depth for everyday tasks' },
+    { effort: 'high', description: 'Greater reasoning depth for complex problems' },
+    { effort: 'xhigh', description: 'Extra high reasoning depth for complex problems' }
+];
+export const OPENROUTER_DEFAULT_REASONING_LEVEL = 'medium';
+function openRouterReasoningLevels() {
+    return OPENROUTER_REASONING_LEVELS.map((level) => ({ ...level }));
+}
 export function codexModelInfoFields(slug, row, fallback) {
     const summaries = typeof row?.supports_reasoning_summary_parameter === 'boolean'
         ? row.supports_reasoning_summary_parameter
@@ -158,7 +174,7 @@ export function codexModelInfoFields(slug, row, fallback) {
     return {
         slug,
         supported_reasoning_levels: Array.isArray(row?.supported_reasoning_levels)
-            ? row.supported_reasoning_levels.map(String)
+            ? row.supported_reasoning_levels.map((level) => (level && typeof level === 'object' ? level : String(level)))
             : [],
         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',
@@ -186,6 +202,7 @@ function canonicalModel(model) {
     if (!publicId || !upstream)
         return null;
     return {
+        ...model,
         public_id: publicId,
         provider_id: model.provider_id,
         upstream_model: upstream,

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

@@ -158,22 +158,25 @@ export function resolveBridgeRequestRoute(request, policy, pins) {
     const sessionId = request.session_id ? canonicalSessionId(request.session_id) : null;
     const pin = sessionId ? pins.find((entry) => entry.thread_id === sessionId) || null : null;
     if (pin && pin.public_model === publicModel) {
-        if (pin.public_model !== publicModel
-            || pin.catalog_generation !== policy.catalog_generation
-            || pin.route_policy_generation !== policy.policy_generation) {
-            throw new DesktopBridgeError('session_pin_route_unavailable');
-        }
         const current = policy.model_routes[publicModel];
         if (!current || current.provider_id !== pin.provider_id || current.upstream_model !== pin.upstream_model) {
             throw new DesktopBridgeError('session_pin_route_unavailable');
         }
+        const aged = pin.catalog_generation !== policy.catalog_generation
+            || pin.route_policy_generation !== policy.policy_generation;
         return {
             provider_id: pin.provider_id,
             public_model: publicModel,
             upstream_model: pin.upstream_model,
-            catalog_generation: pin.catalog_generation,
-            route_policy_generation: pin.route_policy_generation,
-            session_pin: pin,
+            catalog_generation: policy.catalog_generation,
+            route_policy_generation: policy.policy_generation,
+            session_pin: aged
+                ? {
+                    ...pin,
+                    catalog_generation: policy.catalog_generation,
+                    route_policy_generation: policy.policy_generation,
+                }
+                : pin,
         };
     }
     const route = policy.model_routes[publicModel];

package/dist/core/codex-lb/desktop-controller-v3/catalog.js

@@ -1,4 +1,6 @@
-import { readText } from '../../fsx.js';
+import { readText, writeJsonAtomic } from '../../fsx.js';
+import { readTopLevelTomlString } from '../../codex-app/codex-model-catalog.js';
+import { BRIDGE_MODEL_SELECTION_SCHEMA, MAX_SELECTED_OPENROUTER_MODELS, bridgeAvailableModelsPath, pruneSelection, readBridgeModelSelectionState, writeBridgeModelSelection } from '../combined-catalog/model-selection.js';
 import { listOpenRouterModels } from '../../providers/openrouter/openrouter-account.js';
 import { buildCombinedBridgeCatalog, readActiveCombinedBridgeCatalog, stageCombinedBridgeCatalog } from '../combined-catalog.js';
 import { codexLbEnvPath, codexLbMetadataPath, loadCodexLbEnv, readCodexLbModelCatalog } from '../codex-lb-env.js';
@@ -40,7 +42,21 @@ export async function syncCatalogInternal(options) {
     const catalogs = await fetchProviderCatalogs(initialRegistry, rawCredentials, paths, options);
     const credentials = await resolveValidatedCredentials(options, paths);
     const registry = await resolveBridgeProviderRegistry({ home: paths.home, credentials, storedRegistry });
-    const build = buildCombinedBridgeCatalog(registry, { catalogs, created_at: nowIso(options) });
+    const selectionState = await readBridgeModelSelectionState(paths.home, nowIso(options));
+    const selection = selectionState.stored
+        ? selectionState.selection
+        : seedSelectionFromConfiguredModel(selectionState.selection, await readText(paths.configPath, ''));
+    const build = buildCombinedBridgeCatalog(registry, { catalogs, created_at: nowIso(options), selection });
+    if (!selectionState.stored)
+        await writeBridgeModelSelection(paths.home, selection).catch(() => undefined);
+    await writeJsonAtomic(bridgeAvailableModelsPath(paths.home), {
+        schema: 'sks.bridge-available-models.v1',
+        updated_at: nowIso(options),
+        openrouter: build.available_openrouter_models
+    }, { mode: 0o600 }).catch(() => undefined);
+    const pruned = pruneSelection(selection, build.available_openrouter_models);
+    if (pruned !== selection)
+        await writeBridgeModelSelection(paths.home, pruned).catch(() => undefined);
     const staging = await stageCombinedBridgeCatalog({
         build,
         catalogPath: paths.catalogPath,
@@ -200,11 +216,12 @@ async function fetchProviderCatalogs(registry, credentials, paths, options) {
                 home: paths.home,
                 validationPath: paths.validationPath
             });
+            const codexLbModels = result.model_rows.length > 0 ? result.model_rows : result.models;
             return [providerId, {
                     provider_id: providerId,
                     state: result.ok ? 'verified' : 'failed',
-                    generation: result.ok ? sha256Stable({ provider_id: providerId, models: result.models }) : null,
-                    models: { models: result.models },
+                    generation: result.ok ? sha256Stable({ provider_id: providerId, models: codexLbModels }) : null,
+                    models: { models: codexLbModels },
                     checked_at: checkedAt,
                     expires_at: expiresAt,
                     blockers: result.blockers,
@@ -255,3 +272,57 @@ function validationFailureState(blockers) {
     return blockers.some((blocker) => /(?:401|403|auth|rejected|invalid_key|unauthorized)/i.test(blocker))
         ? 'rejected' : 'unavailable';
 }
+export async function listSelectableModels(options) {
+    const paths = controllerPaths(options);
+    const selection = (await readBridgeModelSelectionState(paths.home, nowIso(options))).selection;
+    const available = await readText(bridgeAvailableModelsPath(paths.home), '');
+    let rows = [];
+    try {
+        const parsed = available ? JSON.parse(available) : null;
+        if (parsed && Array.isArray(parsed.openrouter))
+            rows = parsed.openrouter;
+    }
+    catch {
+        rows = [];
+    }
+    const selected = new Set(selection.openrouter.public_ids);
+    const status = await desktopBridgeStatusV3(options);
+    return commandResult('models.list', true, status, {
+        codex_lb_exposure: 'all',
+        openrouter: {
+            mode: 'selected',
+            selected_count: selection.openrouter.public_ids.length,
+            max_selected: MAX_SELECTED_OPENROUTER_MODELS,
+            available_count: rows.length,
+            models: rows.map((row) => ({
+                public_id: String(row?.public_id || ''),
+                display_name: String(row?.display_name || row?.public_id || ''),
+                selected: selected.has(String(row?.public_id || ''))
+            })).filter((row) => row.public_id)
+        }
+    }, rows.length === 0 ? ['bridge_available_models_unknown'] : [], options);
+}
+export async function selectExposedModels(publicIds, options) {
+    const paths = controllerPaths(options);
+    const requested = [...new Set(publicIds.map((id) => String(id || '').trim()).filter(Boolean))].sort();
+    if (requested.length > MAX_SELECTED_OPENROUTER_MODELS) {
+        throw new Error('bridge_model_selection_limit_exceeded');
+    }
+    await writeBridgeModelSelection(paths.home, {
+        schema: BRIDGE_MODEL_SELECTION_SCHEMA,
+        updated_at: nowIso(options),
+        openrouter: { mode: 'selected', public_ids: requested }
+    });
+    const sync = await syncCatalogInternal(options);
+    const status = await desktopBridgeStatusV3(options);
+    const activation = sync.activation && typeof sync.activation === 'object'
+        ? sync.activation
+        : {};
+    return commandResult('models.select', sync.ok === true, status, { selected_count: requested.length, catalog_sync: sync }, sync.ok === true ? [] : stringArray(activation.blockers), options);
+}
+function seedSelectionFromConfiguredModel(selection, configText) {
+    const configured = readTopLevelTomlString(configText, 'model');
+    if (!configured || !configured.includes('/'))
+        return selection;
+    return { ...selection, openrouter: { mode: 'selected', public_ids: [configured] } };
+}

package/dist/core/codex-lb/desktop-controller-v3.js

@@ -1,4 +1,4 @@
-import { syncCatalog } from './desktop-controller-v3/catalog.js';
+import { listSelectableModels, selectExposedModels, syncCatalog } from './desktop-controller-v3/catalog.js';
 import { explainRoute, ensureDesktopBridge, repairDesktopBridge, rollbackDesktopBridge, setDefaultProvider, unmanageDesktopBridge } from './desktop-controller-v3/lifecycle-commands.js';
 import { configureProvider, removeCredential, setProviderState, validateProvider } from './desktop-controller-v3/provider-commands.js';
 import { commandResult, safeCode } from './desktop-controller-v3/shared.js';
@@ -40,6 +40,10 @@ export async function executeDesktopBridgeCommandV3(request, options = {}) {
             if (request.operation === 'provider.remove-credential') {
                 return removeCredential(request.provider_id, options);
             }
+            if (request.operation === 'models.list')
+                return listSelectableModels(options);
+            if (request.operation === 'models.select')
+                return selectExposedModels(request.public_ids, options);
             if (request.operation === 'catalog.sync')
                 return syncCatalog(options);
             if (request.operation === 'catalog.status') {