sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = process.cwd();
+const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
+const rightColumn = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
+const registry = fs.readFileSync(path.join(root, 'src/cli/command-registry.ts'), 'utf8');
+const checks = {
+    command_registered: registry.includes("'zellij-slot-column-anchor'"),
+    anchor_command_used: worker.includes('buildZellijSlotColumnAnchorCommand'),
+    anchor_created_right: worker.includes("'--direction', 'right', '--name', 'SLOTS'"),
+    worker_down_only_for_right_column: worker.includes("const directionRequested: 'right' | 'down' = 'down'"),
+    worker_new_pane_uses_down_direction: worker.includes("'--direction', directionRequested") && !worker.includes("'--direction', 'right', '--name', 'SKS "),
+    legacy_first_worker_right_removed: !worker.includes("rightColumn?.focusPaneId ? 'down' : 'right'"),
+    worker_direction_fields: worker.includes('worker_direction_requested') && worker.includes('worker_direction_applied'),
+    state_anchor_field: rightColumn.includes('slot_column_anchor_pane_id')
+};
+assertGate(Object.values(checks).every(Boolean), 'First visible Zellij worker must stack down from a right-column SLOTS anchor', checks);
+emitGate('zellij:first-slot-down-stack', checks);
+//# sourceMappingURL=zellij-first-slot-down-stack-check.js.map

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

@@ -0,0 +1,349 @@
+#!/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 === 'worker_codex_sdk',
+            record1.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+        ];
+        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,
+        '-e',
+        `console.log(${JSON.stringify(`${slotId} live worker pane`)})`
+    ].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: 'worker',
+        rightColumnMode: 'spawn-on-first-worker',
+        visiblePaneCap: 2,
+        uiMode: 'full-debug'
+    });
+}
+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-homebrew-policy-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('zellij:homebrew-policy');
+//# sourceMappingURL=zellij-homebrew-policy-check.js.map

package/dist/scripts/zellij-initial-main-only-blackbox.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const mad = fs.readFileSync(path.join(root, 'src/core/commands/mad-sks-command.ts'), 'utf8');
+const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
+const launcher = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-launcher.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-initial-main-only-blackbox.v1',
+    ok: true,
+    mad_slot_zero: /launchMadZellijUi\([\s\S]*slotCount:\s*0/.test(mad),
+    mad_no_launch_dashboard: !/launch\.dashboard_pane\s*=\s*await openZellijDashboardPane/.test(mad),
+    mad_initial_ui_artifact: mad.includes('zellij-initial-ui.json') && mad.includes("dashboard_created: false"),
+    naruto_slot_zero: /launchZellijLayout\([\s\S]*slotCount:\s*0/.test(naruto),
+    naruto_no_launch_dashboard: !/liveZellij\.dashboard_pane\s*=\s*await openZellijDashboardPane/.test(naruto),
+    naruto_initial_ui_artifact: naruto.includes('zellij-initial-ui.json') && naruto.includes("dashboard_created: false"),
+    launcher_allows_zero: launcher.includes('slotCount: opts.slotCount || 1')
+};
+report.ok = report.mad_slot_zero
+    && report.mad_no_launch_dashboard
+    && report.mad_initial_ui_artifact
+    && report.naruto_slot_zero
+    && report.naruto_no_launch_dashboard
+    && report.naruto_initial_ui_artifact;
+assertGate(report.ok, 'Zellij initial UI must be main-only with no dashboard/worker pane at launch', report);
+emitGate('zellij:initial-main-only-blackbox', report);
+//# sourceMappingURL=zellij-initial-main-only-blackbox.js.map

package/dist/scripts/zellij-lane-renderer-check.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-lane-renderer.js')).href);
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-lane-'));
+await fs.writeFile(path.join(tmp, 'agent-scheduler-state.json'), `${JSON.stringify({ target_active_slots: 1, active_slot_count: 1, pending_count: 2, completed_count: 3 }, null, 2)}\n`);
+await fs.writeFile(path.join(tmp, 'agent-native-cli-session-swarm.json'), `${JSON.stringify({
+    schema: 'sks.agent-native-cli-session-swarm.v1',
+    records: [{
+            slot_id: 'slot-001',
+            generation_index: 1,
+            status: 'running',
+            stdout_log: 'sessions/slot-001/gen-1/worker/worker.stdout.log',
+            stderr_log: 'sessions/slot-001/gen-1/worker/worker.stderr.log',
+            heartbeat_path: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
+            result_path: 'sessions/slot-001/gen-1/worker/worker-result.json',
+            worker_intake: 'sessions/slot-001/gen-1/worker/worker-intake.json',
+            worker_artifact_dir: 'sessions/slot-001/gen-1/worker'
+        }]
+}, null, 2)}\n`);
+await fs.writeFile(path.join(tmp, 'agent-patch-queue.json'), `${JSON.stringify({ queue: [{ slot_id: 'slot-001', target_file: 'src/core/example.ts' }] }, null, 2)}\n`);
+await fs.writeFile(path.join(tmp, 'agent-proof-evidence.json'), `${JSON.stringify({ ok: false, blockers: ['fixture_blocker_visible'] }, null, 2)}\n`);
+await fs.mkdir(path.join(tmp, 'lanes', 'slot-001'), { recursive: true });
+await fs.mkdir(path.join(tmp, 'sessions', 'slot-001', 'gen-1', 'worker'), { recursive: true });
+await fs.writeFile(path.join(tmp, 'sessions', 'slot-001', 'gen-1', 'worker', 'worker.stdout.log'), 'worker boot\nnative worker says hello\n');
+await fs.writeFile(path.join(tmp, 'sessions', 'slot-001', 'gen-1', 'worker', 'worker.stderr.log'), 'worker stderr tail visible\n');
+await fs.writeFile(path.join(tmp, 'sessions', 'slot-001', 'gen-1', 'worker', 'worker-heartbeat.jsonl'), `${JSON.stringify({ event: 'started', ts: '2026-06-02T00:00:00.000Z', slot_id: 'slot-001' })}\n`);
+await fs.writeFile(path.join(tmp, 'sessions', 'slot-001', 'gen-1', 'worker', 'worker-result.json'), `${JSON.stringify({ status: 'done', summary: 'live worker connected', blockers: [] }, null, 2)}\n`);
+await fs.writeFile(path.join(tmp, 'sessions', 'slot-001', 'gen-1', 'worker', 'worker-intake.json'), `${JSON.stringify({ slot_id: 'slot-001', generation_index: 1, slice: { target_file: 'src/core/example.ts' } }, null, 2)}\n`);
+await fs.writeFile(path.join(tmp, 'lanes', 'slot-001', 'command-inbox.jsonl'), `${JSON.stringify({ schema: 'sks.zellij-lane-command.v1', id: 'cmd-fixture', kind: 'operator_text', payload: { text: 'hello' } })}\n`);
+const frame = await mod.renderZellijLaneFrame({ missionId: 'M-lane', slot: 'slot-001', ledgerRoot: tmp, once: true, color: false });
+const ackText = await fs.readFile(path.join(tmp, 'lanes', 'slot-001', 'command-ack.jsonl'), 'utf8');
+const fastProject = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-fast-on-'));
+const fastProjectLedger = path.join(fastProject, '.sneakoscope', 'missions', 'M-fast-on', 'agents');
+await fs.mkdir(path.join(fastProject, '.sneakoscope', 'state'), { recursive: true });
+await fs.mkdir(fastProjectLedger, { recursive: true });
+await fs.writeFile(path.join(fastProject, '.sneakoscope', 'state', 'fast-mode.json'), `${JSON.stringify({
+    schema: 'sks.fast-mode-preference.v1',
+    updated_at: '2026-06-01T00:00:00.000Z',
+    mode: 'fast',
+    fast_mode: true,
+    service_tier: 'fast',
+    codex_desktop_service_tier: 'priority',
+    source: 'zellij-lane-renderer-check'
+}, null, 2)}\n`);
+const fastFrame = await mod.renderZellijLaneFrame({ missionId: 'M-fast-on', slot: 'slot-001', ledgerRoot: fastProjectLedger, once: true, color: false });
+const project = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-fast-off-'));
+const projectLedger = path.join(project, '.sneakoscope', 'missions', 'M-fast-off', 'agents');
+await fs.mkdir(path.join(project, '.sneakoscope', 'state'), { recursive: true });
+await fs.mkdir(projectLedger, { recursive: true });
+await fs.writeFile(path.join(project, '.sneakoscope', 'state', 'fast-mode.json'), `${JSON.stringify({
+    schema: 'sks.fast-mode-preference.v1',
+    updated_at: '2026-06-01T00:00:00.000Z',
+    mode: 'standard',
+    fast_mode: false,
+    service_tier: 'standard',
+    codex_desktop_service_tier: 'default',
+    source: 'zellij-lane-renderer-check'
+}, null, 2)}\n`);
+const offFrame = await mod.renderZellijLaneFrame({ missionId: 'M-fast-off', slot: 'slot-001', ledgerRoot: projectLedger, once: true, color: false });
+const required = ['SKS Lane', 'Mission', 'Mode', 'Fast', 'off · service_tier=standard', 'Workers', 'slot-001 gen-1 running', 'Codex child', 'live running · result done', 'Current', 'Queue', 'Safety', 'Blockers', 'Reports', 'Keys:', 'src/core/example.ts', 'fixture_blocker_visible', 'live worker:', 'native worker says hello', 'worker stderr tail visible'];
+const fastRequired = ['Fast', 'on · service_tier=fast'];
+const offRequired = ['Fast', 'off · service_tier=standard'];
+const commandBusOk = frame.report.command_bus?.mode === 'jsonl_nonblocking' && frame.report.command_bus?.newly_acked_count === 1 && ackText.includes('cmd-fixture');
+const ok = required.every((item) => frame.frame.includes(item)) && fastRequired.every((item) => fastFrame.frame.includes(item)) && offRequired.every((item) => offFrame.frame.includes(item)) && frame.report.stdout_only === true && commandBusOk;
+const report = { schema: 'sks.zellij-lane-renderer-check.v1', ok, frame: frame.report, fast_on_frame: fastFrame.report, fast_off_frame: offFrame.report, command_bus_ok: commandBusOk };
+await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'zellij-lane-renderer.json'), `${JSON.stringify(report, null, 2)}\n`);
+emit(report);
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.zellij-lane-renderer-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=zellij-lane-renderer-check.js.map

package/dist/scripts/zellij-launch-command-truth-check.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { root, assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+// Locks the single documented Zellij launch command across code + changelog and
+// forbids the stale `zellij --session <s> --layout <l>` launch pattern.
+const launcherText = readText('src/core/zellij/zellij-launcher.ts');
+const builderText = readText('src/core/zellij/zellij-layout-builder.ts');
+for (const [rel, text] of [
+    ['src/core/zellij/zellij-launcher.ts', launcherText],
+    ['src/core/zellij/zellij-layout-builder.ts', builderText]
+]) {
+    assertGate(text.includes('--create-background'), `missing --create-background in ${rel}`, { file: rel });
+    assertGate(text.includes('--default-layout'), `missing --default-layout in ${rel}`, { file: rel });
+}
+// The launcher must use the attach form: the argv array literal begins with
+// 'attach', '--create-background'.
+assertGate(launcherText.includes("'attach', '--create-background'"), "launcher must use the attach form: \"'attach', '--create-background'\"", { file: 'src/core/zellij/zellij-launcher.ts' });
+// Stale-pattern ban across src/ and scripts/ (.ts/.mjs/.js only). The stale
+// launch is `zellij --session <s> --layout <l>`; the regex matches that line
+// shape. zellij-screen-proof.ts uses ['--session', name, 'action',
+// 'dump-screen', ...] (no --layout) so it is correctly ignored.
+const STALE_RE = /--session[^\n]*--layout/;
+const exts = new Set(['.ts', '.mjs', '.js']);
+const scanRoots = ['src', 'scripts'];
+// This gate's own source necessarily contains the stale pattern (the regex +
+// the doc comment), so it must exclude itself from the scan.
+const SELF_FILE = 'zellij-launch-command-truth-check.ts';
+const offenders = [];
+let filesScanned = 0;
+function walk(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(full);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (entry.name === SELF_FILE)
+            continue;
+        if (!exts.has(path.extname(entry.name)))
+            continue;
+        filesScanned += 1;
+        const text = fs.readFileSync(full, 'utf8');
+        if (STALE_RE.test(text))
+            offenders.push(path.relative(root, full));
+    }
+}
+for (const scanRoot of scanRoots)
+    walk(path.join(root, scanRoot));
+assertGate(offenders.length === 0, 'stale `zellij --session <s> --layout <l>` launch pattern found', { offenders, pattern: String(STALE_RE) });
+// Changelog agreement: the documented command in CHANGELOG must match the code.
+const changelog = readText('CHANGELOG.md');
+assertGate(changelog.includes('--create-background'), 'CHANGELOG.md missing --create-background', {});
+assertGate(changelog.includes('--default-layout'), 'CHANGELOG.md missing --default-layout', {});
+const report = {
+    schema: 'sks.zellij-launch-command-truth.v1',
+    ok: true,
+    launcher_ok: true,
+    files_scanned: filesScanned,
+    offenders
+};
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'zellij-launch-command-truth.json'), `${JSON.stringify(report, null, 2)}\n`);
+emitGate('zellij:launch-command-truth', { launcher_ok: true, files_scanned: filesScanned });
+//# sourceMappingURL=zellij-launch-command-truth-check.js.map

package/dist/scripts/zellij-layout-valid-check.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const layoutMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-layout-builder.js')).href);
+const capabilityMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-capability.js')).href);
+const commandMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
+const built = layoutMod.buildZellijLayoutKdl({ missionId: 'M-layout-check', ledgerRoot: path.join(root, '.sneakoscope', 'tmp', 'layout-check'), cwd: root, kind: 'agent', slotCount: 2 });
+const staticValidation = layoutMod.validateZellijLayoutKdl(built.layout_kdl);
+const spawnOnDemandOk = built.initial_worker_panes === 0
+    && built.lane_runtime_policies.length === 0
+    && built.layout_kdl.includes('pane name="orchestrator"')
+    && !built.layout_kdl.includes('zellij-lane')
+    && !(built.layout_kdl.match(/pane name="slot-/g) || []).length
+    && built.lane_dispatch_policy?.mode === 'jsonl_nonblocking'
+    && built.lane_dispatch_policy?.fifo_policy === 'disabled_to_avoid_writer_blocking';
+const narutoFanoutLayout = layoutMod.buildZellijLayoutKdl({
+    missionId: 'M-layout-naruto-fanout',
+    ledgerRoot: path.join(root, '.sneakoscope', 'tmp', 'layout-naruto-fanout'),
+    cwd: root,
+    kind: 'naruto',
+    slotCount: 24
+});
+const narutoFanoutPaneCount = (narutoFanoutLayout.layout_kdl.match(/pane name="slot-/g) || []).length;
+const kindsValidated = ['mad', 'agent', 'team', 'naruto'].map((kind) => {
+    const b = layoutMod.buildZellijLayoutKdl({
+        missionId: `M-layout-${kind}`,
+        ledgerRoot: path.join(root, '.sneakoscope', 'tmp', `layout-${kind}`),
+        cwd: root,
+        kind,
+        slotCount: 2,
+        codexArgs: kind === 'mad' ? ['--profile', 'sks-mad-high', '-c', 'service_tier=fast'] : []
+    });
+    const hasCodexPane = kind !== 'mad' || (b.main_pane_kind === 'codex_interactive' && /exec\s+'?codex'?/.test(b.layout_kdl) && b.layout_kdl.includes('sks-mad-high') && b.layout_kdl.includes('--no-alt-screen'));
+    const noLanePane = !b.layout_kdl.includes('zellij-lane') && !(b.layout_kdl.match(/pane name="slot-/g) || []).length;
+    return { kind, ok: layoutMod.validateZellijLayoutKdl(b.layout_kdl).ok && hasCodexPane && noLanePane && b.initial_worker_panes === 0, main_pane_kind: b.main_pane_kind, has_codex_pane: hasCodexPane, no_lane_pane: noLanePane };
+});
+const allKindsOk = kindsValidated.every((k) => k.ok);
+const invalidValidation = layoutMod.validateZellijLayoutKdl('layout { pane command="zellij-lane" {');
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-layout-'));
+const layoutPath = path.join(tmp, 'layout.kdl');
+await fs.writeFile(layoutPath, built.layout_kdl, 'utf8');
+const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
+const capability = await capabilityMod.checkZellijCapability({ root, require: requireReal, writeReport: true });
+const sessionName = 'sks-layout-check';
+if (capability.status === 'ok')
+    await commandMod.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 2500, optional: true });
+const realRun = capability.status === 'ok'
+    ? {
+        create_background: await commandMod.runZellij(['attach', '--create-background', sessionName, 'options', '--default-layout', layoutPath], { cwd: root, timeoutMs: 5000, optional: !requireReal }),
+        cleanup: null,
+        ok: false
+    }
+    : null;
+if (realRun) {
+    realRun.cleanup = await commandMod.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+    realRun.ok = realRun.create_background.ok === true;
+}
+const ok = staticValidation.ok
+    && spawnOnDemandOk
+    && allKindsOk
+    && layoutMod.validateZellijLayoutKdl(narutoFanoutLayout.layout_kdl).ok
+    && narutoFanoutPaneCount === 0
+    && invalidValidation.ok === false
+    && capability.ok
+    && (requireReal ? realRun?.ok === true : true);
+emit({
+    schema: 'sks.zellij-layout-valid-check.v1',
+    ok,
+    layout: { ...built, layout_kdl: undefined, layout_path: layoutPath },
+    spawn_on_demand_ok: spawnOnDemandOk,
+    kinds_validated: kindsValidated,
+    naruto_fanout_layout: { slot_count: narutoFanoutLayout.slot_count, pane_count: narutoFanoutPaneCount, initial_worker_panes: narutoFanoutLayout.initial_worker_panes },
+    static_validation: staticValidation,
+    invalid_fixture: invalidValidation,
+    capability,
+    real_run: realRun,
+    integration_optional: !requireReal,
+    blockers: ok ? [] : ['zellij_layout_valid_check_failed']
+});
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.zellij-layout-valid-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=zellij-layout-valid-check.js.map