sneakoscope 4.8.7 → 5.1.2

package/dist/scripts/ux-review-imagegen-blackbox-check.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { osTempPngFixtureArg } from './lib/valid-png-fixture.js';
-const sourceImage = osTempPngFixtureArg('ux-review-imagegen-blackbox-source.png');
-const run = spawnSync(process.execPath, ['./dist/bin/sks.js', 'ux-review', 'run', '--image', sourceImage, '--generate-callouts', '--json'], {
-    cwd: process.cwd(),
-    env: { ...process.env, SKS_TEST_FAKE_IMAGEGEN: '1', SKS_TEST_FAKE_EXTRACTOR: '1' },
-    encoding: 'utf8',
-    maxBuffer: 4 * 1024 * 1024
-});
-const parsed = parseJson(run.stdout);
-const missionDir = parsed?.mission_id ? path.join(process.cwd(), '.sneakoscope', 'missions', parsed.mission_id) : null;
-const request = missionDir ? readJson(path.join(missionDir, 'image-ux-gpt-image-2-request.json')) : null;
-const response = missionDir ? readJson(path.join(missionDir, 'image-ux-gpt-image-2-response.json')) : null;
-const issues = missionDir ? readJson(path.join(missionDir, 'image-ux-issue-ledger.json')) : null;
-const generated = missionDir ? readJson(path.join(missionDir, 'image-ux-generated-review-ledger.json')) : null;
-const proof = missionDir ? readJson(path.join(missionDir, 'completion-proof.json')) : null;
-const ok = Boolean(parsed?.mission_id)
-    && run.status === 0
-    && parsed?.status === 'verified_partial_reference'
-    && request?.validation?.ok === true
-    && response?.fake_adapter === true
-    && generated?.generated_count === 1
-    && generated?.real_generated_count === 0
-    && generated?.non_real_generated_count === 1
-    && generated?.generated_review_images?.[0]?.mock === true
-    && Array.isArray(issues?.issues)
-    && issues.issues.length > 0
-    && issues.issues.every((issue) => issue.source === 'mock_fixture')
-    && proof?.status === 'verified_partial'
-    && proof?.evidence?.image_ux_review?.reference_only === true
-    && proof?.evidence?.image_ux_review?.generated_gpt_image_2_callout_images_count === 0;
-console.log(JSON.stringify({
-    schema: 'sks.ux-review-imagegen-blackbox-check.v1',
-    ok,
-    process_status: run.status,
-    mission_id: parsed?.mission_id || null,
-    gate_status: parsed?.status || null,
-    proof_status: proof?.status || null,
-    reference_only: proof?.evidence?.image_ux_review?.reference_only === true,
-    source_image: sourceImage,
-    request,
-    response,
-    issue_count: issues?.issues?.length || 0
-}, null, 2));
-if (!ok)
-    process.exitCode = 1;
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-function readJson(file) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=ux-review-imagegen-blackbox-check.js.map

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("ui_architecture: 'monitor_plus_viewports'") && mad.includes('worker_panes_created: 0'),
-    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'),
-    launcher_uses_layout_builder: launcher.includes('writeZellijLayout(root, layoutInput)')
-};
-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 use monitor plus fixed viewports with no worker panes at launch', report);
-emitGate('zellij:initial-main-only-blackbox', report);
-//# sourceMappingURL=zellij-initial-main-only-blackbox.js.map

package/dist/scripts/zellij-pane-lock-concurrency-blackbox.js

@@ -1,80 +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 { 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-open-worker-integration-blackbox.js

@@ -1,137 +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 { 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-self-heal-typed-blackbox.js

@@ -1,4 +0,0 @@
-#!/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-telemetry-real-blackbox.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const requireZellij = process.env.SKS_REQUIRE_ZELLIJ === '1';
-const zellij = spawnSync('zellij', ['--version'], { encoding: 'utf8', timeout: 10000 });
-assertGate(!requireZellij || zellij.status === 0, 'SKS_REQUIRE_ZELLIJ=1 requires zellij to be installed and runnable', {
-    status: zellij.status,
-    stderr: zellij.stderr
-});
-const telemetry = readText('src/core/zellij/zellij-slot-telemetry.ts');
-const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
-const pane = readText('src/core/zellij/zellij-slot-pane-renderer.ts');
-assertGate(telemetry.includes('appendZellijSlotTelemetry') && telemetry.includes('readZellijSlotTelemetrySnapshot'), 'telemetry ledger/snapshot runtime must exist');
-assertGate(swarm.includes('slot_reserved') && swarm.includes('worker_spawned'), 'real worker launch path must emit slot lifecycle telemetry');
-assertGate(pane.includes('readZellijSlotTelemetrySnapshot'), 'real slot pane path must render from telemetry snapshot');
-emitGate('zellij:slot-telemetry-real', {
-    zellij_available: zellij.status === 0,
-    required: requireZellij
-});
-//# sourceMappingURL=zellij-slot-telemetry-real-blackbox.js.map

package/dist/scripts/zellij-stacked-fallback-integration-blackbox.js

@@ -1,81 +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 { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-fallback-'));
-const missionId = 'M-zellij-stacked-fallback';
-const sessionName = 'sks-stacked-fallback-fixture';
-process.env.SKS_ZELLIJ_FAKE_ADAPTER = '1';
-process.env.SKS_ZELLIJ_FAKE_ROOT = tmp;
-process.env.SKS_ZELLIJ_FAKE_DELAY_MS = '10';
-process.env.SKS_ZELLIJ_FAKE_VERSION = '0.42.2';
-process.env.SKS_ZELLIJ_WORKER_STACKED = '1';
-const { openWorkerPane } = await importDist('core/zellij/zellij-worker-pane-manager.js');
-const records = [];
-for (let slot = 1; slot <= 3; slot += 1)
-    records.push(await openWorkerPane(workerInput(slot)));
-const calls = await readJsonl(path.join(tmp, '.sneakoscope', 'fake-zellij-calls.jsonl'));
-const stackedCalls = calls.filter((row) => row.args.includes('--stacked'));
-assertGate(records.every((row) => row.ok === true), 'fallback integration workers must still run', records);
-assertGate(stackedCalls.length === 0, 'Zellij <0.43 fallback path must not call --stacked', stackedCalls);
-assertGate(records.slice(1).every((row) => row.worker_stacked_requested === true), 'second+ workers must record stacked intent', records);
-assertGate(records.slice(1).every((row) => row.worker_stacked_applied === false), 'fallback workers must record stacked_applied=false', records);
-assertGate(records.slice(1).every((row) => row.worker_stacked_fallback_mode === 'down-split-stack-emulation'), 'fallback mode must be down-split-stack-emulation', records);
-emitGate('zellij:stacked-fallback-integration', { workers: records.length, stacked_calls: stackedCalls.length });
-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(()=>{}, 100)"',
-        providerContext: providerContext(),
-        serviceTier: 'fast',
-        backend: 'codex-sdk',
-        statusLabel: 'running',
-        rightColumnMode: 'spawn-on-first-worker',
-        visiblePaneCap: 3,
-        uiMode: 'compact-slots',
-        dashboardSnapshot: { mission_id: missionId, active_workers: 3, visible_panes: 3 }
-    };
-}
-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 readJsonl(file) {
-    const text = await fs.readFile(file, 'utf8');
-    return text.trim().split(/\n+/).filter(Boolean).map((line) => JSON.parse(line));
-}
-//# sourceMappingURL=zellij-stacked-fallback-integration-blackbox.js.map

package/dist/scripts/zellij-worker-pane-real-ui-blackbox.js

@@ -1,202 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { spawn } from 'node:child_process';
-import { assertGate, emitGate, readText, root } from './sks-1-18-gate-lib.js';
-import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
-const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
-const manager = readText('src/core/zellij/zellij-worker-pane-manager.ts');
-const schema = readText('src/core/agents/agent-schema.ts');
-const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
-assertGate(manager.includes('action') && manager.includes('new-pane'), 'worker pane manager must call zellij action new-pane');
-assertGate(manager.includes('list-panes') && manager.includes('dump-screen'), 'worker pane proof must reconcile real list-panes/dump-screen evidence');
-assertGate(schema.includes('AgentWorkerPlacement') && swarm.includes("placement === 'zellij-pane'"), 'worker placement must control Zellij panes independently of backend');
-if (!requireReal) {
-    emitGate('zellij:worker-pane-real-ui:blackbox', { real_required: false, proof_mode: 'source_contract' });
-    process.exit(0);
-}
-const { spawnSync } = await import('node:child_process');
-const available = spawnSync('zellij', ['--version'], { encoding: 'utf8' });
-assertGate(available.status === 0, 'SKS_REQUIRE_ZELLIJ=1 requires zellij binary', { stderr: available.stderr });
-const freshness = ensureDistFresh({ rebuild: false });
-assertGate(freshness.ok === true, 'dist must be fresh before real Zellij worker-pane blackbox', freshness);
-const zellij = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-const workerPane = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-worker-pane-manager.js')).href);
-const missionId = `M-zellij-worker-pane-real-${Date.now()}`;
-const sessionName = `sks-worker-pane-real-${process.pid}`;
-const ledgerRoot = path.join(root, '.sneakoscope', 'missions', missionId, 'agents');
-fs.rmSync(path.join(root, '.sneakoscope', 'missions', missionId), { recursive: true, force: true });
-fs.mkdirSync(ledgerRoot, { recursive: true });
-await zellij.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-const attachedClient = startAttachedZellijClient(sessionName);
-await sleep(1500);
-await zellij.runZellij(['--session', sessionName, 'action', 'send-keys', 'Esc'], { cwd: root, timeoutMs: 5000, optional: true });
-await sleep(250);
-const before = await zellij.runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: true });
-const beforeCount = parsePaneRows(before.stdout_tail).length;
-const beforeTerminalCount = parsePaneRows(before.stdout_tail).filter((row) => row && row.is_plugin !== true).length;
-const records = [];
-try {
-    for (let index = 1; index <= 3; index += 1) {
-        const slotId = `slot-${String(index).padStart(3, '0')}`;
-        const workerDir = path.join('sessions', slotId, 'gen-1', 'worker');
-        const absWorkerDir = path.join(ledgerRoot, workerDir);
-        fs.mkdirSync(absWorkerDir, { recursive: true });
-        const heartbeatRel = path.join(workerDir, 'worker-heartbeat.jsonl');
-        const resultRel = path.join(workerDir, 'worker-result.json');
-        const stdoutRel = path.join(workerDir, 'worker.stdout.log');
-        const stderrRel = path.join(workerDir, 'worker.stderr.log');
-        const heartbeatAbs = path.join(ledgerRoot, heartbeatRel);
-        const resultAbs = path.join(ledgerRoot, resultRel);
-        const backend = index === 1 ? 'codex-sdk' : index === 2 ? 'local-llm' : 'python-codex-sdk';
-        const expectedTitle = `${slotId}/gen-1 · WT:WT-${String(index).padStart(4, '0')} · branch:fixture · ${backend} · fast · codex-lb · active`;
-        const workerScript = [
-            "const fs=require('fs');",
-            `fs.appendFileSync(${JSON.stringify(heartbeatAbs)}, JSON.stringify({ok:true, slot:${JSON.stringify(slotId)}, ts:new Date().toISOString()})+'\\n');`,
-            `fs.writeFileSync(${JSON.stringify(resultAbs)}, JSON.stringify({schema:'sks.agent-result.v1', status:'done', slot:${JSON.stringify(slotId)}, heartbeat_seen:true}, null, 2)+'\\n');`,
-            "setTimeout(()=>process.exit(0), 30000);"
-        ].join('');
-        const record = await workerPane.openWorkerPane({
-            root: ledgerRoot,
-            missionId,
-            sessionName,
-            slotId,
-            generationIndex: 1,
-            sessionId: `${slotId}-gen-1`,
-            workerArtifactDir: workerDir,
-            workerCommand: `printf ${shellQuote(`\u001b]2;${expectedTitle}\u0007`)}; ${process.execPath} -e ${shellQuote(workerScript)}`,
-            resultPath: resultRel,
-            heartbeatPath: heartbeatRel,
-            patchEnvelopePath: path.join(workerDir, 'worker-patch-envelope.json'),
-            stdoutLog: stdoutRel,
-            stderrLog: stderrRel,
-            cwd: root,
-            serviceTier: 'fast',
-            backend,
-            statusLabel: 'active',
-            worktree: { id: `WT-${String(index).padStart(4, '0')}`, path: root, branch: 'fixture' }
-        });
-        records.push(record);
-    }
-    await sleep(750);
-    const listed = await zellij.runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: false });
-    const rows = parsePaneRows(listed.stdout_tail);
-    const terminalRows = rows.filter((row) => row && row.is_plugin !== true);
-    const titles = rows.map((row) => String(row.title || row.name || row.pane_name || ''));
-    const matchedTitles = records.filter((record) => titles.includes(record.pane_title)).length;
-    const commandMatchedWorkers = records.filter((record) => rows.some((row) => {
-        const command = `${row.terminal_command || ''} ${row.pane_command || ''} ${row.command || ''}`;
-        return command.includes(missionId) && command.includes(record.slot_id);
-    })).length;
-    const requestedTitleCommands = records.filter((record) => {
-        const args = Array.isArray(record.launch?.args) ? record.launch.args.map(String) : [];
-        return args.includes('--name') && args.includes(record.pane_title);
-    }).length;
-    const dump = await zellij.runZellij(['--session', sessionName, 'action', 'dump-screen'], { cwd: root, timeoutMs: 5000, optional: true });
-    const heartbeatSeen = records.filter((record) => fs.existsSync(path.join(ledgerRoot, record.heartbeat_path))).length;
-    const resultSeen = records.filter((record) => fs.existsSync(path.join(ledgerRoot, record.worker_result_path))).length;
-    const realPaneIds = records.filter((record) => workerPane.isRealZellijWorkerPaneIdSource(record.pane_id_source) && record.pane_id).length;
-    const workerKindRecords = records.filter((record) => record.pane_kind === 'worker_codex_sdk').length;
-    const workerPrimitiveRecords = records.filter((record) => record.scaling_primitive === 'native_cli_process_in_zellij_worker_pane').length;
-    const recordProofOk = records.length === 3
-        && realPaneIds === 3
-        && workerKindRecords === 3
-        && workerPrimitiveRecords === 3
-        && requestedTitleCommands === 3
-        && heartbeatSeen === 3
-        && resultSeen === 3;
-    const listPanesVisibilityOk = matchedTitles === 3
-        || commandMatchedWorkers === 3
-        || terminalRows.length >= beforeTerminalCount + 3;
-    const report = {
-        schema: 'sks.zellij-worker-pane-real-ui-blackbox.v1',
-        ok: recordProofOk && dump.ok,
-        real_required: true,
-        zellij_version: available.stdout.trim(),
-        mission_id: missionId,
-        session_name: sessionName,
-        before_pane_count: beforeCount,
-        before_terminal_pane_count: beforeTerminalCount,
-        after_pane_count: rows.length,
-        terminal_pane_count: terminalRows.length,
-        worker_pane_count: records.length,
-        real_pane_ids: realPaneIds,
-        worker_kind_records: workerKindRecords,
-        worker_primitive_records: workerPrimitiveRecords,
-        matched_titles: matchedTitles,
-        command_matched_workers: commandMatchedWorkers,
-        requested_title_commands: requestedTitleCommands,
-        heartbeat_seen: heartbeatSeen,
-        result_seen: resultSeen,
-        dump_screen_ok: dump.ok,
-        record_proof_ok: recordProofOk,
-        list_panes_visibility_ok: listPanesVisibilityOk,
-        pane_titles: records.map((record) => record.pane_title),
-        pane_id_sources: records.map((record) => record.pane_id_source),
-        proof_root: ledgerRoot,
-        blockers: []
-    };
-    if (!report.ok) {
-        report.blockers = [
-            ...(realPaneIds === 3 ? [] : ['real_worker_pane_ids_missing']),
-            ...(workerKindRecords === 3 ? [] : ['worker_pane_kind_missing']),
-            ...(workerPrimitiveRecords === 3 ? [] : ['worker_pane_scaling_primitive_missing']),
-            ...(requestedTitleCommands === 3 ? [] : ['worker_pane_title_request_missing']),
-            ...(heartbeatSeen === 3 ? [] : ['worker_heartbeat_missing']),
-            ...(resultSeen === 3 ? [] : ['worker_result_missing']),
-            ...(dump.ok ? [] : ['worker_pane_dump_screen_failed'])
-        ];
-    }
-    fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-    fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'zellij-worker-pane-real-ui-blackbox.json'), `${JSON.stringify(report, null, 2)}\n`);
-    emitGate('zellij:worker-pane-real-ui:blackbox', report);
-    if (!report.ok)
-        process.exitCode = 1;
-}
-finally {
-    await zellij.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-    safeKill(attachedClient, 'SIGTERM');
-    await sleep(250);
-    safeKill(attachedClient, 'SIGKILL');
-}
-function parsePaneRows(text) {
-    if (!String(text || '').trim())
-        return [];
-    try {
-        const parsed = JSON.parse(String(text));
-        if (Array.isArray(parsed))
-            return parsed;
-        if (Array.isArray(parsed?.panes))
-            return parsed.panes;
-        return [];
-    }
-    catch {
-        return [];
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function shellQuote(value) {
-    return `'${String(value).replace(/'/g, `'\\''`)}'`;
-}
-function startAttachedZellijClient(sessionName) {
-    const logFile = path.join(root, '.sneakoscope', 'reports', `${sessionName}.script.log`);
-    fs.mkdirSync(path.dirname(logFile), { recursive: true });
-    return spawn('script', ['-q', logFile, 'zellij', 'attach', '--create', sessionName], {
-        cwd: root,
-        stdio: ['ignore', 'ignore', 'ignore']
-    });
-}
-function safeKill(child, signal) {
-    try {
-        if (!child.killed)
-            child.kill(signal);
-    }
-    catch {
-        // Best-effort cleanup for the disposable pseudo-terminal client.
-    }
-}
-//# sourceMappingURL=zellij-worker-pane-real-ui-blackbox.js.map