sneakoscope 2.0.7 → 2.0.9

package/dist/scripts/naruto-zellij-dynamic-right-column-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 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 report = {
+    schema: 'sks.naruto-zellij-dynamic-right-column-check.v1',
+    ok: true,
+    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'")
+};
+report.ok = report.initial_main_only && report.passes_session_name && report.passes_worker_placement && report.passes_visible_cap && report.worker_uses_right_column;
+assertGate(report.ok, 'Naruto must use dynamic right-column worker panes in interactive mode', report);
+emitGate('naruto:zellij-dynamic-right-column', report);
+//# sourceMappingURL=naruto-zellij-dynamic-right-column-check.js.map

package/dist/scripts/product-design-auto-install-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { ensureProductDesignPluginInstalledWithRequest, findProductDesignPluginSummaryFromMarketplaces, productDesignAutoInstallRequested } from '../core/product-design-app-server.js';
 import { PRODUCT_DESIGN_PLUGIN, PRODUCT_DESIGN_REQUIRED_SKILLS } from '../core/product-design-plugin.js';
-import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+import { assertGate, emitGate, readText, releaseGateIds } from './lib/codex-sdk-gate-lib.js';
 function pluginReadResponse({ installed, enabled }) {
     return {
         plugin: {
@@ -92,7 +92,7 @@ const codexAppSource = readText('src/core/codex-app.ts');
 const commandSource = readText('src/commands/codex-app.ts');
 const appServerSource = readText('src/core/product-design-app-server.ts');
 const pkg = JSON.parse(readText('package.json'));
-const releaseCheck = String(pkg.scripts?.['release:check'] || '');
+const releaseGates = releaseGateIds();
 for (const token of [
     'ensureProductDesignPluginInstalled',
     'PRODUCT_DESIGN_AUTO_INSTALL_ENV',
@@ -109,7 +109,7 @@ for (const token of [
     assertGate(commandSource.includes(token), `sks codex-app command missing Product Design token: ${token}`);
 }
 assertGate(Boolean(pkg.scripts?.['codex:product-design-auto-install']), 'package script missing codex:product-design-auto-install');
-assertGate(releaseCheck.includes('codex:product-design-auto-install'), 'release:check must include Product Design auto-install gate');
+assertGate(releaseGates.has('codex:product-design-auto-install'), 'release gate DAG must include Product Design auto-install gate');
 emitGate('codex:product-design-auto-install', {
     install_calls: installCalls.map((call) => call.method),
     dry_calls: dryCalls.map((call) => call.method),

package/dist/scripts/product-design-plugin-routing-check.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import { PRODUCT_DESIGN_PIPELINE_STAGES, PRODUCT_DESIGN_PLUGIN, PRODUCT_DESIGN_REQUIRED_SKILLS, normalizeProductDesignPluginEvidence, productDesignPluginVisibilityFromCodexPluginList } from '../core/product-design-plugin.js';
-import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
+import { assertGate, emitGate, readText, releaseGateIds } from './lib/codex-sdk-gate-lib.js';
 const routesSource = readText('src/core/routes.ts');
 const productDesignSource = readText('src/core/product-design-plugin.ts');
 const runtimeSource = readText('src/core/pipeline-internals/runtime-core.ts');
@@ -9,7 +9,7 @@ const pptSource = readText('src/core/ppt.ts');
 const codexAppSource = readText('src/core/codex-app.ts');
 const initSource = readText('src/core/init.ts');
 const pkg = JSON.parse(readText('package.json'));
-const releaseCheck = String(pkg.scripts?.['release:check'] || '');
+const releaseGates = releaseGateIds();
 assertGate(PRODUCT_DESIGN_PLUGIN.id === 'product-design@openai-curated-remote', 'Product Design plugin id must use the remote marketplace');
 assertGate(PRODUCT_DESIGN_PLUGIN.marketplace === 'openai-curated-remote', 'Product Design marketplace must be openai-curated-remote');
 assertGate(PRODUCT_DESIGN_PLUGIN.marketplace_kind === 'vertical', 'Product Design marketplace kind must be vertical');
@@ -90,7 +90,7 @@ for (const token of [
     assertGate(codexAppSource.includes(token), `codex-app.ts missing Product Design readiness token: ${token}`);
 }
 assertGate(Boolean(pkg.scripts?.['codex:product-design-plugin-routing']), 'package script missing codex:product-design-plugin-routing');
-assertGate(releaseCheck.includes('codex:product-design-plugin-routing'), 'release:check must include Product Design routing gate');
+assertGate(releaseGates.has('codex:product-design-plugin-routing'), 'release gate DAG must include Product Design routing gate');
 emitGate('codex:product-design-plugin-routing', {
     plugin_id: PRODUCT_DESIGN_PLUGIN.id,
     remote_plugin_id: PRODUCT_DESIGN_PLUGIN.remote_plugin_id,

package/dist/scripts/release-cache-glob-hashing-check.js

@@ -0,0 +1,42 @@
+#!/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 { expandGlob, releaseGateCacheKey } from '../core/release/release-gate-cache-v2.js';
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-cache-glob-'));
+fs.mkdirSync(path.join(tmp, 'src/core/release'), { recursive: true });
+fs.writeFileSync(path.join(tmp, 'package.json'), JSON.stringify({ version: '0.0.0' }));
+fs.writeFileSync(path.join(tmp, 'release-gates.v2.json'), JSON.stringify({ schema: 'sks.release-gates.v2', gates: [] }));
+fs.writeFileSync(path.join(tmp, 'src/core/release/a.ts'), 'a');
+const gate = {
+    id: 'release:cache-glob-hashing-fixture',
+    command: 'node fixture',
+    deps: [],
+    resource: ['cpu-light'],
+    side_effect: 'hermetic',
+    timeout_ms: 1000,
+    cache: { enabled: true, inputs: ['src/core/release/**'] },
+    isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
+    preset: ['release']
+};
+const before = releaseGateCacheKey(tmp, gate);
+const expandedBefore = expandGlob(tmp, 'src/core/release/**');
+fs.writeFileSync(path.join(tmp, 'src/core/release/b.ts'), 'b');
+const afterAdd = releaseGateCacheKey(tmp, gate);
+fs.writeFileSync(path.join(tmp, 'src/core/release/a.ts'), 'changed');
+const afterChange = releaseGateCacheKey(tmp, gate);
+const expandedAfter = expandGlob(tmp, 'src/core/release/**');
+const report = {
+    schema: 'sks.release-cache-glob-hashing-check.v1',
+    ok: expandedBefore.length === 1 && expandedAfter.length === 2 && before !== afterAdd && afterAdd !== afterChange,
+    expanded_before: expandedBefore.map((file) => path.basename(file)),
+    expanded_after: expandedAfter.map((file) => path.basename(file)),
+    before,
+    after_add: afterAdd,
+    after_change: afterChange
+};
+assertGate(report.ok, 'release cache key must hash recursive glob file paths and contents', report);
+emitGate('release:cache-glob-hashing', report);
+//# sourceMappingURL=release-cache-glob-hashing-check.js.map

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-gate-dag-runner-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, 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');
+assertGate(pkg.scripts['release:check'].includes('release-gate-dag-runner.js'), 'release:check must execute DAG runner', pkg.scripts['release:check']);
+assertGate(!/&&\s*npm run\s+\w/.test(pkg.scripts['release:check'].replace('npm run build --silent &&', '')), 'release:check must not be a giant npm-run chain', pkg.scripts['release:check']);
+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);
+assertGate(runner.includes('Promise.race') && scheduler.includes('pickLaunchableReleaseGates'), 'DAG runner must schedule independent gates concurrently');
+assertGate(runner.includes('readReleaseGateCacheHit') && cache.includes('RELEASE_GATE_CACHE_V2_SCHEMA'), 'DAG runner must use release gate cache v2 module');
+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');
+emitGate('release:dag-runner', { gates: manifest.gates.length, default_script: pkg.scripts['release:check'] });
+//# sourceMappingURL=release-gate-dag-runner-check.js.map

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

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runReleaseGateDag } from '../core/release/release-gate-dag.js';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const args = process.argv.slice(2);
+const presetIndex = args.indexOf('--preset');
+const preset = presetIndex >= 0 ? args[presetIndex + 1] : 'release';
+const result = await runReleaseGateDag({
+    root,
+    ...(preset === undefined ? {} : { preset }),
+    explain: args.includes('--explain'),
+    noCache: args.includes('--no-cache'),
+    failFast: args.includes('--fail-fast')
+});
+console.log(`SKS Release DAG
+  gates: ${result.total_gates} total, ${result.selected_gates} selected, ${result.cached} cached
+  concurrency: ${result.budget_summary}
+  peak_running: ${result.peak_running}
+  completed: ${result.completed} pass, ${result.failed} fail
+  wall: ${(result.wall_ms / 1000).toFixed(1)}s
+  parallelism_gain: ${result.parallelism_gain}
+  cpu_time_saved: ${(result.cpu_time_saved_ms / 1000).toFixed(1)}s
+  critical_path: ${(result.critical_path_ms / 1000).toFixed(1)}s
+  report: ${result.report_dir}`);
+if (!result.ok) {
+    for (const failure of result.failures) {
+        console.error(`[fail] ${failure.id} exit=${failure.exit_code}\n${failure.stderr_tail}`);
+    }
+    process.exit(1);
+}
+//# sourceMappingURL=release-gate-dag-runner.js.map

package/dist/scripts/release-gate-worker.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+const command = process.argv.slice(2).join(' ');
+if (!command) {
+    console.error('usage: release-gate-worker <command>');
+    process.exit(2);
+}
+const result = spawnSync(command, { shell: true, stdio: 'inherit', env: process.env });
+process.exit(result.status ?? 1);
+//# sourceMappingURL=release-gate-worker.js.map

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

@@ -10,6 +10,11 @@ const distManifestPath = path.join(root, 'dist/build-manifest.json');
 const distManifest = fs.existsSync(distManifestPath) ? JSON.parse(fs.readFileSync(distManifestPath, 'utf8')) : null;
 const parallelCheckPath = path.join(root, 'src/scripts/release-parallel-check.ts');
 const parallelCheckSource = fs.existsSync(parallelCheckPath) ? fs.readFileSync(parallelCheckPath, 'utf8') : '';
+const releaseCheckScriptSource = [
+    String(pkg.scripts?.['release:check'] || ''),
+    String(pkg.scripts?.['release:check:legacy'] || ''),
+    parallelCheckSource
+].join('\n');
 const releaseRealCheckPath = path.join(root, 'src/scripts/release-real-check.ts');
 const releaseRealCheckSource = fs.existsSync(releaseRealCheckPath) ? fs.readFileSync(releaseRealCheckPath, 'utf8') : '';
 const requiredDocs = [
@@ -304,13 +309,14 @@ assertGate(distManifest?.version === RELEASE_VERSION, `dist/build-manifest versi
 assertGate(distManifest?.package_version === RELEASE_VERSION, `dist/build-manifest package_version must be ${RELEASE_VERSION}`, { package_version: distManifest?.package_version || null });
 assertGate(typeof distManifest?.source_digest === 'string' && distManifest.source_digest.length >= 32, 'dist/build-manifest must include source_digest', { source_digest: distManifest?.source_digest || null });
 assertGate(pkg.scripts?.['release:metadata']?.includes('dist/scripts/release-metadata-check.js'), 'release:metadata must point to the generic release metadata check');
-assertGate(String(pkg.scripts?.['release:check'] || '').startsWith('npm run release:check:parallel'), 'release:check must use release:check:parallel');
+const releaseCheckScript = String(pkg.scripts?.['release:check'] || '');
+assertGate(releaseCheckScript.startsWith('npm run release:check:parallel') || releaseCheckScript.includes('release-gate-dag-runner.js --preset release'), 'release:check must use release:check:parallel or the release gate DAG runner');
 for (const script of requiredScripts)
     assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
 for (const script of requiredRealScripts)
     assertGate(Boolean(pkg.scripts?.[script]), `missing package real script: ${script}`);
 for (const script of requiredScripts.filter((name) => name !== 'release:check:parallel')) {
-    assertGate(parallelCheckSource.includes(`npm run ${script}`) || String(pkg.scripts?.['release:check'] || '').includes(`npm run ${script}`) || ['release:metadata', 'release:readiness'].includes(script), `release:check DAG missing ${script}`);
+    assertGate(releaseCheckScriptSource.includes(`npm run ${script}`) || ['release:metadata', 'release:readiness'].includes(script), `release check coverage missing ${script}`);
 }
 for (const script of requiredRealScripts) {
     assertGate(String(pkg.scripts?.['release:real-check'] || '').includes(`npm run ${script}`) || releaseRealCheckSource.includes(`'${script}'`) || releaseRealCheckSource.includes(`"${script}"`), `release:real-check missing ${script}`);

package/dist/scripts/release-parallel-speed-budget-check.js

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

@@ -216,7 +216,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),

package/dist/scripts/release-stability-report-check.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// @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 currentRunDir = process.env.SKS_REPORT_DIR ? path.dirname(process.env.SKS_REPORT_DIR) : null;
+const latestReleaseRun = currentRunDir || latestDir(path.join(root, '.sneakoscope', 'reports', 'release-gates'));
+const latestSummary = currentRunDir ? summarizeCurrentRun(currentRunDir) : latestReleaseRun ? readJsonIfExists(path.join(latestReleaseRun, 'summary.json')) : null;
+const zellijReportPath = path.join(root, '.sneakoscope', 'reports', 'zellij-worker-pane-real-ui-blackbox.json');
+const zellij = fs.existsSync(zellijReportPath) ? JSON.parse(fs.readFileSync(zellijReportPath, 'utf8')) : null;
+const requiredGateIds = [
+    'release:dag-runner',
+    'release:parallel-speed-budget',
+    'git:worktree-manifest-append',
+    'git:worktree-dirty-main-detection',
+    'git:worktree-untracked-diff',
+    'git:worktree-diff-envelope',
+    'git:worktree-integration-primary',
+    'git:worktree-dirty-lock',
+    'naruto:worktree-coding:blackbox',
+    'release:version-truth'
+];
+const manifestIds = new Set(manifest.gates.map((gate) => gate.id));
+const missing = requiredGateIds.filter((id) => !manifestIds.has(id));
+const score = computeScore({ missing, latestSummary, zellij });
+const report = {
+    schema: 'sks.release-stability-report.v1',
+    ok: score >= 9.5 && missing.length === 0 && latestSummary?.ok === true && zellij?.ok === true,
+    target_score: 9.5,
+    score,
+    manifest_gate_count: manifest.gates.length,
+    latest_release_summary: latestSummary ? path.relative(root, path.join(latestReleaseRun, 'summary.json')) : null,
+    release_check_ok: latestSummary?.ok === true,
+    release_check_passed: latestSummary?.completed || 0,
+    release_check_failed: latestSummary?.failed || 0,
+    zellij_real_worker_panes_ok: zellij?.ok === true,
+    zellij_real_worker_panes: zellij?.real_pane_ids || 0,
+    missing_required_gates: missing,
+    blockers: []
+};
+if (!report.ok) {
+    report.blockers = [
+        ...(score >= 9.5 ? [] : ['stability_score_below_target']),
+        ...(missing.length ? ['required_release_gate_missing'] : []),
+        ...(latestSummary?.ok === true ? [] : ['latest_release_check_not_green']),
+        ...(zellij?.ok === true ? [] : ['zellij_real_worker_panes_not_green'])
+    ];
+}
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'release-stability-report.json'), `${JSON.stringify(report, null, 2)}\n`);
+assertGate(report.ok, 'release stability report must meet 9.5+ target', report);
+emitGate('release:stability-report', report);
+function computeScore({ missing, latestSummary, zellij }) {
+    let score = 10;
+    score -= missing.length * 0.25;
+    if (latestSummary?.ok !== true)
+        score -= 1.5;
+    if ((latestSummary?.failed || 0) > 0)
+        score -= 1;
+    if (zellij?.ok !== true)
+        score -= 1;
+    return Number(Math.max(0, score).toFixed(2));
+}
+function latestDir(dir) {
+    if (!fs.existsSync(dir))
+        return null;
+    const dirs = fs.readdirSync(dir)
+        .map((name) => path.join(dir, name))
+        .filter((candidate) => fs.statSync(candidate).isDirectory())
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return dirs[0] || null;
+}
+function summarizeCurrentRun(runDir) {
+    const results = [];
+    for (const entry of fs.readdirSync(runDir)) {
+        const result = readJsonIfExists(path.join(runDir, entry, 'result.json'));
+        if (result && result.id !== 'release:stability-report')
+            results.push(result);
+    }
+    if (!results.length)
+        return null;
+    const failed = results.filter((result) => result.ok !== true);
+    return {
+        schema: 'sks.release-gate-current-run-summary.v1',
+        ok: failed.length === 0,
+        completed: results.filter((result) => result.ok === true).length,
+        failed: failed.length
+    };
+}
+function readJsonIfExists(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=release-stability-report-check.js.map

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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
+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(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);
+const missionId = `M-zellij-dashboard-${Date.now()}`;
+const sessionName = `sks-dashboard-${process.pid}`;
+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') && 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 });
+    process.exit(0);
+}
+await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+try {
+    const record = await dashboard.openZellijDashboardPane({
+        root,
+        missionId,
+        sessionName,
+        cwd: root,
+        snapshot: {
+            mode: 'naruto',
+            backend_counts: { 'codex-sdk': 2, 'local-llm': 1 },
+            placement_counts: { 'zellij-pane': 2, headless: 1 },
+            active_workers: 3,
+            visible_panes: 2,
+            headless_workers: 1,
+            queue_depth: 7,
+            worktrees: { active: 2, completed: 1, retained: 0 },
+            local_llm: { tps: 12, queue: 1 },
+            gpt_final_status: 'pending',
+            gate_progress: 'release: 8/12'
+        }
+    });
+    const ok = record.ok === true && record.pane_kind === 'dashboard' && record.worker_pane === false && record.pane_id
+        && String(record.command || '').includes('zellij-dashboard-watch.js')
+        && String(record.command || '').includes('--interval-ms 1000');
+    assertGate(ok, 'real Zellij dashboard pane must open and not count as worker pane', record);
+    emitGate('zellij:dashboard-pane', {
+        real_required: true,
+        pane_id: record.pane_id,
+        pane_kind: record.pane_kind,
+        worker_pane: record.worker_pane,
+        mission_id: missionId,
+        session_name: sessionName
+    });
+}
+finally {
+    await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+}
+//# sourceMappingURL=zellij-dashboard-pane-check.js.map

package/dist/scripts/zellij-dashboard-watch.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildZellijDashboardSnapshot, renderZellijDashboardText } from '../core/zellij/zellij-dashboard-renderer.js';
+const args = process.argv.slice(2);
+const snapshotPath = path.resolve(String(readOption(args, '--snapshot', '') || ''));
+const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000')) || 1000);
+const once = args.includes('--once');
+if (!snapshotPath) {
+    console.error('Usage: zellij-dashboard-watch --snapshot <path> [--interval-ms 1000] [--once]');
+    process.exit(2);
+}
+render();
+if (!once)
+    setInterval(render, intervalMs);
+function render() {
+    const snapshot = readSnapshot(snapshotPath);
+    const text = renderZellijDashboardText(snapshot);
+    process.stdout.write(`\x1b[2J\x1b[H${text}\nUpdated: ${new Date().toISOString()}\n`);
+}
+function readSnapshot(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return buildZellijDashboardSnapshot(parsed);
+    }
+    catch (err) {
+        return buildZellijDashboardSnapshot({
+            mission_id: path.basename(path.dirname(file)) || 'unknown',
+            mode: 'dashboard-watch',
+            latest_blockers: [`snapshot_read_failed:${err?.code || err?.message || String(err)}`]
+        });
+    }
+}
+function readOption(list, name, fallback) {
+    const index = list.indexOf(name);
+    if (index >= 0 && list[index + 1])
+        return list[index + 1];
+    const prefixed = list.find((arg) => arg.startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=zellij-dashboard-watch.js.map

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