sneakoscope 2.0.14 → 2.0.16

package/dist/scripts/official-docs-compat-report.js

@@ -1,304 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import https from 'node:https';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-const RELEASE_VERSION = pkg.version;
-const jsonPath = path.join(reportDir, `official-docs-compat-${RELEASE_VERSION}.json`);
-const mdPath = path.join(reportDir, `official-docs-compat-${RELEASE_VERSION}.md`);
-const sources = {
-    codex_release: 'https://github.com/openai/codex/releases/tag/rust-v0.136.0',
-    codex_0135_release: 'https://github.com/openai/codex/releases/tag/rust-v0.135.0',
-    codex_0134_release: 'https://github.com/openai/codex/releases/tag/rust-v0.134.0',
-    codex_0133_release: 'https://github.com/openai/codex/releases/tag/rust-v0.133.0',
-    codex_config_schema: 'https://raw.githubusercontent.com/openai/codex/rust-v0.136.0/codex-rs/core/config.schema.json',
-    codex_hook_schema_listing: 'https://api.github.com/repos/openai/codex/contents/codex-rs/hooks/schema/generated?ref=rust-v0.136.0',
-    codex_chrome_extension: 'https://developers.openai.com/codex/app/chrome-extension',
-    codex_app_image_generation: 'https://developers.openai.com/codex/app/features#image-generation',
-    chatgpt_images_2: 'https://openai.com/index/introducing-chatgpt-images-2-0/',
-    chatgpt_images_2_safety_card: 'https://deploymentsafety.openai.com/chatgpt-images-2-0',
-    image_generation: 'https://developers.openai.com/api/docs/guides/image-generation',
-    gpt_image_2_model: 'https://developers.openai.com/api/docs/models/gpt-image-2',
-    structured_outputs: 'https://developers.openai.com/api/docs/guides/structured-outputs'
-};
-const codex0136ReleaseApi = 'https://api.github.com/repos/openai/codex/releases/tags/rust-v0.136.0';
-const codex0136Release = await fetchJson(codex0136ReleaseApi);
-const codex0136ReleaseHtml = codex0136Release.ok ? null : await fetchText(sources.codex_release);
-const codex0136ReleaseSource = codex0136Release.ok
-    ? codex0136Release
-    : {
-        ...codex0136ReleaseHtml,
-        statusCode: codex0136ReleaseHtml?.statusCode || codex0136Release.statusCode || null,
-        error: codex0136ReleaseHtml?.error || codex0136Release.error || null,
-        fallback_source: sources.codex_release
-    };
-const codex0136ReleaseBody = String(codex0136Release.json?.body || codex0136ReleaseHtml?.body || '');
-const codexConfigSchema = await fetchText(sources.codex_config_schema);
-const codexHookSchemaListingApi = await fetchText(sources.codex_hook_schema_listing, { accept: 'application/vnd.github+json' });
-const codexHookSchemaListing = codexHookSchemaListingApi.ok
-    ? codexHookSchemaListingApi
-    : await fetchHookSchemaListingFallback(codexHookSchemaListingApi);
-const codexChromeExtension = await fetchText(sources.codex_chrome_extension);
-const codexAppImageGeneration = await fetchText(sources.codex_app_image_generation);
-const chatgptImages2SafetyCard = await fetchText(sources.chatgpt_images_2_safety_card);
-const openaiImageGeneration = await fetchText(sources.image_generation);
-const gptImage2Model = await fetchText(sources.gpt_image_2_model);
-const structuredOutputs = await fetchText(sources.structured_outputs);
-const sourceValidations = [
-    sourceRow('codex_release', sources.codex_release, codex0136ReleaseSource, codex0136ReleaseBody, [
-        'codex archive',
-        'codex app-server --stdio',
-        'CODEX_API_KEY',
-        'server tokens',
-        'codex sandbox setup --elevated',
-        'image generation extension',
-        '/diff',
-        'AWS_REGION',
-        'rmcp'
-    ]),
-    sourceRow('codex_config_schema', sources.codex_config_schema, codexConfigSchema, codexConfigSchema.body || '', [
-        '$ref',
-        'definitions',
-        'mcp_servers',
-        'profiles'
-    ]),
-    sourceRow('codex_hook_schema_listing', sources.codex_hook_schema_listing, codexHookSchemaListing, codexHookSchemaListing.body || '', [
-        'subagent-start.command.input.schema.json',
-        'subagent-stop.command.input.schema.json',
-        'permission-request.command.input.schema.json'
-    ]),
-    sourceRow('codex_chrome_extension', sources.codex_chrome_extension, codexChromeExtension, codexChromeExtension.body || '', [
-        'Chrome extension',
-        'Codex',
-        'browser'
-    ]),
-    sourceRow('codex_app_image_generation', sources.codex_app_image_generation, codexAppImageGeneration, codexAppImageGeneration.body || '', [
-        'Image generation',
-        '$imagegen',
-        'gpt-image-2'
-    ]),
-    sourceRow('chatgpt_images_2_safety_card', sources.chatgpt_images_2_safety_card, chatgptImages2SafetyCard, chatgptImages2SafetyCard.body || '', [
-        'ChatGPT Images 2.0',
-        'image generation',
-        'thinking mode'
-    ]),
-    sourceRow('image_generation', sources.image_generation, openaiImageGeneration, openaiImageGeneration.body || '', [
-        'Image generation',
-        'gpt-image-2',
-        'GPT Image'
-    ]),
-    sourceRow('gpt_image_2_model', sources.gpt_image_2_model, gptImage2Model, gptImage2Model.body || '', [
-        'gpt-image-2',
-        'Image generation',
-        'GPT Image'
-    ]),
-    sourceRow('structured_outputs', sources.structured_outputs, structuredOutputs, structuredOutputs.body || '', [
-        'Structured Outputs',
-        'json_schema',
-        'strict'
-    ])
-];
-const checks = [
-    row('codex_0136_release_matrix', 'rust-v0.136.0', 'src/core/codex/codex-0-136-compat.ts', ['rust-v0.136.0', 'session_archive_restore', 'app_server_resume_status_stdio', 'remote_api_key_registration_server_tokens', 'command_safety_hardening']),
-    row('codex_0136_release_gate', 'rust-v0.136.0', 'src/scripts/codex-0-136-compat-check.ts', ['sks.codex-0.136-compat-check.v1', 'codex-0.136-compat.json', '--require-real']),
-    row('codex_0136_aggregate_report', 'rust-v0.136.0', 'src/core/codex-compat/codex-compat-report.ts', ['codex_0_136', 'collectCodex0136LocalEvidence', 'session_archive_supported']),
-    row('codex_0135_release_matrix', 'rust-v0.135.0', 'src/core/codex/codex-0-135-compat.ts', ['rust-v0.135.0', 'named_permission_profiles', 'responses_retry_centralized']),
-    row('codex_0134_release_matrix', 'rust-v0.134.0', 'src/core/codex/codex-0-134-compat.ts', ['rust-v0.134.0', 'profile_primary_selector', 'local_conversation_history_search', 'mcp_readonly_parallel_hint', 'managed_network_proxy_env']),
-    row('codex_0134_official_compat_report', 'rust-v0.134.0', 'src/scripts/codex-0-134-official-compat-report.ts', ['sks.codex-0-134-official-compat.v1', 'release_source_url', 'source_delta']),
-    row('codex_0134_profile_primary', 'rust-v0.134.0', 'src/core/codex/codex-cli-syntax-builder.ts', ['--profile', '--ignore-user-config', 'cannot combine --profile with --ignore-user-config']),
-    row('codex_0134_managed_proxy_env', 'rust-v0.134.0', 'src/core/codex/managed-proxy-env.ts', ['MANAGED_PROXY_ENV_KEYS', 'HTTPS_PROXY', 'redactProxyValue']),
-    row('codex_0134_history_search', 'rust-v0.134.0', 'src/core/source-intelligence/codex-history-search.ts', ['CODEX_HISTORY_SEARCH_SCHEMA', 'case_insensitive', 'redactPreview']),
-    row('mcp_0134_modernization', 'rust-v0.134.0', 'src/core/mcp/mcp-0-134-policy.ts', ['readOnlyHint', 'candidate_parallel_readonly', '$defs', 'oauth_configured']),
-    row('codex_0133_release_matrix', 'rust-v0.133.0', 'src/core/codex-compat/codex-0-133.ts', ['rust-v0.133.0', 'goals_default_enabled', 'remote_control_foreground_app_server', 'permission_profiles_requirements']),
-    row('codex_0133_official_compat_report', 'rust-v0.133.0', 'src/scripts/codex-0-133-official-compat-report.ts', ['sks.codex-0-133-official-compat.v1', 'release_source_url', 'structured_output_inheritance']),
-    row('hook_official_hash_oracle', 'OpenAI Codex hook trust', 'src/core/codex-hooks/codex-hook-official-hash-oracle.ts', ['sks.codex-hook-hash-oracle.v1', 'golden-fixture', 'unavailable']),
-    row('agent_multisession_output_schema', 'Codex 0.133 exec --output-schema', 'src/core/agents/agent-runner-codex-exec.ts', ['--output-schema', 'agent-result.schema.json', 'session_id']),
-    row('codex_plugin_discovery_marketplaces', 'rust-v0.133.0', 'src/core/codex-compat/codex-0-133.ts', ['plugin_discovery_marketplaces', 'plugins and marketplaces']),
-    row('codex_extension_lifecycle_events', 'rust-v0.133.0', 'src/core/codex-compat/codex-0-133.ts', ['extension_lifecycle_events', 'turn/tool/model/item phases']),
-    row('codex_exec_resume_output_schema', 'rust-v0.133.0', 'src/core/codex-exec-output-schema.ts', ['runCodexExecResumeWithOutputSchema', '--output-schema', '--output-last-message']),
-    row('agent_output_schema_validator', 'rust-v0.133.0', 'src/core/agents/agent-worker-pipeline.ts', ['validateAgentWorkerResult', 'agent-result', 'schema']),
-    row('completion_proof_output_schema_runner', 'rust-v0.133.0', 'src/core/proof/proof-writer.ts', ['generateCompletionProofWithOutputSchema', 'completion-proof']),
-    row('wrongness_output_schema_runner', 'rust-v0.133.0', 'src/core/triwiki-wrongness/wrongness-ledger.ts', ['extractWrongnessWithOutputSchema', 'wrongness-record']),
-    row('codex_app_server_image_fidelity', 'rust-v0.133.0', 'src/core/image-ux-review.ts', ['high_fidelity_automatic', 'image_size_relation']),
-    row('codex_memory_summary_rebuild', 'rust-v0.133.0', 'src/scripts/memory-summary-rebuild-check.ts', ['memory-summary']),
-    row('codex_repeated_blocker_stop', 'rust-v0.133.0', 'src/core/image-ux-review/fix-loop.ts', ['repeated_blocker_stop']),
-    row('codex_app_imagegen_evidence_policy', 'Codex App image generation docs', 'src/core/imagegen/imagegen-capability.ts', ['Codex App $imagegen', 'codex_app_builtin_output_required', 'capability_detection_is_not_output_proof', 'official_codex_app_substitute']),
-    row('codex_chrome_extension_web_verification_policy', 'Codex Chrome Extension docs', 'src/core/routes.ts', ['CODEX_CHROME_EXTENSION_DOC_URL', 'CODEX_WEB_VERIFICATION_POLICY', 'CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE']),
-    row('chatgpt_images_2_prompt_policy', 'ChatGPT Images 2.0 announcement + gpt-image-2 docs', 'src/core/routes.ts', ['OPENAI_CHATGPT_IMAGES_2_DOC_URL', 'ChatGPT Images 2.0 / GPT Image 2.0 with gpt-image-2', 'IMAGEGEN_SOCIAL_SOURCE_POLICY']),
-    row('gpt_image_2_generation_edit', 'OpenAI Image Generation docs', 'src/core/image-ux-review/imagegen-adapter.ts', ['gpt-image-2', '/v1/images/edits', 'FormData']),
-    row('gpt_image_2_high_fidelity_auto', 'OpenAI Image Generation docs', 'src/core/image-ux-review/imagegen-adapter.ts', ['high_fidelity_automatic', 'input_fidelity']),
-    row('structured_outputs_strict_schema', 'OpenAI Structured Outputs docs', 'src/core/structured-output-adapter.ts', ['json_schema', 'strict', 'additionalProperties'])
-];
-const warnings = [];
-for (const check of checks) {
-    if (!check.ok)
-        warnings.push(`${check.feature}:${check.missing.join(',')}`);
-}
-for (const source of sourceValidations) {
-    if (!source.ok)
-        warnings.push(`${source.feature}:${source.missing.join(',') || source.error || 'source_unavailable'}`);
-}
-const report = {
-    schema: 'sks.official-docs-compat.v1',
-    generated_at: new Date().toISOString(),
-    codex_release_baseline: 'rust-v0.136.0',
-    codex_inherited_baselines: ['rust-v0.135.0', 'rust-v0.134.0', 'rust-v0.133.0', 'rust-v0.132.0'],
-    codex_app_image_generation_docs_baseline: sources.codex_app_image_generation,
-    codex_chrome_extension_docs_baseline: sources.codex_chrome_extension,
-    chatgpt_images_2_docs_baseline: sources.chatgpt_images_2_safety_card,
-    chatgpt_images_2_announcement_reference: sources.chatgpt_images_2,
-    openai_image_generation_docs_baseline: sources.image_generation,
-    openai_structured_outputs_docs_baseline: sources.structured_outputs,
-    rules: {
-        gpt_image_2_image_input_fidelity: 'high_fidelity_automatic; omit unsupported input_fidelity',
-        chatgpt_images_2_prompting: 'Codex App image prompts should explicitly request ChatGPT Images 2.0 / GPT Image 2.0 with gpt-image-2 when newest-model output is required',
-        codex_app_imagegen_evidence: 'full SKS visual evidence requires Codex App $imagegen output; API fallbacks are non-Codex evidence',
-        codex_chrome_extension_web_verification: 'web/browser/webapp verification uses Codex Chrome Extension first; Computer Use is native Mac/non-web only',
-        structured_outputs: 'prefer strict json_schema/text.format when schema adherence matters',
-        codex_output_schema: 'prefer codex exec resume --output-schema for session-preserving structured extraction',
-        codex_0_136_release_mapping: 'archive/unarchive, app-server --stdio, CODEX_API_KEY registration, server-token remote-control, elevated Windows sandbox setup, native image generation extension pipeline, and command-safety hardening are tracked in the 0.136 compatibility matrix'
-    },
-    sources,
-    source_validations: sourceValidations,
-    checks,
-    warnings,
-    ok: checks.every((check) => check.ok) && sourceValidations.every((source) => source.ok)
-};
-fs.mkdirSync(reportDir, { recursive: true });
-fs.writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`);
-fs.writeFileSync(mdPath, renderMarkdown(report));
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-function row(feature, baseline, relFile, needles) {
-    const file = path.join(root, relFile);
-    const text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-    const missing = needles.filter((needle) => !text.includes(needle));
-    return {
-        feature,
-        baseline,
-        file: relFile,
-        status: missing.length ? 'warning' : 'mapped',
-        ok: missing.length === 0,
-        missing,
-        release_readiness: true
-    };
-}
-function sourceRow(feature, url, fetchResult, body, needles) {
-    const missing = fetchResult.ok ? needles.filter((needle) => !body.includes(needle)) : needles;
-    return {
-        feature,
-        url,
-        status_code: fetchResult.statusCode || null,
-        status: fetchResult.ok && missing.length === 0 ? 'verified' : 'warning',
-        ok: fetchResult.ok === true && missing.length === 0,
-        missing,
-        error: fetchResult.error || null,
-        fallback_source: fetchResult.fallback_source || null
-    };
-}
-function fetchJson(url) {
-    return new Promise((resolve) => {
-        const req = https.get(url, {
-            headers: {
-                'User-Agent': 'sneakoscope-official-docs-check',
-                Accept: 'application/vnd.github+json'
-            },
-            timeout: 20000
-        }, (res) => {
-            let body = '';
-            res.setEncoding('utf8');
-            res.on('data', (chunk) => { body += chunk; });
-            res.on('end', () => {
-                try {
-                    const json = JSON.parse(body);
-                    resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, statusCode: res.statusCode, json });
-                }
-                catch (err) {
-                    resolve({ ok: false, statusCode: res.statusCode, error: err.message, body: body.slice(0, 1000) });
-                }
-            });
-        });
-        req.on('timeout', () => {
-            req.destroy(new Error('timeout'));
-        });
-        req.on('error', (err) => {
-            resolve({ ok: false, error: err.message });
-        });
-    });
-}
-function fetchText(url, opts = {}) {
-    return new Promise((resolve) => {
-        const req = https.get(url, {
-            headers: {
-                'User-Agent': opts.userAgent || 'sneakoscope-official-docs-check',
-                Accept: opts.accept || 'text/html,application/json,text/plain,*/*'
-            },
-            timeout: 20000
-        }, (res) => {
-            let body = '';
-            res.setEncoding('utf8');
-            res.on('data', (chunk) => { body += chunk; });
-            res.on('end', () => {
-                resolve({
-                    ok: res.statusCode >= 200 && res.statusCode < 300,
-                    statusCode: res.statusCode,
-                    body,
-                    error: res.statusCode >= 200 && res.statusCode < 300 ? null : `http_${res.statusCode}`
-                });
-            });
-        });
-        req.on('timeout', () => {
-            req.destroy(new Error('timeout'));
-        });
-        req.on('error', (err) => {
-            resolve({ ok: false, error: err.message, body: '' });
-        });
-    });
-}
-async function fetchHookSchemaListingFallback(apiResult) {
-    const schemaNames = [
-        'subagent-start.command.input.schema.json',
-        'subagent-stop.command.input.schema.json',
-        'permission-request.command.input.schema.json'
-    ];
-    const fetched = await Promise.all(schemaNames.map(async (name) => {
-        const url = `https://raw.githubusercontent.com/openai/codex/rust-v0.136.0/codex-rs/hooks/schema/generated/${name}`;
-        const result = await fetchText(url, { accept: 'application/json,text/plain,*/*' });
-        return { name, url, result };
-    }));
-    const ok = fetched.every((row) => row.result.ok);
-    return {
-        ok,
-        statusCode: ok ? 200 : apiResult.statusCode || null,
-        body: fetched.filter((row) => row.result.ok).map((row) => row.name).join('\n'),
-        error: ok ? null : `api_${apiResult.statusCode || apiResult.error || 'unavailable'};raw_missing:${fetched.filter((row) => !row.result.ok).map((row) => row.name).join(',')}`,
-        fallback_source: 'raw.githubusercontent.com/openai/codex/rust-v0.136.0/codex-rs/hooks/schema/generated/*.json'
-    };
-}
-function renderMarkdown(report) {
-    const lines = [
-        `# SKS ${RELEASE_VERSION} Official Docs Compatibility`,
-        '',
-        `- Schema: \`${report.schema}\``,
-        `- Codex baseline: \`${report.codex_release_baseline}\``,
-        `- ChatGPT Images 2.0 docs: ${report.chatgpt_images_2_docs_baseline}`,
-        `- Image docs: ${report.openai_image_generation_docs_baseline}`,
-        `- Structured Outputs docs: ${report.openai_structured_outputs_docs_baseline}`,
-        '',
-        '| Feature | Baseline | Result |',
-        '| --- | --- | --- |'
-    ];
-    for (const check of report.checks)
-        lines.push(`| \`${check.feature}\` | ${check.baseline} | ${check.status} |`);
-    lines.push('', '| Official Source | Result |', '| --- | --- |');
-    for (const source of report.source_validations)
-        lines.push(`| \`${source.feature}\` | ${source.status} |`);
-    lines.push('', `Warnings: ${report.warnings.length ? report.warnings.join(', ') : 'None'}`, '');
-    return `${lines.join('\n')}\n`;
-}
-//# sourceMappingURL=official-docs-compat-report.js.map

package/dist/scripts/packlist-performance-check.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 1250);
-const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 6 * 1024 * 1024);
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024);
-function runNpmPack() {
-    const npmCli = process.env.npm_execpath; // set when invoked via `npm run`
-    const npmCache = process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache');
-    fs.mkdirSync(npmCache, { recursive: true });
-    const argv = ['pack', '--dry-run', '--json', '--ignore-scripts'];
-    const opts = {
-        cwd: root,
-        encoding: 'utf8',
-        maxBuffer: 32 * 1024 * 1024,
-        env: {
-            ...process.env,
-            npm_config_cache: npmCache,
-            NPM_CONFIG_CACHE: npmCache
-        }
-    };
-    const res = npmCli
-        ? spawnSync(process.execPath, [npmCli, ...argv], opts)
-        : spawnSync('npm', argv, opts);
-    return res;
-}
-const res = runNpmPack();
-assertGate(res.status === 0, 'npm_pack_failed', { stderr: res.stderr });
-let info;
-try {
-    const parsed = JSON.parse(res.stdout);
-    info = Array.isArray(parsed) ? parsed[0] : parsed;
-}
-catch (err) {
-    assertGate(false, 'npm_pack_unparseable', { error: String(err && err.message ? err.message : err) });
-}
-const files = info.files.map((f) => f.path);
-const runtimeManifest = JSON.parse(fs.readFileSync(path.join(root, 'runtime-required-scripts.json'), 'utf8'));
-assertGate(runtimeManifest.schema === 'sks.runtime-required-scripts.v1' && Array.isArray(runtimeManifest.scripts), 'runtime required scripts manifest invalid', runtimeManifest);
-assertGate(info.entryCount <= MAX_FILES, 'packlist_file_count_over_limit', { entryCount: info.entryCount, max_files: MAX_FILES });
-assertGate(info.unpackedSize <= MAX_UNPACKED, 'packlist_unpacked_over_limit', { unpackedSize: info.unpackedSize, max_unpacked: MAX_UNPACKED });
-assertGate(info.size <= MAX_PACKED, 'packlist_packed_over_limit', { size: info.size, max_packed: MAX_PACKED });
-assertGate(files.includes('dist/bin/sks.js'), 'packlist_missing_runtime_entry', { missing: 'dist/bin/sks.js' });
-for (const entry of runtimeManifest.scripts) {
-    assertGate(files.includes(entry.path), 'packlist_missing_runtime_required_script', { missing: entry.path, reason: entry.reason });
-}
-assertGate(files.includes('package.json'), 'packlist_missing_runtime_entry', { missing: 'package.json' });
-assertGate(files.includes('README.md'), 'packlist_missing_runtime_entry', { missing: 'README.md' });
-assertGate(files.includes('LICENSE'), 'packlist_missing_runtime_entry', { missing: 'LICENSE' });
-assertGate(files.some((f) => f.startsWith('schemas/')), 'packlist_missing_runtime_entry', { missing: 'schemas/' });
-const forbidden = files.filter((f) => f.startsWith('test/') ||
-    f.startsWith('src/') ||
-    f.startsWith('docs/internal/') ||
-    f.endsWith('.map') ||
-    f.startsWith('.sneakoscope/') ||
-    f.endsWith('.tgz') ||
-    f.startsWith('coverage/') ||
-    /(^|\/)\.env/.test(f));
-assertGate(forbidden.length === 0, 'packlist_forbidden_files', { forbidden });
-const report = {
-    entryCount: info.entryCount,
-    size: info.size,
-    unpackedSize: info.unpackedSize,
-    runtime_required_scripts: runtimeManifest.scripts.map((entry) => entry.path),
-    runtime_required_missing: runtimeManifest.scripts.filter((entry) => !files.includes(entry.path)).map((entry) => entry.path),
-    max_files: MAX_FILES,
-    max_packed: MAX_PACKED,
-    max_unpacked: MAX_UNPACKED,
-    forbidden: []
-};
-const out = path.join(root, '.sneakoscope', 'reports', 'packlist-performance.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-emitGate('publish:packlist-performance', {
-    files: info.entryCount,
-    packed_kib: Math.round(info.size / 1024),
-    unpacked_mib: +(info.unpackedSize / 1048576).toFixed(2)
-});
-//# sourceMappingURL=packlist-performance-check.js.map

package/dist/scripts/parallel-verification-engine-check.js

@@ -1,85 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const issues = [];
-for (const rel of [
-    'src/core/verification/verification-dag.ts',
-    'src/core/verification/verification-worker-pool.ts',
-    'src/core/verification/verification-artifact-lock.ts',
-    'src/core/verification/verification-result.ts',
-    'src/core/verification/verification-proof.ts',
-    'src/scripts/release-parallel-check.ts'
-]) {
-    if (!fs.existsSync(path.join(root, rel)))
-        issues.push(`missing:${rel}`);
-}
-await runFixture();
-const releaseSource = read('src/scripts/release-parallel-check.ts');
-for (const token of ['runVerificationDag', 'buildVerificationDag', 'writeParallelVerificationProof']) {
-    if (!releaseSource.includes(token))
-        issues.push(`release_parallel_runner_missing:${token}`);
-}
-const result = { schema: 'sks.parallel-verification-engine-check.v1', ok: issues.length === 0, issues };
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-async function runFixture() {
-    const dagPath = path.join(root, 'dist', 'core', 'verification', 'verification-dag.js');
-    const poolPath = path.join(root, 'dist', 'core', 'verification', 'verification-worker-pool.js');
-    if (!fs.existsSync(dagPath) || !fs.existsSync(poolPath))
-        return;
-    const dagMod = await import(pathToFileURL(dagPath).href);
-    const poolMod = await import(pathToFileURL(poolPath).href);
-    const dag = dagMod.buildVerificationDag([
-        { id: 'a', command: `${process.execPath} -e "process.exit(0)"`, outputs: ['a.json'] },
-        { id: 'b', command: `${process.execPath} -e "process.exit(0)"`, dependencies: ['a'], outputs: ['b.json'] }
-    ]);
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-verify-'));
-    const result = await poolMod.runVerificationDag(dag, { cwd: root, concurrency: 2, logDir: tmp });
-    if (!result.ok || result.task_count !== 2)
-        issues.push('fixture_parallel_verification_failed');
-    const failedDag = dagMod.buildVerificationDag([
-        { id: 'fail', command: `${process.execPath} -e "process.exit(3)"`, outputs: ['fail.json'] },
-        { id: 'after', command: `${process.execPath} -e "process.exit(0)"`, dependencies: ['fail'], outputs: ['after.json'] }
-    ]);
-    const failed = await poolMod.runVerificationDag(failedDag, { cwd: root, concurrency: 2, logDir: tmp });
-    const after = failed.results.find((row) => row.id === 'after');
-    if (!after?.skipped || failed.skipped !== 1 || failed.failed !== 1 || failed.task_count !== 2)
-        issues.push('fixture_failed_dependency_not_skipped');
-    const timeoutDag = dagMod.buildVerificationDag([
-        { id: 'slow', command: `${process.execPath} -e "process.on('SIGTERM',()=>setTimeout(()=>process.exit(0),200)); setInterval(()=>{},50)"`, timeout_ms: 20, outputs: ['slow.json'] }
-    ]);
-    const timeoutResult = await poolMod.runVerificationDag(timeoutDag, { cwd: root, concurrency: 1, logDir: tmp });
-    const slow = timeoutResult.results.find((row) => row.id === 'slow');
-    if (!slow?.error?.startsWith('timeout:') || slow.duration_ms < 20)
-        issues.push('fixture_timeout_process_tree_not_reported');
-    try {
-        dagMod.buildVerificationDag([
-            { id: 'x', command: 'true', outputs: ['same'] },
-            { id: 'y', command: 'true', outputs: ['same'] }
-        ]);
-        issues.push('fixture_output_conflict_not_blocked');
-    }
-    catch { }
-    try {
-        dagMod.buildVerificationDag([
-            { id: 'x', command: 'true', outputs: ['reports/x.json'] },
-            { id: 'y', command: 'true', outputs: ['reports/../reports/x.json'] }
-        ]);
-        issues.push('fixture_normalized_output_conflict_not_blocked');
-    }
-    catch { }
-}
-function read(rel) {
-    try {
-        return fs.readFileSync(path.join(root, rel), 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-//# sourceMappingURL=parallel-verification-engine-check.js.map

package/dist/scripts/postinstall-safe-side-effects-check.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { root, assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-// Locks the guarantee that `postinstall` performs no heavy / network / process-kill
-// side-effects by default. This is STATIC source analysis only — we never execute
-// `postinstall`, because doing so would mutate the global Codex App / shell environment.
-const helpers = readText('src/cli/install-helpers.ts');
-// Heavy CLI tool installs (brew / npm globals) are opt-in only.
-assertGate(helpers.includes('SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS'), 'postinstall cli tool install must be gated behind SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS');
-// Killing a third-party app's processes is opt-in only.
-assertGate(helpers.includes("SKS_POSTINSTALL_RECONCILE_APP_PROCESSES === '1'"), 'postinstall process reconciliation must be gated behind SKS_POSTINSTALL_RECONCILE_APP_PROCESSES');
-// Config writes are gated (unparseable preserved / unsafe rewrite skipped) and backed up.
-assertGate(helpers.includes('unparseable_config_preserved'), 'postinstall must preserve unparseable config');
-assertGate(helpers.includes('skipped_unsafe_rewrite'), 'postinstall must skip unsafe config rewrites');
-assertGate(helpers.includes('backupCodexConfig'), 'postinstall config writes must back up the existing config');
-// User model / service_tier are set-if-absent, never overwritten.
-assertGate(helpers.includes('upsertTopLevelTomlStringIfAbsent'), 'postinstall must set user model/service_tier only when absent');
-// The postinstall() body must be wrapped in try/catch/finally so it never fails `npm install`.
-const postinstallStart = helpers.indexOf('export async function postinstall');
-assertGate(postinstallStart !== -1, 'postinstall function not found in install-helpers.ts');
-const afterStart = postinstallStart + 'export async function postinstall'.length;
-const nextExport = helpers.indexOf('\nexport ', afterStart);
-const nextAsync = helpers.indexOf('\nasync function ', afterStart);
-const candidates = [nextExport, nextAsync].filter((idx) => idx !== -1);
-const bodyEnd = candidates.length ? Math.min(...candidates) : helpers.length;
-const postinstallBody = helpers.slice(postinstallStart, bodyEnd);
-assertGate(postinstallBody.includes('try'), 'postinstall body must use try (never fail npm install)');
-assertGate(postinstallBody.includes('catch'), 'postinstall body must use catch (never fail npm install)');
-assertGate(postinstallBody.includes('finally'), 'postinstall body must use finally (never fail npm install)');
-// Explicit repair / opt-in paths must be surfaced to the user.
-assertGate(helpers.includes('sks bootstrap'), 'postinstall must surface `sks bootstrap` repair path');
-assertGate(helpers.includes('sks deps check'), 'postinstall must surface `sks deps check` repair path');
-assertGate(helpers.includes('sks doctor --fix'), 'postinstall must surface `sks doctor --fix` repair path');
-assertGate(helpers.includes('SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS=1'), 'postinstall hint must mention the SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS=1 opt-in');
-// init.ts hardening: managed Codex config merge is set-if-absent and never force-overwrites features.
-const init = readText('src/core/init.ts');
-const mergeStart = init.indexOf('mergeManagedCodexConfigToml(');
-assertGate(mergeStart !== -1, 'mergeManagedCodexConfigToml not found in init.ts');
-const afterMergeStart = mergeStart + 'mergeManagedCodexConfigToml('.length;
-const mergeNextExport = init.indexOf('\nexport ', afterMergeStart);
-const mergeNextAsync = init.indexOf('\nasync function ', afterMergeStart);
-const mergeNextFn = init.indexOf('\nfunction ', afterMergeStart);
-const mergeCandidates = [mergeNextExport, mergeNextAsync, mergeNextFn].filter((idx) => idx !== -1);
-const mergeEnd = mergeCandidates.length ? Math.min(...mergeCandidates) : init.length;
-const mergeBody = init.slice(mergeStart, mergeEnd);
-assertGate(mergeBody.includes('upsertTomlTableKeyIfAbsent'), 'managed config merge must set feature flags only when absent');
-assertGate(mergeBody.includes("SKS_MANAGE_CODEX_APP_PLUGINS === '1'"), 'managed config plugin auto-enable must be opt-in via SKS_MANAGE_CODEX_APP_PLUGINS=1');
-assertGate(!/upsertTomlTableKey\(next, 'features'/.test(mergeBody), 'managed config merge must NOT force-overwrite the features table');
-const report = {
-    schema: 'sks.postinstall-safe-side-effects.v1',
-    ok: true,
-    gated: ['cli_install', 'process_kill', 'config_write'],
-    try_catch_finally: true,
-    managed_config_set_if_absent: true
-};
-const out = path.join(root, '.sneakoscope/reports/postinstall-safe-side-effects.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-emitGate('postinstall:safe-side-effects', {
-    gated: ['cli_install', 'process_kill', 'config_write'],
-    try_catch_finally: true
-});
-//# sourceMappingURL=postinstall-safe-side-effects-check.js.map

package/dist/scripts/ppt-full-e2e-artifact-graph-check.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-const reportPath = path.join(process.cwd(), '.sneakoscope', 'reports', 'ppt-full-e2e-blackbox.json');
-if (!fs.existsSync(reportPath)) {
-    const run = spawnSync(process.execPath, ['./dist/scripts/ppt-full-e2e-blackbox-check.js'], { cwd: process.cwd(), env: process.env, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
-    if (run.status !== 0) {
-        console.log(JSON.stringify({ schema: 'sks.ppt-full-e2e-artifact-graph.v1', ok: false, blocker: 'blackbox_failed', stdout_tail: run.stdout.slice(-2000), stderr_tail: run.stderr.slice(-2000) }, null, 2));
-        process.exit(1);
-    }
-}
-const blackbox = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
-const required = ['inventory', 'exportLedger', 'callouts', 'slideIssues', 'deckIssues'];
-const blockers = required.filter((key) => !blackbox.artifacts?.[key]).map((key) => `missing:${key}`);
-if (!blackbox.artifacts?.proof_schema)
-    blockers.push('missing:completion_proof');
-if (!blackbox.artifacts?.trust_schema)
-    blockers.push('missing:trust_report');
-if (blackbox.generated_slide_review_count < blackbox.exported_slide_images_count)
-    blockers.push('generated_review_count_lt_slide_count');
-if (blackbox.issue_extraction_count <= 0)
-    blockers.push('issue_extraction_empty');
-if (!blackbox.mock_fake_not_verified_real)
-    blockers.push('mock_promoted_to_real');
-const result = {
-    schema: 'sks.ppt-full-e2e-artifact-graph.v1',
-    ok: blockers.length === 0,
-    mission_id: blackbox.mission_id,
-    local_only_policy: true,
-    generated_slide_review_count: blackbox.generated_slide_review_count,
-    slide_count: blackbox.exported_slide_images_count,
-    issue_extraction_count: blackbox.issue_extraction_count,
-    blockers
-};
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-//# sourceMappingURL=ppt-full-e2e-artifact-graph-check.js.map