sneakoscope 4.7.1 → 4.7.4

package/dist/core/update-check.js

@@ -4,6 +4,7 @@ import { PACKAGE_VERSION, packageRoot, readJson, runProcess, which } from './fsx
 import { createRequestedScopeContract } from './safety/requested-scope-contract.js';
 import { guardedPackageInstall, guardContextForRoute } from './safety/mutation-guard.js';
 import { isUpdateMigrationReceiptCurrent, resolveInstalledSksEntrypoint, runPackageLocalDoctor, writeProjectUpdateMigrationReceipt } from './update/update-migration-state.js';
+import { installSksMenuBar } from './codex-app/sks-menubar.js';
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org/';
 export async function runSksUpdateCheck(options = {}) {
     const packageName = options.packageName || 'sneakoscope';
@@ -164,6 +165,9 @@ export async function runSksUpdateNow(options = {}) {
         }).catch(() => null);
         const migrationCurrent = isUpdateMigrationReceiptCurrent(receipt);
         stage('project_receipt', migrationCurrent, migrationCurrent ? 'current' : 'failed', { root: projectReceiptRoot });
+        const sksMenuBar = migrationCurrent
+            ? await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage })
+            : null;
         return buildUpdateNowResult({
             packageName,
             from: check.current,
@@ -185,19 +189,14 @@ export async function runSksUpdateNow(options = {}) {
             newVersionDoctor: null,
             projectReceipt: receipt,
             migrationCurrent,
+            sksMenuBar,
             stages,
             error: null
         });
     }
-    const oldVersionDoctor = await runPackageLocalDoctor({
-        root: projectReceiptRoot,
-        args: ['doctor', '--fix', '--yes', '--profile', 'migration', '--machine-only', '--report-file', path.join(projectReceiptRoot, '.sneakoscope', 'update', `old-version-doctor-${Date.now()}.json`)],
-        env,
-        timeoutMs: 15_000,
-        maxOutputBytes: 32 * 1024
-    });
-    stage('old_version_doctor_preflight', oldVersionDoctor.ok, oldVersionDoctor.status, { entrypoint: oldVersionDoctor.entrypoint, exit_code: oldVersionDoctor.exit_code });
-    if (!oldVersionDoctor.ok && env.SKS_UPDATE_SKIP_OLD_DOCTOR_PREFLIGHT !== '1') {
+    if (options.dryRun) {
+        stage('old_version_doctor_preflight', true, 'skipped_dry_run', { reason: 'dry_run_does_not_run_doctor_fix' });
+        stage('npm_install', true, 'dry_run', { command });
         return buildUpdateNowResult({
             packageName,
             from: check.current,
@@ -210,21 +209,32 @@ export async function runSksUpdateNow(options = {}) {
             cwd,
             registry,
             globalRoot,
-            status: 'failed',
-            ok: false,
+            status: 'dry_run',
+            ok: true,
             installCode: null,
-            oldVersionDoctor,
+            oldVersionDoctor: null,
             newBinary: null,
             newVersion: null,
             newVersionDoctor: null,
             projectReceipt: null,
             migrationCurrent: false,
             stages,
-            error: oldVersionDoctor.error || 'old-version Doctor preflight failed'
+            error: null
         });
     }
-    if (options.dryRun) {
-        stage('npm_install', true, 'dry_run', { command });
+    const oldDoctorTimeoutOverride = Number.parseInt(env.SKS_UPDATE_OLD_DOCTOR_TIMEOUT_MS || '', 10);
+    const oldDoctorTimeoutMs = Number.isFinite(oldDoctorTimeoutOverride) && oldDoctorTimeoutOverride > 0
+        ? oldDoctorTimeoutOverride
+        : 60_000;
+    const oldVersionDoctor = await runPackageLocalDoctor({
+        root: projectReceiptRoot,
+        args: ['doctor', '--fix', '--yes', '--profile', 'migration', '--machine-only', '--report-file', path.join(projectReceiptRoot, '.sneakoscope', 'update', `old-version-doctor-${Date.now()}.json`)],
+        env,
+        timeoutMs: oldDoctorTimeoutMs,
+        maxOutputBytes: 32 * 1024
+    });
+    stage('old_version_doctor_preflight', oldVersionDoctor.ok, oldVersionDoctor.status, { entrypoint: oldVersionDoctor.entrypoint, exit_code: oldVersionDoctor.exit_code, timeout_ms: oldDoctorTimeoutMs });
+    if (!oldVersionDoctor.ok && env.SKS_UPDATE_SKIP_OLD_DOCTOR_PREFLIGHT !== '1') {
         return buildUpdateNowResult({
             packageName,
             from: check.current,
@@ -237,8 +247,8 @@ export async function runSksUpdateNow(options = {}) {
             cwd,
             registry,
             globalRoot,
-            status: 'dry_run',
-            ok: true,
+            status: 'failed',
+            ok: false,
             installCode: null,
             oldVersionDoctor,
             newBinary: null,
@@ -247,7 +257,7 @@ export async function runSksUpdateNow(options = {}) {
             projectReceipt: null,
             migrationCurrent: false,
             stages,
-            error: null
+            error: oldVersionDoctor.error || 'old-version Doctor preflight failed'
         });
     }
     const mutationLedgerRoot = env.SKS_MUTATION_LEDGER_ROOT || packageRoot();
@@ -277,6 +287,7 @@ export async function runSksUpdateNow(options = {}) {
     let newVersionDoctor = null;
     let projectReceipt = null;
     let migrationCurrent = false;
+    let sksMenuBar = null;
     if (installOk) {
         newBinary = await resolveInstalledSksEntrypoint({ packageName, globalRoot, env });
         stage('resolve_new_package_local_binary', Boolean(newBinary), newBinary ? 'resolved' : 'missing', { new_binary: newBinary });
@@ -310,6 +321,8 @@ export async function runSksUpdateNow(options = {}) {
             }).catch(() => null);
             migrationCurrent = isUpdateMigrationReceiptCurrent(projectReceipt);
             stage('project_receipt', migrationCurrent, migrationCurrent ? 'current' : 'failed', { root: projectReceiptRoot });
+            if (migrationCurrent)
+                sksMenuBar = await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage });
         }
     }
     const ok = installOk && Boolean(newBinary) && newVersionDoctor?.ok === true && migrationCurrent;
@@ -334,6 +347,7 @@ export async function runSksUpdateNow(options = {}) {
         newVersionDoctor,
         projectReceipt,
         migrationCurrent,
+        sksMenuBar,
         stages,
         error: ok ? null : updateNowError(install, newBinary, newVersionDoctor, migrationCurrent)
     });
@@ -500,10 +514,45 @@ function buildUpdateNowResult(input) {
         new_version_doctor: input.newVersionDoctor,
         project_receipt: input.projectReceipt,
         migration_current: input.migrationCurrent,
+        sks_menubar: input.sksMenuBar || null,
         stages: input.stages,
         error: input.error
     };
 }
+async function installUpdateSksMenuBar(input) {
+    if (input.env.SKS_UPDATE_SKIP_SKS_MENUBAR === '1') {
+        input.stage('sks_menubar', true, 'skipped', { reason: 'SKS_UPDATE_SKIP_SKS_MENUBAR=1' });
+        return null;
+    }
+    const result = await installSksMenuBar({
+        root: input.root,
+        apply: true,
+        launch: true,
+        env: input.env
+    }).catch((err) => ({
+        schema: 'sks.codex-app-sks-menubar.v1',
+        ok: false,
+        apply: true,
+        status: 'blocked',
+        platform: process.platform,
+        app_path: null,
+        executable_path: null,
+        launch_agent_path: null,
+        action_script_path: null,
+        report_path: path.join(input.root, '.sneakoscope', 'reports', 'sks-menubar.json'),
+        menu_items: [],
+        actions: [],
+        launch: { requested: true, method: 'none', ok: false, error: err?.message || String(err) },
+        blockers: [err?.message || String(err)],
+        warnings: []
+    }));
+    input.stage('sks_menubar', result.ok !== false, result.status, {
+        app_path: result.app_path,
+        launch_agent_path: result.launch_agent_path,
+        launch: result.launch
+    });
+    return result;
+}
 async function detectNpmGlobalRoot(npmBin, env, opts = {}) {
     const result = await runProcess(npmBin, ['root', '--global', '--silent'], {
         env,

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.7.0';
+export const PACKAGE_VERSION = '4.7.4';
 //# sourceMappingURL=version.js.map

package/dist/scripts/codex-app-provider-model-ui-check.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { codexProviderModelUiStatus, formatCodexAppStatus } from '../core/codex-app.js';
+import { GLM_CODEX_CONFIG_PROVIDER_ID, GLM_CODEX_CONFIG_REASONING_PROFILES } from '../core/codex-app/glm-model-profile.js';
+import { GLM_52_OPENROUTER_MODEL } from '../core/providers/glm/glm-52-settings.js';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-app-provider-ui-'));
+const home = path.join(tmp, 'home');
+const cwd = path.join(tmp, 'project');
+await fs.mkdir(path.join(home, '.codex'), { recursive: true });
+await fs.mkdir(path.join(cwd, '.codex'), { recursive: true });
+const missing = await codexProviderModelUiStatus({ home, cwd, env: { HOME: home } });
+const missingText = formatCodexAppStatus(statusFixture(missing));
+await fs.writeFile(path.join(home, '.codex', 'config.toml'), readyConfig(), 'utf8');
+await fs.writeFile(path.join(home, '.codex', 'sks-codex-lb.env'), "export CODEX_LB_BASE_URL='https://lb.example.test/backend-api/codex'\nexport CODEX_LB_API_KEY='sk-codex-lb-fixture'\n", 'utf8');
+const ready = await codexProviderModelUiStatus({
+    home,
+    cwd,
+    env: { HOME: home, OPENROUTER_API_KEY: 'sk-or-fixture' }
+});
+const readyText = formatCodexAppStatus(statusFixture(ready));
+const ok = missing.ok === false
+    && missing.glm.exposed === false
+    && missing.codex_lb.key_entry_visible === true
+    && missing.ui_actions.includes('sks codex-app set-openrouter-key --api-key-stdin')
+    && missing.ui_actions.includes('sks codex-lb setup --host <domain> --api-key-stdin --yes')
+    && /Provider UI:\s*setup/.test(missingText)
+    && /GLM Model:\s*setup/.test(missingText)
+    && /codex-lb Key:\s*missing \(input: sks codex-lb setup/.test(missingText)
+    && ready.ok === true
+    && ready.glm.exposed === true
+    && ready.glm.model === GLM_52_OPENROUTER_MODEL
+    && ready.glm.profiles_present.length === GLM_CODEX_CONFIG_REASONING_PROFILES.length
+    && ready.codex_lb.provider_present === true
+    && ready.codex_lb.key_present === true
+    && /Provider UI:\s*ok/.test(readyText)
+    && readyText.includes(`GLM Model:  ok ${GLM_52_OPENROUTER_MODEL}`)
+    && /codex-lb Key:\s*configured/.test(readyText)
+    && !JSON.stringify({ missing, ready, missingText, readyText }).includes('sk-codex-lb-fixture');
+emit({
+    schema: 'sks.codex-app-provider-model-ui-check.v1',
+    ok,
+    missing,
+    ready,
+    secret_safe: !JSON.stringify({ missing, ready, missingText, readyText }).includes('sk-codex-lb-fixture'),
+    blockers: ok ? [] : ['codex_app_provider_model_ui_check_failed']
+});
+function readyConfig() {
+    return [
+        `[model_providers.${GLM_CODEX_CONFIG_PROVIDER_ID}]`,
+        'name = "OpenRouter"',
+        'base_url = "https://openrouter.ai/api/v1"',
+        'wire_api = "responses"',
+        'env_key = "OPENROUTER_API_KEY"',
+        'requires_openai_auth = false',
+        '',
+        ...GLM_CODEX_CONFIG_REASONING_PROFILES.flatMap((profile) => [
+            `[profiles.${profile.id}]`,
+            `model_provider = "${GLM_CODEX_CONFIG_PROVIDER_ID}"`,
+            `model = "${GLM_52_OPENROUTER_MODEL}"`,
+            `model_reasoning_effort = "${profile.reasoning_effort}"`,
+            'service_tier = "default"',
+            'approval_policy = "on-request"',
+            ''
+        ]),
+        '[model_providers.codex-lb]',
+        'name = "openai"',
+        'base_url = "https://lb.example.test/backend-api/codex"',
+        'wire_api = "responses"',
+        'env_key = "CODEX_LB_API_KEY"',
+        'supports_websockets = true',
+        'requires_openai_auth = true',
+        ''
+    ].join('\n');
+}
+function statusFixture(providerModelUi) {
+    return {
+        ok: providerModelUi.ok,
+        app: { installed: true, path: '/Applications/Codex.app' },
+        codex_cli: { ok: true, version: '0.142.0' },
+        remote_control: { ok: true, min_version: '0.130.0', codex_cli: { version_number: '0.142.0' } },
+        features: {
+            checked: true,
+            required_flags_ok: true,
+            required_flags: {},
+            fast_mode_config: { ok: true, blockers: [] },
+            provider_model_ui: providerModelUi,
+            git_actions: { ok: true, blockers: [] },
+            browser_tool_ready: true,
+            browser_tool_source: 'fixture',
+            image_generation: true
+        },
+        plugins: {
+            default_plugins: { ok: true },
+            design_product: { ok: true, id: 'product-design' },
+            picker: { ok: true }
+        },
+        chrome_extension: { ok: true, blockers: [] },
+        mcp: {
+            has_computer_use: true,
+            computer_use_source: 'mcp_list',
+            has_browser_use: true,
+            browser_use_source: 'mcp_list'
+        },
+        guidance: []
+    };
+}
+function emit(report) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=codex-app-provider-model-ui-check.js.map

package/dist/scripts/codex-lb-fast-mode-truth-check.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { run } from '../commands/codex-lb.js';
+const calls = [];
+const home = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-fast-truth-'));
+await fs.mkdir(path.join(home, '.codex'), { recursive: true });
+await fs.writeFile(path.join(home, '.codex', 'config.toml'), [
+    'model_provider = "codex-lb"',
+    'service_tier = "fast"',
+    '',
+    '[model_providers.codex-lb]',
+    'name = "openai"',
+    'base_url = "https://lb.example.test/backend-api/codex"',
+    'wire_api = "responses"',
+    'env_key = "CODEX_LB_API_KEY"',
+    'supports_websockets = true',
+    'requires_openai_auth = true',
+    ''
+].join('\n'));
+await fs.writeFile(path.join(home, '.codex', 'auth.json'), `${JSON.stringify({ auth_mode: 'apikey', OPENAI_API_KEY: 'sk-fixture' })}\n`);
+await fs.writeFile(path.join(home, '.codex', 'sks-codex-lb.env'), "export CODEX_LB_BASE_URL='https://lb.example.test/backend-api/codex'\nexport CODEX_LB_API_KEY='sk-fixture'\n");
+const chain = await runFastCheck({
+    HOME: home,
+    CODEX_LB_API_KEY: 'sk-fixture',
+    CODEX_LB_BASE_URL: 'https://lb.example.test/backend-api/codex'
+});
+const requestedOnly = await runFastCheck({
+    HOME: home,
+    CODEX_LB_API_KEY: 'sk-fixture',
+    CODEX_LB_BASE_URL: 'https://lb.example.test/backend-api/codex',
+    SKS_TEST_FAST_ACTUAL_DEFAULT: '1'
+});
+const ok = chain.ok === true
+    && chain.status === 'fast_verified'
+    && calls[0]?.body?.service_tier === 'priority'
+    && requestedOnly.ok === false
+    && requestedOnly.status === 'fast_requested_but_actual_unverified'
+    && requestedOnly.blockers.includes('codex_lb_actual_fast_service_tier_unverified');
+console.log(JSON.stringify({
+    schema: 'sks.codex-lb-fast-mode-truth-check.v1',
+    ok,
+    priority_request_sent: calls[0]?.body?.service_tier === 'priority',
+    verified_case: chain,
+    requested_only_case: requestedOnly,
+    blockers: ok ? [] : ['codex_lb_fast_mode_truth_check_failed']
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+async function runFastCheck(env) {
+    const originalFetch = globalThis.fetch;
+    const originalEnv = { ...process.env };
+    const outputs = [];
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    const originalExitCode = process.exitCode;
+    try {
+        Object.assign(process.env, env);
+        process.exitCode = 0;
+        globalThis.fetch = async (_url, init) => {
+            const body = JSON.parse(String(init.body || '{}'));
+            calls.push({ body });
+            const id = calls.length % 2 === 1 ? 'resp_fast_1' : 'resp_fast_2';
+            const actual = env.SKS_TEST_FAST_ACTUAL_DEFAULT === '1' ? 'default' : 'priority';
+            return new Response(JSON.stringify({
+                id,
+                requestedServiceTier: 'priority',
+                actualServiceTier: actual,
+                serviceTier: actual
+            }), { status: 200, headers: { 'content-type': 'application/json' } });
+        };
+        process.stdout.write = (chunk) => {
+            outputs.push(String(chunk));
+            return true;
+        };
+        await run(null, ['fast-check', '--json']);
+        return JSON.parse(outputs.join('') || '{}');
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        process.stdout.write = originalWrite;
+        process.exitCode = originalExitCode;
+        for (const key of Object.keys(process.env)) {
+            if (!(key in originalEnv))
+                delete process.env[key];
+        }
+        Object.assign(process.env, originalEnv);
+    }
+}
+//# sourceMappingURL=codex-lb-fast-mode-truth-check.js.map

package/dist/scripts/codex-lb-setup-truthfulness-check.js

@@ -46,9 +46,14 @@ async function runSetup(name, args, input = 'sk-clb-test\n') {
 }
 {
     const row = await runSetup('no-env', ['--no-env-file']);
+    const actions = row.json.applied_actions?.map((action) => action.type) || [];
     results.push({
         name: 'no_env_file',
-        ok: row.code === 0 && row.json.ok === true && !(await exists(row.envPath))
+        ok: row.code === 0
+            && row.json.status === 'process_env'
+            && row.json.persistence?.applied_modes?.includes('process_only_ephemeral')
+            && !actions.includes('write_env_file')
+            && !(await exists(row.envPath))
     });
 }
 {

package/dist/scripts/doctor-fixes-codex-app-fast-ui-check.js

@@ -8,7 +8,7 @@ const codexHome = path.join(root, 'home', '.codex');
 await fs.mkdir(path.join(root, '.codex'), { recursive: true });
 await fs.mkdir(codexHome, { recursive: true });
 await fs.writeFile(path.join(root, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "medium"\nmodel_provider = "codex-lb"\n');
-await fs.writeFile(path.join(codexHome, 'config.toml'), '# SKS forced fast UI during legacy install\nmodel = "z-ai/glm-5.2"\nmodel_reasoning_effort = "xhigh"\nmodel_provider = "codex-lb"\nservice_tier = "fast"\n[features]\nfast_mode = false # user disabled, must remain untouched\n\n[profiles.sks-fast-high]\nmodel = "gpt-5.5"\nservice_tier = "fast"\n\n[model_providers.codex-lb]\nname = "OpenAI"\nbase_url = "https://lb.example.test/backend-api/codex"\nwire_api = "responses"\nenv_key = "CODEX_LB_API_KEY"\nsupports_websockets = true\nrequires_openai_auth = false\n');
+await fs.writeFile(path.join(codexHome, 'config.toml'), '# SKS forced fast UI during legacy install\nmodel = "z-ai/glm-5.2"\nmodel_reasoning_effort = "xhigh"\nmodel_provider = "codex-lb"\nservice_tier = "fast"\n[features]\nfast_mode = false # user disabled, must remain untouched\n\n[profiles.sks-fast-high]\nmodel = "gpt-5.5"\nservice_tier = "fast"\n\n[model_providers.codex-lb]\nname = "openai"\nbase_url = "https://lb.example.test/backend-api/codex"\nwire_api = "responses"\nenv_key = "CODEX_LB_API_KEY"\nsupports_websockets = true\nrequires_openai_auth = true\n');
 const plan = await repairCodexAppFastUi(root, { codexHome, apply: false });
 const repaired = await repairCodexAppFastUi(root, { codexHome, apply: true });
 const projectAfter = await fs.readFile(path.join(root, '.codex', 'config.toml'), 'utf8');
@@ -22,8 +22,12 @@ await fs.mkdir(unsafeCodexHome, { recursive: true });
 await fs.writeFile(path.join(unsafeCodexHome, 'config.toml'), 'service_tier = "standard"\n');
 const unsafePlan = await repairCodexAppFastUi(unsafeRoot, { codexHome: unsafeCodexHome, apply: false });
 const ok = plan.fast_selector === 'manual_action_required'
+    && plan.provider_selector === 'manual_action_required'
+    && plan.provider_actions.includes('sks codex-app set-openrouter-key --api-key-stdin')
+    && plan.provider_actions.includes('sks codex-lb setup --host <domain> --api-key-stdin --yes')
     && plan.safe_auto_apply === true
     && repaired.fast_selector === 'repaired'
+    && repaired.provider_selector === 'manual_action_required'
     && repaired.safe_auto_apply === true
     && backups.length >= 2
     && !/^model\s*=/m.test(projectAfter.split(/\n\s*\[/)[0] || '')

package/dist/scripts/gpt-image-2-real-file-smoke.js

@@ -92,7 +92,7 @@ function authState() {
         };
     }
     const codexLb = readCodexLbAuth();
-    if (codexLb.selected && codexLb.provider_configured && codexLb.requires_openai_auth === false && codexLb.key && codexLb.base_url) {
+    if (codexLb.selected && codexLb.provider_configured && codexLb.requires_openai_auth === true && codexLb.key && codexLb.base_url) {
         return {
             ok: true,
             provider: 'openai_responses_image_generation',
@@ -102,7 +102,7 @@ function authState() {
             codex_lb: {
                 selected: true,
                 provider_configured: true,
-                requires_openai_auth: false,
+                requires_openai_auth: true,
                 base_url: codexLb.base_url,
                 env_key: codexLb.env_key,
                 env_path: codexLb.env_path,

package/dist/scripts/provider-context-config-toml-check.js

@@ -10,11 +10,11 @@ const codexLbConfig = [
     'model_provider = "codex-lb"',
     '',
     '[model_providers.codex-lb]',
-    'name = "OpenAI"',
+    'name = "openai"',
     'base_url = "https://lb.example.test"',
     'wire_api = "responses"',
     'env_key = "CODEX_LB_API_KEY"',
-    'requires_openai_auth = false',
+    'requires_openai_auth = true',
     ''
 ].join('\n');
 await fs.writeFile(path.join(codexHome, 'config.toml'), codexLbConfig);

package/dist/scripts/sks-menubar-install-check.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { installSksMenuBar } from '../core/codex-app/sks-menubar.js';
+const temp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-menubar-check-'));
+const result = await installSksMenuBar({
+    apply: true,
+    launch: false,
+    home: temp,
+    root: temp,
+    sksEntry: path.join(process.cwd(), 'dist', 'bin', 'sks.js')
+});
+const executableExists = result.executable_path ? await exists(result.executable_path) : false;
+const launchAgentExists = result.launch_agent_path ? await exists(result.launch_agent_path) : false;
+const actionScriptExists = result.action_script_path ? await exists(result.action_script_path) : false;
+const expectedMenuItems = [
+    'Use codex-lb',
+    'Use ChatGPT OAuth',
+    'Set OpenRouter Key and GLM Profiles',
+    'Fast Check',
+    'SKS Version Check',
+    'Update SKS Now'
+];
+const missingExpectedItems = expectedMenuItems.filter((item) => !result.menu_items.includes(item));
+const hasExpectedItems = missingExpectedItems.length === 0;
+const ok = process.platform === 'darwin'
+    ? result.ok === true
+        && result.status === 'installed_launch_skipped'
+        && executableExists
+        && launchAgentExists
+        && actionScriptExists
+        && hasExpectedItems
+    : result.ok === true && result.status === 'unsupported_platform';
+const report = {
+    schema: 'sks.sks-menubar-install-check.v1',
+    ok,
+    temp,
+    result,
+    executable_exists: executableExists,
+    launch_agent_exists: launchAgentExists,
+    action_script_exists: actionScriptExists,
+    expected_menu_items: expectedMenuItems,
+    missing_expected_items: missingExpectedItems,
+    has_expected_items: hasExpectedItems,
+    blockers: ok ? [] : ['sks_menubar_install_check_failed']
+};
+console.log(JSON.stringify(report, null, 2));
+if (!ok)
+    process.exit(1);
+async function exists(file) {
+    try {
+        await fs.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=sks-menubar-install-check.js.map

package/dist/scripts/update-default-command-check.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+function assertGate(ok, message, detail) {
+    if (!ok) {
+        console.error(JSON.stringify({ schema: 'sks.update-default-command-check.v1', ok: false, message, detail }, null, 2));
+        process.exit(1);
+    }
+}
+const registry = fs.readFileSync('src/cli/command-registry.ts', 'utf8');
+const basicCli = fs.readFileSync('src/core/commands/basic-cli.ts', 'utf8');
+const update = fs.readFileSync('src/core/update-check.ts', 'utf8');
+const routes = fs.readFileSync('src/core/routes.ts', 'utf8');
+assertGate(registry.includes("subcommand(() => import(basicModule), 'updateCommand', 'dist/core/commands/basic-cli.js', 'now')"), 'bare sks update must default to update now');
+assertGate(basicCli.includes("export async function updateCommand(sub: any = 'now'"), 'updateCommand default must be now');
+assertGate(basicCli.includes("action.startsWith('-')") && basicCli.includes('effectiveArgs = [String(sub), ...args]'), 'sks update --json/--dry-run must be treated as update now with flags');
+assertGate(update.includes('installSksMenuBar') && update.includes('sks_menubar'), 'update now must refresh the SKS menu bar companion stage');
+assertGate(routes.includes('sks update [check|now]'), 'command catalog must document bare sks update as the default update path');
+console.log(JSON.stringify({
+    schema: 'sks.update-default-command-check.v1',
+    ok: true,
+    checks: [
+        'registry_default_now',
+        'basic_cli_default_now',
+        'flag_first_default_now',
+        'update_menubar_stage',
+        'command_catalog_usage'
+    ]
+}, null, 2));
+//# sourceMappingURL=update-default-command-check.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.7.1",
+  "version": "4.7.4",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -114,6 +114,7 @@
     "codex-app:fast-ui-preservation": "node ./dist/scripts/codex-app-fast-ui-preservation-check.js",
     "codex-app:ui-clobber-guard": "node ./dist/scripts/codex-app-ui-clobber-guard-check.js",
     "doctor:fixes-codex-app-fast-ui": "node ./dist/scripts/doctor-fixes-codex-app-fast-ui-check.js",
+    "codex-app:provider-model-ui": "node ./dist/scripts/codex-app-provider-model-ui-check.js",
     "mad-sks:app-ui-no-mutation": "node ./dist/scripts/mad-sks-app-ui-no-mutation-check.js",
     "provider:badge-context": "node ./dist/scripts/provider-badge-context-check.js",
     "provider:context-config-toml": "node ./dist/scripts/provider-context-config-toml-check.js",
@@ -167,6 +168,8 @@
     "codex:0.135-compat:require-real": "node ./dist/scripts/codex-0-135-compat-check.js --require-real",
     "doctor:codex-doctor-parity": "node ./dist/scripts/doctor-codex-doctor-parity-check.js",
     "doctor:codex-doctor-parity:actual": "node ./dist/scripts/doctor-codex-doctor-parity-check.js --actual-codex",
+    "doctor:sks-menubar": "node ./dist/scripts/sks-menubar-install-check.js",
+    "update:default-command": "node ./dist/scripts/update-default-command-check.js",
     "codex:permission-profiles": "node ./dist/scripts/codex-permission-profiles-check.js",
     "codex:legacy-profile-consumers-removed": "node ./dist/scripts/codex-legacy-profile-consumers-removed-check.js",
     "terminal:keyboard-enhancement-safety": "node ./dist/scripts/terminal-keyboard-enhancement-safety-check.js",
@@ -303,6 +306,7 @@
     "codex-lb:setup-truthfulness": "node ./dist/scripts/codex-lb-setup-truthfulness-check.js",
     "codex-lb:persistence-truth": "node ./dist/scripts/codex-lb-persistence-truth-check.js",
     "codex-lb:missing-env-regression": "node ./dist/scripts/codex-lb-missing-env-regression.js",
+    "codex-lb:fast-mode-truth": "node ./dist/scripts/codex-lb-fast-mode-truth-check.js",
     "computer-use:policy-check": "node ./dist/scripts/computer-use-policy-check.js",
     "computer-use:visual-route-fixture": "node ./dist/scripts/computer-use-visual-route-fixture-check.js",
     "computer-use:live-optional": "node ./dist/scripts/computer-use-live-optional-check.js",