sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,9 @@
+#!/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-DB ACTIVE'), 'slot column anchor must include update notice and Mad-DB state');
+emitGate('zellij:slot-column-anchor-telemetry', { aggregate_snapshot: true });
+//# sourceMappingURL=zellij-slot-column-anchor-telemetry-check.js.map

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

@@ -0,0 +1,31 @@
+#!/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'"),
+    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'"),
+    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'"),
+    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: swarm.includes('buildZellijSlotPaneCommand') && swarm.includes("liveWorkerPane ? '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

@@ -0,0 +1,150 @@
+#!/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'
+});
+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: 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),
+    mission_stale_hydrates_artifact_fallback: /telemetry stale; worker may still be running/.test(missionHydrated) && (/renderer stdout tail/.test(missionHydrated) || /tool apply_patch/.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 <= 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.mission_stale_hydrates_artifact_fallback && 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-pane-stale-detection-check.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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 }
+};
+// New stale contract: 1000ms+jitter flush throttle means a brief gap is NOT staleness. A snapshot
+// only 3.5s old must read as FRESH (no stale row), preventing the flapping that produced bogus
+// multi-thousand-second staleness in the live UI.
+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);
+// Between 15s and 60s the pane shows the numeric "telemetry stale Ns" warning row.
+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(/telemetry stale 1[0-9]\.\d+s/.test(staleText), 'slot pane must show numeric stale telemetry warning above 15s', { staleText, staleStatus });
+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 });
+// Past 60s the pane shows the "worker may still be running" blocker line.
+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('telemetry stale; worker may still be running'), 'slot pane must show >60s stale blocker line', { blockedText });
+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 });
+//# sourceMappingURL=zellij-slot-pane-stale-detection-check.js.map

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

@@ -0,0 +1,11 @@
+#!/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('waiting for telemetry'), 'slot pane renderer must show waiting fallback before telemetry arrives');
+assertGate(pane.includes('artifactFallbackRows') && pane.includes('renderZellijSlotPaneFromArtifactDir'), 'slot pane renderer must preserve artifact/log fallback when telemetry is stale');
+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');
+emitGate('zellij:slot-pane-telemetry-renderer', { telemetry_with_artifact_fallback: true });
+//# sourceMappingURL=zellij-slot-pane-telemetry-renderer-check.js.map

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

@@ -0,0 +1,59 @@
+#!/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-slot-telemetry-check.js

@@ -0,0 +1,39 @@
+#!/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 });
+//# sourceMappingURL=zellij-slot-telemetry-check.js.map

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

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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 });
+}
+//# sourceMappingURL=zellij-slot-telemetry-incremental-check.js.map

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

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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
+    };
+}
+//# sourceMappingURL=zellij-slot-telemetry-live-flush-check.js.map

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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 });
+}
+//# sourceMappingURL=zellij-slot-telemetry-performance-check.js.map

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const requireZellij = process.env.SKS_REQUIRE_ZELLIJ === '1';
+const zellij = spawnSync('zellij', ['--version'], { encoding: 'utf8', timeout: 10000 });
+assertGate(!requireZellij || zellij.status === 0, 'SKS_REQUIRE_ZELLIJ=1 requires zellij to be installed and runnable', {
+    status: zellij.status,
+    stderr: zellij.stderr
+});
+const telemetry = readText('src/core/zellij/zellij-slot-telemetry.ts');
+const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
+const pane = readText('src/core/zellij/zellij-slot-pane-renderer.ts');
+assertGate(telemetry.includes('appendZellijSlotTelemetry') && telemetry.includes('readZellijSlotTelemetrySnapshot'), 'telemetry ledger/snapshot runtime must exist');
+assertGate(swarm.includes('slot_reserved') && swarm.includes('worker_spawned'), 'real worker launch path must emit slot lifecycle telemetry');
+assertGate(pane.includes('readZellijSlotTelemetrySnapshot'), 'real slot pane path must render from telemetry snapshot');
+emitGate('zellij:slot-telemetry-real', {
+    zellij_available: zellij.status === 0,
+    required: requireZellij
+});
+//# sourceMappingURL=zellij-slot-telemetry-real-blackbox.js.map

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

@@ -0,0 +1,10 @@
+#!/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 anchor = readText('src/core/zellij/zellij-slot-column-anchor.ts');
+assertGate(pane.includes('readZellijSlotTelemetrySnapshot') && pane.includes('waiting for telemetry'), 'slot pane must render from telemetry snapshot with waiting fallback');
+assertGate(pane.includes('artifactFallbackRows') && pane.includes('renderZellijSlotPaneFromArtifactDir'), 'slot pane must merge telemetry with artifact/log fallback instead of stale-only output');
+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-DB ACTIVE'), 'anchor must surface update notice and Mad-DB state');
+emitGate('zellij:slot-telemetry-renderer', { telemetry_with_artifact_fallback: true });
+//# sourceMappingURL=zellij-slot-telemetry-renderer-check.js.map

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
+const swarm = readText('src/core/agents/native-cli-session-swarm.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(swarm.includes(event) || worker.includes(event), `missing runtime slot telemetry event ${event}`);
+}
+assertGate(swarm.includes('appendZellijSlotTelemetry'), 'session swarm 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');
+emitGate('zellij:slot-telemetry-runtime', { lifecycle_events: requiredEvents.length, progress_pump: true });
+//# sourceMappingURL=zellij-slot-telemetry-runtime-check.js.map

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

@@ -0,0 +1,40 @@
+#!/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