sneakoscope 2.0.9 → 2.0.11

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

@@ -1,29 +1,162 @@
 #!/usr/bin/env node
 // @ts-nocheck
+import os from 'node:os';
+import path from 'node:path';
 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;
+import { writeTextAtomic } from '../core/fsx.js';
+import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
+import { runZellij } from '../core/zellij/zellij-command.js';
 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
-};
+const visiblePaneCap = Number(process.env.SKS_ZELLIJ_GEOMETRY_VISIBLE_CAP || 8);
+const report = requireReal ? await realGeometryProof() : syntheticGeometryProof();
 assertGate(report.ok, 'right-column geometry proof failed', report);
 emitGate('zellij:right-column-geometry-proof', report);
+function syntheticGeometryProof() {
+    const panes = [
+        { pane_id: 'main', role: 'main', geometry: { x: 0, y: 0, width: 120, height: 60 }, name: 'orchestrator' },
+        { pane_id: 'w1', role: 'worker', geometry: { x: 121, y: 0, width: 80, height: 15 }, name: 'slot-001' },
+        { pane_id: 'w2', role: 'worker', geometry: { x: 121, y: 16, width: 80, height: 15 }, name: 'slot-002' }
+    ];
+    return buildReport({ synthetic: true, panes, commands: [], listPanes: null, dumpScreen: null, blockers: [] });
+}
+async function realGeometryProof() {
+    const root = process.cwd();
+    const capability = await checkZellijCapability({ root, require: true, writeReport: false });
+    const sessionName = `sks-geom-${process.pid}-${Date.now()}`;
+    const tmpDir = await fsTempDir();
+    const layoutPath = path.join(tmpDir, 'layout.kdl');
+    const commands = [];
+    let listPanes = null;
+    let dumpScreen = null;
+    const blockers = [...(capability.blockers || [])];
+    try {
+        await writeTextAtomic(layoutPath, buildRealGeometryLayout(root));
+        await runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 2500, optional: true });
+        const launch = await runZellij(['attach', '--create-background', sessionName, 'options', '--default-layout', layoutPath], { cwd: root, timeoutMs: 5000, optional: false });
+        commands.push(launch);
+        if (!launch.ok)
+            blockers.push(...launch.blockers.map((blocker) => `zellij_geometry_launch_${blocker}`));
+        await sleep(1000);
+        listPanes = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: false });
+        commands.push(listPanes);
+        if (!listPanes.ok)
+            blockers.push(...listPanes.blockers.map((blocker) => `zellij_geometry_list_panes_${blocker}`));
+        dumpScreen = await runZellij(['--session', sessionName, 'action', 'dump-screen'], { cwd: root, timeoutMs: 5000, optional: false });
+        commands.push(dumpScreen);
+        if (!dumpScreen.ok)
+            blockers.push(...dumpScreen.blockers.map((blocker) => `zellij_geometry_dump_screen_${blocker}`));
+        const panes = parseRealPanes(listPanes.stdout_tail);
+        return buildReport({ synthetic: false, panes, commands, listPanes, dumpScreen, blockers });
+    }
+    finally {
+        commands.push(await runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true }).catch((err) => ({
+            ok: false,
+            command: 'zellij',
+            args: ['kill-session', sessionName],
+            blockers: [`zellij_geometry_cleanup_exception:${err?.message || String(err)}`],
+            warnings: []
+        })));
+    }
+}
+function buildReport(input) {
+    const main = input.panes.find((pane) => pane.role === 'main') || null;
+    const workers = input.panes.filter((pane) => pane.role === 'worker');
+    const sameRightX = workers.length > 0 && workers.every((pane) => Math.abs(Number(pane.geometry.x) - Number(workers[0].geometry.x)) <= 2);
+    const rightOfMain = Boolean(main) && workers.length > 0 && workers.every((pane) => Number(pane.geometry.x) >= Number(main.geometry.x) + Number(main.geometry.width) - 2);
+    const increasingY = workers.every((pane, index) => index === 0 || Number(pane.geometry.y) > Number(workers[index - 1].geometry.y));
+    const capOk = workers.length <= visiblePaneCap;
+    const realEvidenceOk = input.synthetic || (input.listPanes?.ok === true && input.dumpScreen?.ok === true && workers.length >= 2);
+    const blockers = [
+        ...input.blockers,
+        ...(main ? [] : ['zellij_geometry_main_missing']),
+        ...(workers.length >= 2 ? [] : ['zellij_geometry_workers_missing']),
+        ...(sameRightX ? [] : ['zellij_geometry_worker_x_mismatch']),
+        ...(rightOfMain ? [] : ['zellij_geometry_workers_not_right_of_main']),
+        ...(increasingY ? [] : ['zellij_geometry_workers_not_stacked_down']),
+        ...(capOk ? [] : ['zellij_geometry_visible_cap_exceeded']),
+        ...(realEvidenceOk ? [] : ['zellij_geometry_real_evidence_missing'])
+    ];
+    return {
+        schema: 'sks.zellij-right-column-geometry-proof.v1',
+        ok: blockers.length === 0,
+        gate: 'zellij:right-column-geometry-proof',
+        synthetic: input.synthetic,
+        same_right_x: sameRightX,
+        right_of_main: rightOfMain,
+        increasing_y: increasingY,
+        visible_cap_ok: capOk,
+        real_list_panes_json_observed: input.synthetic ? false : input.listPanes?.ok === true,
+        real_dump_screen_observed: input.synthetic ? false : input.dumpScreen?.ok === true,
+        panes: input.panes,
+        command_count: input.commands.length,
+        command_blockers: input.commands.flatMap((row) => row?.blockers || []),
+        blockers
+    };
+}
+function parseRealPanes(text) {
+    let rows = [];
+    try {
+        const parsed = JSON.parse(String(text || '[]'));
+        rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.panes) ? parsed.panes : [];
+    }
+    catch {
+        rows = [];
+    }
+    return rows
+        .filter((row) => row && row.is_plugin !== true && row.exited !== true)
+        .map((row) => {
+        const title = String(row.title || row.name || row.pane_name || '');
+        return {
+            pane_id: String(row.pane_id ?? row.paneId ?? row.id ?? title),
+            role: /^slot-\d+/i.test(title) ? 'worker' : title === 'orchestrator' ? 'main' : 'unknown',
+            geometry: {
+                x: Number(row.pane_x ?? row.x ?? 0),
+                y: Number(row.pane_y ?? row.y ?? 0),
+                width: Number(row.pane_columns ?? row.width ?? 0),
+                height: Number(row.pane_rows ?? row.height ?? 0)
+            },
+            name: title,
+            pane_command: row.pane_command || row.terminal_command || null
+        };
+    })
+        .filter((row) => row.role === 'main' || row.role === 'worker')
+        .sort((a, b) => a.role === b.role ? a.geometry.y - b.geometry.y : a.role === 'main' ? -1 : 1);
+}
+function buildRealGeometryLayout(cwd) {
+    const hold = 'sleep 30';
+    return [
+        'layout {',
+        '    default_tab_template {',
+        '        pane size=1 borderless=true {',
+        '            plugin location="zellij:tab-bar"',
+        '        }',
+        '        children',
+        '        pane size=2 borderless=true {',
+        '            plugin location="zellij:status-bar"',
+        '        }',
+        '    }',
+        `    tab name="SKS geometry proof" cwd=${JSON.stringify(cwd)} split_direction="vertical" {`,
+        '        pane name="orchestrator" command="sh" {',
+        `            args "-lc" ${JSON.stringify(hold)}`,
+        '        }',
+        '        pane name="slot-column" split_direction="horizontal" {',
+        '            pane name="slot-001" command="sh" {',
+        `                args "-lc" ${JSON.stringify(hold)}`,
+        '            }',
+        '            pane name="slot-002" command="sh" {',
+        `                args "-lc" ${JSON.stringify(hold)}`,
+        '            }',
+        '        }',
+        '    }',
+        '}',
+        ''
+    ].join('\n');
+}
+async function fsTempDir() {
+    const fs = await import('node:fs/promises');
+    return fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-geometry-'));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 //# sourceMappingURL=zellij-right-column-geometry-proof.js.map

package/dist/scripts/zellij-right-column-headless-overflow-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 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 headlessReturnIndex = worker.indexOf("rightColumn?.placement === 'headless'");
+const newPaneIndex = worker.indexOf("action', 'new-pane'");
+const report = {
+    schema: 'sks.zellij-right-column-headless-overflow-check.v1',
+    headless_source: worker.includes("'zellij_worker_headless_overflow'"),
+    headless_scaling_primitive: worker.includes('native_cli_process_headless_with_slot_dashboard'),
+    returns_before_new_pane: headlessReturnIndex >= 0 && newPaneIndex >= 0 && headlessReturnIndex < newPaneIndex,
+    manager_records_overflow: manager.includes('worker_headless_overflow') && manager.includes('visible_pane_cap'),
+    swarm_records_overflow: swarm.includes('recordHeadlessWorkerInRightColumn')
+};
+const ok = report.headless_source && report.headless_scaling_primitive && report.returns_before_new_pane && report.manager_records_overflow && report.swarm_records_overflow;
+assertGate(ok, 'headless overflow must not call zellij action new-pane', report);
+emitGate('zellij:right-column-headless-overflow', report);
+//# sourceMappingURL=zellij-right-column-headless-overflow-check.js.map

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

@@ -11,12 +11,17 @@ const report = {
     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'"),
+    dashboard_opt_in: source.includes('zellijUiModeCreatesDashboard') && source.includes('dashboard_created: false'),
+    slot_column_anchor_right: worker.includes('buildZellijSlotColumnAnchorCommand') && worker.includes("'--direction', 'right', '--name', 'SLOTS'"),
+    worker_direction_stack: worker.includes("'--direction', directionRequested")
+        && worker.includes("const directionRequested: 'right' | 'down' = rightColumn ? 'down' : 'right'")
+        && worker.includes("'--near-current-pane'")
+        && worker.includes('worker_direction_requested')
+        && worker.includes('slot_column_anchor_pane_id'),
     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);
+report.ok = report.exports && report.dashboard_after_worker_reservation && report.dashboard_opt_in && report.slot_column_anchor_right && report.worker_direction_stack && report.headless_overflow && report.schema_exists;
+assertGate(report.ok, 'right-column manager must own opt-in dashboard, 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-slot-column-anchor-check.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { buildZellijSlotColumnAnchorCommand, renderZellijSlotColumnAnchor } from '../core/zellij/zellij-slot-column-anchor.js';
+const rendered = renderZellijSlotColumnAnchor({
+    activeWorkers: 3,
+    visiblePaneCap: 8,
+    headlessWorkers: 12,
+    queueDepth: 44,
+    mode: 'compact-slots'
+});
+const command = buildZellijSlotColumnAnchorCommand({
+    nodePath: '/usr/bin/node',
+    cliPath: '/repo/dist/bin/sks.js',
+    missionId: 'M-check',
+    mode: 'compact-slots',
+    artifactRoot: '/repo/.sneakoscope/missions/M-check/agents',
+    watch: true
+});
+const ok = rendered === 'SLOTS active 3/8 · headless 12 · q 44'
+    && command.includes('zellij-slot-column-anchor')
+    && command.includes('--watch');
+assertGate(ok, 'Zellij slot-column anchor must render one compact SLOTS line and build the CLI command', { rendered, command });
+emitGate('zellij:slot-column-anchor', { rendered, command });
+//# sourceMappingURL=zellij-slot-column-anchor-check.js.map

package/dist/scripts/zellij-slot-only-ui-check.js

@@ -0,0 +1,24 @@
+#!/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 uiMode = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-ui-mode.ts'), 'utf8');
+const manager = 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 swarm = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-slot-only-ui-check.v1',
+    default_compact_slots: uiMode.includes("return 'compact-slots'"),
+    state_records_ui_mode: manager.includes('ui_mode: uiMode'),
+    compact_skips_dashboard: manager.includes('if (!createDashboard)') && manager.includes('dashboard_created: false'),
+    first_slot_creates_slot_anchor_right: worker.includes('buildZellijSlotColumnAnchorCommand') && worker.includes("'--direction', 'right', '--name', 'SLOTS'"),
+    workers_stack_down_from_anchor: worker.includes("const directionRequested: 'right' | 'down' = rightColumn ? 'down' : 'right'")
+        && worker.includes("directionRequested === 'down' ? ['--near-current-pane'] : []")
+        && worker.includes('slot_column_anchor_pane_id'),
+    compact_uses_renderer: swarm.includes('buildZellijSlotPaneCommand') && swarm.includes("slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer'")
+};
+const ok = Object.values(report).every((value) => value === true || typeof value === 'string');
+assertGate(ok, 'Zellij default UI must be compact slot-only with opt-in dashboard', report);
+emitGate('zellij:slot-only-ui', report);
+//# sourceMappingURL=zellij-slot-only-ui-check.js.map

package/dist/scripts/zellij-slot-pane-renderer-check.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const renderer = await importDist('core/zellij/zellij-slot-pane-renderer.js');
+const text = renderer.renderZellijSlotPane({
+    slotId: 'slot-003',
+    generationIndex: 2,
+    role: 'implementer',
+    backend: 'local-llm',
+    status: 'coding',
+    currentFile: 'src/core/foo.ts',
+    patchStatus: 'candidate',
+    verifyStatus: 'queued',
+    heartbeatAgeMs: 2000,
+    worktreeId: 'WT-0007',
+    mode: 'compact-slots'
+});
+const lines = text.split(/\n/);
+const command = renderer.buildZellijSlotPaneCommand({
+    cliPath: '/repo/dist/bin/sks.js',
+    missionId: 'M-test',
+    slotId: 'slot-003',
+    generationIndex: 2,
+    artifactDir: '/tmp/worker',
+    watch: true
+});
+const report = {
+    schema: 'sks.zellij-slot-pane-renderer-check.v1',
+    line_count: lines.length,
+    max_compact_lines: 5,
+    contains_slot: /slot-003 gen-2/.test(text),
+    contains_status: /status: coding/.test(text),
+    command_uses_slot_pane: command.includes('zellij-slot-pane') && command.includes('--watch'),
+    snapshot: text
+};
+assertGate(lines.length <= 5 && report.contains_slot && report.contains_status && report.command_uses_slot_pane, 'compact slot pane renderer must stay within five lines', report);
+emitGate('zellij:compact-slot-renderer', report);
+//# sourceMappingURL=zellij-slot-pane-renderer-check.js.map

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

@@ -12,8 +12,13 @@ const managerOwnsNewPane = /runZellij\(\[[\s\S]{0,800}'new-pane'/.test(manager)
 const nativeDirectNewPane = /runZellij\(\[[\s\S]{0,500}'new-pane'/.test(native);
 const nativeUsesManager = native.includes('openWorkerPane({') && native.includes('closeWorkerPane({');
 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;
+const fallbackRecorded = manager.includes('worker_direction_applied')
+    && manager.includes("directionApplied = rightColumn ? 'down' : 'unknown'")
+    && manager.includes("directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied'");
+const slotAnchorOwned = manager.includes('buildZellijSlotColumnAnchorCommand')
+    && manager.includes("recordSlotColumnAnchorInRightColumn")
+    && manager.includes("'--direction', 'right', '--name', 'SLOTS'");
+const ok = managerOwnsNewPane && !nativeDirectNewPane && nativeUsesManager && dynamicDirection && fallbackRecorded && slotAnchorOwned;
 emit({
     schema: 'sks.zellij-worker-pane-manager-single-owner-check.v1',
     ok,
@@ -22,14 +27,16 @@ emit({
         native_direct_new_pane_absent: !nativeDirectNewPane,
         native_uses_manager: nativeUsesManager,
         dynamic_direction_requested: dynamicDirection,
-        fallback_recorded: fallbackRecorded
+        fallback_recorded: fallbackRecorded,
+        slot_anchor_owned: slotAnchorOwned
     },
     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'] : []),
         ...(!dynamicDirection ? ['zellij_worker_dynamic_direction_missing'] : []),
-        ...(!fallbackRecorded ? ['zellij_worker_direction_fallback_not_recorded'] : [])
+        ...(!fallbackRecorded ? ['zellij_worker_direction_fallback_not_recorded'] : []),
+        ...(!slotAnchorOwned ? ['zellij_worker_slot_column_anchor_not_owned'] : [])
     ]
 });
 function emit(report) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -149,12 +149,12 @@
     "all-features:execute-fixtures": "node ./dist/bin/sks.js all-features selftest --mock --execute-fixtures --strict-artifacts --json",
     "feature-fixtures:strict": "node ./dist/bin/sks.js all-features selftest --mock --execute-fixtures --strict-artifacts --hermetic --json",
     "trust:check": "node ./dist/bin/sks.js trust validate latest --json || node ./dist/scripts/trust-fixture-check.js",
-    "wrongness:fixtures": "node --test \"test/wrongness/**/*.test.mjs\"",
+    "wrongness:fixtures": "node --test test/wrongness/*.test.mjs",
     "wrongness:check": "node ./dist/bin/sks.js wrongness validate project --json && node ./dist/scripts/wrongness-fixture-check.js",
     "git-hygiene:check": "node ./dist/bin/sks.js git doctor --json",
     "git-precommit:fixture": "node ./dist/scripts/git-precommit-fixture-check.js",
     "shared-memory:check": "node ./dist/bin/sks.js wiki validate-shared --json || node ./dist/scripts/shared-memory-fixture-check.js",
-    "git-collaboration:e2e": "node --test \"test/e2e/git-*.test.mjs\" \"test/e2e/shared-triwiki-merge.test.mjs\" \"test/e2e/wrongness-shared-sync.test.mjs\"",
+    "git-collaboration:e2e": "node --test test/e2e/git-*.test.mjs test/e2e/shared-triwiki-merge.test.mjs test/e2e/wrongness-shared-sync.test.mjs",
     "evidence:check": "node ./dist/scripts/evidence-fixture-check.js",
     "safety:check": "node ./dist/scripts/safety-check.js",
     "chaos:check": "node --test \"test/chaos/**/*.test.mjs\"",
@@ -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_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:real-check": "node ./dist/scripts/release-real-check.js && SKS_REQUIRE_ZELLIJ=1 npm run zellij:first-slot-down-stack:real -- --require-real && SKS_REQUIRE_ZELLIJ=1 npm run zellij:right-column-real-geometry -- --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",
@@ -453,11 +453,13 @@
     "agent:strategy-to-patch-strict": "node ./dist/scripts/agent-strategy-to-patch-strict-check.js",
     "agent:rollback-command": "node ./dist/scripts/agent-rollback-command-check.js",
     "agent:native-cli-session-swarm": "node ./dist/scripts/agent-native-cli-session-swarm-check.js",
-    "release:worktree-gates": "npm run git:worktree-capability && npm run git:worktree-manager && npm run git:worktree-diff-export && npm run git:worktree-merge-queue && npm run git:worktree-cleanup && npm run git:worktree-cache-performance && npm run git:worktree-pool-performance && npm run naruto:worktree-coding && npm run naruto:worktree-zellij-ui && npm run naruto:worktree-gpt-final",
+    "release:worktree-gates": "npm run git:worktree-capability && npm run git:worktree-manager && npm run git:worktree-diff-export && npm run git:worktree-merge-queue && npm run git:worktree-checkpoint && npm run git:worktree-cross-rebase && npm run git:worktree-cleanup && npm run git:worktree-cache-performance && npm run git:worktree-pool-performance && npm run naruto:worktree-coding && npm run naruto:worktree-zellij-ui && npm run naruto:worktree-gpt-final",
     "git:worktree-capability": "node ./dist/scripts/git-worktree-capability-check.js",
     "git:worktree-manager": "node ./dist/scripts/git-worktree-manager-check.js",
     "git:worktree-diff-export": "node ./dist/scripts/git-worktree-diff-export-check.js",
     "git:worktree-merge-queue": "node ./dist/scripts/git-worktree-merge-queue-check.js",
+    "git:worktree-checkpoint": "node ./dist/scripts/git-worktree-checkpoint-check.js",
+    "git:worktree-cross-rebase": "node ./dist/scripts/git-worktree-cross-rebase-check.js",
     "git:worktree-cleanup": "node ./dist/scripts/git-worktree-cleanup-check.js",
     "git:worktree-cache-performance": "node ./dist/scripts/git-worktree-cache-performance-check.js",
     "git:worktree-pool-performance": "node ./dist/scripts/git-worktree-pool-performance-check.js",
@@ -474,6 +476,10 @@
     "naruto:worktree-coding": "node ./dist/scripts/naruto-worktree-coding-check.js",
     "naruto:worktree-zellij-ui": "node ./dist/scripts/naruto-worktree-zellij-ui-check.js",
     "naruto:worktree-gpt-final": "node ./dist/scripts/naruto-worktree-gpt-final-check.js",
+    "naruto:allocation-policy": "node ./dist/scripts/naruto-allocation-policy-check.js",
+    "naruto:rebalance-policy": "node ./dist/scripts/naruto-rebalance-policy-check.js",
+    "naruto:actual-worker-control-plane": "node ./dist/scripts/naruto-actual-worker-control-plane-check.js",
+    "naruto:orchestrator-runtime-source": "node ./dist/scripts/naruto-orchestrator-runtime-source-check.js",
     "naruto:real-local-gpt-final-smoke": "node ./dist/scripts/naruto-real-local-gpt-final-smoke.js",
     "prompt:placeholder-guard": "node ./dist/scripts/prompt-placeholder-guard-check.js",
     "agent:native-cli-session-swarm-10": "node ./dist/scripts/agent-native-cli-session-swarm-10-check.js",
@@ -493,6 +499,9 @@
     "mad-sks:fast-mode-propagation": "node ./dist/scripts/mad-sks-fast-mode-propagation-check.js",
     "zellij:spawn-on-demand-layout": "node ./dist/scripts/zellij-spawn-on-demand-layout-check.js",
     "zellij:worker-pane-manager": "node ./dist/scripts/zellij-worker-pane-manager-check.js",
+    "zellij:slot-column-anchor": "node ./dist/scripts/zellij-slot-column-anchor-check.js",
+    "zellij:first-slot-down-stack": "node ./dist/scripts/zellij-first-slot-down-stack-check.js",
+    "zellij:first-slot-down-stack:real": "node ./dist/scripts/zellij-first-slot-down-stack-real-check.js",
     "zellij:worker-pane-manager-single-owner": "node ./dist/scripts/zellij-worker-pane-manager-single-owner-check.js",
     "zellij:worker-pane-spawn-order": "node ./dist/scripts/zellij-worker-pane-spawn-order-check.js",
     "agent:slot-pane-binding-proof": "node ./dist/scripts/agent-slot-pane-binding-proof-check.js",
@@ -521,12 +530,20 @@
     "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:slot-only-ui": "node ./dist/scripts/zellij-slot-only-ui-check.js",
+    "zellij:compact-slot-renderer": "node ./dist/scripts/zellij-slot-pane-renderer-check.js",
+    "zellij:right-column-headless-overflow": "node ./dist/scripts/zellij-right-column-headless-overflow-check.js",
     "zellij:right-column-geometry-proof": "node ./dist/scripts/zellij-right-column-geometry-proof.js",
+    "zellij:right-column-real-geometry": "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:real-active-pool-runtime": "node ./dist/scripts/naruto-real-active-pool-runtime-check.js",
     "naruto:extreme-parallelism": "node ./dist/scripts/naruto-extreme-parallelism-check.js",
+    "naruto:extreme-parallelism-real": "node ./dist/scripts/naruto-extreme-parallelism-real-check.js",
     "naruto:zellij-dynamic-right-column": "node ./dist/scripts/naruto-zellij-dynamic-right-column-check.js",
+    "git:worktree-integration-primary-runtime": "node ./dist/scripts/git-worktree-integration-primary-runtime-check.js",
+    "agent:role-config-repair": "node ./dist/scripts/agent-role-config-repair-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"
   },