sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/naruto-worktree-gpt-final-check.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const workGraphMod = await importDist('core/naruto/naruto-work-graph.js');
-const rolesMod = await importDist('core/naruto/naruto-role-policy.js');
-const packMod = await importDist('core/naruto/naruto-gpt-final-pack.js');
-const policy = {
-    mode: 'git-worktree',
-    required: true,
-    main_repo_root: '/repo',
-    worktree_root: '/cache/sks/worktrees/repo/M-final',
-    fallback_reason: null
-};
-const graph = workGraphMod.buildNarutoWorkGraph({ requestedClones: 6, totalWorkItems: 8, writeCapable: true, worktreePolicy: policy });
-const roleDistribution = rolesMod.buildNarutoRoleDistribution(graph.work_items);
-const worktreeDiff = {
-    schema: 'sks.git-worktree-diff.v1',
-    ok: true,
-    mission_id: 'M-final',
-    worker_id: 'worker-1',
-    main_repo_root: '/repo',
-    worktree_path: '/cache/wt/worker-1',
-    branch: 'sks/M/worker-1',
-    changed_files: ['src/a.ts'],
-    diff: 'diff --git a/src/a.ts b/src/a.ts\n',
-    diff_bytes: 37
-};
-const pack = packMod.buildNarutoGptFinalPack({
-    missionId: 'M-final',
-    graph,
-    roleDistribution,
-    changedFiles: ['src/a.ts'],
-    worktreePolicy: policy,
-    worktreeDiffs: [worktreeDiff],
-    localLlmMetrics: { participated: true, final_status: 'draft_until_gpt_final' }
-});
-assertGate(pack.worktree_policy.mode === 'git-worktree', 'GPT final pack must include worktree policy', pack.worktree_policy);
-assertGate(pack.worktree_diffs.length === 1, 'GPT final pack must include bounded worktree diffs', pack);
-assertGate(pack.local_llm_metrics.final_status === 'draft_until_gpt_final', 'local LLM output must remain draft until GPT final', pack.local_llm_metrics);
-assertGate(pack.bounded === true && pack.secrets_redacted === true, 'GPT final pack must stay bounded/redacted', pack);
-emitGate('naruto:worktree-gpt-final', {
-    worktree_mode: pack.worktree_policy.mode,
-    worktree_diffs: pack.worktree_diffs.length
-});
-//# sourceMappingURL=naruto-worktree-gpt-final-check.js.map

package/dist/scripts/naruto-worktree-zellij-ui-check.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
-const plan = dashboardMod.planNarutoZellijDashboard({
-    targetActiveWorkers: 10,
-    visiblePaneCap: 6,
-    roles: ['implementer', 'verifier'],
-    backend: 'codex-sdk',
-    worktreePolicy: {
-        mode: 'git-worktree',
-        required: true,
-        main_repo_root: '/repo',
-        worktree_root: '/cache/sks/worktrees/repo/M',
-        fallback_reason: null
-    }
-});
-assertGate(plan.ok === true, 'Naruto worktree Zellij dashboard must pass', plan);
-assertGate(plan.worktree_mode === 'git-worktree', 'dashboard must carry worktree mode', plan);
-assertGate(plan.worktree_labels.length === plan.visible_worker_panes, 'visible panes must have worktree labels', plan);
-assertGate(plan.pane_titles.every((title) => title.includes('WT:') && title.includes('branch:')), 'pane titles must include worktree id and branch', plan.pane_titles);
-assertGate(plan.headless_workers === 4, 'dashboard must still expose headless worker count', plan);
-emitGate('naruto:worktree-zellij-ui', {
-    visible_worker_panes: plan.visible_worker_panes,
-    headless_workers: plan.headless_workers,
-    sample_title: plan.pane_titles[0]
-});
-//# sourceMappingURL=naruto-worktree-zellij-ui-check.js.map

package/dist/scripts/naruto-zellij-dynamic-right-column-check.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const requireReal = process.argv.includes('--require-real') || process.env.SKS_REQUIRE_ZELLIJ === '1';
-const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
-const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const swarm = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
-const realGeometryProof = requireReal ? runRealGeometryProof() : null;
-const report = {
-    schema: 'sks.naruto-zellij-dynamic-right-column-check.v1',
-    ok: true,
-    require_real: requireReal,
-    initial_main_only: /slotCount:\s*0/.test(naruto),
-    passes_session_name: naruto.includes('zellijSessionName: liveZellij?.session_name'),
-    passes_worker_placement: naruto.includes("workerPlacement: parsed.json || parsed.noOpenZellij ? 'process' : 'zellij-pane'"),
-    passes_visible_cap: naruto.includes('zellijVisiblePaneCap: zellijVisiblePanes'),
-    worker_uses_right_column: worker.includes("rightColumnMode: 'spawn-on-first-worker'") || swarm.includes("rightColumnMode: 'spawn-on-first-worker'"),
-    real_geometry_proof: realGeometryProof
-};
-report.ok = report.initial_main_only
-    && report.passes_session_name
-    && report.passes_worker_placement
-    && report.passes_visible_cap
-    && report.worker_uses_right_column
-    && (!requireReal || realGeometryProof?.ok === true);
-assertGate(report.ok, 'Naruto must use dynamic right-column worker panes in interactive mode', report);
-emitGate('naruto:zellij-dynamic-right-column', report);
-function runRealGeometryProof() {
-    const res = spawnSync('npm', ['run', 'zellij:right-column-real-geometry', '--silent', '--', '--require-real'], {
-        cwd: root,
-        env: { ...process.env, SKS_REQUIRE_ZELLIJ: '1' },
-        encoding: 'utf8',
-        maxBuffer: 20 * 1024 * 1024
-    });
-    return {
-        ok: res.status === 0,
-        exit_code: res.status,
-        stdout_tail: tail(res.stdout),
-        stderr_tail: tail(res.stderr)
-    };
-}
-function tail(text) {
-    return String(text || '').split('\n').slice(-30).join('\n');
-}
-//# sourceMappingURL=naruto-zellij-dynamic-right-column-check.js.map

package/dist/scripts/naruto-zellij-massive-ui-check.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const dashboardMod = await importDist('core/zellij/zellij-naruto-dashboard.js');
-const plan = dashboardMod.planNarutoZellijDashboard({
-    targetActiveWorkers: 32,
-    visiblePaneCap: 12,
-    completed: 8,
-    failed: 1,
-    backpressure: 'normal',
-    roles: ['implementer', 'modifier', 'test_writer', 'verifier'],
-    backend: 'codex-sdk'
-});
-assertGate(plan.ok === true, 'Naruto Zellij dashboard plan must pass', plan);
-assertGate(plan.visible_worker_panes === 12, 'targetActiveWorkers=32 and visiblePaneCap=12 must create 12 visible panes', plan);
-assertGate(plan.headless_workers === 20, 'remaining active workers must be listed as headless', plan);
-assertGate(plan.pane_titles.every((title) => /slot-\d+\/gen-1 · .+ · codex-sdk · active/.test(title)), 'pane titles must include slot/gen/role/backend/status', plan);
-emitGate('naruto:zellij-massive-ui', {
-    visible_worker_panes: plan.visible_worker_panes,
-    headless_workers: plan.headless_workers,
-    dashboard: plan.dashboard
-});
-//# sourceMappingURL=naruto-zellij-massive-ui-check.js.map

package/dist/scripts/non-recursive-pipeline-check.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { nonRecursivePipelineMarkdown, scanNonRecursivePipelinePolicy } from '../core/agents/agent-recursion-guard.js';
-const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-const defaultRoot = path.resolve(scriptDir, '..');
-const args = process.argv.slice(2);
-const root = path.resolve(readFlag('--root') || defaultRoot);
-const json = args.includes('--json');
-const noWrite = args.includes('--no-write');
-const outputDir = path.join(root, '.sneakoscope', 'reports');
-const report = scanNonRecursivePipelinePolicy(collectScanRecords(root));
-if (!noWrite) {
-    fs.mkdirSync(outputDir, { recursive: true });
-    fs.writeFileSync(path.join(outputDir, 'non-recursive-pipeline-report.json'), `${JSON.stringify(report, null, 2)}\n`);
-    fs.writeFileSync(path.join(outputDir, 'non-recursive-pipeline-report.md'), nonRecursivePipelineMarkdown(report));
-}
-if (json)
-    console.log(JSON.stringify(report, null, 2));
-else
-    console.log(`non-recursive-pipeline: ${report.ok ? 'pass' : 'blocked'} (${report.violations.length} violation(s), ${report.scanned_records.length} record(s), ${report.elapsed_ms}ms)`);
-if (!report.ok || !report.performance_ok || !report.secret_redaction_ok)
-    process.exitCode = 1;
-function readFlag(name) {
-    const idx = args.indexOf(name);
-    return idx >= 0 ? args[idx + 1] : null;
-}
-function collectScanRecords(scanRoot) {
-    const candidates = [
-        ['src/core/agents/agent-worker-pipeline.ts', 'source'],
-        ['src/core/agents/agent-recursion-guard.ts', 'source'],
-        ['src/core/agents/agent-runner-process.ts', 'source'],
-        ['src/core/agents/agent-runner-codex-exec.ts', 'source'],
-        ['docs/agent-non-recursive-pipeline.md', 'docs'],
-        ['docs/native-agent-kernel.md', 'docs']
-    ];
-    const records = [];
-    for (const [rel, channel] of candidates) {
-        const full = path.join(scanRoot, rel);
-        if (!fs.existsSync(full) || !fs.statSync(full).isFile())
-            continue;
-        records.push({ path: rel, channel, text: fs.readFileSync(full, 'utf8') });
-    }
-    records.push({
-        path: '.sneakoscope/reports/agent-worker.stdout.fixture.txt',
-        channel: 'stdout',
-        text: 'agent worker completed local slice; no nested route requested'
-    });
-    records.push({
-        path: '.sneakoscope/reports/agent-worker.stderr.fixture.txt',
-        channel: 'stderr',
-        text: 'agent worker stderr clean; no recursive SKS command emitted'
-    });
-    records.push({
-        path: '.sneakoscope/reports/agent-result.fixture.json',
-        channel: 'agent_result',
-        text: JSON.stringify({
-            schema: 'sks.agent-result.v1',
-            status: 'done',
-            recursion_guard: { ok: true, violations: [] },
-            blockers: []
-        })
-    });
-    return records;
-}
-//# sourceMappingURL=non-recursive-pipeline-check.js.map

package/dist/scripts/npm-publish-performance-check.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-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 || 1200);
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024);
-const BUDGET_MS = Number(process.env.SKS_PACK_BUDGET_MS || 30000);
-function runNpmPack() {
-    const npmCli = process.env.npm_execpath; // set when invoked via `npm run`
-    const argv = ['pack', '--dry-run', '--json', '--ignore-scripts'];
-    const res = npmCli
-        ? spawnSync(process.execPath, [npmCli, ...argv], { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 })
-        : spawnSync('npm', argv, { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
-    return res;
-}
-function writeReport(report) {
-    const out = path.join(root, '.sneakoscope', 'reports', 'npm-publish-performance.json');
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-}
-const t0 = Date.now();
-const res = runNpmPack();
-const packMs = Date.now() - t0;
-let info;
-if (res.status === 0) {
-    try {
-        const parsed = JSON.parse(res.stdout);
-        info = Array.isArray(parsed) ? parsed[0] : parsed;
-    }
-    catch {
-        info = undefined;
-    }
-}
-if (!info) {
-    // Real-check gate: never fail when npm is unreachable / pack unavailable.
-    const report = { ok: true, integration_optional: true, reason: 'npm_pack_unavailable' };
-    writeReport(report);
-    emitGate('publish:dry-run-performance', { integration_optional: true });
-    process.exit(0);
-}
-const report = {
-    schema: 'sks.npm-publish-performance.v1',
-    ok: info.entryCount <= MAX_FILES && info.size <= MAX_PACKED,
-    pack_ms: packMs,
-    slowest_phase: 'pack',
-    file_count: info.entryCount,
-    packed_bytes: info.size,
-    unpacked_bytes: info.unpackedSize,
-    over_budget: packMs > BUDGET_MS,
-    warnings: packMs > BUDGET_MS ? ['pack_slower_than_budget'] : [],
-    blockers: [
-        ...(info.entryCount > MAX_FILES ? ['pack_file_count_over_limit'] : []),
-        ...(info.size > MAX_PACKED ? ['pack_size_over_limit'] : [])
-    ]
-};
-writeReport(report);
-if (report.blockers.length) {
-    assertGate(false, 'npm_publish_performance_blockers', { blockers: report.blockers, report });
-}
-// A slow pack is a WARNING only, not a blocker.
-console.log(JSON.stringify(report, null, 2));
-process.exit(0);
-//# sourceMappingURL=npm-publish-performance-check.js.map

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