sneakoscope 2.0.9 → 2.0.10

package/dist/scripts/naruto-real-active-pool-runtime-check.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
+import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
+import { runNarutoRealActivePool } from '../core/naruto/naruto-active-pool.js';
+import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../core/naruto/naruto-real-worker-runtime.js';
+const graph = buildNarutoWorkGraph({ requestedClones: 12, totalWorkItems: 24, writeCapable: false, maxActiveWorkers: 6 });
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-real-runtime-'));
+const missionId = `M-naruto-real-runtime-${process.pid}`;
+const governor = decideNarutoConcurrency({
+    requestedClones: 12,
+    totalWorkItems: graph.total_work_items,
+    pendingWorkQueueSize: graph.total_work_items,
+    backend: 'codex-sdk',
+    hardware: { cores: 8, freeMemoryBytes: 32 * 1024 * 1024 * 1024, totalMemoryBytes: 64 * 1024 * 1024 * 1024, fileDescriptorLimit: 4096, processCount: 100, terminalRows: 40, remoteApiRateLimitBudget: 8 }
+});
+let spawned = 0;
+let collected = 0;
+const target = { ...governor, safe_active_workers: Math.min(6, governor.safe_active_workers), safe_zellij_visible_panes: 3 };
+const report = await runNarutoRealActivePool({
+    graph,
+    governor: target,
+    spawnWorker: async (item, placement) => {
+        spawned += 1;
+        return spawnActualNarutoWorker({
+            root: tempRoot,
+            missionId,
+            item,
+            placement,
+            backend: 'codex-sdk',
+            visiblePaneCap: target.safe_zellij_visible_panes,
+            zellijSessionName: `sks-${missionId}`
+        });
+    },
+    collectWorker: async (handle) => {
+        collected += 1;
+        return collectActualNarutoWorker(handle);
+    },
+    enqueueVerification: async () => undefined,
+    updateDashboard: async () => undefined
+});
+const processEvidence = report.worker_lifecycle.every((row) => row.pid && row.worker_artifact_dir);
+const artifactEvidence = report.worker_lifecycle.every((row) => row.worker_artifact_dir
+    && fs.existsSync(path.join(row.worker_artifact_dir, 'worker-heartbeat.jsonl'))
+    && fs.existsSync(path.join(row.worker_artifact_dir, 'worker-result.json')));
+const ok = report.ok && spawned === graph.total_work_items && collected === graph.total_work_items && report.max_observed_active_workers >= target.safe_active_workers && report.active_pool_utilization >= 0.8 && processEvidence && artifactEvidence;
+assertGate(ok, 'Naruto real active pool runtime must include actual child process, heartbeat, and result evidence', { report, spawned, collected, processEvidence, artifactEvidence, tempRoot });
+emitGate('naruto:real-active-pool-runtime', report);
+//# sourceMappingURL=naruto-real-active-pool-runtime-check.js.map

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

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

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

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { writeTextAtomic } from '../core/fsx.js';
 const root = process.cwd();
 const args = process.argv.slice(2);
 const reportPath = path.join(root, '.sneakoscope', 'reports', 'readme-architecture-imagegen-attempt-1.18.8.json');
@@ -139,12 +140,12 @@ else {
 }
 async function ensurePromptContract() {
     if (!promptExistedBeforeRun) {
-        await fs.promises.writeFile(promptPath, prompt);
+        await writeTextAtomic(promptPath, prompt);
         return { changed: true, reason: 'created' };
     }
     const existing = await fs.promises.readFile(promptPath, 'utf8').catch(() => null);
     if (existing !== prompt) {
-        await fs.promises.writeFile(promptPath, prompt);
+        await writeTextAtomic(promptPath, prompt);
         return { changed: true, reason: 'refreshed_prompt_changed' };
     }
     return { changed: false, reason: 'unchanged' };
@@ -334,7 +335,7 @@ async function textArtifactMeta(file, promptWrite = null) {
     };
 }
 async function writeReport(report) {
-    await fs.promises.writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+    await writeTextAtomic(reportPath, `${JSON.stringify(report, null, 2)}\n`);
 }
 async function sha256File(file) {
     return new Promise((resolve, reject) => {

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

@@ -40,7 +40,7 @@ const invariants = {
 };
 const distHash = distHashValue();
 const gitCommit = gitHead();
-const manifestHash = fileHash('release-gates.json');
+const manifestHash = fileHash(fs.existsSync(path.join(root, 'release-gates.v2.json')) ? 'release-gates.v2.json' : 'release-gates.json');
 const packageScriptsHash = sha256(JSON.stringify(pkg.scripts || {}));
 const nodeVersion = process.version;
 const npmVersion = npmVersionValue();
@@ -134,6 +134,25 @@ emitGate('release:check:dynamic:execute', {
 });
 // ---- helpers ----------------------------------------------------------------
 function loadManifest() {
+    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
+                };
+            })
+        };
+    }
     const p = path.join(root, 'release-gates.json');
     if (fs.existsSync(p))
         return JSON.parse(fs.readFileSync(p, 'utf8'));
@@ -143,6 +162,13 @@ function loadManifest() {
     const ids = [...new Set([...dagIds, ...releaseCheckIds])].filter((id) => id && id !== 'build' && id !== 'release:check:parallel');
     return buildGateManifest(ids);
 }
+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;
+}
 function hashAffectedFiles(globs) {
     const regexes = (globs || []).map(globToRegExp);
     const hashes = [];

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

@@ -12,17 +12,8 @@ const args = process.argv.slice(2);
 const publish = args.includes('--publish');
 const baseArg = readArg(args, '--base');
 const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const dagSource = fs.readFileSync(path.join(root, 'src/scripts/release-parallel-check.ts'), 'utf8');
-const dagIds = [...dagSource.matchAll(/task\('([^']+)'/g)].map((m) => m[1]);
-const releaseCheckIds = [...String(pkg.scripts?.['release:check'] || '').matchAll(/npm run ([^\s&]+)/g)].map((m) => m[1]);
-const releaseGateIds = [...new Set([...dagIds, ...releaseCheckIds])].filter((id) => id && id !== 'build' && id !== 'release:check:parallel');
-// Prefer the checked-in manifest; rebuild from the live set if absent.
-let manifest;
-const manifestPath = path.join(root, 'release-gates.json');
-if (fs.existsSync(manifestPath))
-    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-else
-    manifest = buildGateManifest(releaseGateIds);
+// Prefer the checked-in v2 DAG manifest and normalize it for the legacy dynamic selector.
+const manifest = loadDynamicManifest();
 const changedFiles = detectChangedFiles(baseArg);
 const plan = selectGates(manifest.gates, changedFiles, { publish });
 // --- Hermetic invariant proofs (independent of the current git state) ---
@@ -57,6 +48,42 @@ function readArg(list, name) {
     const i = list.indexOf(name);
     return i >= 0 ? list[i + 1] || null : null;
 }
+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
+                };
+            })
+        };
+    }
+    const manifestPath = path.join(root, 'release-gates.json');
+    if (fs.existsSync(manifestPath))
+        return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const legacySource = fs.readFileSync(path.join(root, 'src/scripts/release-parallel-check.ts'), 'utf8');
+    const legacyIds = [...legacySource.matchAll(/task\('([^']+)'/g)].map((m) => m[1]);
+    const releaseCheckIds = [...String(pkg.scripts?.['release:check'] || '').matchAll(/npm run ([^\s&]+)/g)].map((m) => m[1]);
+    const ids = [...new Set([...legacyIds, ...releaseCheckIds])].filter((id) => id && id !== 'build' && id !== 'release:check:parallel');
+    return buildGateManifest(ids);
+}
+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;
+}
 function detectChangedFiles(base) {
     try {
         let ref = base;

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

@@ -66,8 +66,11 @@ function gitCommit() {
     return result.status === 0 ? result.stdout.trim() : null;
 }
 function releaseGateHash(pkg) {
-    const gateManifest = fs.existsSync(path.join(root, 'release-gates.json')) ? fs.readFileSync(path.join(root, 'release-gates.json'), 'utf8') : '';
-    return sha256(`${pkg.scripts?.['release:check'] || ''}\0${pkg.scripts?.['prepublishOnly'] || ''}\0${gateManifest}`);
+    const manifests = ['release-gates.v2.json', 'release-gates.json'].map((rel) => {
+        const file = path.join(root, rel);
+        return fs.existsSync(file) ? `${rel}\0${fs.readFileSync(file, 'utf8')}` : `${rel}\0missing`;
+    }).join('\0');
+    return sha256(`${pkg.scripts?.['release:check'] || ''}\0${pkg.scripts?.['prepublishOnly'] || ''}\0${manifests}`);
 }
 function collectFiles(dir, out) {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -98,6 +101,8 @@ function releaseRelevant(file) {
         return false;
     if (/^(package|package-lock)\.json$/.test(file))
         return true;
+    if (/^release-gates(?:\.v2)?\.json$/.test(file))
+        return true;
     if (/^tsconfig.*\.json$/.test(file))
         return true;
     if (/^(README|CHANGELOG|LICENSE)(\.md)?$/i.test(file))

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

@@ -4,7 +4,8 @@ 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 manifest = JSON.parse(fs.readFileSync(path.join(root, 'release-gates.json'), 'utf8'));
+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']);
@@ -70,4 +71,33 @@ function readJson(rel, fallback) {
         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-gate-existence-audit.js

@@ -4,8 +4,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { assertGate, emitGate, packageScripts, root } from './sks-1-18-gate-lib.js';
 const scripts = packageScripts();
-const releaseDagSource = fs.readFileSync(path.join(root, 'src', 'scripts', 'release-parallel-check.ts'), 'utf8');
-const dagTasks = new Set([...releaseDagSource.matchAll(/task\('([^']+)'/g)].map((match) => match[1]));
+const releaseManifestPath = path.join(root, 'release-gates.v2.json');
+const releaseManifest = JSON.parse(fs.readFileSync(releaseManifestPath, 'utf8'));
+const releaseGates = Array.isArray(releaseManifest.gates)
+    ? releaseManifest.gates.filter((gate) => Array.isArray(gate.preset) && gate.preset.includes('release'))
+    : [];
+const dagTasks = new Set(releaseGates.map((gate) => gate.id));
+const manifestTasks = new Set((Array.isArray(releaseManifest.gates) ? releaseManifest.gates : []).map((gate) => gate.id));
 const removedRuntime = `${'tm'}ux`;
 const removedLane = `${'warp'}-right-${'lane'}`;
 const removedRuntimeGateRe = new RegExp(`^${removedRuntime}:|^agent:${removedRuntime}-|real-${removedRuntime}|${removedLane}`, 'i');
@@ -14,18 +19,26 @@ const required = [
     'terminal:keyboard-enhancement-safety',
     'terminal:tui-output-stability',
     'zellij:layout-valid',
-    'zellij:pane-proof',
-    'zellij:screen-proof',
+    'zellij:initial-main-only-blackbox',
+    'zellij:right-column-geometry-proof',
+    'zellij:dynamic-pane-lifecycle',
     'zellij:lane-renderer',
     'zellij:doctor-readiness',
     'zellij:spawn-on-demand-layout',
     'zellij:worker-pane-manager',
     'zellij:worker-pane-manager-single-owner',
+    'zellij:slot-only-ui',
+    'zellij:compact-slot-renderer',
+    'zellij:right-column-headless-overflow',
     'safety:mutation-callsite-coverage',
     'mad-sks:zellij-launch',
     'mad-sks:zellij-default-pane-worker',
     'agent:zellij-runtime',
+    'agent:slot-pane-binding-proof',
+    'agent:role-config-repair',
     'agent:worker-pane-communication-contract',
+    'git:worktree-integration-primary',
+    'git:worktree-integration-primary-runtime',
     'codex:0.136-compat',
     'codex:0.135-compat',
     'doctor:codex-doctor-parity',
@@ -34,10 +47,6 @@ const required = [
     'codex:resume-cwd-truth',
     'mcp:tool-naming-parity',
     'responses:retry-policy-centralized',
-    'codex:0.134-compat',
-    'codex:0.134-official-compat',
-    'codex:profile-primary',
-    'codex:managed-proxy-env',
     'codex-app:fast-ui-preservation',
     'codex-app:ui-clobber-guard',
     'doctor:fixes-codex-app-fast-ui',
@@ -47,32 +56,11 @@ const required = [
     'codex-app:provider-badge',
     'runtime:no-mjs-scripts',
     'runtime:ts-python-boundary',
-    'strategy:adhd-orchestrating-gate',
-    'strategy:parallel-modification-plan',
-    'strategy:file-ownership-plan',
-    'strategy:verification-rollback-dag',
-    'appshots:capability',
-    'appshots:operator-policy',
-    'appshots:evidence',
-    'appshots:source-intelligence',
-    'appshots:triwiki-voxel',
-    'appshots:privacy-safety',
-    'mcp:0.134-modernization',
-    'mcp:readonly-concurrency',
-    'hooks:0.134-context-parity',
-    'source-intelligence:codex-history-search',
-    'agent:parallel-write-kernel',
-    'agent:parallel-write-blackbox',
-    'team:parallel-write-blackbox',
-    'dfix:parallel-write-blackbox',
-    'agent:patch-proof',
-    'agent:patch-rollback',
     'agent:patch-swarm-runtime-truth',
     'agent:patch-transaction-journal',
     'agent:patch-conflict-rebase',
     'agent:strategy-to-patch-strict',
     'agent:rollback-command',
-    'agent:real-codex-patch-envelope-smoke',
     'agent:native-cli-session-swarm',
     'agent:native-cli-session-swarm-10',
     'agent:native-cli-session-swarm-20',
@@ -82,7 +70,12 @@ const required = [
     'agent:fast-mode-worker-propagation',
     'codex:fast-mode-profile-propagation',
     'mad-sks:fast-mode-propagation',
-    'release:runtime-truth-matrix',
+    'naruto:active-pool',
+    'naruto:real-active-pool',
+    'naruto:real-active-pool-runtime',
+    'naruto:extreme-parallelism',
+    'naruto:extreme-parallelism-real',
+    'naruto:zellij-dynamic-right-column',
     'agent:wiki-context-proof',
     'shared-memory:check',
     'wrongness:check',
@@ -90,10 +83,13 @@ const required = [
     'trust:check',
     'git-collaboration:e2e'
 ];
+assertGate(releaseManifest.schema === 'sks.release-gates.v2', 'release gate manifest schema mismatch', { schema: releaseManifest.schema });
+assertGate(String(scripts['release:check'] || '').includes('release-gate-dag-runner') && String(scripts['release:check'] || '').includes('--preset release'), 'release:check must use the v2 DAG release preset', { release_check: scripts['release:check'] });
+assertGate(releaseGates.length > 0, 'release v2 manifest must include release preset gates', { gate_count: releaseGates.length });
 for (const name of required) {
     assertGate(Boolean(scripts[name]), `missing release gate script: ${name}`, { required });
-    const inReleaseCheck = dagTasks.has(name) || String(scripts['release:check'] || '').includes(`npm run ${name}`);
-    assertGate(inReleaseCheck, `critical release gate missing from release DAG: ${name}`, { name, dag_tasks: [...dagTasks].sort() });
+    const inReleaseManifest = manifestTasks.has(name);
+    assertGate(inReleaseManifest, `critical gate missing from release v2 manifest: ${name}`, { name, release_gates: [...dagTasks].sort(), manifest_gates: [...manifestTasks].sort() });
     const match = String(scripts[name]).match(/node\s+(\.\/dist\/scripts\/[^ ]+\.js)/);
     if (match)
         assertGate(fs.existsSync(path.join(root, match[1])), `script target missing for ${name}`, { command: scripts[name] });
@@ -107,5 +103,5 @@ for (const name of dagTasks) {
 for (const name of Object.keys(scripts)) {
     assertGate(!removedRuntimeGateRe.test(name), `tmux package gate remains: ${name}`, { name });
 }
-emitGate('release:gate-existence-audit', { gates: required.length, dag_tasks: dagTasks.size });
+emitGate('release:gate-existence-audit', { gates: required.length, dag_tasks: dagTasks.size, manifest: 'release-gates.v2.json' });
 //# sourceMappingURL=release-gate-existence-audit.js.map

package/dist/scripts/release-readiness-report.js

@@ -10,8 +10,13 @@ const reportDir = path.join(root, '.sneakoscope', 'reports');
 const RELEASE_VERSION = pkg.version;
 const jsonPath = path.join(reportDir, `release-readiness-${RELEASE_VERSION}.json`);
 const mdPath = path.join(reportDir, `release-readiness-${RELEASE_VERSION}.md`);
+const releaseGateManifest = readJson('release-gates.v2.json', { gates: [] });
+const releaseGateIds = new Set((Array.isArray(releaseGateManifest.gates) ? releaseGateManifest.gates : [])
+    .filter((gate) => Array.isArray(gate.preset) && gate.preset.includes('release'))
+    .map((gate) => gate.id));
 const releaseParallelCheckSource = readText('src/scripts/release-parallel-check.ts', '');
 const releaseRealCheckSource = readText('src/scripts/release-real-check.ts', '');
+const hooksRuntimeSource = readText('src/core/hooks-runtime.ts', '');
 const checks = {
     runtime_no_src_mjs: scriptContains('release:check:parallel', 'runtime:no-src-mjs'),
     runtime_ts_source_of_truth: scriptContains('release:check:parallel', 'runtime:ts-source-of-truth'),
@@ -208,7 +213,8 @@ const checks = {
     official_docs_compat: scriptContains('release:check', 'official-docs:compat'),
     update_check_function_only: fileContains('src/core/update-check.ts', 'pipeline_required: false')
         && fileContains('src/core/update-check.ts', "mode: 'function'")
-        && fileContains('src/core/hooks-runtime.ts', 'runSksUpdateCheck')
+        && fileContains('src/core/hooks-runtime.ts', 'UPDATE_CHECK_HOOK_INVOCATION_POLICY')
+        && !/\brunSksUpdateCheck\s*\(/.test(stripComments(hooksRuntimeSource))
 };
 const docs = runNodeScript('dist/scripts/docs-truthfulness-check.js');
 const officialDocs = runNodeScriptWithOkReportCache('dist/scripts/official-docs-compat-report.js', `.sneakoscope/reports/official-docs-compat-${RELEASE_VERSION}.json`, ['src/scripts/official-docs-compat-report.ts', 'package.json', 'package-lock.json']);
@@ -1004,13 +1010,18 @@ function scriptContains(name, needle) {
         return String(pkg.scripts?.[name] || '').includes(needle) || releaseParallelCheckSource.includes(needle);
     }
     if (name === 'release:check') {
-        return String(pkg.scripts?.[name] || '').includes(needle) || releaseParallelCheckSource.includes(needle);
+        return String(pkg.scripts?.[name] || '').includes(needle) || releaseParallelCheckSource.includes(needle) || releaseGateIds.has(needle);
     }
     if (name === 'release:real-check') {
         return String(pkg.scripts?.[name] || '').includes(needle) || releaseRealCheckSource.includes(needle);
     }
     return String(pkg.scripts?.[name] || '').includes(needle);
 }
+function stripComments(text) {
+    return String(text || '')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/(^|[^:])\/\/.*$/gm, '$1');
+}
 function readText(rel, fallback = '') {
     try {
         return fs.readFileSync(path.join(root, rel), 'utf8');