sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/release-cache-version-neutral-fixture-check.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { releaseGateCacheKey } from '../core/release/release-gate-cache-v2.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const gate = {
+    id: 'fixture:release-cache',
+    command: 'node fixture.js',
+    deps: [],
+    resource: ['cpu-light'],
+    side_effect: 'hermetic',
+    timeout_ms: 1000,
+    cache: { enabled: true, inputs: ['package.json', 'package-lock.json', 'src/**', 'dist/build-manifest.json'] },
+    isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
+    preset: ['release']
+};
+const fixtures = [
+    ['package version only', (f) => f.pkg.version = '3.0.2', true],
+    ['package script changes', (f) => f.pkg.scripts.test = 'node changed.js', false],
+    ['package dependency changes', (f) => f.pkg.dependencies.left = '2.0.0', false],
+    ['package files changes', (f) => f.pkg.files.push('extra'), false],
+    ['package-lock root version only', (f) => { f.lock.version = '3.0.2'; f.lock.packages[''].version = '3.0.2'; }, true],
+    ['package-lock dependency version changes', (f) => f.lock.packages['node_modules/left'].version = '2.0.0', false],
+    ['version.ts const only', (f) => f.versionTs = "export const PACKAGE_VERSION = '3.0.2';\n", true],
+    ['version.ts logic change', (f) => f.versionTs += 'export const EXTRA = true;\n', false],
+    ['sks.ts fast version only', (f) => f.sksTs = "const FAST_PACKAGE_VERSION = '3.0.2';\n", true],
+    ['sks.ts CLI logic change', (f) => f.sksTs += 'console.log(\"changed\");\n', false],
+    ['build manifest version only', (f) => { f.manifest.version = '3.0.2'; f.manifest.package_version = '3.0.2'; }, true],
+    ['build manifest artifact hash change', (f) => f.manifest.files['dist/bin/sks.js'] = 'hash-b', false]
+];
+for (const [name, mutate, shouldMatch] of fixtures) {
+    const beforeRoot = await writeFixture();
+    const afterRoot = await writeFixture(mutate);
+    const beforeKey = releaseGateCacheKey(beforeRoot, gate);
+    const afterKey = releaseGateCacheKey(afterRoot, gate);
+    assertGate((beforeKey === afterKey) === shouldMatch, `release cache key fixture mismatch: ${name}`, { name, shouldMatch, beforeKey, afterKey });
+}
+emitGate('release:cache-version-neutral-fixtures', { fixtures: fixtures.length });
+async function writeFixture(mutate) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-release-cache-'));
+    const f = {
+        pkg: { name: 'sneakoscope', version: '3.0.0', scripts: { test: 'node test.js' }, dependencies: { left: '1.0.0' }, files: ['dist'] },
+        lock: { name: 'sneakoscope', version: '3.0.0', lockfileVersion: 3, packages: { '': { name: 'sneakoscope', version: '3.0.0', dependencies: { left: '1.0.0' } }, 'node_modules/left': { version: '1.0.0' } } },
+        versionTs: "export const PACKAGE_VERSION = '3.0.0';\n",
+        fsxTs: "export const PACKAGE_VERSION = '3.0.0';\n",
+        sksTs: "const FAST_PACKAGE_VERSION = '3.0.0';\n",
+        manifest: { version: '3.0.0', package_version: '3.0.0', files: { 'dist/bin/sks.js': 'hash-a' } }
+    };
+    if (mutate)
+        mutate(f);
+    await fs.mkdir(path.join(root, 'src/core'), { recursive: true });
+    await fs.mkdir(path.join(root, 'src/bin'), { recursive: true });
+    await fs.mkdir(path.join(root, 'dist'), { recursive: true });
+    await fs.writeFile(path.join(root, 'package.json'), JSON.stringify(f.pkg, null, 2));
+    await fs.writeFile(path.join(root, 'package-lock.json'), JSON.stringify(f.lock, null, 2));
+    await fs.writeFile(path.join(root, 'release-gates.v2.json'), JSON.stringify({ schema: 'sks.release-gates.v2', gates: [gate] }, null, 2));
+    await fs.writeFile(path.join(root, 'src/core/version.ts'), f.versionTs);
+    await fs.writeFile(path.join(root, 'src/core/fsx.ts'), f.fsxTs);
+    await fs.writeFile(path.join(root, 'src/bin/sks.ts'), f.sksTs);
+    await fs.writeFile(path.join(root, 'dist/build-manifest.json'), JSON.stringify(f.manifest, null, 2));
+    return root;
+}
+//# sourceMappingURL=release-cache-version-neutral-fixture-check.js.map

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

@@ -103,7 +103,8 @@ function collectFiles(dir, out) {
 function gitFiles() {
     const result = spawnSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], {
         cwd: root,
-        encoding: 'utf8'
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024
     });
     if (result.status !== 0)
         fail('unable to list release-relevant files', result.stderr || result.stdout);

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

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.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_4001_REAL_CHECK_IDS, REQUIRED_4001_RELEASE_IDS } from './release-4001-required-gates.js';
+import { REQUIRED_4002_REAL_CHECK_IDS, REQUIRED_4002_RELEASE_IDS } from './release-4002-required-gates.js';
+const pkg = readPackageJson(path.join(root, 'package.json'));
+const manifest = readReleaseGateManifest(path.join(root, 'release-gates.v2.json'));
+const scripts = pkg.scripts || {};
+const legacy = String(scripts['release:check:legacy'] || '');
+const legacyIds = [...new Set([...legacy.matchAll(/npm run ([^\s&]+)/g)]
+        .map((match) => String(match[1] || ''))
+        .filter((id) => Boolean(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 realCheckPresetIds = new Set(manifest.gates.filter((gate) => Array.isArray(gate.preset) && (gate.preset.includes('real-check') || gate.preset.includes('strict-release'))).map((gate) => gate.id));
+const requiredReleasePresetIds = [
+    'zellij:first-slot-down-stack',
+    'zellij:slot-renderer-proof-semantics',
+    'zellij:slot-telemetry',
+    'zellij:slot-telemetry-runtime',
+    'zellij:slot-pane-telemetry-renderer',
+    'zellij:slot-column-anchor-telemetry',
+    'agent:slot-telemetry-wiring',
+    'zellij:slot-telemetry-renderer',
+    '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:runtime-truth-matrix',
+    'zellij:stacked-version-matrix',
+    'zellij:stacked-capability-routing',
+    'zellij:pane-lock-concurrency-blackbox',
+    'release:cache-version-neutral-fixtures',
+    'agent:message-bus-reader',
+    'runtime:proof-summary-messages',
+    'zellij:update-prompt-matrix',
+    'release:proof-truth',
+    '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',
+    'research:synthesis-writer',
+    'research:synthesis-writer-blackbox',
+    'research:repetition-detector',
+    'research:template-report-rejection',
+    'research:real-synthesis-no-deterministic-renderer',
+    'research:handoff-consumability',
+    'codex-sdk:research-pipeline',
+    'release:affected-selector',
+    'release:dynamic-presets',
+    'release:batch-runner',
+    'release:gate-batch-runner',
+    'release:aggressive-resource-governor',
+    'release:speed-summary',
+    'release:speed-summary:check',
+    'naruto:ssot-routing',
+    'naruto:ssot-route-normalization',
+    'naruto:ssot-default',
+    'naruto:ssot-gate-aliases',
+    'naruto:ssot-pipeline-default',
+    'update:notice',
+    'update:gate-removed',
+    'update:mad-zellij-notice',
+    'mad-db:capability',
+    'mad-db:command',
+    'mad-db:mad-command',
+    'mad-db:priority-resolver',
+    'mad-db:ledger',
+    'mad-db:one-cycle-consumption',
+    'mad-db:safety-conflict-matrix',
+    'parallel:runtime-proof',
+    'parallel:runtime-proof-events',
+    'parallel:runtime-real-blackbox',
+    'parallel:claim-enforcement',
+    'scheduler:batch-dispatch',
+    'scheduler:utilization-proof',
+    'native-swarm:process-spawn-proof',
+    'native-swarm:zellij-does-not-block-workers',
+    'model-call:concurrency',
+    'naruto:parallelism-mode',
+    'naruto:visible-vs-active-workers',
+    'naruto:parallel-runtime-proof',
+    'naruto:real-parallelism-blackbox',
+    'git:worktree-batch-allocation',
+    'release:full-parallelism-blackbox',
+    'zellij:slot-telemetry-incremental',
+    'zellij:slot-telemetry-performance',
+    'team:legacy-create-removed',
+    'mad-db:one-cycle-bounded',
+    'mad-db:operation-lifecycle-ledger',
+    'parallel:strict-pid-proof',
+    'parallel:missing-pid-rejection',
+    'scheduler:utilization-integral',
+    'scheduler:parallel-proof-consistency',
+    'zellij:slot-telemetry-live-flush',
+    'zellij:slot-pane-stale-detection',
+    'mad-db:lifecycle-hook-decision',
+    'mad-db:mcp-result-lifecycle',
+    'mad-db:operation-lifecycle-blackbox',
+    'runtime:proof-summary',
+    'runtime:proof-summary-cli',
+    'codex:0138-capability',
+    'codex:0138-capability-artifact',
+    'codex-sdk:version-compat',
+    'codex-app:handoff',
+    'qa-loop:app-handoff',
+    'qa-loop:app-handoff-capability',
+    'qa-loop:app-handoff-cli',
+    'zellij:qa-app-handoff-status',
+    'codex-plugin:json',
+    'codex-plugin:inventory',
+    'mcp:plugin-inventory',
+    'codex-plugin:app-template-policy',
+    'image:artifact-path-contract',
+    'qa-loop:image-path-exposure',
+    'image:generation-path-handoff',
+    'image:followup-edit-path',
+    'codex:effort-order',
+    'qa-loop:effort-escalation',
+    'codex:account-usage',
+    'qa-loop:budget-policy',
+    'naruto:parallel-gate-consistency',
+    'codex:0138-doctor',
+    'doctor:codex-0138-fix',
+    'codex:0138-feature-probes',
+    'codex:0139-capability',
+    'codex:0139-feature-probes',
+    'codex:0139-interrupt-agent',
+    'codex:0139-rich-tool-schema',
+    'codex:0139-doctor-env-redaction',
+    'codex:0139-code-mode-web-search',
+    'codex:0139-marketplace-source',
+    'codex:0139-sandbox-profile-alias',
+    'codex:0139-real-probes',
+    'codex:0139-real-probe-summary',
+    'doctor:codex-0139-real-probes',
+    'zellij:fake-adapter',
+    'zellij:pane-lock-open-worker-integration',
+    'zellij:stacked-fallback-integration',
+    'runtime:proof-zellij-stacked-summary',
+    'naruto:proof-zellij-stacked-summary',
+    'docs:codex-0139-wording',
+    'codex-app:launcher',
+    'codex-app:handoff-launch',
+    'qa-loop:app-handoff-launch',
+    'qa-loop:app-handoff-confirmation',
+    'qa-loop:app-handoff-status-lifecycle',
+    'qa-loop:app-handoff-gate-lifecycle',
+    'codex-plugin:parallel-detail-fetch',
+    'codex-plugin:cache',
+    'codex-plugin:diff',
+    'image:artifact-registry',
+    'image:global-path-contract',
+    'qa-loop:image-path-prompt-injection',
+    'codex:model-metadata',
+    'codex:effort-auto-discovery',
+    'codex:account-usage-autodiscovery',
+    'loop:schema',
+    'loop:planner',
+    'loop:runtime',
+    'loop:gate-selector',
+    'loop:lease',
+    'loop:collision-blackbox',
+    'naruto:loop-mesh',
+    'naruto:loop-mesh-blackbox',
+    'loop:cli',
+    'loop:observability',
+    'goal:loop-runtime-default',
+    'goal:legacy-runtime-escape',
+    'loop:fixture-policy',
+    'loop:fixture-production-misuse-blackbox',
+    'loop:final-arbiter-contract',
+    'loop:gpt-final-contract-crossref',
+    'loop:merge-strategy',
+    'loop:merge-strategy-blackbox',
+    'loop:side-effect-scanner',
+    'loop:side-effect-blackbox',
+    'loop:worker-interrupt',
+    'loop:kill-interrupt-real-blackbox',
+    'loop:concurrency-budget',
+    'loop:concurrency-oversubscription-blackbox',
+    'loop:mesh-production-e2e-blackbox',
+    'changelog:loop-productionization',
+    'lint:no-ts-nocheck-core',
+    'codex-app:type-safety',
+    'type-surface:codex-app',
+    'zellij:self-heal',
+    'zellij:self-heal-status-contract',
+    'zellij:self-heal-dry-run',
+    'zellij:self-heal-typed-blackbox',
+    'doctor:zellij-fix-blackbox',
+    'mad:zellij-self-heal-blackbox',
+    'mad:zellij-no-contradictory-output',
+    'brand-neutrality:zero-leakage',
+    'brand-neutrality:zero-leakage-blackbox',
+    'docs:brand-neutrality',
+    'codex-native:feature-broker',
+    'codex-native:invocation-router',
+    'codex-native:route-map',
+    'pipeline:codex-native-loop-routing',
+    'pipeline:codex-native-qa-routing',
+    'pipeline:codex-native-research-routing',
+    'pipeline:codex-native-image-routing',
+    'pipeline:codex-native-doctor-mad-routing',
+    'codex-native:pattern-analysis',
+    'codex-native:reference-evidence',
+    'codex-native:pattern-analysis-blackbox',
+    'codex-native:skill-content',
+    'codex-native:agent-role-content',
+    'codex-native:hook-lifecycle-proof',
+    'init-deep:backup-retention',
+    'init-deep:memory-scope-safety',
+    'release-scripts:type-safe',
+    'lint:no-ts-nocheck-release-scripts',
+    'doctor:codex-native-readiness-ux',
+    'codex-native:feature-broker-blackbox',
+    'pipeline:codex-native-e2e-blackbox',
+    'codex-app:harness-matrix',
+    'codex-app:hook-approval-probe',
+    'codex-app:hook-approval-matrix',
+    'codex-app:hook-approval-blackbox',
+    'codex-app:agent-type-probe',
+    'codex-app:agent-type-routing',
+    'codex-app:agent-type-blackbox',
+    'doctor:codex-app-harness',
+    'codex-app:skill-sync',
+    'codex-app:skill-rich-content',
+    'codex-app:agent-role-sync',
+    'codex-app:agent-role-rich-content',
+    'codex-app:init-deep',
+    'codex-app:init-deep-managed-agents',
+    'loop:planner-project-memory-deep',
+    'codex-app:init-deep-directory-local-blackbox',
+    'codex-app:hook-lifecycle',
+    'codex-app:execution-profile',
+    'loop:execution-profile-routing',
+    'qa-loop:execution-profile-routing',
+    'research:execution-profile-routing',
+    'pipeline:execution-profile-routing-blackbox',
+    'codex-native:harness-compat',
+    'codex-native:invocation-defaults',
+    'codex-native:interop-policy',
+    'doctor:codex-native-repair-actions',
+    'codex-app:harness-blackbox',
+    'brand-neutrality:rename-map',
+    'pipeline:codex-native-loop-routing-real-blackbox',
+    'pipeline:codex-native-qa-routing-real-blackbox',
+    'pipeline:codex-native-research-routing-real-blackbox',
+    'pipeline:codex-native-image-routing-real-blackbox',
+    'pipeline:codex-native-doctor-mad-routing-real-blackbox',
+    'codex-native:reference-cache',
+    'codex-native:reference-cache-blackbox',
+    'codex-native:broker-read-only',
+    'codex-native:repair-transaction',
+    'codex-native:read-repair-split-blackbox',
+    'brand-neutrality:generated-artifacts',
+    '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',
+    'release:wiring-3112-blackbox',
+    'codex:0140-capability',
+    'codex:0140-feature-probes',
+    'codex:0140-usage',
+    'codex:0140-goal-attachment-preservation',
+    'codex:0140-session-delete',
+    'codex:0140-import',
+    'codex:0140-unified-mentions',
+    'codex:0140-bedrock-managed-auth',
+    'codex:0140-mcp-reliability',
+    'codex:0140-sqlite-recovery',
+    'codex:0140-non-tty-interrupt',
+    'codex:0140-large-repo-performance',
+    'pipeline:codex-0140-integration',
+    'codex:0140-integration-blackbox',
+    'doctor:fix-production-blackbox',
+    'doctor:startup-config-repair',
+    'doctor:startup-config-repair-blackbox',
+    'doctor:context7-mcp-repair',
+    'doctor:context7-mcp-repair-blackbox',
+    'doctor:supabase-mcp-repair',
+    'doctor:supabase-mcp-repair-blackbox',
+    'sks:3112-all-feature-regression',
+    ...REQUIRED_3113_RELEASE_IDS,
+    ...REQUIRED_4000_RELEASE_IDS,
+    ...REQUIRED_4001_RELEASE_IDS,
+    ...REQUIRED_4002_RELEASE_IDS
+];
+const requiredRealCheckPresetIds = [
+    'codex:0139-real-probes:require-real',
+    'codex:0139-code-mode-web-search-real',
+    'codex:0139-rich-tool-schema-real',
+    'codex:0139-doctor-env-real',
+    'codex:0139-plugin-marketplace-real',
+    'codex:0139-plugin-cache-real',
+    'codex:0139-sandbox-profile-alias-real',
+    'codex:0139-interrupt-agent-real',
+    'codex:0139-image-path-real',
+    'codex:0139-sandbox-proxy-real',
+    'codex:0140-real-probes:require-real',
+    ...REQUIRED_3113_REAL_CHECK_IDS,
+    ...REQUIRED_4000_REAL_CHECK_IDS,
+    ...REQUIRED_4001_REAL_CHECK_IDS,
+    ...REQUIRED_4002_REAL_CHECK_IDS
+];
+const missing = legacyIds.filter((id) => !gateIds.has(id) && !allowlist.has(id));
+const missingRequiredReleasePreset = requiredReleasePresetIds.filter((id) => !gateIds.has(id) || !releasePresetIds.has(id));
+const missingRequiredRealCheckPreset = requiredRealCheckPresetIds.filter((id) => !gateIds.has(id) || !realCheckPresetIds.has(id));
+const codex0139RequiredGates = requiredReleasePresetIds.filter((id) => id.startsWith('codex:0139'));
+const codex0139MissingRequiredGates = codex0139RequiredGates.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 && missingRequiredRealCheckPreset.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,
+    required_real_check_preset_ids: requiredRealCheckPresetIds,
+    missing_required_real_check_preset: missingRequiredRealCheckPreset,
+    codex_0139_required_gates: codex0139RequiredGates,
+    codex_0139_missing_required_gates: codex0139MissingRequiredGates,
+    allowed,
+    schema_complete: schemaComplete
+};
+assertGate(report.ok, 'release-gates.v2 must cover legacy hermetic release gates', report);
+emitGate('release:dag-full-coverage', report);
+function readPackageJson(file) {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!isRecord(parsed))
+        return {};
+    const scripts = parsed.scripts;
+    if (!isRecord(scripts))
+        return {};
+    return { scripts: Object.fromEntries(Object.entries(scripts).map(([key, value]) => [key, String(value)])) };
+}
+function readReleaseGateManifest(file) {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    assertGate(isRecord(parsed), 'release gate manifest must be an object', { file });
+    if (!isRecord(parsed))
+        return { gates: [] };
+    const gatesValue = parsed.gates;
+    assertGate(Array.isArray(gatesValue), 'release gate manifest missing gates array', { file });
+    if (!Array.isArray(gatesValue))
+        return { gates: [] };
+    const gatesRaw = gatesValue;
+    const gates = gatesRaw.filter(isReleaseGate);
+    assertGate(gates.length === gatesRaw.length, 'release gate manifest contains invalid gates', {
+        file,
+        invalid_count: gatesRaw.length - gates.length
+    });
+    return { gates };
+}
+function isReleaseGate(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value.id === 'string'
+        && typeof value.command === 'string'
+        && typeof value.side_effect === 'string'
+        && typeof value.timeout_ms === 'number'
+        && normalizeStringList(value.deps).length === (Array.isArray(value.deps) ? value.deps.length : 0)
+        && normalizeStringList(value.resource).length === (Array.isArray(value.resource) ? value.resource.length : 0)
+        && normalizeStringList(value.preset).length === (Array.isArray(value.preset) ? value.preset.length : 0)
+        && value.cache !== undefined
+        && value.isolation !== undefined;
+}
+function normalizeStringList(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string').map((item) => item.trim()).filter(Boolean) : [];
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=release-dag-full-coverage-check.js.map

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

@@ -0,0 +1,8 @@
+#!/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

@@ -0,0 +1,110 @@
+#!/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 [
+        'runtime:no-mjs-scripts',
+        'runtime:ts-python-boundary',
+        'runtime:proof-summary',
+        'runtime:proof-summary-cli',
+        'runtime:proof-summary-messages',
+        'runtime:proof-zellij-stacked-summary'
+    ].includes(id);
+}
+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

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { assertGate, emitGate, packageScripts, readText } from './sks-1-18-gate-lib.js';
+import { importDist, root } from './sks-1-18-gate-lib.js';
+const scripts = packageScripts();
+const dagMod = await importDist('core/release/release-gate-dag.js');
+const manifest = dagMod.loadReleaseGateManifest(root);
+const releaseCount = dagMod.selectReleaseGatePreset(manifest, 'release').length;
+const dag = readText('src/core/release/release-gate-dag.ts');
+const runner = readText('src/scripts/release-gate-dag-runner.ts');
+for (const name of ['release:check:affected', 'release:check:full', 'release:check:fast', 'release:check:confidence', 'release:check:research']) {
+    assertGate(Boolean(scripts[name]), `missing package script ${name}`);
+}
+assertGate(String(scripts['release:check']).includes('release:check:affected'), 'release:check must default to affected preset');
+assertGate(String(scripts['release:check:affected']).includes('build:incremental') && String(scripts['release:check:fast']).includes('build:incremental') && String(scripts['release:check:confidence']).includes('--sla 5m'), 'affected/fast/confidence checks must use incremental build and five-minute SLA');
+assertGate(dag.includes('selectAffectedReleaseGates'), 'release DAG must use affected selector');
+assertGate(dagMod.selectReleaseGatePreset(manifest, 'affected').length === releaseCount, 'affected preset must select the release gate universe before affected filtering');
+assertGate(dagMod.selectReleaseGatePreset(manifest, 'fast').length === releaseCount, 'fast preset must select the release gate universe before affected filtering');
+assertGate(runner.includes('--changed-since') && runner.includes('--full') && runner.includes('--sla'), 'release DAG runner must parse changed-since/full/sla');
+emitGate('release:dynamic-presets', { presets: 5 });
+//# sourceMappingURL=release-dynamic-presets-check.js.map