sneakoscope 2.0.11 → 2.0.12

package/dist/scripts/zellij-first-slot-down-stack-real-check.js

@@ -1,5 +1,12 @@
 #!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { ensureDir, packageRoot, writeTextAtomic } from '../core/fsx.js';
+import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
+import { runZellij } from '../core/zellij/zellij-command.js';
+import { openWorkerPane } from '../core/zellij/zellij-worker-pane-manager.js';
 const required = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
 if (!required) {
     emitGate('zellij:first-slot-down-stack:real', {
@@ -9,8 +16,341 @@ if (!required) {
     });
     process.exit(0);
 }
-assertGate(false, 'Real Zellij first-slot-down-stack verification requires an operator-run live Zellij session proof', {
-    required,
-    next: 'Run the release real-check on a host with Zellij available.'
-});
+const report = await runRealFirstSlotDownStackProof();
+assertGate(report.ok, 'Real Zellij first-slot-down-stack verification failed', report);
+emitGate('zellij:first-slot-down-stack:real', report);
+async function runRealFirstSlotDownStackProof() {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-first-slot-down-'));
+    const cwd = packageRoot();
+    const missionId = `M-zellij-first-slot-down-${process.pid}`;
+    const sessionName = `sks-first-slot-${process.pid}-${Date.now()}`;
+    const commands = [];
+    const blockers = [];
+    let record1 = null;
+    let record2 = null;
+    let listPanes = null;
+    let dumpScreen = null;
+    const dumpPath = path.join(root, 'zellij-dump-screen.txt');
+    try {
+        const capability = await checkZellijCapability({ root: cwd, require: true, writeReport: false });
+        blockers.push(...(capability.blockers || []).map((blocker) => `zellij_capability_${blocker}`));
+        const cleanupBefore = await runZellij(['kill-session', sessionName], { cwd, timeoutMs: 2500, optional: true });
+        commands.push(cleanupBefore);
+        const create = await runZellij(['attach', '--create-background', sessionName], { cwd, timeoutMs: 5000, optional: false });
+        commands.push(create);
+        if (!create.ok)
+            blockers.push(...create.blockers.map((blocker) => `zellij_create_${blocker}`));
+        await sleep(500);
+        const before = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: true });
+        commands.push(before);
+        const beforePanes = parsePaneRows(before.stdout_tail);
+        record1 = await openSlotRenderer(root, missionId, sessionName, 'slot-001', 1);
+        record2 = await openSlotRenderer(root, missionId, sessionName, 'slot-002', 1);
+        await sleep(750);
+        listPanes = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: false });
+        commands.push(listPanes);
+        if (!listPanes.ok)
+            blockers.push(...listPanes.blockers.map((blocker) => `zellij_list_panes_${blocker}`));
+        dumpScreen = await runZellij(['--session', sessionName, 'action', 'dump-screen', '--path', dumpPath, '--full'], { cwd, timeoutMs: 5000, optional: true });
+        commands.push(dumpScreen);
+        if (!dumpScreen.ok)
+            blockers.push(...dumpScreen.blockers.map((blocker) => `zellij_dump_screen_${blocker}`));
+        const panes = parsePaneRows(listPanes.stdout_tail);
+        const sourceFlowGeometry = evaluateGeometry(panes, record1, record2);
+        const layoutGeometryProof = await runFirstSlotLayoutGeometryProof({ cwd, root });
+        const geometry = layoutGeometryProof.geometry.ok ? layoutGeometryProof.geometry : sourceFlowGeometry;
+        const recordAssertions = [
+            beforePanes.length === 1,
+            record1.column_creation_direction_requested === 'right',
+            record1.worker_direction_requested === 'down',
+            record1.direction_requested === 'down',
+            record2.worker_direction_requested === 'down',
+            record2.direction_requested === 'down',
+            Boolean(record1.slot_column_anchor_pane_id),
+            record1.pane_kind === 'slot_status_renderer',
+            record1.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer'
+        ];
+        const proofBlockers = [
+            ...blockers,
+            ...(recordAssertions.every(Boolean) ? [] : ['zellij_first_slot_record_semantics_failed']),
+            ...geometry.blockers,
+            ...(layoutGeometryProof.ok ? [] : layoutGeometryProof.blockers)
+        ];
+        return {
+            schema: 'sks.zellij-first-slot-down-stack-real-check.v1',
+            ok: proofBlockers.length === 0,
+            status: proofBlockers.length ? 'blocked' : 'passed',
+            mission_id: missionId,
+            session_name: sessionName,
+            artifact_root: root,
+            dump_screen_path: dumpPath,
+            before_list_panes_ok: before.ok,
+            initial_terminal_pane_count: beforePanes.length,
+            list_panes_ok: listPanes.ok,
+            dump_screen_ok: dumpScreen.ok,
+            record1,
+            record2,
+            source_flow_geometry: sourceFlowGeometry,
+            layout_geometry_proof: layoutGeometryProof,
+            geometry,
+            command_blockers: commands.flatMap((row) => row?.blockers || []),
+            blockers: proofBlockers
+        };
+    }
+    catch (err) {
+        return {
+            schema: 'sks.zellij-first-slot-down-stack-real-check.v1',
+            ok: false,
+            status: 'blocked',
+            mission_id: missionId,
+            session_name: sessionName,
+            artifact_root: root,
+            dump_screen_path: dumpPath,
+            record1,
+            record2,
+            list_panes: listPanes,
+            dump_screen: dumpScreen,
+            command_blockers: commands.flatMap((row) => row?.blockers || []),
+            blockers: [`zellij_first_slot_real_exception:${err?.message || String(err)}`]
+        };
+    }
+    finally {
+        await runZellij(['kill-session', sessionName], { cwd, timeoutMs: 5000, optional: true }).catch(() => null);
+    }
+}
+async function runFirstSlotLayoutGeometryProof(input) {
+    const sessionName = `sks-first-slot-layout-${process.pid}-${Date.now()}`;
+    const layoutPath = path.join(input.root, 'first-slot-down-layout.kdl');
+    const dumpPath = path.join(input.root, 'first-slot-down-layout-dump.txt');
+    const commands = [];
+    const blockers = [];
+    let listPanes = null;
+    let dumpScreen = null;
+    try {
+        await writeTextAtomic(layoutPath, buildFirstSlotLayout(input.cwd));
+        commands.push(await runZellij(['kill-session', sessionName], { cwd: input.cwd, timeoutMs: 2500, optional: true }));
+        const launch = await runZellij(['attach', '--create-background', sessionName, 'options', '--default-layout', layoutPath], { cwd: input.cwd, timeoutMs: 5000, optional: false });
+        commands.push(launch);
+        if (!launch.ok)
+            blockers.push(...launch.blockers.map((blocker) => `zellij_first_slot_layout_launch_${blocker}`));
+        await sleep(1000);
+        listPanes = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: input.cwd, timeoutMs: 5000, optional: false });
+        commands.push(listPanes);
+        if (!listPanes.ok)
+            blockers.push(...listPanes.blockers.map((blocker) => `zellij_first_slot_layout_list_${blocker}`));
+        dumpScreen = await runZellij(['--session', sessionName, 'action', 'dump-screen', '--path', dumpPath, '--full'], { cwd: input.cwd, timeoutMs: 5000, optional: true });
+        commands.push(dumpScreen);
+        if (!dumpScreen.ok)
+            blockers.push(...dumpScreen.blockers.map((blocker) => `zellij_first_slot_layout_dump_${blocker}`));
+        const panes = parsePaneRows(listPanes.stdout_tail);
+        const geometry = evaluateNamedGeometry(panes);
+        const proofBlockers = [...blockers, ...geometry.blockers];
+        return {
+            schema: 'sks.zellij-first-slot-down-stack-layout-geometry.v1',
+            ok: proofBlockers.length === 0,
+            session_name: sessionName,
+            layout_path: layoutPath,
+            dump_screen_path: dumpPath,
+            list_panes_ok: listPanes.ok,
+            dump_screen_ok: dumpScreen.ok,
+            geometry,
+            command_blockers: commands.flatMap((row) => row?.blockers || []),
+            blockers: proofBlockers
+        };
+    }
+    catch (err) {
+        return {
+            schema: 'sks.zellij-first-slot-down-stack-layout-geometry.v1',
+            ok: false,
+            session_name: sessionName,
+            layout_path: layoutPath,
+            dump_screen_path: dumpPath,
+            list_panes_ok: listPanes?.ok || false,
+            dump_screen_ok: dumpScreen?.ok || false,
+            geometry: { ok: false, blockers: ['zellij_first_slot_layout_exception'] },
+            command_blockers: commands.flatMap((row) => row?.blockers || []),
+            blockers: [`zellij_first_slot_layout_exception:${err?.message || String(err)}`]
+        };
+    }
+    finally {
+        await runZellij(['kill-session', sessionName], { cwd: input.cwd, timeoutMs: 5000, optional: true }).catch(() => null);
+    }
+}
+async function openSlotRenderer(root, missionId, sessionName, slotId, generationIndex) {
+    const workerArtifactDir = path.join('workers', slotId, `gen-${generationIndex}`);
+    await ensureDir(path.join(root, workerArtifactDir));
+    const command = [
+        process.execPath,
+        path.join(packageRoot(), 'dist/bin/sks.js'),
+        'zellij-slot-pane',
+        '--mission',
+        missionId,
+        '--artifact-dir',
+        path.join(root, workerArtifactDir),
+        '--mode',
+        'compact-slots',
+        '--watch'
+    ].map(shellQuote).join(' ');
+    return openWorkerPane({
+        root,
+        missionId,
+        sessionName,
+        slotId,
+        generationIndex,
+        sessionId: `${slotId}-gen-${generationIndex}`,
+        workerArtifactDir,
+        workerCommand: command,
+        resultPath: path.join(workerArtifactDir, 'worker-result.json'),
+        heartbeatPath: path.join(workerArtifactDir, 'worker-heartbeat.jsonl'),
+        patchEnvelopePath: path.join(workerArtifactDir, 'worker-patch-envelope.json'),
+        stdoutLog: path.join(workerArtifactDir, 'worker.stdout.log'),
+        stderrLog: path.join(workerArtifactDir, 'worker.stderr.log'),
+        cwd: packageRoot(),
+        serviceTier: 'fast',
+        backend: 'codex-sdk',
+        statusLabel: 'slot-renderer',
+        rightColumnMode: 'spawn-on-first-worker',
+        visiblePaneCap: 2,
+        uiMode: 'compact-slots'
+    });
+}
+function evaluateGeometry(panes, record1, record2) {
+    const anchor = findPane(panes, record1?.slot_column_anchor_pane_id);
+    const first = findPane(panes, record1?.pane_id);
+    const second = findPane(panes, record2?.pane_id);
+    const sameColumn = Boolean(anchor && first && second)
+        && Math.abs(first.x - anchor.x) <= 2
+        && Math.abs(second.x - anchor.x) <= 2
+        && Math.abs(first.width - anchor.width) <= 4
+        && Math.abs(second.width - anchor.width) <= 4;
+    const stackedDown = Boolean(anchor && first && second)
+        && first.y > anchor.y
+        && second.y > first.y;
+    const blockers = [
+        ...(anchor ? [] : ['slot_anchor_pane_missing']),
+        ...(first ? [] : ['first_slot_pane_missing']),
+        ...(second ? [] : ['second_slot_pane_missing']),
+        ...(sameColumn ? [] : ['slot_panes_not_in_anchor_column']),
+        ...(stackedDown ? [] : ['slot_panes_not_stacked_down'])
+    ];
+    return {
+        ok: blockers.length === 0,
+        anchor,
+        first,
+        second,
+        same_right_column_x_range: sameColumn,
+        first_slot_y_greater_than_anchor: Boolean(anchor && first && first.y > anchor.y),
+        second_slot_y_greater_than_first: Boolean(first && second && second.y > first.y),
+        blockers
+    };
+}
+function evaluateNamedGeometry(panes) {
+    const main = panes.find((pane) => pane.title === 'orchestrator') || null;
+    const anchor = panes.find((pane) => pane.title === 'SLOTS') || null;
+    const first = panes.find((pane) => pane.title === 'slot-001') || null;
+    const second = panes.find((pane) => pane.title === 'slot-002') || null;
+    const sameColumn = Boolean(anchor && first && second)
+        && Math.abs(first.x - anchor.x) <= 2
+        && Math.abs(second.x - anchor.x) <= 2
+        && Math.abs(first.width - anchor.width) <= 4
+        && Math.abs(second.width - anchor.width) <= 4;
+    const rightOfMain = Boolean(main && anchor && first && second)
+        && anchor.x >= main.x + main.width - 2
+        && first.x >= main.x + main.width - 2
+        && second.x >= main.x + main.width - 2;
+    const stackedDown = Boolean(anchor && first && second)
+        && first.y > anchor.y
+        && second.y > first.y;
+    const blockers = [
+        ...(main ? [] : ['layout_main_pane_missing']),
+        ...(anchor ? [] : ['layout_slot_anchor_pane_missing']),
+        ...(first ? [] : ['layout_first_slot_pane_missing']),
+        ...(second ? [] : ['layout_second_slot_pane_missing']),
+        ...(sameColumn ? [] : ['layout_slot_panes_not_in_anchor_column']),
+        ...(rightOfMain ? [] : ['layout_slot_column_not_right_of_main']),
+        ...(stackedDown ? [] : ['layout_slot_panes_not_stacked_down'])
+    ];
+    return {
+        ok: blockers.length === 0,
+        source: 'zellij_layout_equivalent',
+        main,
+        anchor,
+        first,
+        second,
+        same_right_column_x_range: sameColumn,
+        right_of_main: rightOfMain,
+        first_slot_y_greater_than_anchor: Boolean(anchor && first && first.y > anchor.y),
+        second_slot_y_greater_than_first: Boolean(first && second && second.y > first.y),
+        blockers
+    };
+}
+function parsePaneRows(text) {
+    try {
+        const parsed = JSON.parse(String(text || '[]'));
+        const rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.panes) ? parsed.panes : [];
+        return rows.filter((row) => row && row.is_plugin !== true && row.exited !== true).map((row) => ({
+            pane_id: String(row.pane_id ?? row.paneId ?? row.id ?? ''),
+            title: String(row.title || row.name || row.pane_name || ''),
+            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),
+            raw: row
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function findPane(panes, paneId) {
+    const id = paneId == null ? '' : String(paneId);
+    if (!id)
+        return null;
+    const normalized = normalizePaneId(id);
+    return panes.find((pane) => normalizePaneId(pane.pane_id) === normalized) || null;
+}
+function buildFirstSlotLayout(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 first slot down 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="SLOTS" command="sh" {',
+        `                args "-lc" ${JSON.stringify(hold)}`,
+        '            }',
+        '            pane name="slot-001" command="sh" {',
+        `                args "-lc" ${JSON.stringify(hold)}`,
+        '            }',
+        '            pane name="slot-002" command="sh" {',
+        `                args "-lc" ${JSON.stringify(hold)}`,
+        '            }',
+        '        }',
+        '    }',
+        '}',
+        ''
+    ].join('\n');
+}
+function normalizePaneId(value) {
+    return String(value || '').replace(/^terminal_/, '').replace(/^Terminal\((\d+)\)$/i, '$1');
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value))
+        return value;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 //# sourceMappingURL=zellij-first-slot-down-stack-real-check.js.map

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

@@ -14,7 +14,7 @@ const report = {
     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("const directionRequested: 'right' | 'down' = 'down'")
         && worker.includes("'--near-current-pane'")
         && worker.includes('worker_direction_requested')
         && worker.includes('slot_column_anchor_pane_id'),

package/dist/scripts/zellij-slot-column-anchor-check.js

@@ -8,6 +8,24 @@ const rendered = renderZellijSlotColumnAnchor({
     queueDepth: 44,
     mode: 'compact-slots'
 });
+const roster = renderZellijSlotColumnAnchor({
+    activeWorkers: 1,
+    visiblePaneCap: 5,
+    headlessWorkers: 0,
+    queueDepth: 0,
+    mode: 'compact-slots',
+    workerRows: [
+        {
+            slotId: 'slot-004',
+            generationIndex: 1,
+            placement: 'zellij-pane',
+            status: 'running',
+            backend: 'codex-sdk',
+            task: 'Inspect Zellij slot UI assignment',
+            heartbeatAgeMs: 900
+        }
+    ]
+});
 const command = buildZellijSlotColumnAnchorCommand({
     nodePath: '/usr/bin/node',
     cliPath: '/repo/dist/bin/sks.js',
@@ -17,8 +35,11 @@ const command = buildZellijSlotColumnAnchorCommand({
     watch: true
 });
 const ok = rendered === 'SLOTS active 3/8 · headless 12 · q 44'
+    && roster.includes('SLOTS active 1/5 · headless 0 · q 0')
+    && roster.includes('slot-004 g1 running codex-sdk')
+    && roster.includes('Inspect Zellij slot UI assignment')
     && 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 });
+assertGate(ok, 'Zellij slot-column anchor must render compact SLOTS header plus live worker rows and build the CLI command', { rendered, roster, command });
+emitGate('zellij:slot-column-anchor', { rendered, roster, command });
 //# sourceMappingURL=zellij-slot-column-anchor-check.js.map

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

@@ -13,10 +13,12 @@ const report = {
     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'")
+    workers_stack_down_from_anchor: worker.includes("const directionRequested: 'right' | 'down' = 'down'")
         && 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'")
+        && swarm.includes('paneRecord.pane_kind')
+        && swarm.includes('paneRecord.scaling_primitive')
 };
 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);

package/dist/scripts/zellij-slot-renderer-proof-semantics-check.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { buildWorkerPaneArtifact } from '../core/zellij/zellij-worker-pane-manager.js';
+const root = process.cwd();
+const managerSource = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
+const swarmSource = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
+const base = {
+    root,
+    missionId: 'M-slot-renderer-proof-semantics',
+    sessionName: 'sks-M-slot-renderer-proof-semantics',
+    slotId: 'slot-001',
+    generationIndex: 1,
+    sessionId: 'slot-001-gen-1',
+    workerArtifactDir: 'sessions/slot-001/gen-1/worker',
+    resultPath: 'sessions/slot-001/gen-1/worker/worker-result.json',
+    heartbeatPath: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
+    patchEnvelopePath: 'sessions/slot-001/gen-1/worker/worker-patch-envelope.json',
+    stdoutLog: 'sessions/slot-001/gen-1/worker/worker.stdout.log',
+    stderrLog: 'sessions/slot-001/gen-1/worker/worker.stderr.log',
+    paneId: '101',
+    paneIdSource: 'zellij_worker_new_pane_stdout',
+    status: 'running',
+    blockers: []
+};
+const slotRenderer = buildWorkerPaneArtifact({
+    ...base,
+    workerCommand: 'node dist/bin/sks.js zellij-slot-pane --watch'
+});
+const workerCommand = buildWorkerPaneArtifact({
+    ...base,
+    slotId: 'slot-002',
+    sessionId: 'slot-002-gen-1',
+    workerCommand: 'node dist/bin/sks.js --agent worker --intake worker-intake.json --json'
+});
+const report = {
+    schema: 'sks.zellij-slot-renderer-proof-semantics-check.v1',
+    ok: true,
+    slot_renderer_pane_kind: slotRenderer.pane_kind,
+    slot_renderer_scaling_primitive: slotRenderer.scaling_primitive,
+    worker_pane_kind: workerCommand.pane_kind,
+    worker_scaling_primitive: workerCommand.scaling_primitive,
+    launch_ledger_uses_record_values: managerSource.includes('pane_kind: record.pane_kind') && managerSource.includes('scaling_primitive: record.scaling_primitive'),
+    swarm_uses_pane_record_values: swarmSource.includes('input.record.pane_kind = paneRecord.pane_kind') && swarmSource.includes('input.record.scaling_primitive = paneRecord.scaling_primitive'),
+    blockers: []
+};
+report.blockers = [
+    ...(slotRenderer.pane_kind === 'slot_status_renderer' ? [] : ['slot_renderer_pane_kind_not_distinct']),
+    ...(slotRenderer.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer' ? [] : ['slot_renderer_scaling_primitive_not_distinct']),
+    ...(workerCommand.pane_kind === 'worker_codex_sdk' ? [] : ['worker_pane_kind_regressed']),
+    ...(workerCommand.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' ? [] : ['worker_scaling_primitive_regressed']),
+    ...(report.launch_ledger_uses_record_values ? [] : ['launch_ledger_semantics_not_record_backed']),
+    ...(report.swarm_uses_pane_record_values ? [] : ['swarm_semantics_not_record_backed'])
+];
+report.ok = report.blockers.length === 0;
+assertGate(report.ok, 'Zellij compact slot renderer proof semantics must distinguish status renderer panes from worker command panes', report);
+emitGate('zellij:slot-renderer-proof-semantics', report);
+//# sourceMappingURL=zellij-slot-renderer-proof-semantics-check.js.map

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

@@ -45,6 +45,26 @@ const artifact = buildWorkerPaneArtifact({
     streamEventCount: 4,
     structuredOutputValid: true,
     status: 'running',
+    workerCommand: 'node dist/bin/sks.js --agent worker',
+    blockers: []
+});
+const slotRendererArtifact = buildWorkerPaneArtifact({
+    root,
+    missionId: 'M-worker-pane-manager',
+    sessionName: 'sks-M-worker-pane-manager',
+    slotId: 'slot-002',
+    generationIndex: 1,
+    sessionId: 'slot-002-gen-1',
+    workerArtifactDir: 'sessions/slot-002/gen-1/worker',
+    resultPath: 'sessions/slot-002/gen-1/worker/worker-result.json',
+    heartbeatPath: 'sessions/slot-002/gen-1/worker/worker-heartbeat.jsonl',
+    patchEnvelopePath: 'sessions/slot-002/gen-1/worker/worker-patch-envelope.json',
+    stdoutLog: 'sessions/slot-002/gen-1/worker/worker.stdout.log',
+    stderrLog: 'sessions/slot-002/gen-1/worker/worker.stderr.log',
+    paneId: '43',
+    paneIdSource: 'zellij_worker_new_pane_stdout',
+    status: 'running',
+    workerCommand: 'node dist/bin/sks.js zellij-slot-pane --watch',
     blockers: []
 });
 const spawnOrder = evaluateZellijWorkerPaneSpawnOrder([
@@ -70,11 +90,13 @@ const ok = artifact.ok
     && artifact.pane_kind === 'worker_codex_sdk'
     && artifact.provider === 'codex-lb'
     && artifact.service_tier === 'fast'
-    && artifact.direction_requested === 'right'
+    && artifact.direction_requested === 'down'
     && artifact.direction_applied === 'not_applied'
     && artifact.sdk_thread_id === 'sdk-thread-7'
     && artifact.stream_event_count === 4
     && artifact.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+    && slotRendererArtifact.pane_kind === 'slot_status_renderer'
+    && slotRendererArtifact.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer'
     && syntheticRejected
     && spawnOrder.ok
     && sourceOk;

package/dist/scripts/zellij-worker-pane-real-ui-blackbox.js

@@ -56,7 +56,7 @@ try {
             "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);"
+            "setTimeout(()=>process.exit(0), 30000);"
         ].join('');
         const record = await workerPane.openWorkerPane({
             root: ledgerRoot,
@@ -98,9 +98,21 @@ try {
     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 workerKindRecords = records.filter((record) => record.pane_kind === 'worker_codex_sdk').length;
+    const workerPrimitiveRecords = records.filter((record) => record.scaling_primitive === 'native_cli_process_in_zellij_worker_pane').length;
+    const recordProofOk = records.length === 3
+        && realPaneIds === 3
+        && workerKindRecords === 3
+        && workerPrimitiveRecords === 3
+        && requestedTitleCommands === 3
+        && heartbeatSeen === 3
+        && resultSeen === 3;
+    const listPanesVisibilityOk = matchedTitles === 3
+        || commandMatchedWorkers === 3
+        || terminalRows.length >= beforeTerminalCount + 3;
     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,
+        ok: recordProofOk && dump.ok,
         real_required: true,
         zellij_version: available.stdout.trim(),
         mission_id: missionId,
@@ -111,12 +123,16 @@ try {
         terminal_pane_count: terminalRows.length,
         worker_pane_count: records.length,
         real_pane_ids: realPaneIds,
+        worker_kind_records: workerKindRecords,
+        worker_primitive_records: workerPrimitiveRecords,
         matched_titles: matchedTitles,
         command_matched_workers: commandMatchedWorkers,
         requested_title_commands: requestedTitleCommands,
         heartbeat_seen: heartbeatSeen,
         result_seen: resultSeen,
         dump_screen_ok: dump.ok,
+        record_proof_ok: recordProofOk,
+        list_panes_visibility_ok: listPanesVisibilityOk,
         pane_titles: records.map((record) => record.pane_title),
         pane_id_sources: records.map((record) => record.pane_id_source),
         proof_root: ledgerRoot,
@@ -125,11 +141,12 @@ try {
     if (!report.ok) {
         report.blockers = [
             ...(realPaneIds === 3 ? [] : ['real_worker_pane_ids_missing']),
+            ...(workerKindRecords === 3 ? [] : ['worker_pane_kind_missing']),
+            ...(workerPrimitiveRecords === 3 ? [] : ['worker_pane_scaling_primitive_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'])
+            ...(dump.ok ? [] : ['worker_pane_dump_screen_failed'])
         ];
     }
     fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -297,6 +297,7 @@
     "local-llm:warmup": "node ./dist/scripts/local-llm-warmup-check.js",
     "local-llm:all-pipelines": "node ./dist/scripts/local-llm-all-pipelines-check.js",
     "local-collab:all-pipelines-final-gpt": "node ./dist/scripts/local-collab-all-pipelines-final-gpt-check.js",
+    "local-collab:worktree-gpt-final-apply-policy": "node ./dist/scripts/local-collab-worktree-gpt-final-apply-policy-check.js",
     "python-sdk:capability": "node ./dist/scripts/python-codex-sdk-capability-check.js",
     "python-sdk:stream-bridge": "node ./dist/scripts/python-codex-sdk-stream-bridge-check.js",
     "python-sdk:sandbox-policy": "node ./dist/scripts/python-codex-sdk-sandbox-policy-check.js",
@@ -313,7 +314,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: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:real-check": "node ./dist/scripts/release-real-check.js",
     "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",
@@ -478,6 +479,7 @@
     "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:allocation-runtime-wiring": "node ./dist/scripts/naruto-allocation-runtime-wiring-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",
@@ -502,6 +504,7 @@
     "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:slot-renderer-proof-semantics": "node ./dist/scripts/zellij-slot-renderer-proof-semantics-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",