sneakoscope 4.8.7 → 5.3.0

package/dist/scripts/team-patch-swarm-route-blackbox.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runPatchSwarmRouteBlackbox } from './agent-patch-swarm-gate-lib.js';
-await runPatchSwarmRouteBlackbox({
-    gate: 'team:patch-swarm-route-blackbox',
-    route: '$Team',
-    routeCommand: 'sks team',
-    reportName: 'team-patch-swarm-route-blackbox'
-});
-//# sourceMappingURL=team-patch-swarm-route-blackbox.js.map

package/dist/scripts/triwiki-affected-graph-blackbox.js

@@ -1,28 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { assertGate, emitGate, makeTempRoot } from './sks-3-1-8-check-lib.js';
-import { importDist } from './sks-1-18-gate-lib.js';
-const tmp = await makeTempRoot('sks-triwiki-affected-');
-await fs.writeFile(path.join(tmp, 'package.json'), JSON.stringify({ scripts: { 'triwiki:affected-graph': 'node fixture.js' } }));
-await fs.writeFile(path.join(tmp, 'release-gates.v2.json'), JSON.stringify({
-    schema: 'sks.release-gates.v2',
-    gates: [{
-            id: 'triwiki:affected-graph',
-            command: 'npm run triwiki:affected-graph --silent',
-            deps: [],
-            resource: ['cpu-light'],
-            side_effect: 'hermetic',
-            timeout_ms: 1000,
-            cache: { enabled: true, inputs: ['src/core/triwiki/**'] },
-            isolation: { home: 'temp', codex_home: 'temp', report_dir: 'per-gate' },
-            preset: ['release']
-        }]
-}, null, 2));
-await fs.mkdir(path.join(tmp, 'src/core/triwiki'), { recursive: true });
-await fs.writeFile(path.join(tmp, 'src/core/triwiki/a.ts'), 'export const a = 1;\n');
-const mod = await importDist('core/triwiki/triwiki-affected-graph.js');
-const graph = mod.computeTriWikiAffectedGraph({ root: tmp, changedFiles: ['src/core/triwiki/a.ts'], tier: 'affected' });
-assertGate(graph.gates.includes('triwiki:affected-graph'), 'blackbox affected graph must select changed gate', graph);
-emitGate('triwiki:affected-graph-blackbox', { gates: graph.gates });
-//# sourceMappingURL=triwiki-affected-graph-blackbox.js.map

package/dist/scripts/triwiki-proof-bank-blackbox.js

@@ -1,30 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { assertGate, emitGate, makeTempRoot } from './sks-3-1-8-check-lib.js';
-import { importDist } from './sks-1-18-gate-lib.js';
-const tmp = await makeTempRoot('sks-triwiki-proof-bank-');
-await fs.writeFile(path.join(tmp, 'package.json'), JSON.stringify({ version: '4.0.0' }));
-await fs.writeFile(path.join(tmp, 'package-lock.json'), JSON.stringify({ lockfileVersion: 3 }));
-const cardMod = await importDist('core/triwiki/triwiki-proof-card.js');
-const bank = await importDist('core/triwiki/triwiki-proof-bank.js');
-const card = cardMod.createTriWikiProofCard({
-    subject_type: 'gate',
-    subject_id: 'fixture:gate',
-    cache_key: 'fixture-cache',
-    input_hash: 'input',
-    implementation_hash: 'impl',
-    tool_version: '4.0.0',
-    fixture_version: 'sks-4.0.0',
-    result: 'passed',
-    reusable: true,
-    evidence: { blackbox: true }
-});
-bank.writeTriWikiProofCard(tmp, card);
-const hit = bank.readReusableTriWikiProofCard({ root: tmp, subjectId: 'fixture:gate', cacheKey: 'fixture-cache' });
-assertGate(hit.hit === true && hit.card?.proof_id === card.proof_id, 'proof bank must reuse matching passed card', hit);
-bank.markTriWikiProofInvalidated(tmp, 'fixture:gate', card.proof_id, 'fixture_invalidated');
-const miss = bank.readReusableTriWikiProofCard({ root: tmp, subjectId: 'fixture:gate', cacheKey: 'fixture-cache' });
-assertGate(miss.hit === false, 'invalidated proof card must not be reused', miss);
-emitGate('triwiki:proof-bank-blackbox', { hit: true, invalidation_blocked_reuse: true });
-//# sourceMappingURL=triwiki-proof-bank-blackbox.js.map

package/dist/scripts/triwiki-proof-bank-lock-blackbox.js

@@ -1,7 +0,0 @@
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const source = readText('src/core/triwiki/triwiki-proof-bank.ts');
-assertGate(source.includes('function pidAlive(pid: number): boolean'), 'proof bank lock must use a pidAlive helper');
-assertGate(!source.includes('process.kill(raw.pid, 0) !== undefined'), 'proof bank lock must not compare process.kill(pid, 0) to undefined');
-assertGate(source.includes("code === 'EPERM'"), 'proof bank lock must treat EPERM as alive');
-emitGate('triwiki:proof-bank-lock-blackbox');
-//# sourceMappingURL=triwiki-proof-bank-lock-blackbox.js.map

package/dist/scripts/ux-patch-swarm-route-blackbox.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runPatchSwarmRouteBlackbox } from './agent-patch-swarm-gate-lib.js';
-await runPatchSwarmRouteBlackbox({
-    gate: 'ux:patch-swarm-route-blackbox',
-    route: '$UX-Review',
-    routeCommand: 'sks ux-review',
-    reportName: 'ux-patch-swarm-route-blackbox'
-});
-//# sourceMappingURL=ux-patch-swarm-route-blackbox.js.map

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