sneakoscope 8.0.3 → 8.0.4

package/dist/cli/install-helpers-install-support.js

@@ -10,7 +10,6 @@ import { EMPTY_CODEX_INFO, getCodexInfo } from '../core/codex-adapter.js';
 import { formatHarnessConflictReport, llmHarnessCleanupPrompt, scanHarnessConflicts } from '../core/harness-conflicts.js';
 import { initProject, installGlobalSkills } from '../core/init.js';
 import { context7ConfigToml, DOLLAR_SKILL_NAMES, GETDESIGN_REFERENCE, hasContext7ConfigText, RECOMMENDED_SKILLS } from '../core/routes.js';
-import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
 import { reconcileCodexAppUpgradeProcesses } from '../core/codex-app.js';
 import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
 import { cleanupMacLaunchSecretEnvironment } from '../core/codex-app/menubar/index.js';
@@ -72,12 +71,13 @@ export async function selftestSksShimRepair() {
     const staleShimTmp = tmpdir();
     const staleBin = path.join(staleShimTmp, 'old-prefix', 'bin');
     const stalePkg = path.join(staleShimTmp, 'old-prefix', 'lib', 'node_modules', 'sneakoscope');
-    await ensureDir(path.join(stalePkg, 'bin'));
+    const staleEntrypoint = path.join(stalePkg, 'dist', 'bin', 'sks.js');
+    await ensureDir(path.dirname(staleEntrypoint));
     await ensureDir(staleBin);
     await writeTextAtomic(path.join(stalePkg, 'package.json'), JSON.stringify({ name: 'sneakoscope', version: '0.0.1' }, null, 2));
-    await writeTextAtomic(path.join(stalePkg, 'bin', 'sks.js'), '#!/usr/bin/env node\nconsole.log("sneakoscope 0.0.1");\n');
-    await fsp.chmod(path.join(stalePkg, 'bin', 'sks.js'), 0o755).catch(() => { });
-    await fsp.symlink(path.join(stalePkg, 'bin', 'sks.js'), path.join(staleBin, 'sks'));
+    await writeTextAtomic(staleEntrypoint, '#!/usr/bin/env node\nconsole.log("sneakoscope 0.0.1");\n');
+    await fsp.chmod(staleEntrypoint, 0o755).catch(() => { });
+    await fsp.symlink(staleEntrypoint, path.join(staleBin, 'sks'));
     const repair = await ensureSksCommandDuringInstall({ force: true, pathEnv: staleBin, home: path.join(staleShimTmp, 'home') });
     if (repair.status !== 'repaired')
         throw new Error(`selftest: stale global sks shim was not repaired (${repair.status})`);
@@ -136,10 +136,13 @@ async function inspectSksPathShim(candidate, opts = {}) {
 }
 function sksPackageRootForBin(file) {
     const normalized = String(file || '').split(path.sep).join('/');
-    const marker = '/node_modules/sneakoscope/bin/';
+    const marker = '/node_modules/sneakoscope/';
     const idx = normalized.lastIndexOf(marker);
     if (idx < 0)
         return null;
+    const relative = normalized.slice(idx + marker.length);
+    if (!/^(?:dist\/)?bin\//.test(relative))
+        return null;
     return normalized.slice(0, idx + '/node_modules/sneakoscope'.length).split('/').join(path.sep);
 }
 async function installedPackageVersion(root) {

package/dist/cli/install-helpers.js

@@ -9,7 +9,6 @@ import { guardedPackageInstall, guardContextForRoute } from '../core/safety/muta
 import { formatHarnessConflictReport, llmHarnessCleanupPrompt, scanHarnessConflicts } from '../core/harness-conflicts.js';
 import { initProject, installGlobalSkills } from '../core/init.js';
 import { context7ConfigToml, DOLLAR_SKILL_NAMES, GETDESIGN_REFERENCE, hasContext7ConfigText, RECOMMENDED_SKILLS } from '../core/routes.js';
-import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
 import { reconcileCodexAppUpgradeProcesses } from '../core/codex-app.js';
 import { restartCodexApp } from '../core/codex-app/codex-app-restart.js';
 import { cleanupMacLaunchSecretEnvironment } from '../core/codex-app/menubar/index.js';
@@ -1633,12 +1632,16 @@ export async function codexLbStatus(opts = {}) {
         && providerName === 'codex-lb'
         && providerWireApi === 'responses'
         && providerEnvKey === CODEX_LB_PROVIDER_ENV_KEY
+        && providerHasSeparateGatewayAuth
         && providerSupportsWebsockets === true
         && providerOpenAiAuthDisabled;
     const retiredCompatConfigured = desktopMode === 'desktop-dual-auth-compat';
     const definedButNotSelected = providerConfigured && !selected && desktopMode === null;
     const providerContractOk = !retiredCompatConfigured && cliProviderContractOk;
-    const providerUsesCodexLbEnvAuth = providerConfigured && providerEnvKey === CODEX_LB_PROVIDER_ENV_KEY && providerOpenAiAuthDisabled;
+    const providerUsesCodexLbEnvAuth = providerConfigured
+        && providerEnvKey === CODEX_LB_PROVIDER_ENV_KEY
+        && providerHasSeparateGatewayAuth
+        && providerOpenAiAuthDisabled;
     const oauthAvailable = authMode.mode === 'chatgpt_oauth' || authMode.mode === 'browser_marker';
     const authRoutingCoherent = desktopMode === 'desktop-native-bridge'
         ? !selected && oauthAvailable && !codexLbKeyInSharedAuth
@@ -1884,11 +1887,15 @@ function codexLbProviderOpenAiAuthDisabled(text = '') {
 }
 function codexLbProviderEnvKey(text = '') {
     const block = String(text || '').match(/(^|\n)\[model_providers\.codex-lb\]([\s\S]*?)(?=\n\[[^\]]+\]|\s*$)/)?.[2] || '';
-    return block.match(/(^|\n)\s*env_key\s*=\s*"([^"]+)"/)?.[2] || '';
+    return block.match(/(^|\n)\s*env_key\s*=\s*"([^"]+)"/)?.[2]
+        || block.match(/env_http_headers\s*=\s*\{[^}]*"X-Codex-LB-API-Key"\s*=\s*"([^"]+)"[^}]*\}/)?.[1]
+        || '';
 }
 function codexLbProviderHasSeparateGatewayAuth(text = '') {
     const block = String(text || '').match(/(^|\n)\[model_providers\.codex-lb\]([\s\S]*?)(?=\n\[[^\]]+\]|\s*$)/)?.[2] || '';
-    return /X-Codex-LB-API-Key/.test(block) && /CODEX_LB_API_KEY/.test(block);
+    return /X-Codex-LB-API-Key/.test(block)
+        && /CODEX_LB_API_KEY/.test(block)
+        && !/(^|\n)\s*env_key\s*=/.test(block);
 }
 function codexLbFastModeConfigStatus(text = '') {
     const globalServiceTier = topLevelTomlString(text, 'service_tier');
@@ -2872,7 +2879,7 @@ async function inspectCodexLbMacLaunchEnvironment(baseUrl = '', opts = {}) {
             : []
     };
 }
-export { checkContext7, ensureCodexCliTool, ensureMadLaunchDependencies, ensureRelatedCliTools, ensureZellijCliTool, formatMadLaunchDependencyAction, maybePromptCodexUpdateForLaunch, maybePromptSksUpdateForLaunch, shouldAutoApproveInstall } from './install-tool-helpers.js';
+export { checkContext7, ensureCodexCliTool, ensureRelatedCliTools, maybePromptCodexUpdateForLaunch, maybePromptSksUpdateForLaunch, shouldAutoApproveInstall } from './install-tool-helpers.js';
 export { codexFastModeDesktopStatus, ensureGlobalCodexFastModeDuringInstall, normalizeCodexFastModeUiConfig, safeWriteCodexConfigToml } from '../core/codex-runtime/codex-desktop-config-policy.js';
 export { checkRequiredSkills, context7GlobalMcpStatus, ensureCodexImagegenDuringInstall, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureSksCommandDuringInstall, globalCodexSkillsRoot, selftestSksShimRepair } from './install-helpers-install-support.js';
 export { askPostinstallQuestion, codexLbConfigPath, codexLbEnvPath, normalizeCodexLbBaseUrl } from './install-helpers-codex-lb-shared.js';

package/dist/cli/install-tool-helpers.js

@@ -7,56 +7,10 @@ import { exists, globalSksRoot, PACKAGE_VERSION, runProcess, which } from '../co
 import { hasContext7ConfigText } from '../core/routes.js';
 import { createRequestedScopeContract } from '../core/safety/requested-scope-contract.js';
 import { guardedPackageInstall, guardContextForRoute } from '../core/safety/mutation-guard.js';
-import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
 export async function ensureRelatedCliTools(args = []) {
     const skip = args.includes('--skip-cli-tools') || process.env.SKS_SKIP_CLI_TOOLS === '1';
     const codex = await ensureCodexCliTool({ skip, args });
-    const zellijRepair = skip ? { status: 'skipped', reason: 'SKS_SKIP_CLI_TOOLS=1 or --skip-cli-tools' } : await ensureZellijCliTool(args);
-    const zellij = await checkZellijCapability({ require: false, writeReport: false });
-    return {
-        codex,
-        zellij: {
-            ok: zellij.status === 'ok',
-            bin: zellij.bin,
-            version: zellij.version,
-            min_version: zellij.min_version,
-            current_session: false,
-            repair: zellijRepair,
-            install_hint: zellij.status === 'ok' ? null : zellijInstallHint(),
-            error: zellijRepair.error || zellij.blockers[0] || zellij.warnings[0] || null
-        }
-    };
-}
-export async function ensureMadLaunchDependencies(args = []) {
-    const skip = args.includes('--skip-cli-tools') || process.env.SKS_SKIP_CLI_TOOLS === '1';
-    const zellijRepair = skip ? { target: 'zellij', status: 'skipped', reason: 'SKS_SKIP_CLI_TOOLS=1 or --skip-cli-tools' } : await ensureZellijCliTool(args);
-    const zellij = await checkZellijCapability({ require: false, writeReport: false });
-    const ready = zellij.status === 'ok';
-    return {
-        ready,
-        actions: ready ? [] : [{
-                target: 'zellij',
-                status: zellijRepair.status,
-                command: zellijRepair.command || zellijInstallHint(),
-                error: zellijRepair.error || zellij.blockers[0] || zellij.warnings[0] || null,
-                repair: zellijRepair
-            }],
-        status: {
-            zellij: {
-                ok: ready,
-                status: zellij.status,
-                version: zellij.version,
-                min_version: zellij.min_version,
-                repair: zellijRepair,
-                install_hint: ready ? null : zellijInstallHint()
-            }
-        }
-    };
-}
-export function formatMadLaunchDependencyAction(action = {}) {
-    const command = action.command ? ` Run: ${action.command}.` : '';
-    const error = action.error ? ` ${action.error}` : '';
-    return `${action.target || 'dependency'} ${action.status || 'blocked'}.${command}${error}`.trim();
+    return { codex };
 }
 export async function ensureCodexCliTool({ skip = false, args = [] } = {}) {
     if (skip)
@@ -88,37 +42,6 @@ export async function ensureCodexCliTool({ skip = false, args = [] } = {}) {
         hint: after.bin ? null : 'npm completed, but codex is not on PATH. Restart the shell or set SKS_CODEX_BIN.'
     };
 }
-export async function ensureZellijCliTool(args = [], opts = {}) {
-    const before = await checkZellijCapability({ require: false, writeReport: false });
-    if (before.status === 'ok')
-        return { target: 'zellij', status: 'present', bin: before.bin, version: before.version || null };
-    const command = zellijInstallHint();
-    if (process.platform !== 'darwin')
-        return { target: 'zellij', status: 'manual_required', command, error: before.blockers[0] || before.warnings[0] || 'zellij not found' };
-    const brew = await which('brew').catch(() => null);
-    if (!brew)
-        return { target: 'zellij', status: 'manual_required', command: 'Install Homebrew, then run: brew install zellij', error: before.blockers[0] || before.warnings[0] || 'zellij not found' };
-    if (args.includes('--dry-run') || opts.dryRun)
-        return { target: 'zellij', status: 'dry_run', command, error: before.blockers[0] || before.warnings[0] || null };
-    const hasInstalledZellij = Boolean(before.version);
-    const question = hasInstalledZellij
-        ? `Homebrew Zellij ${before.version || 'unknown'} is not ready. Upgrade to latest Zellij with ${command}?`
-        : `Zellij is missing. Install latest Zellij with ${command}?`;
-    if (!await confirmInstallYesDefault(question, args))
-        return { target: 'zellij', status: 'needs_approval', command, error: before.blockers[0] || before.warnings[0] || null };
-    const brewArgs = hasInstalledZellij ? ['upgrade', 'zellij'] : ['install', 'zellij'];
-    const zellijRoot = globalSksRoot();
-    const zellijContract = createRequestedScopeContract({
-        route: 'install', userRequest: command, projectRoot: zellijRoot, overrides: { package_install: true, zellij_install: true }
-    });
-    const install = await guardedPackageInstall(guardContextForRoute(zellijRoot, zellijContract, command), 'zellij', { confirmed: true, command: brew, args: brewArgs, timeoutMs: 180000 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
-    if (install.code !== 0)
-        return { target: 'zellij', status: 'failed', command, error: `${install.stderr || install.stdout || command + ' failed'}`.trim() };
-    const after = await checkZellijCapability({ require: false, writeReport: false });
-    if (after.status !== 'ok')
-        return { target: 'zellij', status: 'installed_not_ready', command, error: after.blockers[0] || after.warnings[0] || 'zellij installed but not ready' };
-    return { target: 'zellij', status: hasInstalledZellij ? 'upgraded' : 'installed', command, bin: after.bin, version: after.version || null };
-}
 export async function maybePromptCodexUpdateForLaunch(args = [], opts = {}) {
     if (hasFlag(args, '--json') || hasFlag(args, '--skip-cli-tools') || hasFlag(args, '--skip-codex-update') || process.env.SKS_SKIP_CODEX_UPDATE === '1')
         return { status: 'skipped' };
@@ -126,7 +49,7 @@ export async function maybePromptCodexUpdateForLaunch(args = [], opts = {}) {
     const codex = await getCodexInfo().catch(() => EMPTY_CODEX_INFO);
     const current = codexCliVersionNumber(codex.version);
     const command = 'npm i -g @openai/codex@latest';
-    const label = opts.label || 'Zellij launch';
+    const label = opts.label || 'Codex launch';
     const missing = !codex.bin;
     const updateAvailable = Boolean(latest.version && current && compareVersions(latest.version, current) > 0);
     if (!missing && !updateAvailable)
@@ -215,9 +138,6 @@ export async function checkContext7(root) {
     result.ok = result.project.ok || result.codex_mcp_list.ok || (result.global.ok && !list.checked);
     return result;
 }
-function zellijInstallHint() {
-    return process.platform === 'darwin' ? 'brew install zellij' : 'Install Zellij from https://zellij.dev/documentation/installation.html';
-}
 async function confirmInstallYesDefault(question, args = []) {
     if (hasFlag(args, '--from-postinstall') && process.env.SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS !== '1')
         return false;

package/dist/cli/output.js

@@ -2,6 +2,11 @@ import { PACKAGE_VERSION } from '../core/version.js';
 export function sksTextLogo() {
     return `SKS\nSNEAKOSCOPE CODEX v${PACKAGE_VERSION}`;
 }
-export function printJson(value) {
+export function printJson(value, options = {}) {
+    if (options.failureExitCode !== false && value && typeof value === 'object' && value.ok === false) {
+        const current = Number(process.exitCode || 0);
+        if (!Number.isFinite(current) || current === 0)
+            process.exitCode = 1;
+    }
     console.log(JSON.stringify(value, null, 2));
 }

package/dist/cli/router.js

@@ -1,7 +1,53 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash } from 'node:crypto';
 import { COMMAND_ALIASES_LITE, COMMAND_MANIFEST_BY_NAME, COMMAND_NAME_SET, } from './command-manifest-lite.js';
 import { ui as cliUi } from './cli-theme.js';
 import { helpResult, isHelpRequest, renderManifestHelp } from './help.js';
 import { findRetiredGlobalExecutionArgumentErrors } from './global-mode-router.js';
+import { normalizeIntentCommand, } from '../core/commands/intent-normalization/normalizer.js';
+const routerIntentStorage = new AsyncLocalStorage();
+export function currentRouterIntentContract() {
+    return routerIntentStorage.getStore() || null;
+}
+export function prepareRouterExecutionIntent(argv, inheritance = {}) {
+    const effectiveArgv = argv.length ? [...argv] : ['doctor'];
+    const rawCommand = effectiveArgv[0]?.startsWith('$')
+        ? effectiveArgv.join(' ')
+        : `sks ${effectiveArgv.join(' ')}`;
+    const parent = inheritance.parentContract;
+    if (parent) {
+        const normalized = normalizeIntentCommand({
+            rawCommand,
+            naturalLanguageEffect: parent.natural_language_effect,
+            effect: parent.effect,
+            observedChangedPaths: parent.observed_changed_paths,
+            targetHashes: parent.target_hashes,
+            policyVersion: parent.policy_version,
+            modeSnapshot: parent.mode_snapshot,
+            evidenceState: parent.evidence_state,
+            retryBudget: parent.retry_budget,
+            requestedRisk: parent.risk,
+            explicitUltraOptIn: parent.risk === 'ULTRA',
+            force: parent.force,
+        });
+        if (normalized.contract.contract_hash !== parent.contract_hash) {
+            throw new Error('router_parent_intent_contract_mismatch');
+        }
+        return Object.freeze({ ...normalized, contract: parent });
+    }
+    const preflight = normalizeIntentCommand({
+        rawCommand,
+        naturalLanguageEffect: inheritance.naturalLanguageEffect || `Execute ${effectiveArgv[0] || 'doctor'}`,
+        effect: inheritance.effect || classifyCliIntentEffect(effectiveArgv),
+        targetHashes: [createHash('sha256').update(`${process.cwd()}\0${effectiveArgv[0] || 'doctor'}`).digest('hex')],
+        policyVersion: 'sks-cli-router-v1',
+        modeSnapshot: inheritance.modeSnapshot || providerModeFromEnvironment(),
+        evidenceState: inheritance.evidenceState || 'missing',
+        retryBudget: inheritance.retryBudget ?? 0,
+        force: effectiveArgv.includes('--force'),
+    });
+    return preflight;
+}
 export function isCommandName(value) {
     return COMMAND_NAME_SET.has(value);
 }
@@ -22,7 +68,28 @@ export function normalizeCommand(args = []) {
 export async function dispatch(args) {
     const argv = args ?? process.argv.slice(2);
     try {
-        return await dispatchInner(argv);
+        let intent = null;
+        try {
+            intent = prepareRouterExecutionIntent(argv);
+        }
+        catch (error) {
+            const code = error instanceof Error ? error.message : String(error);
+            if (code === 'intent_legacy_option_unsupported') {
+                process.exitCode = 1;
+                const result = { ok: false, status: 'blocked', reason: code, command: argv[0] || 'doctor' };
+                if (argv.includes('--json'))
+                    console.log(JSON.stringify(result, null, 2));
+                else
+                    console.error(code);
+                return result;
+            }
+            if (!['intent_cli_command_unknown', 'intent_dollar_command_unknown', 'intent_dollar_command_unmapped'].includes(code)) {
+                throw error;
+            }
+        }
+        return intent
+            ? await routerIntentStorage.run(intent.contract, () => dispatchInner(argv))
+            : await dispatchInner(argv);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -37,6 +104,32 @@ export async function dispatch(args) {
         return result;
     }
 }
+function providerModeFromEnvironment() {
+    const mode = String(process.env.SKS_PROVIDER_MODE || '').trim();
+    return mode === 'codex-lb' || mode === 'openrouter' || mode === 'chatgpt-oauth'
+        ? mode
+        : 'chatgpt-oauth';
+}
+function classifyCliIntentEffect(argv) {
+    const normalized = normalizeCommand(argv);
+    const command = normalized.command;
+    const entry = command ? COMMAND_MANIFEST_BY_NAME[command] : null;
+    const tokens = argv.map((value) => String(value).toLowerCase());
+    const action = tokens.slice(1).find((value) => !value.startsWith('-')) || '';
+    if (entry?.readonly === true || safeReadOnlySubcommand(command, normalized.args))
+        return 'read';
+    if (/^(?:delete|remove|uninstall|purge|cleanup)$/.test(action))
+        return 'delete';
+    if (/^(?:deploy|publish|release|push)$/.test(action))
+        return 'deploy';
+    if (/^(?:login|logout|signin|sign-in|auth|setup|reconnect)$/.test(action))
+        return 'auth';
+    if (/^(?:install|update|upgrade|add-dependency)$/.test(action))
+        return 'dependency';
+    if (/^(?:security|permissions|sign|verify-signature|rotate)$/.test(action))
+        return 'security';
+    return 'write';
+}
 async function dispatchInner(argv) {
     const retiredGlm = findRetiredGlobalExecutionArgumentErrors(argv).filter((item) => item.includes('--glm'));
     if (retiredGlm.length && argv.some((arg) => arg === '--glm' || String(arg).startsWith('--glm='))) {
@@ -133,7 +226,13 @@ async function dispatchInner(argv) {
     }
     if (typeof mod.run !== 'function')
         throw new Error(`Command ${command} must export run(command, args)`);
-    return mod.run(rawCommand || command, rest);
+    const result = await mod.run(rawCommand || command, rest);
+    if (argv.includes('--json') && result && typeof result === 'object' && result.ok === false) {
+        const current = Number(process.exitCode || 0);
+        if (!Number.isFinite(current) || current === 0)
+            process.exitCode = 1;
+    }
+    return result;
 }
 async function ensureActiveRouteCommandGate(command, args) {
     const entry = COMMAND_MANIFEST_BY_NAME[command];

package/dist/commands/codex-lb.js

@@ -106,7 +106,8 @@ export async function run(command, args = []) {
         const routingTruth = await measureAndWriteCodexLbRoutingTruth({
             selected: status.selected === true,
             baseUrl: loadedEnv.base_url,
-            apiKey: loadedEnv.secret_api_key
+            apiKey: loadedEnv.secret_api_key,
+            authTransport: 'x-codex-lb-api-key'
         }, {
             home: path.dirname(path.dirname(status.env_path))
         });
@@ -144,7 +145,8 @@ export async function run(command, args = []) {
         const routingTruth = await measureAndWriteCodexLbRoutingTruth({
             selected: status.selected === true,
             baseUrl: loadedEnv.base_url,
-            apiKey: loadedEnv.secret_api_key
+            apiKey: loadedEnv.secret_api_key,
+            authTransport: 'x-codex-lb-api-key'
         }, {
             home: path.dirname(path.dirname(status.env_path))
         });
@@ -561,7 +563,7 @@ export async function run(command, args = []) {
                 selected: result.codex_lb?.selected === true,
                 baseUrl: result.base_url || null,
                 apiKey: options.apiKey,
-                authTransport: 'authorization-bearer'
+                authTransport: 'x-codex-lb-api-key'
             }, {
                 home: path.dirname(path.dirname(result.env_path))
             })

package/dist/commands/doctor-profile.js

@@ -51,7 +51,7 @@ export function doctorPhaseIdsForProfile(profile) {
 function unknownDoctorFlags(args) {
     const knownBoolean = new Set([
         '--fix', '--yes', '-y', '--machine-only', '--actual-codex', '--require-actual-codex',
-        '--full', '--capabilities', '--repair-codex-app-ui', '--repair-zellij', '--install-homebrew',
+        '--full', '--capabilities', '--repair-codex-app-ui',
         '--repair-native-capabilities', '--repair-codex-native', '--local-only', '--global-only', '--project', '--global',
         '--dry-run', '--json'
     ]);