sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/zellij-pane-creation-lock-metrics-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const src = readText('src/core/zellij/zellij-worker-pane-manager.ts');
+assertGate(src.includes('sks.zellij-pane-creation-lock-metrics.v1'), 'pane lock metrics schema missing');
+assertGate(src.includes('pane-creation-lock-events.jsonl'), 'pane lock metrics artifact path missing');
+for (const token of ['requested_at', 'acquired_at', 'released_at', 'wait_ms', 'held_ms']) {
+    assertGate(src.includes(token), `pane lock metrics missing ${token}`);
+}
+assertGate(src.includes('zellij_pane_creation_lock_requested') && src.includes('zellij_pane_creation_lock_released'), 'pane lock runtime events missing');
+emitGate('zellij:pane-creation-lock-metrics');
+//# sourceMappingURL=zellij-pane-creation-lock-metrics-check.js.map

package/dist/scripts/zellij-pane-lock-concurrency-blackbox.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 { spawn } from 'node:child_process';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const missionId = 'M-zellij-pane-lock-blackbox';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-pane-lock-'));
+const metricsFile = path.join(tmp, '.sneakoscope', 'missions', missionId, 'zellij', 'pane-creation-lock-events.jsonl');
+await fs.mkdir(path.dirname(metricsFile), { recursive: true });
+const workers = 32;
+const visiblePaneCap = 8;
+const workerSleepMs = 3000;
+const paneDelayMs = 300;
+const started = Date.now();
+let active = 0;
+let maxActive = 0;
+const pids = new Set();
+const events = [];
+let lock = Promise.resolve();
+const runs = Array.from({ length: workers }, (_, index) => runWorker(index + 1));
+await Promise.all(runs);
+const wall = Date.now() - started;
+const metricsText = await fs.readFile(metricsFile, 'utf8');
+const metrics = metricsText.trim().split(/\n+/).map((line) => JSON.parse(line));
+const visiblePanes = metrics.length;
+const headlessWorkers = workers - visiblePanes;
+const lastPaneCreated = Math.max(...events.filter((event) => event.type === 'zellij_pane_created').map((event) => event.at));
+const firstSpawn = Math.min(...events.filter((event) => event.type === 'worker_process_spawned').map((event) => event.at));
+assertGate(maxActive >= 32, 'max active workers must reach 32', { maxActive });
+assertGate(pids.size >= 32, 'unique PIDs must reach 32', { unique: pids.size });
+assertGate(wall < 9000, 'wall time must prove overlap under 9s', { wall });
+assertGate(metrics.length === visiblePaneCap && metrics.every((row) => row.wait_ms >= 0 && row.held_ms >= paneDelayMs - 40), 'pane lock metrics missing or invalid', metrics);
+assertGate(firstSpawn <= lastPaneCreated, 'worker processes must spawn before all pane creation finishes', { firstSpawn, lastPaneCreated });
+assertGate(visiblePanes <= 8 && headlessWorkers >= 24, 'visible/headless worker counts mismatch', { visiblePanes, headlessWorkers });
+emitGate('zellij:pane-lock-concurrency-blackbox', { wall_ms: wall, max_active_workers: maxActive, unique_pids: pids.size, visible_panes: visiblePanes, headless_workers: headlessWorkers });
+async function runWorker(slot) {
+    const child = spawn(process.execPath, ['-e', `setTimeout(()=>process.exit(0), ${workerSleepMs})`], { stdio: 'ignore' });
+    active += 1;
+    maxActive = Math.max(maxActive, active);
+    if (child.pid)
+        pids.add(child.pid);
+    events.push({ type: 'worker_process_spawned', slot, at: Date.now() - started, pid: child.pid || null });
+    const paneTask = slot <= visiblePaneCap ? withPaneLock(slot) : Promise.resolve();
+    await Promise.all([
+        new Promise((resolve) => child.on('close', resolve)),
+        paneTask
+    ]);
+    active -= 1;
+}
+async function withPaneLock(slot) {
+    const requestedAt = new Date().toISOString();
+    const requestedMs = Date.now();
+    events.push({ type: 'zellij_pane_creation_lock_requested', slot, at: requestedMs - started });
+    const previous = lock;
+    let release;
+    lock = new Promise((resolve) => { release = resolve; });
+    await previous;
+    const acquiredAt = new Date().toISOString();
+    const acquiredMs = Date.now();
+    await new Promise((resolve) => setTimeout(resolve, paneDelayMs));
+    events.push({ type: 'zellij_pane_created', slot, at: Date.now() - started });
+    const releasedAt = new Date().toISOString();
+    const releasedMs = Date.now();
+    await fs.appendFile(metricsFile, JSON.stringify({
+        schema: 'sks.zellij-pane-creation-lock-metrics.v1',
+        mission_id: missionId,
+        session_name: 'fixture',
+        slot_id: `slot-${String(slot).padStart(3, '0')}`,
+        generation_index: 1,
+        requested_at: requestedAt,
+        acquired_at: acquiredAt,
+        released_at: releasedAt,
+        wait_ms: acquiredMs - requestedMs,
+        held_ms: releasedMs - acquiredMs
+    }) + '\n');
+    release();
+}
+//# sourceMappingURL=zellij-pane-lock-concurrency-blackbox.js.map

package/dist/scripts/zellij-pane-lock-does-not-block-worker-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
+const processRunStart = swarm.indexOf('const processRun = liveWorkerPane');
+const compactBlock = swarm.slice(processRunStart, swarm.indexOf('const zellijRequired'));
+assertGate(processRunStart >= 0, 'native swarm compact branch missing');
+assertGate(compactBlock.indexOf('spawnCompactSlotWorkerProcess') >= 0 && compactBlock.indexOf('spawnCompactSlotWorkerProcess') < compactBlock.indexOf('openWorkerPane'), 'compact worker process must spawn before pane creation');
+const parallel = readText('src/core/agents/parallel-runtime-proof.ts');
+for (const event of ['worker_process_spawned', 'zellij_pane_creation_lock_requested', 'zellij_pane_created']) {
+    assertGate(parallel.includes(event), `parallel proof event missing ${event}`);
+}
+emitGate('zellij:pane-lock-does-not-block-worker');
+//# sourceMappingURL=zellij-pane-lock-does-not-block-worker-check.js.map

package/dist/scripts/zellij-pane-lock-open-worker-integration-blackbox.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-open-worker-pane-'));
+const missionId = 'M-zellij-open-worker-pane';
+const sessionName = 'sks-open-worker-pane-fixture';
+const workers = 32;
+const visible = 8;
+const workerSleepMs = 3000;
+const events = [];
+const pids = new Set();
+let active = 0;
+let maxActive = 0;
+const started = Date.now();
+process.env.SKS_ZELLIJ_FAKE_ADAPTER = '1';
+process.env.SKS_ZELLIJ_FAKE_ROOT = tmp;
+process.env.SKS_ZELLIJ_FAKE_DELAY_MS = '300';
+process.env.SKS_ZELLIJ_FAKE_VERSION = '0.43.1';
+process.env.SKS_ZELLIJ_WORKER_STACKED = '1';
+const { openWorkerPane } = await importDist('core/zellij/zellij-worker-pane-manager.js');
+const runs = Array.from({ length: workers }, (_, index) => runWorker(index + 1));
+const records = await Promise.all(runs);
+const wall = Date.now() - started;
+const visibleRecords = records.filter(Boolean);
+const calls = await readJsonl(path.join(tmp, '.sneakoscope', 'fake-zellij-calls.jsonl'));
+const metrics = await readJsonl(path.join(tmp, '.sneakoscope', 'missions', missionId, 'zellij', 'pane-creation-lock-events.jsonl'));
+const anchorCalls = calls.filter((row) => row.args.includes('--name') && row.args.includes('SLOTS'));
+const stackedCalls = calls.filter((row) => row.args.includes('--stacked'));
+const stackPaneCalls = calls.filter((row) => row.args.includes('stack-panes'));
+const workerArtifacts = await Promise.all(visibleRecords.map((record) => readJson(path.join(tmp, record.worker_artifact_dir, 'zellij-worker-pane.json'))));
+const stackedWorkerArtifacts = workerArtifacts.filter((row) => row.worker_stacked_requested === true);
+const lastPaneCreated = Math.max(...events.filter((event) => event.type === 'zellij_pane_created').map((event) => event.at));
+const firstSpawn = Math.min(...events.filter((event) => event.type === 'worker_process_spawned').map((event) => event.at));
+assertGate(visibleRecords.length === visible, 'visible openWorkerPane records missing', { visibleRecords: visibleRecords.length });
+assertGate(workerArtifacts.every((row) => row?.schema === 'sks.zellij-worker-pane.v1'), 'openWorkerPane must write zellij-worker-pane.json artifacts', workerArtifacts);
+assertGate(anchorCalls.length === 1, 'exactly one SLOTS anchor must be created', { anchorCalls });
+assertGate(new Set(anchorCalls.map((row) => JSON.stringify(row.args))).size === 1, 'SLOTS anchor must not be created N side-by-side times', { anchorCalls });
+assertGate(metrics.length >= visible, 'pane lock metrics must cover visible panes', { metrics: metrics.length });
+assertGate(firstSpawn <= lastPaneCreated, 'worker processes must spawn before all pane creation finishes', { firstSpawn, lastPaneCreated });
+assertGate(maxActive >= workers, 'worker process execution must not be serialized by pane lock', { maxActive });
+assertGate(pids.size >= workers, 'unique worker process PIDs must reach requested worker count', { pids: pids.size });
+assertGate(wall < 9000, 'openWorkerPane integration wall time must stay below 9s', { wall });
+assertGate(stackedCalls.length >= visible - 1, 'second+ visible workers must request native stacked panes on fake zellij >=0.43', { stackedCalls: stackedCalls.length });
+assertGate(stackPaneCalls.length >= visible - 1, 'second+ visible workers must reconcile native stacked panes with stack-panes', { stackPaneCalls: stackPaneCalls.length });
+assertGate(stackedWorkerArtifacts.length >= visible - 1, 'second+ visible worker artifacts must record stacked requested', workerArtifacts);
+assertGate(stackedWorkerArtifacts.every((row) => row.worker_stacked_applied === true), 'second+ visible worker artifacts must record stacked applied', workerArtifacts);
+emitGate('zellij:pane-lock-open-worker-integration', {
+    wall_ms: wall,
+    max_active_workers: maxActive,
+    unique_pids: pids.size,
+    visible_panes: visibleRecords.length,
+    stacked_calls: stackedCalls.length,
+    stack_panes_calls: stackPaneCalls.length,
+    pane_lock_metrics: metrics.length
+});
+async function runWorker(slot) {
+    const child = spawn(process.execPath, ['-e', `setTimeout(()=>process.exit(0), ${workerSleepMs})`], { stdio: 'ignore' });
+    active += 1;
+    maxActive = Math.max(maxActive, active);
+    if (child.pid)
+        pids.add(child.pid);
+    events.push({ type: 'worker_process_spawned', slot, at: Date.now() - started, pid: child.pid || null });
+    const paneTask = slot <= visible
+        ? openWorkerPane(workerInput(slot)).then((record) => {
+            events.push({ type: 'zellij_pane_created', slot, at: Date.now() - started, pane_id: record.pane_id });
+            return record;
+        })
+        : Promise.resolve(null);
+    const [, record] = await Promise.all([
+        new Promise((resolve) => child.on('close', resolve)),
+        paneTask
+    ]);
+    active -= 1;
+    return record;
+}
+function workerInput(slot) {
+    const slotId = `slot-${String(slot).padStart(3, '0')}`;
+    const workerDir = path.join('sessions', slotId, 'gen-1', 'worker');
+    return {
+        root: tmp,
+        cwd: tmp,
+        projectRoot: tmp,
+        missionId,
+        sessionName,
+        slotId,
+        generationIndex: 1,
+        sessionId: `${slotId}-gen-1`,
+        workerArtifactDir: workerDir,
+        resultPath: path.join(workerDir, 'worker-result.json'),
+        heartbeatPath: path.join(workerDir, 'worker-heartbeat.jsonl'),
+        patchEnvelopePath: path.join(workerDir, 'worker-patch-envelope.json'),
+        stdoutLog: path.join(workerDir, 'worker.stdout.log'),
+        stderrLog: path.join(workerDir, 'worker.stderr.log'),
+        workerCommand: `node -e "setTimeout(()=>{}, ${workerSleepMs})"`,
+        providerContext: providerContext(),
+        serviceTier: 'fast',
+        backend: 'codex-sdk',
+        statusLabel: 'running',
+        rightColumnMode: 'spawn-on-first-worker',
+        visiblePaneCap: visible,
+        uiMode: 'compact-slots',
+        dashboardSnapshot: { mission_id: missionId, active_workers: workers, visible_panes: visible }
+    };
+}
+function providerContext() {
+    return {
+        schema: 'sks.provider-context.v1',
+        generated_at: new Date().toISOString(),
+        provider: 'codex-lb',
+        auth_mode: 'codex_lb_key',
+        route: '$Naruto',
+        service_tier: 'fast',
+        source: 'fixture',
+        confidence: 'high',
+        conflict: false,
+        warnings: [],
+        signals: {
+            openai_api_key_present: false,
+            codex_lb_key_present: true,
+            codex_lb_explicit: true,
+            codex_app_auth_present: false,
+            model_provider: 'codex-lb'
+        }
+    };
+}
+async function readJson(file) {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+}
+async function readJsonl(file) {
+    const text = await fs.readFile(file, 'utf8');
+    return text.trim().split(/\n+/).filter(Boolean).map((line) => JSON.parse(line));
+}
+//# sourceMappingURL=zellij-pane-lock-open-worker-integration-blackbox.js.map

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

@@ -0,0 +1,59 @@
+#!/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-qa-app-handoff-status-check.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const pane = readText('src/core/zellij/zellij-slot-pane-renderer.ts');
+const anchor = readText('src/core/zellij/zellij-slot-column-anchor.ts');
+assertGate(pane.includes('QA app handoff pending') && pane.includes('app-handoff.json'), 'Zellij slot pane must surface QA app handoff pending status');
+assertGate(anchor.includes('QA /app handoff pending') && anchor.includes('qa-loop/app-handoff.json'), 'Zellij column anchor must surface QA app handoff pending status');
+emitGate('zellij:qa-app-handoff-status');
+//# sourceMappingURL=zellij-qa-app-handoff-status-check.js.map

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

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

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

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

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

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

@@ -0,0 +1,45 @@
+#!/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-self-heal-check.js

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

package/dist/scripts/zellij-self-heal-dry-run-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
+await runDirective315Gate('zellij:self-heal-dry-run');
+//# sourceMappingURL=zellij-self-heal-dry-run-check.js.map

package/dist/scripts/zellij-self-heal-status-contract-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
+await runDirective315Gate('zellij:self-heal-status-contract');
+//# sourceMappingURL=zellij-self-heal-status-contract-check.js.map

package/dist/scripts/zellij-self-heal-typed-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
+await runDirective315Gate('zellij:self-heal-typed-blackbox');
+//# sourceMappingURL=zellij-self-heal-typed-blackbox.js.map

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

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