sneakoscope 2.0.18 → 3.0.0

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -215,7 +215,10 @@ async function tryRenderTelemetrySlotPane(input) {
         return null;
     const staleRows = staleTelemetryRows(telemetryStatus(snapshot).telemetry_age_ms);
     const fallbackRows = artifactFallbackRows(input.artifactRender);
-    const liveRows = staleRows.length || !slot.progress ? fallbackRows : [];
+    // Always surface the live artifact rows (current file, tool events, stdout
+    // tail). Telemetry freshness only tells us the worker is alive — the user
+    // still needs to see WHAT the worker is doing right now.
+    const liveRows = fallbackRows;
     if (slot.status === 'failed') {
         return [
             `${slot.slot_id} gen-${slot.generation_index} · FAILED`,
@@ -254,7 +257,7 @@ function artifactFallbackRows(text) {
         .map((line) => line.replace(/^\|\s?/, '').replace(/\s?\|$/, '').trim())
         .filter((line) => /^(heartbeat|doing|files|event|out|err):\s+/i.test(line))
         .filter((line) => !/unknown|waiting for worker intake|no changed file yet/i.test(line))
-        .slice(-4)
+        .slice(-7)
         .map((line) => `live: ${trimInline(line, 72)}`);
 }
 function findTelemetrySlot(snapshot, slotId, generationIndex) {

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

@@ -7,6 +7,7 @@ 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');
 }
@@ -33,24 +34,68 @@ export async function appendZellijSlotTelemetry(root, event) {
     await rebuildZellijSlotTelemetrySnapshot(root, missionId);
 }
 export async function readZellijSlotTelemetrySnapshot(root, missionId) {
-    const snapshotPath = slotTelemetrySnapshotPath(root, missionId);
-    const cached = telemetrySnapshotCache.get(snapshotPath);
-    if (cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
-        return cached;
-    const existing = await readJson(snapshotPath, null);
-    if (existing?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
-        return existing;
+    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);
-    if (cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
+    const stat = await statTelemetryFile(snapshotPath);
+    const recorded = telemetrySnapshotDiskStat.get(snapshotPath);
+    const diskChanged = Boolean(stat) && (!recorded || recorded.mtimeMs !== stat.mtimeMs || recorded.size !== stat.size);
+    // CRITICAL: never serve a process-local cache forever. Long-lived reader
+    // processes (zellij slot pane renderers in --watch mode) must observe
+    // snapshot flushes performed by the orchestrator and worker processes,
+    // otherwise the pane renders the same frame for the entire mission.
+    if (!diskChanged && cached?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
         return cached;
     const existing = await readJson(snapshotPath, null);
-    if (existing?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA)
-        telemetrySnapshotCache.set(snapshotPath, existing);
-    return existing?.schema === ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA ? existing : 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;
+    // Merge with any locally cached (possibly not-yet-flushed) slot state so a
+    // writer process does not lose its pending events when another process
+    // flushed the snapshot file in the meantime. The DISK updated_at stays
+    // authoritative on the read path: it reflects the last real flush, which is
+    // what stale-telemetry detection must measure.
+    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 || telemetryTsMs(row.latest_ts) >= telemetryTsMs(existing.latest_ts) ? row : existing;
+    }
+    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;
+}
+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);
@@ -216,9 +261,17 @@ async function writeTelemetrySnapshotFast(file, snapshot) {
     const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
     telemetrySnapshotFlushCounts.set(file, flushCount);
     telemetrySnapshotLastFlushMs.set(file, Date.now());
-    const next = { ...snapshot, flush_count: flushCount };
+    // Merge with the on-disk snapshot before overwriting: multiple processes
+    // (orchestrator + worker children) flush this file concurrently and a plain
+    // overwrite would drop slots that only the other process has observed.
+    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)) };
     telemetrySnapshotCache.set(file, next);
     await fsp.writeFile(file, `${JSON.stringify(next)}\n`, 'utf8');
+    const stat = await statTelemetryFile(file);
+    if (stat)
+        telemetrySnapshotDiskStat.set(file, stat);
 }
 function shouldFlushTelemetrySnapshot(file, event) {
     const next = (telemetrySnapshotWriteCounts.get(file) || 0) + 1;

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

@@ -2,7 +2,14 @@ export function resolveZellijUiMode(args = [], env = process.env) {
     return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
 }
 export function resolveZellijWorkerPaneUiMode(args = [], env = process.env) {
-    return resolveExplicitZellijUiMode(args, env) || 'full-debug';
+    // Default worker panes to the live slot renderer (compact-slots). In
+    // 'full-debug' the pane runs the worker process itself, but the worker is
+    // invoked with --json and the codex SDK streams events to JSONL files — so
+    // the pane stays blank until the worker exits. The slot renderer re-reads
+    // heartbeat/event/stdout artifacts every second and actually shows what each
+    // parallel worker is doing in real time. 'full-debug' remains available via
+    // --zellij-full-debug or SKS_ZELLIJ_UI_MODE=full-debug.
+    return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
 }
 function resolveExplicitZellijUiMode(args = [], env = process.env) {
     const fromEnv = String(env.SKS_ZELLIJ_UI_MODE || '').trim();

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

@@ -0,0 +1,307 @@
+import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { ensureDir, globalSksRoot, nowIso, readJson, runProcess, writeJsonAtomic } from '../fsx.js';
+import { guardContextForRoute, guardedPackageInstall } from '../safety/mutation-guard.js';
+import { createRequestedScopeContract } from '../safety/requested-scope-contract.js';
+import { checkZellijCapability } from './zellij-capability.js';
+import { compareVersionLike, parseZellijVersionText } from './zellij-command.js';
+export const ZELLIJ_UPDATE_NOTICE_SCHEMA = 'sks.zellij-update-notice.v1';
+const ZELLIJ_RELEASES_API_PATH = '/repos/zellij-org/zellij/releases/latest';
+export function zellijUpgradeCommandHint(missing = false) {
+    if (process.platform === 'darwin')
+        return missing ? 'brew install zellij' : 'brew upgrade zellij';
+    if (process.platform === 'linux')
+        return 'cargo install --locked zellij   # or your distro package manager';
+    return 'See https://zellij.dev/documentation/installation';
+}
+/**
+ * Resolve the latest STABLE zellij version. GitHub's /releases/latest endpoint
+ * already excludes prereleases and drafts. Results are cached on disk
+ * (default TTL 6h, override with SKS_ZELLIJ_UPDATE_TTL_MS) so command launches
+ * stay fast and offline-safe. SKS_ZELLIJ_LATEST_VERSION pins the value for
+ * tests and air-gapped environments.
+ */
+export async function fetchLatestZellijVersion(input = {}) {
+    const env = input.env || process.env;
+    const pinned = stripVersionPrefix(String(env.SKS_ZELLIJ_LATEST_VERSION || '').trim());
+    if (pinned)
+        return { version: parseZellijVersionText(pinned) || pinned, source: 'env' };
+    const ttlMs = normalizePositiveInt(env.SKS_ZELLIJ_UPDATE_TTL_MS, 6 * 60 * 60 * 1000);
+    const cachePath = zellijUpdateCachePath();
+    const cached = await readJson(cachePath, null);
+    if (cached?.schema === ZELLIJ_UPDATE_NOTICE_SCHEMA && cached.latest_version && Date.now() - Date.parse(cached.checked_at || '') < ttlMs) {
+        return { version: cached.latest_version, source: 'cache' };
+    }
+    try {
+        const tag = await githubLatestTag(input.timeoutMs || normalizePositiveInt(env.SKS_ZELLIJ_UPDATE_TIMEOUT_MS, 2500));
+        // GitHub release tags carry a leading "v" (v0.44.3); \b-based version
+        // parsing cannot start inside "v0", so strip the prefix first.
+        const version = parseZellijVersionText(stripVersionPrefix(tag));
+        if (!version)
+            throw new Error(`zellij_latest_tag_unparsed:${tag}`);
+        return { version, source: 'github-releases' };
+    }
+    catch (err) {
+        return {
+            version: cached?.latest_version || null,
+            source: 'error',
+            error: err?.message || String(err)
+        };
+    }
+}
+export async function checkZellijUpdateNotice(input = {}) {
+    const env = input.env || process.env;
+    const ttlMs = normalizePositiveInt(env.SKS_ZELLIJ_UPDATE_TTL_MS, 6 * 60 * 60 * 1000);
+    if (env.SKS_SKIP_ZELLIJ_UPDATE === '1' || env.SKS_DISABLE_UPDATE_NOTICE === '1') {
+        return persistNotice(input.missionDir, {
+            schema: ZELLIJ_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            current_version: null,
+            latest_version: null,
+            update_available: false,
+            zellij_missing: false,
+            source: 'disabled',
+            cache_ttl_ms: ttlMs,
+            upgrade_command: zellijUpgradeCommandHint(),
+            message: 'Zellij update notice disabled by environment.'
+        });
+    }
+    const capability = await checkZellijCapability({ require: false, writeReport: false }).catch(() => null);
+    const current = capability?.version || null;
+    const missing = capability?.status === 'missing' || !capability;
+    const fetchInput = { env };
+    if (input.timeoutMs !== undefined)
+        fetchInput.timeoutMs = input.timeoutMs;
+    const latest = await fetchLatestZellijVersion(fetchInput);
+    const updateAvailable = Boolean(!missing && current && latest.version && compareVersionLike(latest.version, current) > 0);
+    const notice = {
+        schema: ZELLIJ_UPDATE_NOTICE_SCHEMA,
+        checked_at: nowIso(),
+        current_version: current,
+        latest_version: latest.version,
+        update_available: updateAvailable,
+        zellij_missing: missing,
+        source: latest.source,
+        cache_ttl_ms: ttlMs,
+        upgrade_command: zellijUpgradeCommandHint(missing),
+        message: missing
+            ? `Zellij is not installed. Install with: ${zellijUpgradeCommandHint(true)}`
+            : updateAvailable
+                ? `Zellij ${latest.version} is available; current ${current}. Upgrade with: ${zellijUpgradeCommandHint()}`
+                : `Zellij ${current || 'unknown'} is current enough.`,
+        ...(latest.error ? { error: latest.error } : {})
+    };
+    if (latest.source === 'github-releases') {
+        await ensureDir(path.dirname(zellijUpdateCachePath())).catch(() => undefined);
+        await writeJsonAtomic(zellijUpdateCachePath(), notice).catch(() => undefined);
+    }
+    return persistNotice(input.missionDir, notice);
+}
+/**
+ * Upgrade zellij to the latest stable release. Only Homebrew automation is
+ * attempted (macOS / Linuxbrew); everything else returns manual_required with
+ * the exact operator command, mirroring how the Codex CLI update flow behaves.
+ */
+export async function upgradeZellijToLatest(input = {}) {
+    const before = await checkZellijCapability({ require: false, writeReport: false }).catch(() => null);
+    const beforeVersion = before?.version || null;
+    const missing = before?.status === 'missing' || !before;
+    const latest = await fetchLatestZellijVersion({ env: input.env || process.env });
+    const brew = await runProcess('brew', ['--version'], { timeoutMs: 8000, maxOutputBytes: 4096 });
+    if (brew.code !== 0) {
+        return {
+            status: 'manual_required',
+            before_version: beforeVersion,
+            after_version: beforeVersion,
+            latest_version: latest.version,
+            command: zellijUpgradeCommandHint(missing),
+            error: 'homebrew_not_available'
+        };
+    }
+    const upgradeArgs = missing ? ['install', 'zellij'] : ['upgrade', 'zellij'];
+    // Package installs go through the mutation guard with an explicit
+    // zellij_install scope contract (same path ensureZellijCliTool uses), so the
+    // mutation ledger records the install and safety gates can audit it. The
+    // upgrade only runs after the operator confirmed the [Y/n] prompt or passed
+    // --yes / `sks zellij update --yes`.
+    const guardRoot = globalSksRoot();
+    const guardCommand = `brew ${upgradeArgs.join(' ')}`;
+    const contract = createRequestedScopeContract({
+        route: 'zellij-update',
+        userRequest: guardCommand,
+        projectRoot: guardRoot,
+        overrides: { package_install: true, zellij_install: true }
+    });
+    const guardCtx = guardContextForRoute(guardRoot, contract, guardCommand);
+    let run = await guardedPackageInstall(guardCtx, 'zellij', {
+        confirmed: true,
+        command: 'brew',
+        args: upgradeArgs,
+        timeoutMs: input.timeoutMs || 180000,
+        maxOutputBytes: 256 * 1024
+    }).catch((err) => ({ code: 1, stdout: '', stderr: String(err?.message || err) }));
+    if (run.code !== 0 && !missing && /No such keg|No available formula|not installed/i.test(`${run.stderr}\n${run.stdout}`)) {
+        // zellij exists on PATH but was not installed through Homebrew (e.g. cargo
+        // or a manual binary). Installing the brew formula gives a managed copy.
+        run = await guardedPackageInstall(guardCtx, 'zellij', {
+            confirmed: true,
+            command: 'brew',
+            args: ['install', 'zellij'],
+            timeoutMs: input.timeoutMs || 180000,
+            maxOutputBytes: 256 * 1024
+        }).catch((err) => ({ code: 1, stdout: '', stderr: String(err?.message || err) }));
+    }
+    if (run.code !== 0 && /already installed|already up-to-date/i.test(`${run.stderr}\n${run.stdout}`)) {
+        return {
+            status: 'noop',
+            before_version: beforeVersion,
+            after_version: beforeVersion,
+            latest_version: latest.version,
+            command: `brew ${upgradeArgs.join(' ')}`,
+            error: null
+        };
+    }
+    if (run.code !== 0) {
+        return {
+            status: 'failed',
+            before_version: beforeVersion,
+            after_version: beforeVersion,
+            latest_version: latest.version,
+            command: `brew ${upgradeArgs.join(' ')}`,
+            error: `${run.stderr || run.stdout || 'brew upgrade failed'}`.trim().slice(-1000)
+        };
+    }
+    const after = await checkZellijCapability({ require: false, writeReport: false }).catch(() => null);
+    return {
+        status: missing ? 'installed' : 'upgraded',
+        before_version: beforeVersion,
+        after_version: after?.version || null,
+        latest_version: latest.version,
+        command: `brew ${upgradeArgs.join(' ')}`,
+        error: null
+    };
+}
+/**
+ * Launch-time prompt, mirroring maybePromptCodexUpdateForLaunch: check the
+ * installed zellij version against the latest stable release and offer an
+ * upgrade before opening the live session. Never blocks the launch.
+ *
+ * Skips: --json, --skip-cli-tools, --skip-zellij-update, SKS_SKIP_ZELLIJ_UPDATE=1.
+ * Auto-approves: --yes / -y.
+ */
+export async function maybePromptZellijUpdateForLaunch(args = [], opts = {}) {
+    const env = opts.env || process.env;
+    const list = (args || []).map((arg) => String(arg));
+    if (list.includes('--json') || list.includes('--skip-cli-tools') || list.includes('--skip-zellij-update') || env.SKS_SKIP_ZELLIJ_UPDATE === '1') {
+        return { status: 'skipped', current: null, latest: null, command: null };
+    }
+    const notice = await checkZellijUpdateNotice({ env }).catch(() => null);
+    if (!notice)
+        return { status: 'skipped', current: null, latest: null, command: null };
+    if (notice.zellij_missing) {
+        // Zellij is an optional integration; installation is owned by
+        // `sks deps check --yes` / `sks zellij update --yes`. Just surface the hint.
+        console.log(`Zellij not found (optional live panes disabled). Install with: ${notice.upgrade_command}`);
+        return { status: 'missing', current: null, latest: notice.latest_version, command: notice.upgrade_command };
+    }
+    if (!notice.update_available) {
+        return { status: 'current', current: notice.current_version, latest: notice.latest_version, command: null, error: notice.error || null };
+    }
+    const label = opts.label || 'Zellij launch';
+    const autoYes = list.includes('--yes') || list.includes('-y');
+    if (!autoYes && !canAskYesNo(env)) {
+        console.log(`Zellij update available: ${notice.current_version} -> ${notice.latest_version}. Run: ${notice.upgrade_command}`);
+        return { status: 'available', current: notice.current_version, latest: notice.latest_version, command: notice.upgrade_command };
+    }
+    if (!autoYes) {
+        const yes = await askYesNoDefaultYes(`Zellij ${notice.current_version} -> ${notice.latest_version} update before ${label}? [Y/n] `);
+        if (!yes)
+            return { status: 'skipped_by_user', current: notice.current_version, latest: notice.latest_version, command: notice.upgrade_command };
+    }
+    const upgraded = await upgradeZellijToLatest({ env });
+    if (upgraded.status === 'upgraded' || upgraded.status === 'installed') {
+        console.log(`Zellij ${upgraded.before_version || 'unknown'} -> ${upgraded.after_version || upgraded.latest_version || 'latest'} (${upgraded.command})`);
+    }
+    else if (upgraded.status === 'manual_required') {
+        console.log(`Zellij upgrade needs a manual step: ${upgraded.command}`);
+    }
+    else if (upgraded.status === 'failed') {
+        console.log(`Zellij upgrade failed (launch continues): ${upgraded.error || upgraded.command}`);
+    }
+    return {
+        status: upgraded.status,
+        current: upgraded.after_version || upgraded.before_version,
+        latest: upgraded.latest_version,
+        command: upgraded.command,
+        error: upgraded.error || null
+    };
+}
+export function zellijUpdateCachePath() {
+    return path.join(os.homedir(), '.sneakoscope', 'cache', 'zellij-update-notice.json');
+}
+async function persistNotice(missionDir, notice) {
+    if (missionDir)
+        await writeJsonAtomic(path.join(missionDir, 'zellij-update-notice.json'), notice).catch(() => undefined);
+    return notice;
+}
+function githubLatestTag(timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: 'api.github.com',
+            path: ZELLIJ_RELEASES_API_PATH,
+            method: 'GET',
+            timeout: timeoutMs,
+            headers: {
+                Accept: 'application/vnd.github+json',
+                'User-Agent': 'sneakoscope-cli'
+            }
+        }, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try {
+                    if ((res.statusCode || 0) < 200 || (res.statusCode || 0) >= 300)
+                        throw new Error(`github_status_${res.statusCode}`);
+                    const parsed = JSON.parse(body);
+                    const tag = String(parsed?.tag_name || '').trim();
+                    if (!tag)
+                        throw new Error('github_latest_tag_missing');
+                    resolve(tag);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy(new Error('zellij_update_check_timeout'));
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+function canAskYesNo(env) {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && env.CI !== 'true');
+}
+async function askYesNoDefaultYes(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await new Promise((resolve) => rl.question(question, resolve));
+        const trimmed = String(answer || '').trim();
+        return trimmed === '' || /^(y|yes|예|네|응)$/i.test(trimmed);
+    }
+    finally {
+        rl.close();
+    }
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function stripVersionPrefix(value) {
+    return value.replace(/^v(?=\d)/i, '');
+}
+//# sourceMappingURL=zellij-update.js.map