sneakoscope 6.0.2 → 6.0.3

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

@@ -444,7 +444,7 @@ async function resolveCodexBundleId(input) {
 }
 export async function smokeSksMenuBarAction(actionScriptPath) {
     if (!(await exists(actionScriptPath)))
-        return { ok: false, code: null, output: null, versionDetected: false, executable: false };
+        return { ok: false, code: null, output: null, versionDetected: false, detectedVersion: null, executable: false };
     // The Swift app runs the script directly (which requires the executable bit), so the smoke
     // check must invoke it the same way. Running it via `/bin/zsh <script>` — as this check used
     // to — succeeds even when +x is missing, which let doctor/status report a healthy action
@@ -456,6 +456,7 @@ export async function smokeSksMenuBarAction(actionScriptPath) {
             code: null,
             output: 'action script is not executable (missing +x); the menu bar app cannot run it',
             versionDetected: false,
+            detectedVersion: null,
             executable: false
         };
     }
@@ -464,12 +465,14 @@ export async function smokeSksMenuBarAction(actionScriptPath) {
         maxOutputBytes: 16 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
     const output = String(`${result.stdout || ''}\n${result.stderr || ''}`).trim();
-    const versionDetected = /\b(?:sks|sneakoscope)?\s*v?\d+\.\d+\.\d+\b/i.test(output);
+    const detectedVersion = output.match(/\b(?:sks|sneakoscope)?\s*v?(\d+\.\d+\.\d+)\b/i)?.[1] || null;
+    const versionDetected = Boolean(detectedVersion);
     return {
         ok: result.code === 0 && versionDetected,
         code: result.code,
         output: output ? output.slice(0, 700) : null,
         versionDetected,
+        detectedVersion,
         executable: true
     };
 }
@@ -505,6 +508,10 @@ export async function inspectSksMenuBarStatus(opts = {}) {
         warning: config.codex_bundle_id ? null : 'codex_sync_disabled'
     };
     const buildStamp = await readJson(paths.build_stamp_path, null);
+    const actionIntegrity = evaluateActionScriptIntegrity(actionText, buildStamp);
+    const expectedActionVersion = buildStamp?.package_version || PACKAGE_VERSION;
+    const actionVersionMatchesExpected = actionSmoke.detectedVersion === expectedActionVersion
+        && actionSmoke.detectedVersion === PACKAGE_VERSION;
     const launchd = await inspectLaunchdService(opts.env);
     const signature = await inspectSignature(paths.app_path, opts.env);
     const blockers = [];
@@ -517,6 +524,12 @@ export async function inspectSksMenuBarStatus(opts = {}) {
         blockers.push('action_script_not_executable');
     if (installed && !actionSmoke.ok)
         blockers.push('action_script_smoke_failed');
+    if (installed && actionSmoke.ok && !actionVersionMatchesExpected)
+        blockers.push('action_target_version_mismatch');
+    if (installed && !buildStamp)
+        blockers.push('build_stamp_missing');
+    if (installed && buildStamp && !actionIntegrity.script_hash_matches_stamp)
+        blockers.push('action_script_hash_mismatch');
     if (installed && signature.checked && !signature.ok)
         warnings.push('codesign_identifier_unexpected');
     if (!codexSync.ok)
@@ -539,8 +552,12 @@ export async function inspectSksMenuBarStatus(opts = {}) {
             smoke_code: actionSmoke.code,
             smoke_output: actionSmoke.output,
             version_detected: actionSmoke.versionDetected,
+            detected_version: actionSmoke.detectedVersion,
+            expected_version: expectedActionVersion,
+            version_matches_expected: actionVersionMatchesExpected,
+            ...actionIntegrity,
             executable: actionSmoke.executable,
-            ok: actionSmoke.ok
+            ok: actionSmoke.ok && actionVersionMatchesExpected && actionIntegrity.script_hash_matches_stamp
         },
         codex_sync: codexSync,
         build_stamp: buildStamp,
@@ -551,6 +568,15 @@ export async function inspectSksMenuBarStatus(opts = {}) {
         next_actions: blockers.length || warnings.length ? defaultNextActions() : ['sks menubar status --json']
     };
 }
+export function evaluateActionScriptIntegrity(actionText, buildStamp) {
+    const scriptSha256 = actionText ? sha256(actionText) : null;
+    const expectedScriptSha256 = buildStamp?.action_script_sha256 || null;
+    return {
+        script_sha256: scriptSha256,
+        expected_script_sha256: expectedScriptSha256,
+        script_hash_matches_stamp: Boolean(scriptSha256 && expectedScriptSha256 && scriptSha256 === expectedScriptSha256)
+    };
+}
 export async function restartSksMenuBar(opts = {}) {
     const env = opts.env || process.env;
     const paths = sksMenuBarPaths(opts.home || env.HOME, opts.root);
@@ -757,6 +783,14 @@ run_node_entry() {
   exec "$node_bin" "$entry" "$@"
 }
 
+# The installer pins the entry that produced this menu build. Prefer it over
+# PATH/global copies so a newly updated 6.0.3 companion cannot execute stale
+# 6.0.2 auth/restart logic. Fall back only when the pinned file or Node runtime
+# is unavailable.
+if [ -f "$SKS_ENTRY" ]; then
+  run_node_entry "$SKS_ENTRY" "$@" || true
+fi
+
 SKS_BIN="$(/bin/zsh -lc 'command -v sks' 2>/dev/null | /usr/bin/head -n 1 || true)"
 if [ -n "$SKS_BIN" ] && [ -x "$SKS_BIN" ]; then
   exec "$SKS_BIN" "$@"
@@ -772,7 +806,6 @@ for entry in "$HOME"/.nvm/versions/node/*/lib/node_modules/sneakoscope/dist/bin/
     run_node_entry "$entry" "$@" || true
   fi
 done
-run_node_entry "$SKS_ENTRY" "$@" || true
 notify_sks_missing
 echo "SKS command not found. Run npm install -g sneakoscope or sks doctor --fix, then try again." >&2
 exit 127
@@ -1176,9 +1209,10 @@ ${codexLifecycleSource}
         let cachePath = NSString(string: "~/.sneakoscope/cache/update-notice.json").expandingTildeInPath
         guard let data = FileManager.default.contents(atPath: cachePath) else { return false }
         guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return false }
-        if let available = json["update_available"] as? Bool { return available }
-        guard let latest = json["latest_version"] as? String else { return false }
-        return latest != packageVersion && !latest.isEmpty
+        if let latest = json["latest_version"] as? String, !latest.isEmpty {
+            return latest.compare(packageVersion, options: .numeric) == .orderedDescending
+        }
+        return json["update_available"] as? Bool == true
     }
 
     func runSksCapture(_ args: [String], title: String, stdinText: String? = nil, notify: Bool = true, completion: ((Int32, String) -> Void)? = nil) {
@@ -1238,12 +1272,18 @@ ${codexLifecycleSource}
         runSksSilent(["codex-lb", "status", "--json"]) { [weak self] code, output in
             guard let self = self else { return }
             let json = parseJsonObject(output)
-            let selected = json?["selected"] as? Bool == true
-            let provider = (json?["model_provider"] as? String)?.lowercased() == "codex-lb"
-            let mode = (json?["mode"] as? String)?.lowercased() == "codex-lb"
-            let codexLbActive = code == 0 && (selected || provider || mode)
+            guard code == 0, let json = json else {
+                self.codexLbItem.state = .off
+                self.oauthItem.state = .off
+                return
+            }
+            let selected = json["selected"] as? Bool == true
+            let providerContract = json["provider_contract_ok"] as? Bool == true
+            let authMode = (json["auth_mode"] as? String)?.lowercased() ?? ""
+            let codexLbActive = selected && providerContract && authMode == "apikey"
+            let oauthActive = !selected && (authMode.contains("chatgpt") || authMode.contains("oauth") || authMode.contains("browser"))
             self.codexLbItem.state = codexLbActive ? .on : .off
-            self.oauthItem.state = codexLbActive ? .off : .on
+            self.oauthItem.state = oauthActive ? .on : .off
         }
     }
 
@@ -1251,8 +1291,13 @@ ${codexLifecycleSource}
         runSksSilent(["fast-mode", "status", "--json"]) { [weak self] code, output in
             guard let self = self else { return }
             let json = parseJsonObject(output)
-            let fastMode = json?["fast_mode"] as? Bool == true
-            let serviceTier = (json?["service_tier"] as? String)?.lowercased()
+            guard code == 0, let json = json else {
+                self.fastModeOnItem.state = .off
+                self.fastModeOffItem.state = .off
+                return
+            }
+            let fastMode = json["fast_mode"] as? Bool == true
+            let serviceTier = (json["service_tier"] as? String)?.lowercased()
             let fastActive = code == 0 && (fastMode || serviceTier == "fast" || serviceTier == "priority")
             self.fastModeOnItem.state = fastActive ? .on : .off
             self.fastModeOffItem.state = fastActive ? .off : .on
@@ -1260,13 +1305,13 @@ ${codexLifecycleSource}
     }
 
     @objc func useCodexLb() {
-        runSksBackground(["codex-lb", "use-codex-lb", "--json"], title: "Use codex-lb") { [weak self] code, _ in
+        runSksBackground(["codex-lb", "use-codex-lb", "--restart-app", "--json"], title: "Use codex-lb") { [weak self] code, _ in
             if code == 0 { self?.updateAuthModeChecks() }
         }
     }
 
     @objc func useChatGptOAuth() {
-        runSksBackground(["codex-lb", "use-oauth", "--json"], title: "Use ChatGPT OAuth") { [weak self] code, _ in
+        runSksBackground(["codex-lb", "use-oauth", "--restart-app", "--json"], title: "Use ChatGPT OAuth") { [weak self] code, _ in
             if code == 0 { self?.updateAuthModeChecks() }
         }
     }
@@ -1274,14 +1319,14 @@ ${codexLifecycleSource}
     @objc func setCodexLbDomainAndKey() {
         guard let domain = promptText(title: "Set codex-lb Domain", message: "Enter just your codex-lb domain or base URL — the /backend-api/codex path is added automatically.", placeholder: "lb.example.com") else { return }
         guard let key = promptText(title: "Set codex-lb Key", message: "Enter your codex-lb API key.", placeholder: "sk-clb-...", secure: true) else { return }
-        runSksBackground(["codex-lb", "setup", "--host", domain, "--api-key-stdin", "--yes", "--json"], title: "Set codex-lb", stdinText: key + "\\n") { [weak self] code, _ in
+        runSksBackground(["codex-lb", "setup", "--host", domain, "--api-key-stdin", "--yes", "--restart-app", "--json"], title: "Set codex-lb", stdinText: key + "\\n") { [weak self] code, _ in
             if code == 0 { self?.updateAuthModeChecks() }
         }
     }
 
     @objc func setOpenRouterKey() {
         guard let key = promptText(title: "Set OpenRouter Key", message: "Enter your OpenRouter API key.", placeholder: "sk-or-v1-...", secure: true) else { return }
-        runSksBackground(["codex-app", "set-openrouter-key", "--api-key-stdin", "--json"], title: "Set OpenRouter Key", stdinText: key + "\\n")
+        runSksBackground(["codex-app", "set-openrouter-key", "--api-key-stdin", "--restart-app", "--json"], title: "Set OpenRouter Key", stdinText: key + "\\n")
     }
 
     @objc func fastModeOn() {
@@ -1312,36 +1357,46 @@ ${codexLifecycleSource}
         let urlString = "http://127.0.0.1:4477"
         runProcess("/usr/bin/curl", ["-fsS", "--max-time", "1", urlString]) { [weak self] code, _ in
             DispatchQueue.main.async {
-                if code != 0 {
+                if code == 0 {
+                    if let url = URL(string: urlString) { NSWorkspace.shared.open(url) }
+                } else {
                     self?.startSksDetached(["ui"], title: "SKS Dashboard")
+                    self?.waitForDashboard(urlString, attempts: 20)
+                }
+            }
+        }
+    }
+
+    func waitForDashboard(_ urlString: String, attempts: Int) {
+        runProcess("/usr/bin/curl", ["-fsS", "--max-time", "1", urlString]) { [weak self] code, _ in
+            if code == 0 {
+                DispatchQueue.main.async {
+                    if let url = URL(string: urlString) { NSWorkspace.shared.open(url) }
+                }
+            } else if attempts > 1 {
+                DispatchQueue.global().asyncAfter(deadline: .now() + 0.25) {
+                    self?.waitForDashboard(urlString, attempts: attempts - 1)
                 }
-                if let url = URL(string: urlString) {
-                    NSWorkspace.shared.open(url)
+            } else {
+                DispatchQueue.main.async {
+                    showAlert("SKS Dashboard failed", informative: "Dashboard did not become ready at \(urlString). See View Last Log.")
                 }
             }
         }
     }
 
     @objc func openCodexSettings() {
-        runProcess("/usr/bin/open", ["codex://settings"])
+        runProcess("/usr/bin/open", ["codex://settings"]) { code, output in
+            if code != 0 {
+                DispatchQueue.main.async {
+                    showAlert("Open Codex Settings failed", informative: humanizeSksFailure(redactSecrets(output)))
+                }
+            }
+        }
     }
 
     @objc func restartCodex() {
-        let running = NSWorkspace.shared.runningApplications.filter { app in
-            if let bundle = codexBundleId, app.bundleIdentifier == bundle { return true }
-            return app.localizedName == "Codex"
-        }
-        for app in running {
-            app.terminate()
-        }
-        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
-            if let bundle = codexBundleId, let url = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundle) {
-                NSWorkspace.shared.open(url)
-                showNotification("Restart Codex", "requested")
-            } else {
-                showAlert("Restart Codex failed", informative: "Codex app bundle could not be resolved.")
-            }
-        }
+        runSksBackground(["codex-app", "restart", "--json"], title: "Restart Codex")
     }
 
     @objc func viewLastLog() {

package/dist/core/codex-app.js

@@ -9,7 +9,7 @@ import { PRODUCT_DESIGN_AUTO_INSTALL_ENV, ensureProductDesignPluginInstalled, pr
 import { GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES } from './codex-app/glm-model-profile.js';
 import { GLM_52_OPENROUTER_MODEL } from './providers/glm/glm-52-settings.js';
 import { resolveOpenRouterApiKey } from './providers/openrouter/openrouter-secret-store.js';
-import { codexLbEnvPath, parseShellEnvValue } from './codex-lb/codex-lb-env.js';
+import { codexLbEnvPath, loadCodexLbEnv, parseShellEnvValue, readCodexLbModelCatalog } from './codex-lb/codex-lb-env.js';
 export const CODEX_APP_DOCS_URL = 'https://developers.openai.com/codex/app/features';
 export const CODEX_CHANGELOG_URL = 'https://developers.openai.com/codex/changelog';
 export const CODEX_ACCESS_TOKENS_DOCS_URL = 'https://developers.openai.com/codex/enterprise/access-tokens';
@@ -35,6 +35,8 @@ export function codexAppCandidatePaths(home = os.homedir(), env = process.env) {
     if (env.SKS_CODEX_APP_PATH)
         candidates.push(env.SKS_CODEX_APP_PATH);
     if (process.platform === 'darwin') {
+        candidates.push('/Applications/ChatGPT.app');
+        candidates.push(path.join(home || '', 'Applications', 'ChatGPT.app'));
         candidates.push('/Applications/Codex.app');
         candidates.push(path.join(home || '', 'Applications', 'Codex.app'));
     }
@@ -545,7 +547,8 @@ export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, re
         lines.push(`Run: ${providerModelUi.glm.key_command}; then ${providerModelUi.glm.install_command}; restart Codex App if the model picker was already open.`);
     }
     if (providerModelUi?.codex_lb?.key_entry_visible && providerModelUi.codex_lb.key_present && providerModelUi.codex_lb.provider_present && providerModelUi.codex_lb.provider_contract_ok && providerModelUi.codex_lb.base_url_present) {
-        lines.push(`codex-lb key entry path is visible and configured; update command ${providerModelUi.codex_lb.set_key_command}.`);
+        lines.push(`codex-lb key entry path is configured; provider catalog ${providerModelUi.codex_lb.expected_models_present ? 'contains GPT-5.6 Sol/Terra/Luna' : 'is not verified'}. Update command: ${providerModelUi.codex_lb.set_key_command}.`);
+        lines.push('Provider/config readiness does not by itself prove the already-running Desktop picker; auth/profile actions restart ChatGPT/Codex so it reloads model/list.');
     }
     else if (providerModelUi?.codex_lb?.key_entry_visible) {
         lines.push(`codex-lb key entry path is visible, but setup is incomplete: ${providerModelUi.codex_lb.blockers.join(', ') || 'setup required'}.`);
@@ -938,6 +941,14 @@ export async function codexProviderModelUiStatus(opts = {}) {
         && hasTomlBoolean(codexLbProvider, 'supports_websockets', true)
         && hasTomlBoolean(codexLbProvider, 'requires_openai_auth', true);
     const codexLbSelectedDefault = /(?:^|\n)\s*model_provider\s*=\s*"codex-lb"\s*(?:#.*)?(?=\n|$)/.test(topLevelToml(globalConfig));
+    let codexLbModelCatalog = opts.codexLbModelCatalog || null;
+    if (!codexLbModelCatalog && codexLbProviderContractOk && codexLbApiKeySource !== 'missing' && codexLbBaseUrlSource !== 'missing') {
+        const loadedEnv = await loadCodexLbEnv({ home, envPath: codexLbEnvFilePath }).catch(() => null);
+        codexLbModelCatalog = loadedEnv ? await readCodexLbModelCatalog({ loadedEnv }).catch(() => null) : null;
+    }
+    const expectedCodexLbModels = ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'];
+    const catalogModels = Array.isArray(codexLbModelCatalog?.models) ? codexLbModelCatalog.models.map(String) : [];
+    const expectedCodexLbModelsPresent = expectedCodexLbModels.every((model) => catalogModels.includes(model));
     const glmBlockers = [
         ...(glmProviderPresent ? [] : ['glm_openrouter_provider_missing']),
         ...glmProfileBlockers,
@@ -947,7 +958,10 @@ export async function codexProviderModelUiStatus(opts = {}) {
         ...(codexLbProviderPresent ? [] : ['codex_lb_provider_missing']),
         ...(codexLbProviderPresent && !codexLbProviderContractOk ? ['codex_lb_provider_contract_drift'] : []),
         ...(codexLbApiKeySource !== 'missing' ? [] : ['codex_lb_api_key_missing']),
-        ...(codexLbBaseUrlSource !== 'missing' ? [] : ['codex_lb_base_url_missing'])
+        ...(codexLbBaseUrlSource !== 'missing' ? [] : ['codex_lb_base_url_missing']),
+        ...(codexLbProviderContractOk && codexLbApiKeySource !== 'missing' && codexLbBaseUrlSource !== 'missing' && !expectedCodexLbModelsPresent
+            ? ['codex_lb_gpt_5_6_catalog_unverified']
+            : [])
     ];
     const blockers = [...glmBlockers, ...codexLbBlockers];
     const keyCommand = 'sks codex-app set-openrouter-key --api-key-stdin';
@@ -958,6 +972,8 @@ export async function codexProviderModelUiStatus(opts = {}) {
         schema: 'sks.codex-app-provider-model-ui.v1',
         ok: blockers.length === 0,
         checked: true,
+        verification_scope: 'config_and_provider_catalog',
+        desktop_picker_verified: false,
         status: blockers.length === 0 ? 'ready' : 'setup_required',
         config_paths: {
             codex_config: globalConfigPath,
@@ -988,6 +1004,12 @@ export async function codexProviderModelUiStatus(opts = {}) {
             api_key_source: codexLbApiKeySource,
             base_url_present: codexLbBaseUrlSource !== 'missing',
             base_url_source: codexLbBaseUrlSource,
+            model_catalog_checked: Boolean(codexLbModelCatalog),
+            model_catalog_ok: codexLbModelCatalog?.ok === true,
+            model_catalog_models: catalogModels,
+            expected_models: expectedCodexLbModels,
+            expected_models_present: expectedCodexLbModelsPresent,
+            model_catalog_blockers: codexLbModelCatalog?.blockers || [],
             setup_command: setupCommand,
             set_key_command: setKeyCommand,
             status_command: 'sks codex-lb status',
@@ -1066,7 +1088,7 @@ function providerModelUiSummary(status = {}) {
     if (!status?.checked)
         return ' not checked';
     if (status.ok)
-        return ' ok (GLM + codex-lb)';
+        return ' config/catalog ready (live picker reload required)';
     return ` setup ${(status.blockers || []).join(', ') || 'required'}`;
 }
 function sksNativeMenuSummary(status = {}) {

package/dist/core/codex-control/codex-model-metadata.js

@@ -57,19 +57,23 @@ async function readCodexCliMetadata(model) {
     return null;
 }
 function normalizePayload(payload, fallbackModel, source) {
-    const catalog = Array.isArray(payload?.models) ? payload.models : null;
+    const catalog = Array.isArray(payload?.data) ? payload.data : Array.isArray(payload?.models) ? payload.models : null;
     const reportedSelection = String(payload?.selected_model || payload?.current_model || payload?.active_model || '').trim();
     const requestedModel = String(fallbackModel || reportedSelection).trim();
     const row = catalog
         ? requestedModel
-            ? catalog.find((candidate) => String(candidate?.id || candidate?.model || candidate?.name || '') === requestedModel) || null
+            ? catalog.find((candidate) => String(candidate?.id || candidate?.model || candidate?.slug || candidate?.name || '') === requestedModel) || null
             : null
         : payload?.model_metadata || payload?.metadata || payload;
     if (!row) {
         return metadata(requestedModel, [], 'medium', source, [requestedModel ? 'codex_model_not_found_in_advertised_catalog' : 'codex_model_selection_unknown']);
     }
-    const efforts = normalizeAdvertisedEfforts(row?.advertised_efforts || row?.advertisedEfforts || row?.reasoning_efforts || row?.reasoningEfforts || payload?.advertised_efforts);
-    return metadata(String(row?.model || row?.id || row?.name || requestedModel), efforts, row?.default_effort || row?.defaultEffort || payload?.default_effort || 'medium', source, efforts.length ? [] : ['codex_model_metadata_efforts_missing']);
+    const effortRows = row?.supportedReasoningEfforts || row?.supported_reasoning_levels || row?.supported_reasoning_efforts || [];
+    const structuredEfforts = Array.isArray(effortRows)
+        ? effortRows.map((entry) => entry?.reasoningEffort || entry?.effort || entry)
+        : [];
+    const efforts = normalizeAdvertisedEfforts(structuredEfforts.length ? structuredEfforts : row?.advertised_efforts || row?.advertisedEfforts || row?.reasoning_efforts || row?.reasoningEfforts || payload?.advertised_efforts);
+    return metadata(String(row?.model || row?.id || row?.slug || row?.name || requestedModel), efforts, row?.default_reasoning_level || row?.defaultReasoningLevel || row?.default_effort || row?.defaultEffort || payload?.default_effort || 'medium', source, efforts.length ? [] : ['codex_model_metadata_efforts_missing']);
 }
 function metadata(model, efforts, defaultEffort, source, blockers) {
     const advertised = normalizeAdvertisedEfforts(efforts);

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

@@ -29,6 +29,84 @@ export async function readLbHealth(home = process.env.HOME || os.homedir()) {
         updated_at: typeof raw.updated_at === 'string' ? raw.updated_at : null
     };
 }
+export async function readCodexLbModelCatalog(opts = {}) {
+    const loaded = opts.loadedEnv || await loadCodexLbEnv();
+    if (!loaded.configured || !loaded.base_url || !loaded.secret_api_key) {
+        return {
+            schema: 'sks.codex-lb-model-catalog.v1',
+            ok: false,
+            status: 'blocked',
+            models: [],
+            model_efforts: {},
+            http_status: null,
+            blockers: loaded.missing.length ? loaded.missing.map((item) => `codex_lb_missing:${item}`) : ['codex_lb_not_configured']
+        };
+    }
+    const fetchImpl = opts.fetchImpl || fetch;
+    try {
+        const response = await fetchImpl(`${loaded.base_url}/models`, {
+            headers: { Authorization: `Bearer ${loaded.secret_api_key}` },
+            signal: AbortSignal.timeout(Math.max(250, Number(opts.timeoutMs || 5000)))
+        });
+        const payload = await response.json().catch(() => null);
+        const models = normalizeCodexLbModelCatalogPayload(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);
+        const cachedEfforts = normalizeCodexModelEffortCatalogPayload(cachePayload);
+        const modelEfforts = Object.fromEntries(models.map((model) => [model, apiEfforts[model] || cachedEfforts[model] || []]));
+        const ok = response.ok && models.length > 0;
+        return {
+            schema: 'sks.codex-lb-model-catalog.v1',
+            ok,
+            status: ok ? 'ready' : 'blocked',
+            models,
+            model_efforts: modelEfforts,
+            http_status: response.status,
+            blockers: [
+                ...(response.ok ? [] : [`codex_lb_models_http_${response.status}`]),
+                ...(models.length ? [] : ['codex_lb_model_catalog_empty'])
+            ]
+        };
+    }
+    catch {
+        return {
+            schema: 'sks.codex-lb-model-catalog.v1',
+            ok: false,
+            status: 'blocked',
+            models: [],
+            model_efforts: {},
+            http_status: null,
+            blockers: ['codex_lb_model_catalog_unavailable']
+        };
+    }
+}
+export function normalizeCodexModelEffortCatalogPayload(payload) {
+    const rows = Array.isArray(payload?.data) ? payload.data : Array.isArray(payload?.models) ? payload.models : [];
+    const result = {};
+    for (const row of rows) {
+        const model = String(row?.id || row?.model || row?.slug || row?.name || '').trim();
+        if (!model)
+            continue;
+        const effortRows = row?.supportedReasoningEfforts
+            || row?.supported_reasoning_levels
+            || row?.supported_reasoning_efforts
+            || row?.reasoning_efforts
+            || [];
+        const efforts = (Array.isArray(effortRows) ? effortRows : [])
+            .map((entry) => String(entry?.reasoningEffort || entry?.effort || entry || '').trim().toLowerCase())
+            .filter(Boolean);
+        result[model] = [...new Set(efforts)];
+    }
+    return result;
+}
+export function normalizeCodexLbModelCatalogPayload(payload) {
+    const rows = Array.isArray(payload?.data) ? payload.data : Array.isArray(payload?.models) ? payload.models : [];
+    const models = rows
+        .map((row) => String(row?.id || row?.model || row?.slug || row?.name || '').trim())
+        .filter(Boolean);
+    return [...new Set(models)];
+}
 export function normalizeCodexLbBaseUrl(input = '') {
     let host = String(input || '').trim();
     if (!host)

package/dist/core/commands/basic-cli.js

@@ -15,6 +15,7 @@ import { hooksExplainReport } from '../../cli/feature-commands.js';
 import { writeSelftestRouteProof } from '../proof/selftest-proof-fixtures.js';
 import { createMission } from '../mission.js';
 import { formatSksUpdateCheckText, runSksUpdateCheck, runSksUpdateNow } from '../update-check.js';
+import { persistSksUpdateNoticeFromVersions } from '../update/update-notice.js';
 import { withSecretPreservationGuard } from '../config/config-migration-journal.js';
 export async function helpCommand(args = []) {
     const topic = args[0];
@@ -121,6 +122,12 @@ For implementation work, use Codex App prompt routes such as $Naruto, $Goal, $QA
 }
 export async function updateCheckCommand(args = []) {
     const result = await runSksUpdateCheck();
+    await persistSksUpdateNoticeFromVersions({
+        packageName: result.package,
+        currentVersion: result.current,
+        latestVersion: result.latest,
+        error: result.error
+    }).catch(() => undefined);
     if (flag(args, '--json'))
         return printJson(result);
     cliUi.banner('update');
@@ -151,6 +158,14 @@ export async function updateCommand(sub = 'now', args = []) {
         timeoutMs: 10 * 60 * 1000,
         maxOutputBytes: 128 * 1024
     }));
+    if (!flag(effectiveArgs, '--dry-run')) {
+        await persistSksUpdateNoticeFromVersions({
+            packageName: result.package,
+            currentVersion: result.new_version || result.from,
+            latestVersion: result.latest,
+            error: result.ok ? null : result.error
+        }).catch(() => undefined);
+    }
     if (flag(effectiveArgs, '--json'))
         return printJson(result);
     cliUi.banner('update');

package/dist/core/commands/naruto-command.js

@@ -42,10 +42,26 @@ const NARUTO_ROUTE = '$Naruto';
 // writes). The standard 20-agent ceiling is lifted only for this route.
 export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
     const args = Array.isArray(commandOrArgs) ? commandOrArgs : maybeArgs;
-    // 4.0.9: `sks naruto --glm` delegates to GLM Naruto before legacy Naruto starts.
+    // Normal Naruto is a GPT-5.6-family-only route. Keep the historical GLM
+    // implementation reachable only through the explicitly separate
+    // `sks --mad --glm --naruto` global mode; a command-local --glm flag must
+    // never bypass the Luna/Terra/Sol catalog and backend guards below.
     if (args.includes('--glm')) {
-        const { glmNarutoCommand } = await import('../providers/glm/naruto/glm-naruto-command.js');
-        return glmNarutoCommand(args.filter((arg) => arg !== '--glm'));
+        const result = {
+            schema: 'sks.naruto-command-result.v1',
+            ok: false,
+            mode: 'NARUTO',
+            status: 'blocked',
+            reason: 'naruto_gpt_5_6_family_only_glm_override_forbidden',
+            blockers: ['naruto_gpt_5_6_family_only_glm_override_forbidden'],
+            hint: 'Use normal sks naruto for Luna/Terra/Sol. The separate legacy GLM route requires: sks --mad --glm --naruto.'
+        };
+        process.exitCode = 1;
+        if (args.includes('--json'))
+            console.log(JSON.stringify(result, null, 2));
+        else
+            console.error(`$Naruto blocked: ${result.reason}. ${result.hint}`);
+        return result;
     }
     const parsed = parseNarutoArgs(args);
     if (!parsed.json)
@@ -84,13 +100,21 @@ async function narutoRun(parsed) {
     const writeCapable = parsed.readonly !== true && parsed.writeMode !== 'off';
     const patchEnvelopeBasePath = '.sneakoscope/naruto/patch-envelopes';
     const explicitPromptPaths = writeCapable ? extractNarutoPromptPaths(parsed.prompt) : [];
-    const targetPaths = explicitPromptPaths.length ? explicitPromptPaths : [patchEnvelopeBasePath];
+    // Keep an empty target list when the prompt does not name a concrete file.
+    // buildNarutoWorkGraph then derives one patch-envelope path per work item;
+    // passing the base directory as a target would collapse every write lease
+    // onto the same path and force an avoidable serial merge bottleneck.
+    const targetPaths = explicitPromptPaths;
+    const fixtureLeaseTargetsAllowed = parsed.backend === 'fake' || parsed.mock;
     const placeholderGuard = checkPromptPlaceholders({
         prompt: parsed.prompt,
         writeCapable,
-        targetPaths: writeCapable ? targetPaths : []
+        targetPaths: writeCapable
+            ? (targetPaths.length ? targetPaths : fixtureLeaseTargetsAllowed ? [patchEnvelopeBasePath] : [])
+            : []
     });
     if (!placeholderGuard.ok) {
+        process.exitCode = 1;
         return emit(parsed, {
             schema: NARUTO_RESULT_SCHEMA,
             ok: false,
@@ -98,7 +122,10 @@ async function narutoRun(parsed) {
             action: 'run',
             status: 'blocked',
             prompt_placeholder_guard: placeholderGuard,
-            blockers: placeholderGuard.blockers
+            blockers: placeholderGuard.blockers,
+            hint: placeholderGuard.blockers.includes('write_capable_prompt_target_paths_empty')
+                ? 'Name the target source path(s), or run Naruto read-only discovery before starting a write-capable worker swarm.'
+                : null
         }, () => {
             console.log('$Naruto blocked before work graph creation: unresolved prompt placeholder or empty write target path.');
             for (const blocker of placeholderGuard.blockers)
@@ -137,7 +164,7 @@ async function narutoRun(parsed) {
     // system-safe number so naruto never spawns the whole count at once unless an
     // explicit operator override asks for a higher target.
     const localWorker = await resolveNarutoLocalWorkerMode(parsed);
-    const schedulerBackend = localWorker.auto_select_eligible ? 'local-llm' : parsed.backend;
+    const schedulerBackend = parsed.backend;
     const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
     const baseWorkGraph = buildNarutoWorkGraph({
         prompt: parsed.prompt,
@@ -1176,7 +1203,7 @@ async function resolveNarutoLocalWorkerMode(parsed) {
         description: parsed.prompt,
         write_paths: parsed.readonly ? [] : ['<lease-scoped-worker-path>']
     }, { route: NARUTO_ROUTE, agent: { role: parsed.readonly ? 'collector' : 'implementer' } });
-    const autoSelectEligible = parsed.backend === 'codex-sdk'
+    const localAutoSelectCandidate = parsed.backend === 'codex-sdk'
         && parsed.backendExplicit !== true
         && parsed.noOllama !== true
         && config?.ok === true
@@ -1189,13 +1216,14 @@ async function resolveNarutoLocalWorkerMode(parsed) {
         model: config?.model || null,
         requested_backend: parsed.backend,
         backend_explicit: parsed.backendExplicit,
-        auto_select_eligible: autoSelectEligible,
+        auto_select_eligible: false,
         worker_only: true,
         no_strategy_planning_design: true,
         policy,
         blockers: [
             ...(config?.blockers || (config ? [] : ['ollama_worker_config_unavailable'])),
             ...(policy.blockers || []),
+            ...(localAutoSelectCandidate ? ['naruto_gpt_5_6_family_only_local_auto_select_forbidden'] : []),
             ...(parsed.backendExplicit ? ['backend_explicit'] : []),
             ...(parsed.noOllama ? ['no_ollama_requested'] : [])
         ]

package/dist/core/naruto/naruto-write-e2e.js

@@ -1,17 +1,16 @@
 import fs from 'node:fs/promises';
-import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { applyNarutoPatchEnvelopes } from './naruto-parallel-patch-apply.js';
 import { realisticNarutoRealWriteProofFixture, validateNarutoRealWriteProof } from './naruto-real-write-proof.js';
-import { ensureDir, runProcess, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { ensureDir, runProcess, tmpdir, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 export async function runNarutoWriteE2e(mode) {
     if (mode === 'real-codex')
         return runRealCodexWriteE2e();
     return runHermeticWriteE2e();
 }
 export async function runHermeticWriteE2e() {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-naruto-write-e2e-'));
+    const tempRoot = tmpdir('naruto-write-e2e-');
     const mergeArtifactPath = path.join(tempRoot, '.sneakoscope', 'naruto-write-e2e-parent-merge.json');
     const blockers = [];
     let cleanup = { ok: false, temp_root_removed: false, blockers: [] };
@@ -284,7 +283,7 @@ async function probeRealCodexRuntime() {
     return { ok: result.code === 0, blockers: result.code === 0 ? [] : [`codex_version_exit_${result.code}`] };
 }
 async function runRealNarutoCommandWriteE2e() {
-    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-naruto-real-write-e2e-'));
+    const tempRoot = tmpdir('naruto-real-write-e2e-');
     const mergeArtifactPath = path.join(tempRoot, '.sneakoscope', 'naruto-real-write-e2e-parent-merge.json');
     const blockers = [];
     let cleanup = { ok: false, temp_root_removed: false, blockers: [] };