sneakoscope 8.0.2 → 8.0.4

package/dist/core/zellij/zellij-slot-telemetry.js

@@ -1,384 +0,0 @@
-import path from 'node:path';
-import fsp from 'node:fs/promises';
-import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeTextAtomic } from '../fsx.js';
-import { withFileLock } from '../locks/file-lock.js';
-export const ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA = 'sks.zellij-slot-telemetry-event.v1';
-export const ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA = 'sks.zellij-slot-telemetry-snapshot.v1';
-export const ZELLIJ_SLOT_TELEMETRY_LOCK_TIMEOUT_MS = 2_000;
-export const ZELLIJ_SLOT_TELEMETRY_LOCK_STALE_MS = 15_000;
-const telemetrySnapshotCache = new Map();
-const telemetrySnapshotWriteCounts = new Map();
-const telemetrySnapshotFlushCounts = new Map();
-const telemetrySnapshotLastFlushMs = new Map();
-const telemetrySnapshotDiskStat = new Map();
-export function slotTelemetryEventPath(root, missionId) {
-    return path.join(inferMissionDir(root, missionId), 'zellij', 'slot-telemetry.events.jsonl');
-}
-export function slotTelemetrySnapshotPath(root, missionId) {
-    return path.join(inferMissionDir(root, missionId), 'zellij', 'slot-telemetry.snapshot.json');
-}
-export async function appendZellijSlotTelemetry(root, event) {
-    const missionId = String(event?.mission_id || '').trim();
-    if (!missionId)
-        throw new Error('mission_id required for Zellij slot telemetry');
-    const normalized = normalizeTelemetryEvent(event);
-    const file = slotTelemetryEventPath(root, missionId);
-    await ensureDir(path.dirname(file));
-    await withFileLock({
-        lockPath: `${file}.append.lock`,
-        timeoutMs: ZELLIJ_SLOT_TELEMETRY_LOCK_TIMEOUT_MS,
-        staleMs: ZELLIJ_SLOT_TELEMETRY_LOCK_STALE_MS
-    }, async () => appendJsonlBounded(file, normalized));
-    const previous = await readZellijSlotTelemetrySnapshotNoRebuild(root, missionId);
-    if (previous) {
-        const snapshotPath = slotTelemetrySnapshotPath(root, missionId);
-        const next = applyTelemetryEventToSnapshot(previous, normalized);
-        telemetrySnapshotCache.set(snapshotPath, next);
-        if (shouldFlushTelemetrySnapshot(snapshotPath, normalized))
-            await writeTelemetrySnapshotFast(snapshotPath, next);
-        return;
-    }
-    await rebuildZellijSlotTelemetrySnapshot(root, missionId);
-}
-export async function readZellijSlotTelemetrySnapshot(root, missionId) {
-    const fresh = await readZellijSlotTelemetrySnapshotNoRebuild(root, missionId);
-    if (fresh)
-        return fresh;
-    return rebuildZellijSlotTelemetrySnapshot(root, missionId);
-}
-export async function readZellijSlotTelemetrySnapshotNoRebuild(root, missionId) {
-    const snapshotPath = slotTelemetrySnapshotPath(root, missionId);
-    const cached = telemetrySnapshotCache.get(snapshotPath);
-    const stat = await statTelemetryFile(snapshotPath);
-    const recorded = telemetrySnapshotDiskStat.get(snapshotPath);
-    const diskChanged = Boolean(stat) && (!recorded || recorded.mtimeMs !== stat.mtimeMs || recorded.size !== stat.size);
-    if (!diskChanged && cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
-        return cached;
-    const existing = await readJson(snapshotPath, null);
-    if (stat)
-        telemetrySnapshotDiskStat.set(snapshotPath, stat);
-    if (existing?.schema !== ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA) {
-        return cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? cached : null;
-    }
-    const disk = existing;
-    const merged = cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? mergeTelemetrySnapshots(disk, cached, { updatedAt: 'base' }) : disk;
-    telemetrySnapshotCache.set(snapshotPath, merged);
-    return merged;
-}
-export function mergeTelemetrySnapshots(base, overlay, opts = {}) {
-    const slots = { ...(base.slots || {}) };
-    for (const [key, row] of Object.entries(overlay.slots || {})) {
-        const existing = slots[key];
-        slots[key] = !existing ? row : newerSlotTelemetry(existing, row);
-    }
-    const baseTs = Date.parse(String(base.updated_at || '')) || 0;
-    const overlayTs = Date.parse(String(overlay.updated_at || '')) || 0;
-    return {
-        schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
-        mission_id: base.mission_id || overlay.mission_id,
-        updated_at: opts.updatedAt === 'base' ? base.updated_at : overlayTs > baseTs ? overlay.updated_at : base.updated_at,
-        flush_count: Math.max(Number(base.flush_count || 0), Number(overlay.flush_count || 0)),
-        slots,
-        counts: countSlotTelemetry(slots)
-    };
-}
-function telemetryTsMs(value) {
-    const parsed = Date.parse(String(value || ''));
-    return Number.isFinite(parsed) ? parsed : 0;
-}
-function newerSlotTelemetry(current, incoming) {
-    const currentTs = telemetryTsMs(current.latest_ts);
-    const incomingTs = telemetryTsMs(incoming.latest_ts);
-    const currentTerminal = isTelemetryTerminalStatus(current.status);
-    const incomingTerminal = isTelemetryTerminalStatus(incoming.status);
-    if (currentTerminal && !incomingTerminal)
-        return current;
-    if (!currentTerminal && incomingTerminal)
-        return incoming;
-    if (incomingTs > currentTs)
-        return incoming;
-    if (incomingTs < currentTs)
-        return current;
-    return incoming;
-}
-async function statTelemetryFile(file) {
-    try {
-        const st = await fsp.stat(file);
-        return { mtimeMs: st.mtimeMs, size: st.size };
-    }
-    catch {
-        return null;
-    }
-}
-export function applyTelemetryEventToSnapshot(snapshot, event) {
-    const key = slotTelemetryKey(event.slot_id || event.worker_id, event.generation_index);
-    const previous = snapshot.slots?.[key];
-    const nextSlot = mergeSlotTelemetry(previous, event);
-    const slots = snapshot.slots || {};
-    slots[key] = nextSlot;
-    return {
-        schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
-        mission_id: event.mission_id || snapshot.mission_id,
-        updated_at: nowIso(),
-        flush_count: snapshot.flush_count || 0,
-        slots,
-        counts: adjustSlotTelemetryCounts(snapshot.counts || countSlotTelemetry(snapshot.slots || {}), previous, nextSlot)
-    };
-}
-export async function rebuildZellijSlotTelemetrySnapshot(root, missionId) {
-    const eventsPath = slotTelemetryEventPath(root, missionId);
-    const rows = await readTelemetryEvents(eventsPath);
-    const slots = {};
-    for (const row of rows) {
-        if (row.mission_id !== missionId)
-            continue;
-        const key = slotTelemetryKey(row.slot_id || row.worker_id, row.generation_index);
-        const previous = slots[key];
-        slots[key] = mergeSlotTelemetry(previous, row);
-    }
-    const snapshot = {
-        schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
-        mission_id: missionId,
-        updated_at: nowIso(),
-        flush_count: 0,
-        slots,
-        counts: countSlotTelemetry(slots)
-    };
-    await writeTelemetrySnapshotFast(slotTelemetrySnapshotPath(root, missionId), snapshot);
-    return snapshot;
-}
-async function readTelemetryEvents(file) {
-    const text = await readText(file, '');
-    return String(text)
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => {
-        try {
-            return normalizeTelemetryEvent(JSON.parse(line));
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter((row) => Boolean(row));
-}
-function normalizeTelemetryEvent(event) {
-    const status = normalizeStatus(event.status);
-    return {
-        schema: ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA,
-        ts: event.ts || nowIso(),
-        mission_id: String(event.mission_id || ''),
-        slot_id: String(event.slot_id || event.worker_id || 'slot-001'),
-        generation_index: Math.max(1, Math.floor(Number(event.generation_index) || 1)),
-        worker_id: String(event.worker_id || event.slot_id || 'worker'),
-        event_type: normalizeEventType(event.event_type),
-        status,
-        ...(event.role ? { role: String(event.role) } : {}),
-        ...(event.backend ? { backend: String(event.backend) } : {}),
-        ...(event.provider ? { provider: String(event.provider) } : {}),
-        ...(event.service_tier ? { service_tier: String(event.service_tier) } : {}),
-        ...(event.model ? { model: String(event.model) } : {}),
-        ...(event.reasoning_effort ? { reasoning_effort: String(event.reasoning_effort) } : {}),
-        worktree_id: event.worktree_id == null ? null : String(event.worktree_id),
-        worktree_path: event.worktree_path == null ? null : String(event.worktree_path),
-        ...(event.task_id ? { task_id: String(event.task_id) } : {}),
-        ...(event.task_title ? { task_title: String(event.task_title) } : {}),
-        current_file: event.current_file == null ? null : String(event.current_file),
-        ...(event.spawned_at ? { spawned_at: String(event.spawned_at) } : {}),
-        ...(event.progress ? (() => {
-            const progress = normalizeProgress(event.progress);
-            return progress ? { progress } : {};
-        })() : {}),
-        ...(Array.isArray(event.artifact_paths) ? { artifact_paths: event.artifact_paths.map(String).filter(Boolean) } : {}),
-        ...(event.log_tail ? { log_tail: tail(event.log_tail, 1200) } : {}),
-        ...(Array.isArray(event.blockers) ? { blockers: event.blockers.map(String).filter(Boolean) } : {}),
-        ...(event.activity_source ? { activity_source: String(event.activity_source) } : {}),
-        ...(event.activity_hash ? { activity_hash: String(event.activity_hash) } : {})
-    };
-}
-function mergeSlotTelemetry(previous, event) {
-    const previousTs = telemetryTsMs(previous?.latest_ts);
-    const eventTs = telemetryTsMs(event.ts);
-    const previousTerminal = isTelemetryTerminalStatus(previous?.status);
-    const eventTerminal = isTelemetryTerminalStatus(event.status);
-    const terminalRegression = Boolean(previous && previousTerminal && !eventTerminal);
-    const stale = Boolean(previous && (terminalRegression
-        || (!eventTerminal && eventTs < previousTs)
-        || (previousTerminal && eventTerminal && eventTs < previousTs)));
-    return {
-        slot_id: stale ? previous.slot_id : event.slot_id,
-        generation_index: stale ? previous.generation_index : event.generation_index,
-        worker_id: stale ? previous.worker_id : event.worker_id,
-        status: stale ? previous.status : event.status,
-        role: event.role || previous?.role || 'worker',
-        backend: event.backend || previous?.backend || 'unknown',
-        provider: event.provider || previous?.provider || 'unknown',
-        service_tier: event.service_tier || previous?.service_tier || 'unknown',
-        model: event.model || previous?.model || 'unknown',
-        reasoning_effort: event.reasoning_effort || previous?.reasoning_effort || 'unknown',
-        worktree_id: event.worktree_id ?? previous?.worktree_id ?? null,
-        worktree_path: event.worktree_path ?? previous?.worktree_path ?? null,
-        task_title: event.task_title || previous?.task_title || event.task_id || 'waiting for task',
-        current_file: stale ? previous.current_file ?? (terminalRegression ? null : event.current_file ?? null) : event.current_file ?? previous?.current_file ?? null,
-        latest_event_type: stale ? previous.latest_event_type : event.event_type,
-        latest_ts: stale ? previous.latest_ts : event.ts,
-        started_at: previous?.started_at || event.ts,
-        spawned_at: event.spawned_at || previous?.spawned_at || event.ts,
-        progress: stale ? previous.progress || (terminalRegression ? null : event.progress || null) : event.progress || previous?.progress || null,
-        artifact_paths: unique([...(previous?.artifact_paths || []), ...(event.artifact_paths || [])]),
-        blockers: unique([...(previous?.blockers || []), ...(event.blockers || [])]),
-        log_tail: stale ? previous.log_tail || (terminalRegression ? '' : event.log_tail || '') : event.log_tail || previous?.log_tail || '',
-        activity_source: stale ? previous.activity_source ?? null : event.activity_source || previous?.activity_source || null,
-        activity_hash: stale ? previous.activity_hash ?? null : event.activity_hash || previous?.activity_hash || null
-    };
-}
-function countSlotTelemetry(slots) {
-    const counts = { queued: 0, running: 0, verifying: 0, completed: 0, failed: 0, headless: 0 };
-    for (const row of Object.values(slots)) {
-        const bucket = slotTelemetryCountBucket(row.status);
-        counts[bucket] += 1;
-    }
-    return counts;
-}
-function adjustSlotTelemetryCounts(current, previous, next) {
-    const counts = { ...current };
-    const nextBucket = slotTelemetryCountBucket(next.status);
-    if (previous) {
-        const previousBucket = slotTelemetryCountBucket(previous.status);
-        if (previousBucket !== nextBucket) {
-            counts[previousBucket] = Math.max(0, Number(counts[previousBucket] || 0) - 1);
-            counts[nextBucket] = Number(counts[nextBucket] || 0) + 1;
-        }
-        return counts;
-    }
-    counts[nextBucket] = Number(counts[nextBucket] || 0) + 1;
-    return counts;
-}
-function slotTelemetryCountBucket(status) {
-    const normalized = normalizeStatus(status);
-    if (normalized === 'queued' || normalized === 'launching')
-        return 'queued';
-    if (normalized === 'verifying')
-        return 'verifying';
-    if (normalized === 'completed' || normalized === 'drained')
-        return 'completed';
-    if (normalized === 'failed')
-        return 'failed';
-    if (normalized === 'headless')
-        return 'headless';
-    return 'running';
-}
-function isTelemetryTerminalStatus(status) {
-    const normalized = normalizeStatus(status);
-    return normalized === 'completed' || normalized === 'failed' || normalized === 'drained';
-}
-function normalizeStatus(value) {
-    const text = String(value || '').toLowerCase();
-    if (text === 'closed' || text === 'done' || text === 'passed')
-        return 'completed';
-    if (text === 'blocked' || text === 'error' || text === 'timed_out')
-        return 'failed';
-    if (text === 'coding')
-        return 'running';
-    if (['queued', 'launching', 'running', 'verifying', 'completed', 'failed', 'headless', 'drained'].includes(text))
-        return text;
-    return 'running';
-}
-function normalizeEventType(value) {
-    const text = String(value || '');
-    const allowed = new Set([
-        'slot_reserved', 'worker_spawned', 'heartbeat', 'task_started', 'task_progress',
-        'artifact_written', 'patch_candidate', 'verification_started', 'verification_passed',
-        'verification_failed', 'worker_completed', 'worker_failed', 'headless_overflow'
-    ]);
-    return allowed.has(text) ? text : 'heartbeat';
-}
-function normalizeProgress(value) {
-    const done = Math.max(0, Math.floor(Number(value?.done) || 0));
-    const total = Math.max(0, Math.floor(Number(value?.total) || 0));
-    if (total === 0 && done > 0)
-        return null;
-    return {
-        done,
-        total,
-        label: String(value?.label || 'progress')
-    };
-}
-function unique(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
-}
-function slotTelemetryKey(slotId, generationIndex) {
-    const slot = String(slotId || 'slot-001').trim() || 'slot-001';
-    const generation = Math.max(1, Math.floor(Number(generationIndex) || 1));
-    return `${slot}:g${generation}`;
-}
-function tail(value, max) {
-    const text = String(value || '').replace(/\s+$/g, '');
-    return text.length > max ? text.slice(-max) : text;
-}
-async function writeTelemetrySnapshotFast(file, snapshot) {
-    await ensureDir(path.dirname(file));
-    await withFileLock({
-        lockPath: `${file}.lock`,
-        timeoutMs: ZELLIJ_SLOT_TELEMETRY_LOCK_TIMEOUT_MS,
-        staleMs: ZELLIJ_SLOT_TELEMETRY_LOCK_STALE_MS
-    }, async () => {
-        const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
-        telemetrySnapshotFlushCounts.set(file, flushCount);
-        telemetrySnapshotLastFlushMs.set(file, Date.now());
-        const disk = await readJson(file, null);
-        const merged = disk?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? mergeTelemetrySnapshots(disk, snapshot) : snapshot;
-        const next = { ...merged, flush_count: Math.max(flushCount, Number(merged.flush_count || 0)) };
-        if (disk?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA && telemetrySnapshotContentKey(disk) === telemetrySnapshotContentKey(next)) {
-            telemetrySnapshotCache.set(file, disk);
-            return;
-        }
-        telemetrySnapshotCache.set(file, next);
-        await writeTextAtomic(file, `${JSON.stringify(next)}\n`);
-        const stat = await statTelemetryFile(file);
-        if (stat)
-            telemetrySnapshotDiskStat.set(file, stat);
-    });
-}
-function shouldFlushTelemetrySnapshot(file, event) {
-    const next = (telemetrySnapshotWriteCounts.get(file) || 0) + 1;
-    telemetrySnapshotWriteCounts.set(file, next);
-    const now = Date.now();
-    const last = telemetrySnapshotLastFlushMs.get(file) || 0;
-    const parsedFlushMs = Number(process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_MS || 5000);
-    const flushMs = Math.max(1000, Number.isFinite(parsedFlushMs) ? parsedFlushMs : 5000);
-    const important = event.event_type === 'task_started'
-        || event.event_type === 'patch_candidate'
-        || event.event_type === 'worker_completed'
-        || event.event_type === 'worker_failed'
-        || event.status === 'completed'
-        || event.status === 'failed'
-        || event.status === 'drained';
-    const should = next === 1
-        || important
-        || now - last >= flushMs;
-    if (should)
-        telemetrySnapshotLastFlushMs.set(file, now);
-    return should;
-}
-function telemetrySnapshotContentKey(snapshot) {
-    return JSON.stringify({
-        schema: snapshot.schema,
-        mission_id: snapshot.mission_id,
-        slots: snapshot.slots || {},
-        counts: snapshot.counts || {}
-    });
-}
-function inferMissionDir(root, missionId) {
-    const resolved = path.resolve(root);
-    if (path.basename(resolved) === 'agents' && path.basename(path.dirname(resolved)) === missionId)
-        return path.dirname(resolved);
-    if (path.basename(resolved) === missionId && path.basename(path.dirname(resolved)) === 'missions')
-        return resolved;
-    const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}${missionId}${path.sep}`;
-    const index = resolved.indexOf(marker);
-    if (index >= 0)
-        return resolved.slice(0, index + marker.length - 1);
-    return path.join(resolved, '.sneakoscope', 'missions', missionId);
-}

package/dist/core/zellij/zellij-theme.js

@@ -1,66 +0,0 @@
-const ANSI = {
-    reset: '\x1b[0m',
-    dim: '\x1b[2m',
-    bold: '\x1b[1m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    cyan: '\x1b[36m',
-    magenta: '\x1b[35m',
-    gray: '\x1b[90m'
-};
-export function resolveZellijTheme() {
-    const noColor = process.env.NO_COLOR === '1' || process.env.SKS_ZELLIJ_COLOR === '0';
-    return {
-        color: !noColor && process.stdout.isTTY !== false,
-        width: Math.min(Math.max(Number(process.stdout.columns) || 100, 60), 140),
-        statusIcon: {
-            running: '●',
-            verifying: '◍',
-            queued: '◌',
-            launching: '◌',
-            done: '✔',
-            completed: '✔',
-            failed: '✖',
-            blocked: '■',
-            timed_out: '⏱',
-            headless: '·',
-            drained: '✔'
-        },
-        statusColor: {
-            running: ANSI.green,
-            verifying: ANSI.cyan,
-            queued: ANSI.gray,
-            launching: ANSI.gray,
-            done: ANSI.green,
-            completed: ANSI.green,
-            failed: ANSI.red,
-            blocked: ANSI.yellow,
-            timed_out: ANSI.red,
-            headless: ANSI.gray,
-            drained: ANSI.green
-        }
-    };
-}
-export function paint(theme, code, text) {
-    return theme.color && code ? `${code}${text}${ANSI.reset}` : text;
-}
-export function statusBadge(theme, status) {
-    const s = String(status || 'queued').toLowerCase();
-    const icon = theme.statusIcon[s] || '●';
-    return paint(theme, theme.statusColor[s] || '', `${icon} ${s}`);
-}
-export function progressBar(theme, done, total, width = 10) {
-    if (!Number.isFinite(total) || total <= 0)
-        return '';
-    const filled = Math.max(0, Math.min(width, Math.round((done / total) * width)));
-    return `${paint(theme, ANSI.green, '▉'.repeat(filled))}${paint(theme, ANSI.gray, '▁'.repeat(width - filled))} ${done}/${total}`;
-}
-export function elapsed(sinceIso) {
-    const t = Date.parse(String(sinceIso || ''));
-    if (!Number.isFinite(t))
-        return '';
-    const s = Math.max(0, Math.floor((Date.now() - t) / 1000));
-    return `${String(Math.floor(s / 60)).padStart(2, '0')}:${String(s % 60).padStart(2, '0')}`;
-}
-export const ANSI_CODES = ANSI;

package/dist/core/zellij/zellij-ui-mode.js

@@ -1,34 +0,0 @@
-export function resolveZellijUiConfig(args = [], env = process.env) {
-    return {
-        mode: resolveZellijUiMode(args, env),
-        color: env.SKS_ZELLIJ_COLOR !== '0' && env.NO_COLOR !== '1',
-        visiblePanes: Number(env.SKS_ZELLIJ_VISIBLE_PANES) || null,
-        viewports: boundedInt(env.SKS_ZELLIJ_VIEWPORTS, 1, 0, 3),
-        monitorRows: Math.max(4, Number(env.SKS_ZELLIJ_MONITOR_ROWS || 12)),
-        monitor: env.SKS_ZELLIJ_MONITOR_PANE !== '0',
-        intervalMs: Math.max(500, Number(env.SKS_ZELLIJ_REFRESH_MS) || 1000)
-    };
-}
-export function resolveZellijUiMode(args = [], env = process.env) {
-    return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
-}
-export function resolveZellijWorkerPaneUiMode(args = [], env = process.env) {
-    return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
-}
-function resolveExplicitZellijUiMode(args = [], env = process.env) {
-    const fromEnv = String(env.SKS_ZELLIJ_UI_MODE || '').trim();
-    if (fromEnv === 'compact-slots')
-        return 'compact-slots';
-    if (fromEnv === 'full-debug')
-        return 'full-debug';
-    if (args.includes('--zellij-compact-slots'))
-        return 'compact-slots';
-    if (args.includes('--zellij-full-debug'))
-        return 'full-debug';
-    return null;
-}
-function boundedInt(value, fallback, min, max) {
-    const parsed = Math.floor(Number(value ?? fallback));
-    const n = Number.isFinite(parsed) ? parsed : fallback;
-    return Math.max(min, Math.min(n, max));
-}