sneakoscope 2.0.14 → 2.0.16

package/dist/scripts/zellij-slot-only-ui-check.js

@@ -1,26 +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 uiMode = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-ui-mode.ts'), 'utf8');
-const manager = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
-const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const swarm = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
-const report = {
-    schema: 'sks.zellij-slot-only-ui-check.v1',
-    default_compact_slots: uiMode.includes("return 'compact-slots'"),
-    state_records_ui_mode: manager.includes('ui_mode: uiMode'),
-    compact_skips_dashboard: manager.includes('if (!createDashboard)') && manager.includes('dashboard_created: false'),
-    first_slot_creates_slot_anchor_right: worker.includes('buildZellijSlotColumnAnchorCommand') && worker.includes("'--direction', 'right', '--name', 'SLOTS'"),
-    workers_stack_down_from_anchor: worker.includes("const directionRequested: 'right' | 'down' = 'down'")
-        && worker.includes("directionRequested === 'down' ? ['--near-current-pane'] : []")
-        && worker.includes('slot_column_anchor_pane_id'),
-    compact_uses_renderer: swarm.includes('buildZellijSlotPaneCommand') && swarm.includes("slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer'")
-        && swarm.includes('paneRecord.pane_kind')
-        && swarm.includes('paneRecord.scaling_primitive')
-};
-const ok = Object.values(report).every((value) => value === true || typeof value === 'string');
-assertGate(ok, 'Zellij default UI must be compact slot-only with opt-in dashboard', report);
-emitGate('zellij:slot-only-ui', report);
-//# sourceMappingURL=zellij-slot-only-ui-check.js.map

package/dist/scripts/zellij-slot-pane-renderer-check.js

@@ -1,106 +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 renderer = await importDist('core/zellij/zellij-slot-pane-renderer.js');
-const text = renderer.renderZellijSlotPane({
-    slotId: 'slot-003',
-    generationIndex: 2,
-    role: 'implementer',
-    backend: 'local-llm',
-    status: 'coding',
-    fastMode: true,
-    serviceTier: 'fast',
-    provider: 'codex-lb',
-    authMode: 'codex_lb_key',
-    model: 'gpt-5.5',
-    reasoningEffort: 'medium',
-    currentFile: 'src/core/foo.ts',
-    currentTask: 'Editing Zellij slot pane renderer',
-    changedFiles: ['src/core/foo.ts', 'src/core/bar.ts'],
-    patchStatus: 'candidate',
-    verifyStatus: 'queued',
-    heartbeatAgeMs: 2000,
-    worktreeId: 'WT-0007',
-    eventLines: ['running: tool apply_patch', 'running: file src/core/foo.ts'],
-    stdoutTail: ['renderer updated live pane output'],
-    mode: 'compact-slots'
-});
-const lines = text.split(/\n/);
-const artifactDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-slot-pane-renderer-'));
-await fs.writeFile(path.join(artifactDir, 'worker-intake.json'), JSON.stringify({
-    agent: { session_id: 'session-slot-003', role: 'implementer' },
-    backend: 'codex-sdk',
-    fast_mode: true,
-    service_tier: 'fast',
-    slice: {
-        title: 'Hydrate live slot pane from artifacts',
-        write_paths: ['src/core/zellij/zellij-slot-pane-renderer.ts']
-    },
-    worktree: { id: 'WT-0007' }
-}, null, 2));
-await fs.writeFile(path.join(artifactDir, 'worker-fast-mode.json'), JSON.stringify({
-    fast_mode: true,
-    service_tier: 'fast'
-}, null, 2));
-await fs.writeFile(path.join(artifactDir, 'zellij-worker-pane.json'), JSON.stringify({
-    provider: 'codex-lb',
-    service_tier: 'fast',
-    provider_context: {
-        provider: 'codex-lb',
-        auth_mode: 'codex_lb_key'
-    }
-}, null, 2));
-await fs.writeFile(path.join(artifactDir, 'codex-control-proof.json'), JSON.stringify({
-    config: {
-        model: 'gpt-5.5',
-        model_provider: 'codex-lb',
-        service_tier: 'fast',
-        model_reasoning_effort: 'medium'
-    }
-}, null, 2));
-await fs.writeFile(path.join(artifactDir, 'worker-heartbeat.jsonl'), `${JSON.stringify({ event: 'started', status: 'running' })}\n`);
-await fs.writeFile(path.join(artifactDir, 'codex-sdk-events.jsonl'), `${JSON.stringify({
-    sdk_event_type: 'item.completed',
-    lane_status: 'running',
-    current_tool: 'apply_patch',
-    current_file: 'src/core/zellij/zellij-slot-pane-renderer.ts',
-    message_tail: null
-})}\n`);
-await fs.writeFile(path.join(artifactDir, 'worker.stdout.log'), 'renderer stdout tail\n');
-const hydrated = await renderer.renderZellijSlotPaneFromArtifacts({
-    artifactDir,
-    slotId: 'slot-003',
-    generationIndex: 2,
-    mode: 'compact-slots'
-});
-await fs.rm(artifactDir, { recursive: true, force: true });
-const command = renderer.buildZellijSlotPaneCommand({
-    cliPath: '/repo/dist/bin/sks.js',
-    missionId: 'M-test',
-    slotId: 'slot-003',
-    generationIndex: 2,
-    artifactDir: '/tmp/worker',
-    watch: true
-});
-const report = {
-    schema: 'sks.zellij-slot-pane-renderer-check.v1',
-    line_count: lines.length,
-    max_compact_lines: 17,
-    contains_slot: /LIVE SLOT slot-003/.test(text) && /slot: slot-003 \/ gen-2/.test(text),
-    contains_status: /coding/.test(text),
-    contains_runtime: /runtime: fast on/.test(text) && /model: gpt-5\.5/.test(text) && /provider: codex-lb/.test(text),
-    contains_files: /src\/core\/foo\.ts/.test(text) && /src\/core\/bar\.ts/.test(text),
-    contains_live_event: /event: running:/.test(text),
-    artifact_hydrates_runtime: /runtime: fast on/.test(hydrated) && /model: gpt-5\.5/.test(hydrated) && /reasoning: medium/.test(hydrated) && /auth: codex_lb_key/.test(hydrated),
-    artifact_hydrates_live_event: /tool apply_patch/.test(hydrated) && /renderer stdout tail/.test(hydrated),
-    artifact_hydrates_planned_file: /zellij-slot-pane-renderer\.ts/.test(hydrated),
-    command_uses_slot_pane: command.includes('zellij-slot-pane') && command.includes('--watch'),
-    snapshot: text,
-    hydrated_snapshot: hydrated
-};
-assertGate(lines.length <= 17 && report.contains_slot && report.contains_status && report.contains_runtime && report.contains_files && report.contains_live_event && report.artifact_hydrates_runtime && report.artifact_hydrates_live_event && report.artifact_hydrates_planned_file && report.command_uses_slot_pane, 'compact slot pane renderer must render one live work pane per slot', report);
-emitGate('zellij:compact-slot-renderer', report);
-//# sourceMappingURL=zellij-slot-pane-renderer-check.js.map

package/dist/scripts/zellij-slot-renderer-proof-semantics-check.js

@@ -1,59 +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';
-import { buildWorkerPaneArtifact } from '../core/zellij/zellij-worker-pane-manager.js';
-const root = process.cwd();
-const managerSource = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const swarmSource = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-session-swarm.ts'), 'utf8');
-const base = {
-    root,
-    missionId: 'M-slot-renderer-proof-semantics',
-    sessionName: 'sks-M-slot-renderer-proof-semantics',
-    slotId: 'slot-001',
-    generationIndex: 1,
-    sessionId: 'slot-001-gen-1',
-    workerArtifactDir: 'sessions/slot-001/gen-1/worker',
-    resultPath: 'sessions/slot-001/gen-1/worker/worker-result.json',
-    heartbeatPath: 'sessions/slot-001/gen-1/worker/worker-heartbeat.jsonl',
-    patchEnvelopePath: 'sessions/slot-001/gen-1/worker/worker-patch-envelope.json',
-    stdoutLog: 'sessions/slot-001/gen-1/worker/worker.stdout.log',
-    stderrLog: 'sessions/slot-001/gen-1/worker/worker.stderr.log',
-    paneId: '101',
-    paneIdSource: 'zellij_worker_new_pane_stdout',
-    status: 'running',
-    blockers: []
-};
-const slotRenderer = buildWorkerPaneArtifact({
-    ...base,
-    workerCommand: 'node dist/bin/sks.js zellij-slot-pane --watch'
-});
-const workerCommand = buildWorkerPaneArtifact({
-    ...base,
-    slotId: 'slot-002',
-    sessionId: 'slot-002-gen-1',
-    workerCommand: 'node dist/bin/sks.js --agent worker --intake worker-intake.json --json'
-});
-const report = {
-    schema: 'sks.zellij-slot-renderer-proof-semantics-check.v1',
-    ok: true,
-    slot_renderer_pane_kind: slotRenderer.pane_kind,
-    slot_renderer_scaling_primitive: slotRenderer.scaling_primitive,
-    worker_pane_kind: workerCommand.pane_kind,
-    worker_scaling_primitive: workerCommand.scaling_primitive,
-    launch_ledger_uses_record_values: managerSource.includes('pane_kind: record.pane_kind') && managerSource.includes('scaling_primitive: record.scaling_primitive'),
-    swarm_uses_pane_record_values: swarmSource.includes('input.record.pane_kind = paneRecord.pane_kind') && swarmSource.includes('input.record.scaling_primitive = paneRecord.scaling_primitive'),
-    blockers: []
-};
-report.blockers = [
-    ...(slotRenderer.pane_kind === 'slot_status_renderer' ? [] : ['slot_renderer_pane_kind_not_distinct']),
-    ...(slotRenderer.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer' ? [] : ['slot_renderer_scaling_primitive_not_distinct']),
-    ...(workerCommand.pane_kind === 'worker_codex_sdk' ? [] : ['worker_pane_kind_regressed']),
-    ...(workerCommand.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' ? [] : ['worker_scaling_primitive_regressed']),
-    ...(report.launch_ledger_uses_record_values ? [] : ['launch_ledger_semantics_not_record_backed']),
-    ...(report.swarm_uses_pane_record_values ? [] : ['swarm_semantics_not_record_backed'])
-];
-report.ok = report.blockers.length === 0;
-assertGate(report.ok, 'Zellij compact slot renderer proof semantics must distinguish status renderer panes from worker command panes', report);
-emitGate('zellij:slot-renderer-proof-semantics', report);
-//# sourceMappingURL=zellij-slot-renderer-proof-semantics-check.js.map

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

@@ -1,40 +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');
-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: 'agent', 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 laneCommandMatches = built.layout_kdl.match(/\bzellij-lane\b/g) || [];
-const ok = validation.ok
-    && built.initial_worker_panes === 0
-    && built.lane_runtime_policies.length === 0
-    && workerPaneMatches.length === 0
-    && 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,
-    slot_count_request: built.slot_count,
-    lane_runtime_policy_count: built.lane_runtime_policies.length,
-    worker_pane_matches: workerPaneMatches.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_spawn_on_demand_layout_contract_failed']
-});
-function emit(report) {
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.ok)
-        process.exitCode = 1;
-}
-//# sourceMappingURL=zellij-spawn-on-demand-layout-check.js.map

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

@@ -1,105 +0,0 @@
-#!/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-worker-pane-manager-check.js

@@ -1,109 +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/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

@@ -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-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