sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/codex-0-135-compat-check.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'codex', 'codex-0-135-compat.js')).href);
+const evidence = await mod.collectCodex0135LocalEvidence();
+const matrix = mod.codex0135Matrix({
+    version: evidence.versionText,
+    available: evidence.available,
+    doctorText: evidence.doctorText,
+    permissionsText: evidence.permissionsText,
+    execHelp: evidence.execHelp,
+    resumeHelp: evidence.resumeHelp,
+    requireReal: process.argv.includes('--require-real')
+});
+const report = { ...matrix, local_evidence: evidence };
+await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'codex-0.135-compat.json'), `${JSON.stringify(report, null, 2)}\n`);
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'codex-plugin-inventory.json'), `${JSON.stringify(await collectPluginInventory(), null, 2)}\n`);
+emit(report);
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.codex-0.135-compat-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+async function collectPluginInventory() {
+    const codexHome = process.env.CODEX_HOME || path.join(process.env.HOME || '', '.codex');
+    const candidates = [
+        path.join(root, '.codex', 'plugins'),
+        path.join(codexHome, 'plugins'),
+        path.join(codexHome, 'plugins', 'cache')
+    ];
+    const entries = [];
+    for (const dir of candidates) {
+        const stat = await fs.stat(dir).catch(() => null);
+        if (!stat?.isDirectory())
+            continue;
+        for (const name of await fs.readdir(dir).catch(() => [])) {
+            if (!name || name.startsWith('.'))
+                continue;
+            entries.push({ source: dir, name });
+        }
+    }
+    return {
+        schema: 'sks.codex-plugin-inventory.v1',
+        generated_at: new Date().toISOString(),
+        ok: true,
+        state_owner: 'codex_app_server_or_codex_home',
+        project_config_policy: 'project .codex/config.toml must not store TUI/plugin runtime state',
+        sources_checked: candidates,
+        plugins: entries.sort((a, b) => `${a.source}/${a.name}`.localeCompare(`${b.source}/${b.name}`))
+    };
+}
+//# sourceMappingURL=codex-0-135-compat-check.js.map

package/dist/scripts/codex-0-136-compat-check.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'codex', 'codex-0-136-compat.js')).href);
+const evidence = await mod.collectCodex0136LocalEvidence();
+const matrix = mod.codex0136Matrix({
+    version: evidence.versionText,
+    available: evidence.available,
+    doctorText: evidence.doctorText,
+    archiveHelp: evidence.archiveHelp,
+    unarchiveHelp: evidence.unarchiveHelp,
+    appServerHelp: evidence.appServerHelp,
+    sandboxSetupHelp: evidence.sandboxSetupHelp,
+    remoteControlHelp: evidence.remoteControlHelp,
+    requireReal: process.argv.includes('--require-real')
+});
+const report = { ...matrix, local_evidence: evidence };
+await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'codex-0.136-compat.json'), `${JSON.stringify(report, null, 2)}\n`);
+emit(report);
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.codex-0.136-compat-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=codex-0-136-compat-check.js.map

package/dist/scripts/codex-0-137-compat-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'codex', 'codex-0-137-compat.js')).href);
+const evidence = await mod.collectCodex0137LocalEvidence();
+const matrix = mod.codex0137Matrix({
+    version: evidence.versionText,
+    available: evidence.available,
+    pluginListText: evidence.pluginListText,
+    debugModelsText: evidence.debugModelsText,
+    doctorText: evidence.doctorText,
+    requireReal: process.argv.includes('--require-real') || process.env.SKS_REQUIRE_CODEX_0137 === '1'
+});
+const report = { ...matrix, local_evidence: evidence };
+await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'codex-0.137-compat.json'), `${JSON.stringify(report, null, 2)}\n`);
+emit(report);
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.codex-0.137-compat-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=codex-0-137-compat-check.js.map

package/dist/scripts/codex-0138-capability-artifact-check.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+process.env.SKS_CODEX_0138_FAKE = '1';
+const mod = await importDist('core/codex-control/codex-0138-capability.js');
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-0138-cap-'));
+const result = await mod.writeCodex0138CapabilityArtifacts(root, { missionId: 'M-fixture' });
+const rootArtifact = JSON.parse(await fs.readFile(result.root_artifact, 'utf8'));
+const missionArtifact = JSON.parse(await fs.readFile(result.mission_artifact, 'utf8'));
+assertGate(rootArtifact.schema === 'sks.codex-0138-capability.v1' && missionArtifact.ok === true, 'capability artifacts must be written at root and mission scope', result);
+emitGate('codex:0138-capability-artifact', { root_artifact: path.basename(result.root_artifact), mission_artifact: path.basename(result.mission_artifact) });
+//# sourceMappingURL=codex-0138-capability-artifact-check.js.map

package/dist/scripts/codex-0138-capability-check.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+process.env.SKS_CODEX_0138_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.138.0';
+const mod = await importDist('core/codex-control/codex-0138-capability.js');
+const cap = await mod.detectCodex0138Capability({ codexBin: 'codex' });
+assertGate(cap.ok === true, 'Codex 0.138 capability detector must accept 0.138.0', cap);
+assertGate(cap.supports_app_handoff && cap.supports_plugin_json && cap.supports_image_path_exposure && cap.supports_model_defined_efforts && cap.supports_app_server_token_usage && cap.supports_oauth_mcp_prerefresh, '0.138 feature flags missing', cap);
+emitGate('codex:0138-capability', { parsed_version: cap.parsed_version });
+//# sourceMappingURL=codex-0138-capability-check.js.map

package/dist/scripts/codex-0138-doctor-check.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+import { writeTextAtomic } from '../core/fsx.js';
+process.env.SKS_CODEX_0138_FAKE = '1';
+const mod = await importDist('core/doctor/codex-0138-doctor.js');
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-0138-doctor-'));
+await writeTextAtomic(path.join(root, 'AGENTS.md'), '# fixture\n');
+const report = await mod.runCodex0138Doctor(root, { fix: true });
+assertGate(report.schema === 'sks.codex-0138-doctor.v1' && report.ok === true && report.checks.oauth_mcp_prerefresh.supported === true, 'Codex 0.138 doctor must check startup resilience and OAuth MCP pre-refresh support', report);
+emitGate('codex:0138-doctor', { fixed: report.fixed });
+//# sourceMappingURL=codex-0138-doctor-check.js.map

package/dist/scripts/codex-0138-feature-probes-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+process.env.SKS_CODEX_0138_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.138.0';
+process.env.SKS_CODEX_0138_PROBE = '1';
+process.env.SKS_CODEX_0138_FAKE_PLUGIN_JSON_FAIL = '1';
+const mod = await importDist('core/codex-control/codex-0138-capability.js');
+const cap = await mod.detectCodex0138Capability({ codexBin: 'codex' });
+assertGate(cap.ok === false && cap.probe_mode === 'feature-probe' && cap.supports_plugin_json === false && cap.blockers.includes('codex_plugin_json_probe_failed'), '0.138 feature probes must override coarse version-only plugin JSON support and mark failed probes not ok');
+emitGate('codex:0138-feature-probes', { probe_mode: cap.probe_mode, plugin_json: cap.feature_probe_results.plugin_json });
+//# sourceMappingURL=codex-0138-feature-probes-check.js.map

package/dist/scripts/codex-0139-capability-check.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+process.env.SKS_CODEX_0139_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.139.0';
+const mod = await importDist('core/codex-control/codex-0139-capability.js');
+const cap = await mod.detectCodex0139Capability({ codexBin: 'codex' });
+assertGate(cap.ok === true, 'Codex 0.139 capability detector must accept 0.139.0', cap);
+assertGate(cap.supports_code_mode_web_search
+    && cap.supports_rich_tool_schemas
+    && cap.supports_doctor_env_details
+    && cap.supports_marketplace_source_field
+    && cap.supports_plugin_catalog_cache
+    && cap.supports_sandbox_profile_alias
+    && cap.supports_interrupt_agent_rename, '0.139 feature flags missing', cap);
+// Older Codex must NOT claim 0.139 features.
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.138.0';
+const older = await mod.detectCodex0139Capability({ codexBin: 'codex' });
+assertGate(older.ok === false && older.supports_code_mode_web_search === false, '0.138 must not claim 0.139 features', older);
+// Marketplace source-field parser accepts array and wrapped shapes.
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify([{ name: 'm', source: 'https://example.com/catalog.json' }])) === true, 'marketplace source array shape', {});
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify({ marketplaces: [{ name: 'm', source: 'git' }] })) === true, 'marketplace source wrapped shape', {});
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify({ marketplaces: [{ name: 'm', root: '/tmp/codex-marketplace' }] })) === true, 'marketplace root locator wrapped shape', {});
+assertGate(mod.marketplaceSourcesPresent('not json') === false, 'marketplace parser rejects non-JSON', {});
+emitGate('codex:0139-capability', { parsed_version: cap.parsed_version });
+//# sourceMappingURL=codex-0139-capability-check.js.map

package/dist/scripts/codex-0139-code-mode-web-search-check.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const { writeJsonAtomic } = await importDist('core/fsx.js');
+const mod = await importDist('core/codex-control/codex-0139-capability.js');
+process.env.SKS_CODEX_0139_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.139.0';
+delete process.env.SKS_CODEX_0139_PROBE;
+const cap = await mod.detectCodex0139Capability({ codexBin: 'codex' });
+const policy = {
+    schema: 'sks.codex-0139-code-mode-web-search-policy.v1',
+    ok: cap.supports_code_mode_web_search === true,
+    allow_standalone_web_search_in_code_mode: cap.supports_code_mode_web_search === true,
+    actual_web_call_required_for_release: false,
+    capability: {
+        parsed_version: cap.parsed_version,
+        supports_code_mode_web_search: cap.supports_code_mode_web_search
+    },
+    blockers: cap.supports_code_mode_web_search === true ? [] : ['codex_code_mode_web_search_capability_missing']
+};
+await writeJsonAtomic(path.join(root, '.sneakoscope', 'codex-0139-code-mode-web-search-policy.json'), policy);
+assertGate(policy.ok && policy.allow_standalone_web_search_in_code_mode, 'code-mode web search release marker must be enabled for 0.139 fixture', policy);
+emitGate('codex:0139-code-mode-web-search', { artifact: '.sneakoscope/codex-0139-code-mode-web-search-policy.json' });
+//# sourceMappingURL=codex-0139-code-mode-web-search-check.js.map

package/dist/scripts/codex-0139-code-mode-web-search-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-web-search-probe.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139WebSearchRealProbe({ root, requireReal: true, allowNetwork: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 120000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 code-mode web search real probe must pass', result);
+emitGate('codex:0139-code-mode-web-search-real', result.evidence);
+//# sourceMappingURL=codex-0139-code-mode-web-search-real-check.js.map

package/dist/scripts/codex-0139-doctor-env-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-doctor-real-probe.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139DoctorEnvRealProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 60000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 doctor env redaction real probe must pass', result);
+emitGate('codex:0139-doctor-env-real', result.evidence);
+//# sourceMappingURL=codex-0139-doctor-env-real-check.js.map

package/dist/scripts/codex-0139-doctor-env-redaction-check.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-capability.js');
+const fixture = {
+    editor: 'vim',
+    pager: 'less',
+    OPENAI_API_KEY: 'sk-secret',
+    CODEX_AUTH_TOKEN: 'secret-token-value',
+    PATH: '/usr/bin'
+};
+const redacted = mod.redactCodexDoctorEnvDetails(fixture);
+const text = JSON.stringify(redacted);
+assertGate(redacted.editor === 'vim' && redacted.pager === 'less' && redacted.PATH === '/usr/bin', 'doctor editor/pager/PATH env details must be retained', redacted);
+assertGate(redacted.OPENAI_API_KEY === '<redacted>' && redacted.CODEX_AUTH_TOKEN === '<redacted>', 'doctor secret env values must be redacted', redacted);
+assertGate(!text.includes('sk-secret'), 'doctor redaction output must not include raw sk token', redacted);
+emitGate('codex:0139-doctor-env-redaction', { retained: ['editor', 'pager', 'PATH'] });
+//# sourceMappingURL=codex-0139-doctor-env-redaction-check.js.map

package/dist/scripts/codex-0139-feature-probes-check.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-capability.js');
+process.env.SKS_CODEX_0139_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.139.0';
+process.env.SKS_CODEX_0139_PROBE = '1';
+clearFailureEnv();
+const cap = await mod.detectCodex0139Capability({ codexBin: 'codex' });
+assertGate(cap.ok === true && cap.probe_mode === 'feature-probe', 'Codex 0.139 feature probe mode must pass fixture', cap);
+for (const [name, status] of Object.entries(cap.feature_probe_results || {})) {
+    assertGate(status === 'passed', `feature probe must pass: ${name}`, cap.feature_probe_results);
+}
+process.env.SKS_CODEX_0139_FAKE_RICH_SCHEMA_FAIL = '1';
+const failed = await mod.detectCodex0139Capability({ codexBin: 'codex' });
+assertGate(failed.ok === false && failed.blockers.includes('codex_rich_tool_schema_probe_failed'), 'rich schema probe failure must block capability', failed);
+clearFailureEnv();
+emitGate('codex:0139-feature-probes', { probe_mode: cap.probe_mode, probe_count: Object.keys(cap.feature_probe_results || {}).length });
+function clearFailureEnv() {
+    for (const key of [
+        'SKS_CODEX_0139_FAKE_MARKETPLACE_FAIL',
+        'SKS_CODEX_0139_FAKE_PROFILE_ALIAS_FAIL',
+        'SKS_CODEX_0139_FAKE_INTERRUPT_FAIL',
+        'SKS_CODEX_0139_FAKE_RICH_SCHEMA_FAIL',
+        'SKS_CODEX_0139_FAKE_DOCTOR_ENV_FAIL',
+        'SKS_CODEX_0139_FAKE_WEB_SEARCH_FAIL'
+    ])
+        delete process.env[key];
+}
+//# sourceMappingURL=codex-0139-feature-probes-check.js.map

package/dist/scripts/codex-0139-image-path-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-image-path-real-probe.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139ImageReferencedPathRealProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 120000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 image referenced path real probe must pass', result);
+emitGate('codex:0139-image-path-real', result.evidence);
+//# sourceMappingURL=codex-0139-image-path-real-check.js.map

package/dist/scripts/codex-0139-interrupt-agent-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, readText } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-multi-agent-event-normalizer.js');
+const interrupt = mod.normalizeCodexMultiAgentEventName('interrupt_agent');
+const close = mod.normalizeCodexMultiAgentEventName('close_agent');
+const start = mod.normalizeCodexMultiAgentEventName('spawn_agent');
+assertGate(interrupt.canonical === 'interrupt_agent' && interrupt.stage === 'result', 'interrupt_agent must map to result stage', interrupt);
+assertGate(close.canonical === 'close_agent' && close.stage === 'result', 'close_agent must remain result stage', close);
+assertGate(start.canonical === 'start_agent' && start.stage === 'start', 'spawn_agent must map to start stage', start);
+const runtimeCore = readText('src/core/pipeline-internals/runtime-core.ts');
+assertGate(runtimeCore.includes('normalizeCodexMultiAgentEventName'), 'runtime-core subagent evidence must use the 0.139 normalizer');
+emitGate('codex:0139-interrupt-agent', { canonical_events: [interrupt.canonical, close.canonical, start.canonical] });
+//# sourceMappingURL=codex-0139-interrupt-agent-check.js.map

package/dist/scripts/codex-0139-interrupt-agent-real-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-multi-agent-real-probe.js');
+const result = await mod.runCodex0139InterruptAgentRealProbe({ requireReal: true });
+assertGate(result.ok === true, 'Codex 0.139 interrupt_agent real event stream probe must pass', result);
+emitGate('codex:0139-interrupt-agent-real', result.evidence);
+//# sourceMappingURL=codex-0139-interrupt-agent-real-check.js.map

package/dist/scripts/codex-0139-marketplace-source-check.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-capability.js');
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify([{ name: 'default', source: 'remote' }])) === true, 'array marketplace shape with source must pass');
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify({ marketplaces: [{ name: 'default', source: 'remote' }] })) === true, 'marketplaces wrapper with source must pass');
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify({ items: [{ name: 'default', source: 'remote' }] })) === true, 'items wrapper with source must pass');
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify({ marketplaces: [{ name: 'default', root: '/tmp/codex-marketplace' }] })) === true, 'marketplaces wrapper with root locator must pass');
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify([])) === true, 'empty marketplace list must not fail');
+assertGate(mod.marketplaceSourcesPresent('not-json') === false, 'non-json marketplace output must fail');
+assertGate(mod.marketplaceSourcesPresent(JSON.stringify([{ name: 'missing-source' }])) === false, 'non-empty rows must expose source locator');
+emitGate('codex:0139-marketplace-source');
+//# sourceMappingURL=codex-0139-marketplace-source-check.js.map

package/dist/scripts/codex-0139-plugin-cache-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-plugin-real-probes.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139PluginCacheRealProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 60000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 plugin cached catalog real probe must pass', result);
+emitGate('codex:0139-plugin-cache-real', result.evidence);
+//# sourceMappingURL=codex-0139-plugin-cache-real-check.js.map

package/dist/scripts/codex-0139-plugin-marketplace-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-plugin-real-probes.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139MarketplaceSourceRealProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 60000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 plugin marketplace source real probe must pass', result);
+emitGate('codex:0139-plugin-marketplace-real', result.evidence);
+//# sourceMappingURL=codex-0139-plugin-marketplace-real-check.js.map

package/dist/scripts/codex-0139-real-probe-summary-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-real-probe-summary.js');
+const { summary } = await mod.writeCodex0139RealProbeSummary(root);
+assertGate(summary.schema === 'sks.codex-0139-real-probe-summary.v1', 'Codex 0.139 real probe summary schema mismatch', summary);
+assertGate(summary.require_real ? summary.ok === true : true, 'require-real probe summary must have no skipped or failed probes', summary);
+emitGate('codex:0139-real-probe-summary', {
+    summary_ok: summary.ok,
+    actual_cli_probe_count: summary.actual_cli_probe_count,
+    skipped_count: summary.skipped_count,
+    failed_count: summary.failed_count
+});
+//# sourceMappingURL=codex-0139-real-probe-summary-check.js.map

package/dist/scripts/codex-0139-real-probes-check.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const args = process.argv.slice(2);
+const requireReal = args.includes('--require-real');
+const allowNetwork = args.includes('--allow-network');
+const allowDesktop = args.includes('--allow-desktop');
+const json = args.includes('--json');
+const timeoutMs = Number(readArg('--timeout-ms') || process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 120000);
+const missionId = readArg('--mission-id') || process.env.SKS_MISSION_ID || process.env.SNEAKOSCOPE_MISSION_ID || null;
+const probes = readRepeated('--probe');
+const mod = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const writer = await importDist('core/codex-control/codex-0139-real-probes.js');
+const result = await mod.runCodex0139RealProbes({ root, missionId, requireReal, allowNetwork, allowDesktop, timeoutMs, probes });
+const artifacts = await writer.writeCodex0139RealProbeResult(root, result, { missionId, writeDist: true });
+assertGate(result.overall_ok === true || !requireReal, requireReal ? 'codex:0139-real-probes:require-real failed' : 'codex:0139-real-probes optional probe runner failed', result);
+emitGate(requireReal ? 'codex:0139-real-probes:require-real' : 'codex:0139-real-probes', {
+    overall_ok: result.overall_ok,
+    parsed_version: result.parsed_version,
+    skipped: result.skipped,
+    blockers: result.blockers,
+    artifact: '.sneakoscope/codex-0139-real-probes.json',
+    mission_artifact: artifacts.mission_artifact ? `.sneakoscope/missions/${missionId}/codex-0139-real-probes.json` : null,
+    ...(json ? { result } : {})
+});
+function readArg(name) {
+    const idx = args.indexOf(name);
+    return idx >= 0 ? args[idx + 1] : null;
+}
+function readRepeated(name) {
+    const out = [];
+    for (let i = 0; i < args.length; i += 1)
+        if (args[i] === name && args[i + 1])
+            out.push(args[i + 1]);
+    return out;
+}
+//# sourceMappingURL=codex-0139-real-probes-check.js.map

package/dist/scripts/codex-0139-rich-tool-schema-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-tool-schema-fixtures.js');
+const result = mod.evaluateCodex0139RichToolSchemaPreservation();
+assertGate(result.ok === true, 'oneOf/allOf rich tool schema fixture must survive SKS schema bridge', result);
+emitGate('codex:0139-rich-tool-schema', {
+    oneOf: result.top_level_oneOf_preserved,
+    allOf: result.top_level_allOf_preserved,
+    nested: result.nested_structure_preserved
+});
+//# sourceMappingURL=codex-0139-rich-tool-schema-check.js.map

package/dist/scripts/codex-0139-rich-tool-schema-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-rich-schema-real-probe.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139RichSchemaRealProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 60000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 rich tool schema real SKS bridge probe must pass', result);
+emitGate('codex:0139-rich-tool-schema-real', result.evidence);
+//# sourceMappingURL=codex-0139-rich-tool-schema-real-check.js.map

package/dist/scripts/codex-0139-sandbox-profile-alias-check.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const cap = await importDist('core/codex-control/codex-0139-capability.js');
+const cli = await importDist('core/codex/codex-cli-syntax-builder.js');
+assertGate(cap.codexHelpSupportsSandboxProfileAlias('Usage: codex exec -P, --profile <PROFILE>') === true, 'help output with -P alias must pass');
+assertGate(cap.codexHelpSupportsSandboxProfileAlias('Usage: codex exec --profile <PROFILE>') === false, 'help output without -P alias must fail');
+const shortArgs = cli.buildCodexExecArgs({ prompt: 'fixture', profile: 'sks-fast', profileAlias: 'short' });
+const longArgs = cli.buildCodexExecArgs({ prompt: 'fixture', profile: 'sks-fast', profileAlias: 'long' });
+assertGate(shortArgs.includes('-P') && shortArgs.includes('sks-fast'), 'Codex CLI builder must support -P profile alias', shortArgs);
+assertGate(longArgs.includes('--profile') && longArgs.includes('sks-fast'), 'Codex CLI builder must fall back to long --profile', longArgs);
+emitGate('codex:0139-sandbox-profile-alias', { short_alias: '-P', long_alias: '--profile' });
+//# sourceMappingURL=codex-0139-sandbox-profile-alias-check.js.map

package/dist/scripts/codex-0139-sandbox-profile-alias-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-sandbox-real-probe.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139SandboxProfileAliasProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 60000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 -P sandbox profile alias real probe must pass', result);
+emitGate('codex:0139-sandbox-profile-alias-real', result.evidence);
+//# sourceMappingURL=codex-0139-sandbox-profile-alias-real-check.js.map

package/dist/scripts/codex-0139-sandbox-proxy-real-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/codex-control/codex-0139-sandbox-real-probe.js');
+const runner = await importDist('core/codex-control/codex-0139-probe-runner.js');
+const codexBin = await runner.findCodex0139RealProbeBinary();
+const result = await mod.runCodex0139SandboxProxyPreservationProbe({ root, requireReal: true, timeoutMs: Number(process.env.SKS_CODEX_0139_REAL_PROBE_TIMEOUT_MS || 120000), codexBin });
+assertGate(result.ok === true, 'Codex 0.139 sandbox/proxy preservation real probe must pass', result);
+emitGate('codex:0139-sandbox-proxy-real', result.evidence);
+//# sourceMappingURL=codex-0139-sandbox-proxy-real-check.js.map

package/dist/scripts/codex-0140-bedrock-managed-auth-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCodex0140FeatureGate } from './codex-0140-feature-gate-lib.js';
+await runCodex0140FeatureGate('codex:0140-bedrock-managed-auth', 'bedrock_managed_auth');
+//# sourceMappingURL=codex-0140-bedrock-managed-auth-check.js.map

package/dist/scripts/codex-0140-capability-check.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { detectCodex0140Capability } from '../core/codex-control/codex-0140-capability.js';
+process.env.SKS_CODEX_0140_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.140.0';
+delete process.env.SKS_CODEX_0140_PROBE;
+const cap = await detectCodex0140Capability({ codexBin: 'codex' });
+assertGate(cap.ok === true && cap.supports_0140 === true, 'Codex 0.140 capability fixture must pass', cap);
+assertGate(Object.values(cap.feature_states).every((state) => state.supported === true && state.certainty === 'assumed_by_version'), 'version-only mode must mark 0.140 features as assumed, not probed', cap);
+assertGate(cap.warnings.some((warning) => warning.endsWith('_assumed_by_version')), 'version-only mode must warn about assumed feature support', cap);
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.139.0';
+const old = await detectCodex0140Capability({ codexBin: 'codex' });
+assertGate(old.ok === false && old.blockers.includes('codex_0_140_required_for_0140_features'), 'Codex 0.139 must not satisfy 0.140 capability', old);
+emitGate('codex:0140-capability', { features: Object.keys(cap.features).length });
+//# sourceMappingURL=codex-0140-capability-check.js.map

package/dist/scripts/codex-0140-deep-probes-check.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { detectCodex0140Capability } from '../core/codex-control/codex-0140-capability.js';
+const saved = {
+    fake: process.env.SKS_CODEX_0140_FAKE,
+    version: process.env.SKS_CODEX_VERSION_FAKE,
+    probe: process.env.SKS_CODEX_0140_PROBE,
+    usageFail: process.env.SKS_CODEX_0140_FAKE_USAGE_VIEWS_FAIL
+};
+try {
+    process.env.SKS_CODEX_0140_FAKE = '1';
+    process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.140.0';
+    delete process.env.SKS_CODEX_0140_PROBE;
+    delete process.env.SKS_CODEX_0140_FAKE_USAGE_VIEWS_FAIL;
+    const versionOnly = await detectCodex0140Capability({ codexBin: 'codex' });
+    assertGate(versionOnly.ok === true, '0.140 version-only capability fixture must pass', versionOnly);
+    assertGate(Object.values(versionOnly.feature_states).every((state) => state.certainty === 'assumed_by_version'), 'version-only mode must not pretend feature probes ran', versionOnly);
+    process.env.SKS_CODEX_0140_PROBE = '1';
+    const probed = await detectCodex0140Capability({ codexBin: 'codex' });
+    assertGate(probed.ok === true, '0.140 feature-probe fixture must pass', probed);
+    assertGate(Object.values(probed.feature_states).every((state) => state.certainty === 'fixture'), 'fixture feature-probe mode must expose fixture certainty', probed);
+    process.env.SKS_CODEX_0140_FAKE_USAGE_VIEWS_FAIL = '1';
+    const failed = await detectCodex0140Capability({ codexBin: 'codex' });
+    assertGate(failed.ok === false && failed.blockers.includes('codex_0140_usage_views_probe_failed'), 'failed feature probe must block capability', failed);
+    assertGate(failed.feature_states.usage_views.supported === false && failed.feature_states.usage_views.certainty === 'failed', 'failed feature state must be explicit', failed.feature_states.usage_views);
+    emitGate('codex:0140-deep-probes', { features: Object.keys(probed.feature_states).length });
+}
+finally {
+    restore('SKS_CODEX_0140_FAKE', saved.fake);
+    restore('SKS_CODEX_VERSION_FAKE', saved.version);
+    restore('SKS_CODEX_0140_PROBE', saved.probe);
+    restore('SKS_CODEX_0140_FAKE_USAGE_VIEWS_FAIL', saved.usageFail);
+}
+function restore(key, value) {
+    if (value === undefined)
+        delete process.env[key];
+    else
+        process.env[key] = value;
+}
+//# sourceMappingURL=codex-0140-deep-probes-check.js.map

package/dist/scripts/codex-0140-feature-probes-check.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { detectCodex0140Capability } from '../core/codex-control/codex-0140-capability.js';
+process.env.SKS_CODEX_0140_FAKE = '1';
+process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.140.0';
+process.env.SKS_CODEX_0140_PROBE = '1';
+clearFailureEnv();
+const cap = await detectCodex0140Capability({ codexBin: 'codex' });
+assertGate(cap.ok === true && cap.probe_mode === 'feature-probe', 'Codex 0.140 feature probe fixture must pass', cap);
+for (const [name, status] of Object.entries(cap.feature_probe_results || {})) {
+    assertGate(status === 'passed', `Codex 0.140 feature probe must pass: ${name}`, cap.feature_probe_results);
+}
+process.env.SKS_CODEX_0140_FAKE_USAGE_VIEWS_FAIL = '1';
+const failed = await detectCodex0140Capability({ codexBin: 'codex' });
+assertGate(failed.ok === false && failed.blockers.includes('codex_0140_usage_views_probe_failed'), 'failed 0.140 feature probe must block capability', failed);
+clearFailureEnv();
+emitGate('codex:0140-feature-probes', { probe_count: Object.keys(cap.feature_probe_results || {}).length });
+function clearFailureEnv() {
+    for (const key of Object.keys(process.env)) {
+        if (/^SKS_CODEX_0140_FAKE_.*_FAIL$/.test(key))
+            delete process.env[key];
+    }
+}
+//# sourceMappingURL=codex-0140-feature-probes-check.js.map

package/dist/scripts/codex-0140-goal-attachment-preservation-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { assertGate } from './sks-1-18-gate-lib.js';
+import { runCodex0140FeatureGate } from './codex-0140-feature-gate-lib.js';
+const payload = { text: 'x'.repeat(70_000), attachments: [{ type: 'image', path: '/tmp/codex-0140-goal.png', sha256: 'fixture' }] };
+const restored = JSON.parse(JSON.stringify(payload));
+assertGate(restored.text.length === payload.text.length && restored.attachments[0]?.path === payload.attachments[0]?.path, 'goal attachment preservation fixture must keep large text and image path metadata');
+await runCodex0140FeatureGate('codex:0140-goal-attachment-preservation', 'goal_attachment_preservation');
+//# sourceMappingURL=codex-0140-goal-attachment-preservation-check.js.map

package/dist/scripts/codex-0140-goal-attachment-roundtrip-check.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { probeGoalAttachmentPreservation } from '../core/codex-control/codex-0140-feature-probes.js';
+const result = await probeGoalAttachmentPreservation('codex');
+assertGate(result.status === 'passed' && result.certainty === 'actual', 'goal attachment roundtrip must produce actual checksum evidence', result);
+assertGate(result.evidence.some((item) => item.startsWith('sks_goal_artifact_roundtrip_sha256:')), 'goal attachment roundtrip must include checksum evidence', result);
+assertGate(result.evidence.some((item) => /^large_text_bytes:\d+/.test(item)), 'goal attachment roundtrip must include large text evidence', result);
+emitGate('codex:0140-goal-attachment-roundtrip', { evidence: result.evidence.length });
+//# sourceMappingURL=codex-0140-goal-attachment-roundtrip-check.js.map