sneakoscope 2.0.18 → 3.0.1

package/dist/core/release/release-gate-cache-v2.js

@@ -5,19 +5,44 @@ export const RELEASE_GATE_CACHE_V2_SCHEMA = 'sks.release-gate-cache.v2';
 export function releaseGateCacheFile(root) {
     return path.join(root, '.sneakoscope', 'reports', 'release-gates', 'cache-v2.json');
 }
+// Files whose only release-to-release difference is the version literal.
+// Hashing them version-neutrally keeps a pure `sks versioning bump` from
+// invalidating every behavior gate: bumping the version rewrites
+// package.json, package-lock.json, and the three PACKAGE_VERSION constant
+// sources, which are inputs of ~280 gates (via `package.json` and `src/**`).
+// Before this normalization every publish re-ran the entire DAG from zero
+// (test:blackbox alone is ~11 minutes) even when no behavior changed.
+// Version-CORRECTNESS gates (release:version-truth, release:metadata, ...)
+// are declared with `cache.enabled: false`, so they always re-run and still
+// catch version drift. Set SKS_RELEASE_CACHE_VERSION_SENSITIVE=1 to restore
+// the old fully version-sensitive hashing.
+const VERSION_NEUTRAL_CACHE_FILES = new Set([
+    'package.json',
+    'package-lock.json',
+    'src/core/version.ts',
+    'src/core/fsx.ts',
+    'src/bin/sks.ts'
+]);
 export function releaseGateCacheKey(root, gate) {
     const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const releaseVersion = String(pkg.version || '');
+    const versionSensitive = process.env.SKS_RELEASE_CACHE_VERSION_SENSITIVE === '1';
     const hash = crypto.createHash('sha256');
     hash.update(gate.id);
     hash.update(gate.command);
-    hash.update(String(pkg.version || ''));
+    if (versionSensitive)
+        hash.update(releaseVersion);
     hash.update(process.version);
     hash.update(String(process.env.npm_config_user_agent || ''));
     hash.update(JSON.stringify(gate.resource || []));
     hash.update(JSON.stringify(gate.preset || []));
     hashFileIfPresent(hash, path.join(root, 'release-gates.v2.json'));
-    hashFileIfPresent(hash, path.join(root, 'package.json'));
-    hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
+    if (versionSensitive || !gate.cache.inputs.length) {
+        // No declared inputs (or explicitly version-sensitive mode): fall back to
+        // the conservative global digests so such a gate cannot cache-hit forever.
+        hashFileIfPresent(hash, path.join(root, 'package.json'));
+        hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
+    }
     for (const input of gate.cache.inputs) {
         const expanded = expandGlob(root, input);
         hash.update(`input:${input}`);
@@ -26,12 +51,29 @@ export function releaseGateCacheKey(root, gate) {
             continue;
         }
         for (const file of expanded) {
-            hash.update(path.relative(root, file));
-            hashFileIfPresent(hash, file);
+            const rel = path.relative(root, file);
+            hash.update(rel);
+            if (!versionSensitive && VERSION_NEUTRAL_CACHE_FILES.has(rel))
+                hashVersionNeutralFile(hash, file, releaseVersion);
+            else
+                hashFileIfPresent(hash, file);
         }
     }
     return hash.digest('hex');
 }
+function hashVersionNeutralFile(hash, file, releaseVersion) {
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+        return;
+    const text = fs.readFileSync(file, 'utf8');
+    if (!releaseVersion) {
+        hash.update(text);
+        return;
+    }
+    // Replace exact occurrences of the current release version literal so a
+    // version-only bump hashes identically. Any other content change in these
+    // files still alters the key.
+    hash.update(text.split(releaseVersion).join('__SKS_RELEASE_VERSION__'));
+}
 export function expandGlob(root, input) {
     const absolute = path.join(root, input);
     if (!/[*!?[\]{}]/.test(input)) {

package/dist/core/usage/codex-account-usage.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { findCodexBinary } from '../codex-adapter.js';
+import { nowIso, runProcess, writeJsonAtomic } from '../fsx.js';
 export async function collectCodexAccountUsage() {
     if (process.env.SKS_CODEX_ACCOUNT_USAGE_FAKE === '1') {
         return {
@@ -15,22 +16,42 @@ export async function collectCodexAccountUsage() {
                 reset_at: null
             },
             usage_limit_tokens: 100000,
+            attempted_sources: ['fake'],
             blockers: []
         };
     }
-    const url = String(process.env.SKS_CODEX_APP_SERVER_USAGE_URL || process.env.CODEX_APP_SERVER_USAGE_URL || '').trim();
-    if (!url)
-        return unavailable(['codex_app_server_usage_endpoint_unavailable']);
-    try {
-        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
-        if (!response.ok)
-            return unavailable([`codex_app_server_usage_http_${response.status}`]);
-        const payload = await response.json();
-        return normalizeUsagePayload(payload, 'app-server');
-    }
-    catch (err) {
-        return unavailable([`codex_app_server_usage_fetch_failed:${err?.message || String(err)}`]);
+    const attemptedSources = [];
+    const urls = [
+        ['CODEX_APP_SERVER_USAGE_URL', process.env.CODEX_APP_SERVER_USAGE_URL],
+        ['SKS_CODEX_APP_SERVER_USAGE_URL', process.env.SKS_CODEX_APP_SERVER_USAGE_URL],
+        ...localWellKnownUsageUrls().map((url) => [`local:${url}`, url])
+    ];
+    const blockers = [];
+    for (const [label, rawUrl] of urls) {
+        const url = String(rawUrl || '').trim();
+        if (!url)
+            continue;
+        attemptedSources.push(label);
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(label.startsWith('local:') ? 800 : 5000) });
+            if (!response.ok) {
+                blockers.push(`codex_app_server_usage_http_${response.status}:${label}`);
+                continue;
+            }
+            const payload = await response.json();
+            return normalizeUsagePayload(payload, 'app-server', attemptedSources);
+        }
+        catch (err) {
+            blockers.push(`codex_app_server_usage_fetch_failed:${label}:${err?.message || String(err)}`);
+        }
     }
+    const cli = await collectUsageFromCodexCli(attemptedSources).catch((err) => {
+        blockers.push(`codex_cli_usage_probe_failed:${err?.message || String(err)}`);
+        return null;
+    });
+    if (cli)
+        return cli;
+    return unavailable(attemptedSources.length ? blockers : ['codex_app_server_usage_endpoint_unavailable'], attemptedSources);
 }
 export async function writeCodexAccountUsageArtifacts(root, input = {}) {
     const snapshot = await collectCodexAccountUsage();
@@ -43,7 +64,7 @@ export async function writeCodexAccountUsageArtifacts(root, input = {}) {
     }
     return { snapshot, root_artifact: rootArtifact, mission_artifact: missionArtifact };
 }
-function normalizeUsagePayload(payload, source) {
+function normalizeUsagePayload(payload, source, attemptedSources) {
     const usage = payload?.token_usage || payload?.usage || payload;
     const input = Number(usage?.input_tokens || usage?.inputTokens || 0);
     const output = Number(usage?.output_tokens || usage?.outputTokens || 0);
@@ -61,18 +82,58 @@ function normalizeUsagePayload(payload, source) {
             reset_at: usage?.reset_at || usage?.resetAt || null
         },
         usage_limit_tokens: Number.isFinite(Number(payload?.usage_limit_tokens || payload?.usageLimitTokens)) ? Number(payload?.usage_limit_tokens || payload?.usageLimitTokens) : null,
+        attempted_sources: attemptedSources,
         blockers: []
     };
 }
-function unavailable(blockers) {
+function unavailable(blockers, attemptedSources = []) {
     return {
         schema: 'sks.codex-account-usage.v1',
         generated_at: nowIso(),
-        ok: true,
+        ok: false,
         source: 'unavailable',
         token_usage: null,
         usage_limit_tokens: null,
+        attempted_sources: attemptedSources,
         blockers
     };
 }
+function localWellKnownUsageUrls() {
+    const ports = [
+        process.env.CODEX_APP_SERVER_PORT,
+        process.env.SKS_CODEX_APP_SERVER_PORT,
+        1455,
+        1456,
+        3000
+    ].map((value) => Number(value)).filter((value, index, rows) => Number.isFinite(value) && value > 0 && rows.indexOf(value) === index);
+    return ports.flatMap((port) => [
+        `http://127.0.0.1:${port}/usage`,
+        `http://127.0.0.1:${port}/api/usage`,
+        `http://127.0.0.1:${port}/.well-known/codex/usage`
+    ]);
+}
+async function collectUsageFromCodexCli(attemptedSources) {
+    const bin = await findCodexBinary();
+    if (!bin)
+        return null;
+    const commands = [
+        ['account', 'usage', '--json'],
+        ['usage', '--json'],
+        ['app-server', 'status', '--json']
+    ];
+    for (const args of commands) {
+        const label = `codex-cli:${args.join(' ')}`;
+        attemptedSources.push(label);
+        const result = await runProcess(bin, args, { timeoutMs: 3000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+        if (!result || result.code !== 0)
+            continue;
+        try {
+            const payload = JSON.parse(`${result.stdout || ''}${result.stderr || ''}`.trim() || '{}');
+            const normalized = normalizeUsagePayload(payload, 'app-server', attemptedSources);
+            return { ...normalized, source: 'app-server' };
+        }
+        catch { }
+    }
+    return null;
+}
 //# sourceMappingURL=codex-account-usage.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.18';
+export const PACKAGE_VERSION = '3.0.1';
 //# sourceMappingURL=version.js.map

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();