sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/wrongness-fixture-check.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import os from 'node:os';
-import path from 'node:path';
-import fsp from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-wrongness-fixture-'));
-const [ledger, imageWrongness, proofLinker] = await Promise.all([
-    import(path.join(repo, 'dist/core/triwiki-wrongness/wrongness-ledger.js')),
-    import(path.join(repo, 'dist/core/triwiki-wrongness/image-wrongness.js')),
-    import(path.join(repo, 'dist/core/triwiki-wrongness/wrongness-proof-linker.js'))
-]);
-await fsp.mkdir(path.join(root, '.sneakoscope', 'missions', 'M-fixture'), { recursive: true });
-await ledger.recordTestFailureWrongness(root, {
-    mission_id: 'M-fixture',
-    route: '$Team',
-    command: 'node --test failing-fixture.test.mjs',
-    failure: 'fixture assertion failed',
-    artifact: '.sneakoscope/missions/M-fixture/test-report.json'
-});
-await ledger.recordDbSafetyMismatchWrongness(root, {
-    mission_id: 'M-fixture',
-    expected: 'blocked',
-    actual: 'safe',
-    command: 'sks db check --sql "DROP TABLE users"',
-    sql: 'DROP TABLE users'
-});
-await ledger.recordHookPolicyMismatchWrongness(root, {
-    mission_id: 'M-fixture',
-    expected: 'block',
-    actual: 'continue',
-    artifact: 'test/fixtures/hooks/mismatch.json'
-});
-await ledger.recordAgentMismatchWrongness(root, {
-    mission_id: 'M-fixture',
-    agent_id: 'agent-2-verification',
-    issues: ['parse_failed'],
-    artifact: '.sneakoscope/missions/M-fixture/agent-2-verification.json'
-});
-await imageWrongness.recordImageWrongnessFromValidation(root, {
-    missionId: 'M-fixture',
-    route: '$Wiki',
-    artifact: '.sneakoscope/missions/M-fixture/image-voxel-ledger.json',
-    validation: {
-        ok: false,
-        issues: ['missing_anchors:$Wiki', 'bbox_out_of_bounds:anchor-001']
-    }
-});
-const validation = await ledger.validateWrongnessScope(root, 'latest');
-const evidence = await proofLinker.wrongnessProofEvidence(root, 'M-fixture');
-const ok = validation.ok
-    && validation.checked >= 5
-    && evidence.active_count >= 5
-    && evidence.high_severity_active >= 2;
-console.log(JSON.stringify({
-    schema: 'sks.wrongness-fixture-check.v1',
-    ok,
-    root,
-    validation,
-    evidence
-}, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=wrongness-fixture-check.js.map

package/dist/scripts/xai-mcp-capability-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const detector = await importDist('core/mcp/xai-mcp-detector.js');
-const detection = detector.detectXaiMcpFromConfig([
-    { path: 'fixture.toml', source: 'provided', text: '[mcp_servers.grok]\ntools = ["search", "query"]\n' }
-]);
-assertGate(detection.ok === true, 'X AI detector must not fail');
-assertGate(detection.configured === true, 'X AI detector must detect configured Grok MCP');
-assertGate(detection.search_capable === true, 'X AI detector must detect search-capable tools');
-const missing = detector.detectXaiMcpFromConfig([]);
-assertGate(missing.ok === true && missing.status === 'missing', 'missing X AI MCP must be ok fallback');
-emitGate('xai-mcp:capability', { configured_status: detection.status, missing_status: missing.status });
-//# sourceMappingURL=xai-mcp-capability-check.js.map

package/dist/scripts/zellij-capability-check.js

@@ -1,15 +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-capability.js')).href);
-const report = await mod.checkZellijCapability({ root, require: process.argv.includes('--require-real') || process.env.SKS_REQUIRE_ZELLIJ === '1' });
-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-capability-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=zellij-capability-check.js.map

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

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
-import fs from 'node:fs';
-const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
-const freshness = ensureDistFresh({ rebuild: false });
-assertGate(freshness.ok === true, 'dist must be fresh for zellij dashboard pane check', freshness);
-const managerSource = fs.readFileSync(path.join(root, 'src', 'core', 'zellij', 'zellij-right-column-manager.ts'), 'utf8');
-const narutoSource = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'naruto-command.ts'), 'utf8');
-const madSource = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'mad-sks-command.ts'), 'utf8');
-assertGate(managerSource.includes('openZellijDashboardPane') && narutoSource.includes("dashboard_created: false") && madSource.includes("dashboard_created: false"), 'Dashboard pane must be created by right-column manager after first worker spawn, not at launch', {
-    manager: managerSource.includes('openZellijDashboardPane'),
-    naruto_initial_dashboard_false: narutoSource.includes("dashboard_created: false"),
-    mad_initial_dashboard_false: madSource.includes("dashboard_created: false")
-});
-const dashboard = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-dashboard-pane.js')).href);
-const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-const missionId = `M-zellij-dashboard-${Date.now()}`;
-const sessionName = `sks-dashboard-${process.pid}`;
-if (!requireReal) {
-    const snapshotMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-dashboard-renderer.js')).href);
-    const snapshot = snapshotMod.buildZellijDashboardSnapshot({ mission_id: missionId, active_workers: 4, visible_panes: 2, headless_workers: 2 });
-    const text = snapshotMod.renderZellijDashboardText(snapshot);
-    assertGate(text.includes('Mission') && text.includes('Backend counts') && text.includes('headless') && text.includes('GPT final status') && text.includes('Patch / verify'), 'dashboard renderer must include required fields', { text });
-    assertGate(fs.readFileSync(path.join(root, 'src', 'scripts', 'zellij-dashboard-watch.ts'), 'utf8').includes('--interval-ms')
-        && fs.existsSync(path.join(root, 'dist', 'scripts', 'zellij-dashboard-watch.js')), 'dashboard watch script must support interval updates');
-    emitGate('zellij:dashboard-pane', { real_required: false, renderer_fields: true });
-    process.exit(0);
-}
-await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-try {
-    const record = await dashboard.openZellijDashboardPane({
-        root,
-        missionId,
-        sessionName,
-        cwd: root,
-        snapshot: {
-            mode: 'naruto',
-            backend_counts: { 'codex-sdk': 2, 'local-llm': 1 },
-            placement_counts: { 'zellij-pane': 2, headless: 1 },
-            active_workers: 3,
-            visible_panes: 2,
-            headless_workers: 1,
-            queue_depth: 7,
-            worktrees: { active: 2, completed: 1, retained: 0 },
-            local_llm: { tps: 12, queue: 1 },
-            gpt_final_status: 'pending',
-            gate_progress: 'release: 8/12'
-        }
-    });
-    const ok = record.ok === true && record.pane_kind === 'dashboard' && record.worker_pane === false && record.pane_id
-        && String(record.command || '').includes('zellij-dashboard-watch.js')
-        && String(record.command || '').includes('--interval-ms 1000');
-    assertGate(ok, 'real Zellij dashboard pane must open and not count as worker pane', record);
-    emitGate('zellij:dashboard-pane', {
-        real_required: true,
-        pane_id: record.pane_id,
-        pane_kind: record.pane_kind,
-        worker_pane: record.worker_pane,
-        mission_id: missionId,
-        session_name: sessionName
-    });
-}
-finally {
-    await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
-}
-//# sourceMappingURL=zellij-dashboard-pane-check.js.map

package/dist/scripts/zellij-developer-controls-check.js

@@ -1,20 +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 zellij = fs.readFileSync(path.join(root, 'src/commands/zellij.ts'), 'utf8');
-const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
-const report = {
-    schema: 'sks.zellij-developer-controls-check.v1',
-    ok: true,
-    zellij_controls: ['focus-worker', 'worker-logs', 'dashboard', 'close-drained'].every((token) => zellij.includes(token)),
-    naruto_controls: ['dashboard', 'workers'].every((token) => naruto.includes(`'${token}'`)),
-    dashboard_watch: zellij.includes('--watch') && zellij.includes('renderZellijDashboardText'),
-    focus_uses_pane_id: zellij.includes('focus-pane-id'),
-    logs_read_swarm: zellij.includes('agent-native-cli-session-swarm.json')
-};
-report.ok = report.zellij_controls && report.naruto_controls && report.dashboard_watch && report.focus_uses_pane_id && report.logs_read_swarm;
-assertGate(report.ok, 'Zellij/Naruto developer controls missing', report);
-emitGate('zellij:developer-controls', report);
-//# sourceMappingURL=zellij-developer-controls-check.js.map

package/dist/scripts/zellij-doctor-readiness-check.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// zellij:doctor-readiness (1.20.2 Area 5.1/5.2).
-//
-// Verifies: (1) the doctor readiness matrix exposes the Zellij block with the
-// mad_ready=false-while-cli_ready-can-stay-true semantics and tmux removed, and
-// (2) the screen-proof scrapeable section set is a strict SUBSET of the composed
-// lane section superset (so the two layers can never silently diverge).
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const { buildDoctorReadinessMatrix } = await importDist('core/doctor/doctor-readiness-matrix.js');
-const { ZELLIJ_LANE_SECTIONS, ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS } = await importDist('core/zellij/zellij-lane-renderer.js');
-// --- Matrix readiness semantics (synthetic inputs, hermetic) ---
-const baseConfig = { ok: true, checks: [
-        { name: 'node_process_read', ok: true },
-        { name: 'spawned_child_read', ok: true },
-        { name: 'actual_codex_cli_config_load', ok: true, status: 'passed' }
-    ], blockers: [] };
-// Zellij missing → mad_ready false, cli_ready can stay true.
-const missing = buildDoctorReadinessMatrix({
-    codex: { bin: '/usr/bin/codex', available: true },
-    codex_config: baseConfig,
-    zellij: { status: 'missing', ok: false }
-});
-assertGate(missing.mad_ready === false, 'zellij missing must make mad_ready=false', { missing });
-assertGate(missing.cli_ready === true, 'zellij missing must NOT block cli_ready', { missing });
-assertGate(missing.tmux_removed_runtime === true, 'tmux must be a removed runtime', { missing });
-assertGate(missing.zellij && Array.isArray(missing.zellij.required_for), 'matrix must carry a zellij block with required_for', { missing });
-// Zellij ok → mad_ready true (config readable).
-const okMatrix = buildDoctorReadinessMatrix({
-    codex: { bin: '/usr/bin/codex', available: true },
-    codex_config: baseConfig,
-    zellij: { status: 'ok', ok: true, version: '0.44.0', bin: 'zellij', min_version: '0.41.0' }
-});
-assertGate(okMatrix.mad_ready === true, 'zellij ok + readable config must make mad_ready=true', { okMatrix });
-// --- Section subset invariant (5.2) ---
-const superset = new Set(ZELLIJ_LANE_SECTIONS);
-const missingFromSuperset = ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.filter((s) => !superset.has(s));
-assertGate(missingFromSuperset.length === 0, 'screen-proof scrapeable sections must be a strict subset of lane sections', { missingFromSuperset });
-assertGate(ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length < ZELLIJ_LANE_SECTIONS.length, 'scrapeable subset must be smaller than the composed superset', {
-    scrapeable: ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length, lane: ZELLIJ_LANE_SECTIONS.length
-});
-// --- doctor source exposes the zellij_readiness block ---
-const doctorSource = fs.readFileSync(path.join(root, 'src/commands/doctor.ts'), 'utf8');
-assertGate(/zellij_readiness\s*:/.test(doctorSource), 'doctor result must expose a zellij_readiness block', {});
-// --- built dist smoke: JSON and human output must expose the Zellij section ---
-const doctorJson = spawnSync(process.execPath, ['dist/bin/sks.js', 'doctor', '--json'], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-assertGate(doctorJson.stdout.trim().startsWith('{'), 'built doctor --json must print JSON', { stderr: doctorJson.stderr.slice(-2000), status: doctorJson.status });
-const parsedDoctor = JSON.parse(doctorJson.stdout);
-assertGate(parsedDoctor.zellij_readiness && parsedDoctor.zellij_readiness.schema === 'sks.zellij-readiness.v1', 'built doctor --json must carry zellij_readiness block', { zellij_readiness: parsedDoctor.zellij_readiness || null });
-const doctorHuman = spawnSync(process.execPath, ['dist/bin/sks.js', 'doctor'], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-assertGate(/(^|\n)Zellij:\n/.test(doctorHuman.stdout), 'built doctor human output must include Zellij section', { stdout_tail: doctorHuman.stdout.slice(-2000), stderr_tail: doctorHuman.stderr.slice(-2000), status: doctorHuman.status });
-emitGate('zellij:doctor-readiness', {
-    mad_ready_when_missing: false,
-    cli_ready_when_missing: true,
-    built_json_smoke: true,
-    built_human_smoke: true,
-    lane_sections: ZELLIJ_LANE_SECTIONS.length,
-    scrapeable_sections: ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length
-});
-//# sourceMappingURL=zellij-doctor-readiness-check.js.map

package/dist/scripts/zellij-dynamic-pane-lifecycle-check.js

@@ -1,21 +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 report = {
-    schema: 'sks.zellij-dynamic-pane-lifecycle-check.v1',
-    ok: true,
-    close_success_default: worker.includes("SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0'"),
-    keep_failed_default: worker.includes('SKS_ZELLIJ_KEEP_FAILED_PANE'),
-    close_updates_right_column: worker.includes('closeWorkerInRightColumn'),
-    drained_status_recorded: manager.includes('worker_pane_drained'),
-    overflow_headless_recorded: swarm.includes('recordHeadlessWorkerInRightColumn')
-};
-report.ok = report.close_success_default && report.keep_failed_default && report.close_updates_right_column && report.drained_status_recorded && report.overflow_headless_recorded;
-assertGate(report.ok, 'dynamic pane lifecycle must close/drain workers and record headless overflow', report);
-emitGate('zellij:dynamic-pane-lifecycle', report);
-//# sourceMappingURL=zellij-dynamic-pane-lifecycle-check.js.map

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

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

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

@@ -1,356 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { ensureDir, packageRoot, writeTextAtomic } from '../core/fsx.js';
-import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
-import { runZellij } from '../core/zellij/zellij-command.js';
-import { openWorkerPane } from '../core/zellij/zellij-worker-pane-manager.js';
-const required = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
-if (!required) {
-    emitGate('zellij:first-slot-down-stack:real', {
-        ok: true,
-        status: 'skipped',
-        reason: 'SKS_REQUIRE_ZELLIJ_not_set'
-    });
-    process.exit(0);
-}
-const report = await runRealFirstSlotDownStackProof();
-assertGate(report.ok, 'Real Zellij first-slot-down-stack verification failed', report);
-emitGate('zellij:first-slot-down-stack:real', report);
-async function runRealFirstSlotDownStackProof() {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-first-slot-down-'));
-    const cwd = packageRoot();
-    const missionId = `M-zellij-first-slot-down-${process.pid}`;
-    const sessionName = `sks-first-slot-${process.pid}-${Date.now()}`;
-    const commands = [];
-    const blockers = [];
-    let record1 = null;
-    let record2 = null;
-    let listPanes = null;
-    let dumpScreen = null;
-    const dumpPath = path.join(root, 'zellij-dump-screen.txt');
-    try {
-        const capability = await checkZellijCapability({ root: cwd, require: true, writeReport: false });
-        blockers.push(...(capability.blockers || []).map((blocker) => `zellij_capability_${blocker}`));
-        const cleanupBefore = await runZellij(['kill-session', sessionName], { cwd, timeoutMs: 2500, optional: true });
-        commands.push(cleanupBefore);
-        const create = await runZellij(['attach', '--create-background', sessionName], { cwd, timeoutMs: 5000, optional: false });
-        commands.push(create);
-        if (!create.ok)
-            blockers.push(...create.blockers.map((blocker) => `zellij_create_${blocker}`));
-        await sleep(500);
-        const before = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: true });
-        commands.push(before);
-        const beforePanes = parsePaneRows(before.stdout_tail);
-        record1 = await openSlotRenderer(root, missionId, sessionName, 'slot-001', 1);
-        record2 = await openSlotRenderer(root, missionId, sessionName, 'slot-002', 1);
-        await sleep(750);
-        listPanes = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: false });
-        commands.push(listPanes);
-        if (!listPanes.ok)
-            blockers.push(...listPanes.blockers.map((blocker) => `zellij_list_panes_${blocker}`));
-        dumpScreen = await runZellij(['--session', sessionName, 'action', 'dump-screen', '--path', dumpPath, '--full'], { cwd, timeoutMs: 5000, optional: true });
-        commands.push(dumpScreen);
-        if (!dumpScreen.ok)
-            blockers.push(...dumpScreen.blockers.map((blocker) => `zellij_dump_screen_${blocker}`));
-        const panes = parsePaneRows(listPanes.stdout_tail);
-        const sourceFlowGeometry = evaluateGeometry(panes, record1, record2);
-        const layoutGeometryProof = await runFirstSlotLayoutGeometryProof({ cwd, root });
-        const geometry = layoutGeometryProof.geometry.ok ? layoutGeometryProof.geometry : sourceFlowGeometry;
-        const recordAssertions = [
-            beforePanes.length === 1,
-            record1.column_creation_direction_requested === 'right',
-            record1.worker_direction_requested === 'down',
-            record1.direction_requested === 'down',
-            record2.worker_direction_requested === 'down',
-            record2.direction_requested === 'down',
-            Boolean(record1.slot_column_anchor_pane_id),
-            record1.pane_kind === 'slot_status_renderer',
-            record1.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer'
-        ];
-        const proofBlockers = [
-            ...blockers,
-            ...(recordAssertions.every(Boolean) ? [] : ['zellij_first_slot_record_semantics_failed']),
-            ...geometry.blockers,
-            ...(layoutGeometryProof.ok ? [] : layoutGeometryProof.blockers)
-        ];
-        return {
-            schema: 'sks.zellij-first-slot-down-stack-real-check.v1',
-            ok: proofBlockers.length === 0,
-            status: proofBlockers.length ? 'blocked' : 'passed',
-            mission_id: missionId,
-            session_name: sessionName,
-            artifact_root: root,
-            dump_screen_path: dumpPath,
-            before_list_panes_ok: before.ok,
-            initial_terminal_pane_count: beforePanes.length,
-            list_panes_ok: listPanes.ok,
-            dump_screen_ok: dumpScreen.ok,
-            record1,
-            record2,
-            source_flow_geometry: sourceFlowGeometry,
-            layout_geometry_proof: layoutGeometryProof,
-            geometry,
-            command_blockers: commands.flatMap((row) => row?.blockers || []),
-            blockers: proofBlockers
-        };
-    }
-    catch (err) {
-        return {
-            schema: 'sks.zellij-first-slot-down-stack-real-check.v1',
-            ok: false,
-            status: 'blocked',
-            mission_id: missionId,
-            session_name: sessionName,
-            artifact_root: root,
-            dump_screen_path: dumpPath,
-            record1,
-            record2,
-            list_panes: listPanes,
-            dump_screen: dumpScreen,
-            command_blockers: commands.flatMap((row) => row?.blockers || []),
-            blockers: [`zellij_first_slot_real_exception:${err?.message || String(err)}`]
-        };
-    }
-    finally {
-        await runZellij(['kill-session', sessionName], { cwd, timeoutMs: 5000, optional: true }).catch(() => null);
-    }
-}
-async function runFirstSlotLayoutGeometryProof(input) {
-    const sessionName = `sks-first-slot-layout-${process.pid}-${Date.now()}`;
-    const layoutPath = path.join(input.root, 'first-slot-down-layout.kdl');
-    const dumpPath = path.join(input.root, 'first-slot-down-layout-dump.txt');
-    const commands = [];
-    const blockers = [];
-    let listPanes = null;
-    let dumpScreen = null;
-    try {
-        await writeTextAtomic(layoutPath, buildFirstSlotLayout(input.cwd));
-        commands.push(await runZellij(['kill-session', sessionName], { cwd: input.cwd, timeoutMs: 2500, optional: true }));
-        const launch = await runZellij(['attach', '--create-background', sessionName, 'options', '--default-layout', layoutPath], { cwd: input.cwd, timeoutMs: 5000, optional: false });
-        commands.push(launch);
-        if (!launch.ok)
-            blockers.push(...launch.blockers.map((blocker) => `zellij_first_slot_layout_launch_${blocker}`));
-        await sleep(1000);
-        listPanes = await runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: input.cwd, timeoutMs: 5000, optional: false });
-        commands.push(listPanes);
-        if (!listPanes.ok)
-            blockers.push(...listPanes.blockers.map((blocker) => `zellij_first_slot_layout_list_${blocker}`));
-        dumpScreen = await runZellij(['--session', sessionName, 'action', 'dump-screen', '--path', dumpPath, '--full'], { cwd: input.cwd, timeoutMs: 5000, optional: true });
-        commands.push(dumpScreen);
-        if (!dumpScreen.ok)
-            blockers.push(...dumpScreen.blockers.map((blocker) => `zellij_first_slot_layout_dump_${blocker}`));
-        const panes = parsePaneRows(listPanes.stdout_tail);
-        const geometry = evaluateNamedGeometry(panes);
-        const proofBlockers = [...blockers, ...geometry.blockers];
-        return {
-            schema: 'sks.zellij-first-slot-down-stack-layout-geometry.v1',
-            ok: proofBlockers.length === 0,
-            session_name: sessionName,
-            layout_path: layoutPath,
-            dump_screen_path: dumpPath,
-            list_panes_ok: listPanes.ok,
-            dump_screen_ok: dumpScreen.ok,
-            geometry,
-            command_blockers: commands.flatMap((row) => row?.blockers || []),
-            blockers: proofBlockers
-        };
-    }
-    catch (err) {
-        return {
-            schema: 'sks.zellij-first-slot-down-stack-layout-geometry.v1',
-            ok: false,
-            session_name: sessionName,
-            layout_path: layoutPath,
-            dump_screen_path: dumpPath,
-            list_panes_ok: listPanes?.ok || false,
-            dump_screen_ok: dumpScreen?.ok || false,
-            geometry: { ok: false, blockers: ['zellij_first_slot_layout_exception'] },
-            command_blockers: commands.flatMap((row) => row?.blockers || []),
-            blockers: [`zellij_first_slot_layout_exception:${err?.message || String(err)}`]
-        };
-    }
-    finally {
-        await runZellij(['kill-session', sessionName], { cwd: input.cwd, timeoutMs: 5000, optional: true }).catch(() => null);
-    }
-}
-async function openSlotRenderer(root, missionId, sessionName, slotId, generationIndex) {
-    const workerArtifactDir = path.join('workers', slotId, `gen-${generationIndex}`);
-    await ensureDir(path.join(root, workerArtifactDir));
-    const command = [
-        process.execPath,
-        path.join(packageRoot(), 'dist/bin/sks.js'),
-        'zellij-slot-pane',
-        '--mission',
-        missionId,
-        '--artifact-dir',
-        path.join(root, workerArtifactDir),
-        '--mode',
-        'compact-slots',
-        '--watch'
-    ].map(shellQuote).join(' ');
-    return openWorkerPane({
-        root,
-        missionId,
-        sessionName,
-        slotId,
-        generationIndex,
-        sessionId: `${slotId}-gen-${generationIndex}`,
-        workerArtifactDir,
-        workerCommand: command,
-        resultPath: path.join(workerArtifactDir, 'worker-result.json'),
-        heartbeatPath: path.join(workerArtifactDir, 'worker-heartbeat.jsonl'),
-        patchEnvelopePath: path.join(workerArtifactDir, 'worker-patch-envelope.json'),
-        stdoutLog: path.join(workerArtifactDir, 'worker.stdout.log'),
-        stderrLog: path.join(workerArtifactDir, 'worker.stderr.log'),
-        cwd: packageRoot(),
-        serviceTier: 'fast',
-        backend: 'codex-sdk',
-        statusLabel: 'slot-renderer',
-        rightColumnMode: 'spawn-on-first-worker',
-        visiblePaneCap: 2,
-        uiMode: 'compact-slots'
-    });
-}
-function evaluateGeometry(panes, record1, record2) {
-    const anchor = findPane(panes, record1?.slot_column_anchor_pane_id);
-    const first = findPane(panes, record1?.pane_id);
-    const second = findPane(panes, record2?.pane_id);
-    const sameColumn = Boolean(anchor && first && second)
-        && Math.abs(first.x - anchor.x) <= 2
-        && Math.abs(second.x - anchor.x) <= 2
-        && Math.abs(first.width - anchor.width) <= 4
-        && Math.abs(second.width - anchor.width) <= 4;
-    const stackedDown = Boolean(anchor && first && second)
-        && first.y > anchor.y
-        && second.y > first.y;
-    const blockers = [
-        ...(anchor ? [] : ['slot_anchor_pane_missing']),
-        ...(first ? [] : ['first_slot_pane_missing']),
-        ...(second ? [] : ['second_slot_pane_missing']),
-        ...(sameColumn ? [] : ['slot_panes_not_in_anchor_column']),
-        ...(stackedDown ? [] : ['slot_panes_not_stacked_down'])
-    ];
-    return {
-        ok: blockers.length === 0,
-        anchor,
-        first,
-        second,
-        same_right_column_x_range: sameColumn,
-        first_slot_y_greater_than_anchor: Boolean(anchor && first && first.y > anchor.y),
-        second_slot_y_greater_than_first: Boolean(first && second && second.y > first.y),
-        blockers
-    };
-}
-function evaluateNamedGeometry(panes) {
-    const main = panes.find((pane) => pane.title === 'orchestrator') || null;
-    const anchor = panes.find((pane) => pane.title === 'SLOTS') || null;
-    const first = panes.find((pane) => pane.title === 'slot-001') || null;
-    const second = panes.find((pane) => pane.title === 'slot-002') || null;
-    const sameColumn = Boolean(anchor && first && second)
-        && Math.abs(first.x - anchor.x) <= 2
-        && Math.abs(second.x - anchor.x) <= 2
-        && Math.abs(first.width - anchor.width) <= 4
-        && Math.abs(second.width - anchor.width) <= 4;
-    const rightOfMain = Boolean(main && anchor && first && second)
-        && anchor.x >= main.x + main.width - 2
-        && first.x >= main.x + main.width - 2
-        && second.x >= main.x + main.width - 2;
-    const stackedDown = Boolean(anchor && first && second)
-        && first.y > anchor.y
-        && second.y > first.y;
-    const blockers = [
-        ...(main ? [] : ['layout_main_pane_missing']),
-        ...(anchor ? [] : ['layout_slot_anchor_pane_missing']),
-        ...(first ? [] : ['layout_first_slot_pane_missing']),
-        ...(second ? [] : ['layout_second_slot_pane_missing']),
-        ...(sameColumn ? [] : ['layout_slot_panes_not_in_anchor_column']),
-        ...(rightOfMain ? [] : ['layout_slot_column_not_right_of_main']),
-        ...(stackedDown ? [] : ['layout_slot_panes_not_stacked_down'])
-    ];
-    return {
-        ok: blockers.length === 0,
-        source: 'zellij_layout_equivalent',
-        main,
-        anchor,
-        first,
-        second,
-        same_right_column_x_range: sameColumn,
-        right_of_main: rightOfMain,
-        first_slot_y_greater_than_anchor: Boolean(anchor && first && first.y > anchor.y),
-        second_slot_y_greater_than_first: Boolean(first && second && second.y > first.y),
-        blockers
-    };
-}
-function parsePaneRows(text) {
-    try {
-        const parsed = JSON.parse(String(text || '[]'));
-        const rows = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.panes) ? parsed.panes : [];
-        return rows.filter((row) => row && row.is_plugin !== true && row.exited !== true).map((row) => ({
-            pane_id: String(row.pane_id ?? row.paneId ?? row.id ?? ''),
-            title: String(row.title || row.name || row.pane_name || ''),
-            x: Number(row.pane_x ?? row.x ?? 0),
-            y: Number(row.pane_y ?? row.y ?? 0),
-            width: Number(row.pane_columns ?? row.width ?? 0),
-            height: Number(row.pane_rows ?? row.height ?? 0),
-            raw: row
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-function findPane(panes, paneId) {
-    const id = paneId == null ? '' : String(paneId);
-    if (!id)
-        return null;
-    const normalized = normalizePaneId(id);
-    return panes.find((pane) => normalizePaneId(pane.pane_id) === normalized) || null;
-}
-function buildFirstSlotLayout(cwd) {
-    const hold = 'sleep 30';
-    return [
-        'layout {',
-        '    default_tab_template {',
-        '        pane size=1 borderless=true {',
-        '            plugin location="zellij:tab-bar"',
-        '        }',
-        '        children',
-        '        pane size=2 borderless=true {',
-        '            plugin location="zellij:status-bar"',
-        '        }',
-        '    }',
-        `    tab name="SKS first slot down proof" cwd=${JSON.stringify(cwd)} split_direction="vertical" {`,
-        '        pane name="orchestrator" command="sh" {',
-        `            args "-lc" ${JSON.stringify(hold)}`,
-        '        }',
-        '        pane name="slot-column" split_direction="horizontal" {',
-        '            pane name="SLOTS" command="sh" {',
-        `                args "-lc" ${JSON.stringify(hold)}`,
-        '            }',
-        '            pane name="slot-001" command="sh" {',
-        `                args "-lc" ${JSON.stringify(hold)}`,
-        '            }',
-        '            pane name="slot-002" command="sh" {',
-        `                args "-lc" ${JSON.stringify(hold)}`,
-        '            }',
-        '        }',
-        '    }',
-        '}',
-        ''
-    ].join('\n');
-}
-function normalizePaneId(value) {
-    return String(value || '').replace(/^terminal_/, '').replace(/^Terminal\((\d+)\)$/i, '$1');
-}
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-function shellQuote(value) {
-    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value))
-        return value;
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-//# sourceMappingURL=zellij-first-slot-down-stack-real-check.js.map