sneakoscope 2.0.11 → 2.0.13

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,42 @@ 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 overflow = renderZellijSlotColumnAnchor({
+    activeWorkers: 6,
+    visiblePaneCap: 5,
+    headlessWorkers: 1,
+    queueDepth: 0,
+    mode: 'compact-slots',
+    workerRows: [
+        {
+            slotId: 'slot-009',
+            generationIndex: 1,
+            placement: 'headless',
+            status: 'running',
+            backend: 'local-llm',
+            task: 'Waiting for a visible slot pane',
+            heartbeatAgeMs: 1200
+        }
+    ]
+});
 const command = buildZellijSlotColumnAnchorCommand({
     nodePath: '/usr/bin/node',
     cliPath: '/repo/dist/bin/sks.js',
@@ -16,9 +52,15 @@ const command = buildZellijSlotColumnAnchorCommand({
     artifactRoot: '/repo/.sneakoscope/missions/M-check/agents',
     watch: true
 });
-const ok = rendered === 'SLOTS active 3/8 · headless 12 · q 44'
+const ok = rendered.includes('SLOTS active 3/8 · headless 12 · q 44')
+    && rendered.includes('visible slot panes stack below this anchor')
+    && roster.includes('SLOTS active 1/5 · headless 0 · q 0')
+    && roster.includes('visible slot panes stack below this anchor')
+    && !roster.includes('slot-004 g1 running codex-sdk')
+    && overflow.includes('slot-009 g1 running local-llm')
+    && overflow.includes('Waiting for a visible slot pane')
     && 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 stay an anchor while slot workers render in dedicated stacked panes', { rendered, roster, overflow, command });
+emitGate('zellij:slot-column-anchor', { rendered, roster, overflow, 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-pane-renderer-check.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 // @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 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({
@@ -8,14 +11,72 @@ const text = renderer.renderZellijSlotPane({
     role: 'implementer',
     backend: 'local-llm',
     status: 'coding',
+    fastMode: true,
+    serviceTier: 'fast',
+    provider: 'codex-lb',
+    authMode: 'codex_lb_key',
+    model: 'gpt-5.5',
+    reasoningEffort: 'medium',
     currentFile: 'src/core/foo.ts',
+    currentTask: 'Editing Zellij slot pane renderer',
+    changedFiles: ['src/core/foo.ts', 'src/core/bar.ts'],
     patchStatus: 'candidate',
     verifyStatus: 'queued',
     heartbeatAgeMs: 2000,
     worktreeId: 'WT-0007',
+    eventLines: ['running: tool apply_patch', 'running: file src/core/foo.ts'],
+    stdoutTail: ['renderer updated live pane output'],
     mode: 'compact-slots'
 });
 const lines = text.split(/\n/);
+const artifactDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-slot-pane-renderer-'));
+await fs.writeFile(path.join(artifactDir, 'worker-intake.json'), JSON.stringify({
+    agent: { session_id: 'session-slot-003', role: 'implementer' },
+    backend: 'codex-sdk',
+    fast_mode: true,
+    service_tier: 'fast',
+    slice: {
+        title: 'Hydrate live slot pane from artifacts',
+        write_paths: ['src/core/zellij/zellij-slot-pane-renderer.ts']
+    },
+    worktree: { id: 'WT-0007' }
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'worker-fast-mode.json'), JSON.stringify({
+    fast_mode: true,
+    service_tier: 'fast'
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'zellij-worker-pane.json'), JSON.stringify({
+    provider: 'codex-lb',
+    service_tier: 'fast',
+    provider_context: {
+        provider: 'codex-lb',
+        auth_mode: 'codex_lb_key'
+    }
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'codex-control-proof.json'), JSON.stringify({
+    config: {
+        model: 'gpt-5.5',
+        model_provider: 'codex-lb',
+        service_tier: 'fast',
+        model_reasoning_effort: 'medium'
+    }
+}, null, 2));
+await fs.writeFile(path.join(artifactDir, 'worker-heartbeat.jsonl'), `${JSON.stringify({ event: 'started', status: 'running' })}\n`);
+await fs.writeFile(path.join(artifactDir, 'codex-sdk-events.jsonl'), `${JSON.stringify({
+    sdk_event_type: 'item.completed',
+    lane_status: 'running',
+    current_tool: 'apply_patch',
+    current_file: 'src/core/zellij/zellij-slot-pane-renderer.ts',
+    message_tail: null
+})}\n`);
+await fs.writeFile(path.join(artifactDir, 'worker.stdout.log'), 'renderer stdout tail\n');
+const hydrated = await renderer.renderZellijSlotPaneFromArtifacts({
+    artifactDir,
+    slotId: 'slot-003',
+    generationIndex: 2,
+    mode: 'compact-slots'
+});
+await fs.rm(artifactDir, { recursive: true, force: true });
 const command = renderer.buildZellijSlotPaneCommand({
     cliPath: '/repo/dist/bin/sks.js',
     missionId: 'M-test',
@@ -27,12 +88,19 @@ const command = renderer.buildZellijSlotPaneCommand({
 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),
+    max_compact_lines: 17,
+    contains_slot: /LIVE SLOT slot-003/.test(text) && /slot: slot-003 \/ gen-2/.test(text),
+    contains_status: /coding/.test(text),
+    contains_runtime: /runtime: fast on/.test(text) && /model: gpt-5\.5/.test(text) && /provider: codex-lb/.test(text),
+    contains_files: /src\/core\/foo\.ts/.test(text) && /src\/core\/bar\.ts/.test(text),
+    contains_live_event: /event: running:/.test(text),
+    artifact_hydrates_runtime: /runtime: fast on/.test(hydrated) && /model: gpt-5\.5/.test(hydrated) && /reasoning: medium/.test(hydrated) && /auth: codex_lb_key/.test(hydrated),
+    artifact_hydrates_live_event: /tool apply_patch/.test(hydrated) && /renderer stdout tail/.test(hydrated),
+    artifact_hydrates_planned_file: /zellij-slot-pane-renderer\.ts/.test(hydrated),
     command_uses_slot_pane: command.includes('zellij-slot-pane') && command.includes('--watch'),
-    snapshot: text
+    snapshot: text,
+    hydrated_snapshot: hydrated
 };
-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);
+assertGate(lines.length <= 17 && report.contains_slot && report.contains_status && report.contains_runtime && report.contains_files && report.contains_live_event && report.artifact_hydrates_runtime && report.artifact_hydrates_live_event && report.artifact_hydrates_planned_file && report.command_uses_slot_pane, 'compact slot pane renderer must render one live work pane per slot', report);
 emitGate('zellij:compact-slot-renderer', report);
 //# sourceMappingURL=zellij-slot-pane-renderer-check.js.map

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;