sneakoscope 7.1.0 → 7.3.0

package/dist/scripts/zellij-spawn-on-demand-layout-check.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { packageRoot } from '../core/fsx.js';
-import { buildZellijLayoutKdl, validateZellijLayoutKdl, writeZellijLayout } from '../core/zellij/zellij-layout-builder.js';
-const root = packageRoot();
-const tmpRoot = path.join(root, '.sneakoscope', 'tmp', 'spawn-on-demand-layout-check');
-process.env.SKS_ZELLIJ_VIEWPORTS = '3';
-const built = buildZellijLayoutKdl({ missionId: 'M-spawn-on-demand-layout', ledgerRoot: tmpRoot, cwd: root, kind: 'naruto', slotCount: 24 });
-const validation = validateZellijLayoutKdl(built.layout_kdl);
-const writeBuilt = await writeZellijLayout(root, { missionId: 'M-spawn-on-demand-layout-write', ledgerRoot: tmpRoot, cwd: root, kind: 'naruto', slotCount: 5 });
-const manifest = JSON.parse(await fs.readFile(path.join(tmpRoot, 'zellij-lane-runtime.json'), 'utf8'));
-const workerPaneMatches = built.layout_kdl.match(/pane name="slot-/g) || [];
-const viewportPaneMatches = built.layout_kdl.match(/pane name="sks-viewport-/g) || [];
-const laneCommandMatches = built.layout_kdl.match(/\bzellij-lane\b/g) || [];
-const ok = validation.ok
-    && built.initial_worker_panes === 0
-    && built.viewport_count === 3
-    && built.ui_architecture === 'monitor_plus_viewports'
-    && built.lane_runtime_policies.length === 0
-    && workerPaneMatches.length === 0
-    && viewportPaneMatches.length === 3
-    && laneCommandMatches.length === 0
-    && manifest.lanes.length === 0
-    && writeBuilt.initial_worker_panes === 0;
-emit({
-    schema: 'sks.zellij-spawn-on-demand-layout-check.v1',
-    ok,
-    initial_worker_panes: built.initial_worker_panes,
-    viewport_count: built.viewport_count,
-    lane_runtime_policy_count: built.lane_runtime_policies.length,
-    worker_pane_matches: workerPaneMatches.length,
-    viewport_pane_matches: viewportPaneMatches.length,
-    lane_command_matches: laneCommandMatches.length,
-    monitor_pane_enabled: built.monitor_pane_enabled,
-    validation,
-    manifest_lane_count: manifest.lanes.length,
-    layout_path: writeBuilt.layout_path,
-    blockers: ok ? [] : ['zellij_dynamic_viewport_layout_contract_failed']
-});
-function emit(report) {
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.ok)
-        process.exitCode = 1;
-}

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

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-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');

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

@@ -1,78 +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, 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'
-    };
-}
-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));
-}

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

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-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 });

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

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-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 });

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

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { root, assertGate, emitGate, importDist, readText } from './sks-1-18-gate-lib.js';
-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 · workers 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'
-};
-const REQUIRED_SECTIONS = ZELLIJ_LANE_SECTIONS;
-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 });
-    }
-}
-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`, {});
-}
-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)', {});
-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;
-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 });
-}
-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', 'naruto']) {
-    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 });

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

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

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

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-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 });

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

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-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 });

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

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-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');

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

@@ -1,108 +0,0 @@
-#!/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/core/agents/native-cli-worker-entry.js --intake worker-intake.json --json',
-    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;
-}

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

@@ -1,47 +0,0 @@
-#!/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-worker-runtime.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('openHeadlessByDesignViewportWorker(')) && 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_worker_runtime_direct_new_pane'] : []),
-        ...(!nativeUsesManager ? ['native_cli_worker_runtime_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;
-}