sneakoscope 2.0.4 → 2.0.6

package/dist/core/codex/codex-0-137-compat.js

@@ -0,0 +1,119 @@
+import { runProcess, which } from '../fsx.js';
+import { compareSemverLike, parseCodexVersionText } from '../codex-compat/codex-version-policy.js';
+import { createHash } from 'node:crypto';
+export const CODEX_0_137_BASELINE_TAG = 'rust-v0.137.0';
+export const CODEX_0_137_VERSION = '0.137.0';
+export const CODEX_0_137_SCHEMA = 'sks.codex-0.137-compat.v1';
+export function codex0137Matrix(input = {}) {
+    const version = parseCodexVersionText(input.version) || input.version || null;
+    const available = input.available !== false && Boolean(version);
+    const meets = available && compareSemverLike(version, CODEX_0_137_VERSION) >= 0;
+    const pluginJsonDetected = looksLikeJson(input.pluginListText || '');
+    const runtimeDetected = /runtime|model|provider|thread/i.test(input.debugModelsText || '');
+    const approvalsDetected = /approval|environment|sandbox|profile|permission/i.test(input.doctorText || '');
+    const localOrBaseline = (detected) => detected ? 'detected' : meets ? 'release_baseline' : available ? 'blocked' : 'unavailable';
+    const capabilities = [
+        capability('plugin_list_json', 'P0', localOrBaseline(pluginJsonDetected), '`codex plugin list --json` parses as JSON or 0.137 baseline records it.'),
+        capability('thread_runtime_choice', 'P0', localOrBaseline(runtimeDetected), 'Thread/runtime choice is tracked by SKS per-thread proof and Codex runtime evidence.'),
+        capability('environment_scoped_approvals', 'P0', localOrBaseline(approvalsDetected), 'Approval proof carries environment identity and sandbox scope.'),
+        capability('managed_proxy_ca_bundle_child_commands', 'P1', meets ? 'release_baseline' : available ? 'blocked' : 'unavailable', 'Managed proxy CA bundle propagation is release-baseline plus SKS env proof.'),
+        capability('python_sdk_app_server_json_rpc', 'P0', meets ? 'release_baseline' : available ? 'blocked' : 'unavailable', 'Python SDK controls local app-server over JSON-RPC per current Codex manual.')
+    ];
+    const below = available && version ? compareSemverLike(version, CODEX_0_137_VERSION) < 0 : false;
+    const blockers = [
+        ...(input.requireReal && (!version || below) ? ['codex_0_137_required_but_not_detected'] : []),
+        ...capabilities
+            .filter((row) => input.requireReal && row.priority === 'P0' && (row.status === 'blocked' || row.status === 'unavailable'))
+            .map((row) => `codex_0_137_capability_unavailable:${row.id}`)
+    ];
+    return {
+        schema: CODEX_0_137_SCHEMA,
+        baseline: CODEX_0_137_BASELINE_TAG,
+        required_version: CODEX_0_137_VERSION,
+        release_evidence: {
+            upstream: 'openai/codex',
+            npm_package: '@openai/codex-sdk',
+            npm_version: '0.137.0',
+            manual_source: 'https://developers.openai.com/codex/codex-manual.md',
+            checked_topics: ['Codex SDK TypeScript', 'Codex SDK Python', 'CLI plugin/json/runtime/approval surfaces']
+        },
+        inherited_baselines: ['rust-v0.136.0', 'rust-v0.135.0', 'rust-v0.134.0'],
+        detected_version: version,
+        available,
+        require_real: input.requireReal === true,
+        capabilities,
+        plugin_list_json_supported: supported(capabilities, 'plugin_list_json'),
+        thread_runtime_choice_supported: supported(capabilities, 'thread_runtime_choice'),
+        environment_scoped_approvals_supported: supported(capabilities, 'environment_scoped_approvals'),
+        ok: blockers.length === 0,
+        warnings: !input.requireReal && (!version || below) ? [`Codex ${CODEX_0_137_BASELINE_TAG} not detected; release:check treats this as warning-only.`] : [],
+        blockers
+    };
+}
+export async function collectCodex0137LocalEvidence(opts = {}) {
+    const bin = opts.codexBin || await which('codex');
+    if (!bin) {
+        return {
+            available: false,
+            versionText: '',
+            pluginListText: '',
+            debugModelsText: '',
+            doctorText: '',
+            warnings: ['codex_binary_missing']
+        };
+    }
+    const run = async (args) => runProcess(bin, args, { timeoutMs: 10000, maxOutputBytes: 64 * 1024 }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err.message || String(err)
+    }));
+    const [version, pluginList, debugModels, doctor] = await Promise.all([
+        run(['--version']),
+        run(['plugin', 'list', '--json']),
+        run(['debug', 'models', '--bundled']),
+        run(['doctor', '--json'])
+    ]);
+    return {
+        available: version.code === 0,
+        versionText: `${version.stdout || ''}${version.stderr || ''}`.trim(),
+        pluginListText: `${pluginList.stdout || ''}${pluginList.stderr || ''}`,
+        debugModelsText: summarizeCodexCommandOutput(`${debugModels.stdout || ''}${debugModels.stderr || ''}`, ['runtime', 'model', 'provider', 'thread']),
+        doctorText: summarizeCodexCommandOutput(`${doctor.stdout || ''}${doctor.stderr || ''}`, ['approval', 'environment', 'sandbox', 'profile', 'permission']),
+        warnings: [
+            ...(pluginList.code === 0 ? [] : ['codex_plugin_list_json_unavailable']),
+            ...(debugModels.code === 0 ? [] : ['codex_debug_models_unavailable']),
+            ...(doctor.code === 0 ? [] : ['codex_doctor_json_unavailable'])
+        ]
+    };
+}
+function capability(id, priority, status, detector) {
+    return { id, priority, status, detector, notes: [] };
+}
+function supported(capabilities, id) {
+    const status = capabilities.find((capability) => capability.id === id)?.status;
+    return status === 'detected' || status === 'release_baseline';
+}
+function looksLikeJson(value) {
+    const text = String(value || '').trim();
+    if (!text)
+        return false;
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function summarizeCodexCommandOutput(value, keywords) {
+    const text = String(value || '');
+    const lower = text.toLowerCase();
+    const matched = keywords.filter((keyword) => lower.includes(keyword.toLowerCase()));
+    return [
+        `raw_output_redacted=true`,
+        `bytes=${Buffer.byteLength(text, 'utf8')}`,
+        `sha256=${createHash('sha256').update(text).digest('hex')}`,
+        `matched_keywords=${matched.join(',') || 'none'}`
+    ].join(' ');
+}
+//# sourceMappingURL=codex-0-137-compat.js.map

package/dist/core/codex-app.js

@@ -4,6 +4,8 @@ import fsp from 'node:fs/promises';
 import { exists, runProcess } from './fsx.js';
 import { EMPTY_CODEX_INFO, getCodexInfo } from './codex-adapter.js';
 import { CODEX_CHROME_EXTENSION_DOC_URL, DEFAULT_CODEX_APP_PLUGINS as DEFAULT_CODEX_APP_PLUGIN_TUPLES, RESERVED_CODEX_PLUGIN_SKILL_NAMES } from './routes.js';
+import { PRODUCT_DESIGN_PLUGIN, normalizeProductDesignPluginEvidence } from './product-design-plugin.js';
+import { PRODUCT_DESIGN_AUTO_INSTALL_ENV, ensureProductDesignPluginInstalled, productDesignAutoInstallRequested } from './product-design-app-server.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';
@@ -128,6 +130,7 @@ export async function codexAppIntegrationStatus(opts = {}) {
     const chromePath = await findPluginCache('chrome', opts);
     const computerUsePath = await findPluginCache('computer-use', opts);
     const defaultPlugins = await codexDefaultPluginStatus(opts);
+    const productDesignPlugin = await codexProductDesignPluginStatus(opts);
     const pluginSkillShadows = await codexPluginSkillShadowStatus(opts);
     const fastModeConfig = await codexFastModeConfigStatus(opts);
     const computerUseMcpListed = /computer[-_ ]?use/i.test(mcpText);
@@ -209,6 +212,7 @@ export async function codexAppIntegrationStatus(opts = {}) {
             browser_use_cache: browserUsePath,
             chrome_cache: chromePath,
             default_plugins: defaultPlugins,
+            design_product: productDesignPlugin,
             skill_shadows: pluginSkillShadows,
             picker: {
                 ok: pluginPickerReady,
@@ -219,7 +223,7 @@ export async function codexAppIntegrationStatus(opts = {}) {
             }
         },
         chrome_extension: chromeExtension,
-        guidance: codexAppGuidance({ appInstalled, codex, mcpList, featureList, requiredFeatureFlags, requiredFeatureFlagsOk, defaultPlugins, pluginSkillShadows, fastModeConfig, gitActions, imageGenerationReady, inAppBrowserReady, browserUseFeatureReady, computerUseReady, browserUseReady, browserToolReady, computerUseMcpListed, browserUseMcpListed, chromeExtension, remoteControl })
+        guidance: codexAppGuidance({ appInstalled, codex, mcpList, featureList, requiredFeatureFlags, requiredFeatureFlagsOk, defaultPlugins, productDesignPlugin, pluginSkillShadows, fastModeConfig, gitActions, imageGenerationReady, inAppBrowserReady, browserUseFeatureReady, computerUseReady, browserUseReady, browserToolReady, computerUseMcpListed, browserUseMcpListed, chromeExtension, remoteControl })
     };
 }
 export async function codexChromeExtensionStatus(opts = {}) {
@@ -438,7 +442,7 @@ export function codexAccessTokenStatus(env = process.env) {
             : ['No CODEX_ACCESS_TOKEN detected in the current process environment. This is fine for interactive ChatGPT login or API-key auth.']
     };
 }
-export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, requiredFeatureFlags = {}, requiredFeatureFlagsOk = true, defaultPlugins = { ok: true, missing_enabled: [] }, pluginSkillShadows = { ok: true, blocking: [] }, fastModeConfig = { ok: true, blockers: [] }, gitActions = { ok: true, blockers: [] }, imageGenerationReady, inAppBrowserReady, browserUseFeatureReady, computerUseReady, browserUseReady, browserToolReady, computerUseMcpListed, browserUseMcpListed, chromeExtension, remoteControl }) {
+export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, requiredFeatureFlags = {}, requiredFeatureFlagsOk = true, defaultPlugins = { ok: true, missing_enabled: [] }, productDesignPlugin = null, pluginSkillShadows = { ok: true, blocking: [] }, fastModeConfig = { ok: true, blockers: [] }, gitActions = { ok: true, blockers: [] }, imageGenerationReady, inAppBrowserReady, browserUseFeatureReady, computerUseReady, browserUseReady, browserToolReady, computerUseMcpListed, browserUseMcpListed, chromeExtension, remoteControl }) {
     const lines = [];
     if (!appInstalled) {
         lines.push('Install and open Codex App for first-party MCP/plugin tools. SKS Zellij launch can still run with Codex CLI alone, but Codex Computer Use and imagegen/gpt-image-2 evidence will be unavailable until Codex App is ready.');
@@ -474,6 +478,18 @@ export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, re
         lines.push(`Codex default plugin source(s) missing: ${defaultPlugins.missing_installed.join(', ')}. The @ plugin picker can hide built-in surfaces when plugin files are absent even if config says enabled.`);
         lines.push('Run: sks doctor --fix, then restart Codex App if the plugin cache was just restored.');
     }
+    if (productDesignPlugin?.ok) {
+        lines.push(`Product Design plugin is ready for design routes via ${productDesignPlugin.source || 'verified evidence'} (${productDesignPlugin.id}).`);
+    }
+    else if (productDesignPlugin?.auto_install?.attempted) {
+        lines.push(`Product Design auto-install was attempted but did not produce ready evidence: ${(productDesignPlugin.blockers || []).join(', ') || 'unverified'}. Recheck with: ${productDesignPlugin.auto_install.command}`);
+    }
+    else if (productDesignPlugin?.app_server?.checked && !productDesignPlugin.app_server.ok) {
+        lines.push(`Product Design app-server lookup ran but is not ready: ${(productDesignPlugin.blockers || []).join(', ') || 'unverified'}. Run: ${productDesignPlugin.auto_install?.command || 'sks codex-app product-design --json'}`);
+    }
+    else if (productDesignPlugin?.remote_lookup_required) {
+        lines.push(`Product Design is a remote vertical marketplace plugin and may not appear in \`codex plugin list\`; design routes should run ${productDesignPlugin.auto_install?.command || 'sks codex-app product-design --json'} or set ${PRODUCT_DESIGN_AUTO_INSTALL_ENV}=1 before falling back to legacy design.md skills.`);
+    }
     if (pluginSkillShadows?.generated?.length) {
         const names = pluginSkillShadows.generated.map((entry) => `${entry.name}:${entry.scope}`).join(', ');
         lines.push(`Codex plugin picker generated skill shadow(s) detected: ${names}. Generated SKS skills with first-party plugin names can hide @ plugin entries after upgrades.`);
@@ -536,6 +552,7 @@ export function formatCodexAppStatus(status, { includeRaw = false } = {}) {
         `App Flags:  ${status.features?.required_flags_ok ? 'ok' : `missing ${missingRequiredFeatureFlags(status.features?.required_flags).join(', ') || 'required flags'}`}`,
         `Fast UI:    ${status.features?.fast_mode_config?.ok ? 'ok' : `locked ${(status.features?.fast_mode_config?.blockers || []).join(', ') || 'config'}`}`,
         `Default Plugins:${status.plugins?.default_plugins?.ok ? ' ok' : ` missing ${defaultPluginMissingSummary(status.plugins?.default_plugins) || 'plugin install/config'}`}`,
+        `Product Design:${productDesignStatusSummary(status.plugins?.design_product)}`,
         `Plugin Picker:${status.plugins?.picker?.ok ? ' ok' : ` blocked ${pluginPickerBlockers(status).join(', ') || 'config'}`}`,
         `Git Actions:${status.features?.git_actions?.ok ? ' ok' : ` blocked ${(status.features?.git_actions?.blockers || []).join(', ') || 'config'}`}`,
         `Chrome Ext: ${status.chrome_extension?.ok ? 'ok' : `setup ${(status.chrome_extension?.blockers || []).join(', ') || 'required'}`}`,
@@ -552,6 +569,30 @@ export function formatCodexAppStatus(status, { includeRaw = false } = {}) {
         lines.push('', status.features.stdout.trim());
     return lines.join('\n');
 }
+export function formatCodexProductDesignPluginStatus(status) {
+    const lines = [
+        'Codex App Product Design Plugin',
+        '',
+        `Ready:        ${status.ok ? 'yes' : 'no'}`,
+        `Installed:    ${status.installed ? 'yes' : 'no'}`,
+        `Enabled:      ${status.enabled === true ? 'yes' : status.enabled === false ? 'no' : 'unknown'}`,
+        `Source:       ${status.source || 'unverified'}`,
+        `Marketplace:  ${status.marketplace}`,
+        `Remote ID:    ${status.remote_plugin_id}`,
+        `Auto Install: ${status.auto_install?.requested ? 'requested' : 'not requested'}${status.auto_install?.attempted ? ' (attempted)' : ''}`,
+        `Command:      ${status.auto_install?.command || 'sks codex-app product-design --json'}`,
+        '',
+        ...(status.blockers || []).map((blocker) => `- ${blocker}`)
+    ];
+    if (status.remote_evidence?.missing_skills?.length) {
+        lines.push(`- missing skills: ${status.remote_evidence.missing_skills.join(', ')}`);
+    }
+    if (status.ok)
+        lines.push('- Product Design is ready for design routes.');
+    else if (!status.auto_install?.requested)
+        lines.push('- Run `sks codex-app product-design --json`, or set SKS_PRODUCT_DESIGN_AUTO_INSTALL=1 for design-route auto-ensure.');
+    return lines.join('\n');
+}
 function summarizeCodexMcpError(text) {
     const cleanLines = String(text || '')
         .split(/\r?\n/)
@@ -629,6 +670,76 @@ async function codexDefaultPluginStatus(opts = {}) {
         missing_enabled: missingEnabled
     };
 }
+export async function codexProductDesignPluginStatus(opts = {}) {
+    const home = opts.home || os.homedir();
+    const cwd = opts.cwd || process.cwd();
+    const globalConfigPath = path.join(home || '', '.codex', 'config.toml');
+    const projectConfigPath = path.join(cwd || '', '.codex', 'config.toml');
+    const globalConfig = await readTextIfExists(globalConfigPath);
+    const projectConfig = path.resolve(projectConfigPath) === path.resolve(globalConfigPath)
+        ? ''
+        : await readTextIfExists(projectConfigPath);
+    const configText = `${globalConfig}\n${projectConfig}`;
+    const plugin = { name: PRODUCT_DESIGN_PLUGIN.name, marketplace: PRODUCT_DESIGN_PLUGIN.marketplace };
+    const autoInstallProductDesign = productDesignAutoInstallRequested(opts);
+    const appServerStatus = opts.productDesignAppServerStatus || (autoInstallProductDesign
+        ? await ensureProductDesignPluginInstalled({
+            ...opts,
+            autoInstallProductDesign
+        })
+        : null);
+    const injectedRemoteEvidence = opts.productDesignPluginReadResponse
+        ? normalizeProductDesignPluginEvidence(opts.productDesignPluginReadResponse)
+        : null;
+    const appServerEvidence = appServerStatus?.remote_evidence?.schema === 'sks.product-design-plugin-evidence.v1'
+        ? appServerStatus.remote_evidence
+        : null;
+    const remoteEvidence = appServerEvidence || injectedRemoteEvidence;
+    const localSource = await findDefaultPluginSource(plugin, { home, configText });
+    const configEnabled = codexPluginEnabled(configText, plugin);
+    const enabled = remoteEvidence?.enabled === true ? true : configEnabled ? true : null;
+    const installed = Boolean(localSource) || remoteEvidence?.installed === true;
+    const ok = Boolean(remoteEvidence?.ok || (installed && enabled === true));
+    const remoteLookupRequired = !remoteEvidence?.ok && (!localSource || enabled !== true) && !appServerStatus?.checked;
+    const blockers = ok ? [] : Array.from(new Set([
+        ...(!installed ? ['product_design_plugin_not_installed_or_not_locally_visible'] : []),
+        ...(enabled !== true ? ['product_design_plugin_enabled_state_requires_remote_evidence'] : []),
+        ...(remoteLookupRequired ? ['product_design_remote_vertical_lookup_required'] : []),
+        ...(autoInstallProductDesign && appServerStatus && !appServerStatus.ok ? ['product_design_app_server_install_failed'] : []),
+        ...(appServerStatus?.blockers || [])
+    ]));
+    return {
+        schema: 'sks.codex-product-design-plugin-status.v1',
+        ok,
+        checked: true,
+        route_required_only: true,
+        id: PRODUCT_DESIGN_PLUGIN.id,
+        name: PRODUCT_DESIGN_PLUGIN.name,
+        display_name: PRODUCT_DESIGN_PLUGIN.display_name,
+        marketplace: PRODUCT_DESIGN_PLUGIN.marketplace,
+        marketplace_kind: PRODUCT_DESIGN_PLUGIN.marketplace_kind,
+        remote_plugin_id: PRODUCT_DESIGN_PLUGIN.remote_plugin_id,
+        installed,
+        enabled,
+        source: remoteEvidence?.ok
+            ? appServerStatus?.install_attempted ? 'app_server_plugin_install' : 'app_server_plugin_read'
+            : localSource ? 'local_plugin_cache_or_marketplace_source' : null,
+        local_source: localSource,
+        remote_evidence: remoteEvidence,
+        app_server: appServerStatus,
+        auto_install: {
+            requested: autoInstallProductDesign,
+            attempted: Boolean(appServerStatus?.install_attempted),
+            command: 'sks codex-app product-design --json',
+            env: PRODUCT_DESIGN_AUTO_INSTALL_ENV
+        },
+        remote_lookup_required: remoteLookupRequired,
+        app_server_read_params: PRODUCT_DESIGN_PLUGIN.app_server.read_params,
+        app_server_install_params: PRODUCT_DESIGN_PLUGIN.app_server.install_params,
+        app_server_list_params: PRODUCT_DESIGN_PLUGIN.app_server.list_params,
+        blockers
+    };
+}
 async function codexPluginSkillShadowStatus(opts = {}) {
     const home = opts.home || os.homedir();
     const cwd = opts.cwd || process.cwd();
@@ -754,6 +865,17 @@ function pluginPickerBlockers(status = {}) {
         out.push('fast_mode_config');
     return out;
 }
+function productDesignStatusSummary(status = {}) {
+    if (status.ok)
+        return ' ok';
+    if (status.auto_install?.attempted)
+        return ' install unverified';
+    if (status.remote_lookup_required)
+        return ' remote lookup required';
+    if (status.app_server?.checked)
+        return ' app-server unverified';
+    return ' not checked';
+}
 function defaultPluginMissingSummary(defaultPlugins = {}) {
     return [
         ...(defaultPlugins?.missing_installed || []),

package/dist/core/codex-control/codex-control-proof.js

@@ -7,7 +7,8 @@ export async function writeCodexControlProof(root, input) {
         schema: CODEX_CONTROL_PROOF_SCHEMA,
         generated_at: nowIso(),
         ok: input.result.ok === true,
-        backend: 'codex-sdk',
+        backend: input.result.backend,
+        backend_family: input.result.backend_family,
         route: input.task.route,
         mission_id: input.task.missionId,
         work_item_id: input.task.workItemId || null,
@@ -22,6 +23,8 @@ export async function writeCodexControlProof(root, input) {
         output_schema_id: input.task.outputSchemaId,
         worker_result_path: input.result.workerResultPath,
         patch_envelope_path: input.result.patchEnvelopePath || null,
+        local_llm_proof_path: input.result.localLlmProofPath || null,
+        python_sdk_proof_path: input.result.pythonSdkProofPath || null,
         sandbox: input.sandbox || null,
         env: input.envProof || null,
         config: input.config ? redactCodexSdkConfig(input.config) : null,

package/dist/core/codex-control/codex-sdk-capability.js

@@ -37,7 +37,7 @@ export async function detectCodexSdkCapability(input = {}) {
         node_compatible: nodeCompatible,
         dynamic_import_ok: dynamicImportOk,
         structured_output_fake_smoke: structuredFake,
-        setup_action: blockers.includes('codex_sdk_unavailable') ? 'npm install @openai/codex-sdk@0.136.0' : null,
+        setup_action: blockers.includes('codex_sdk_unavailable') ? 'npm install @openai/codex-sdk@0.137.0' : null,
         blockers
     };
 }