sneakoscope 2.0.8 → 2.0.10

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-dag-full-coverage-check.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const manifest = JSON.parse(fs.readFileSync(path.join(root, 'release-gates.v2.json'), 'utf8'));
+const legacy = String(pkg.scripts['release:check:legacy'] || '');
+const legacyIds = [...new Set([...legacy.matchAll(/npm run ([^\s&]+)/g)].map((match) => match[1]).filter((id) => pkg.scripts[id]))];
+const allowlist = new Map([
+    ['release:check:parallel', 'legacy aggregate superseded by release-gates.v2 DAG'],
+    ['codex-app:fast-ui-preservation', 'Codex App UI real-environment preservation gate'],
+    ['codex-control:keepalive-no-cot-leak', 'long-running remote keepalive/debug gate'],
+    ['zellij:real-session-heartbeat', 'real Zellij heartbeat covered by release:real-check'],
+    ['publish:packlist-performance', 'publish/package performance gate'],
+    ['release:dynamic-performance', 'performance budget gate covered by release:parallel-speed-budget']
+]);
+const gateIds = new Set(manifest.gates.map((gate) => gate.id));
+const missing = legacyIds.filter((id) => !gateIds.has(id) && !allowlist.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 && coverage >= 0.95 && schemaComplete,
+    legacy_gate_count: legacyIds.length,
+    v2_gate_count: manifest.gates.length,
+    coverage,
+    missing,
+    allowed,
+    schema_complete: schemaComplete
+};
+assertGate(report.ok, 'release-gates.v2 must cover legacy hermetic release gates', report);
+emitGate('release:dag-full-coverage', report);
+//# sourceMappingURL=release-dag-full-coverage-check.js.map

package/dist/scripts/release-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-parallel-speed-budget-check.js

@@ -2,24 +2,78 @@
 // @ts-nocheck
 import fs from 'node:fs';
 import path from 'node:path';
-import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
-const manifest = readJson('release-gates.v2.json');
-const independent = manifest.gates.filter((gate) => !gate.deps.length).length;
-const resourceAware = new Set(manifest.gates.flatMap((gate) => gate.resource || []));
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const latest = latestDagSummary();
+assertGate(Boolean(latest), 'release speed budget requires an actual DAG summary', {
+    expected: '.sneakoscope/reports/release-gates/<latest>/summary.json',
+    hint: 'run npm run release:check:dag first'
+});
+const summary = JSON.parse(fs.readFileSync(latest.summaryPath, 'utf8'));
+const slowest = slowestGateResults(latest.dir);
+const warnOnly = process.env.SKS_RELEASE_SPEED_BUDGET_WARN_ONLY === '1';
+const budgetMs = Number(process.env.SKS_RELEASE_SPEED_BUDGET_MS || 20 * 60 * 1000);
+const cachedBudgetMs = 3 * 60 * 1000;
+const cachedRatio = Number(summary.cached || 0) / Math.max(1, Number(summary.completed || summary.selected_gates || 1));
+const cachedRun = cachedRatio >= 0.5;
+const parallelismOk = cachedRun || summary.parallelism_gain >= 2;
+const wallOk = cachedRun ? summary.wall_ms <= cachedBudgetMs : summary.wall_ms <= budgetMs;
+const summaryOk = Number(summary.failed || 0) === 0;
 const report = {
     schema: 'sks.release-speed.v1',
-    ok: true,
-    total_gates: manifest.gates.length,
-    independent_gates: independent,
-    resource_classes: [...resourceAware].sort(),
-    target_full_wall_ms: 20 * 60 * 1000,
-    target_cached_wall_ms: 3 * 60 * 1000,
+    ok: summaryOk && parallelismOk && (wallOk || warnOnly),
+    summary_path: path.relative(root, latest.summaryPath),
+    run_id: summary.run_id,
+    mode: cachedRun ? 'cached' : 'full',
+    total_gates: summary.total_gates,
+    selected_gates: summary.selected_gates,
+    completed: summary.completed,
+    failed: summary.failed,
+    cached: summary.cached,
+    cached_ratio: Number(cachedRatio.toFixed(4)),
+    wall_ms: summary.wall_ms,
+    sum_gate_ms: summary.sum_gate_ms,
+    critical_path_ms: summary.critical_path_ms,
+    slowest_gates: slowest,
+    target_full_wall_ms: budgetMs,
+    target_cached_wall_ms: cachedBudgetMs,
     target_changed_file_wall_ms: 90 * 1000,
-    parallelism_gain: independent > 1 ? 2.1 : 1
+    parallelism_gain: summary.parallelism_gain,
+    warn_only: warnOnly,
+    blockers: [
+        ...(summaryOk ? [] : ['release_summary_has_failures']),
+        ...(parallelismOk ? [] : ['parallelism_gain_below_2']),
+        ...(wallOk || warnOnly ? [] : [cachedRun ? 'cached_release_wall_budget_exceeded' : 'release_wall_budget_exceeded']),
+        ...(Number.isFinite(Number(summary.critical_path_ms)) ? [] : ['critical_path_ms_missing']),
+        ...(Array.isArray(slowest) && slowest.length ? [] : ['slowest_gates_missing'])
+    ]
 };
-assertGate(independent > 1, 'release DAG must contain independent gates for parallel speedup', report);
-assertGate(resourceAware.has('git-worktree') && resourceAware.has('zellij-real'), 'release DAG must model git-worktree and zellij-real resources', report);
+assertGate(report.blockers.length === 0, 'release DAG speed budget must use and pass actual run summary', report);
 fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
 fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'release-parallel-speed-budget.json'), `${JSON.stringify(report, null, 2)}\n`);
 emitGate('release:parallel-speed-budget', report);
+function latestDagSummary() {
+    const dir = path.join(root, '.sneakoscope', 'reports', 'release-gates');
+    if (!fs.existsSync(dir))
+        return null;
+    const rows = fs.readdirSync(dir)
+        .map((name) => path.join(dir, name))
+        .filter((candidate) => fs.existsSync(path.join(candidate, 'summary.json')))
+        .map((candidate) => ({ dir: candidate, summaryPath: path.join(candidate, 'summary.json'), mtime: fs.statSync(path.join(candidate, 'summary.json')).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+    return rows[0] || null;
+}
+function slowestGateResults(reportDir) {
+    const out = [];
+    for (const name of fs.readdirSync(reportDir)) {
+        const file = path.join(reportDir, name, 'result.json');
+        if (!fs.existsSync(file))
+            continue;
+        try {
+            const result = JSON.parse(fs.readFileSync(file, 'utf8'));
+            out.push({ id: result.id || name, duration_ms: Number(result.duration_ms || 0), cached: result.cached === true, ok: result.ok === true });
+        }
+        catch { }
+    }
+    return out.sort((a, b) => b.duration_ms - a.duration_ms).slice(0, 10);
+}
 //# sourceMappingURL=release-parallel-speed-budget-check.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']);
@@ -216,7 +222,7 @@ const releaseMetadata = runNodeScript('dist/scripts/release-metadata-check.js');
 const sideEffectRuntime = runNodeScript('dist/scripts/side-effect-runtime-report-check.js');
 const releaseProvenance = runNodeScript('dist/scripts/release-provenance-check.js');
 const imagegenCore = runNodeScript('dist/scripts/imagegen-capability-check.js');
-const dynamicReleaseMode = process.env.SKS_RELEASE_DYNAMIC === '1';
+const dynamicReleaseMode = process.env.SKS_RELEASE_DYNAMIC === '1' || Boolean(process.env.SKS_REPORT_DIR);
 const runtimeReports = {
     ppt_full_e2e_blackbox: readJson('.sneakoscope/reports/ppt-full-e2e-blackbox.json', null),
     flagship_proof_graph_v3: readJson('.sneakoscope/reports/flagship-proof-graph-v3.json', null),
@@ -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');

package/dist/scripts/zellij-dashboard-pane-check.js

@@ -8,11 +8,13 @@ import fs from 'node:fs';
 const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
 const freshness = ensureDistFresh({ rebuild: false });
 assertGate(freshness.ok === true, 'dist must be fresh for zellij dashboard pane check', freshness);
+const managerSource = fs.readFileSync(path.join(root, 'src', 'core', 'zellij', 'zellij-right-column-manager.ts'), 'utf8');
 const narutoSource = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'naruto-command.ts'), 'utf8');
 const madSource = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'mad-sks-command.ts'), 'utf8');
-assertGate(narutoSource.includes('openZellijDashboardPane') && madSource.includes('openZellijDashboardPane'), 'Naruto and MAD Zellij launches must open dashboard pane', {
-    naruto: narutoSource.includes('openZellijDashboardPane'),
-    mad_sks: madSource.includes('openZellijDashboardPane')
+assertGate(managerSource.includes('openZellijDashboardPane') && narutoSource.includes("dashboard_created: false") && madSource.includes("dashboard_created: false"), 'Dashboard pane must be created by right-column manager after first worker spawn, not at launch', {
+    manager: managerSource.includes('openZellijDashboardPane'),
+    naruto_initial_dashboard_false: narutoSource.includes("dashboard_created: false"),
+    mad_initial_dashboard_false: madSource.includes("dashboard_created: false")
 });
 const dashboard = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-dashboard-pane.js')).href);
 const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
@@ -22,7 +24,7 @@ if (!requireReal) {
     const snapshotMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-dashboard-renderer.js')).href);
     const snapshot = snapshotMod.buildZellijDashboardSnapshot({ mission_id: missionId, active_workers: 4, visible_panes: 2, headless_workers: 2 });
     const text = snapshotMod.renderZellijDashboardText(snapshot);
-    assertGate(text.includes('Mission') && text.includes('Backend counts') && text.includes('Headless workers') && text.includes('GPT final status'), 'dashboard renderer must include required fields', { text });
+    assertGate(text.includes('Mission') && text.includes('Backend counts') && text.includes('headless') && text.includes('GPT final status') && text.includes('Patch / verify'), 'dashboard renderer must include required fields', { text });
     assertGate(fs.readFileSync(path.join(root, 'src', 'scripts', 'zellij-dashboard-watch.ts'), 'utf8').includes('--interval-ms')
         && fs.existsSync(path.join(root, 'dist', 'scripts', 'zellij-dashboard-watch.js')), 'dashboard watch script must support interval updates');
     emitGate('zellij:dashboard-pane', { real_required: false, renderer_fields: true });

package/dist/scripts/zellij-developer-controls-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const zellij = fs.readFileSync(path.join(root, 'src/commands/zellij.ts'), 'utf8');
+const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-developer-controls-check.v1',
+    ok: true,
+    zellij_controls: ['focus-worker', 'worker-logs', 'dashboard', 'close-drained'].every((token) => zellij.includes(token)),
+    naruto_controls: ['dashboard', 'workers'].every((token) => naruto.includes(`'${token}'`)),
+    dashboard_watch: zellij.includes('--watch') && zellij.includes('renderZellijDashboardText'),
+    focus_uses_pane_id: zellij.includes('focus-pane-id'),
+    logs_read_swarm: zellij.includes('agent-native-cli-session-swarm.json')
+};
+report.ok = report.zellij_controls && report.naruto_controls && report.dashboard_watch && report.focus_uses_pane_id && report.logs_read_swarm;
+assertGate(report.ok, 'Zellij/Naruto developer controls missing', report);
+emitGate('zellij:developer-controls', report);
+//# sourceMappingURL=zellij-developer-controls-check.js.map

package/dist/scripts/zellij-dynamic-pane-lifecycle-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
+const manager = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
+const swarm = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-dynamic-pane-lifecycle-check.v1',
+    ok: true,
+    close_success_default: worker.includes("SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0'"),
+    keep_failed_default: worker.includes('SKS_ZELLIJ_KEEP_FAILED_PANE'),
+    close_updates_right_column: worker.includes('closeWorkerInRightColumn'),
+    drained_status_recorded: manager.includes('worker_pane_drained'),
+    overflow_headless_recorded: swarm.includes('recordHeadlessWorkerInRightColumn')
+};
+report.ok = report.close_success_default && report.keep_failed_default && report.close_updates_right_column && report.drained_status_recorded && report.overflow_headless_recorded;
+assertGate(report.ok, 'dynamic pane lifecycle must close/drain workers and record headless overflow', report);
+emitGate('zellij:dynamic-pane-lifecycle', report);
+//# sourceMappingURL=zellij-dynamic-pane-lifecycle-check.js.map

package/dist/scripts/zellij-initial-main-only-blackbox.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const mad = fs.readFileSync(path.join(root, 'src/core/commands/mad-sks-command.ts'), 'utf8');
+const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
+const launcher = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-launcher.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-initial-main-only-blackbox.v1',
+    ok: true,
+    mad_slot_zero: /launchMadZellijUi\([\s\S]*slotCount:\s*0/.test(mad),
+    mad_no_launch_dashboard: !/launch\.dashboard_pane\s*=\s*await openZellijDashboardPane/.test(mad),
+    mad_initial_ui_artifact: mad.includes('zellij-initial-ui.json') && mad.includes("dashboard_created: false"),
+    naruto_slot_zero: /launchZellijLayout\([\s\S]*slotCount:\s*0/.test(naruto),
+    naruto_no_launch_dashboard: !/liveZellij\.dashboard_pane\s*=\s*await openZellijDashboardPane/.test(naruto),
+    naruto_initial_ui_artifact: naruto.includes('zellij-initial-ui.json') && naruto.includes("dashboard_created: false"),
+    launcher_allows_zero: launcher.includes('slotCount: opts.slotCount || 1')
+};
+report.ok = report.mad_slot_zero
+    && report.mad_no_launch_dashboard
+    && report.mad_initial_ui_artifact
+    && report.naruto_slot_zero
+    && report.naruto_no_launch_dashboard
+    && report.naruto_initial_ui_artifact;
+assertGate(report.ok, 'Zellij initial UI must be main-only with no dashboard/worker pane at launch', report);
+emitGate('zellij:initial-main-only-blackbox', report);
+//# sourceMappingURL=zellij-initial-main-only-blackbox.js.map