sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const src = readText('src/core/zellij/zellij-worker-pane-manager.ts');
+assertGate(src.includes('checkZellijStackedPaneCapability'), 'worker pane manager must read stacked capability before --stacked');
+assertGate(src.includes("'--stacked'"), 'worker pane manager must still support native --stacked when capability allows');
+assertGate(src.includes('worker_stacked_requested') && src.includes('worker_stacked_applied'), 'worker pane record must capture requested/applied stacked fields');
+assertGate(src.includes('worker_stacked_fallback_mode'), 'worker pane record must capture fallback mode');
+assertGate(src.includes('zellij_stacked_pane_rejected_fallback_down'), 'worker pane manager must record rejected --stacked fallback');
+emitGate('zellij:stacked-capability-routing');
+//# sourceMappingURL=zellij-stacked-capability-routing-check.js.map

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

@@ -0,0 +1,81 @@
+#!/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-stacked-version-matrix-check.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { resolveZellijStackedPaneCapability, ZELLIJ_MIN_VERSION, ZELLIJ_STACKED_PANE_MIN_VERSION } from '../core/zellij/zellij-capability.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const fixtures = [
+    ['zellij 0.43.0', true],
+    ['zellij 0.43.1', true],
+    ['zellij 0.44.0', true],
+    ['v0.43.0', true],
+    ['zellij 0.42.2', false],
+    ['zellij 0.41.0', false],
+    ['unknown', false]
+];
+assertGate(ZELLIJ_MIN_VERSION === ZELLIJ_STACKED_PANE_MIN_VERSION, 'doctor minimum zellij version must match stacked-pane support minimum', {
+    ZELLIJ_MIN_VERSION,
+    ZELLIJ_STACKED_PANE_MIN_VERSION
+});
+for (const [versionText, expected] of fixtures) {
+    const report = resolveZellijStackedPaneCapability({ ok: true, versionText });
+    assertGate(report.supports_stacked_panes === expected, `stacked matrix mismatch: ${versionText}`, report);
+    if (expected) {
+        assertGate(report.fallback_mode === 'native-stacked', 'supported zellij must use native stacked fallback mode', report);
+    }
+    else {
+        assertGate(report.fallback_mode !== 'native-stacked', 'unsupported zellij must not use native stacked fallback mode', report);
+        if (report.parsed_version)
+            assertGate(report.requires_update === true, 'unsupported parsed zellij must require update', report);
+    }
+}
+emitGate('zellij:stacked-version-matrix', { fixtures: fixtures.length });
+//# sourceMappingURL=zellij-stacked-version-matrix-check.js.map

package/dist/scripts/zellij-stacked-version-parser-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { parseZellijVersionText } from '../core/zellij/zellij-command.js';
+import { zellijSupportsStackedPanes } from '../core/zellij/zellij-capability.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const fixtures = [
+    ['zellij 0.43.1', '0.43.1', true],
+    ['zellij 0.44.0', '0.44.0', true],
+    ['0.43.0', '0.43.0', true],
+    ['v0.43.0', '0.43.0', true],
+    ['zellij v0.43.0', '0.43.0', true],
+    ['zellij 0.43.0-dev', '0.43.0', true],
+    ['zellij 0.42.2', '0.42.2', false],
+    ['unknown', null, false]
+];
+for (const [input, parsed, supported] of fixtures) {
+    assertGate(parseZellijVersionText(input) === parsed, `version parse mismatch: ${input}`, { input, parsed: parseZellijVersionText(input) });
+    assertGate(zellijSupportsStackedPanes(input) === supported, `stacked support mismatch: ${input}`, { input, supported });
+}
+emitGate('zellij:stacked-version-parser', { fixtures: fixtures.length });
+//# sourceMappingURL=zellij-stacked-version-parser-check.js.map

package/dist/scripts/zellij-ui-design-check.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { root, assertGate, emitGate, importDist, readText } from './sks-1-18-gate-lib.js';
+// Validates the lane UI design constraints: no line overflow at common widths,
+// all required sections present, blocker cap + report pointer, middle-ellipsis
+// for long paths, NO_COLOR / color-strippability, and that footer `sks ...`
+// commands are really registered.
+const ESC = '';
+const ANSI_RE = /\[[0-9;]*m/g;
+const mod = await importDist('core/zellij/zellij-lane-renderer.js');
+const { composeLaneFrame, ZELLIJ_LANE_FOOTER_KEYS, ZELLIJ_LANE_MAX_BLOCKERS, ZELLIJ_LANE_SECTIONS } = mod;
+assertGate(typeof composeLaneFrame === 'function', 'composeLaneFrame export missing', {});
+assertGate(Array.isArray(ZELLIJ_LANE_FOOTER_KEYS), 'ZELLIJ_LANE_FOOTER_KEYS export missing', {});
+assertGate(ZELLIJ_LANE_MAX_BLOCKERS === 3, 'ZELLIJ_LANE_MAX_BLOCKERS should be 3', { actual: ZELLIJ_LANE_MAX_BLOCKERS });
+const longPath = `src/core/${'deep/'.repeat(40)}final-file.ts`;
+const view = {
+    missionId: 'M-ui',
+    slot: 'slot-001',
+    updatedAt: '2026-05-30T00:00:00.000Z',
+    mode: 'Naruto',
+    fast: 'on · service_tier=fast',
+    workers: 'active 5/20 · clone 003/100 · pending 12',
+    codexChild: 'active 5',
+    currentFile: longPath,
+    queue: 'pending 12 · applying 2 · verified 8 · blocked 0',
+    patch: 'apply ok · verify ok · model-authored 3',
+    lease: 'ok',
+    protectedPaths: 'ok',
+    rollback: 'ready',
+    blockers: ['blocker_one', 'blocker_two', 'blocker_three', 'blocker_four', 'blocker_five', 'blocker_six'],
+    reports: '.sneakoscope/reports/agent-proof-evidence.json',
+    laneNote: 'fixture'
+};
+// Canonical composed-frame superset (shared with screen-proof's scrapeable subset).
+const REQUIRED_SECTIONS = ZELLIJ_LANE_SECTIONS;
+// No-overflow + all-sections across the common Zellij pane widths.
+for (const width of [80, 100, 120]) {
+    const frame = composeLaneFrame(view, { width, color: false });
+    const lines = frame.split('\n');
+    for (const line of lines) {
+        assertGate(line.length <= width, `line_overflow_at_${width}`, { width, line, length: line.length });
+    }
+    for (const token of REQUIRED_SECTIONS) {
+        assertGate(frame.includes(token), `missing section "${token}" at width ${width}`, { width, token });
+    }
+}
+// Blocker cap at width 100: first 3 shown + "+3 more" + report path; the rest hidden.
+const frame100 = composeLaneFrame(view, { width: 100, color: false });
+for (const shown of ['blocker_one', 'blocker_two', 'blocker_three']) {
+    assertGate(frame100.includes(shown), `blocker "${shown}" should be shown`, {});
+}
+assertGate(frame100.includes('+3 more'), 'should summarize "+3 more" overflow blockers', {});
+assertGate(frame100.includes(view.reports), 'overflow summary should point at the report path', {});
+for (const hidden of ['blocker_four', 'blocker_five', 'blocker_six']) {
+    assertGate(!frame100.includes(hidden), `blocker "${hidden}" should be capped/hidden`, {});
+}
+// Middle-ellipsis: long path is truncated with '…' and the full run is gone.
+const frame80 = composeLaneFrame(view, { width: 80, color: false });
+assertGate(frame80.includes('…'), 'long path should be middle-ellipsized', {});
+assertGate(!frame80.includes(longPath), 'full long path should not appear (truncated)', {});
+// NO_COLOR respect: when color is derived from NO_COLOR, no ESC bytes appear.
+process.env.NO_COLOR = '1';
+const frameA = composeLaneFrame(view, { width: 100 });
+assertGate(!frameA.includes(ESC), 'NO_COLOR=1 must suppress ANSI escape bytes', {});
+const frameB = composeLaneFrame(view, { width: 100, color: false });
+assertGate(!frameB.includes(ESC), 'color:false must suppress ANSI escape bytes', {});
+delete process.env.NO_COLOR;
+// With color on, stripping ANSI must still leave all sections readable.
+const frameC = composeLaneFrame(view, { width: 100, color: true });
+const stripped = frameC.replace(ANSI_RE, '');
+for (const token of REQUIRED_SECTIONS) {
+    assertGate(stripped.includes(token), `section "${token}" must survive ANSI strip`, { token });
+}
+// Footer `sks ...` commands must be real registry keys.
+const registry = readText('src/cli/command-registry.ts');
+const footerCommands = [];
+for (const key of ZELLIJ_LANE_FOOTER_KEYS) {
+    if (!key.startsWith('sks '))
+        continue;
+    const cmd = key.split(/\s+/)[1];
+    if (cmd)
+        footerCommands.push(cmd);
+}
+for (const cmd of footerCommands) {
+    const registered = registry.includes(`\n  ${cmd}:`) ||
+        registry.includes(`'${cmd}':`) ||
+        registry.includes(`"${cmd}":`);
+    assertGate(registered, `footer command "${cmd}" is not a registered CLI command`, { cmd });
+}
+for (const required of ['doctor', 'zellij', 'agent']) {
+    assertGate(footerCommands.includes(required), `expected footer command "${required}" not found`, { footerCommands });
+}
+const report = {
+    schema: 'sks.zellij-ui-design.v1',
+    ok: true,
+    widths: [80, 100, 120],
+    sections: REQUIRED_SECTIONS.length,
+    footer_commands: footerCommands
+};
+await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'zellij-ui-design.json'), `${JSON.stringify(report, null, 2)}\n`);
+emitGate('zellij:ui-design', { widths: [80, 100, 120], sections: REQUIRED_SECTIONS.length });
+//# sourceMappingURL=zellij-ui-design-check.js.map

package/dist/scripts/zellij-update-missing-self-heal-check.js

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

package/dist/scripts/zellij-update-prompt-matrix-check.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { resolveZellijUpdatePromptMode } from '../core/zellij/zellij-update.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const matrix = [
+    ['interactive tty + update available', { env: {}, headless: false }, 'interactive-prompt'],
+    ['CI=1', { env: { CI: '1' }, headless: false }, 'nonblocking-notice'],
+    ['SKS_NO_QUESTION=1', { env: { SKS_NO_QUESTION: '1' }, headless: false }, 'nonblocking-notice'],
+    ['--skip-zellij-update', { env: {}, skipFlag: true, headless: false }, 'skip'],
+    ['SKS_SKIP_ZELLIJ_UPDATE=1', { env: { SKS_SKIP_ZELLIJ_UPDATE: '1' }, headless: false }, 'skip'],
+    ['no zellij installed/headless fallback', { env: {}, headless: true }, 'nonblocking-notice']
+];
+for (const [name, input, expected] of matrix) {
+    const actual = resolveZellijUpdatePromptMode(input);
+    assertGate(actual === expected, `zellij prompt matrix mismatch: ${name}`, { name, input, expected, actual });
+}
+emitGate('zellij:update-prompt-matrix', { matrix: matrix.length });
+//# sourceMappingURL=zellij-update-prompt-matrix-check.js.map

package/dist/scripts/zellij-update-prompt-mode-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { resolveZellijUpdatePromptMode } from '../core/zellij/zellij-update.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const fixtures = [
+    [{ env: {}, headless: false }, 'interactive-prompt'],
+    [{ env: { CI: '1' }, headless: false }, 'nonblocking-notice'],
+    [{ env: { CI: 'true' }, headless: false }, 'nonblocking-notice'],
+    [{ env: { SKS_NO_QUESTION: '1' }, headless: false }, 'nonblocking-notice'],
+    [{ env: {}, noQuestion: true, headless: false }, 'nonblocking-notice'],
+    [{ env: {}, headless: true }, 'nonblocking-notice'],
+    [{ env: { SKS_SKIP_ZELLIJ_UPDATE: '1' }, headless: false }, 'skip'],
+    [{ env: {}, skipFlag: true, headless: false }, 'skip']
+];
+for (const [input, expected] of fixtures) {
+    const actual = resolveZellijUpdatePromptMode(input);
+    assertGate(actual === expected, 'zellij update prompt mode mismatch', { input, expected, actual });
+}
+emitGate('zellij:update-prompt-mode', { fixtures: fixtures.length });
+//# sourceMappingURL=zellij-update-prompt-mode-check.js.map

package/dist/scripts/zellij-update-prompt-safety-check.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const src = readText('src/core/zellij/zellij-update.ts');
+assertGate(src.includes('resolveZellijUpdatePromptMode'), 'zellij update launch path must use prompt mode resolver');
+assertGate(src.includes("mode === 'skip'") && src.indexOf("mode === 'skip'") < src.indexOf('const notice = await checkZellijUpdateNotice'), 'skip mode must avoid update notice network/cache call');
+assertGate(src.includes("mode === 'nonblocking-notice'") && src.includes('Run: ${notice.upgrade_command}'), 'nonblocking mode must print notice and continue');
+assertGate(src.includes('process.stdin.isTTY') && src.includes('process.stdout.isTTY'), 'interactive prompt must be tty gated');
+emitGate('zellij:update-prompt-safety');
+//# sourceMappingURL=zellij-update-prompt-safety-check.js.map

package/dist/scripts/zellij-worker-pane-manager-check.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { packageRoot } from '../core/fsx.js';
+import { buildWorkerPaneArtifact, evaluateZellijWorkerPaneSpawnOrder, isRealZellijWorkerPaneIdSource } from '../core/zellij/zellij-worker-pane-manager.js';
+const root = packageRoot();
+const source = await fs.readFile(path.join(root, 'src', 'core', 'zellij', 'zellij-worker-pane-manager.ts'), 'utf8');
+const artifact = buildWorkerPaneArtifact({
+    root,
+    missionId: 'M-worker-pane-manager',
+    sessionName: 'sks-M-worker-pane-manager',
+    slotId: 'slot-001',
+    generationIndex: 7,
+    sessionId: 'slot-001-gen-7',
+    workerArtifactDir: 'sessions/slot-001/gen-7/worker',
+    resultPath: 'sessions/slot-001/gen-7/worker/worker-result.json',
+    heartbeatPath: 'sessions/slot-001/gen-7/worker/worker-heartbeat.jsonl',
+    patchEnvelopePath: 'sessions/slot-001/gen-7/worker/worker-patch-envelope.json',
+    stdoutLog: 'sessions/slot-001/gen-7/worker/worker.stdout.log',
+    stderrLog: 'sessions/slot-001/gen-7/worker/worker.stderr.log',
+    paneId: '42',
+    paneIdSource: 'zellij_worker_new_pane_stdout',
+    providerContext: {
+        schema: 'sks.provider-context.v1',
+        generated_at: new Date().toISOString(),
+        provider: 'codex-lb',
+        auth_mode: 'codex_lb_key',
+        route: '$Naruto',
+        service_tier: 'fast',
+        source: 'codex_lb',
+        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'
+        }
+    },
+    serviceTier: 'fast',
+    sdkThreadId: 'sdk-thread-7',
+    sdkRunId: 'sdk-run-7',
+    streamEventCount: 4,
+    structuredOutputValid: true,
+    status: 'running',
+    workerCommand: 'node dist/bin/sks.js --agent worker',
+    blockers: []
+});
+const slotRendererArtifact = buildWorkerPaneArtifact({
+    root,
+    missionId: 'M-worker-pane-manager',
+    sessionName: 'sks-M-worker-pane-manager',
+    slotId: 'slot-002',
+    generationIndex: 1,
+    sessionId: 'slot-002-gen-1',
+    workerArtifactDir: 'sessions/slot-002/gen-1/worker',
+    resultPath: 'sessions/slot-002/gen-1/worker/worker-result.json',
+    heartbeatPath: 'sessions/slot-002/gen-1/worker/worker-heartbeat.jsonl',
+    patchEnvelopePath: 'sessions/slot-002/gen-1/worker/worker-patch-envelope.json',
+    stdoutLog: 'sessions/slot-002/gen-1/worker/worker.stdout.log',
+    stderrLog: 'sessions/slot-002/gen-1/worker/worker.stderr.log',
+    paneId: '43',
+    paneIdSource: 'zellij_worker_new_pane_stdout',
+    status: 'running',
+    workerCommand: 'node dist/bin/sks.js zellij-slot-pane --watch',
+    blockers: []
+});
+const spawnOrder = evaluateZellijWorkerPaneSpawnOrder([
+    { event_type: 'session_launch_started' },
+    { event_type: 'zellij_worker_pane_created' },
+    { event_type: 'worker_started' },
+    { event_type: 'codex_sdk_thread_started' },
+    { event_type: 'result_written' },
+    { event_type: 'pane_closed' }
+]);
+const syntheticRejected = !isRealZellijWorkerPaneIdSource('synthetic_layout_pending_proof')
+    && !isRealZellijWorkerPaneIdSource('zellij_worker_pane_stdout_missing');
+const sourceOk = source.includes("action', 'new-pane'")
+    && source.includes("'--direction', directionRequested")
+    && source.includes("'--near-current-pane'")
+    && source.includes("'--name', paneName")
+    && source.includes("'--', 'sh', '-lc'")
+    && source.includes('zellij_worker_new_pane_stdout')
+    && source.includes('zellij_worker_list_panes')
+    && source.includes('provider_context');
+const ok = artifact.ok
+    && artifact.pane_name === 'slot-001/gen-7 · codex-sdk · fast · codex-lb · running'
+    && artifact.pane_kind === 'worker_codex_sdk'
+    && artifact.provider === 'codex-lb'
+    && artifact.service_tier === 'fast'
+    && artifact.direction_requested === 'down'
+    && artifact.direction_applied === 'not_applied'
+    && artifact.sdk_thread_id === 'sdk-thread-7'
+    && artifact.stream_event_count === 4
+    && artifact.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+    && slotRendererArtifact.pane_kind === 'slot_status_renderer'
+    && slotRendererArtifact.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer'
+    && syntheticRejected
+    && spawnOrder.ok
+    && sourceOk;
+emit({ schema: 'sks.zellij-worker-pane-manager-check.v1', ok, artifact, synthetic_rejected: syntheticRejected, spawn_order: spawnOrder, source_ok: sourceOk, blockers: ok ? [] : ['zellij_worker_pane_manager_contract_failed'] });
+function emit(report) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=zellij-worker-pane-manager-check.js.map

package/dist/scripts/zellij-worker-pane-manager-single-owner-check.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { packageRoot } from '../core/fsx.js';
+const root = packageRoot();
+const managerPath = path.join(root, 'src', 'core', 'zellij', 'zellij-worker-pane-manager.ts');
+const nativePath = path.join(root, 'src', 'core', 'agents', 'native-cli-session-swarm.ts');
+const manager = await fs.readFile(managerPath, 'utf8');
+const native = await fs.readFile(nativePath, 'utf8');
+const managerOwnsNewPane = /runZellij\(\[[\s\S]{0,800}'new-pane'/.test(manager)
+    || (manager.includes("'new-pane'") && manager.includes('const newPaneArgs') && manager.includes('runZellij(newPaneArgs'));
+const nativeDirectNewPane = /runZellij\(\[[\s\S]{0,500}'new-pane'/.test(native);
+const nativeUsesManager = native.includes('openWorkerPane({') && native.includes('closeWorkerPane({');
+const dynamicDirection = manager.includes("'--direction', directionRequested") && manager.includes("'--near-current-pane'");
+const fallbackRecorded = manager.includes('worker_direction_applied')
+    && manager.includes("directionApplied = rightColumn ? 'down' : 'unknown'")
+    && manager.includes("directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied'");
+const slotAnchorOwned = manager.includes('buildZellijSlotColumnAnchorCommand')
+    && manager.includes("recordSlotColumnAnchorInRightColumn")
+    && manager.includes("'--direction', 'right', '--name', 'SLOTS'");
+const ok = managerOwnsNewPane && !nativeDirectNewPane && nativeUsesManager && dynamicDirection && fallbackRecorded && slotAnchorOwned;
+emit({
+    schema: 'sks.zellij-worker-pane-manager-single-owner-check.v1',
+    ok,
+    checks: {
+        manager_owns_new_pane: managerOwnsNewPane,
+        native_direct_new_pane_absent: !nativeDirectNewPane,
+        native_uses_manager: nativeUsesManager,
+        dynamic_direction_requested: dynamicDirection,
+        fallback_recorded: fallbackRecorded,
+        slot_anchor_owned: slotAnchorOwned
+    },
+    blockers: ok ? [] : [
+        ...(!managerOwnsNewPane ? ['worker_pane_manager_new_pane_missing'] : []),
+        ...(nativeDirectNewPane ? ['native_cli_session_swarm_direct_new_pane'] : []),
+        ...(!nativeUsesManager ? ['native_cli_session_swarm_not_using_worker_pane_manager'] : []),
+        ...(!dynamicDirection ? ['zellij_worker_dynamic_direction_missing'] : []),
+        ...(!fallbackRecorded ? ['zellij_worker_direction_fallback_not_recorded'] : []),
+        ...(!slotAnchorOwned ? ['zellij_worker_slot_column_anchor_not_owned'] : [])
+    ]
+});
+function emit(report) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=zellij-worker-pane-manager-single-owner-check.js.map