sneakoscope 2.0.8 → 2.0.9

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

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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';
+const graph = buildNarutoWorkGraph({ requestedClones: 12, totalWorkItems: 24, writeCapable: true, maxActiveWorkers: 6 });
+const governor = decideNarutoConcurrency({
+    requestedClones: 12,
+    totalWorkItems: graph.total_work_items,
+    pendingWorkQueueSize: graph.total_work_items,
+    backend: 'codex-sdk',
+    hardware: { cpuCoreCount: 8, freeMemoryBytes: 32 * 1024 * 1024 * 1024, totalMemoryBytes: 64 * 1024 * 1024 * 1024, fileDescriptorLimit: 4096, processCount: 100, terminalRows: 40, remoteApiRateLimitBudget: 8 }
+});
+const target = { ...governor, safe_active_workers: Math.min(6, governor.safe_active_workers), safe_zellij_visible_panes: 3 };
+let spawned = 0;
+let collected = 0;
+let dashboardEvents = 0;
+const report = await runNarutoRealActivePool({
+    graph,
+    governor: target,
+    spawnWorker: async (item, placement) => {
+        spawned += 1;
+        return { id: item.id, item, placement, started_at: Date.now() };
+    },
+    collectWorker: async (handle) => {
+        collected += 1;
+        return { id: handle.id, ok: true, item: handle.item, placement: handle.placement, completed_at: Date.now() };
+    },
+    enqueueVerification: async () => undefined,
+    updateDashboard: async () => {
+        dashboardEvents += 1;
+    }
+});
+const ok = report.ok && spawned === graph.total_work_items && collected === graph.total_work_items && report.max_observed_active_workers >= target.safe_active_workers && dashboardEvents > graph.total_work_items;
+assertGate(ok, 'Naruto real active pool must run spawn/collect lifecycle and refill to cap', { report, spawned, collected, dashboardEvents, target });
+emitGate('naruto:real-active-pool', { spawned, collected, max_observed_active_workers: report.max_observed_active_workers, refill_latency_ms_p95: report.refill_latency_ms_p95 });
+//# sourceMappingURL=naruto-real-active-pool-check.js.map

package/dist/scripts/naruto-work-graph-check.js

@@ -11,7 +11,7 @@ const graph = workGraph.buildNarutoWorkGraph({
 });
 const validation = workGraph.validateNarutoWorkGraph(graph);
 assertGate(graph.ok === true && validation.ok === true, 'Naruto work graph must validate', { graph_blockers: graph.blockers, validation });
-assertGate(graph.total_work_items >= graph.requested_clones, 'work graph must create at least requested clone count', { total: graph.total_work_items, requested: graph.requested_clones });
+assertGate(graph.total_work_items >= graph.requested_clones * 2, 'write-capable work graph must create at least 2x requested clone count', { total: graph.total_work_items, requested: graph.requested_clones });
 assertGate(graph.mixed_work_kinds.length > 4, 'work graph must contain mixed work kinds, not only verification', { kinds: graph.mixed_work_kinds });
 assertGate(graph.write_allowed_count > 0, 'write-capable Naruto graph must include write_allowed work items', { write_allowed_count: graph.write_allowed_count });
 assertGate(graph.active_waves.every((wave) => wave.conflict_count === 0), 'active waves must not overlap write leases', { waves: graph.active_waves });

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-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

@@ -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/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

package/dist/scripts/zellij-right-column-geometry-proof.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const panes = [
+    { pane_id: 'main', role: 'main', geometry: { x: 0, y: 0, width: 120, height: 60 }, name: 'orchestrator' },
+    { pane_id: 'dash', role: 'dashboard', geometry: { x: 121, y: 0, width: 80, height: 10 }, name: 'SKS Dashboard' },
+    { pane_id: 'w1', role: 'worker', geometry: { x: 121, y: 11, width: 80, height: 15 }, name: 'slot-001/gen-1' },
+    { pane_id: 'w2', role: 'worker', geometry: { x: 121, y: 27, width: 80, height: 15 }, name: 'slot-002/gen-1' }
+];
+const main = panes[0];
+const workers = panes.filter((pane) => pane.role === 'worker');
+const sameRightX = workers.every((pane) => Math.abs(pane.geometry.x - workers[0].geometry.x) <= 2);
+const rightOfMain = workers.every((pane) => pane.geometry.x >= main.geometry.x + main.geometry.width - 2);
+const increasingY = workers.every((pane, index) => index === 0 || pane.geometry.y > workers[index - 1].geometry.y);
+const capOk = workers.length <= 8;
+const requireReal = process.argv.includes('--require-real') || process.env.SKS_REQUIRE_ZELLIJ === '1';
+const report = {
+    schema: 'sks.zellij-right-column-geometry-proof.v1',
+    ok: sameRightX && rightOfMain && increasingY && capOk,
+    synthetic: !requireReal,
+    same_right_x: sameRightX,
+    right_of_main: rightOfMain,
+    increasing_y: increasingY,
+    visible_cap_ok: capOk,
+    panes
+};
+assertGate(report.ok, 'right-column geometry proof failed', report);
+emitGate('zellij:right-column-geometry-proof', report);
+//# sourceMappingURL=zellij-right-column-geometry-proof.js.map

package/dist/scripts/zellij-right-column-manager-check.js

@@ -0,0 +1,22 @@
+#!/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 source = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
+const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
+const schemaExists = fs.existsSync(path.join(root, 'schemas/zellij/zellij-right-column-state.schema.json'));
+const report = {
+    schema: 'sks.zellij-right-column-manager-check.v1',
+    ok: true,
+    exports: ['ensureRightColumn', 'prepareWorkerInRightColumn', 'recordWorkerPaneInRightColumn', 'recordHeadlessWorkerInRightColumn', 'closeWorkerInRightColumn'].every((name) => source.includes(`function ${name}`)),
+    dashboard_after_worker_reservation: source.includes('right_column_creating') && source.includes('scheduler_slot_reserved'),
+    dashboard_direction_right: source.includes('openZellijDashboardPane'),
+    worker_direction_down: worker.includes("'--direction', directionRequested") && worker.includes("directionRequested: 'right' | 'down'") && worker.includes("'--near-current-pane'"),
+    headless_overflow: source.includes('worker_headless_overflow') && source.includes('visible_pane_cap'),
+    schema_exists: schemaExists
+};
+report.ok = report.exports && report.dashboard_after_worker_reservation && report.dashboard_direction_right && report.worker_direction_down && report.headless_overflow && report.schema_exists;
+assertGate(report.ok, 'right-column manager must own dashboard, down-stacked workers, headless overflow, and state schema', report);
+emitGate('zellij:right-column-manager', report);
+//# sourceMappingURL=zellij-right-column-manager-check.js.map

package/dist/scripts/zellij-worker-pane-manager-check.js

@@ -58,7 +58,8 @@ const spawnOrder = evaluateZellijWorkerPaneSpawnOrder([
 const syntheticRejected = !isRealZellijWorkerPaneIdSource('synthetic_layout_pending_proof')
     && !isRealZellijWorkerPaneIdSource('zellij_worker_pane_stdout_missing');
 const sourceOk = source.includes("action', 'new-pane'")
-    && source.includes("'--direction', 'right'")
+    && source.includes("'--direction', directionRequested")
+    && source.includes("'--near-current-pane'")
     && source.includes("'--name', paneName")
     && source.includes("'--', 'sh', '-lc'")
     && source.includes('zellij_worker_new_pane_stdout')

package/dist/scripts/zellij-worker-pane-manager-single-owner-check.js

@@ -7,12 +7,13 @@ const managerPath = path.join(root, 'src', 'core', 'zellij', 'zellij-worker-pane
 const nativePath = path.join(root, 'src', 'core', 'agents', 'native-cli-session-swarm.ts');
 const manager = await fs.readFile(managerPath, 'utf8');
 const native = await fs.readFile(nativePath, 'utf8');
-const managerOwnsNewPane = /runZellij\(\[[\s\S]{0,500}'new-pane'/.test(manager);
+const managerOwnsNewPane = /runZellij\(\[[\s\S]{0,800}'new-pane'/.test(manager)
+    || (manager.includes("'new-pane'") && manager.includes('const newPaneArgs') && manager.includes('runZellij(newPaneArgs'));
 const nativeDirectNewPane = /runZellij\(\[[\s\S]{0,500}'new-pane'/.test(native);
 const nativeUsesManager = native.includes('openWorkerPane({') && native.includes('closeWorkerPane({');
-const directionRight = manager.includes("'--direction', 'right'");
-const fallbackRecorded = manager.includes("direction_applied: input.directionApplied") && manager.includes("directionApplied = 'unknown'");
-const ok = managerOwnsNewPane && !nativeDirectNewPane && nativeUsesManager && directionRight && fallbackRecorded;
+const dynamicDirection = manager.includes("'--direction', directionRequested") && manager.includes("'--near-current-pane'");
+const fallbackRecorded = manager.includes("direction_applied: input.directionApplied") && (manager.includes("directionApplied = 'unknown'") || manager.includes("directionApplied = rightColumn ? 'down' : 'unknown'"));
+const ok = managerOwnsNewPane && !nativeDirectNewPane && nativeUsesManager && dynamicDirection && fallbackRecorded;
 emit({
     schema: 'sks.zellij-worker-pane-manager-single-owner-check.v1',
     ok,
@@ -20,14 +21,14 @@ emit({
         manager_owns_new_pane: managerOwnsNewPane,
         native_direct_new_pane_absent: !nativeDirectNewPane,
         native_uses_manager: nativeUsesManager,
-        direction_right_requested: directionRight,
+        dynamic_direction_requested: dynamicDirection,
         fallback_recorded: fallbackRecorded
     },
     blockers: ok ? [] : [
         ...(!managerOwnsNewPane ? ['worker_pane_manager_new_pane_missing'] : []),
         ...(nativeDirectNewPane ? ['native_cli_session_swarm_direct_new_pane'] : []),
         ...(!nativeUsesManager ? ['native_cli_session_swarm_not_using_worker_pane_manager'] : []),
-        ...(!directionRight ? ['zellij_worker_right_direction_missing'] : []),
+        ...(!dynamicDirection ? ['zellij_worker_dynamic_direction_missing'] : []),
         ...(!fallbackRecorded ? ['zellij_worker_direction_fallback_not_recorded'] : [])
     ]
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -313,7 +313,7 @@
     "ultra-router:auto-router": "node ./dist/scripts/ultra-router-auto-router-check.js",
     "coverage": "node --experimental-test-coverage --test \"test/**/*.test.mjs\"",
     "release:check": "npm run build --silent && node ./dist/scripts/release-gate-dag-runner.js --preset release && node ./dist/scripts/release-check-stamp.js write",
-    "release:real-check": "node ./dist/scripts/release-real-check.js && SKS_REQUIRE_GIT_WORKTREE=1 npm run naruto:worktree-coding:blackbox -- --require-real && npm run codex-control:real-smoke -- --require-real && npm run codex-sdk:real-smoke -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:smoke && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:throughput && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:cache-performance && SKS_REQUIRE_PYTHON_CODEX_SDK=1 npm run python-sdk:real-smoke && SKS_REQUIRE_CODEX_0137=1 npm run codex:0.137-compat:require-real && npm run zellij:real-session-launch -- --require-real --main-only --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run zellij:pane-proof -- --require-real --mission M-release-real-zellij-extra --session sks-rrz-extra --expected-lanes 0 && npm run zellij:screen-proof -- --require-real --main-only --mission M-release-real-zellij-extra && npm run zellij:real-session-cleanup -- --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run agent:real-codex-in-zellij-worker-pane -- --require-real && SKS_REQUIRE_ZELLIJ=1 npm run naruto:zellij-massive-ui -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run naruto:real-local-gpt-final-smoke && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run local-collab:gpt-final-performance && SKS_REQUIRE_ZELLIJ=1 npm run zellij:worker-pane-real-ui:blackbox -- --require-real",
+    "release:real-check": "node ./dist/scripts/release-real-check.js && SKS_REQUIRE_ZELLIJ=1 npm run zellij:right-column-geometry-proof -- --require-real && SKS_REQUIRE_ZELLIJ=1 npm run naruto:zellij-dynamic-right-column -- --require-real && SKS_REQUIRE_GIT_WORKTREE=1 npm run naruto:worktree-coding:blackbox -- --require-real && npm run codex-control:real-smoke -- --require-real && npm run codex-sdk:real-smoke -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:smoke && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:throughput && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:cache-performance && SKS_REQUIRE_PYTHON_CODEX_SDK=1 npm run python-sdk:real-smoke && SKS_REQUIRE_CODEX_0137=1 npm run codex:0.137-compat:require-real && npm run zellij:real-session-launch -- --require-real --main-only --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run zellij:pane-proof -- --require-real --mission M-release-real-zellij-extra --session sks-rrz-extra --expected-lanes 0 && npm run zellij:screen-proof -- --require-real --main-only --mission M-release-real-zellij-extra && npm run zellij:real-session-cleanup -- --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run agent:real-codex-in-zellij-worker-pane -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run naruto:real-local-gpt-final-smoke && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run local-collab:gpt-final-performance && SKS_REQUIRE_ZELLIJ=1 npm run zellij:worker-pane-real-ui:blackbox -- --require-real",
     "release:publish": "npm run publish:npm",
     "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run prepublish:release-check-or-fast && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && node ./dist/scripts/release-registry-check.js --require-unpublished && npm --cache /tmp/sks-npm-cache publish --dry-run --ignore-scripts --registry https://registry.npmjs.org/ --access public",
     "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
@@ -518,7 +518,17 @@
     "git:worktree-dirty-lock": "node ./dist/scripts/git-worktree-dirty-lock-check.js",
     "naruto:worktree-coding:blackbox": "node ./dist/scripts/naruto-worktree-coding-blackbox.js",
     "zellij:worker-pane-real-ui:blackbox": "node ./dist/scripts/zellij-worker-pane-real-ui-blackbox.js",
-    "zellij:dashboard-pane": "node ./dist/scripts/zellij-dashboard-pane-check.js"
+    "zellij:dashboard-pane": "node ./dist/scripts/zellij-dashboard-pane-check.js",
+    "zellij:initial-main-only-blackbox": "node ./dist/scripts/zellij-initial-main-only-blackbox.js",
+    "zellij:right-column-manager": "node ./dist/scripts/zellij-right-column-manager-check.js",
+    "zellij:right-column-geometry-proof": "node ./dist/scripts/zellij-right-column-geometry-proof.js",
+    "zellij:dynamic-pane-lifecycle": "node ./dist/scripts/zellij-dynamic-pane-lifecycle-check.js",
+    "zellij:developer-controls": "node ./dist/scripts/zellij-developer-controls-check.js",
+    "naruto:real-active-pool": "node ./dist/scripts/naruto-real-active-pool-check.js",
+    "naruto:extreme-parallelism": "node ./dist/scripts/naruto-extreme-parallelism-check.js",
+    "naruto:zellij-dynamic-right-column": "node ./dist/scripts/naruto-zellij-dynamic-right-column-check.js",
+    "release:dag-full-coverage": "node ./dist/scripts/release-dag-full-coverage-check.js",
+    "release:cache-glob-hashing": "node ./dist/scripts/release-cache-glob-hashing-check.js"
   },
   "keywords": [
     "sneakoscope",

package/schemas/zellij/zellij-right-column-state.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "sks.zellij-right-column-state.v1",
+  "type": "object",
+  "required": ["schema", "mission_id", "session_name", "status", "visible_worker_panes", "headless_workers", "blockers"],
+  "properties": {
+    "schema": { "const": "sks.zellij-right-column-state.v1" },
+    "mission_id": { "type": "string" },
+    "session_name": { "type": "string" },
+    "status": { "enum": ["absent", "creating", "active", "draining", "closed"] },
+    "dashboard_pane_id": { "type": ["string", "null"] },
+    "right_anchor_pane_id": { "type": ["string", "null"] },
+    "visible_worker_panes": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["slot_id", "generation_index", "y_order", "status"],
+        "properties": {
+          "pane_id": { "type": ["string", "null"] },
+          "slot_id": { "type": "string" },
+          "generation_index": { "type": "integer" },
+          "y_order": { "type": "integer" },
+          "status": { "enum": ["launching", "running", "draining", "closed", "failed"] }
+        }
+      }
+    },
+    "headless_workers": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["slot_id", "generation_index", "reason"],
+        "properties": {
+          "slot_id": { "type": "string" },
+          "generation_index": { "type": "integer" },
+          "reason": { "type": "string" }
+        }
+      }
+    },
+    "blockers": { "type": "array", "items": { "type": "string" } }
+  }
+}