sneakoscope 2.0.7 → 2.0.9

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/dist/scripts/zellij-worker-pane-real-ui-blackbox.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { spawn } from 'node:child_process';
+import { assertGate, emitGate, readText, root } from './sks-1-18-gate-lib.js';
+import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
+const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
+const manager = readText('src/core/zellij/zellij-worker-pane-manager.ts');
+const schema = readText('src/core/agents/agent-schema.ts');
+const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
+assertGate(manager.includes('action') && manager.includes('new-pane'), 'worker pane manager must call zellij action new-pane');
+assertGate(manager.includes('list-panes') && manager.includes('dump-screen'), 'worker pane proof must reconcile real list-panes/dump-screen evidence');
+assertGate(schema.includes('AgentWorkerPlacement') && swarm.includes("placement === 'zellij-pane'"), 'worker placement must control Zellij panes independently of backend');
+if (!requireReal) {
+    emitGate('zellij:worker-pane-real-ui:blackbox', { real_required: false, proof_mode: 'source_contract' });
+    process.exit(0);
+}
+const { spawnSync } = await import('node:child_process');
+const available = spawnSync('zellij', ['--version'], { encoding: 'utf8' });
+assertGate(available.status === 0, 'SKS_REQUIRE_ZELLIJ=1 requires zellij binary', { stderr: available.stderr });
+const freshness = ensureDistFresh({ rebuild: false });
+assertGate(freshness.ok === true, 'dist must be fresh before real Zellij worker-pane blackbox', freshness);
+const zellij = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
+const workerPane = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-worker-pane-manager.js')).href);
+const missionId = `M-zellij-worker-pane-real-${Date.now()}`;
+const sessionName = `sks-worker-pane-real-${process.pid}`;
+const ledgerRoot = path.join(root, '.sneakoscope', 'missions', missionId, 'agents');
+fs.rmSync(path.join(root, '.sneakoscope', 'missions', missionId), { recursive: true, force: true });
+fs.mkdirSync(ledgerRoot, { recursive: true });
+await zellij.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+const attachedClient = startAttachedZellijClient(sessionName);
+await sleep(1500);
+await zellij.runZellij(['--session', sessionName, 'action', 'send-keys', 'Esc'], { cwd: root, timeoutMs: 5000, optional: true });
+await sleep(250);
+const before = await zellij.runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: true });
+const beforeCount = parsePaneRows(before.stdout_tail).length;
+const beforeTerminalCount = parsePaneRows(before.stdout_tail).filter((row) => row && row.is_plugin !== true).length;
+const records = [];
+try {
+    for (let index = 1; index <= 3; index += 1) {
+        const slotId = `slot-${String(index).padStart(3, '0')}`;
+        const workerDir = path.join('sessions', slotId, 'gen-1', 'worker');
+        const absWorkerDir = path.join(ledgerRoot, workerDir);
+        fs.mkdirSync(absWorkerDir, { recursive: true });
+        const heartbeatRel = path.join(workerDir, 'worker-heartbeat.jsonl');
+        const resultRel = path.join(workerDir, 'worker-result.json');
+        const stdoutRel = path.join(workerDir, 'worker.stdout.log');
+        const stderrRel = path.join(workerDir, 'worker.stderr.log');
+        const heartbeatAbs = path.join(ledgerRoot, heartbeatRel);
+        const resultAbs = path.join(ledgerRoot, resultRel);
+        const backend = index === 1 ? 'codex-sdk' : index === 2 ? 'local-llm' : 'python-codex-sdk';
+        const expectedTitle = `${slotId}/gen-1 · WT:WT-${String(index).padStart(4, '0')} · branch:fixture · ${backend} · fast · codex-lb · active`;
+        const workerScript = [
+            "const fs=require('fs');",
+            `fs.appendFileSync(${JSON.stringify(heartbeatAbs)}, JSON.stringify({ok:true, slot:${JSON.stringify(slotId)}, ts:new Date().toISOString()})+'\\n');`,
+            `fs.writeFileSync(${JSON.stringify(resultAbs)}, JSON.stringify({schema:'sks.agent-result.v1', status:'done', slot:${JSON.stringify(slotId)}, heartbeat_seen:true}, null, 2)+'\\n');`,
+            "setTimeout(()=>process.exit(0), 8000);"
+        ].join('');
+        const record = await workerPane.openWorkerPane({
+            root: ledgerRoot,
+            missionId,
+            sessionName,
+            slotId,
+            generationIndex: 1,
+            sessionId: `${slotId}-gen-1`,
+            workerArtifactDir: workerDir,
+            workerCommand: `printf ${shellQuote(`\u001b]2;${expectedTitle}\u0007`)}; ${process.execPath} -e ${shellQuote(workerScript)}`,
+            resultPath: resultRel,
+            heartbeatPath: heartbeatRel,
+            patchEnvelopePath: path.join(workerDir, 'worker-patch-envelope.json'),
+            stdoutLog: stdoutRel,
+            stderrLog: stderrRel,
+            cwd: root,
+            serviceTier: 'fast',
+            backend,
+            statusLabel: 'active',
+            worktree: { id: `WT-${String(index).padStart(4, '0')}`, path: root, branch: 'fixture' }
+        });
+        records.push(record);
+    }
+    await sleep(750);
+    const listed = await zellij.runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: false });
+    const rows = parsePaneRows(listed.stdout_tail);
+    const terminalRows = rows.filter((row) => row && row.is_plugin !== true);
+    const titles = rows.map((row) => String(row.title || row.name || row.pane_name || ''));
+    const matchedTitles = records.filter((record) => titles.includes(record.pane_title)).length;
+    const commandMatchedWorkers = records.filter((record) => rows.some((row) => {
+        const command = `${row.terminal_command || ''} ${row.pane_command || ''} ${row.command || ''}`;
+        return command.includes(missionId) && command.includes(record.slot_id);
+    })).length;
+    const requestedTitleCommands = records.filter((record) => {
+        const args = Array.isArray(record.launch?.args) ? record.launch.args.map(String) : [];
+        return args.includes('--name') && args.includes(record.pane_title);
+    }).length;
+    const dump = await zellij.runZellij(['--session', sessionName, 'action', 'dump-screen'], { cwd: root, timeoutMs: 5000, optional: true });
+    const heartbeatSeen = records.filter((record) => fs.existsSync(path.join(ledgerRoot, record.heartbeat_path))).length;
+    const resultSeen = records.filter((record) => fs.existsSync(path.join(ledgerRoot, record.worker_result_path))).length;
+    const realPaneIds = records.filter((record) => workerPane.isRealZellijWorkerPaneIdSource(record.pane_id_source) && record.pane_id).length;
+    const report = {
+        schema: 'sks.zellij-worker-pane-real-ui-blackbox.v1',
+        ok: realPaneIds === 3 && requestedTitleCommands === 3 && matchedTitles === 3 && heartbeatSeen === 3 && resultSeen === 3 && terminalRows.length >= beforeTerminalCount + 3,
+        real_required: true,
+        zellij_version: available.stdout.trim(),
+        mission_id: missionId,
+        session_name: sessionName,
+        before_pane_count: beforeCount,
+        before_terminal_pane_count: beforeTerminalCount,
+        after_pane_count: rows.length,
+        terminal_pane_count: terminalRows.length,
+        worker_pane_count: records.length,
+        real_pane_ids: realPaneIds,
+        matched_titles: matchedTitles,
+        command_matched_workers: commandMatchedWorkers,
+        requested_title_commands: requestedTitleCommands,
+        heartbeat_seen: heartbeatSeen,
+        result_seen: resultSeen,
+        dump_screen_ok: dump.ok,
+        pane_titles: records.map((record) => record.pane_title),
+        pane_id_sources: records.map((record) => record.pane_id_source),
+        proof_root: ledgerRoot,
+        blockers: []
+    };
+    if (!report.ok) {
+        report.blockers = [
+            ...(realPaneIds === 3 ? [] : ['real_worker_pane_ids_missing']),
+            ...(requestedTitleCommands === 3 ? [] : ['worker_pane_title_request_missing']),
+            ...(matchedTitles === 3 ? [] : ['worker_pane_titles_not_visible_in_list_panes']),
+            ...(heartbeatSeen === 3 ? [] : ['worker_heartbeat_missing']),
+            ...(resultSeen === 3 ? [] : ['worker_result_missing']),
+            ...(terminalRows.length >= beforeTerminalCount + 3 ? [] : ['terminal_worker_pane_count_below_3'])
+        ];
+    }
+    fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'zellij-worker-pane-real-ui-blackbox.json'), `${JSON.stringify(report, null, 2)}\n`);
+    emitGate('zellij:worker-pane-real-ui:blackbox', report);
+    if (!report.ok)
+        process.exitCode = 1;
+}
+finally {
+    await zellij.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+    safeKill(attachedClient, 'SIGTERM');
+    await sleep(250);
+    safeKill(attachedClient, 'SIGKILL');
+}
+function parsePaneRows(text) {
+    if (!String(text || '').trim())
+        return [];
+    try {
+        const parsed = JSON.parse(String(text));
+        if (Array.isArray(parsed))
+            return parsed;
+        if (Array.isArray(parsed?.panes))
+            return parsed.panes;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+function startAttachedZellijClient(sessionName) {
+    const logFile = path.join(root, '.sneakoscope', 'reports', `${sessionName}.script.log`);
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    return spawn('script', ['-q', logFile, 'zellij', 'attach', '--create', sessionName], {
+        cwd: root,
+        stdio: ['ignore', 'ignore', 'ignore']
+    });
+}
+function safeKill(child, signal) {
+    try {
+        if (!child.killed)
+            child.kill(signal);
+    }
+    catch {
+        // Best-effort cleanup for the disposable pseudo-terminal client.
+    }
+}
+//# sourceMappingURL=zellij-worker-pane-real-ui-blackbox.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.7",
+  "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",
@@ -312,10 +312,10 @@
     "ultra-router:classification": "node ./dist/scripts/ultra-router-classification-check.js",
     "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 release:check:parallel && npm run mad-sks:app-ui-no-mutation && npm run codex-app:fast-ui-preservation && npm run codex-app:ui-clobber-guard && npm run doctor:fixes-codex-app-fast-ui && npm run provider:badge-context && npm run provider:context-config-toml && npm run codex-app:provider-badge && npm run zellij:spawn-on-demand-layout && npm run zellij:worker-pane-manager && npm run zellij:worker-pane-manager-single-owner && npm run agent:worker-pane-communication-contract && npm run runtime:no-mjs-scripts && npm run runtime:ts-python-boundary && npm run codex-sdk:capability && npm run codex-sdk:no-legacy-fallback && npm run codex-sdk:backend-router && npm run codex-sdk:structured-output && npm run codex-sdk:event-stream-ledger && npm run codex-sdk:thread-registry && npm run codex-sdk:sandbox-policy && npm run codex-sdk:zellij-pane-binding && npm run codex-sdk:all-pipelines && npm run codex-sdk:dfix-pipeline && npm run codex-sdk:qa-pipeline && npm run codex-sdk:research-pipeline && npm run codex-sdk:team-naruto-agent-pipeline && npm run codex-sdk:release-review-pipeline && npm run codex-sdk:ux-ppt-review-pipeline && npm run codex-sdk:core-skill-pipeline && npm run codex-control:capability && npm run codex-control:no-legacy-fallback && npm run codex-control:structured-output && npm run codex-control:event-stream-ledger && npm run codex-control:thread-registry && npm run codex-control:side-effect-scope && npm run codex-control:all-pipelines && npm run codex-control:empty-result-retry && npm run codex-control:stream-idle-watchdog && npm run codex-control:tool-call-sequence-repair && npm run codex-control:keepalive-no-cot-leak && npm run local-collab:policy && npm run local-collab:gpt-final-arbiter && npm run local-collab:no-local-only-final && npm run local-collab:gpt-final-availability && npm run local-llm:capability && npm run local-llm:structured-output && npm run local-llm:tool-call-repair && npm run local-llm:all-pipelines && npm run local-collab:all-pipelines-final-gpt && npm run python-sdk:capability && npm run python-sdk:stream-bridge && npm run python-sdk:sandbox-policy && npm run python-sdk:all-pipelines && npm run codex:plugin-list-json && npm run codex:product-design-plugin-routing && npm run codex:product-design-auto-install && npm run codex:thread-runtime-choice && npm run codex:environment-scoped-approvals && npm run ultra-router:classification && npm run ultra-router:auto-router && npm run release:version-truth && npm run release:worktree-gates && npm run codex:0.137-compat && npm run codex:0.136-compat && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run agent:zellij-dynamic-backfill-panes && npm run agent:worker-pane-communication-contract && npm run agent:slot-pane-binding-proof && npm run zellij:worker-pane-manager && npm run zellij:spawn-on-demand-layout && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run mad-sks:zellij-default-pane-worker && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run naruto:work-graph && npm run naruto:readonly-routing && npm run naruto:concurrency-governor && npm run naruto:active-pool && npm run naruto:role-distribution && npm run naruto:parallel-patch-apply && npm run naruto:verification-pool && npm run naruto:zellij-massive-ui && npm run naruto:gpt-final-pack && npm run prompt:placeholder-guard && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run naruto:shadow-clone-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./dist/scripts/release-check-stamp.js write && npm run release:readiness --silent && 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 -- --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",
+    "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_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/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && npm --cache /tmp/sks-npm-cache publish --dry-run --registry https://registry.npmjs.org/ --access public",
+    "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",
     "prepack": "npm run build",
     "prepublishOnly": "npm run release:metadata && npm run release:version-truth && npm run release:dist-freshness && 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 && node ./dist/scripts/release-registry-check.js --require-unpublished --require-publish-auth",
@@ -501,7 +501,34 @@
     "runtime:ts-python-boundary": "node ./dist/scripts/runtime-ts-python-boundary-check.js",
     "python-tools:smoke": "node ./dist/scripts/python-tools-smoke-check.js",
     "agent:zellij-dynamic-backfill-panes": "node ./dist/scripts/agent-zellij-dynamic-backfill-panes-check.js",
-    "agent:real-codex-in-zellij-worker-pane": "node ./dist/scripts/agent-real-codex-in-zellij-worker-pane-check.js"
+    "agent:real-codex-in-zellij-worker-pane": "node ./dist/scripts/agent-real-codex-in-zellij-worker-pane-check.js",
+    "release:check:legacy": "npm run release:check:parallel && npm run mad-sks:app-ui-no-mutation && npm run codex-app:fast-ui-preservation && npm run codex-app:ui-clobber-guard && npm run doctor:fixes-codex-app-fast-ui && npm run provider:badge-context && npm run provider:context-config-toml && npm run codex-app:provider-badge && npm run zellij:spawn-on-demand-layout && npm run zellij:worker-pane-manager && npm run zellij:worker-pane-manager-single-owner && npm run agent:worker-pane-communication-contract && npm run runtime:no-mjs-scripts && npm run runtime:ts-python-boundary && npm run codex-sdk:capability && npm run codex-sdk:no-legacy-fallback && npm run codex-sdk:backend-router && npm run codex-sdk:structured-output && npm run codex-sdk:event-stream-ledger && npm run codex-sdk:thread-registry && npm run codex-sdk:sandbox-policy && npm run codex-sdk:zellij-pane-binding && npm run codex-sdk:all-pipelines && npm run codex-sdk:dfix-pipeline && npm run codex-sdk:qa-pipeline && npm run codex-sdk:research-pipeline && npm run codex-sdk:team-naruto-agent-pipeline && npm run codex-sdk:release-review-pipeline && npm run codex-sdk:ux-ppt-review-pipeline && npm run codex-sdk:core-skill-pipeline && npm run codex-control:capability && npm run codex-control:no-legacy-fallback && npm run codex-control:structured-output && npm run codex-control:event-stream-ledger && npm run codex-control:thread-registry && npm run codex-control:side-effect-scope && npm run codex-control:all-pipelines && npm run codex-control:empty-result-retry && npm run codex-control:stream-idle-watchdog && npm run codex-control:tool-call-sequence-repair && npm run codex-control:keepalive-no-cot-leak && npm run local-collab:policy && npm run local-collab:gpt-final-arbiter && npm run local-collab:no-local-only-final && npm run local-collab:gpt-final-availability && npm run local-llm:capability && npm run local-llm:structured-output && npm run local-llm:tool-call-repair && npm run local-llm:all-pipelines && npm run local-collab:all-pipelines-final-gpt && npm run python-sdk:capability && npm run python-sdk:stream-bridge && npm run python-sdk:sandbox-policy && npm run python-sdk:all-pipelines && npm run codex:plugin-list-json && npm run codex:product-design-plugin-routing && npm run codex:product-design-auto-install && npm run codex:thread-runtime-choice && npm run codex:environment-scoped-approvals && npm run ultra-router:classification && npm run ultra-router:auto-router && npm run release:version-truth && npm run release:worktree-gates && npm run codex:0.137-compat && npm run codex:0.136-compat && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run agent:zellij-dynamic-backfill-panes && npm run agent:worker-pane-communication-contract && npm run agent:slot-pane-binding-proof && npm run zellij:worker-pane-manager && npm run zellij:spawn-on-demand-layout && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run mad-sks:zellij-default-pane-worker && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run naruto:work-graph && npm run naruto:readonly-routing && npm run naruto:concurrency-governor && npm run naruto:active-pool && npm run naruto:role-distribution && npm run naruto:parallel-patch-apply && npm run naruto:verification-pool && npm run naruto:zellij-massive-ui && npm run naruto:gpt-final-pack && npm run prompt:placeholder-guard && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run naruto:shadow-clone-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./dist/scripts/release-check-stamp.js write && npm run release:readiness --silent && node ./dist/scripts/release-check-stamp.js write",
+    "release:check:dag": "node ./dist/scripts/release-gate-dag-runner.js --preset release",
+    "release:check:dag:explain": "node ./dist/scripts/release-gate-dag-runner.js --preset release --explain",
+    "release:check:dag:no-cache": "node ./dist/scripts/release-gate-dag-runner.js --preset release --no-cache",
+    "release:check:dag:fail-fast": "node ./dist/scripts/release-gate-dag-runner.js --preset release --fail-fast",
+    "release:dag-runner": "node ./dist/scripts/release-gate-dag-runner-check.js",
+    "release:parallel-speed-budget": "node ./dist/scripts/release-parallel-speed-budget-check.js",
+    "release:stability-report": "node ./dist/scripts/release-stability-report-check.js",
+    "git:worktree-manifest-append": "node ./dist/scripts/git-worktree-manifest-append-check.js",
+    "git:worktree-dirty-main-detection": "node ./dist/scripts/git-worktree-dirty-main-detection-check.js",
+    "git:worktree-untracked-diff": "node ./dist/scripts/git-worktree-untracked-diff-check.js",
+    "git:worktree-diff-envelope": "node ./dist/scripts/git-worktree-diff-envelope-check.js",
+    "git:worktree-integration-primary": "node ./dist/scripts/git-worktree-integration-primary-check.js",
+    "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: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/release/release-gate-node.schema.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneakoscope.local/schemas/release/release-gate-node.schema.json",
+  "type": "object",
+  "required": ["schema", "gates"],
+  "properties": {
+    "schema": { "const": "sks.release-gates.v2" },
+    "gates": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "command", "deps", "resource", "side_effect", "timeout_ms", "cache", "isolation", "preset"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "command": { "type": "string", "minLength": 1 },
+          "deps": { "type": "array", "items": { "type": "string" } },
+          "resource": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "enum": ["cpu-light", "cpu-heavy", "io-light", "io-heavy", "git", "git-worktree", "zellij-real", "local-llm-real", "remote-model-real", "python", "network", "global-config", "publish", "fs-read"]
+            }
+          },
+          "side_effect": { "enum": ["hermetic", "real-env"] },
+          "timeout_ms": { "type": "integer", "minimum": 1 },
+          "cache": {
+            "type": "object",
+            "required": ["enabled", "inputs"],
+            "properties": {
+              "enabled": { "type": "boolean" },
+              "inputs": { "type": "array", "items": { "type": "string" } }
+            },
+            "additionalProperties": false
+          },
+          "isolation": {
+            "type": "object",
+            "required": ["home", "codex_home", "report_dir"],
+            "properties": {
+              "home": { "enum": ["temp", "inherit"] },
+              "codex_home": { "enum": ["temp", "inherit"] },
+              "report_dir": { "const": "per-gate" }
+            },
+            "additionalProperties": false
+          },
+          "preset": { "type": "array", "items": { "type": "string" } }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

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" } }
+  }
+}