sneakoscope 2.0.15 → 2.0.17

package/dist/core/mad-db/mad-db-result-lifecycle.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+import { appendMadDbOperationLifecycle } from './mad-db-ledger.js';
+const PENDING_FILE = 'mad-db-lifecycle-pending.jsonl';
+const PENDING_LATEST_FILE = 'mad-db-lifecycle-pending.latest.json';
+export async function recordPendingMadDbLifecycleHook(root, missionId, hook) {
+    const dir = missionDir(root, missionId);
+    const row = {
+        schema: 'sks.mad-db-lifecycle-pending.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        hook
+    };
+    await appendJsonlBounded(path.join(dir, PENDING_FILE), row);
+    await writeJsonAtomic(path.join(dir, PENDING_LATEST_FILE), row).catch(() => undefined);
+    return row;
+}
+export async function readLatestPendingMadDbLifecycleHook(root, missionId, payload = {}) {
+    const dir = missionDir(root, missionId);
+    const embedded = lifecycleHookFromUnknown(payload);
+    if (embedded)
+        return embedded;
+    const latest = await readJson(path.join(dir, PENDING_LATEST_FILE), null).catch(() => null);
+    const latestHook = lifecycleHookFromUnknown(latest?.hook);
+    if (latestHook && hookMatchesPayload(latestHook, payload))
+        return latestHook;
+    const text = await readText(path.join(dir, PENDING_FILE), '').catch(() => '');
+    const rows = String(text).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
+    for (const line of rows.slice(0, 50)) {
+        try {
+            const row = JSON.parse(line);
+            const hook = lifecycleHookFromUnknown(row?.hook);
+            if (hook && hookMatchesPayload(hook, payload))
+                return hook;
+        }
+        catch {
+            // Ignore malformed pending rows.
+        }
+    }
+    return null;
+}
+export async function recordMadDbToolResult(input) {
+    const terminalType = input.ok ? 'db_operation.succeeded' : 'db_operation.failed';
+    if (await hasTerminalLifecycleEvent(input.root, input.missionId, input.hook.operation_id)) {
+        return {
+            schema: 'sks.mad-db-tool-result-lifecycle.v1',
+            ok: true,
+            skipped: true,
+            reason: 'mad_db_operation_terminal_event_already_recorded',
+            operation_id: input.hook.operation_id
+        };
+    }
+    const event = await appendMadDbOperationLifecycle(input.root, input.missionId, {
+        type: terminalType,
+        operationId: input.hook.operation_id,
+        cycleId: input.hook.cycle_id || null,
+        mcpServer: input.hook.mcp_server || null,
+        toolName: input.hook.tool_name || null,
+        sqlHash: input.hook.sql_hash || null,
+        destructive: input.hook.destructive === true,
+        resultStatus: input.ok ? 'succeeded' : 'failed',
+        rowCount: input.rowCount ?? null,
+        error: input.error || null
+    });
+    await markPendingHookResolved(input.root, input.missionId, input.hook, input.ok);
+    return {
+        schema: 'sks.mad-db-tool-result-lifecycle.v1',
+        ok: true,
+        skipped: false,
+        operation_id: input.hook.operation_id,
+        result_status: input.ok ? 'succeeded' : 'failed',
+        event
+    };
+}
+export function lifecycleHookFromUnknown(value) {
+    const candidate = value?.ledger_result_hook || value?.mad_db?.ledger_result_hook || value;
+    const missionId = stringOrNull(candidate?.mission_id || candidate?.missionId);
+    const operationId = stringOrNull(candidate?.operation_id || candidate?.operationId);
+    if (!missionId || !operationId)
+        return null;
+    return {
+        mission_id: missionId,
+        operation_id: operationId,
+        cycle_id: stringOrNull(candidate?.cycle_id || candidate?.cycleId),
+        tool_name: stringOrNull(candidate?.tool_name || candidate?.toolName),
+        sql_hash: stringOrNull(candidate?.sql_hash || candidate?.sqlHash),
+        mcp_server: stringOrNull(candidate?.mcp_server || candidate?.mcpServer),
+        destructive: candidate?.destructive === true
+    };
+}
+function hookMatchesPayload(hook, payload) {
+    if (!hook.tool_name)
+        return true;
+    const toolText = [
+        payload.tool_name,
+        payload.toolName,
+        payload.name,
+        payload.tool?.name,
+        payload.server,
+        payload.mcp_tool,
+        payload.tool,
+        payload.type
+    ].filter(Boolean).join(' ').toLowerCase();
+    if (!toolText)
+        return true;
+    return toolText.includes(String(hook.tool_name).toLowerCase()) || String(hook.tool_name).toLowerCase().includes(toolText);
+}
+async function hasTerminalLifecycleEvent(root, missionId, operationId) {
+    const ledger = path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl');
+    const text = await readText(ledger, '').catch(() => '');
+    return String(text).split(/\r?\n/).some((line) => {
+        if (!line.includes(operationId))
+            return false;
+        return line.includes('db_operation.succeeded') || line.includes('db_operation.failed');
+    });
+}
+async function markPendingHookResolved(root, missionId, hook, ok) {
+    const dir = missionDir(root, missionId);
+    const row = {
+        schema: 'sks.mad-db-lifecycle-pending-resolution.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        operation_id: hook.operation_id,
+        cycle_id: hook.cycle_id || null,
+        result_status: ok ? 'succeeded' : 'failed'
+    };
+    await appendJsonlBounded(path.join(dir, 'mad-db-lifecycle-resolved.jsonl'), row).catch(() => undefined);
+    await fs.rm(path.join(dir, PENDING_LATEST_FILE), { force: true }).catch(() => undefined);
+}
+function stringOrNull(value) {
+    const text = String(value || '').trim();
+    return text ? text : null;
+}
+//# sourceMappingURL=mad-db-result-lifecycle.js.map

package/dist/core/naruto/naruto-concurrency-governor.js

@@ -9,6 +9,7 @@ export function decideNarutoConcurrency(input = {}) {
     const hardware = probeHardwareCapacity(input.hardware || {});
     const zellijVisiblePaneCap = normalizePositiveInt(input.zellijVisiblePaneCap, Math.min(8, Math.max(4, Math.floor(hardware.terminal_rows / 5))));
     const backend = String(input.backend || 'codex-sdk');
+    const parallelismMode = normalizeParallelismMode(input.parallelismMode);
     const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
     const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);
     const reclaimableFloorGb = totalGb >= 32 ? 16 : totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : Math.max(1, freeGb);
@@ -33,7 +34,12 @@ export function decideNarutoConcurrency(input = {}) {
     const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap + ioCap, gitWorktreeCap + processCap, backendBudget, queueCap, leaseCap, 100));
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
-    const safeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const currentSafeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
+    const safeActiveWorkers = parallelismMode === 'extreme'
+        ? rawSafe
+        : parallelismMode === 'balanced'
+            ? Math.max(1, Math.min(rawSafe, Math.max(16, Math.floor(rawSafe * 0.75))))
+            : currentSafeActiveWorkers;
     const safeVisible = Math.min(safeActiveWorkers, zellijVisiblePaneCap);
     const reasons = [
         ...(memoryCap < requestedClones ? ['memory_cap'] : []),
@@ -60,11 +66,18 @@ export function decideNarutoConcurrency(input = {}) {
         git_worktree_parallel: gitWorktreeCap,
         cpu_io_parallel: cpuCap + ioCap,
         verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
+        parallelism_mode: parallelismMode,
         reasons: [...new Set(reasons)],
         backpressure: backpressure.backpressure,
         hardware
     };
 }
+function normalizeParallelismMode(value) {
+    const text = String(value || process.env.SKS_NARUTO_PARALLELISM || 'extreme').toLowerCase();
+    if (text === 'safe' || text === 'balanced' || text === 'extreme')
+        return text;
+    return 'extreme';
+}
 function normalizePositiveInt(value, fallback) {
     const parsed = Number(value);
     if (!Number.isFinite(parsed) || parsed < 1)

package/dist/core/release/release-gate-affected-selector.js

@@ -10,7 +10,7 @@ export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
     if (input.full) {
         return selectionResult(gates, gates, [], 'full', {}, []);
     }
-    const changedFiles = resolveChangedFiles(root, input.changedSince || 'auto');
+    const changedFiles = input.changedFiles ? [...new Set(input.changedFiles)].sort() : resolveChangedFiles(root, input.changedSince || 'auto');
     const selected = [];
     const reasons = {};
     for (const gate of gates) {
@@ -28,7 +28,9 @@ export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
             reasons[gate.id] = 'always_keep_core_release_safety';
         }
     }
-    const expanded = expandWithDependencies(selected, manifest);
+    const expanded = input.preset === 'affected' || input.preset === 'fast'
+        ? selected
+        : expandWithDependencies(selected, manifest);
     const ordered = manifest.gates.filter((gate) => expanded.some((row) => row.id === gate.id));
     return selectionResult(gates, ordered, changedFiles, 'affected', reasons, gates.filter((gate) => !ordered.some((row) => row.id === gate.id)).map((gate) => gate.id));
 }
@@ -53,19 +55,32 @@ function gateSelectionReason(gate, changedFiles, preset) {
         return 'always_keep_core_release_safety';
     if (!changedFiles.length)
         return preset === 'fast' ? 'fast_no_diff_core_only_skip' : 'no_changed_files';
+    const releaseGate = /^(release:|publish:|prepublish)/.test(gate.id);
     if (changedFiles.some((file) => file === 'package.json' || file === 'package-lock.json')) {
         if (/^(release:|publish:|prepublish|runtime:|typecheck|schema:check)/.test(gate.id))
             return 'package_metadata_changed';
     }
-    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/') || file.startsWith('src/scripts/release-')))
-        return 'release_gate_system_changed';
+    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/'))) {
+        if (releaseGate)
+            return 'release_gate_system_changed';
+    }
+    const matchingReleaseScript = changedFiles.some((file) => releaseScriptGateCandidates(file).includes(gate.id));
+    if (matchingReleaseScript)
+        return 'release_script_changed';
+    if (changedFiles.some((file) => file.startsWith('src/scripts/prepublish-') || file.startsWith('src/scripts/publish-'))) {
+        if (releaseGate && gate.id === 'release:version-truth')
+            return 'publish_or_prepublish_script_changed';
+    }
+    if (changedFiles.some((file) => file.startsWith('src/scripts/scheduler-') || file.startsWith('src/core/scheduler/'))) {
+        return gate.id.startsWith('scheduler:') ? 'scheduler_source_changed' : null;
+    }
     if (changedFiles.some((file) => file.startsWith('src/core/research/')))
         return gate.id.startsWith('research:') ? 'research_source_changed' : null;
     if (changedFiles.some((file) => file.startsWith('src/core/zellij/') || file.startsWith('src/commands/zellij')))
         return gate.id.startsWith('zellij:') || gate.id.startsWith('agent:zellij') || gate.id.startsWith('naruto:zellij') ? 'zellij_source_changed' : null;
     if (changedFiles.some((file) => file.includes('/db') || file.includes('mad-db') || file.includes('mcp')))
         return /db|mcp|mad-db|mad-sks/.test(gate.id) ? 'db_mcp_or_mad_db_changed' : null;
-    const inputs = gate.cache?.inputs || [];
+    const inputs = (gate.cache?.inputs || []).filter((pattern) => !isBroadAffectedInput(pattern));
     if (inputs.some((pattern) => changedFiles.some((file) => matchesGlobish(file, pattern))))
         return 'cache_input_changed';
     return null;
@@ -110,4 +125,31 @@ function matchesGlobish(file, pattern) {
         return file.startsWith(normalized.slice(0, -1));
     return false;
 }
+function isBroadAffectedInput(pattern) {
+    const normalized = pattern.replace(/\\/g, '/');
+    return new Set([
+        '**',
+        '**/*',
+        'src/**',
+        'src/**/*',
+        'schemas/**',
+        'schemas/**/*',
+        'package.json',
+        'package-lock.json',
+        'release-gates.v2.json'
+    ]).has(normalized);
+}
+function releaseScriptGateCandidates(file) {
+    const normalized = file.replace(/\\/g, '/');
+    const base = normalized.split('/').pop()?.replace(/\.(ts|js|mjs|cjs)$/, '') || '';
+    if (!base.startsWith('release-'))
+        return [];
+    const rest = base.slice('release-'.length);
+    const withoutCheck = rest.replace(/-check$/, '');
+    return [
+        `release:${rest}`,
+        `release:${withoutCheck}`,
+        `release:${withoutCheck}:check`
+    ];
+}
 //# sourceMappingURL=release-gate-affected-selector.js.map

package/dist/core/release/release-gate-dag.js

@@ -26,6 +26,10 @@ export async function runReleaseGateDag(input) {
         ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', preset })
         : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
     const selected = affected.gates;
+    const selectedIds = new Set(selected.map((gate) => gate.id));
+    const affectedExternalSatisfiedDeps = affected.selection.mode === 'affected'
+        ? new Set(selected.flatMap((gate) => gate.deps || []).filter((dep) => !selectedIds.has(dep)))
+        : new Set();
     const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
     const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
     fs.mkdirSync(reportDir, { recursive: true });
@@ -88,7 +92,7 @@ export async function runReleaseGateDag(input) {
         writeReleaseGateJson(path.join(reportDir, 'explain.json'), { schema: RELEASE_GATE_NODE_SCHEMA, preset, budget, gates: selected.map((gate) => ({ id: gate.id, deps: gate.deps, resource: gate.resource, command: gate.command })) });
     }
     while (pending.size || running.size) {
-        const ready = findReadyReleaseGateNodes({ pending, completed, failed });
+        const ready = findReadyReleaseGateNodes({ pending, completed, failed, satisfiedDeps: affectedExternalSatisfiedDeps });
         const launchable = pickReadyLaunchableReleaseGates({ ready, running: [...running.values()].map((row) => row.gate) });
         let progressed = false;
         for (const gate of launchable) {

package/dist/core/release/release-gate-scheduler.js

@@ -1,6 +1,7 @@
 import { defaultReleaseGateBudget, pickLaunchableReleaseGates } from './release-gate-resource-governor.js';
 export function findReadyReleaseGateNodes(input) {
-    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
+    const satisfiedDeps = input.satisfiedDeps || new Set();
+    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep) || satisfiedDeps.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
 }
 export function findReleaseGatesBlockedByFailedDeps(input) {
     return [...input.pending.values()].filter((gate) => gate.deps.some((dep) => input.failed.has(dep)));

package/dist/core/routes.js

@@ -552,12 +552,14 @@ export const ROUTES = [
         route: 'explicit scoped permission-widening modifier',
         description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation, while preserving catastrophic wipe/all-row/project-management, credential-exfiltration, persistent security-weakening, and unrequested fallback safeguards.',
         requiredSkills: ['mad-sks', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
+        dollarAliases: ['$MAD-DB'],
+        appSkillAliases: ['mad-db'],
         lifecycle: ['explicit_invocation', 'auto_sealed_permission_scope', 'scoped_permission_override', 'catastrophic_guard', 'permission_deactivation', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'required',
         reasoningPolicy: 'xhigh',
         stopGate: 'mad-sks-gate.json',
         cliEntrypoint: 'Codex App prompt route only: $MAD-SKS <task>',
-        examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS']
+        examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS', '$MAD-DB enable one-cycle DB break-glass only after explicit ack']
     },
     {
         id: 'GX',

package/dist/core/version.js

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

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

@@ -31,21 +31,41 @@ export function renderZellijSlotPane(input) {
     return frameSlotPane(`LIVE SLOT ${input.slotId}`, rows.slice(0, Math.max(1, maxLines - 2)));
 }
 export async function renderZellijSlotPaneFromArtifacts(input) {
+    const artifactRender = await renderZellijSlotPaneFromArtifactDir(input).catch(() => null);
     if (input.missionId && input.missionId !== 'latest') {
         const telemetry = await tryRenderTelemetrySlotPane({
             artifactRoot: input.artifactRoot || input.artifactDir,
             missionId: input.missionId,
             slotId: input.slotId,
-            generationIndex: input.generationIndex
+            generationIndex: input.generationIndex,
+            artifactRender
         });
         if (telemetry)
             return telemetry;
+        if (artifactRender)
+            return artifactRender;
         return [
             `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
             'waiting for telemetry...',
             `mission ${input.missionId}`
         ].join('\n');
     }
+    if (artifactRender)
+        return artifactRender;
+    const fallbackInput = {
+        slotId: input.slotId,
+        generationIndex: input.generationIndex,
+        status: 'launching',
+        currentTask: 'waiting for worker intake',
+        mode: input.mode || 'compact-slots'
+    };
+    if (input.role !== undefined)
+        fallbackInput.role = input.role;
+    if (input.backend !== undefined)
+        fallbackInput.backend = input.backend;
+    return renderZellijSlotPane(fallbackInput);
+}
+async function renderZellijSlotPaneFromArtifactDir(input) {
     const artifactDir = path.resolve(input.artifactDir);
     const result = await readJson(path.join(artifactDir, 'worker-result.json'));
     const intake = await readJson(path.join(artifactDir, 'worker-intake.json'));
@@ -77,6 +97,8 @@ export async function renderZellijSlotPaneFromArtifacts(input) {
         ...(Array.isArray(intake?.input_files) ? intake.input_files : [])
     ]);
     const now = Date.now();
+    if (!result && !intake && !backendReport && !fastReport && !paneReport && !codexProof && !localProof && !heartbeatMtime && !eventRows.length)
+        return null;
     return renderZellijSlotPane({
         slotId: input.slotId,
         generationIndex: input.generationIndex,
@@ -136,6 +158,20 @@ export async function renderZellijSlotPaneFromArtifacts(input) {
         mode: input.mode || 'compact-slots'
     });
 }
+export async function renderZellijSlotPaneStatusFromArtifacts(input) {
+    const snapshot = input.missionId && input.missionId !== 'latest'
+        ? await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot || input.artifactDir), input.missionId).catch(() => null)
+        : null;
+    const status = telemetryStatus(snapshot);
+    return {
+        schema: 'sks.zellij-slot-pane-status.v1',
+        mission_id: input.missionId || null,
+        slot_id: input.slotId,
+        generation_index: Math.max(1, Math.floor(Number(input.generationIndex) || 1)),
+        telemetry_stale: status.telemetry_stale,
+        telemetry_age_ms: status.telemetry_age_ms
+    };
+}
 export function buildZellijSlotPaneCommand(input) {
     const args = [
         input.cliPath,
@@ -159,9 +195,14 @@ async function tryRenderTelemetrySlotPane(input) {
     const slot = findTelemetrySlot(snapshot, input.slotId, input.generationIndex);
     if (!slot)
         return null;
+    const staleRows = staleTelemetryRows(telemetryStatus(snapshot).telemetry_age_ms);
+    const fallbackRows = artifactFallbackRows(input.artifactRender);
+    const liveRows = staleRows.length || !slot.progress ? fallbackRows : [];
     if (slot.status === 'failed') {
         return [
             `${slot.slot_id} gen-${slot.generation_index} · FAILED`,
+            ...staleRows,
+            ...liveRows,
             `blocker: ${trimInline(slot.blockers[0] || 'worker_failed', 78)}`,
             `artifact: ${trimInline(slot.artifact_paths[slot.artifact_paths.length - 1] || '-', 78)}`
         ].join('\n');
@@ -169,6 +210,8 @@ async function tryRenderTelemetrySlotPane(input) {
     if (slot.status === 'completed' || slot.status === 'drained') {
         return [
             `${slot.slot_id} gen-${slot.generation_index} · done`,
+            ...staleRows,
+            ...liveRows,
             `artifacts ${slot.artifact_paths.length} · ${slot.latest_event_type === 'verification_passed' ? 'verify passed' : 'verify queued'}`,
             'closing in 3s'
         ].join('\n');
@@ -177,12 +220,25 @@ async function tryRenderTelemetrySlotPane(input) {
     const heartbeat = slot.latest_ts ? `${Math.max(0, Math.round((Date.now() - Date.parse(slot.latest_ts)) / 1000))}s` : '?';
     return [
         `${slot.slot_id} gen-${slot.generation_index} · ${trimInline(slot.role || 'worker', 28)}`,
+        ...staleRows,
+        ...liveRows,
         trimInline(backend, 78),
         `${slot.status}: ${trimInline(slot.task_title || 'worker task', 68)}`,
         `${formatTelemetryProgress(slot.progress)} · latest ${slot.latest_event_type} ${heartbeat}`,
         `${slot.latest_event_type === 'patch_candidate' ? 'patch candidate' : 'patch'}: ${slot.latest_event_type === 'patch_candidate' ? 'queued' : trimInline(slot.current_file || '-', 42)}`
     ].join('\n');
 }
+function artifactFallbackRows(text) {
+    if (!text)
+        return [];
+    return String(text)
+        .split(/\r?\n/)
+        .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)
+        .map((line) => `live: ${trimInline(line, 72)}`);
+}
 function findTelemetrySlot(snapshot, slotId, generationIndex) {
     const generation = Math.max(1, Math.floor(Number(generationIndex) || 1));
     return Object.values(snapshot.slots || {}).find((row) => row.slot_id === slotId && Number(row.generation_index) === generation) || null;
@@ -192,6 +248,23 @@ function formatTelemetryProgress(progress) {
         return 'progress ?';
     return `progress ${progress.done}/${progress.total}${progress.label ? ` ${trimInline(progress.label, 24)}` : ''}`;
 }
+function telemetryStatus(snapshot) {
+    const parsed = snapshot?.updated_at ? Date.parse(snapshot.updated_at) : NaN;
+    const telemetryAgeMs = Number.isFinite(parsed) ? Math.max(0, Date.now() - parsed) : Number.MAX_SAFE_INTEGER;
+    return {
+        telemetry_stale: telemetryAgeMs > 3000,
+        telemetry_age_ms: telemetryAgeMs
+    };
+}
+function staleTelemetryRows(ageMs) {
+    if (!Number.isFinite(ageMs))
+        return ['telemetry stale; worker may still be running'];
+    if (ageMs > 10000)
+        return ['telemetry stale; worker may still be running'];
+    if (ageMs > 3000)
+        return [`telemetry stale ${(ageMs / 1000).toFixed(1)}s`];
+    return [];
+}
 async function readJson(file) {
     try {
         return JSON.parse(await fs.promises.readFile(file, 'utf8'));

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

@@ -1,7 +1,12 @@
 import path from 'node:path';
-import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import fsp from 'node:fs/promises';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText } from '../fsx.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';
+const telemetrySnapshotCache = new Map();
+const telemetrySnapshotWriteCounts = new Map();
+const telemetrySnapshotFlushCounts = new Map();
+const telemetrySnapshotLastFlushMs = new Map();
 export function slotTelemetryEventPath(root, missionId) {
     return path.join(inferMissionDir(root, missionId), 'zellij', 'slot-telemetry.events.jsonl');
 }
@@ -16,14 +21,52 @@ export async function appendZellijSlotTelemetry(root, event) {
     const file = slotTelemetryEventPath(root, missionId);
     await ensureDir(path.dirname(file));
     await 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 existing = await readJson(slotTelemetrySnapshotPath(root, missionId), null);
+    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;
     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)
+        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;
+}
+export function applyTelemetryEventToSnapshot(snapshot, event) {
+    const key = slotTelemetryKey(event.slot_id || event.worker_id, event.generation_index);
+    const slots = {
+        ...(snapshot.slots || {}),
+        [key]: mergeSlotTelemetry(snapshot.slots?.[key], event)
+    };
+    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: countSlotTelemetry(slots)
+    };
+}
 export async function rebuildZellijSlotTelemetrySnapshot(root, missionId) {
     const eventsPath = slotTelemetryEventPath(root, missionId);
     const rows = await readTelemetryEvents(eventsPath);
@@ -39,10 +82,11 @@ export async function rebuildZellijSlotTelemetrySnapshot(root, missionId) {
         schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
         mission_id: missionId,
         updated_at: nowIso(),
+        flush_count: 0,
         slots,
         counts: countSlotTelemetry(slots)
     };
-    await writeJsonAtomic(slotTelemetrySnapshotPath(root, missionId), snapshot);
+    await writeTelemetrySnapshotFast(slotTelemetrySnapshotPath(root, missionId), snapshot);
     return snapshot;
 }
 async function readTelemetryEvents(file) {
@@ -167,6 +211,40 @@ 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));
+    const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
+    telemetrySnapshotFlushCounts.set(file, flushCount);
+    telemetrySnapshotLastFlushMs.set(file, Date.now());
+    const next = { ...snapshot, flush_count: flushCount };
+    telemetrySnapshotCache.set(file, next);
+    await fsp.writeFile(file, `${JSON.stringify(next)}\n`, 'utf8');
+}
+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 || 1000);
+    const parsedFlushEvery = Number(process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_EVERY_N || 100);
+    const flushMs = Math.max(250, Number.isFinite(parsedFlushMs) ? parsedFlushMs : 1000);
+    const flushEvery = Math.max(1, Number.isFinite(parsedFlushEvery) ? Math.floor(parsedFlushEvery) : 100);
+    const important = event.event_type === 'task_started'
+        || event.event_type === 'task_progress'
+        || event.event_type === 'artifact_written'
+        || event.event_type === 'patch_candidate'
+        || event.event_type === 'worker_completed'
+        || event.event_type === 'worker_failed'
+        || event.status === 'completed'
+        || event.status === 'failed';
+    const should = next === 1
+        || important
+        || now - last >= flushMs
+        || next % flushEvery === 0;
+    if (should)
+        telemetrySnapshotLastFlushMs.set(file, now);
+    return should;
+}
 function inferMissionDir(root, missionId) {
     const resolved = path.resolve(root);
     if (path.basename(resolved) === 'agents' && path.basename(path.dirname(resolved)) === missionId)

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

@@ -1,16 +1,26 @@
 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';
+}
+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 (fromEnv === 'dashboard-plus-slots')
         return 'dashboard-plus-slots';
+    if (args.includes('--zellij-compact-slots'))
+        return 'compact-slots';
     if (args.includes('--zellij-dashboard'))
         return 'dashboard-plus-slots';
     if (args.includes('--zellij-full-debug'))
         return 'full-debug';
-    return 'compact-slots';
+    return null;
 }
 export function zellijUiModeCreatesDashboard(mode) {
-    return mode !== 'compact-slots';
+    return mode === 'dashboard-plus-slots';
 }
 //# sourceMappingURL=zellij-ui-mode.js.map

package/dist/scripts/prepublish-release-check-or-fast.js

@@ -4,7 +4,7 @@
 //
 // Fast path: accept a current release-check stamp.
 // Repair path: if the stamp is missing/stale, run the authoritative full
-// `release:check` once, then require the fast check to pass.
+// `release:check:full` once, then require the fast check to pass.
 //
 // This keeps direct `npm publish` usable without weakening the publish gate:
 // stale stamp repair is the full release gate, not a synthetic stamp write.
@@ -37,7 +37,7 @@ function runReleaseCheck() {
             stdio: 'inherit'
         });
     }
-    return spawnSync(npmCmd, ['run', 'release:check'], {
+    return spawnSync(npmCmd, ['run', 'release:check:full'], {
         cwd: process.cwd(),
         encoding: 'utf8',
         env: process.env,
@@ -82,7 +82,7 @@ function main() {
         console.error('Prepublish release-check auto-repair disabled by SKS_PREPUBLISH_RUN_RELEASE_CHECK_ON_STALE=0.');
         process.exit(first.status || 1);
     }
-    console.error('Prepublish release stamp is stale or missing; running full `npm run release:check` before publish.');
+    console.error('Prepublish release stamp is stale or missing; running full `npm run release:check:full` before publish.');
     const releaseCheck = runReleaseCheck();
     if (releaseCheck.status !== 0)
         process.exit(releaseCheck.status || 1);