sneakoscope 2.0.13 → 2.0.15

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

@@ -1,28 +0,0 @@
-#!/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

@@ -1,65 +0,0 @@
-#!/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 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', 'on · service_tier=fast', '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 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)) && 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_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

@@ -1,75 +0,0 @@
-#!/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

@@ -1,90 +0,0 @@
-#!/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

package/dist/scripts/zellij-pane-proof-check.js

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-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-pane-proof.js')).href);
-const args = process.argv.slice(2);
-const missionId = readArg(args, '--mission');
-const sessionName = readArg(args, '--session');
-const expectedLaneArg = readArg(args, '--expected-lanes');
-const expectedLaneCount = expectedLaneArg === null ? undefined : Number(expectedLaneArg);
-const report = await mod.writeZellijPaneProof(root, {
-    require: process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real'),
-    missionId: missionId || undefined,
-    sessionName: sessionName || undefined,
-    expectedLaneCount,
-    ledgerRoot: missionId ? path.join(root, '.sneakoscope', 'missions', missionId) : undefined
-});
-const positive = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh -lc sks status --json', cwd: root, exited: false, x: 0, y: 0, width: 80, height: 24 },
-    { pane_id: '2', name: 'slot-001', command: 'sh -lc sks zellij-lane --mission M --slot slot-001', cwd: root, exited: false, x: 80, y: 0, width: 40, height: 24 }
-]), { expectedLaneCount: 1, expectedCwd: root });
-const missingLane = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh', cwd: root, exited: false }
-]), { expectedLaneCount: 1, expectedCwd: root });
-const exitedLane = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh', cwd: root, exited: false },
-    { pane_id: '2', name: 'slot-001', command: 'sks zellij-lane --mission M --slot slot-001', cwd: root, exited: true }
-]), { expectedLaneCount: 1, expectedCwd: root });
-const madCodexMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'codex --profile sks-mad-high', cwd: root, exited: false },
-    { pane_id: '2', name: 'slot-001', command: 'sks zellij-lane --mission M --slot slot-001', cwd: root, exited: false }
-]), { expectedLaneCount: 1, expectedCwd: root, expectedMainCommandIncludes: 'codex' });
-const madShellMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh -lc sks status --json', cwd: root, exited: false },
-    { pane_id: '2', name: 'slot-001', command: 'sks zellij-lane --mission M --slot slot-001', cwd: root, exited: false }
-]), { expectedLaneCount: 1, expectedCwd: root, expectedMainCommandIncludes: 'codex' });
-const codexLbOnlyMain = mod.evaluateZellijPaneProofRows(mod.normalizeZellijPaneRows([
-    { pane_id: '1', name: 'orchestrator', command: 'sh -lc model_provider="codex-lb"', cwd: root, exited: false },
-    { pane_id: '2', name: 'slot-001', command: 'sks zellij-lane --mission M --slot slot-001', cwd: root, exited: false }
-]), { expectedLaneCount: 1, expectedCwd: root, expectedMainCommandIncludes: 'codex' });
-const fixtureOk = positive.blockers.length === 0
-    && missingLane.blockers.includes('zellij_lane_pane_missing')
-    && exitedLane.blockers.some((blocker) => blocker.startsWith('zellij_lane_pane_exited'))
-    && madCodexMain.blockers.length === 0
-    && madShellMain.blockers.includes('zellij_main_pane_unexpected_command:codex')
-    && codexLbOnlyMain.blockers.includes('zellij_main_pane_unexpected_command:codex');
-emit({ ...report, fixture_ok: fixtureOk, fixture_results: { positive, missingLane, exitedLane, madCodexMain, madShellMain, codexLbOnlyMain }, ok: report.ok && fixtureOk });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-pane-proof-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}
-//# sourceMappingURL=zellij-pane-proof-check.js.map

package/dist/scripts/zellij-real-session-cleanup-check.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: false });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const args = process.argv.slice(2);
-const sessionName = readArg(args, '--session') || 'sks-real';
-const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-const result = await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-emit({ schema: 'sks.zellij-real-session-cleanup-check.v1', ok: result.ok === true || result.exit_code !== 0, session_name: sessionName, result });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-real-session-cleanup-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}
-//# sourceMappingURL=zellij-real-session-cleanup-check.js.map

package/dist/scripts/zellij-real-session-heartbeat-check.js

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { root, assertGate, emitGate, importDist, readText } from './sks-1-18-gate-lib.js';
-// Proves the heartbeat-timeout-as-blocker LOGIC hermetically (no real Zellij):
-// a missing/empty heartbeat must yield a decisive timeout blocker so the
-// real-session launch gate can fail directly instead of hanging.
-const sp = await importDist('core/zellij/zellij-screen-proof.js');
-const { waitForLaneHeartbeat, ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER } = sp;
-assertGate(ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER === 'zellij_lane_heartbeat_timeout', 'ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER mismatch', { actual: ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER });
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-hb-'));
-// Case PRESENT: a heartbeat file with a non-empty JSON line resolves ok fast.
-const presentPath = path.join(tmp, 'present-heartbeat.jsonl');
-await fs.writeFile(presentPath, `${JSON.stringify({ schema: 'sks.zellij-lane-render.v1', ok: true })}\n`);
-const present = await waitForLaneHeartbeat(presentPath, { timeoutMs: 1000, intervalMs: 25 });
-assertGate(present.ok === true, 'PRESENT heartbeat should be ok', { present });
-assertGate(present.heartbeat_present === true, 'PRESENT heartbeat should be present', { present });
-assertGate(present.blocker === null, 'PRESENT heartbeat should have no blocker', { present });
-assertGate(present.waited_ms < 1000, 'PRESENT heartbeat should resolve before timeout', { present });
-// Case MISSING: a nonexistent path times out into the blocker.
-const missingPath = path.join(tmp, 'nope-heartbeat.jsonl');
-const missing = await waitForLaneHeartbeat(missingPath, { timeoutMs: 200, intervalMs: 25 });
-assertGate(missing.ok === false, 'MISSING heartbeat should not be ok', { missing });
-assertGate(missing.heartbeat_present === false, 'MISSING heartbeat should not be present', { missing });
-assertGate(missing.blocker === ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER, 'MISSING heartbeat should yield timeout blocker', { missing });
-assertGate(missing.waited_ms >= 150, 'MISSING heartbeat should wait the timeout window', { missing });
-// Case EMPTY: a whitespace-only file is treated as no heartbeat.
-const emptyPath = path.join(tmp, 'empty-heartbeat.jsonl');
-await fs.writeFile(emptyPath, '\n  \n');
-const empty = await waitForLaneHeartbeat(emptyPath, { timeoutMs: 200, intervalMs: 25 });
-assertGate(empty.ok === false, 'EMPTY heartbeat should not be ok', { empty });
-assertGate(empty.blocker === ZELLIJ_HEARTBEAT_TIMEOUT_BLOCKER, 'EMPTY heartbeat should yield timeout blocker', { empty });
-// Wiring: the real-session launch gate must consume the heartbeat blocker.
-const launchGate = readText('src/scripts/zellij-real-session-launch-check.ts');
-assertGate(launchGate.includes('waitForLaneHeartbeat'), 'launch gate must call waitForLaneHeartbeat', {});
-assertGate(launchGate.includes('heartbeat.blocker'), 'launch gate must consume heartbeat.blocker', {});
-const report = {
-    schema: 'sks.zellij-real-session-heartbeat.v1',
-    ok: true,
-    present_ok: true,
-    timeout_ok: true,
-    cases: { present, missing, empty }
-};
-await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'zellij-real-session-heartbeat.json'), `${JSON.stringify(report, null, 2)}\n`);
-emitGate('zellij:real-session-heartbeat', { present_ok: true, timeout_ok: true });
-//# sourceMappingURL=zellij-real-session-heartbeat-check.js.map

package/dist/scripts/zellij-real-session-launch-check.js

@@ -1,57 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-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 args = process.argv.slice(2);
-const missionId = readArg(args, '--mission') || 'M-zellij-real-check';
-const sessionName = readArg(args, '--session') || 'sks-real';
-const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real');
-const mainOnly = args.includes('--main-only') || process.env.SKS_ZELLIJ_MAIN_ONLY === '1';
-const launcher = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-launcher.js')).href);
-const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-const screenProof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-screen-proof.js')).href);
-await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-await fs.rm(path.join(root, '.sneakoscope', 'missions', missionId), { recursive: true, force: true }).catch(() => null);
-const report = await launcher.launchMadZellijUi(['--session', sessionName], {
-    root,
-    missionId,
-    ledgerRoot: path.join(root, '.sneakoscope', 'missions', missionId, 'agents'),
-    dryRun: false,
-    requireZellij: requireReal,
-    slotCount: 1
-});
-const heartbeatPath = path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-lane-renderer-heartbeat.jsonl');
-const heartbeat = mainOnly
-    ? { ok: true, heartbeat_present: false, waited_ms: 0, timeout_ms: 0, blocker: null, skipped: true }
-    : await screenProof.waitForLaneHeartbeat(heartbeatPath, { timeoutMs: 5000 });
-const blockers = [
-    ...(requireReal && report.ok !== true ? ['zellij_real_session_launch_failed'] : []),
-    ...(requireReal && heartbeat.blocker ? [heartbeat.blocker] : [])
-];
-const gate = {
-    schema: 'sks.zellij-real-session-launch-check.v1',
-    ok: requireReal ? (report.ok === true && heartbeat.ok === true && blockers.length === 0) : report.ok === true,
-    integration_optional: !requireReal,
-    main_only: mainOnly,
-    mission_id: missionId,
-    session_name: sessionName,
-    heartbeat: { path: heartbeatPath, present: heartbeat.heartbeat_present, waited_ms: heartbeat.waited_ms, timeout_ms: heartbeat.timeout_ms },
-    blockers,
-    report
-};
-await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'zellij-real-session-launch.json'), `${JSON.stringify(gate, null, 2)}\n`);
-emit(gate);
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-real-session-launch-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}
-//# sourceMappingURL=zellij-real-session-launch-check.js.map

package/dist/scripts/zellij-right-column-headless-overflow-check.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const manager = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
-const swarm = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
-const headlessReturnIndex = worker.indexOf("rightColumn?.placement === 'headless'");
-const newPaneIndex = worker.indexOf("action', 'new-pane'");
-const report = {
-    schema: 'sks.zellij-right-column-headless-overflow-check.v1',
-    headless_source: worker.includes("'zellij_worker_headless_overflow'"),
-    headless_scaling_primitive: worker.includes('native_cli_process_headless_with_slot_dashboard'),
-    returns_before_new_pane: headlessReturnIndex >= 0 && newPaneIndex >= 0 && headlessReturnIndex < newPaneIndex,
-    manager_records_overflow: manager.includes('worker_headless_overflow') && manager.includes('visible_pane_cap'),
-    swarm_records_overflow: swarm.includes('recordHeadlessWorkerInRightColumn')
-};
-const ok = report.headless_source && report.headless_scaling_primitive && report.returns_before_new_pane && report.manager_records_overflow && report.swarm_records_overflow;
-assertGate(ok, 'headless overflow must not call zellij action new-pane', report);
-emitGate('zellij:right-column-headless-overflow', report);
-//# sourceMappingURL=zellij-right-column-headless-overflow-check.js.map

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

@@ -1,27 +0,0 @@
-#!/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 source = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
-const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const schemaExists = fs.existsSync(path.join(root, 'schemas/zellij/zellij-right-column-state.schema.json'));
-const report = {
-    schema: 'sks.zellij-right-column-manager-check.v1',
-    ok: true,
-    exports: ['ensureRightColumn', 'prepareWorkerInRightColumn', 'recordWorkerPaneInRightColumn', 'recordHeadlessWorkerInRightColumn', 'closeWorkerInRightColumn'].every((name) => source.includes(`function ${name}`)),
-    dashboard_after_worker_reservation: source.includes('right_column_creating') && source.includes('scheduler_slot_reserved'),
-    dashboard_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' = '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.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-screen-proof-check.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-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-screen-proof.js')).href);
-const args = process.argv.slice(2);
-const missionId = readArg(args, '--mission');
-const mainOnly = args.includes('--main-only') || process.env.SKS_ZELLIJ_MAIN_ONLY === '1';
-if (missionId && !mainOnly)
-    await waitForHeartbeat([
-        path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-lane-renderer-heartbeat.jsonl'),
-        path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'zellij-lane-renderer-heartbeat.jsonl')
-    ]);
-const report = await mod.writeZellijScreenProof(root, {
-    require: process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real'),
-    missionId: missionId || undefined,
-    ledgerRoot: missionId ? path.join(root, '.sneakoscope', 'missions', missionId) : undefined,
-    mainOnly
-});
-const requiredTextOk = ['SKS Lane', 'Mission', 'Mode', 'Workers', 'Current', 'Queue', 'Safety', 'Blockers', 'Reports', 'Keys:'].every((label) => report.required_text?.includes(label));
-emit({ ...report, required_text_fixture_ok: requiredTextOk, ok: report.ok && requiredTextOk });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-screen-proof-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}
-async function waitForHeartbeat(files) {
-    const fs = await import('node:fs/promises');
-    const deadline = Date.now() + 5000;
-    while (Date.now() < deadline) {
-        for (const file of files) {
-            const text = await fs.readFile(file, 'utf8').catch(() => '');
-            if (text.trim())
-                return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-}
-//# sourceMappingURL=zellij-screen-proof-check.js.map

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

@@ -1,66 +0,0 @@
-#!/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 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',
-    missionId: 'M-check',
-    mode: 'compact-slots',
-    artifactRoot: '/repo/.sneakoscope/missions/M-check/agents',
-    watch: true
-});
-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 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