sneakoscope 2.0.14 → 2.0.16

package/dist/scripts/readme-architecture-imagegen-official-check.js

@@ -1,448 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { createHash } from 'node:crypto';
-import { execFileSync } from 'node:child_process';
-import { writeTextAtomic } from '../core/fsx.js';
-const root = process.cwd();
-const args = process.argv.slice(2);
-const reportPath = path.join(root, '.sneakoscope', 'reports', 'readme-architecture-imagegen-attempt-1.18.8.json');
-const promptPath = path.join(root, '.sneakoscope', 'reports', 'readme-architecture-imagegen-prompt-1.18.8.txt');
-const assetPath = path.join(root, 'docs', 'assets', 'sneakoscope-architecture-pipeline.jpg');
-const promptOnly = hasFlag('--print-prompt') || hasFlag('--prompt-only');
-const suppliedOutput = String(argValue('--output', process.env.SKS_CODEX_APP_IMAGEGEN_OUTPUT || '')).trim();
-const suppliedModel = String(argValue('--model', process.env.SKS_CODEX_APP_IMAGEGEN_MODEL || 'gpt-image-2')).trim();
-const suppliedSurface = String(argValue('--surface', process.env.SKS_CODEX_APP_IMAGEGEN_SURFACE || 'codex_app_imagegen')).trim();
-const suppliedOutputId = String(argValue('--output-id', process.env.SKS_CODEX_APP_IMAGEGEN_OUTPUT_ID || '')).trim() || null;
-const suppliedCreatedAt = String(argValue('--created-at', process.env.SKS_CODEX_APP_IMAGEGEN_CREATED_AT || '')).trim() || null;
-const autoPickLatest = hasFlag('--auto-pick-latest') || String(process.env.SKS_CODEX_APP_IMAGEGEN_AUTOPICK_LATEST || '').trim() === '1';
-const waitMs = nonNegativeInt(argValue('--wait-ms', process.env.SKS_CODEX_APP_IMAGEGEN_WAIT_MS), 0);
-const pollMs = Math.max(50, nonNegativeInt(argValue('--poll-ms', process.env.SKS_CODEX_APP_IMAGEGEN_POLL_MS), 1000));
-const hostToolExposed = String(process.env.SKS_CODEX_APP_IMAGEGEN_TOOL_EXPOSED || '').trim() === '1';
-const codexHome = String(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'));
-const generatedImagesRoot = path.join(codexHome, 'generated_images');
-const promptExistedBeforeRun = fs.existsSync(promptPath);
-const codexFeatureEvidence = detectCodexImageGenerationFeature();
-const prompt = `Use case: infographic-diagram
-Asset type: README architecture hero image for Sneakoscope Codex
-Primary request: Use ChatGPT Images 2.0 / GPT Image 2.0 with gpt-image-2 to generate a polished, abstract architecture flow summary image for SKS 1.18.8.
-Content intent: Show Codex App, SKS runtime, Team/Goal routing, MAD-SKS scoped permission widening, gpt-image-2 image evidence, validation gates, and release readiness as connected layers.
-Visual constraints: 16:9 or wide landscape, premium technical product style, no logos, no mascot, no tiny unreadable text, no fake UI screenshots, no dark stock-photo look, no placeholder glyph soup.
-Output requirement: real Codex App $imagegen/gpt-image-2 raster output. Save the selected output path, then run:
-SKS_CODEX_APP_IMAGEGEN_OUTPUT=<path> SKS_CODEX_APP_IMAGEGEN_MODEL=gpt-image-2 SKS_CODEX_APP_IMAGEGEN_SURFACE=codex_app_imagegen npm run imagegen:readme-architecture
-Use the selected file directly under $CODEX_HOME/generated_images; moved or copied files are not accepted as provenance evidence.
-`;
-await fs.promises.mkdir(path.dirname(reportPath), { recursive: true });
-const promptWrite = await ensurePromptContract();
-const promptMeta = await textArtifactMeta(promptPath, promptWrite);
-const previousAsset = await imageMeta(assetPath).catch((err) => ({
-    ok: false,
-    path: assetPath,
-    error: err instanceof Error ? err.message : String(err)
-}));
-let generatedImagesAudit = await scanGeneratedImages(generatedImagesRoot);
-let autoPickedOutput = null;
-let waitResult = null;
-if (promptOnly) {
-    const report = baseReport({
-        ok: true,
-        status: 'prompt_ready',
-        blocker: null,
-        prompt_path: relative(promptPath),
-        setup_guidance: 'Paste this prompt into Codex App $imagegen. After a real gpt-image-2 output appears under $CODEX_HOME/generated_images, rerun this script with --output <path> or --auto-pick-latest when exactly one current candidate exists.',
-        previous_asset: previousAsset,
-        existing_asset_overwritten: false
-    });
-    await writeReport(report);
-    console.log(JSON.stringify({ ...report, prompt }, null, 2));
-    process.exit(0);
-}
-if (promptWrite.changed && suppliedOutput) {
-    const report = baseReport({
-        ok: false,
-        status: 'blocked',
-        blocker: 'prompt_contract_changed_regenerate_image_required',
-        prompt_path: relative(promptPath),
-        setup_guidance: 'The README architecture image prompt changed. Regenerate with Codex App $imagegen/gpt-image-2 using the updated prompt artifact, then rerun this script.',
-        previous_asset: previousAsset,
-        existing_asset_overwritten: false
-    });
-    await writeReport(report);
-    console.log(JSON.stringify(report, null, 2));
-    process.exit(1);
-}
-autoPickedOutput = !suppliedOutput && autoPickLatest ? autoPickCurrentGeneratedImage(generatedImagesAudit) : null;
-if (!suppliedOutput && !autoPickedOutput && waitMs > 0) {
-    waitResult = await waitForCurrentGeneratedImage(waitMs, pollMs);
-    generatedImagesAudit = waitResult.audit;
-    autoPickedOutput = waitResult.output;
-}
-const effectiveOutput = suppliedOutput || autoPickedOutput?.absolute_path || '';
-if (!effectiveOutput) {
-    const blocker = missingOutputBlocker(generatedImagesAudit);
-    const report = baseReport({
-        ok: false,
-        status: 'blocked',
-        blocker,
-        prompt_path: relative(promptPath),
-        setup_guidance: blocker === 'official_codex_app_imagegen_output_ambiguous'
-            ? 'Multiple current generated_images candidates exist. Rerun with SKS_CODEX_APP_IMAGEGEN_OUTPUT pointing at the selected Codex App $imagegen/gpt-image-2 raster file.'
-            : 'Invoke Codex App $imagegen/gpt-image-2 with the prompt artifact, then rerun this script with SKS_CODEX_APP_IMAGEGEN_OUTPUT pointing at the generated raster file or SKS_CODEX_APP_IMAGEGEN_AUTOPICK_LATEST=1 when exactly one current candidate exists.',
-        previous_asset: previousAsset,
-        existing_asset_overwritten: false
-    });
-    await writeReport(report);
-    console.log(JSON.stringify(report, null, 2));
-    process.exitCode = 1;
-}
-else {
-    const sourcePath = path.resolve(root, effectiveOutput);
-    const source = await imageMeta(sourcePath).catch((err) => ({
-        ok: false,
-        path: sourcePath,
-        error: err instanceof Error ? err.message : String(err)
-    }));
-    const validation = validateSource(source, suppliedModel, suppliedSurface);
-    if (!validation.ok) {
-        const report = baseReport({
-            ok: false,
-            status: 'blocked',
-            blocker: 'official_codex_app_imagegen_output_invalid',
-            prompt_path: relative(promptPath),
-            validation,
-            supplied_output: source,
-            previous_asset: previousAsset,
-            existing_asset_overwritten: false
-        });
-        await writeReport(report);
-        console.log(JSON.stringify(report, null, 2));
-        process.exitCode = 1;
-    }
-    else {
-        await fs.promises.copyFile(sourcePath, assetPath);
-        const updatedAsset = await imageMeta(assetPath);
-        const report = baseReport({
-            ok: true,
-            status: 'replaced',
-            blocker: null,
-            prompt_path: relative(promptPath),
-            validation,
-            supplied_output: source,
-            previous_asset: previousAsset,
-            updated_asset: updatedAsset,
-            existing_asset_overwritten: true
-        });
-        await writeReport(report);
-        console.log(JSON.stringify(report, null, 2));
-    }
-}
-async function ensurePromptContract() {
-    if (!promptExistedBeforeRun) {
-        await writeTextAtomic(promptPath, prompt);
-        return { changed: true, reason: 'created' };
-    }
-    const existing = await fs.promises.readFile(promptPath, 'utf8').catch(() => null);
-    if (existing !== prompt) {
-        await writeTextAtomic(promptPath, prompt);
-        return { changed: true, reason: 'refreshed_prompt_changed' };
-    }
-    return { changed: false, reason: 'unchanged' };
-}
-async function waitForCurrentGeneratedImage(timeoutMs, intervalMs) {
-    const startedAt = Date.now();
-    let audit = generatedImagesAudit;
-    let output = autoPickCurrentGeneratedImage(audit);
-    while (!output && Date.now() - startedAt < timeoutMs) {
-        await sleep(Math.min(intervalMs, Math.max(0, timeoutMs - (Date.now() - startedAt))));
-        audit = await scanGeneratedImages(generatedImagesRoot);
-        output = autoPickCurrentGeneratedImage(audit);
-    }
-    return {
-        waited_ms: Date.now() - startedAt,
-        timeout_ms: timeoutMs,
-        poll_ms: intervalMs,
-        timed_out: !output,
-        output,
-        audit
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function missingOutputBlocker(audit) {
-    if ((autoPickLatest || waitMs > 0) && Number(audit?.current_request_candidate_count || 0) > 1) {
-        return 'official_codex_app_imagegen_output_ambiguous';
-    }
-    return 'official_codex_app_imagegen_output_missing';
-}
-function nonNegativeInt(value, fallback) {
-    const parsed = Number.parseInt(String(value ?? ''), 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
-}
-function baseReport(extra) {
-    return {
-        schema: 'sks.readme-architecture-imagegen-attempt.v1',
-        generated_at: new Date().toISOString(),
-        requested_asset: 'docs/assets/sneakoscope-architecture-pipeline.jpg',
-        model: 'gpt-image-2',
-        skill_surface: 'Official Codex App $imagegen/gpt-image-2 required; API/codex-lb fallback is non-Codex evidence',
-        codex_app_image_generation_feature_detected: codexFeatureEvidence.image_generation === true,
-        codex_app_image_generation_feature_evidence: codexFeatureEvidence,
-        codex_app_builtin_tool_exposed_to_this_turn: hostToolExposed,
-        codex_app_builtin_tool_exposure_source: hostToolExposed
-            ? 'SKS_CODEX_APP_IMAGEGEN_TOOL_EXPOSED=1'
-            : 'not exposed to this script/tool context; only an actual Codex App $imagegen output can satisfy replacement evidence',
-        official_docs_checked: [
-            'https://developers.openai.com/codex/app/features#image-generation',
-            'https://deploymentsafety.openai.com/chatgpt-images-2-0',
-            'https://openai.com/index/introducing-chatgpt-images-2-0/',
-            'https://developers.openai.com/api/docs/guides/image-generation',
-            'https://developers.openai.com/api/docs/guides/tools-image-generation?lang=javascript',
-            'https://developers.openai.com/api/docs/models/gpt-image-2'
-        ],
-        input_contract: {
-            env_output: 'SKS_CODEX_APP_IMAGEGEN_OUTPUT',
-            env_model: 'SKS_CODEX_APP_IMAGEGEN_MODEL=gpt-image-2',
-            env_surface: 'SKS_CODEX_APP_IMAGEGEN_SURFACE=codex_app_imagegen',
-            env_output_id: 'SKS_CODEX_APP_IMAGEGEN_OUTPUT_ID optional_metadata_only',
-            env_created_at: 'SKS_CODEX_APP_IMAGEGEN_CREATED_AT optional_metadata_only',
-            env_auto_pick_latest: 'SKS_CODEX_APP_IMAGEGEN_AUTOPICK_LATEST=1 optional_after_prompt_generated_images_pick',
-            env_wait_ms: 'SKS_CODEX_APP_IMAGEGEN_WAIT_MS optional_wait_for_after_prompt_generated_images_candidate',
-            env_poll_ms: 'SKS_CODEX_APP_IMAGEGEN_POLL_MS optional_wait_poll_interval',
-            cli_prompt_only: '--print-prompt or --prompt-only',
-            cli_output: '--output <path>',
-            cli_model: '--model gpt-image-2',
-            cli_surface: '--surface codex_app_imagegen',
-            cli_auto_pick_latest: '--auto-pick-latest',
-            cli_wait_ms: '--wait-ms <milliseconds>',
-            cli_poll_ms: '--poll-ms <milliseconds>',
-            output_id: suppliedOutputId,
-            created_at: suppliedCreatedAt,
-            prompt_only: promptOnly,
-            auto_pick_latest: autoPickLatest,
-            auto_pick_result: autoPickedOutput,
-            wait_ms: waitMs,
-            poll_ms: pollMs,
-            wait_result: waitResult,
-            moved_outputs_accepted: false,
-            api_or_codex_lb_fallback_allowed: false
-        },
-        prompt_contract: promptMeta,
-        codex_generated_images_audit: generatedImagesAudit,
-        ...extra
-    };
-}
-function autoPickCurrentGeneratedImage(audit) {
-    const candidates = Array.isArray(audit.current_request_candidates) ? audit.current_request_candidates : [];
-    if (candidates.length !== 1)
-        return null;
-    return candidates[0];
-}
-function hasFlag(name) {
-    return args.includes(name);
-}
-function argValue(name, fallback = '') {
-    const exactIndex = args.indexOf(name);
-    if (exactIndex >= 0 && exactIndex + 1 < args.length)
-        return args[exactIndex + 1];
-    const prefix = `${name}=`;
-    const found = args.find((arg) => String(arg).startsWith(prefix));
-    return found ? String(found).slice(prefix.length) : fallback;
-}
-function detectCodexImageGenerationFeature() {
-    try {
-        const stdout = execFileSync('codex', ['features', 'list'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-        const imageLine = stdout.split(/\r?\n/).find((line) => /^image_generation\s+/i.test(line.trim())) || '';
-        return {
-            checked: true,
-            detector: 'codex features list',
-            image_generation: /\bstable\b\s+true\b/i.test(imageLine),
-            image_generation_line: imageLine || null
-        };
-    }
-    catch (err) {
-        return {
-            checked: true,
-            detector: 'codex features list',
-            image_generation: false,
-            error: err instanceof Error ? err.message : String(err)
-        };
-    }
-}
-function validateSource(source, model, surface) {
-    const blockers = [];
-    const sourceUnderGeneratedImages = source.absolute_path
-        ? source.absolute_path.startsWith(`${path.resolve(generatedImagesRoot)}${path.sep}`)
-        : false;
-    if (source.ok !== true)
-        blockers.push('source_image_missing_or_unreadable');
-    if (model !== 'gpt-image-2')
-        blockers.push('model_must_be_gpt_image_2');
-    if (surface !== 'codex_app_imagegen')
-        blockers.push('surface_must_be_codex_app_imagegen');
-    if (!sourceUnderGeneratedImages)
-        blockers.push('codex_app_output_must_reside_under_generated_images');
-    const createdAtMs = suppliedCreatedAt ? Date.parse(suppliedCreatedAt) : null;
-    if (suppliedCreatedAt && !Number.isFinite(createdAtMs))
-        blockers.push('codex_app_created_at_must_be_iso8601');
-    if (sourceUnderGeneratedImages && Number(source.mtime_ms || 0) < Number(promptMeta.mtime_ms || 0))
-        blockers.push('generated_image_older_than_prompt_contract');
-    if (!['jpeg', 'png', 'webp'].includes(String(source.format || '')))
-        blockers.push('unsupported_image_format');
-    if (Number(source.width || 0) < 1000 || Number(source.height || 0) < 600)
-        blockers.push('image_too_small_for_readme_architecture_asset');
-    return {
-        ok: blockers.length === 0,
-        blockers,
-        required_surface: 'codex_app_imagegen',
-        required_model: 'gpt-image-2',
-        generated_images_root: generatedImagesRoot,
-        source_under_generated_images: sourceUnderGeneratedImages,
-        output_id_present: Boolean(suppliedOutputId),
-        created_at_present: Boolean(suppliedCreatedAt),
-        created_at_ms: Number.isFinite(createdAtMs) ? createdAtMs : null,
-        prompt_mtime: promptMeta.mtime,
-        min_dimensions: { width: 1000, height: 600 }
-    };
-}
-async function imageMeta(file) {
-    const stats = await fs.promises.stat(file);
-    const dims = await imageDimensions(file);
-    return {
-        ok: true,
-        path: relative(file),
-        absolute_path: path.resolve(file),
-        sha256: await sha256File(file),
-        bytes: stats.size,
-        mtime: stats.mtime.toISOString(),
-        mtime_ms: stats.mtimeMs,
-        ...dims
-    };
-}
-async function textArtifactMeta(file, promptWrite = null) {
-    const stats = await fs.promises.stat(file);
-    return {
-        path: relative(file),
-        absolute_path: path.resolve(file),
-        sha256: await sha256File(file),
-        bytes: stats.size,
-        mtime: stats.mtime.toISOString(),
-        mtime_ms: stats.mtimeMs,
-        existed_before_run: promptExistedBeforeRun,
-        write: promptWrite
-    };
-}
-async function writeReport(report) {
-    await writeTextAtomic(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-}
-async function sha256File(file) {
-    return new Promise((resolve, reject) => {
-        const hash = createHash('sha256');
-        const input = fs.createReadStream(file);
-        input.on('error', reject);
-        input.on('data', (chunk) => hash.update(chunk));
-        input.on('end', () => resolve(hash.digest('hex')));
-    });
-}
-async function imageDimensions(file) {
-    const handle = await fs.promises.open(file, 'r');
-    try {
-        const header = Buffer.alloc(32);
-        const { bytesRead } = await handle.read(header, 0, header.length, 0);
-        if (bytesRead >= 24 && header.slice(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
-            return { width: header.readUInt32BE(16), height: header.readUInt32BE(20), format: 'png' };
-        }
-        if (bytesRead >= 12 && header.slice(0, 4).toString('ascii') === 'RIFF' && header.slice(8, 12).toString('ascii') === 'WEBP') {
-            return await webpDimensions(file);
-        }
-        if (bytesRead >= 10 && header[0] === 0xff && header[1] === 0xd8)
-            return await jpegDimensions(file);
-        return { width: null, height: null, format: 'unknown' };
-    }
-    finally {
-        await handle.close().catch(() => { });
-    }
-}
-async function jpegDimensions(file) {
-    const buf = await fs.promises.readFile(file);
-    let offset = 2;
-    while (offset < buf.length) {
-        if (buf[offset] !== 0xff)
-            break;
-        const marker = buf.readUInt8(offset + 1);
-        const length = buf.readUInt16BE(offset + 2);
-        if (marker >= 0xc0 && marker <= 0xc3) {
-            return { width: buf.readUInt16BE(offset + 7), height: buf.readUInt16BE(offset + 5), format: 'jpeg' };
-        }
-        offset += 2 + length;
-    }
-    return { width: null, height: null, format: 'jpeg' };
-}
-async function webpDimensions(file) {
-    const buf = await fs.promises.readFile(file);
-    const chunk = buf.slice(12, 16).toString('ascii');
-    if (chunk === 'VP8X' && buf.length >= 30) {
-        return {
-            width: 1 + buf.readUIntLE(24, 3),
-            height: 1 + buf.readUIntLE(27, 3),
-            format: 'webp'
-        };
-    }
-    if (chunk === 'VP8 ' && buf.length >= 30) {
-        return { width: buf.readUInt16LE(26) & 0x3fff, height: buf.readUInt16LE(28) & 0x3fff, format: 'webp' };
-    }
-    return { width: null, height: null, format: 'webp' };
-}
-async function scanGeneratedImages(rootDir) {
-    const files = await listGeneratedImageFiles(rootDir).catch(() => []);
-    const rows = [];
-    for (const file of files) {
-        const stats = await fs.promises.stat(file).catch(() => null);
-        if (!stats)
-            continue;
-        rows.push({
-            path: relative(file),
-            absolute_path: path.resolve(file),
-            mtime: stats.mtime.toISOString(),
-            mtime_ms: stats.mtimeMs,
-            bytes: stats.size
-        });
-    }
-    rows.sort((a, b) => b.mtime_ms - a.mtime_ms);
-    const currentRequestCandidates = rows.filter((row) => Number(row.mtime_ms || 0) >= Number(promptMeta.mtime_ms || 0));
-    return {
-        root: rootDir,
-        total_png_candidates: rows.length,
-        latest_candidates: rows.slice(0, 5).map(({ mtime_ms, ...row }) => row),
-        current_request_candidates: currentRequestCandidates.slice(0, 5),
-        current_request_candidate_count: currentRequestCandidates.length,
-        latest_is_current_request_output: currentRequestCandidates.length > 0 && rows[0]?.absolute_path === currentRequestCandidates[0]?.absolute_path,
-        auto_pick_latest_available: currentRequestCandidates.length === 1,
-        note: 'Existing files under generated_images are discoverable, but SKS does not treat them as this README replacement unless the user provides SKS_CODEX_APP_IMAGEGEN_OUTPUT or opts into SKS_CODEX_APP_IMAGEGEN_AUTOPICK_LATEST=1 with exactly one generated_images candidate newer than the prompt contract.'
-    };
-}
-async function listGeneratedImageFiles(rootDir) {
-    const out = [];
-    const entries = await fs.promises.readdir(rootDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const first = path.join(rootDir, entry.name);
-        if (entry.isDirectory()) {
-            const nested = await fs.promises.readdir(first, { withFileTypes: true }).catch(() => []);
-            for (const child of nested) {
-                if (child.isFile() && /\.(png|jpe?g|webp)$/i.test(child.name))
-                    out.push(path.join(first, child.name));
-            }
-        }
-        else if (entry.isFile() && /\.(png|jpe?g|webp)$/i.test(entry.name)) {
-            out.push(first);
-        }
-    }
-    return out;
-}
-function relative(file) {
-    const rel = path.relative(root, path.resolve(file));
-    return rel.startsWith('..') ? path.resolve(file) : rel;
-}
-//# sourceMappingURL=readme-architecture-imagegen-official-check.js.map

package/dist/scripts/release-cache-glob-hashing-check.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { expandGlob, releaseGateCacheKey } from '../core/release/release-gate-cache-v2.js';
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-cache-glob-'));
-fs.mkdirSync(path.join(tmp, 'src/core/release'), { recursive: true });
-fs.writeFileSync(path.join(tmp, 'package.json'), JSON.stringify({ version: '0.0.0' }));
-fs.writeFileSync(path.join(tmp, 'release-gates.v2.json'), JSON.stringify({ schema: 'sks.release-gates.v2', gates: [] }));
-fs.writeFileSync(path.join(tmp, 'src/core/release/a.ts'), 'a');
-const gate = {
-    id: 'release:cache-glob-hashing-fixture',
-    command: 'node fixture',
-    deps: [],
-    resource: ['cpu-light'],
-    side_effect: 'hermetic',
-    timeout_ms: 1000,
-    cache: { enabled: true, inputs: ['src/core/release/**'] },
-    isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
-    preset: ['release']
-};
-const before = releaseGateCacheKey(tmp, gate);
-const expandedBefore = expandGlob(tmp, 'src/core/release/**');
-fs.writeFileSync(path.join(tmp, 'src/core/release/b.ts'), 'b');
-const afterAdd = releaseGateCacheKey(tmp, gate);
-fs.writeFileSync(path.join(tmp, 'src/core/release/a.ts'), 'changed');
-const afterChange = releaseGateCacheKey(tmp, gate);
-const expandedAfter = expandGlob(tmp, 'src/core/release/**');
-const report = {
-    schema: 'sks.release-cache-glob-hashing-check.v1',
-    ok: expandedBefore.length === 1 && expandedAfter.length === 2 && before !== afterAdd && afterAdd !== afterChange,
-    expanded_before: expandedBefore.map((file) => path.basename(file)),
-    expanded_after: expandedAfter.map((file) => path.basename(file)),
-    before,
-    after_add: afterAdd,
-    after_change: afterChange
-};
-assertGate(report.ok, 'release cache key must hash recursive glob file paths and contents', report);
-emitGate('release:cache-glob-hashing', report);
-//# sourceMappingURL=release-cache-glob-hashing-check.js.map

package/dist/scripts/release-dag-full-coverage-check.js

@@ -1,66 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const manifest = JSON.parse(fs.readFileSync(path.join(root, 'release-gates.v2.json'), 'utf8'));
-const legacy = String(pkg.scripts['release:check:legacy'] || '');
-const legacyIds = [...new Set([...legacy.matchAll(/npm run ([^\s&]+)/g)].map((match) => match[1]).filter((id) => pkg.scripts[id]))];
-const allowlist = new Map([
-    ['release:check:parallel', 'legacy aggregate superseded by release-gates.v2 DAG'],
-    ['codex-app:fast-ui-preservation', 'Codex App UI real-environment preservation gate'],
-    ['codex-control:keepalive-no-cot-leak', 'long-running remote keepalive/debug gate'],
-    ['zellij:real-session-heartbeat', 'real Zellij heartbeat covered by release:real-check'],
-    ['publish:packlist-performance', 'publish/package performance gate'],
-    ['release:dynamic-performance', 'performance budget gate covered by release:parallel-speed-budget']
-]);
-const gateIds = new Set(manifest.gates.map((gate) => gate.id));
-const releasePresetIds = new Set(manifest.gates.filter((gate) => Array.isArray(gate.preset) && gate.preset.includes('release')).map((gate) => gate.id));
-const requiredReleasePresetIds = [
-    'zellij:first-slot-down-stack',
-    'zellij:slot-renderer-proof-semantics',
-    'naruto:allocation-policy',
-    'naruto:rebalance-policy',
-    'naruto:allocation-runtime-wiring',
-    'naruto:actual-worker-control-plane',
-    'naruto:orchestrator-runtime-source',
-    'git:worktree-checkpoint',
-    'git:worktree-cross-rebase',
-    'local-collab:worktree-gpt-final-apply-policy',
-    'release:cache-glob-hashing',
-    'release:dag-full-coverage',
-    'research:quality-contract',
-    'research:claim-matrix',
-    'research:source-quality-report',
-    'research:implementation-blueprint',
-    'research:experiment-plan',
-    'research:replication-pack',
-    'research:final-reviewer',
-    'research:work-graph',
-    'research:short-report-rejection',
-    'research:complete-package-fixture',
-    'research:stage-cycle-runtime-blackbox',
-    'research:final-reviewer-blackbox',
-    'codex-sdk:research-pipeline'
-];
-const missing = legacyIds.filter((id) => !gateIds.has(id) && !allowlist.has(id));
-const missingRequiredReleasePreset = requiredReleasePresetIds.filter((id) => !gateIds.has(id) || !releasePresetIds.has(id));
-const allowed = legacyIds.filter((id) => allowlist.has(id)).map((id) => ({ id, reason: allowlist.get(id) }));
-const coverage = legacyIds.length ? (legacyIds.length - missing.length) / legacyIds.length : 1;
-const schemaComplete = manifest.gates.every((gate) => gate.id && gate.command && Array.isArray(gate.deps) && Array.isArray(gate.resource) && gate.side_effect && gate.timeout_ms && gate.cache && gate.isolation && Array.isArray(gate.preset));
-const report = {
-    schema: 'sks.release-dag-full-coverage-check.v1',
-    ok: missing.length === 0 && missingRequiredReleasePreset.length === 0 && coverage >= 0.95 && schemaComplete,
-    legacy_gate_count: legacyIds.length,
-    v2_gate_count: manifest.gates.length,
-    coverage,
-    missing,
-    required_release_preset_ids: requiredReleasePresetIds,
-    missing_required_release_preset: missingRequiredReleasePreset,
-    allowed,
-    schema_complete: schemaComplete
-};
-assertGate(report.ok, 'release-gates.v2 must cover legacy hermetic release gates', report);
-emitGate('release:dag-full-coverage', report);
-//# sourceMappingURL=release-dag-full-coverage-check.js.map

package/dist/scripts/release-dist-freshness-check.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
-const report = ensureDistFresh({ rebuild: process.env.SKS_RELEASE_DIST_FRESHNESS_NO_REBUILD !== '1' });
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok)
-    process.exitCode = 1;
-//# sourceMappingURL=release-dist-freshness-check.js.map

package/dist/scripts/release-dynamic-performance-check.js

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const { selectGates } = await importDist('core/release/gate-manifest.js');
-const { buildGateManifest } = await importDist('core/release/gate-manifest.js');
-const manifest = loadDynamicManifest();
-const t0 = Date.now();
-const docsOnly = summarize(['docs/release-readiness.md']);
-const zellijOnly = summarize(['src/core/zellij/zellij-capability.ts']);
-const coreSkillOnly = summarize(['src/core/skills/core-skill-deployment.ts']);
-const currentReport = readJson('.sneakoscope/reports/release-check-dynamic-execute.json', null);
-const durationMs = Date.now() - t0;
-const report = {
-    schema: 'sks.release-dynamic-performance.v1',
-    ok: true,
-    duration_ms: durationMs,
-    gate_count: manifest.gates.length,
-    current: currentReport ? {
-        selected_count: currentReport.selected?.length || 0,
-        executed_count: currentReport.executed?.length || 0,
-        cache_hits: currentReport.cache_hits?.length || 0,
-        skipped_count: currentReport.skipped?.length || 0,
-        mode: currentReport.mode || null
-    } : null,
-    fixtures: {
-        docs_only: docsOnly,
-        zellij_only: zellijOnly,
-        core_skill_only: coreSkillOnly
-    },
-    warnings: durationMs > 30_000 ? ['dynamic_performance_check_over_budget'] : []
-};
-report.ok = docsOnly.heavy_selected === 0
-    && zellijOnly.selected.every((id) => id.startsWith('zellij:') || alwaysOn(id) || scopedRuntimeBoundary(id))
-    && coreSkillOnly.selected.every((id) => id.startsWith('core-skill:') || alwaysOn(id) || scopedRuntimeBoundary(id))
-    && docsOnly.selected_count < manifest.gates.length;
-const out = path.join(root, '.sneakoscope', 'reports', 'release-dynamic-performance.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.ok, 'dynamic release performance fixtures failed', report);
-emitGate('release:dynamic-performance', {
-    gates: manifest.gates.length,
-    docs_only_selected: docsOnly.selected_count,
-    zellij_only_selected: zellijOnly.selected_count,
-    core_skill_only_selected: coreSkillOnly.selected_count,
-    duration_ms: durationMs
-});
-function summarize(changedFiles) {
-    const plan = selectGates(manifest.gates, changedFiles, { publish: false });
-    const selected = plan.selected.map((gate) => gate.id);
-    return {
-        changed_files: changedFiles,
-        selected,
-        selected_count: selected.length,
-        skipped_count: plan.skipped.length,
-        heavy_selected: plan.selected.filter((gate) => gate.cost === 'heavy' || gate.cost === 'real').length
-    };
-}
-function alwaysOn(id) {
-    return manifest.gates.some((gate) => gate.id === id && gate.always_on_release === true);
-}
-function scopedRuntimeBoundary(id) {
-    return id === 'runtime:no-mjs-scripts' || id === 'runtime:ts-python-boundary';
-}
-function readJson(rel, fallback) {
-    try {
-        return JSON.parse(fs.readFileSync(path.join(root, rel), 'utf8'));
-    }
-    catch {
-        return fallback;
-    }
-}
-function loadDynamicManifest() {
-    const v2Path = path.join(root, 'release-gates.v2.json');
-    if (fs.existsSync(v2Path)) {
-        const parsed = JSON.parse(fs.readFileSync(v2Path, 'utf8'));
-        const releaseNodes = (Array.isArray(parsed.gates) ? parsed.gates : []).filter((gate) => Array.isArray(gate.preset) && gate.preset.includes('release'));
-        const byId = new Map(releaseNodes.map((gate) => [gate.id, gate]));
-        const dynamic = buildGateManifest(releaseNodes.map((gate) => gate.id));
-        return {
-            schema: 'sks.release-gate-manifest.v1.from-v2',
-            gates: dynamic.gates.map((entry) => {
-                const node = byId.get(entry.id);
-                const resource = Array.isArray(node?.resource) ? node.resource.join(',') : '';
-                return {
-                    ...entry,
-                    affected_by: usefulCacheInputs(node?.cache?.inputs, entry.affected_by),
-                    cost: node?.side_effect === 'real-env' || resource.includes('real') ? 'real' : entry.cost
-                };
-            })
-        };
-    }
-    return JSON.parse(fs.readFileSync(path.join(root, 'release-gates.json'), 'utf8'));
-}
-function usefulCacheInputs(inputs, fallback) {
-    if (!Array.isArray(inputs) || !inputs.length)
-        return fallback;
-    if (inputs.some((input) => ['src/**', 'package.json', 'release-gates.v2.json', 'schemas/**'].includes(input)))
-        return fallback;
-    return inputs;
-}
-//# sourceMappingURL=release-dynamic-performance-check.js.map