sneakoscope 2.0.14 → 2.0.15

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

@@ -1,150 +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 args = process.argv.slice(2);
-const publish = args.includes('--publish');
-const pkg = readJson('package.json');
-const version = pkg.version;
-const currentBranch = git(['rev-parse', '--abbrev-ref', 'HEAD']);
-const currentCommit = git(['rev-parse', 'HEAD']);
-const dist = readJson('dist/build-manifest.json', null);
-const srcVersion = readVersionFrom('src/core/version.ts', /PACKAGE_VERSION\s*=\s*['"]([^'"]+)['"]/);
-const fsxVersion = readVersionFrom('src/core/fsx.ts', /PACKAGE_VERSION\s*=\s*['"]([^'"]+)['"]/);
-const cargoVersion = readVersionFrom('crates/sks-core/Cargo.toml', /^version\s*=\s*"([^"]+)"/m);
-const latestChangelog = latestVersionedChangelogSection(readText('CHANGELOG.md'));
-const tag = tagStatus(version, currentCommit);
-const main = mainVersion();
-const originMain = originMainVersion();
-const npm = npmVersion();
-const warnings = [];
-const blockers = [];
-if (main.version && main.version !== version)
-    warnings.push('main_out_of_date');
-if (publish && main.version && main.version !== version)
-    blockers.push('main_version_mismatch');
-if (originMain.version && originMain.version !== version)
-    warnings.push('origin_main_out_of_date');
-if (publish && tag.exists && tag.commit !== currentCommit)
-    blockers.push('tag_not_on_current_commit');
-if (publish && npm.version && semverCompare(npm.version, version) >= 0)
-    blockers.push('npm_version_already_published_or_ahead');
-for (const [name, actual] of Object.entries({ dist_package_version: dist?.package_version, dist_version: dist?.version, src_version: srcVersion, fsx_version: fsxVersion, cargo_version: cargoVersion, changelog: latestChangelog })) {
-    if (actual !== version)
-        blockers.push(`${name}_mismatch`);
-}
-const report = {
-    schema: 'sks.release-provenance.v1',
-    ok: blockers.length === 0,
-    mode: publish ? 'publish' : 'dev_review',
-    reviewed_ref: currentBranch || 'unknown',
-    current_branch: currentBranch,
-    current_git_commit: currentCommit,
-    package_version: version,
-    dist_build_manifest_version: dist?.package_version || null,
-    src_versions: { version_ts: srcVersion, fsx_ts: fsxVersion },
-    cargo_version: cargoVersion,
-    latest_changelog_section: latestChangelog,
-    main_version: main.version,
-    main_commit: main.commit,
-    main_status: main.status,
-    origin_main_version: originMain.version,
-    origin_main_commit: originMain.commit,
-    origin_main_status: originMain.status,
-    npm_version: npm.version,
-    npm_status: npm.version ? (semverCompare(npm.version, version) < 0 ? 'registry_behind_candidate' : npm.version === version ? 'candidate_already_published' : 'registry_ahead') : npm.status,
-    tag_status: tag,
-    warnings,
-    blockers,
-    generated_at: new Date().toISOString()
-};
-const out = path.join(root, '.sneakoscope', 'reports', 'release-provenance.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-assertGate(report.ok, 'release provenance blockers', report);
-emitGate('release:provenance', { mode: report.mode, reviewed_ref: report.reviewed_ref, warnings: warnings.length, blockers: blockers.length });
-function git(argv) {
-    const res = spawnSync('git', argv, { cwd: root, encoding: 'utf8' });
-    return res.status === 0 ? res.stdout.trim() : null;
-}
-function mainVersion() {
-    const ref = git(['rev-parse', '--verify', 'HEAD']);
-    if (!ref)
-        return { version: null, commit: null, status: 'unavailable' };
-    const res = spawnSync('git', ['show', 'HEAD:package.json'], { cwd: root, encoding: 'utf8' });
-    if (res.status !== 0)
-        return { version: null, commit: ref, status: 'package_unavailable' };
-    try {
-        return { version: JSON.parse(res.stdout).version || null, commit: ref, status: 'local_head' };
-    }
-    catch {
-        return { version: null, commit: ref, status: 'unparseable' };
-    }
-}
-function originMainVersion() {
-    const ref = git(['rev-parse', '--verify', 'origin/main']);
-    if (!ref)
-        return { version: null, commit: null, status: 'unavailable' };
-    const res = spawnSync('git', ['show', 'origin/main:package.json'], { cwd: root, encoding: 'utf8' });
-    if (res.status !== 0)
-        return { version: null, commit: ref, status: 'package_unavailable' };
-    try {
-        return { version: JSON.parse(res.stdout).version || null, commit: ref, status: 'ok' };
-    }
-    catch {
-        return { version: null, commit: ref, status: 'unparseable' };
-    }
-}
-function npmVersion() {
-    const res = spawnSync('npm', ['view', `${pkg.name}`, 'version'], { cwd: root, encoding: 'utf8', timeout: 30000 });
-    if (res.status !== 0)
-        return { version: null, status: 'unavailable', stderr_tail: tail(res.stderr) };
-    return { version: res.stdout.trim() || null, status: 'ok' };
-}
-function tagStatus(version, currentCommit) {
-    const tagName = `v${version}`;
-    const commit = git(['rev-list', '-n', '1', tagName]);
-    if (!commit)
-        return { tag: tagName, exists: false, commit: null, matches_current: false };
-    return { tag: tagName, exists: true, commit, matches_current: commit === currentCommit };
-}
-function readJson(rel, fallback) {
-    try {
-        return JSON.parse(readText(rel));
-    }
-    catch {
-        if (arguments.length > 1)
-            return fallback;
-        throw new Error(`failed to read ${rel}`);
-    }
-}
-function readText(rel) {
-    return fs.readFileSync(path.join(root, rel), 'utf8');
-}
-function readVersionFrom(rel, re) {
-    return readText(rel).match(re)?.[1] || null;
-}
-function semverCompare(a, b) {
-    const av = String(a).split('.').map((n) => Number(n));
-    const bv = String(b).split('.').map((n) => Number(n));
-    for (let i = 0; i < Math.max(av.length, bv.length); i += 1) {
-        const diff = (av[i] || 0) - (bv[i] || 0);
-        if (diff !== 0)
-            return diff;
-    }
-    return 0;
-}
-function latestVersionedChangelogSection(text) {
-    for (const match of text.matchAll(/^## \[([^\]]+)\]/gm)) {
-        if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(match[1]))
-            return match[1];
-    }
-    return null;
-}
-function tail(value, limit = 1000) {
-    const text = String(value || '');
-    return text.length > limit ? text.slice(-limit) : text;
-}
-//# sourceMappingURL=release-provenance-check.js.map

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

@@ -1,330 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { writeJsonAtomic } from '../core/fsx.js';
-const args = process.argv.slice(2);
-const skipReleaseCheck = args.includes('--skip-release-check') || process.env.SKS_RELEASE_REAL_CHECK_SKIP_RELEASE_CHECK === '1';
-const root = process.cwd();
-const concurrency = Math.max(1, Math.floor(Number(process.env.SKS_RELEASE_REAL_CHECK_CONCURRENCY || 4)));
-const report = {
-    schema: 'sks.release-real-check.v1',
-    generated_at: new Date().toISOString(),
-    ok: false,
-    pipeline_shape: {
-        schema: 'sks.release-real-check-diamond.v1',
-        stages: ['design', 'parallel_processing', 'parallel_verification', 'aggregation'],
-        concurrency,
-        dependency_model: 'dag-with-ordered-zellij-proof-chains'
-    },
-    release_check: null,
-    environment_required_checks: [],
-    real_smoke_checks: [],
-    real_ui_checks: [],
-    all_checks: [],
-    phase_results: [],
-    blockers: [],
-    warnings: []
-};
-const tasks = [
-    task('codex:actual-config-load-probe', 'codex:actual-config-load-probe', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('codex:0.137-compat:require-real', 'codex:0.137-compat:require-real', { group: 'environment_required', phase: 'parallel_processing', env: { SKS_REQUIRE_CODEX_0137: '1' } }),
-    task('codex:0.136-compat:require-real', 'codex:0.136-compat:require-real', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('codex:0.135-compat:require-real', 'codex:0.135-compat:require-real', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('doctor:codex-doctor-parity:actual', 'doctor:codex-doctor-parity:actual', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('publish:dry-run-performance', 'publish:dry-run-performance', { group: 'environment_required', phase: 'parallel_processing' }),
-    task('zellij:capability', 'zellij:capability', { group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' } }),
-    task('zellij:layout-valid', 'zellij:layout-valid', { group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:capability'] }),
-    task('zellij:real-session-launch:base', 'zellij:real-session-launch', { group: 'environment_required', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij', '--session', 'sks-rrz'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:pane-proof:base', 'zellij:pane-proof', { group: 'environment_required', phase: 'parallel_verification', args: ['--require-real', '--mission', 'M-release-real-zellij', '--session', 'sks-rrz', '--expected-lanes', '0'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:base'] }),
-    task('zellij:screen-proof:base', 'zellij:screen-proof', { group: 'environment_required', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:base'] }),
-    task('zellij:real-session-cleanup:base', 'zellij:real-session-cleanup', { group: 'environment_required', phase: 'aggregation', args: ['--mission', 'M-release-real-zellij', '--session', 'sks-rrz'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:pane-proof:base', 'zellij:screen-proof:base'] }),
-    task('zellij:first-slot-down-stack:real', 'zellij:first-slot-down-stack:real', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:right-column-real-geometry', 'zellij:right-column-real-geometry', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('naruto:zellij-dynamic-right-column', 'naruto:zellij-dynamic-right-column', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:worker-pane-real-ui:blackbox', 'zellij:worker-pane-real-ui:blackbox', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:real-session-launch:extra', 'zellij:real-session-launch', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij-extra', '--session', 'sks-rrz-extra'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:layout-valid'] }),
-    task('zellij:pane-proof:extra', 'zellij:pane-proof', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--mission', 'M-release-real-zellij-extra', '--session', 'sks-rrz-extra', '--expected-lanes', '0'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:extra'] }),
-    task('zellij:screen-proof:extra', 'zellij:screen-proof', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--mission', 'M-release-real-zellij-extra'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:real-session-launch:extra'] }),
-    task('zellij:real-session-cleanup:extra', 'zellij:real-session-cleanup', { group: 'real_ui', phase: 'aggregation', args: ['--mission', 'M-release-real-zellij-extra', '--session', 'sks-rrz-extra'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:pane-proof:extra', 'zellij:screen-proof:extra'] }),
-    task('naruto:worktree-coding:blackbox', 'naruto:worktree-coding:blackbox', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_GIT_WORKTREE: '1' } }),
-    task('codex-control:real-smoke', 'codex-control:real-smoke', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'] }),
-    task('codex-sdk:real-smoke', 'codex-sdk:real-smoke', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'] }),
-    task('local-llm:smoke', 'local-llm:smoke', { group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_LOCAL_LLM: '1' } }),
-    task('local-llm:throughput', 'local-llm:throughput', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1' }, deps: ['local-llm:smoke'] }),
-    task('local-llm:cache-performance', 'local-llm:cache-performance', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1' }, deps: ['local-llm:smoke'] }),
-    task('python-sdk:real-smoke', 'python-sdk:real-smoke', {
-        group: 'real_smoke',
-        phase: 'parallel_verification',
-        env: { SKS_REQUIRE_PYTHON_CODEX_SDK: '1', SKS_PYTHON_CODEX_SDK_TIMEOUT_MS: '240000' },
-        deps: ['codex-sdk:real-smoke', 'codex-control:real-smoke', 'agent:real-codex-in-zellij-worker-pane'],
-        retries: 2,
-        retryDelayMs: 1500
-    }),
-    task('codex:0.134-runner-truth', 'codex:0.134-runner-truth', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-patch-envelope-smoke', 'agent:real-codex-patch-envelope-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers', 'agent:real-codex-parallel-workers', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers-5', 'agent:real-codex-parallel-workers-5', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers-10', 'agent:real-codex-parallel-workers-10', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-parallel-workers-20', 'agent:real-codex-parallel-workers-20', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-dynamic-smoke-v2', 'agent:real-codex-dynamic-smoke-v2', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-dynamic-smoke', 'agent:real-codex-dynamic-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('agent:real-codex-in-zellij-worker-pane', 'agent:real-codex-in-zellij-worker-pane', { group: 'real_ui', phase: 'parallel_verification', args: ['--require-real'], deps: ['zellij:layout-valid'] }),
-    task('imagegen:real-smoke', 'imagegen:real-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('ux-review:real-imagegen-smoke', 'ux-review:real-imagegen-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('ppt:real-imagegen-smoke', 'ppt:real-imagegen-smoke', { group: 'real_smoke', phase: 'parallel_processing' }),
-    task('naruto:real-local-gpt-final-smoke', 'naruto:real-local-gpt-final-smoke', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1', SKS_REQUIRE_GPT_FINAL: '1' }, deps: ['local-llm:smoke'] }),
-    task('local-collab:gpt-final-performance', 'local-collab:gpt-final-performance', { group: 'real_smoke', phase: 'parallel_verification', env: { SKS_REQUIRE_LOCAL_LLM: '1', SKS_REQUIRE_GPT_FINAL: '1' }, deps: ['local-llm:smoke'] })
-];
-main().catch(async (err) => {
-    report.blockers.push(`release_real_check_exception:${err?.message || String(err)}`);
-    await finish(false);
-});
-async function main() {
-    if (!skipReleaseCheck) {
-        report.release_check = await runNpm(task('release:check', 'release:check', { group: 'design', phase: 'design' }));
-        collect(report.release_check);
-        if (!report.release_check.ok)
-            return await finish(false);
-    }
-    else {
-        report.release_check = {
-            id: 'release:check',
-            script: 'release:check',
-            group: 'design',
-            phase: 'design',
-            ok: true,
-            skipped: true,
-            note: 'Skipped because caller already verified release:check in this workspace.'
-        };
-    }
-    const result = await runDag(tasks, concurrency);
-    report.all_checks = result.results;
-    report.environment_required_checks = result.results.filter((row) => row.group === 'environment_required');
-    report.real_smoke_checks = result.results.filter((row) => row.group === 'real_smoke');
-    report.real_ui_checks = result.results.filter((row) => row.group === 'real_ui');
-    report.phase_results = summarizePhases(result.results);
-    for (const row of result.results)
-        collect(row);
-    await finish(result.results.every((row) => row.ok));
-}
-function task(id, script, options = {}) {
-    return {
-        id,
-        script,
-        group: options.group || 'real_smoke',
-        phase: options.phase || 'parallel_processing',
-        args: options.args || [],
-        env: options.env || {},
-        deps: options.deps || [],
-        retries: Number(options.retries || 0),
-        retryDelayMs: Number(options.retryDelayMs || 0)
-    };
-}
-async function runDag(taskList, maxConcurrency) {
-    const pending = new Map(taskList.map((row) => [row.id, row]));
-    const running = new Map();
-    const completed = new Map();
-    const results = [];
-    while (pending.size || running.size) {
-        for (const [id, row] of [...pending]) {
-            const failedDeps = row.deps.filter((dep) => completed.has(dep) && !completed.get(dep).ok);
-            if (failedDeps.length) {
-                pending.delete(id);
-                const blocked = blockedResult(row, failedDeps);
-                completed.set(id, blocked);
-                results.push(blocked);
-            }
-        }
-        const ready = [...pending.values()].filter((row) => row.deps.every((dep) => completed.get(dep)?.ok === true));
-        while (running.size < maxConcurrency && ready.length) {
-            const row = ready.shift();
-            pending.delete(row.id);
-            const promise = runNpm(row);
-            running.set(row.id, promise);
-        }
-        if (!running.size) {
-            if (pending.size) {
-                for (const row of pending.values()) {
-                    const blocked = blockedResult(row, row.deps.filter((dep) => !completed.get(dep)?.ok));
-                    completed.set(row.id, blocked);
-                    results.push(blocked);
-                }
-                pending.clear();
-            }
-            continue;
-        }
-        const result = await Promise.race([...running.values()]);
-        running.delete(result.id);
-        completed.set(result.id, result);
-        results.push(result);
-    }
-    return { results };
-}
-async function runNpm(row) {
-    const maxAttempts = Math.max(1, Number(row.retries || 0) + 1);
-    const attempts = [];
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const result = await runNpmOnce(row, attempt);
-        attempts.push(compactAttempt(result));
-        if (result.ok || attempt >= maxAttempts) {
-            return {
-                ...result,
-                attempt,
-                attempts,
-                retried: attempts.length > 1
-            };
-        }
-        await sleep(Math.max(0, Number(row.retryDelayMs || 0)));
-    }
-}
-function runNpmOnce(row, attempt) {
-    const npmArgs = ['run', row.script, '--silent'];
-    if (row.args?.length)
-        npmArgs.push('--', ...row.args);
-    const started = Date.now();
-    let stdout = '';
-    let stderr = '';
-    return new Promise((resolve) => {
-        const child = spawn('npm', npmArgs, {
-            cwd: root,
-            env: { ...process.env, ...(row.env || {}) },
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        child.stdout.on('data', (chunk) => { stdout = appendTail(stdout, chunk); });
-        child.stderr.on('data', (chunk) => { stderr = appendTail(stderr, chunk); });
-        child.on('error', (err) => {
-            resolve(normalizeResult(row, npmArgs, 1, null, { code: err.code, message: err.message }, stdout, stderr, Date.now() - started, attempt));
-        });
-        child.on('close', (code, signal) => {
-            resolve(normalizeResult(row, npmArgs, code, signal, null, stdout, stderr, Date.now() - started, attempt));
-        });
-    });
-}
-function normalizeResult(row, npmArgs, code, signal, error, stdout, stderr, durationMs, attempt) {
-    const parsed = parseJson(stdout);
-    return {
-        id: row.id,
-        script: row.script,
-        group: row.group,
-        phase: row.phase,
-        deps: row.deps || [],
-        command: ['npm', ...npmArgs],
-        ok: code === 0,
-        attempt,
-        exit_code: code,
-        signal,
-        duration_ms: durationMs,
-        error,
-        parsed_schema: parsed?.schema || null,
-        parsed_ok: typeof parsed?.ok === 'boolean' ? parsed.ok : null,
-        blockers: extractList(parsed, 'blockers'),
-        warnings: extractList(parsed, 'warnings'),
-        stdout_tail: tail(stdout),
-        stderr_tail: tail(stderr)
-    };
-}
-function compactAttempt(result) {
-    return {
-        attempt: result.attempt,
-        ok: result.ok,
-        exit_code: result.exit_code,
-        duration_ms: result.duration_ms,
-        blockers: result.blockers || [],
-        stderr_tail: tail(result.stderr_tail || '', 600)
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function blockedResult(row, failedDeps) {
-    return {
-        id: row.id,
-        script: row.script,
-        group: row.group,
-        phase: row.phase,
-        deps: row.deps || [],
-        command: ['npm', 'run', row.script, '--silent'],
-        ok: false,
-        blocked: true,
-        exit_code: null,
-        signal: null,
-        duration_ms: 0,
-        error: null,
-        parsed_schema: null,
-        parsed_ok: null,
-        blockers: failedDeps.map((dep) => `blocked_by_failed_dependency:${dep}`),
-        warnings: [],
-        stdout_tail: '',
-        stderr_tail: `blocked by failed dependency: ${failedDeps.join(', ')}`
-    };
-}
-function collect(result) {
-    for (const blocker of result.blockers || []) {
-        if (!report.blockers.includes(blocker))
-            report.blockers.push(blocker);
-    }
-    if (!result.ok && !(result.blockers || []).length) {
-        const blocker = `${result.id.replace(/[^A-Za-z0-9]+/g, '_')}_failed`;
-        if (!report.blockers.includes(blocker))
-            report.blockers.push(blocker);
-    }
-    for (const warning of result.warnings || []) {
-        if (!report.warnings.includes(warning))
-            report.warnings.push(warning);
-    }
-}
-function summarizePhases(results) {
-    return ['design', 'parallel_processing', 'parallel_verification', 'aggregation'].map((phase) => {
-        const rows = phase === 'design' ? [report.release_check].filter(Boolean) : results.filter((row) => row.phase === phase);
-        return {
-            phase,
-            total: rows.length,
-            passed: rows.filter((row) => row.ok).length,
-            failed: rows.filter((row) => !row.ok).length,
-            duration_ms: rows.reduce((sum, row) => sum + Number(row.duration_ms || 0), 0)
-        };
-    });
-}
-async function finish(ok) {
-    report.ok = ok && report.blockers.length === 0;
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'release-real-check.json'), report);
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.ok)
-        process.exitCode = 1;
-}
-function parseJson(text) {
-    const value = String(text || '').trim();
-    if (!value)
-        return null;
-    const start = value.indexOf('{');
-    if (start < 0)
-        return null;
-    try {
-        return JSON.parse(value.slice(start));
-    }
-    catch {
-        return null;
-    }
-}
-function extractList(parsed, key) {
-    if (!parsed || typeof parsed !== 'object')
-        return [];
-    const values = [];
-    const top = parsed[key];
-    const nested = parsed.report && typeof parsed.report === 'object' ? parsed.report[key] : null;
-    for (const list of [top, nested]) {
-        if (Array.isArray(list))
-            values.push(...list);
-    }
-    return [...new Set(values)];
-}
-function appendTail(previous, chunk, limit = 50 * 1024) {
-    const text = previous + String(chunk || '');
-    return text.length <= limit ? text : text.slice(-limit);
-}
-function tail(value, limit = 4000) {
-    const text = String(value || '');
-    return text.length <= limit ? text : text.slice(-limit);
-}
-//# sourceMappingURL=release-real-check.js.map