sneakoscope 7.1.0 → 7.3.0

package/dist/scripts/zellij-slot-column-anchor-check.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { buildZellijSlotColumnAnchorCommand, renderZellijSlotColumnAnchor } from '../core/zellij/zellij-slot-column-anchor.js';
-const rendered = renderZellijSlotColumnAnchor({
-    activeWorkers: 3,
-    visiblePaneCap: 8,
-    headlessWorkers: 12,
-    queueDepth: 44,
-    mode: 'compact-slots'
-});
-const roster = renderZellijSlotColumnAnchor({
-    activeWorkers: 1,
-    visiblePaneCap: 5,
-    headlessWorkers: 0,
-    queueDepth: 0,
-    mode: 'compact-slots',
-    workerRows: [
-        {
-            slotId: 'slot-004',
-            generationIndex: 1,
-            placement: 'zellij-pane',
-            status: 'running',
-            backend: 'codex-sdk',
-            task: 'Inspect Zellij slot UI assignment',
-            heartbeatAgeMs: 900
-        }
-    ]
-});
-const overflow = renderZellijSlotColumnAnchor({
-    activeWorkers: 6,
-    visiblePaneCap: 5,
-    headlessWorkers: 1,
-    queueDepth: 0,
-    mode: 'compact-slots',
-    workerRows: [
-        {
-            slotId: 'slot-009',
-            generationIndex: 1,
-            placement: 'headless',
-            status: 'running',
-            backend: 'local-llm',
-            task: 'Waiting for a visible slot pane',
-            heartbeatAgeMs: 1200
-        }
-    ]
-});
-const command = buildZellijSlotColumnAnchorCommand({
-    nodePath: '/usr/bin/node',
-    cliPath: '/repo/dist/bin/sks.js',
-    missionId: 'M-check',
-    mode: 'compact-slots',
-    artifactRoot: '/repo/.sneakoscope/missions/M-check/agents',
-    watch: true
-});
-const ok = rendered.includes('SLOTS active 3/8 · headless 12 · q 44')
-    && rendered.includes('visible slot panes stack below this anchor')
-    && roster.includes('SLOTS active 1/5 · headless 0 · q 0')
-    && roster.includes('visible slot panes stack below this anchor')
-    && !roster.includes('slot-004 g1 running codex-sdk')
-    && overflow.includes('slot-009 g1 running local-llm')
-    && overflow.includes('Waiting for a visible slot pane')
-    && command.includes('zellij-slot-column-anchor')
-    && command.includes('--watch');
-assertGate(ok, 'Zellij slot-column anchor must stay an anchor while slot workers render in dedicated stacked panes', { rendered, roster, overflow, command });
-emitGate('zellij:slot-column-anchor', { rendered, roster, overflow, command });

package/dist/scripts/zellij-slot-column-anchor-telemetry-check.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const anchor = readText('src/core/zellij/zellij-slot-column-anchor.ts');
-assertGate(anchor.includes('readZellijSlotTelemetrySnapshot'), 'slot column anchor must read aggregate telemetry snapshots');
-assertGate(anchor.includes('snapshot.counts') && anchor.includes('counts.running'), 'slot column anchor must show aggregate status counts');
-assertGate(anchor.includes('SLOTS telemetry stale'), 'slot column anchor must mark stale telemetry');
-assertGate(anchor.includes('update-notice.json') && anchor.includes('MAD-SKS SQL-PLANE ACTIVE'), 'slot column anchor must include update notice and MAD-SKS SQL-plane state');
-emitGate('zellij:slot-column-anchor-telemetry', { aggregate_snapshot: true });

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

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-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 runtime = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-worker-runtime.ts'), 'utf8');
-const report = {
-    schema: 'sks.zellij-slot-only-ui-check.v1',
-    default_compact_slots: uiMode.includes("return 'compact-slots'"),
-    worker_panes_default_live_renderer: uiMode.includes('resolveZellijWorkerPaneUiMode') && uiMode.includes("|| 'compact-slots'"),
-    full_debug_opt_in_available: uiMode.includes("'--zellij-full-debug'") && uiMode.includes("fromEnv === 'full-debug'"),
-    compact_explicit_fallback: uiMode.includes("'--zellij-compact-slots'") && uiMode.includes("fromEnv === 'compact-slots'"),
-    supported_modes_present: ["'compact-slots'", "'full-debug'"].every((token) => uiMode.includes(token)),
-    state_records_ui_mode: manager.includes('ui_mode: uiMode'),
-    first_slot_creates_slot_anchor_right: worker.includes('buildZellijSlotColumnAnchorCommand') && worker.includes("'--direction', 'right', '--name', 'SLOTS'"),
-    anchor_creation_serialized: worker.includes('withZellijPaneCreationLock'),
-    workers_stack_down_from_anchor: worker.includes("const directionRequested: 'right' | 'down' = 'down'")
-        && worker.includes("'--near-current-pane'")
-        && worker.includes("'--stacked'")
-        && worker.includes('slot_column_anchor_pane_id'),
-    explicit_compact_uses_renderer: runtime.includes('buildZellijSlotPaneCommand') && runtime.includes("liveWorkerPane ? 'worker-command-pane' : 'zellij-slot-pane-renderer'")
-        && runtime.includes('paneRecord.pane_kind')
-        && runtime.includes('paneRecord.scaling_primitive')
-};
-const ok = Object.values(report).every((value) => value === true || typeof value === 'string');
-assertGate(ok, 'Zellij UI must remain compact slot and viewport based', report);
-emitGate('zellij:slot-only-ui', report);

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

@@ -1,149 +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 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.6-terra',
-    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-process-report.json'), JSON.stringify({
-    fast_mode: true,
-    service_tier: 'fast',
-    session_proof: { ok: true, session_id: 'session-slot-003' }
-}, 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.6-terra',
-        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'
-});
-const missionRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-slot-pane-mission-'));
-const missionId = 'M-slot-pane-renderer';
-const snapshotDir = path.join(missionRoot, '.sneakoscope', 'missions', missionId, 'zellij');
-await fs.mkdir(snapshotDir, { recursive: true });
-await fs.writeFile(path.join(snapshotDir, 'slot-telemetry.snapshot.json'), `${JSON.stringify({
-    schema: 'sks.zellij-slot-telemetry-snapshot.v1',
-    mission_id: missionId,
-    updated_at: new Date(Date.now() - 61000).toISOString(),
-    flush_count: 1,
-    slots: {
-        'slot-003:g2': {
-            slot_id: 'slot-003',
-            generation_index: 2,
-            worker_id: 'slot-003',
-            status: 'running',
-            role: 'implementer',
-            backend: 'codex-sdk',
-            provider: 'codex-lb',
-            service_tier: 'fast',
-            worktree_id: 'WT-0007',
-            worktree_path: null,
-            task_title: 'mission telemetry stale fixture',
-            current_file: null,
-            latest_event_type: 'task_started',
-            latest_ts: new Date(Date.now() - 12000).toISOString(),
-            progress: null,
-            artifact_paths: [],
-            blockers: [],
-            log_tail: ''
-        }
-    },
-    counts: { queued: 0, running: 1, verifying: 0, completed: 0, failed: 0, headless: 0 }
-})}\n`, 'utf8');
-const missionHydrated = await renderer.renderZellijSlotPaneFromArtifacts({
-    artifactDir,
-    artifactRoot: missionRoot,
-    missionId,
-    slotId: 'slot-003',
-    generationIndex: 2,
-    mode: 'compact-slots'
-});
-await fs.rm(missionRoot, { recursive: true, force: true });
-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: 14,
-    contains_slot: /┌─ slot-003/.test(text) && /slot-003/.test(text),
-    contains_status: /coding/.test(text),
-    contains_runtime: /gpt-5\.6-terra·fast/.test(text),
-    contains_files: /src\/core\/foo\.ts/.test(text),
-    contains_live_event: /renderer updated live pane output/.test(text),
-    artifact_hydrates_runtime: /gpt-5\.6-terra·fast/.test(hydrated),
-    artifact_hydrates_live_event: /renderer stdout tail/.test(hydrated),
-    artifact_hydrates_planned_file: /zellij-slot-pane-renderer\.ts/.test(hydrated),
-    mission_live_telemetry_wins: /mission telemetry stale fixture/.test(missionHydrated) && /renderer stdout tail/.test(missionHydrated),
-    command_uses_slot_pane: command.includes('zellij-slot-pane') && command.includes('--watch'),
-    snapshot: text,
-    hydrated_snapshot: hydrated,
-    mission_hydrated_snapshot: missionHydrated
-};
-assertGate(lines.length <= 14 && 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.mission_live_telemetry_wins && report.command_uses_slot_pane, 'compact slot pane renderer must render one live work pane per slot', report);
-emitGate('zellij:compact-slot-renderer', report);

package/dist/scripts/zellij-slot-pane-stale-detection-check.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { slotTelemetrySnapshotPath } from '../core/zellij/zellij-slot-telemetry.js';
-import { renderZellijSlotPaneFromArtifacts, renderZellijSlotPaneStatusFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-stale-'));
-const missionId = 'M-zellij-stale';
-const file = slotTelemetrySnapshotPath(root, missionId);
-const artifactDir = path.join(root, 'worker-artifacts');
-await fs.mkdir(path.dirname(file), { recursive: true });
-await fs.mkdir(artifactDir, { recursive: true });
-await fs.writeFile(path.join(artifactDir, 'worker-intake.json'), JSON.stringify({
-    agent: { session_id: 'stale-session', role: 'worker' },
-    backend: 'codex-sdk',
-    slice: { title: 'fresh artifact fallback', write_paths: ['src/core/zellij/zellij-slot-pane-renderer.ts'] }
-}, null, 2));
-await fs.writeFile(path.join(artifactDir, 'worker-heartbeat.jsonl'), `${JSON.stringify({ event: 'progress', status: 'running', message: 'fresh heartbeat fallback' })}\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' })}\n`);
-await fs.writeFile(path.join(artifactDir, 'worker.stdout.log'), 'fresh worker stdout fallback\n');
-const snapshot = {
-    schema: 'sks.zellij-slot-telemetry-snapshot.v1',
-    mission_id: missionId,
-    updated_at: new Date().toISOString(),
-    flush_count: 1,
-    slots: {
-        'slot-001:g1': {
-            slot_id: 'slot-001',
-            generation_index: 1,
-            worker_id: 'worker-001',
-            status: 'running',
-            role: 'worker',
-            backend: 'fixture',
-            provider: 'fixture',
-            service_tier: 'fast',
-            worktree_id: null,
-            worktree_path: null,
-            task_title: 'stale detection fixture',
-            current_file: null,
-            latest_event_type: 'task_started',
-            latest_ts: new Date().toISOString(),
-            progress: null,
-            artifact_paths: [],
-            blockers: [],
-            log_tail: ''
-        }
-    },
-    counts: { queued: 0, running: 1, verifying: 0, completed: 0, failed: 0, headless: 0 }
-};
-snapshot.updated_at = new Date(Date.now() - 3500).toISOString();
-await fs.writeFile(file, `${JSON.stringify(snapshot)}\n`, 'utf8');
-const freshStatus = await renderZellijSlotPaneStatusFromArtifacts({ artifactDir, artifactRoot: root, missionId, slotId: 'slot-001', generationIndex: 1 });
-assertGate(freshStatus.telemetry_stale === false, 'slot pane status JSON must treat 3.5s-old telemetry as fresh under new 15s threshold', freshStatus);
-snapshot.updated_at = new Date(Date.now() - 16000).toISOString();
-await fs.writeFile(file, `${JSON.stringify(snapshot)}\n`, 'utf8');
-const staleText = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot: root, missionId, slotId: 'slot-001', generationIndex: 1 });
-const staleStatus = await renderZellijSlotPaneStatusFromArtifacts({ artifactDir, artifactRoot: root, missionId, slotId: 'slot-001', generationIndex: 1 });
-assertGate(staleStatus.telemetry_stale === true && staleStatus.telemetry_age_ms >= 15000, 'slot pane status JSON must expose stale telemetry above 15s', staleStatus);
-assertGate(staleText.includes('fresh worker stdout fallback') || staleText.includes('apply_patch'), 'stale slot pane must show fresh artifact/log fallback', { staleText });
-snapshot.updated_at = new Date(Date.now() - 61000).toISOString();
-await fs.writeFile(file, `${JSON.stringify(snapshot)}\n`, 'utf8');
-const blockedText = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot: root, missionId, slotId: 'slot-001', generationIndex: 1 });
-assertGate(blockedText.includes('fresh worker stdout fallback') || blockedText.includes('apply_patch'), 'blocked stale slot pane must keep artifact/log fallback', { blockedText });
-emitGate('zellij:slot-pane-stale-detection', { stale_age_ms: staleStatus.telemetry_age_ms, artifact_fallback: true });

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

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const pane = readText('src/core/zellij/zellij-slot-pane-renderer.ts');
-const command = readText('src/commands/zellij-slot-pane.ts');
-assertGate(pane.includes('readZellijSlotTelemetrySnapshot'), 'slot pane renderer must read telemetry snapshots');
-assertGate(pane.includes('mergeRenderInputWithLiveTelemetry'), 'slot pane renderer must prefer live telemetry over artifact detail');
-assertGate(pane.includes('renderInputFromArtifactDir') && pane.includes('stdoutTail'), 'slot pane renderer must preserve artifact/log fallback details');
-assertGate(pane.includes('latest_heartbeat') || pane.includes('heartbeat'), 'slot pane renderer must surface heartbeat/progress state');
-assertGate(command.includes('artifactRoot') && command.includes('--artifact-root'), 'slot pane command must pass artifact root for telemetry lookup');
-assertGate(command.includes('staleTicks') && command.includes('worker heartbeat lost >5m'), 'slot pane command must close zombie panes instead of freezing');
-emitGate('zellij:slot-pane-telemetry-renderer', { telemetry_with_artifact_fallback: true });

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

@@ -1,58 +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 runtimeSource = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-worker-runtime.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/core/agents/native-cli-worker-entry.js --intake worker-intake.json --json'
-});
-const report = {
-    schema: 'sks.zellij-slot-renderer-proof-semantics-check.v2',
-    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'),
-    runtime_uses_pane_record_values: runtimeSource.includes('input.record.pane_kind = paneRecord.pane_kind') && runtimeSource.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.runtime_uses_pane_record_values ? [] : ['runtime_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);

package/dist/scripts/zellij-slot-telemetry-check.js

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const telemetry = await importDist('core/zellij/zellij-slot-telemetry.js');
-const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-slot-telemetry-'));
-const missionId = 'M-20260608-000000-test';
-await telemetry.appendZellijSlotTelemetry(tempRoot, {
-    schema: telemetry.ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA,
-    mission_id: missionId,
-    ts: new Date().toISOString(),
-    slot_id: 'slot-001',
-    generation_index: 1,
-    event_type: 'worker_spawned',
-    status: 'running',
-    placement: 'zellij-pane',
-    backend: 'fake',
-    service_tier: 'fast',
-    role: 'verifier'
-});
-await telemetry.appendZellijSlotTelemetry(tempRoot, {
-    schema: telemetry.ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA,
-    mission_id: missionId,
-    ts: new Date().toISOString(),
-    slot_id: 'slot-001',
-    generation_index: 2,
-    event_type: 'worker_spawned',
-    status: 'queued',
-    backend: 'fake',
-    service_tier: 'fast',
-    role: 'verifier'
-});
-const snapshot = await telemetry.readZellijSlotTelemetrySnapshot(tempRoot, missionId);
-assertGate(snapshot.schema === telemetry.ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA, 'snapshot schema must match', snapshot);
-assertGate(snapshot.slots['slot-001:g1']?.status === 'running', 'slot status must be snapshot-backed by slot generation', snapshot);
-assertGate(snapshot.slots['slot-001:g2']?.status === 'queued', 'slot telemetry must preserve reused slot generations separately', snapshot);
-emitGate('zellij:slot-telemetry', { slots: Object.keys(snapshot.slots).length });

package/dist/scripts/zellij-slot-telemetry-incremental-check.js

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { appendZellijSlotTelemetry, readZellijSlotTelemetrySnapshot, slotTelemetrySnapshotPath } from '../core/zellij/zellij-slot-telemetry.js';
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const removeTempDir = fs.rm.bind(fs);
-const src = readText('src/core/zellij/zellij-slot-telemetry.ts');
-assertGate(src.includes('applyTelemetryEventToSnapshot') && src.includes('readZellijSlotTelemetrySnapshotNoRebuild'), 'incremental telemetry helpers missing');
-assertGate(src.includes('withFileLock') && src.includes('writeTextAtomic(file'), 'slot telemetry snapshot writes must be locked and atomically published');
-const missionId = 'M-zellij-incremental';
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-incremental-'));
-try {
-    process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_MS = '60000';
-    process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_EVERY_N = '1000';
-    const startedAt = '2026-01-01T00:00:00.000Z';
-    const completedAt = '2026-01-01T00:00:01.000Z';
-    const delayedHeartbeatAt = '2026-01-01T00:00:02.000Z';
-    const drainedAt = '2026-01-01T00:00:03.000Z';
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: startedAt, mission_id: missionId, slot_id: 'slot-001', generation_index: 1, worker_id: 'w1', event_type: 'slot_reserved', status: 'queued' });
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: completedAt, mission_id: missionId, slot_id: 'slot-001', generation_index: 1, worker_id: 'w1', event_type: 'worker_completed', status: 'completed' });
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: startedAt, mission_id: missionId, slot_id: 'slot-001', generation_index: 1, worker_id: 'w1', event_type: 'heartbeat', status: 'running', artifact_paths: ['late-artifact.txt'] });
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: completedAt, mission_id: missionId, slot_id: 'slot-001', generation_index: 1, worker_id: 'w1', event_type: 'heartbeat', status: 'running' });
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: delayedHeartbeatAt, mission_id: missionId, slot_id: 'slot-001', generation_index: 1, worker_id: 'w1', event_type: 'heartbeat', status: 'running', log_tail: 'late heartbeat after completion' });
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: startedAt, mission_id: missionId, slot_id: 'slot-002', generation_index: 1, worker_id: 'w2', event_type: 'worker_spawned', status: 'running' });
-    await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: drainedAt, mission_id: missionId, slot_id: 'slot-002', generation_index: 1, worker_id: 'w2', event_type: 'heartbeat', status: 'drained' });
-    const snapshot = await readZellijSlotTelemetrySnapshot(root, missionId);
-    assertGate(snapshot.counts.completed === 2 && Object.keys(snapshot.slots).length === 2, 'incremental snapshot merge failed', snapshot);
-    assertGate(snapshot.counts.running === 0 && snapshot.slots['slot-001:g1']?.status === 'completed', 'stale slot telemetry must not regress terminal status', snapshot);
-    assertGate(snapshot.slots['slot-001:g1']?.artifact_paths?.includes('late-artifact.txt'), 'stale slot telemetry should still preserve additive artifacts', snapshot);
-    assertGate(!String(snapshot.slots['slot-001:g1']?.log_tail || '').includes('late heartbeat after completion'), 'delayed heartbeat must not replace terminal telemetry tail', snapshot);
-    const diskSnapshot = JSON.parse(await fs.readFile(slotTelemetrySnapshotPath(root, missionId), 'utf8'));
-    assertGate(diskSnapshot.slots?.['slot-002:g1']?.status === 'drained', 'drained terminal status must flush to disk immediately', diskSnapshot);
-    emitGate('zellij:slot-telemetry-incremental', snapshot.counts);
-}
-finally {
-    await guardedRm(root, 'sks-zellij-incremental-');
-}
-async function guardedRm(target, prefix) {
-    const tempRoot = path.resolve(os.tmpdir());
-    const resolved = path.resolve(target);
-    if (path.dirname(resolved) !== tempRoot || !path.basename(resolved).startsWith(prefix)) {
-        throw new Error(`refusing_to_remove_unscoped_temp_dir:${target}`);
-    }
-    await removeTempDir(resolved, { recursive: true, force: true });
-}

package/dist/scripts/zellij-slot-telemetry-live-flush-check.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { appendZellijSlotTelemetry, readZellijSlotTelemetrySnapshot, slotTelemetrySnapshotPath } from '../core/zellij/zellij-slot-telemetry.js';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-const removeTempDir = fs.rm.bind(fs);
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-live-flush-'));
-const missionId = 'M-zellij-live-flush';
-try {
-    process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_MS = '1000';
-    process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_EVERY_N = '100';
-    await appendZellijSlotTelemetry(root, event('task_started', 'running', { task_title: 'live flush fixture' }));
-    let snapshot = JSON.parse(await fs.readFile(slotTelemetrySnapshotPath(root, missionId), 'utf8'));
-    assertGate(Object.keys(snapshot.slots || {}).length === 1, 'task_started must flush snapshot immediately', snapshot);
-    const updates = [snapshot.updated_at];
-    for (let i = 0; i < 7; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 300));
-        await appendZellijSlotTelemetry(root, event('heartbeat', 'running', { log_tail: `heartbeat ${i}` }));
-        const current = JSON.parse(await fs.readFile(slotTelemetrySnapshotPath(root, missionId), 'utf8'));
-        if (current.updated_at !== updates[updates.length - 1])
-            updates.push(current.updated_at);
-    }
-    await appendZellijSlotTelemetry(root, event('worker_completed', 'completed', { artifact_paths: ['artifact.json'] }));
-    const completed = await readZellijSlotTelemetrySnapshot(root, missionId);
-    assertGate(completed.counts.completed === 1, 'completed event must flush immediately', completed);
-    const eventCount = 1 + 7 + 1;
-    assertGate(updates.length >= 2, 'heartbeat stream must update snapshot at least twice in about 2s', { updates });
-    assertGate(Number(completed.flush_count || 0) < eventCount, 'flush count must be throttled below event count', { flush_count: completed.flush_count, eventCount });
-    emitGate('zellij:slot-telemetry-live-flush', { flush_count: completed.flush_count, event_count: eventCount, updates: updates.length });
-}
-finally {
-    await guardedRm(root, 'sks-zellij-live-flush-');
-}
-async function guardedRm(target, prefix) {
-    const tempRoot = path.resolve(os.tmpdir());
-    const resolved = path.resolve(target);
-    if (path.dirname(resolved) !== tempRoot || !path.basename(resolved).startsWith(prefix)) {
-        throw new Error(`refusing_to_remove_unscoped_temp_dir:${target}`);
-    }
-    await removeTempDir(resolved, { recursive: true, force: true });
-}
-function event(eventType, status, extra = {}) {
-    return {
-        schema: 'sks.zellij-slot-telemetry-event.v1',
-        ts: new Date().toISOString(),
-        mission_id: missionId,
-        slot_id: 'slot-001',
-        generation_index: 1,
-        worker_id: 'worker-001',
-        event_type: eventType,
-        status,
-        ...extra
-    };
-}

package/dist/scripts/zellij-slot-telemetry-performance-check.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { appendZellijSlotTelemetry, readZellijSlotTelemetrySnapshot } from '../core/zellij/zellij-slot-telemetry.js';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-const removeTempDir = fs.rm.bind(fs);
-const missionId = 'M-zellij-performance';
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-perf-'));
-try {
-    const started = Date.now();
-    for (let i = 0; i < 5000; i++)
-        await appendZellijSlotTelemetry(root, { schema: 'sks.zellij-slot-telemetry-event.v1', ts: new Date().toISOString(), mission_id: missionId, slot_id: `slot-${String(i % 100).padStart(3, '0')}`, generation_index: Math.floor(i / 100) + 1, worker_id: `w${i}`, event_type: 'heartbeat', status: 'running' });
-    const wallMs = Date.now() - started;
-    const snapshot = await readZellijSlotTelemetrySnapshot(root, missionId);
-    assertGate(wallMs < 15000, '5000 telemetry appends exceeded performance threshold', { wallMs, counts: snapshot.counts });
-    assertGate(Object.keys(snapshot.slots).length === 5000, 'snapshot slot count mismatch', { wallMs, slot_count: Object.keys(snapshot.slots).length });
-    assertGate(Number(snapshot.flush_count || 0) > 0 && Number(snapshot.flush_count || 0) < 500, 'snapshot writes must be throttled far below event count', { flush_count: snapshot.flush_count });
-    assertGate(snapshot.slots['slot-099:g50']?.status === 'running', 'latest slot state must remain correct after incremental updates', snapshot.slots['slot-099:g50']);
-    emitGate('zellij:slot-telemetry-performance', { wall_ms: wallMs, slot_count: Object.keys(snapshot.slots).length, flush_count: snapshot.flush_count });
-}
-finally {
-    await guardedRm(root, 'sks-zellij-perf-');
-}
-async function guardedRm(target, prefix) {
-    const tempRoot = path.resolve(os.tmpdir());
-    const resolved = path.resolve(target);
-    if (path.dirname(resolved) !== tempRoot || !path.basename(resolved).startsWith(prefix)) {
-        throw new Error(`refusing_to_remove_unscoped_temp_dir:${target}`);
-    }
-    await removeTempDir(resolved, { recursive: true, force: true });
-}

package/dist/scripts/zellij-slot-telemetry-real-blackbox.js

@@ -1,19 +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 runtime = readText('src/core/agents/native-cli-worker-runtime.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(runtime.includes('slot_reserved') && runtime.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
-});

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

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const pane = readText('src/core/zellij/zellij-slot-pane-renderer.ts');
-const command = readText('src/commands/zellij-slot-pane.ts');
-const anchor = readText('src/core/zellij/zellij-slot-column-anchor.ts');
-assertGate(pane.includes('readZellijSlotTelemetrySnapshot') && pane.includes('mergeRenderInputWithLiveTelemetry'), 'slot pane must read telemetry first and merge it with artifact detail');
-assertGate(pane.includes('renderInputFromArtifactDir') && pane.includes('stdoutTail'), 'slot pane must preserve artifact/log fallback while live telemetry wins');
-assertGate(command.includes('staleTicks') && command.includes('worker heartbeat lost >5m'), 'slot pane watch loop must close frozen heartbeat panes');
-assertGate(anchor.includes('readZellijSlotTelemetrySnapshot') && anchor.includes('SLOTS telemetry stale'), 'slot anchor must render telemetry snapshot and stale state');
-assertGate(anchor.includes('update-notice.json') && anchor.includes('MAD-SKS SQL-PLANE ACTIVE'), 'anchor must surface update notice and MAD-SKS SQL-plane state');
-emitGate('zellij:slot-telemetry-renderer', { telemetry_with_artifact_fallback: true });

package/dist/scripts/zellij-slot-telemetry-runtime-check.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const runtime = readText('src/core/agents/native-cli-worker-runtime.ts');
-const worker = readText('src/core/agents/native-cli-worker.ts');
-const requiredEvents = [
-    'slot_reserved',
-    'worker_spawned',
-    'task_started',
-    'heartbeat',
-    'task_progress',
-    'patch_candidate',
-    'artifact_written',
-    'worker_completed',
-    'worker_failed'
-];
-for (const event of requiredEvents) {
-    assertGate(runtime.includes(event) || worker.includes(event), `missing runtime slot telemetry event ${event}`);
-}
-assertGate(runtime.includes('appendZellijSlotTelemetry'), 'session runtime must append Zellij slot telemetry');
-assertGate(worker.includes('appendZellijSlotTelemetry'), 'native worker must append Zellij slot telemetry');
-assertGate(worker.includes('startWorkerProgressTelemetry'), 'native worker must emit progress telemetry during backend runtime');
-assertGate(!/progress:\s*\{\s*done:\s*tick,\s*total:\s*0/.test(worker), 'heartbeat ticks must not be reported as progress done/total counters');
-emitGate('zellij:slot-telemetry-runtime', { lifecycle_events: requiredEvents.length, progress_pump: true });