sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/release-full-parallelism-blackbox.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runReleaseGateBatch } from '../core/release/release-gate-batch-runner.js';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const reportRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-release-full-'));
+const gates = Array.from({ length: 80 }, (_, i) => ({ id: `synthetic:${i + 1}`, command: `${process.execPath} -e \"setTimeout(()=>process.exit(0),1000)\"`, deps: [], resource: ['cpu-light', 'fs-read'], side_effect: 'hermetic', timeout_ms: 15000, cache: { enabled: false, inputs: [] }, isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' }, preset: ['release'] }));
+const started = Date.now();
+const result = await runReleaseGateBatch(root, gates, { concurrency: 40, reportRoot });
+const wallMs = Date.now() - started;
+const completedDurations = result.results
+    .map((row) => Number(row.duration_ms || 0))
+    .filter((duration) => Number.isFinite(duration) && duration > 0);
+const observedSequentialMs = completedDurations.reduce((total, duration) => total + duration, 0);
+const slowestGateMs = Math.max(1, ...completedDurations);
+const expectedWaves = Math.ceil(gates.length / 40);
+const dynamicWallBudgetMs = Math.max(20_000, Math.ceil((slowestGateMs * expectedWaves) + 12_000));
+const gain = Number((observedSequentialMs / Math.max(1, wallMs)).toFixed(2));
+assertGate(result.ok === true, 'synthetic release gates failed', result);
+assertGate(result.batch_size === 80 && result.completed === 80, 'synthetic gate count mismatch', result);
+assertGate(completedDurations.length === 80, 'synthetic gate duration evidence missing', { durations: completedDurations.length, result });
+assertGate(wallMs <= dynamicWallBudgetMs, 'release full parallelism wall time too slow', {
+    wallMs,
+    dynamicWallBudgetMs,
+    slowestGateMs,
+    expectedWaves,
+    result
+});
+assertGate(gain >= 8, 'release full parallelism gain below 8x', { gain, wallMs, observedSequentialMs });
+emitGate('release:full-parallelism-blackbox', {
+    wall_ms: wallMs,
+    parallelism_gain: gain,
+    observed_sequential_ms: observedSequentialMs,
+    dynamic_wall_budget_ms: dynamicWallBudgetMs,
+    slowest_gate_ms: slowestGateMs,
+    max_running: 40,
+    slowest_gates: result.results.sort((a, b) => b.duration_ms - a.duration_ms).slice(0, 5)
+});
+//# sourceMappingURL=release-full-parallelism-blackbox.js.map

package/dist/scripts/release-gate-batch-runner-check.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const batch = await importDist('core/release/release-gate-batch-runner.js');
+assertGate(typeof batch.runReleaseGateBatch === 'function', 'release batch runner export missing');
+assertGate(typeof batch.isReleaseGateBatchable === 'function', 'release batchable predicate export missing');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-release-batch-'));
+const reportRoot = path.join(root, 'reports');
+const base = {
+    deps: [],
+    resource: ['cpu-light', 'fs-read'],
+    side_effect: 'hermetic',
+    timeout_ms: 30000,
+    cache: { enabled: false, inputs: [] },
+    isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
+    preset: ['release']
+};
+const envProofScript = [
+    "if(process.env.SKS_GATE_ID!=='batch:pass')process.exit(21)",
+    "if(process.env.SKS_DISABLE_GLOBAL_CONFIG_MUTATION!=='1')process.exit(22)",
+    "if(process.env.SKS_DISABLE_REAL_MODEL_CALLS!=='1')process.exit(23)",
+    "if(!String(process.env.HOME||'').includes('sks-gate'))process.exit(24)",
+    "if(!String(process.env.CODEX_HOME||'').includes('sks-gate'))process.exit(25)",
+    "if(!String(process.env.SKS_REPORT_DIR||'').includes('batch-pass'))process.exit(26)"
+].join(';');
+const passGate = { ...base, id: 'batch:pass', command: `${process.execPath} -e ${JSON.stringify(envProofScript)}` };
+const failGate = { ...base, id: 'batch:fail', command: `${process.execPath} -e "process.exit(7)"` };
+const timeoutGate = { ...base, id: 'batch:timeout', timeout_ms: 50, command: `${process.execPath} -e "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000)"` };
+const zellijGate = { ...base, id: 'batch:zellij-real', resource: ['zellij-real'], side_effect: 'real-env', command: `${process.execPath} -e "process.exit(0)"` };
+assertGate(batch.isReleaseGateBatchable(passGate) === true, 'hermetic cpu-light fs-read gate must be batchable');
+assertGate(batch.isReleaseGateBatchable(zellijGate) === false, 'zellij-real gate must not be batchable');
+const result = await batch.runReleaseGateBatch(root, [passGate, failGate], { concurrency: 2, reportRoot });
+assertGate(result.ok === false && result.failed === 1, 'one failed child gate must fail the batch', result);
+assertGate(result.results.some((row) => row.id === 'batch:fail' && row.ok === false && row.exit_code === 7), 'batch result must report exact failed child id', result);
+assertGate(fs.existsSync(path.join(reportRoot, 'batch-pass', 'result.json')) && fs.existsSync(path.join(reportRoot, 'batch-fail', 'result.json')), 'batch runner must preserve individual result JSON files');
+assertGate(result.results.some((row) => row.id === 'batch:pass' && row.ok === true), 'batch runner must execute children with hermetic release-gate environment', result);
+const timeoutResult = await batch.runReleaseGateBatch(root, [timeoutGate], { concurrency: 1, reportRoot });
+assertGate(timeoutResult.results.some((row) => row.id === 'batch:timeout' && row.ok === false && row.exit_code === 124 && row.timed_out === true), 'batch runner must report timed-out child process trees explicitly', timeoutResult);
+assertGate(timeoutResult.results.some((row) => row.id === 'batch:timeout' && row.duration_ms >= 1400), 'batch runner must wait for timed-out process tree hard-kill cleanup before resolving', timeoutResult);
+emitGate('release:gate-batch-runner', { batch_size: result.batch_size, failed_child: 'batch:fail' });
+//# sourceMappingURL=release-gate-batch-runner-check.js.map

package/dist/scripts/release-gate-budget-check.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// @ts-nocheck
+// Gate: release:gate-budget
+// Reports the slowest gates and any gate exceeding its time budget, from the gate
+// result cache. Tolerant of missing timing data (informational on a cold cache).
+// Only a gate exceeding the HARD ceiling is a blocker.
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const { readGateCache } = await importDist('core/release/gate-cache.js');
+const SOFT_BUDGET_MS = Number(process.env.SKS_GATE_BUDGET_MS || 120_000);
+const HARD_CEILING_MS = Number(process.env.SKS_GATE_HARD_CEILING_MS || 600_000);
+const cache = await readGateCache(root);
+const records = Object.values(cache.records || {});
+const sorted = records.slice().sort((a, b) => (b.duration_ms || 0) - (a.duration_ms || 0));
+const slowest = sorted.slice(0, 10).map((r) => ({ gate_id: r.gate_id, duration_ms: r.duration_ms }));
+const overBudget = sorted.filter((r) => (r.duration_ms || 0) > SOFT_BUDGET_MS).map((r) => ({ gate_id: r.gate_id, duration_ms: r.duration_ms }));
+const overCeiling = sorted.filter((r) => (r.duration_ms || 0) > HARD_CEILING_MS).map((r) => ({ gate_id: r.gate_id, duration_ms: r.duration_ms }));
+const report = {
+    schema: 'sks.release-gate-budget.v1',
+    ok: overCeiling.length === 0,
+    timing_data: records.length > 0,
+    soft_budget_ms: SOFT_BUDGET_MS,
+    hard_ceiling_ms: HARD_CEILING_MS,
+    slowest,
+    over_budget: overBudget,
+    over_ceiling: overCeiling,
+    note: records.length === 0 ? 'no_timing_data (populate via release:check:dynamic gate cache)' : undefined
+};
+const reportDir = path.join(root, '.sneakoscope', 'reports');
+fs.mkdirSync(reportDir, { recursive: true });
+fs.writeFileSync(path.join(reportDir, 'release-gate-budget.json'), `${JSON.stringify(report, null, 2)}\n`);
+// Only a gate over the HARD ceiling fails the gate; soft-budget gates are warnings.
+assertGate(overCeiling.length === 0, 'a gate exceeded the hard time ceiling', { overCeiling, hard_ceiling_ms: HARD_CEILING_MS });
+emitGate('release:gate-budget', { slowest: slowest.length, over_budget: overBudget.length, timing_data: records.length > 0 });
+//# sourceMappingURL=release-gate-budget-check.js.map

package/dist/scripts/release-gate-dag-runner-check.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, readJson, readText } from './sks-1-18-gate-lib.js';
+const pkg = readJson('package.json');
+const manifest = readJson('release-gates.v2.json');
+const runner = readText('src/core/release/release-gate-dag.ts');
+const scheduler = readText('src/core/release/release-gate-scheduler.ts');
+const cache = readText('src/core/release/release-gate-cache-v2.ts');
+const releaseCheck = String(pkg.scripts['release:check'] || '');
+const delegatedReleaseCheck = releaseCheck.match(/^npm run ([^\s&]+)$/)?.[1];
+const effectiveReleaseCheck = delegatedReleaseCheck ? String(pkg.scripts[delegatedReleaseCheck] || '') : releaseCheck;
+assertGate(effectiveReleaseCheck.includes('release-gate-dag-runner.js'), 'release:check must execute DAG runner', { release_check: releaseCheck, delegated_release_check: delegatedReleaseCheck || null, effective_release_check: effectiveReleaseCheck });
+assertGate(!/&&\s*npm run\s+\w/.test(releaseCheck.replace('npm run build --silent &&', '')), 'release:check must not be a giant npm-run chain', releaseCheck);
+assertGate(!/&&\s*npm run\s+\w/.test(effectiveReleaseCheck.replace('npm run build:incremental --silent &&', '').replace('npm run build --silent &&', '')), 'effective release:check must not be a giant npm-run chain', effectiveReleaseCheck);
+assertGate(pkg.scripts['release:check:legacy'], 'release:check:legacy must exist for explicit debugging');
+assertGate(manifest.schema === 'sks.release-gates.v2' && manifest.gates.length >= 10, 'release-gates.v2 manifest must exist with nodes', manifest);
+for (const gateId of ['scheduler:utilization-integral', 'parallel:runtime-real-blackbox', 'agent:native-cli-session-swarm-20', 'doctor:fix-proves-codex-read', 'codex:0139-real-probes', 'zellij:slot-telemetry-performance', 'naruto:real-parallelism-blackbox']) {
+    const gate = manifest.gates.find((row) => row.id === gateId);
+    assertGate(gate?.resource?.includes('timing-sensitive'), `${gateId} must run in timing-sensitive isolation`, gate);
+}
+assertGate(runner.includes('Promise.race') && scheduler.includes('pickLaunchableReleaseGates'), 'DAG runner must schedule independent gates concurrently');
+assertGate(runner.includes('readReleaseGateCacheRecord') && cache.includes('duration_ms') && cache.includes('RELEASE_GATE_CACHE_V2_SCHEMA'), 'DAG runner must use release gate cache v2 module with cached duration evidence');
+assertGate(runner.includes('cpu_time_saved_ms') && runner.includes('peak_running') && runner.includes('budget_snapshot'), 'DAG summary must include CPU time saved, peak running gates, and resource budget proof');
+assertGate(runner.includes('sks.five-minute-completion-certificate.v1') && runner.includes('sks.affected-gate-graph.v1') && cache.includes('releaseGateProofBankFile'), 'DAG runner must emit completion certificates, affected graph, and proof-bank cache path');
+assertGate(runner.includes('detached: process.platform') && runner.includes('killGateProcessTree') && runner.includes('timed_out'), 'DAG runner must kill timed-out gate process trees and record timeout evidence');
+assertGate(runner.includes('pruneOldReleaseGateRunDirs') && runner.includes('SKS_RELEASE_GATE_RUN_RETENTION'), 'DAG runner must prune stale release-gate run reports before they exhaust local disk');
+const dag = await importDist('core/release/release-gate-dag.js');
+const fsx = await importDist('core/fsx.js');
+const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-release-dag-timeout-'));
+await fsx.writeJsonAtomic(path.join(fixtureRoot, 'release-gates.v2.json'), {
+    schema: 'sks.release-gates.v2',
+    gates: [{
+            id: 'dag:timeout',
+            command: `${process.execPath} -e "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000)"`,
+            deps: [],
+            resource: ['cpu-light', 'fs-read'],
+            side_effect: 'hermetic',
+            timeout_ms: 50,
+            cache: { enabled: false, inputs: [] },
+            isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
+            preset: ['release']
+        }]
+});
+const timeoutRun = await dag.runReleaseGateDag({ root: fixtureRoot, preset: 'release', full: true, noCache: true });
+const timeoutFailure = timeoutRun.failures.find((row) => row.id === 'dag:timeout');
+const timeoutDuration = timeoutRun.slowest_gates.find((row) => row.id === 'dag:timeout')?.duration_ms || 0;
+assertGate(timeoutRun.ok === false && timeoutRun.failed === 1, 'DAG timeout fixture must fail the run', timeoutRun);
+assertGate(timeoutFailure?.exit_code === 124 && timeoutFailure?.timed_out === true, 'DAG timeout fixture must record exit 124 and timed_out evidence', timeoutRun);
+assertGate(String(timeoutFailure?.stderr_tail || '').includes('release_gate_timeout:dag:timeout:50ms'), 'DAG timeout fixture must include timeout marker in stderr tail', timeoutRun);
+assertGate(timeoutDuration >= 1400, 'DAG timeout fixture must wait for hard-kill cleanup before resolving', timeoutRun);
+const cacheRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-release-dag-cache-'));
+await fsx.writeJsonAtomic(path.join(cacheRoot, 'package.json'), { name: 'cache-fixture', version: '0.0.0' });
+await fsx.writeJsonAtomic(path.join(cacheRoot, 'release-gates.v2.json'), {
+    schema: 'sks.release-gates.v2',
+    gates: [{
+            id: 'dag:cached-duration',
+            command: `${process.execPath} -e "const until=Date.now()+80; while(Date.now()<until){}"`,
+            deps: [],
+            resource: ['cpu-light', 'fs-read'],
+            side_effect: 'hermetic',
+            timeout_ms: 5000,
+            cache: { enabled: true, inputs: [] },
+            isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
+            preset: ['release']
+        }]
+});
+const firstCacheRun = await dag.runReleaseGateDag({ root: cacheRoot, preset: 'release', full: true });
+const secondCacheRun = await dag.runReleaseGateDag({ root: cacheRoot, preset: 'release', full: true });
+const cachedDuration = secondCacheRun.slowest_gates.find((row) => row.id === 'dag:cached-duration')?.duration_ms || 0;
+assertGate(firstCacheRun.ok === true && firstCacheRun.cached === 0, 'DAG cache fixture first run must execute the gate', firstCacheRun);
+assertGate(secondCacheRun.ok === true && secondCacheRun.cached === 1, 'DAG cache fixture second run must hit cache', secondCacheRun);
+assertGate(cachedDuration > 0, 'DAG cache fixture must retain nonzero cached duration evidence', secondCacheRun);
+assertGate(secondCacheRun.sum_gate_ms >= cachedDuration, 'DAG cache fixture must include cached duration in sum_gate_ms evidence', secondCacheRun);
+assertGate(secondCacheRun.completion_certificate?.schema === 'sks.five-minute-completion-certificate.v1', 'DAG cache fixture must include completion certificate', secondCacheRun);
+assertGate(secondCacheRun.affected_graph?.proof_bank_file?.includes('.sneakoscope/proof-bank/gates/cache-v2.json'), 'DAG cache fixture must expose proof bank path', secondCacheRun);
+assertGate(await exists(path.join(cacheRoot, '.sneakoscope', 'reports', 'release-gates', secondCacheRun.run_id, 'completion-certificate.json')), 'DAG cache fixture must write completion-certificate artifact');
+assertGate(await exists(path.join(cacheRoot, '.sneakoscope', 'proof-bank', 'gates', 'cache-v2.json')), 'DAG cache fixture must mirror successful proof into proof bank');
+const retentionRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-release-dag-retention-'));
+const retentionBase = path.join(retentionRoot, '.sneakoscope', 'reports', 'release-gates');
+await fs.mkdir(retentionBase, { recursive: true });
+for (let i = 0; i < 5; i++) {
+    const dir = path.join(retentionBase, `rg-2026-06-01T00-00-0${i}-000Z-${i}`);
+    await fs.mkdir(dir, { recursive: true });
+    await fsx.writeJsonAtomic(path.join(dir, 'summary.json'), { ok: true, index: i });
+    const date = new Date(Date.UTC(2026, 5, 1, 0, 0, i));
+    await fs.utimes(path.join(dir, 'summary.json'), date, date);
+}
+await fsx.writeJsonAtomic(path.join(retentionBase, 'cache-v2.json'), {});
+const retention = await dag.pruneOldReleaseGateRunDirs(retentionRoot, { keep: 2, preserveRunId: 'rg-2026-06-01T00-00-00-000Z-0' });
+const remainingRetentionRuns = (await fs.readdir(retentionBase)).filter((name) => name.startsWith('rg-')).sort();
+assertGate(retention.removed === 2 && retention.kept === 3, 'DAG retention fixture must remove stale runs while preserving requested run', retention);
+assertGate(remainingRetentionRuns.length === 3 && remainingRetentionRuns.includes('rg-2026-06-01T00-00-00-000Z-0'), 'DAG retention fixture must keep newest runs and preserved current run', { remainingRetentionRuns, retention });
+assertGate(await exists(path.join(retentionBase, 'cache-v2.json')), 'DAG retention fixture must not remove cache-v2.json');
+emitGate('release:dag-runner', { gates: manifest.gates.length, default_script: releaseCheck, effective_script: effectiveReleaseCheck });
+async function exists(file) {
+    try {
+        await fs.stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=release-gate-dag-runner-check.js.map

package/dist/scripts/release-gate-script-parity-check.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
+import { writeJsonAtomic } from '../core/fsx.js';
+import { REQUIRED_3112_REAL_CHECK_IDS, REQUIRED_3112_RELEASE_IDS } from './release-3112-required-gates.js';
+import { REQUIRED_3113_REAL_CHECK_IDS, REQUIRED_3113_RELEASE_IDS } from './release-3113-required-gates.js';
+import { REQUIRED_4000_REAL_CHECK_IDS, REQUIRED_4000_RELEASE_IDS } from './release-4000-required-gates.js';
+import { REQUIRED_4002_REAL_CHECK_IDS, REQUIRED_4002_RELEASE_IDS } from './release-4002-required-gates.js';
+export const REQUIRED_3110_RELEASE_IDS = [
+    'core-skill:manifest',
+    'core-skill:immutable-sync',
+    'core-skill:no-drift',
+    'core-skill:integrity-blackbox',
+    'skill:name-canonicalizer',
+    'skill:registry-ledger',
+    'skill:dedupe',
+    'skill:sync-atomic',
+    'skill:dedupe-blackbox',
+    'native-capability:repair-matrix',
+    'native-capability:repair',
+    'native-capability:postcheck',
+    'native:image-generation-repair',
+    'native:computer-use-repair',
+    'native:chrome-web-review-repair',
+    'native:app-screenshot-repair',
+    'doctor:native-capability-repair',
+    'doctor:native-repair-output',
+    'doctor:native-capability-repair-blackbox',
+    'secret:preservation',
+    'config:managed-merge',
+    'secret:preservation-guard',
+    'secret:supabase-preservation-blackbox',
+    'update:preserves-supabase-keys',
+    'update:secret-preservation-guard',
+    'update:secret-migration-journal',
+    'config:managed-merge-callsite-coverage',
+    'release:gate-script-parity',
+    'release:wiring-3110-blackbox',
+    'sks:3110-all-feature-regression'
+];
+if (isMain()) {
+    main().catch((err) => {
+        console.error(err instanceof Error ? err.stack || err.message : String(err));
+        process.exit(1);
+    });
+}
+export async function main() {
+    const report = buildReleaseGateScriptParityReport();
+    const out = path.join(root, '.sneakoscope', 'reports', 'release-gate-script-parity.json');
+    await writeJsonAtomic(out, report);
+    assertGate(report.ok, 'release gate script parity failed', report);
+    emitGate('release:gate-script-parity', {
+        release_gate_count: report.release_gate_count,
+        checked_required_ids: report.checked_required_ids
+    });
+}
+export function buildReleaseGateScriptParityReport() {
+    const pkg = readJson('package.json');
+    const manifest = readJson('release-gates.v2.json');
+    const scripts = pkg.scripts || {};
+    const gates = Array.isArray(manifest.gates) ? manifest.gates : [];
+    const gateById = new Map(gates.map((gate) => [gate.id, gate]));
+    const releaseGateIds = gates.filter((gate) => gate.preset?.includes('release')).map((gate) => gate.id);
+    const requiredReleaseIds = [...new Set([...REQUIRED_3110_RELEASE_IDS, ...REQUIRED_3112_RELEASE_IDS, ...REQUIRED_3113_RELEASE_IDS, ...REQUIRED_4000_RELEASE_IDS, ...REQUIRED_4002_RELEASE_IDS, 'codex:0140-real-probes'])];
+    const requiredRealCheckIds = [...new Set([...REQUIRED_3112_REAL_CHECK_IDS, ...REQUIRED_3113_REAL_CHECK_IDS, ...REQUIRED_4000_REAL_CHECK_IDS, ...REQUIRED_4002_REAL_CHECK_IDS])];
+    const requiredAllIds = [...new Set([...requiredReleaseIds, ...requiredRealCheckIds])];
+    const missingScripts = [...new Set([
+            ...releaseGateIds.filter((id) => !scripts[id]),
+            ...requiredAllIds.filter((id) => !scripts[id])
+        ])].sort();
+    const missingGates = requiredAllIds.filter((id) => !gateById.has(id)).sort();
+    const missingReleasePreset = requiredReleaseIds.filter((id) => !gateById.get(id)?.preset?.includes('release')).sort();
+    const missingRealCheckPreset = requiredRealCheckIds.filter((id) => !gateById.get(id)?.preset?.includes('real-check')).sort();
+    const wrongCommands = requiredAllIds
+        .map((id) => ({ id, expected: `npm run ${id} --silent`, actual: gateById.get(id)?.command || '' }))
+        .filter((row) => row.actual !== row.expected);
+    const missingSourceTargets = requiredAllIds
+        .map((id) => ({ id, source: sourceTargetForScript(scripts[id]) }))
+        .filter((row) => row.source && !fs.existsSync(path.join(root, row.source)))
+        .map((row) => row.source)
+        .sort();
+    const missingDistTargets = requiredAllIds
+        .map((id) => ({ id, dist: distTargetForScript(scripts[id]) }))
+        .filter((row) => row.dist && fs.existsSync(path.join(root, 'dist')) && !fs.existsSync(path.join(root, row.dist)))
+        .map((row) => row.dist)
+        .sort();
+    return {
+        schema: 'sks.release-gate-script-parity.v1',
+        ok: missingScripts.length === 0 && missingGates.length === 0 && missingReleasePreset.length === 0 && missingRealCheckPreset.length === 0 && wrongCommands.length === 0 && missingSourceTargets.length === 0 && missingDistTargets.length === 0,
+        release_gate_count: releaseGateIds.length,
+        package_script_count: Object.keys(scripts).length,
+        checked_required_ids: requiredAllIds.length,
+        missing_scripts: missingScripts,
+        missing_gates: missingGates,
+        missing_release_preset: missingReleasePreset,
+        missing_real_check_preset: missingRealCheckPreset,
+        wrong_commands: wrongCommands,
+        missing_source_targets: missingSourceTargets,
+        missing_dist_targets: missingDistTargets
+    };
+}
+function distTargetForScript(script) {
+    const match = String(script || '').match(/node\s+\.\/dist\/scripts\/([^\s]+\.js)/);
+    return match ? `dist/scripts/${match[1]}` : null;
+}
+function sourceTargetForScript(script) {
+    const dist = distTargetForScript(script);
+    if (!dist)
+        return null;
+    return dist.replace(/^dist\/scripts\//, 'src/scripts/').replace(/\.js$/, '.ts');
+}
+function isMain() {
+    return path.resolve(process.argv[1] || '') === fileURLToPath(import.meta.url);
+}
+//# sourceMappingURL=release-gate-script-parity-check.js.map

package/dist/scripts/release-metadata-1-11-check.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-11-gate-lib.js';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const requiredDocs = ['README.md', 'CHANGELOG.md', 'docs/release-readiness.md', 'docs/ux-review.md', 'docs/ppt-imagegen-review.md', 'docs/dfix.md'];
+const requiredScripts = [
+    'ux-review:generate-callouts-fixture',
+    'ux-review:extract-real-callouts-fixture',
+    'ux-review:patch-handoff-fixture',
+    'ux-review:recapture-recheck-fixture',
+    'ux-review:no-fake-callouts',
+    'ppt:imagegen-review-fixture',
+    'ppt:slide-export-fixture',
+    'ppt:no-text-fallback',
+    'ppt:no-mock-as-real',
+    'ppt:issue-extraction-fixture',
+    'ppt:image-voxel-relations',
+    'ppt:proof-trust-fixture',
+    'dfix:fixture',
+    'dfix:verification',
+    'all-features:completion',
+    'json-schema:recursive-check'
+];
+assertGate(pkg.version === '1.11.0', 'package.json version must be 1.11.0', { version: pkg.version });
+for (const script of requiredScripts)
+    assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
+for (const file of requiredDocs) {
+    const absolute = path.join(root, file);
+    assertGate(fs.existsSync(absolute), `missing release doc: ${file}`);
+    if (['README.md', 'CHANGELOG.md', 'docs/release-readiness.md'].includes(file)) {
+        assertGate(fs.readFileSync(absolute, 'utf8').includes('1.11.0'), `release doc does not mention 1.11.0: ${file}`);
+    }
+}
+emitGate('release:metadata', { version: pkg.version, scripts: requiredScripts.length, docs: requiredDocs.length });
+//# sourceMappingURL=release-metadata-1-11-check.js.map

package/dist/scripts/release-metadata-1-12-check.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-11-gate-lib.js';
+const RELEASE_VERSION = '1.12.0';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const requiredDocs = ['README.md', 'CHANGELOG.md', 'docs/release-readiness.md', 'docs/ux-review.md', 'docs/ppt-imagegen-review.md', 'docs/dfix.md', 'docs/all-feature-completion.md'];
+const requiredScripts = [
+    'ux-review:run-wires-imagegen',
+    'ux-review:extract-wires-real-extractor',
+    'ux-review:patch-diff-recheck',
+    'ppt:real-export-adapter',
+    'ppt:real-imagegen-wiring',
+    'ppt:reexport-rereview',
+    'dfix:patch-handoff',
+    'dfix:verification-recommendation',
+    'all-features:deep-completion',
+    'evidence:flagship-coverage',
+    'ux-review:generate-callouts-fixture',
+    'ux-review:extract-real-callouts-fixture',
+    'ux-review:patch-handoff-fixture',
+    'ux-review:recapture-recheck-fixture',
+    'ux-review:no-fake-callouts',
+    'ppt:imagegen-review-fixture',
+    'ppt:slide-export-fixture',
+    'ppt:no-text-fallback',
+    'ppt:no-mock-as-real',
+    'ppt:issue-extraction-fixture',
+    'ppt:image-voxel-relations',
+    'ppt:proof-trust-fixture',
+    'dfix:fixture',
+    'dfix:verification',
+    'all-features:completion',
+    'json-schema:recursive-check'
+];
+assertGate(pkg.version === RELEASE_VERSION, `package.json version must be ${RELEASE_VERSION}`, { version: pkg.version });
+for (const script of requiredScripts)
+    assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
+for (const file of requiredDocs) {
+    const absolute = path.join(root, file);
+    assertGate(fs.existsSync(absolute), `missing release doc: ${file}`);
+    if (['README.md', 'CHANGELOG.md', 'docs/release-readiness.md', 'docs/all-feature-completion.md'].includes(file)) {
+        assertGate(fs.readFileSync(absolute, 'utf8').includes(RELEASE_VERSION), `release doc does not mention ${RELEASE_VERSION}: ${file}`);
+    }
+}
+emitGate('release:metadata', { version: pkg.version, scripts: requiredScripts.length, docs: requiredDocs.length });
+//# sourceMappingURL=release-metadata-1-12-check.js.map

package/dist/scripts/release-metadata-1-13-check.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-11-gate-lib.js';
+const RELEASE_VERSION = '1.13.0';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const requiredDocs = [
+    'README.md',
+    'CHANGELOG.md',
+    'docs/release-readiness.md',
+    'docs/ux-review.md',
+    'docs/ppt-imagegen-review.md',
+    'docs/dfix.md',
+    'docs/all-feature-completion.md',
+    'docs/performance-budgets.md',
+    'docs/wrongness-learning-loop.md',
+    'docs/hooks-pat.md'
+];
+const requiredScripts = [
+    'dfix:fast-kernel',
+    'dfix:blackbox-fast',
+    'dfix:performance',
+    'dfix:patch-handoff',
+    'dfix:verification-recommendation',
+    'dfix:fixture',
+    'dfix:verification',
+    'hooks:latest-schema-check',
+    'hooks:trust-state-check',
+    'hooks:trust-warning-zero',
+    'hooks:subagent-events-check',
+    'hooks:no-unsupported-handlers',
+    'hooks:codex-validate',
+    'hooks:warning-check',
+    'hooks:semantic-check',
+    'hooks:strict-subset-check',
+    'all-features:deep-completion',
+    'all-features:completion',
+    'evidence:flagship-coverage',
+    'json-schema:recursive-check'
+];
+assertGate(pkg.version === RELEASE_VERSION, `package.json version must be ${RELEASE_VERSION}`, { version: pkg.version });
+for (const script of requiredScripts)
+    assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
+for (const file of requiredDocs) {
+    const absolute = path.join(root, file);
+    assertGate(fs.existsSync(absolute), `missing release doc: ${file}`);
+    if (['README.md', 'CHANGELOG.md', 'docs/release-readiness.md', 'docs/dfix.md', 'docs/performance-budgets.md', 'docs/wrongness-learning-loop.md', 'docs/hooks-pat.md'].includes(file)) {
+        assertGate(fs.readFileSync(absolute, 'utf8').includes(RELEASE_VERSION), `release doc does not mention ${RELEASE_VERSION}: ${file}`);
+    }
+}
+emitGate('release:metadata', { version: pkg.version, scripts: requiredScripts.length, docs: requiredDocs.length });
+//# sourceMappingURL=release-metadata-1-13-check.js.map

package/dist/scripts/release-metadata-1-14-check.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-11-gate-lib.js';
+const RELEASE_VERSION = '1.14.1';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const requiredDocs = [
+    'README.md',
+    'CHANGELOG.md',
+    'docs/release-readiness.md',
+    'docs/official-docs-compat.md',
+    'docs/ux-review.md',
+    'docs/ppt-imagegen-review.md',
+    'docs/dfix.md',
+    'docs/all-feature-completion.md',
+    'docs/performance-budgets.md',
+    'docs/wrongness-learning-loop.md',
+    'docs/hooks-pat.md'
+];
+const requiredScripts = [
+    'dfix:fast-kernel',
+    'dfix:blackbox-fast',
+    'dfix:performance',
+    'dfix:patch-handoff',
+    'dfix:verification-recommendation',
+    'dfix:fixture',
+    'dfix:verification',
+    'hooks:latest-schema-check',
+    'hooks:trust-state-check',
+    'hooks:trust-warning-zero',
+    'hooks:subagent-events-check',
+    'hooks:no-unsupported-handlers',
+    'hooks:actual-parity-check',
+    'hooks:official-hash-parity',
+    'hooks:managed-install-fixture',
+    'hooks:runtime-replay-warning-zero',
+    'imagegen:capability',
+    'imagegen:gpt-image-2-request-validator',
+    'ux-review:imagegen-blackbox',
+    'ppt:imagegen-blackbox',
+    'ux-ppt:structured-extraction',
+    'hooks:codex-validate',
+    'hooks:warning-check',
+    'hooks:semantic-check',
+    'hooks:strict-subset-check',
+    'all-features:deep-completion',
+    'all-features:completion',
+    'evidence:flagship-coverage',
+    'json-schema:recursive-check'
+];
+assertGate(pkg.version === RELEASE_VERSION, `package.json version must be ${RELEASE_VERSION}`, { version: pkg.version });
+for (const script of requiredScripts)
+    assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
+for (const file of requiredDocs) {
+    const absolute = path.join(root, file);
+    assertGate(fs.existsSync(absolute), `missing release doc: ${file}`);
+    if (['README.md', 'CHANGELOG.md', 'docs/release-readiness.md', 'docs/official-docs-compat.md', 'docs/dfix.md', 'docs/performance-budgets.md', 'docs/wrongness-learning-loop.md', 'docs/hooks-pat.md'].includes(file)) {
+        assertGate(fs.readFileSync(absolute, 'utf8').includes(RELEASE_VERSION), `release doc does not mention ${RELEASE_VERSION}: ${file}`);
+    }
+}
+emitGate('release:metadata', { version: pkg.version, scripts: requiredScripts.length, docs: requiredDocs.length });
+//# sourceMappingURL=release-metadata-1-14-check.js.map

package/dist/scripts/release-metadata-1-16-check.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-11-gate-lib.js';
+const RELEASE_VERSION = '1.16.2';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
+const requiredDocs = [
+    'README.md',
+    'CHANGELOG.md',
+    'docs/release-readiness.md',
+    'docs/native-agent-kernel.md',
+    'docs/native-agent-engines.md',
+    'docs/native-agent-orchestration.md',
+    'docs/agent-non-recursive-pipeline.md',
+    'docs/agent-central-ledger.md',
+    'docs/work-partition-and-leases.md',
+    'docs/team-mode.md',
+    'docs/research-mode.md',
+    'docs/native-agent-orchestration.md'
+];
+const requiredScripts = [
+    'agent:non-recursive-pipeline',
+    'agent:non-recursive-pipeline-report',
+    'agent:legacy-multiagent-removed',
+    'agent:central-ledger',
+    'agent:work-partition',
+    'agent:no-overlap-proof',
+    'agent:persona-uniqueness',
+    'agent:max-cap',
+    'agent:fake-backend-blackbox',
+    'agent:lifecycle-close',
+    'agent:output-schema',
+    'agent:lease-conflicts',
+    'agent:proof-graph',
+    'team:native-agent-backend',
+    'research:native-agent-backend',
+    'qa:native-agent-backend',
+    'mad-sks:permission-model',
+    'mad-sks:immutable-harness',
+    'mad-sks:write-guard',
+    'mad-sks:audit-proof',
+    'mad-sks:no-harness-modification',
+    'mad-sks:actual-executor',
+    'mad-sks:file-write-executor',
+    'mad-sks:shell-executor',
+    'mad-sks:package-executor',
+    'mad-sks:service-executor',
+    'mad-sks:db-executor',
+    'mad-sks:rollback-apply',
+    'mad-sks:live-guard-smoke',
+    'mad-sks:executor-proof-graph',
+    'release:dist-freshness',
+    'codex:exec-output-schema-actual-syntax',
+    'flagship:proof-graph-v3',
+    'flagship:proof-graph-v4'
+];
+assertGate(pkg.version === RELEASE_VERSION, `package.json version must be ${RELEASE_VERSION}`, { version: pkg.version });
+assertGate(lock.version === RELEASE_VERSION, `package-lock version must be ${RELEASE_VERSION}`, { version: lock.version });
+assertGate(lock.packages?.['']?.version === RELEASE_VERSION, `package-lock root version must be ${RELEASE_VERSION}`, { version: lock.packages?.['']?.version });
+assertGate(pkg.scripts?.['release:metadata']?.includes('release-metadata-1-16-check.mjs'), 'release:metadata must point to the 1.16 release check');
+for (const script of requiredScripts)
+    assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
+for (const script of ['release:check', 'release:real-check', 'publish:dry', 'prepublishOnly']) {
+    assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
+}
+assertGate(pkg.scripts['release:check'].startsWith('npm run build && npm run release:dist-freshness'), 'release:check must start with build and dist freshness');
+for (const script of requiredScripts) {
+    assertGate(pkg.scripts['release:check'].includes(script), `release:check missing ${script}`);
+}
+assertGate(!/\bscouts?:/.test(pkg.scripts['release:real-check'] || ''), 'release:real-check must not require legacy multi-agent checks');
+assertGate(pkg.scripts.prepublishOnly.includes('release:dist-freshness'), 'prepublishOnly missing dist freshness');
+assertGate(pkg.scripts['publish:dry'].includes('release:dist-freshness'), 'publish:dry missing dist freshness');
+for (const file of requiredDocs) {
+    const absolute = path.join(root, file);
+    assertGate(fs.existsSync(absolute), `missing release doc: ${file}`);
+    assertGate(fs.readFileSync(absolute, 'utf8').includes(RELEASE_VERSION), `release doc does not mention ${RELEASE_VERSION}: ${file}`);
+}
+emitGate('release:metadata', { version: pkg.version, scripts: requiredScripts.length, docs: requiredDocs.length });
+//# sourceMappingURL=release-metadata-1-16-check.js.map