sneakoscope 8.3.2 → 8.4.0

package/dist/core/architecture-map-pipeline.js

@@ -0,0 +1,172 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { exists, nowIso, readJson, writeJsonAtomic } from './fsx.js';
+import { ARCHITECTURE_CAPSULE_ARTIFACT, ARCHITECTURE_MAP_BASELINE_ARTIFACT, ARCHITECTURE_MAP_MANIFEST_ARTIFACT, ARCHITECTURE_MAP_REVIEW_ARTIFACT, bindArchitectureMapBaseline, buildAfterReview, sealBaseline, validateArchitectureMapBaselineArtifact, validateArchitectureMapReviewArtifact } from './architecture-map-review.js';
+import { readContextGraphSnapshot } from './triwiki/context-graph/store/snapshot-store.js';
+export { ARCHITECTURE_MAP_REVIEW_ARTIFACT };
+export const ARCHITECTURE_MAP_BASELINE_STAGE = 'architecture_map_baseline';
+export const ARCHITECTURE_MAP_REVIEW_STAGE = 'architecture_map_review';
+const ARCHITECTURE_MAP_EXEMPT_ROUTES = new Set([
+    'Answer',
+    'DFix',
+    'Help',
+    'Wiki',
+    'Goal',
+    'GX',
+    'DB'
+]);
+export function routeNeedsArchitectureMap(route) {
+    const id = String(route?.id || '');
+    if (!id)
+        return false;
+    if (ARCHITECTURE_MAP_EXEMPT_ROUTES.has(id))
+        return false;
+    return true;
+}
+export function createArchitectureMapPlanBinding() {
+    return Object.freeze({
+        baseline_artifact: ARCHITECTURE_MAP_BASELINE_ARTIFACT,
+        review_artifact: ARCHITECTURE_MAP_REVIEW_ARTIFACT,
+        capsule_artifact: ARCHITECTURE_CAPSULE_ARTIFACT,
+        manifest_artifact: ARCHITECTURE_MAP_MANIFEST_ARTIFACT,
+        required: true,
+        seeded_at: nowIso()
+    });
+}
+export function planStagesArchitectureMap(plan) {
+    return Array.isArray(plan?.stages)
+        && plan.stages.some((stage) => String(stage?.id || '') === ARCHITECTURE_MAP_BASELINE_STAGE
+            && !['skipped', 'not_applicable'].includes(String(stage?.status || '')));
+}
+export async function seedArchitectureMapPlanBinding(dir, plan) {
+    if (!planStagesArchitectureMap(plan))
+        return plan;
+    plan.architecture_map = createArchitectureMapPlanBinding();
+    await writeJsonAtomic(path.join(dir, 'pipeline-plan.json'), plan);
+    return plan;
+}
+export async function maybeSeedArchitectureMapForPlan(input) {
+    if (!input.plan?.architecture_map || !input.missionId)
+        return;
+    await seedArchitectureMapBaselineArtifacts({
+        root: input.root,
+        dir: input.dir,
+        missionId: String(input.missionId),
+        routeId: String(input.plan.route?.id || input.plan.route?.command || 'SKS'),
+        taskProfile: String(input.taskProfile || input.plan.task_profile || '')
+    });
+}
+export async function seedArchitectureMapBaselineArtifacts(input) {
+    const baselinePath = path.join(input.dir, ARCHITECTURE_MAP_BASELINE_ARTIFACT);
+    if (await exists(baselinePath))
+        return { ok: true, baselinePath };
+    const load = await readContextGraphSnapshot(input.root);
+    if (load.status !== 'ok' || !load.snapshot) {
+        return { ok: false, reason: load.blocker || 'architecture_map_graph_unavailable' };
+    }
+    const sealed = sealBaseline({
+        missionId: input.missionId,
+        routeId: input.routeId,
+        snapshot: load.snapshot,
+        policyRoot: input.root,
+        capturedAt: nowIso(),
+        ...(input.taskProfile ? { taskProfile: input.taskProfile } : {})
+    });
+    await fsp.mkdir(input.dir, { recursive: true });
+    await writeJsonAtomic(baselinePath, sealed.baseline);
+    await writeJsonAtomic(path.join(input.dir, ARCHITECTURE_MAP_MANIFEST_ARTIFACT), sealed.manifest);
+    await writeArchitectureMapCapsule(input.dir, sealed.capsule.text);
+    return { ok: true, baselinePath };
+}
+export async function ensureArchitectureMapReviewArtifacts(input) {
+    const reviewPath = path.join(input.dir, ARCHITECTURE_MAP_REVIEW_ARTIFACT);
+    if (await exists(reviewPath))
+        return { ok: true, reviewPath };
+    const baselinePath = path.join(input.dir, ARCHITECTURE_MAP_BASELINE_ARTIFACT);
+    if (!(await exists(baselinePath))) {
+        return { ok: false, reason: 'architecture_map_baseline_missing' };
+    }
+    const baseline = await readJson(baselinePath, null);
+    if (!baseline)
+        return { ok: false, reason: 'architecture_map_baseline_unreadable' };
+    const load = await readContextGraphSnapshot(input.root);
+    if (load.status !== 'ok' || !load.snapshot) {
+        return { ok: false, reason: load.blocker || 'architecture_map_graph_unavailable' };
+    }
+    const built = buildAfterReview({
+        missionId: input.missionId,
+        ...(input.routeId ? { routeId: input.routeId } : {}),
+        baseline,
+        afterSnapshot: load.snapshot,
+        policyRoot: input.root,
+        generatedAt: nowIso()
+    });
+    await fsp.mkdir(input.dir, { recursive: true });
+    await writeJsonAtomic(reviewPath, built.review);
+    await writeJsonAtomic(path.join(input.dir, ARCHITECTURE_MAP_MANIFEST_ARTIFACT), built.manifest);
+    await writeArchitectureMapCapsule(input.dir, built.capsule.text);
+    await writeJsonAtomic(path.join(input.dir, 'architecture-map-delta.json'), built.delta);
+    return { ok: true, reviewPath };
+}
+export async function architectureMapGateStatus(root, state = {}) {
+    if (state?.architecture_map_required !== true)
+        return { ok: true, blockers: [] };
+    const missionId = state?.mission_id;
+    if (!missionId)
+        return { ok: false, blockers: ['architecture_map_mission_missing'] };
+    const dir = path.join(root, '.sneakoscope/missions', missionId);
+    const plan = await readJson(path.join(dir, 'pipeline-plan.json'), null);
+    if (!plan?.architecture_map)
+        return { ok: true, blockers: [], not_applicable: true };
+    if (await exists(path.join(dir, ARCHITECTURE_MAP_BASELINE_ARTIFACT))) {
+        await ensureArchitectureMapReviewArtifacts({
+            root,
+            dir,
+            missionId,
+            routeId: String(plan?.route?.id || state?.route || '')
+        });
+    }
+    const blockers = [];
+    const baselinePath = path.join(dir, ARCHITECTURE_MAP_BASELINE_ARTIFACT);
+    const reviewPath = path.join(dir, ARCHITECTURE_MAP_REVIEW_ARTIFACT);
+    if (!(await exists(baselinePath))) {
+        blockers.push('architecture_map_baseline_missing');
+    }
+    else {
+        const baseline = await readJson(baselinePath, null);
+        const validation = validateArchitectureMapBaselineArtifact(baseline);
+        if (!validation.ok)
+            blockers.push('architecture_map_baseline_invalid', ...validation.blockers.map((b) => `baseline:${b}`));
+        else {
+            const binding = bindArchitectureMapBaseline({ baseline: baseline, missionId });
+            if (!binding.ok)
+                blockers.push(...binding.blockers.map((b) => `architecture_map_baseline_${b}`));
+            if (baseline && baseline.capturedBeforeMutation !== true)
+                blockers.push('architecture_map_baseline_late');
+        }
+    }
+    if (!(await exists(reviewPath))) {
+        blockers.push('architecture_map_review_missing');
+    }
+    else {
+        const review = await readJson(reviewPath, null);
+        const validation = validateArchitectureMapReviewArtifact(review);
+        if (!validation.ok)
+            blockers.push('architecture_map_review_invalid', ...validation.blockers.map((b) => `review:${b}`));
+        else if (review?.verdict !== 'pass') {
+            blockers.push('architecture_map_review_blocked');
+            if (Array.isArray(review?.unaccountedChangedPaths) && review.unaccountedChangedPaths.length) {
+                blockers.push('architecture_map_unaccounted_changed_file');
+            }
+            for (const id of review?.blockingFindingIds || [])
+                blockers.push(`architecture_map_finding:${id}`);
+        }
+    }
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
+}
+export async function writeArchitectureMapCapsule(dir, text) {
+    const file = path.join(dir, ARCHITECTURE_CAPSULE_ARTIFACT);
+    await fsp.mkdir(dir, { recursive: true });
+    await fsp.writeFile(file, text.endsWith('\n') ? text : `${text}\n`, 'utf8');
+    return file;
+}

package/dist/core/architecture-map-review.js

@@ -0,0 +1,180 @@
+import { sha256 } from './fsx.js';
+import { ARCHITECTURE_BASELINE_SCHEMA, ARCHITECTURE_MAP_MANIFEST_SCHEMA, ARCHITECTURE_REVIEW_SCHEMA } from './triwiki/context-graph/architecture/contracts.js';
+import { buildArchitectureBaseline, verifyArchitectureBaselineSeal } from './triwiki/context-graph/architecture/baseline.js';
+import { renderArchitectureCapsule } from './triwiki/context-graph/architecture/capsule.js';
+import { buildArchitectureDelta, buildArchitectureReview } from './triwiki/context-graph/architecture/delta.js';
+import { buildArchitectureInputBundle, policyContentHash } from './triwiki/context-graph/architecture/input-bundle.js';
+import { loadArchitectureMapPolicy } from './triwiki/context-graph/architecture/policy.js';
+import { buildArchitectureScope } from './triwiki/context-graph/architecture/slice.js';
+import { validateArchitectureBaseline, validateArchitectureInputBundle, validateArchitectureMapManifest, validateArchitectureReview } from './triwiki/context-graph/architecture/validation.js';
+import { buildArchitectureMapManifest, buildArchitectureMapViews } from './triwiki/context-graph/projections/mermaid/index.js';
+export const ARCHITECTURE_MAP_BASELINE_ARTIFACT = 'architecture-map-baseline.json';
+export const ARCHITECTURE_MAP_REVIEW_ARTIFACT = 'architecture-map-review.json';
+export const ARCHITECTURE_CAPSULE_ARTIFACT = 'architecture-capsule.txt';
+export const ARCHITECTURE_MAP_MANIFEST_ARTIFACT = 'architecture-map-manifest.json';
+export const ARCHITECTURE_MAP_REVIEW_SCHEMA = ARCHITECTURE_REVIEW_SCHEMA;
+export const ARCHITECTURE_MAP_BASELINE_SCHEMA = ARCHITECTURE_BASELINE_SCHEMA;
+export const ARCHITECTURE_MAP_MANIFEST_SCHEMA_ID = ARCHITECTURE_MAP_MANIFEST_SCHEMA;
+export function resolveArchitectureMapPolicy(input) {
+    if (input.policy)
+        return input.policy;
+    if (input.policyRoot)
+        return loadArchitectureMapPolicy(input.policyRoot);
+    throw new Error('architecture_map_policy_required');
+}
+export function sealBaseline(input) {
+    const policy = resolveArchitectureMapPolicy(input);
+    const rootId = input.rootId ?? 'workspace';
+    const profile = input.profile ?? 'global';
+    const bundle = buildArchitectureInputBundle({
+        rootId,
+        graph: input.snapshot,
+        policy,
+        profile
+    });
+    const views = buildArchitectureMapViews(input.snapshot, policy, {
+        rootId,
+        missionId: input.missionId
+    });
+    const viewHashes = Object.freeze(Object.fromEntries(views.views.map((view) => [view.viewId, view.projection.contentHash])));
+    const scope = buildArchitectureScope({
+        profile,
+        ...(input.seedNodeIds ? { seedNodeIds: input.seedNodeIds } : {}),
+        ...(input.seedPaths ? { seedPaths: input.seedPaths } : {})
+    });
+    const baseline = buildArchitectureBaseline({
+        missionId: input.missionId,
+        routeId: input.routeId,
+        taskProfile: input.taskProfile ?? profile,
+        capturedAt: input.capturedAt,
+        bundle,
+        policy,
+        scope,
+        viewHashes,
+        findings: views.findings,
+        metrics: views.metrics
+    });
+    const capsule = renderArchitectureCapsule({
+        profile,
+        missionId: input.missionId,
+        routeId: input.routeId,
+        baseline,
+        metrics: views.metrics,
+        findings: views.findings,
+        ...(input.seedPaths ? { seedPaths: input.seedPaths } : {}),
+        mapArtifact: ARCHITECTURE_MAP_MANIFEST_ARTIFACT
+    });
+    return Object.freeze({
+        baseline,
+        bundle,
+        manifest: views.manifest,
+        capsule,
+        policy
+    });
+}
+export function buildAfterReview(input) {
+    const policy = resolveArchitectureMapPolicy(input);
+    const rootId = input.rootId ?? 'workspace';
+    const profile = input.profile ?? input.baseline.scope.profile;
+    const afterBundle = buildArchitectureInputBundle({
+        rootId,
+        graph: input.afterSnapshot,
+        policy,
+        profile,
+        policyHash: policyContentHash(policy)
+    });
+    const views = buildArchitectureMapViews(input.afterSnapshot, policy, {
+        rootId,
+        missionId: input.missionId
+    });
+    const projectionAccounting = Object.freeze(Object.fromEntries(views.views.map((view) => [
+        view.viewId,
+        {
+            selectedNodeCount: view.projection.accounting.selectedNodeIds.length,
+            emittedNodeCount: view.projection.accounting.emittedNodeIds.length,
+            omittedNodeCount: view.projection.accounting.omittedNodes.length,
+            selectedEdgeCount: view.projection.accounting.selectedEdgeIds.length,
+            emittedEdgeCount: view.projection.accounting.emittedEdgeIds.length,
+            omittedEdgeCount: view.projection.accounting.omittedEdges.length,
+            accountingRatio: view.projection.accounting.selectedNodeIds.length === 0
+                ? 1
+                : view.projection.accounting.emittedNodeIds.length /
+                    view.projection.accounting.selectedNodeIds.length
+        }
+    ])));
+    const review = buildArchitectureReview({
+        missionId: input.missionId,
+        baseline: input.baseline,
+        afterBundle,
+        policy,
+        generatedAt: input.generatedAt,
+        projectionAccounting,
+        ...(input.accountedChangedPaths
+            ? { accountedChangedPaths: input.accountedChangedPaths }
+            : {})
+    });
+    const delta = buildArchitectureDelta({
+        missionId: input.missionId,
+        baseline: input.baseline,
+        afterBundle,
+        policy
+    });
+    const capsule = renderArchitectureCapsule({
+        profile,
+        missionId: input.missionId,
+        ...(input.routeId ? { routeId: input.routeId } : {}),
+        baseline: input.baseline,
+        metrics: views.metrics,
+        findings: views.findings,
+        mapArtifact: 'architecture-map-delta.mmd'
+    });
+    return Object.freeze({
+        review,
+        delta,
+        afterBundle,
+        manifest: views.manifest,
+        capsule,
+        policy
+    });
+}
+export function validateArchitectureMapBaselineArtifact(value) {
+    return validateArchitectureBaseline(value);
+}
+export function validateArchitectureMapReviewArtifact(value) {
+    return validateArchitectureReview(value);
+}
+export function validateArchitectureMapManifestArtifact(value) {
+    return validateArchitectureMapManifest(value);
+}
+export function validateArchitectureMapInputBundleArtifact(value) {
+    return validateArchitectureInputBundle(value);
+}
+export function bindArchitectureMapBaseline(input) {
+    const validation = validateArchitectureBaseline(input.baseline);
+    const blockers = [...validation.blockers];
+    if (input.baseline.missionId !== input.missionId)
+        blockers.push('mission_mismatch');
+    if (!verifyArchitectureBaselineSeal(input.baseline))
+        blockers.push('seal_mismatch');
+    if (blockers.length)
+        return { ok: false, blockers, binding: null };
+    return {
+        ok: true,
+        blockers: [],
+        binding: {
+            missionId: input.baseline.missionId,
+            seal: input.baseline.seal,
+            canonicalPayloadHash: input.baseline.canonicalPayloadHash,
+            policyHash: input.baseline.policyHash,
+            graphHash: input.baseline.graphHash,
+            worktreeFingerprintHash: input.baseline.worktreeFingerprintHash
+        }
+    };
+}
+export function architectureMapReviewDigest(review) {
+    return sha256(JSON.stringify(review ?? null));
+}
+export function architectureMapBaselineDigest(baseline) {
+    return sha256(JSON.stringify(baseline ?? null));
+}
+export { buildArchitectureMapManifest, buildArchitectureMapViews };

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-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,