@mindexec/cli 0.2.436 → 0.2.438

package/codex-model-catalog.js

@@ -0,0 +1,202 @@
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+const DEFAULT_CACHE_TTL_MS = 15 * 60 * 1000;
+const DEFAULT_FAILURE_CACHE_TTL_MS = 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 20 * 1000;
+const DEFAULT_MAX_BUFFER = 16 * 1024 * 1024;
+
+function getPathEnvironmentKey(env) {
+    return Object.keys(env).find(key => key.toLowerCase() === 'path') || 'PATH';
+}
+
+function isPackageBinPath(value) {
+    const normalized = path.normalize(String(value || '').trim()).replace(/[\\/]+$/, '');
+    return /[\\/]node_modules[\\/]\.bin$/i.test(normalized);
+}
+
+/**
+ * The LocalBridge npm package carries a version-pinned Codex CLI through
+ * @openai/codex-sdk. That CLI is the execution runtime, but it must not shadow
+ * the user's newer installed Codex CLI when resolving the authoritative model
+ * catalog.
+ */
+export function buildExternalCodexCatalogEnv(sourceEnv = process.env) {
+    const env = { ...sourceEnv };
+    const pathKey = getPathEnvironmentKey(env);
+    const pathValue = String(env[pathKey] || '');
+    env[pathKey] = pathValue
+        .split(path.delimiter)
+        .map(item => item.trim())
+        .filter(Boolean)
+        .filter(item => !isPackageBinPath(item))
+        .join(path.delimiter);
+    return env;
+}
+
+export function normalizeCodexDebugModel(item) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
+
+    const id = String(item.slug || '').trim();
+    if (!id || String(item.visibility || '').toLowerCase() !== 'list') {
+        return null;
+    }
+
+    return {
+        id,
+        displayName: String(item.display_name || id).trim(),
+        description: String(item.description || '').trim(),
+        priority: Number.isFinite(Number(item.priority)) ? Number(item.priority) : 999,
+        defaultReasoningLevel: String(item.default_reasoning_level || '').trim(),
+        supportedReasoningLevels: Array.isArray(item.supported_reasoning_levels)
+            ? item.supported_reasoning_levels
+                .map(level => String(level?.effort || '').trim())
+                .filter(Boolean)
+            : [],
+        supportedInApi: Boolean(item.supported_in_api)
+    };
+}
+
+function parseCodexDebugModels(stdout) {
+    const parsed = JSON.parse(String(stdout || '{}'));
+    const models = Array.isArray(parsed.models)
+        ? parsed.models
+            .map(normalizeCodexDebugModel)
+            .filter(Boolean)
+            .sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id))
+        : [];
+
+    if (models.length === 0) {
+        throw new Error('Codex live model catalog returned no list-visible models.');
+    }
+
+    return models;
+}
+
+function formatAttemptError(error) {
+    const message = String(error?.stderr || error?.message || error || 'unknown-error').trim();
+    return message.length > 1200 ? `${message.slice(0, 1200)}...` : message;
+}
+
+/**
+ * Contract:
+ * - `forceRefresh` always bypasses the completed-result TTL.
+ * - Concurrent refreshes share one authoritative CLI request sequence.
+ * - The user's external Codex CLI is tried before the SDK-pinned package CLI.
+ * - A failed refresh never replaces a previously verified non-empty catalog.
+ */
+export function createCodexModelCatalog(options = {}) {
+    const execute = options.execute || execAsync;
+    const sourceEnv = options.env || process.env;
+    const packageRoot = options.packageRoot || process.cwd();
+    const cacheTtlMs = Number(options.cacheTtlMs) > 0
+        ? Number(options.cacheTtlMs)
+        : DEFAULT_CACHE_TTL_MS;
+    const failureCacheTtlMs = Number(options.failureCacheTtlMs) > 0
+        ? Number(options.failureCacheTtlMs)
+        : DEFAULT_FAILURE_CACHE_TTL_MS;
+    const timeoutMs = Number(options.timeoutMs) > 0
+        ? Number(options.timeoutMs)
+        : DEFAULT_TIMEOUT_MS;
+    const now = typeof options.now === 'function' ? options.now : Date.now;
+
+    let cachedCatalog = null;
+    let cachedCatalogExpiresAt = 0;
+    let refreshPromise = null;
+
+    async function refresh() {
+        const attemptedAtMs = now();
+        const attemptedAt = new Date(attemptedAtMs).toISOString();
+        const attempts = [
+            {
+                commandSource: 'external',
+                command: 'codex debug models',
+                env: buildExternalCodexCatalogEnv(sourceEnv)
+            },
+            {
+                commandSource: 'package-local',
+                // Older SDK-pinned CLIs may not understand a newer configured
+                // reasoning level. The catalog itself is independent of this
+                // preference, so use a broadly supported value for fallback.
+                command: 'codex debug models --config model_reasoning_effort=high',
+                env: { ...sourceEnv }
+            }
+        ];
+        const attemptErrors = [];
+
+        for (const attempt of attempts) {
+            try {
+                const { stdout } = await execute(attempt.command, {
+                    cwd: packageRoot,
+                    env: attempt.env,
+                    timeout: timeoutMs,
+                    maxBuffer: DEFAULT_MAX_BUFFER,
+                    windowsHide: true
+                });
+                const models = parseCodexDebugModels(stdout);
+                cachedCatalog = {
+                    source: 'codex debug models',
+                    commandSource: attempt.commandSource,
+                    updatedAt: attemptedAt,
+                    refreshAttemptedAt: attemptedAt,
+                    stale: false,
+                    error: null,
+                    models
+                };
+                cachedCatalogExpiresAt = attemptedAtMs + cacheTtlMs;
+                return cachedCatalog;
+            } catch (error) {
+                attemptErrors.push(`${attempt.commandSource}: ${formatAttemptError(error)}`);
+            }
+        }
+
+        const error = attemptErrors.join(' | ');
+        cachedCatalogExpiresAt = attemptedAtMs + failureCacheTtlMs;
+        if (cachedCatalog?.models?.length > 0) {
+            cachedCatalog = {
+                ...cachedCatalog,
+                refreshAttemptedAt: attemptedAt,
+                stale: true,
+                error
+            };
+            return cachedCatalog;
+        }
+
+        cachedCatalog = {
+            source: 'codex debug models',
+            commandSource: null,
+            updatedAt: null,
+            refreshAttemptedAt: attemptedAt,
+            stale: true,
+            error,
+            models: []
+        };
+        return cachedCatalog;
+    }
+
+    async function getCatalog(requestOptions = {}) {
+        const forceRefresh = Boolean(requestOptions.forceRefresh);
+        if (!forceRefresh && cachedCatalog && cachedCatalogExpiresAt > now()) {
+            return cachedCatalog;
+        }
+
+        if (refreshPromise) {
+            return refreshPromise;
+        }
+
+        refreshPromise = refresh().finally(() => {
+            refreshPromise = null;
+        });
+        return refreshPromise;
+    }
+
+    return {
+        getCatalog,
+        peek: () => cachedCatalog
+    };
+}

package/codex-runtime.js

@@ -558,11 +558,11 @@ export function createCodexRuntime(options) {
     const threads = new Map();
     const activeTurns = new Map();
 
-    async function getCapabilities() {
+    async function getCapabilities(options = {}) {
         const [sdk, legacy, modelCatalog] = await Promise.all([
             checkSdkAvailability(packageRoot),
             checkLegacyAvailability(),
-            getModelCatalog()
+            getModelCatalog({ forceRefresh: Boolean(options.forceRefresh) })
         ]);
         const preferredProviderKind = sdk.available
             ? PROVIDER_KIND.typeScriptSdk
@@ -595,7 +595,10 @@ export function createCodexRuntime(options) {
             runtime: getCurrentRuntime(),
             models: modelCatalog.models || [],
             modelCatalogSource: modelCatalog.source,
+            modelCatalogCommandSource: modelCatalog.commandSource || null,
             modelCatalogUpdatedAt: modelCatalog.updatedAt,
+            modelCatalogRefreshAttemptedAt: modelCatalog.refreshAttemptedAt || null,
+            modelCatalogStale: modelCatalog.stale === true,
             modelCatalogError: modelCatalog.error || null
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.436",
+  "version": "0.2.438",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -11,6 +11,7 @@
     "server.js",
     "remote-hub.js",
     "codex-runtime.js",
+    "codex-model-catalog.js",
     "port-guard.cjs",
     "remote-fast/",
     "wwwroot/",
@@ -21,7 +22,9 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:codex-model-catalog": "node scripts/codex-model-catalog-smoke.mjs",
+    "test:codex-model-catalog:live": "node scripts/codex-model-catalog-smoke.mjs --live",
     "test:auth": "node scripts/auth-session-smoke.mjs",
     "test:remote": "node scripts/remote-hub-smoke.mjs",
     "test:remote:scale": "node scripts/remote-hub-scale-smoke.mjs",
@@ -57,7 +60,7 @@
   },
   "dependencies": {
     "@mindexec/remote": "^0.1.17",
-    "@openai/codex-sdk": "^0.137.0",
+    "@openai/codex-sdk": "^0.144.1",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",
     "express": "^4.18.2",

package/scripts/codex-model-catalog-smoke.mjs

@@ -0,0 +1,150 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+    buildExternalCodexCatalogEnv,
+    createCodexModelCatalog
+} from '../codex-model-catalog.js';
+
+function catalogJson(models) {
+    return JSON.stringify({ models });
+}
+
+function listed(slug, priority, displayName = slug) {
+    return {
+        slug,
+        display_name: displayName,
+        visibility: 'list',
+        priority,
+        supported_in_api: true,
+        supported_reasoning_levels: [{ effort: 'medium' }, { effort: 'high' }]
+    };
+}
+
+async function testExternalPathWinsAndForceRefreshBypassesCache() {
+    const packageBin = path.join('C:', 'tmp', 'package', 'node_modules', '.bin');
+    const globalBin = path.join('C:', 'tools', 'codex');
+    const env = { PATH: [packageBin, globalBin].join(path.delimiter) };
+    const externalEnv = buildExternalCodexCatalogEnv(env);
+    assert.equal(externalEnv.PATH.includes('node_modules'), false);
+    assert.equal(externalEnv.PATH.includes(globalBin), true);
+
+    let calls = 0;
+    const execute = async (command, options) => {
+        calls += 1;
+        assert.equal(command, 'codex debug models');
+        assert.equal(String(options.env.PATH).includes('node_modules'), false);
+        const current = calls === 1 ? 'gpt-current-a' : 'gpt-current-b';
+        return {
+            stdout: catalogJson([
+                listed('hidden-model', 0),
+                listed(current, 1, current.toUpperCase()),
+                { ...listed('not-listed', 2), visibility: 'hide' }
+            ]),
+            stderr: ''
+        };
+    };
+    const catalog = createCodexModelCatalog({ execute, env, packageRoot: process.cwd() });
+
+    const first = await catalog.getCatalog();
+    const cached = await catalog.getCatalog();
+    assert.equal(calls, 1);
+    assert.strictEqual(cached, first);
+    assert.deepEqual(first.models.map(model => model.id), ['hidden-model', 'gpt-current-a']);
+    assert.equal(first.commandSource, 'external');
+    assert.equal(first.stale, false);
+
+    const refreshed = await catalog.getCatalog({ forceRefresh: true });
+    assert.equal(calls, 2);
+    assert.deepEqual(refreshed.models.map(model => model.id), ['hidden-model', 'gpt-current-b']);
+}
+
+async function testConcurrentRefreshIsSingleFlight() {
+    let calls = 0;
+    let release;
+    const gate = new Promise(resolve => {
+        release = resolve;
+    });
+    const catalog = createCodexModelCatalog({
+        execute: async () => {
+            calls += 1;
+            await gate;
+            return { stdout: catalogJson([listed('gpt-concurrent', 1)]), stderr: '' };
+        }
+    });
+
+    const first = catalog.getCatalog({ forceRefresh: true });
+    const second = catalog.getCatalog({ forceRefresh: true });
+    await Promise.resolve();
+    assert.equal(calls, 1);
+    release();
+    const [firstResult, secondResult] = await Promise.all([first, second]);
+    assert.strictEqual(firstResult, secondResult);
+    assert.equal(calls, 1);
+}
+
+async function testPackageFallbackNormalizesNewerConfigPreference() {
+    const commands = [];
+    const catalog = createCodexModelCatalog({
+        execute: async command => {
+            commands.push(command);
+            if (commands.length === 1) {
+                throw new Error('external Codex CLI unavailable');
+            }
+
+            return { stdout: catalogJson([listed('gpt-package-fallback', 1)]), stderr: '' };
+        }
+    });
+
+    const result = await catalog.getCatalog({ forceRefresh: true });
+    assert.equal(commands.length, 2);
+    assert.match(commands[1], /model_reasoning_effort=high/);
+    assert.equal(result.commandSource, 'package-local');
+    assert.deepEqual(result.models.map(model => model.id), ['gpt-package-fallback']);
+}
+
+async function testFailedRefreshPreservesLastVerifiedCatalog() {
+    let shouldFail = false;
+    const catalog = createCodexModelCatalog({
+        execute: async () => {
+            if (shouldFail) {
+                throw new Error('temporary catalog failure');
+            }
+
+            return { stdout: catalogJson([listed('gpt-last-known-good', 1)]), stderr: '' };
+        }
+    });
+
+    const verified = await catalog.getCatalog({ forceRefresh: true });
+    shouldFail = true;
+    const stale = await catalog.getCatalog({ forceRefresh: true });
+    assert.deepEqual(stale.models, verified.models);
+    assert.equal(stale.updatedAt, verified.updatedAt);
+    assert.equal(stale.stale, true);
+    assert.match(stale.error, /external:.*temporary catalog failure/);
+    assert.match(stale.error, /package-local:.*temporary catalog failure/);
+}
+
+async function runDeterministicSmoke() {
+    await testExternalPathWinsAndForceRefreshBypassesCache();
+    await testConcurrentRefreshIsSingleFlight();
+    await testPackageFallbackNormalizesNewerConfigPreference();
+    await testFailedRefreshPreservesLastVerifiedCatalog();
+    console.log('[codex-model-catalog-smoke] deterministic catalog contracts passed');
+}
+
+async function runLiveSmoke() {
+    const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+    const catalog = createCodexModelCatalog({ packageRoot: path.resolve(scriptDirectory, '..') });
+    const result = await catalog.getCatalog({ forceRefresh: true });
+    assert.ok(result.models.length > 0, result.error || 'expected a non-empty live Codex catalog');
+    assert.equal(result.commandSource, 'external');
+    assert.equal(result.stale, false);
+    console.log(`[codex-model-catalog-smoke] live ${result.source} (${result.commandSource}): ${result.models.map(model => model.id).join(', ')}`);
+}
+
+if (process.argv.includes('--live')) {
+    await runLiveSmoke();
+} else {
+    await runDeterministicSmoke();
+}

package/server.js

@@ -22,6 +22,7 @@ import chokidar from 'chokidar';
 import Parser from 'web-tree-sitter';
 import { fileURLToPath } from 'url';
 import { createCodexRuntime } from './codex-runtime.js';
+import { createCodexModelCatalog } from './codex-model-catalog.js';
 import { createRemoteHub } from './remote-hub.js';
 import portGuard from './port-guard.cjs';
 
@@ -3167,14 +3168,14 @@ function extractCodexOutputPath(command) {
     return match[2] || match[3] || match[4] || null;
 }
 
-const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
-const CODEX_MODEL_CATALOG_TTL_MS = 15 * 60 * 1000;
-let cachedCodexConfig = null;
-let cachedCodexConfigMtimeMs = -1;
-let cachedCodexModelCatalog = null;
-let cachedCodexModelCatalogExpiresAt = 0;
+const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
+let cachedCodexConfig = null;
+let cachedCodexConfigMtimeMs = -1;
 let lastCodexExecRuntime = null;
 let codexRuntime = null;
+const codexModelCatalog = createCodexModelCatalog({
+    packageRoot: BRIDGE_ROOT
+});
 
 function readCodexConfig(options = {}) {
     const forceRefresh = Boolean(options.forceRefresh);
@@ -3281,68 +3282,17 @@ function formatCodexRuntime(runtime) {
     return parts.join(' ??');
 }
 
-function normalizeCodexDebugModel(item) {
-    if (!item || typeof item !== 'object') {
-        return null;
-    }
-
-    const id = String(item.slug || '').trim();
-    if (!id || String(item.visibility || '').toLowerCase() !== 'list') {
-        return null;
-    }
-
-    return {
-        id,
-        displayName: String(item.display_name || id).trim(),
-        description: String(item.description || '').trim(),
-        priority: Number.isFinite(Number(item.priority)) ? Number(item.priority) : 999,
-        defaultReasoningLevel: String(item.default_reasoning_level || '').trim(),
-        supportedReasoningLevels: Array.isArray(item.supported_reasoning_levels)
-            ? item.supported_reasoning_levels
-                .map(level => String(level?.effort || '').trim())
-                .filter(Boolean)
-            : [],
-        supportedInApi: Boolean(item.supported_in_api)
-    };
-}
-
 async function getCodexModelCatalog(options = {}) {
-    const now = Date.now();
-    if (!options.forceRefresh && cachedCodexModelCatalog && cachedCodexModelCatalogExpiresAt > now) {
-        return cachedCodexModelCatalog;
-    }
-
-    try {
-        const { stdout } = await execAsync('codex debug models', {
-            timeout: 10000,
-            maxBuffer: 16 * 1024 * 1024,
-            windowsHide: true
-        });
-        const parsed = JSON.parse(String(stdout || '{}'));
-        const models = Array.isArray(parsed.models)
-            ? parsed.models
-                .map(normalizeCodexDebugModel)
-                .filter(Boolean)
-                .sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id))
-            : [];
-
-        cachedCodexModelCatalog = {
-            source: 'codex debug models',
-            updatedAt: new Date().toISOString(),
-            models
-        };
-        cachedCodexModelCatalogExpiresAt = now + CODEX_MODEL_CATALOG_TTL_MS;
-        return cachedCodexModelCatalog;
-    } catch (err) {
-        cachedCodexModelCatalog = {
-            source: 'codex debug models',
-            updatedAt: new Date().toISOString(),
-            error: err?.message || String(err),
-            models: []
-        };
-        cachedCodexModelCatalogExpiresAt = now + Math.min(CODEX_MODEL_CATALOG_TTL_MS, 60 * 1000);
-        return cachedCodexModelCatalog;
+    return await codexModelCatalog.getCatalog(options);
+}
+
+function shouldForceCodexCatalogRefresh(value, defaultValue = true) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    if (!normalized) {
+        return defaultValue;
     }
+
+    return !['0', 'false', 'no', 'off', 'cache', 'cached'].includes(normalized);
 }
 
 function getCodexRuntime() {
@@ -12426,7 +12376,10 @@ app.get('/api/status', async (req, res) => {
     res.setHeader('Pragma', 'no-cache');
     res.setHeader('Expires', '0');
 
-    const forceRefresh = ['1', 'true', 'yes', 'force'].includes(String(req.query.refresh || '').trim().toLowerCase());
+    // `/api/status` is the LocalBridge connection handshake used by browser and
+    // app clients. Refresh the authoritative Codex catalog for every handshake;
+    // callers doing a non-connection diagnostic poll can opt into `refresh=cache`.
+    const forceRefresh = shouldForceCodexCatalogRefresh(req.query.refresh, true);
     const currentCodexRuntime = getCurrentCodexRuntime({
         forceRefresh,
         forceConfigRefresh: forceRefresh
@@ -12478,7 +12431,10 @@ app.get('/api/status', async (req, res) => {
             preferredProviderKind: codexCapabilities.preferredProviderKind,
             availableModels: codexModelCatalog.models,
             modelCatalogSource: codexModelCatalog.source,
+            modelCatalogCommandSource: codexModelCatalog.commandSource,
             modelCatalogUpdatedAt: codexModelCatalog.updatedAt,
+            modelCatalogRefreshAttemptedAt: codexModelCatalog.refreshAttemptedAt,
+            modelCatalogStale: codexModelCatalog.stale === true,
             modelCatalogError: codexModelCatalog.error
         },
         codex: {
@@ -12865,7 +12821,9 @@ app.post('/api/remote/devices/:deviceId/live/stop', (req, res) => {
 
 app.get('/api/codex/capabilities', async (req, res) => {
     try {
-        res.json(await getCodexRuntime().getCapabilities());
+        res.setHeader('Cache-Control', 'no-store, no-cache, max-age=0, must-revalidate');
+        const forceRefresh = shouldForceCodexCatalogRefresh(req.query.refresh, true);
+        res.json(await getCodexRuntime().getCapabilities({ forceRefresh }));
     } catch (err) {
         console.error('[Codex/Capabilities] Error:', err);
         res.status(500).json({
@@ -14285,13 +14243,21 @@ async function startBridgeServer() {
             logError('workspace', 'failed to initialize .mindexec layout.', layoutErr);
         }
 
-        const startupCodexRuntime = getCurrentCodexRuntime();
+        const startupCodexRuntime = getCurrentCodexRuntime({
+            forceRefresh: true,
+            forceConfigRefresh: true
+        });
+        const startupCodexCatalog = await getCodexModelCatalog({ forceRefresh: true });
+        if (startupCodexCatalog.error) {
+            logWarn('codex', `model catalog refresh issue ${shortenText(startupCodexCatalog.error, 320)}`);
+        }
         const remoteHubStatus = remoteHub.getStatus({ includeSecrets: true });
         logSection('MindExec Local Bridge', [
             formatKeyValue('port', tone(PORT, 'accent')),
             formatKeyValue('workspace', tone(normalizePathForClient(workspacePath), 'path')),
             formatKeyValue('status', tone('ready', 'success')),
             formatKeyValue('exec', tone(formatCodexRuntime(startupCodexRuntime), 'accent')),
+            formatKeyValue('codexModels', startupCodexCatalog.models?.length || 0),
             formatKeyValue('remote', remoteHubStatus.started
                 ? tone(`tcp://${remoteHubStatus.host}:${remoteHubStatus.port}`, 'accent')
                 : tone(remoteHubStatus.enabled ? 'failed' : 'disabled', 'warn')),