sneakoscope 2.0.10 → 2.0.12

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

@@ -0,0 +1,356 @@
+#!/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', {
+        ok: true,
+        status: 'skipped',
+        reason: 'SKS_REQUIRE_ZELLIJ_not_set'
+    });
+    process.exit(0);
+}
+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

@@ -12,11 +12,16 @@ const report = {
     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_opt_in: source.includes('zellijUiModeCreatesDashboard') && source.includes('dashboard_created: false'),
-    worker_direction_stack: worker.includes("'--direction', directionRequested") && worker.includes("rightColumn?.focusPaneId ? 'down' : 'right'") && worker.includes("'--near-current-pane'"),
+    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' = 'down'")
+        && 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_opt_in && report.worker_direction_stack && report.headless_overflow && report.schema_exists;
+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,45 @@
+#!/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 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',
+    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'
+    && 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 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

@@ -12,9 +12,13 @@ const report = {
     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_can_open_right: worker.includes("rightColumn?.focusPaneId ? 'down' : 'right'"),
-    second_slot_down_only_with_focus: worker.includes("directionRequested === 'down' ? ['--near-current-pane'] : []"),
+    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' = '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-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/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 });