sneakoscope 6.0.2 → 6.1.0

package/dist/cli/router.js

@@ -80,6 +80,16 @@ async function dispatchInner(argv) {
     if (!helpRequest) {
         const commandGate = await ensureActiveRouteCommandGate(command, rest);
         if (!commandGate.ok) {
+            if ('command_result' in commandGate && commandGate.command_result) {
+                process.exitCode = 1;
+                if (argv.includes('--json'))
+                    console.log(JSON.stringify(commandGate.command_result, null, 2));
+                else
+                    printHandledCommandBlock(commandGate.command_result);
+                return commandGate.command_result;
+            }
+            if (argv.includes('--json'))
+                console.log(JSON.stringify(commandGate, null, 2));
             console.error(commandGate.message);
             process.exitCode = 1;
             return commandGate;
@@ -92,7 +102,7 @@ async function dispatchInner(argv) {
         const migrationGate = await ensureCurrentMigrationBeforeCommand({
             command,
             args: rest,
-            skipMigrationGate: entry.skipMigrationGate === true || entry.readonly === true
+            skipMigrationGate: entry.skipMigrationGate === true || entry.readonly === true || safeActiveRouteVisualQuery(command, rest)
         });
         if (!migrationGate.ok) {
             console.error('SKS project migration blocked.');
@@ -106,6 +116,8 @@ async function dispatchInner(argv) {
                 console.error(`Optional warning: ${warning}`);
             console.error(`Receipt: ${migrationGate.receipt_path}`);
             console.error('Remedies: run `sks doctor --fix --yes`, then retry; diagnostics that must bypass this gate are marked skipMigrationGate in the command registry.');
+            if (argv.includes('--json'))
+                console.log(JSON.stringify(migrationGate, null, 2));
             process.exitCode = 1;
             return migrationGate;
         }
@@ -136,9 +148,10 @@ async function ensureActiveRouteCommandGate(command, args) {
         return { ok: true, status: 'allowed' };
     if (safeReadOnlySubcommand(args))
         return { ok: true, status: 'allowed_status_subcommand' };
-    if (process.env.SKS_TEST_ISOLATION === '1' && process.env.SKS_RELEASE_FIXTURE_ACTIVE_ROUTE_BYPASS === '1') {
-        return { ok: true, status: 'allowed_release_fixture_isolation' };
-    }
+    if (safeActiveRouteVisualQuery(command, args))
+        return { ok: true, status: 'allowed_visual_query' };
+    if (safeActiveRouteRecoverySubcommand(command, args))
+        return { ok: true, status: 'allowed_active_route_recovery' };
     const [{ projectRoot, readJson }, { stateFile }] = await Promise.all([
         import('../core/fsx.js'),
         import('../core/mission.js')
@@ -147,6 +160,14 @@ async function ensureActiveRouteCommandGate(command, args) {
     const state = await readJson(stateFile(root), {}).catch(() => ({}));
     if (!activeRouteStateBlocksCommand(state))
         return { ok: true, status: 'allowed' };
+    const visualPreflight = await blockedVisualSourcePreflight(command, args);
+    if (visualPreflight) {
+        return {
+            ok: false,
+            status: 'handled_non_mutating_visual_preflight',
+            command_result: visualPreflight
+        };
+    }
     return {
         schema: 'sks.command-gate-active-route.v1',
         ok: false,
@@ -158,12 +179,40 @@ async function ensureActiveRouteCommandGate(command, args) {
         message: `SKS command gate blocked '${command}' because active route mission ${state.mission_id} is not closed. Run: sks route close --mission ${state.mission_id}`
     };
 }
+function safeActiveRouteVisualQuery(command, args) {
+    if (command !== 'computer-use')
+        return false;
+    const sub = String(args.find((arg) => !String(arg).startsWith('-')) || '').toLowerCase();
+    if (sub !== 'require')
+        return false;
+    return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
+}
+async function blockedVisualSourcePreflight(command, args) {
+    if (command !== 'image-ux-review' || String(args[0] || '').toLowerCase() !== 'run')
+        return null;
+    if (!args.includes('--from-chrome-extension') && !args.includes('--from-computer-use'))
+        return null;
+    const { imageUxReviewSourcePreflight } = await import('../core/commands/image-ux-review-command.js');
+    const preflight = await imageUxReviewSourcePreflight([...args.slice(1)]);
+    return preflight.result;
+}
+function printHandledCommandBlock(result) {
+    console.error(`SKS command blocked: ${result?.blocker || result?.status || 'preflight_failed'}`);
+    for (const line of Array.isArray(result?.guidance) ? result.guidance : [])
+        console.error(`- ${line}`);
+}
 function safeReadOnlySubcommand(args) {
     const sub = String(args.find((arg) => !String(arg).startsWith('-')) || '').toLowerCase();
     if (!['status', 'show', 'list', 'observe', 'watch', 'doctor', 'help'].includes(sub))
         return false;
     return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
 }
+function safeActiveRouteRecoverySubcommand(command, args) {
+    if (command !== 'agent')
+        return false;
+    const sub = String(args.find((arg) => !String(arg).startsWith('-')) || '').toLowerCase();
+    return ['close', 'cleanup', 'rollback-patches'].includes(sub);
+}
 function activeRouteStateBlocksCommand(state = {}) {
     if (!state?.mission_id || state.route_closed === true)
         return false;

package/dist/commands/codex-app.js

@@ -12,8 +12,11 @@ import { resolveCodexAppExecutionProfile } from '../core/codex-app/codex-app-exe
 import { repairCodexNativeManagedAssets } from '../core/codex-native/codex-native-repair-transaction.js';
 import { doctorCodexAppGlmProfile, installCodexAppGlmProfile } from '../core/codex-app/glm-profile-installer.js';
 import { promptForOpenRouterKeyHidden, writeStoredOpenRouterKey } from '../core/providers/openrouter/openrouter-secret-store.js';
+import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'check';
+    if (action === 'restart')
+        return printCodexAppResult(args, await restartCodexApp());
     if (action === 'remote-control' || action === 'remote')
         return codexAppRemoteControlCommand(args.slice(1));
     if (action === 'harness-matrix') {
@@ -47,15 +50,17 @@ export async function run(_command, args = []) {
         }
         const record = await writeStoredOpenRouterKey(key);
         const profile = await installCodexAppGlmProfile({ root, apply: true });
+        const restart = await restartCodexApp({ enabled: flag(args, '--restart-app') || flag(args, '--restart') });
         const result = {
             schema: 'sks.codex-app-openrouter-key.v1',
-            ok: profile.ok,
-            status: profile.ok ? 'stored' : 'stored_profile_blocked',
+            ok: Boolean(profile.ok && restart.ok),
+            status: !profile.ok ? 'stored_profile_blocked' : restart.ok ? 'stored' : 'stored_restart_blocked',
             key_preview: record.key_preview,
             raw_key_recorded: false,
             secret_store: 'sks-openrouter-secret-store',
             glm_profile: profile,
-            blockers: profile.blockers || [],
+            restart_app: restart,
+            blockers: [...(profile.blockers || []), ...(restart.blockers || [])],
             warnings: profile.warnings || []
         };
         return printCodexAppResult(args, result);

package/dist/commands/codex-lb.js

@@ -8,6 +8,7 @@ import { codexLbMetrics, readCodexLbCircuit, recordCodexLbHealthEvent, resetCode
 import { checkCodexLbResponseChain, codexLbStatus, configureCodexLb, formatCodexLbStatusText, releaseCodexLbAuthHold, repairCodexLbAuth, unselectCodexLbProvider } from '../cli/install-helpers.js';
 import { buildCodexLbSetupPlan, codexLbPersistenceSummary, renderCodexLbSetupPlan } from '../core/codex-lb/codex-lb-setup.js';
 import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
+import { repairCodexAppFastUi } from '../core/codex-app/codex-app-fast-ui-repair.js';
 export async function run(command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'status';
@@ -53,35 +54,43 @@ export async function run(command, args = []) {
     if (action === 'fast-check' || action === 'fast' || action === 'verify-fast') {
         const status = await codexLbStatus();
         const blocker = !status.env_key_configured ? 'missing_env_key' : !status.base_url ? 'missing_base_url' : !status.provider_contract_ok ? 'provider_contract_drift' : 'not_configured';
-        const chain = status.env_key_configured && status.base_url
-            ? await checkCodexLbResponseChain(status, { force: true, cache: false, root, fastMode: true })
-            : { ok: false, status: blocker, codex_lb: status };
+        const modelSelection = await resolveCodexLbFastCheckModel(status);
+        const chain = status.env_key_configured && status.base_url && modelSelection.model
+            ? await checkCodexLbResponseChain(status, { force: true, cache: false, root, fastMode: true, model: modelSelection.model })
+            : { ok: false, status: modelSelection.model ? blocker : 'model_unselected', codex_lb: status };
         const evidence = await fastEvidenceFromChain(chain, readOption(args, '--request-log', readOption(args, '--request-log-json', null)));
         const providerReady = status.provider_contract_ok === true;
+        const chainVerified = isCodexLbFastChainVerified(chain);
         const result = {
             schema: 'sks.codex-lb-fast-check.v1',
-            ok: Boolean(providerReady && chain.ok && evidence.fast_requested && evidence.fast_actual),
+            ok: Boolean(providerReady && chainVerified && evidence.fast_requested && evidence.fast_actual),
             status: !providerReady
                 ? 'provider_contract_drift'
-                : chain.ok
-                    ? evidence.fast_actual
-                        ? 'fast_verified'
-                        : evidence.fast_requested
-                            ? 'fast_requested_but_actual_unverified'
-                            : 'fast_not_requested'
-                    : chain.status,
+                : chain.skipped === true
+                    ? 'fast_check_chain_skipped'
+                    : chainVerified
+                        ? evidence.fast_actual
+                            ? 'fast_verified'
+                            : evidence.fast_requested
+                                ? 'fast_requested_but_actual_unverified'
+                                : 'fast_not_requested'
+                        : chain.status,
             codex_lb: status,
+            model_selection: modelSelection,
             chain,
             evidence,
             degraded_models: Array.isArray(chain.degraded_models) ? chain.degraded_models : [],
             quota_low: Boolean(chain.quota_low),
             blockers: [
                 ...(providerReady ? [] : ['codex_lb_provider_contract_drift']),
-                ...(chain.ok
-                    ? evidence.fast_actual
-                        ? []
-                        : ['codex_lb_actual_fast_service_tier_unverified']
-                    : [chain.status || blocker])
+                ...modelSelection.blockers,
+                ...(chain.skipped === true
+                    ? ['codex_lb_fast_check_chain_skipped']
+                    : chainVerified
+                        ? evidence.fast_actual
+                            ? []
+                            : [evidence.fast_requested ? 'codex_lb_actual_fast_service_tier_unverified' : 'codex_lb_fast_service_tier_not_requested']
+                        : [chain.status || blocker])
             ]
         };
         if (flag(args, '--json'))
@@ -95,11 +104,13 @@ export async function run(command, args = []) {
     }
     if (action === 'repair' || action === 'resync' || action === 'login') {
         const result = await repairCodexLbAuth();
-        if (flag(args, '--json'))
-            return printJson(result);
-        console.log(`codex-lb repair: ${result.ok ? 'ok' : result.status}`);
-        if (!result.ok)
+        const fastUi = await repairCodexAppFastUiAfterMutation(root, Boolean(result.ok));
+        const shaped = { ...result, ok: Boolean(result.ok && fastUi.ok), codex_app_fast_ui: fastUi };
+        if (!shaped.ok)
             process.exitCode = 1;
+        if (flag(args, '--json'))
+            return printJson(shaped);
+        console.log(`codex-lb repair: ${shaped.ok ? 'ok' : result.ok ? 'fast_ui_repair_failed' : result.status}`);
         return;
     }
     if (action === 'release') {
@@ -126,8 +137,10 @@ export async function run(command, args = []) {
         const host = status.base_url;
         if (!host) {
             const result = { schema: 'sks.codex-lb-set-key.v1', ok: false, status: 'not_configured' };
-            if (flag(args, '--json'))
+            if (flag(args, '--json')) {
+                process.exitCode = 1;
                 return printJson(result);
+            }
             console.error('codex-lb is not configured yet. Run: sks codex-lb setup --host <domain> --api-key-stdin');
             process.exitCode = 1;
             return;
@@ -135,43 +148,60 @@ export async function run(command, args = []) {
         const newKey = await resolveNewApiKey(args);
         if (!newKey) {
             const result = { schema: 'sks.codex-lb-set-key.v1', ok: false, status: 'missing_api_key' };
-            if (flag(args, '--json'))
+            if (flag(args, '--json')) {
+                process.exitCode = 1;
                 return printJson(result);
+            }
             console.error('No new API key provided. Run: sks codex-lb set-key --api-key-stdin   (or --api-key <key>)');
             process.exitCode = 1;
             return;
         }
         const result = await configureCodexLb({ host, apiKey: newKey, authMode: flag(args, '--preserve-auth') ? 'preserve' : 'codex-lb', forceCodexLbApiKeyAuth: !flag(args, '--preserve-auth') });
-        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok));
-        const output = { ...result, action: 'set-key', restart_app: restart };
+        const fastUi = await repairCodexAppFastUiAfterMutation(root, Boolean(result.ok));
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok && fastUi.ok));
+        const ok = Boolean(result.ok && fastUi.ok && restart?.ok !== false);
+        const output = { ...result, ok, action: 'set-key', codex_app_fast_ui: fastUi, restart_app: restart };
+        if (!ok)
+            process.exitCode = 1;
         if (flag(args, '--json'))
             return printJson(output);
         console.log(result.ok ? `codex-lb API key updated (${result.base_url || host}).` : `codex-lb key update failed: ${result.status}${result.error ? `: ${result.error}` : ''}`);
         if (restart?.status === 'restarted')
             console.log('Codex App restarted for the new codex-lb auth mode.');
-        if (!result.ok)
+        if (!ok)
             process.exitCode = 1;
         return;
     }
     if (action === 'use-codex-lb' || action === 'use-lb') {
         // Switch auth mode -> codex-lb (API key). Re-selects the provider and re-syncs auth.
         const result = await repairCodexLbAuth({ forceCodexLbApiKeyAuth: true, authMode: 'codex-lb', forceFastMode: !flag(args, '--no-fast') });
-        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok));
+        const fastUi = await repairCodexAppFastUiAfterMutation(root, Boolean(result.ok));
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok && fastUi.ok));
+        const ok = Boolean(result.ok && fastUi.ok && restart?.ok !== false);
+        const shaped = { ...result, ok, mode: 'codex-lb', codex_app_fast_ui: fastUi, restart_app: restart };
+        if (!ok)
+            process.exitCode = 1;
         if (flag(args, '--json'))
-            return printJson({ ...result, mode: 'codex-lb', restart_app: restart });
+            return printJson(shaped);
         console.log(result.ok ? 'Auth mode: codex-lb selected (API key).' : `Switch to codex-lb failed: ${result.status}${result.error ? `: ${result.error}` : ''}`);
         if (restart?.status === 'restarted')
             console.log('Codex App restarted for codex-lb auth.');
-        if (!result.ok)
+        if (!ok)
             process.exitCode = 1;
         return;
     }
     if (action === 'use-oauth' || action === 'use-chatgpt') {
         // Switch auth mode -> ChatGPT OAuth. Restores the saved OAuth login if present.
         const result = await releaseCodexLbAuthHold({ force: flag(args, '--force') });
-        const restart = await maybeRestartCodexAppForAuthSwitch(args, !['no_backup', 'auth_in_use', 'failed'].includes(result.status));
+        const authOk = !['no_backup', 'auth_in_use', 'failed'].includes(result.status);
+        const fastUi = await repairCodexAppFastUiAfterMutation(root, authOk);
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(authOk && fastUi.ok));
+        const ok = Boolean(authOk && fastUi.ok && restart?.ok !== false);
+        const shaped = { ...result, ok, mode: 'oauth', codex_app_fast_ui: fastUi, restart_app: restart };
+        if (!ok)
+            process.exitCode = 1;
         if (flag(args, '--json'))
-            return printJson({ ...result, mode: 'oauth', restart_app: restart });
+            return printJson(shaped);
         if (result.status === 'no_backup') {
             console.log('No saved ChatGPT OAuth credentials to restore. Switch to OAuth by logging in:');
             console.log('  codex login');
@@ -210,8 +240,10 @@ export async function run(command, args = []) {
                     'Or: sks codex-lb setup --host <domain> --api-key-stdin --yes'
                 ]
             };
-            if (flag(args, '--json'))
+            if (flag(args, '--json')) {
+                process.exitCode = 1;
                 return printJson(result);
+            }
             console.error('codex-lb API key is not configured.');
             console.error('Run:');
             console.error('  sks codex-lb setup');
@@ -222,6 +254,8 @@ export async function run(command, args = []) {
         }
         if (flag(args, '--plan')) {
             const result = { schema: 'sks.codex-lb-setup-plan-result.v1', ok: plan.blockers.length === 0, plan, writes: false, expected_actions: plan.expected_actions, persistence: plan.persistence };
+            if (!result.ok)
+                process.exitCode = 1;
             if (flag(args, '--json'))
                 return printJson(result);
             process.stdout.write(renderCodexLbSetupPlan(plan));
@@ -235,8 +269,10 @@ export async function run(command, args = []) {
             const confirm = (await ask('Apply this codex-lb setup plan? [y/N] ')).trim();
             if (!/^(y|yes|예|네|응)$/i.test(confirm)) {
                 const result = { schema: 'sks.codex-lb-setup.v1', ok: false, status: 'cancelled', plan, applied_actions: [] };
-                if (flag(args, '--json'))
+                if (flag(args, '--json')) {
+                    process.exitCode = 1;
                     return printJson(result);
+                }
                 console.log('codex-lb setup cancelled.');
                 process.exitCode = 1;
                 return;
@@ -291,19 +327,23 @@ export async function run(command, args = []) {
             apiKeySource: options.apiKeySource,
             allowInsecureHttp: options.allowInsecureLocalhost
         });
-        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok) && !flag(args, '--preserve-auth'));
-        const shaped = { schema: 'sks.codex-lb-setup.v1', ...result, api_key: { present: Boolean(options.apiKey), redacted: true }, env_file_chmod: '0600' };
+        const fastUi = await repairCodexAppFastUiAfterMutation(root, Boolean(result.ok));
+        const restart = await maybeRestartCodexAppForAuthSwitch(args, Boolean(result.ok && fastUi.ok) && !flag(args, '--preserve-auth'));
+        const shaped = { schema: 'sks.codex-lb-setup.v1', ...result, api_key: { present: Boolean(options.apiKey), redacted: true }, env_file_chmod: '0600', codex_app_fast_ui: fastUi };
         shaped.restart_app = restart;
         if (options.health)
             shaped.applied_actions = [...(shaped.applied_actions || []), { type: 'run_health_check', target: 'codex-lb response chain', ok: true }];
         if (options.health)
             shaped.chain_health = result.ok ? await checkCodexLbResponseChain(result, { force: true, root }) : null;
+        shaped.ok = Boolean(result.ok && fastUi.ok && restart?.ok !== false);
+        if (!shaped.ok)
+            process.exitCode = 1;
         if (flag(args, '--json'))
             return printJson(shaped);
         console.log(`codex-lb configured: ${result.base_url || result.status}`);
         if (shaped.persistence?.warning)
             console.log(`warning: ${shaped.persistence.warning}`);
-        if (!result.ok)
+        if (!shaped.ok)
             process.exitCode = 1;
         return;
     }
@@ -345,12 +385,90 @@ export async function run(command, args = []) {
 }
 async function maybeRestartCodexAppForAuthSwitch(args = [], enabled) {
     if (!enabled)
-        return { schema: 'sks.codex-app-restart.v1', ok: true, status: 'skipped', skipped: true, reason: 'previous_step_failed', app_name: 'Codex', blockers: [] };
+        return { schema: 'sks.codex-app-restart.v1', ok: true, status: 'skipped', skipped: true, reason: 'previous_step_failed', app_name: 'ChatGPT', bundle_id: 'com.openai.codex', blockers: [] };
     const requested = flag(args, '--restart-app') || flag(args, '--restart');
     const shouldRestart = requested || (!flag(args, '--json') && !flag(args, '--no-restart-app') && !flag(args, '--no-restart'));
     return restartCodexApp({ enabled: shouldRestart });
 }
-async function fastEvidenceFromChain(chain = {}, requestLogPath = null) {
+async function repairCodexAppFastUiAfterMutation(root, enabled) {
+    if (!enabled) {
+        return {
+            schema: 'sks.codex-app-fast-ui-repair.v1',
+            ok: true,
+            status: 'skipped',
+            skipped: true,
+            reason: 'previous_step_failed',
+            actions: [],
+            blockers: []
+        };
+    }
+    try {
+        return await repairCodexAppFastUi(root, { apply: true });
+    }
+    catch (err) {
+        return {
+            schema: 'sks.codex-app-fast-ui-repair.v1',
+            ok: false,
+            status: 'failed',
+            actions: [],
+            blockers: ['codex_app_fast_ui_repair_failed'],
+            error: String(err?.message || err)
+        };
+    }
+}
+export function isCodexLbFastChainVerified(chain = {}) {
+    return chain.ok === true && chain.skipped !== true;
+}
+export async function resolveCodexLbFastCheckModel(status = {}, env = process.env) {
+    const explicit = String(env.SKS_CODEX_MODEL || env.CODEX_MODEL || '').trim();
+    if (explicit)
+        return { model: explicit, source: env.SKS_CODEX_MODEL ? 'SKS_CODEX_MODEL' : 'CODEX_MODEL', blockers: [] };
+    const configPath = String(status.config_path || '').trim();
+    const config = configPath ? await readText(configPath, '').catch(() => '') : '';
+    const configured = topLevelTomlString(config, 'model');
+    if (configured)
+        return { model: configured, source: 'global_config', blockers: [] };
+    const configuredCatalogPath = topLevelTomlString(config, 'model_catalog_json');
+    if (!configuredCatalogPath)
+        return { model: null, source: null, blockers: ['codex_lb_fast_check_model_unselected'] };
+    const home = String(env.HOME || '').trim();
+    const expandedCatalogPath = configuredCatalogPath.startsWith('~/') && home
+        ? path.join(home, configuredCatalogPath.slice(2))
+        : configuredCatalogPath;
+    const catalogPath = path.isAbsolute(expandedCatalogPath)
+        ? expandedCatalogPath
+        : path.resolve(path.dirname(configPath), expandedCatalogPath);
+    try {
+        const payload = JSON.parse(await readText(catalogPath, ''));
+        const model = selectPriorityCapableCatalogModel(payload);
+        return model
+            ? { model, source: 'model_catalog_json', blockers: [] }
+            : { model: null, source: 'model_catalog_json', blockers: ['codex_lb_fast_check_priority_model_unavailable'] };
+    }
+    catch {
+        return { model: null, source: 'model_catalog_json', blockers: ['codex_lb_fast_check_catalog_invalid'] };
+    }
+}
+function topLevelTomlString(text, key) {
+    const topLevel = String(text || '').split(/\n\s*\[/)[0] || '';
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return (topLevel.match(new RegExp(`(?:^|\\n)\\s*${escaped}\\s*=\\s*"([^"]+)"`))?.[1] || '').trim();
+}
+function selectPriorityCapableCatalogModel(payload = {}) {
+    const models = Array.isArray(payload?.models) ? payload.models : Array.isArray(payload?.data) ? payload.data : [];
+    return models
+        .filter((row) => {
+        if (!row || typeof row !== 'object' || row.supported_in_api !== true || typeof row.slug !== 'string' || !row.slug.trim())
+            return false;
+        const serviceTiers = Array.isArray(row.service_tiers) ? row.service_tiers : [];
+        const speedTiers = Array.isArray(row.additional_speed_tiers) ? row.additional_speed_tiers : [];
+        return serviceTiers.some((tier) => normalizeTier(typeof tier === 'string' ? tier : tier?.id) === 'priority')
+            || speedTiers.some((tier) => normalizeTier(tier) === 'priority');
+    })
+        .sort((left, right) => Number(left.priority ?? Number.MAX_SAFE_INTEGER) - Number(right.priority ?? Number.MAX_SAFE_INTEGER)
+        || String(left.slug).localeCompare(String(right.slug)))[0]?.slug || null;
+}
+export async function fastEvidenceFromChain(chain = {}, requestLogPath = null) {
     const chainEvidence = chain.service_tier_evidence || {};
     const logRows = requestLogPath ? await readRequestLogRows(String(requestLogPath)) : [];
     const logEvidence = serviceTierEvidenceFromRows(logRows);
@@ -398,14 +516,14 @@ async function readRequestLogRows(file) {
     }
     return rows;
 }
-function serviceTierEvidenceFromRows(rows = []) {
+export function serviceTierEvidenceFromRows(rows = []) {
     let requested = null;
     let actual = null;
     let effective = null;
     for (const row of rows) {
         requested ||= normalizeTier(row?.requestedServiceTier || row?.requested_service_tier || row?.request?.service_tier || row?.body?.service_tier);
-        actual ||= normalizeTier(row?.actualServiceTier || row?.actual_service_tier || row?.response?.actualServiceTier);
-        effective ||= normalizeTier(row?.serviceTier || row?.service_tier || row?.response?.serviceTier);
+        actual ||= normalizeTier(row?.actualServiceTier || row?.actual_service_tier || row?.response?.actualServiceTier || row?.response?.actual_service_tier);
+        effective ||= responseServiceTier(row);
     }
     return {
         requested_service_tier: requested,
@@ -414,6 +532,17 @@ function serviceTierEvidenceFromRows(rows = []) {
         fast_actual: actual === 'priority' || effective === 'priority'
     };
 }
+function responseServiceTier(row) {
+    const nested = normalizeTier(row?.response?.serviceTier || row?.response?.service_tier || row?.event?.response?.serviceTier || row?.event?.response?.service_tier);
+    if (nested)
+        return nested;
+    const responseKind = String(row?.direction || row?.phase || row?.kind || row?.type || '').trim().toLowerCase();
+    const responseBody = row?.object === 'response' || /^resp[_-]/i.test(String(row?.id || '')) || Array.isArray(row?.output);
+    if (responseBody || responseKind === 'response' || responseKind === 'inbound' || responseKind.startsWith('response.')) {
+        return normalizeTier(row?.serviceTier || row?.service_tier);
+    }
+    return null;
+}
 function normalizeTier(value) {
     const text = String(value || '').trim().toLowerCase();
     if (text === 'fast')

package/dist/commands/codex.js

@@ -4,7 +4,8 @@ import { codexCompatibilityReport, codexDoctorReport } from '../core/codex-compa
 import { codexVersionReport } from '../core/codex-compat/codex-version.js';
 import { codexSchemaSnapshotReport } from '../core/codex-compat/codex-schema-snapshot.js';
 import { detectCodex0141Capability } from '../core/codex-control/codex-0141-capability.js';
-import { detectCodex0142Capability } from '../core/codex-control/codex-0142-capability.js';
+import { detectCodex0144Capability } from '../core/codex-control/codex-0144-capability.js';
+import { CURRENT_CODEX_RELEASE_MANIFEST } from '../core/codex-compat/codex-release-manifest.js';
 export async function run(_command, args = []) {
     const action = args[0] || 'compatibility';
     if (action === 'compatibility' || action === 'compat') {
@@ -39,11 +40,11 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    if (action === '0.142' || action === '0142' || action === 'rust-v0.142.0') {
-        const result = await detectCodex0142Capability({ requireReal: flag(args, '--require-real') });
+    if (action === '0.144' || action === '0144' || action === CURRENT_CODEX_RELEASE_MANIFEST.targetTag) {
+        const result = await detectCodex0144Capability({ requireReal: flag(args, '--require-real') });
         if (flag(args, '--json'))
             return printJson(result);
-        console.log(`Codex 0.142 compatibility: ${result.ok ? 'ok' : 'blocked'} (${result.probe_mode})`);
+        console.log(`Codex ${CURRENT_CODEX_RELEASE_MANIFEST.requiredCliVersion} compatibility: ${result.ok ? 'ok' : 'blocked'} (${result.probe_mode})`);
         for (const blocker of result.blockers || [])
             console.log(`- blocker: ${blocker}`);
         for (const warning of result.warnings || [])
@@ -70,7 +71,7 @@ export async function run(_command, args = []) {
             process.exitCode = 1;
         return;
     }
-    console.error('Usage: sks codex compatibility|version|doctor|schema|0.142|0.141 [--json]');
+    console.error('Usage: sks codex compatibility|version|doctor|schema|0.144|0.141 [--json]');
     process.exitCode = 1;
 }
 //# sourceMappingURL=codex.js.map