sneakoscope 4.8.6 → 4.8.7

package/dist/commands/zellij-monitor-pane.js

@@ -0,0 +1,25 @@
+import { readZellijSlotTelemetrySnapshot } from '../core/zellij/zellij-slot-telemetry.js';
+import { renderZellijMonitor } from '../core/zellij/zellij-monitor-renderer.js';
+import { projectRoot } from '../core/fsx.js';
+export async function run(_cmd = 'zellij-monitor-pane', args = []) {
+    const mission = readOption(args, '--mission', 'latest') || 'latest';
+    const root = await projectRoot();
+    const intervalMs = Math.max(500, Number(readOption(args, '--interval-ms', String(process.env.SKS_ZELLIJ_REFRESH_MS || '1000')) || 1000));
+    const once = !flag(args, '--watch');
+    for (;;) {
+        const snapshot = await readZellijSlotTelemetrySnapshot(root, mission).catch(() => null);
+        const text = renderZellijMonitor({ snapshot, missionId: mission, root });
+        process.stdout.write(`\x1b[H${text}\n\x1b[0J`);
+        if (once)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
+function readOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
+}
+function flag(args, name) {
+    return args.includes(name);
+}
+//# sourceMappingURL=zellij-monitor-pane.js.map

package/dist/commands/zellij-slot-pane.js

@@ -7,6 +7,14 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
     const generationIndex = Number(readOption(args, '--generation', '1') || 1);
     const backend = readOption(args, '--backend', null);
     const role = readOption(args, '--role', null);
+    const envDefaults = {
+        provider: process.env.SKS_SLOT_PROVIDER || null,
+        model: process.env.SKS_SLOT_MODEL || null,
+        serviceTier: process.env.SKS_SLOT_TIER || null,
+        reasoningEffort: process.env.SKS_SLOT_REASONING || null,
+        currentTask: process.env.SKS_SLOT_TASK || null,
+        role: process.env.SKS_SLOT_ROLE || role
+    };
     const mode = readOption(args, '--mode', 'compact-slots');
     const watch = hasFlag(args, '--watch');
     const json = hasFlag(args, '--json');
@@ -16,8 +24,32 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
         console.log(JSON.stringify(status, null, 2));
         return;
     }
+    let staleTicks = 0;
     for (;;) {
-        const text = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
+        let text = '';
+        let heartbeatAgeMs = null;
+        try {
+            text = await renderZellijSlotPaneFromArtifacts({
+                artifactDir,
+                artifactRoot,
+                missionId,
+                slotId,
+                generationIndex,
+                backend,
+                role: envDefaults.role,
+                provider: envDefaults.provider,
+                model: envDefaults.model,
+                serviceTier: envDefaults.serviceTier,
+                reasoningEffort: envDefaults.reasoningEffort,
+                currentTask: envDefaults.currentTask,
+                mode
+            });
+            const status = await renderZellijSlotPaneStatusFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex }).catch(() => null);
+            heartbeatAgeMs = Number.isFinite(Number(status?.telemetry_age_ms)) ? Number(status?.telemetry_age_ms) : null;
+        }
+        catch (err) {
+            text = `render error: ${err?.message || String(err)}`;
+        }
         process.stdout.write(redrawFrame(text));
         if (!watch)
             break;
@@ -27,10 +59,15 @@ export async function run(_command = 'zellij-slot-pane', args = []) {
         const shouldExit = await resolveZellijSlotPaneExit({ artifactDir, artifactRoot, missionId, slotId, generationIndex }).catch(() => false);
         if (shouldExit) {
             await new Promise((resolve) => setTimeout(resolve, 5000));
-            const finalText = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role, mode });
+            const finalText = await renderZellijSlotPaneFromArtifacts({ artifactDir, artifactRoot, missionId, slotId, generationIndex, backend, role: envDefaults.role, provider: envDefaults.provider, model: envDefaults.model, serviceTier: envDefaults.serviceTier, reasoningEffort: envDefaults.reasoningEffort, currentTask: envDefaults.currentTask, mode });
             process.stdout.write(redrawFrame(finalText));
             return;
         }
+        staleTicks = heartbeatAgeMs != null && heartbeatAgeMs > 5 * 60 * 1000 ? staleTicks + 1 : 0;
+        if (staleTicks >= 5) {
+            process.stdout.write(redrawFrame(`${text}\n⏱ worker heartbeat lost >5m - pane closing (sks pipeline status 로 확인)`));
+            return;
+        }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }

package/dist/commands/zellij-viewport-pane.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import { flag, readOption } from '../cli/args.js';
+import { projectRoot, readJson } from '../core/fsx.js';
+import { readZellijSlotTelemetrySnapshot } from '../core/zellij/zellij-slot-telemetry.js';
+import { bindViewports } from '../core/zellij/zellij-viewport-binder.js';
+import { renderZellijSlotPaneFromArtifacts } from '../core/zellij/zellij-slot-pane-renderer.js';
+import { ANSI_CODES, paint, resolveZellijTheme } from '../core/zellij/zellij-theme.js';
+let previousBindings = [];
+export async function run(_cmd = 'zellij-viewport-pane', args = []) {
+    const mission = String(readOption(args, '--mission', 'latest') || 'latest');
+    const index = Math.max(1, Number(readOption(args, '--index', '1')) || 1);
+    const of = Math.max(index, Number(readOption(args, '--of', '4')) || 4);
+    const intervalMs = Math.max(500, Number(process.env.SKS_ZELLIJ_REFRESH_MS || 1000));
+    const root = await projectRoot();
+    previousBindings = Array.from({ length: of }, () => null);
+    const once = !flag(args, '--watch');
+    for (;;) {
+        const frame = await renderViewportFrame(root, mission, index, of).catch((err) => `viewport render error: ${err?.message || String(err)}`);
+        process.stdout.write(`\x1b[H${frame}\n\x1b[0J`);
+        if (once)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
+async function renderViewportFrame(root, mission, index, of) {
+    const theme = resolveZellijTheme();
+    const snapshot = await readZellijSlotTelemetrySnapshot(root, mission).catch(() => null);
+    const missionId = snapshot?.mission_id || mission;
+    const pins = await readJson(pinsPath(root, missionId), { pins: [] });
+    const bindings = bindViewports({
+        snapshot,
+        pins: pins.pins || [],
+        previous: previousBindings,
+        viewportCount: of
+    });
+    previousBindings = bindings.map((binding) => binding.slotKey);
+    const mine = bindings[index - 1] || { slotKey: null, reason: 'idle' };
+    const badge = mine.reason === 'pinned' ? 'pinned' : mine.reason === 'kept' ? 'auto' : mine.reason;
+    const header = paint(theme, ANSI_CODES.dim, `viewport ${index}/${of} | ${mine.slotKey ?? '-'} (${badge})`);
+    if (!mine.slotKey)
+        return `${header}\n${paint(theme, ANSI_CODES.dim, `idle - no active worker. Pin: sks zellij pin <slot> --viewport ${index}`)}`;
+    const [slotId, rawGen] = mine.slotKey.split(':g');
+    const generationIndex = Math.max(1, Number(rawGen || 1) || 1);
+    const detail = await renderZellijSlotPaneFromArtifacts({
+        artifactRoot: root,
+        missionId,
+        artifactDir: path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'sessions', slotId || mine.slotKey, `gen-${generationIndex}`, 'worker'),
+        slotId: slotId || mine.slotKey,
+        generationIndex
+    });
+    return `${header}\n${detail}`;
+}
+function pinsPath(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId, 'zellij', 'viewport-pins.json');
+}
+//# sourceMappingURL=zellij-viewport-pane.js.map

package/dist/commands/zellij.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs';
-import { projectRoot, readJson } from '../core/fsx.js';
+import { nowIso, projectRoot, readJson, writeJsonAtomic } from '../core/fsx.js';
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
@@ -8,6 +8,7 @@ import { checkZellijUpdateNotice, upgradeZellijToLatest } from '../core/zellij/z
 import { runZellij } from '../core/zellij/zellij-command.js';
 import { appendZellijLaneCommand, normalizeZellijSlot } from '../core/zellij/zellij-lane-runtime.js';
 import { buildZellijDashboardSnapshot, renderZellijDashboardText } from '../core/zellij/zellij-dashboard-renderer.js';
+import { readZellijSlotTelemetrySnapshot } from '../core/zellij/zellij-slot-telemetry.js';
 export const ZELLIJ_COMMAND_SCHEMA = 'sks.zellij-command.v1';
 export const ZELLIJ_REPAIR_SCHEMA = 'sks.zellij-repair.v1';
 function installHint() {
@@ -37,6 +38,8 @@ export async function run(_command = 'zellij', args = []) {
         return zellijDashboard(root, args, json);
     if (sub === 'close-drained')
         return zellijCloseDrained(root, args, json);
+    if (sub === 'pin' || sub === 'unpin')
+        return zellijViewportPin(root, sub, args, json);
     return zellijStatus(root, args, json);
 }
 async function zellijStatus(root, args, json) {
@@ -230,6 +233,41 @@ async function zellijCloseDrained(root, args, json) {
     if (!out.ok)
         process.exitCode = 1;
 }
+async function zellijViewportPin(root, action, args, json) {
+    const missionId = resolveMissionId(root, readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest');
+    const slotArg = positionalAfter(args, action) || readOption(args, '--slot', '');
+    const viewport = Math.max(1, Number(readOption(args, '--viewport', '1')) || 1);
+    const file = path.join(root, '.sneakoscope', 'missions', missionId, 'zellij', 'viewport-pins.json');
+    const cur = await readJson(file, { pins: [] });
+    const slotKey = slotArg ? await resolveLatestGenKey(root, missionId, slotArg) : '';
+    const pins = (cur.pins || []).filter((pin) => pin.viewport !== viewport && (!slotKey || pin.slot_key !== slotKey));
+    const blockers = slotArg ? [] : ['slot_required'];
+    if (action === 'pin' && slotKey && blockers.length === 0)
+        pins.push({ viewport, slot_key: slotKey });
+    await writeJsonAtomic(file, {
+        schema: 'sks.zellij-viewport-pins.v1',
+        updated_at: nowIso(),
+        pins
+    });
+    const out = {
+        schema: 'sks.zellij-viewport-pin-command.v1',
+        ok: blockers.length === 0,
+        action,
+        mission_id: missionId,
+        viewport,
+        slot_key: slotKey || null,
+        pins,
+        blockers
+    };
+    if (json)
+        printJson(out);
+    else if (out.ok)
+        console.log(action === 'pin' ? `pinned ${slotKey} -> viewport ${viewport}` : `unpinned ${slotKey}`);
+    else
+        console.log('Usage: sks zellij pin <slot> [--viewport N] [--mission M]');
+    if (!out.ok)
+        process.exitCode = 1;
+}
 async function zellijDispatch(root, args, json) {
     const missionId = readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest';
     const slotId = normalizeZellijSlot(readOption(args, '--slot', 'slot-001'));
@@ -320,7 +358,7 @@ function printHelp(json) {
         schema: ZELLIJ_COMMAND_SCHEMA,
         subcommand: 'help',
         ok: true,
-        usage: 'sks zellij status|update|repair|dispatch|send|focus-worker|worker-logs|dashboard|close-drained [--json]',
+        usage: 'sks zellij status|update|repair|dispatch|send|focus-worker|worker-logs|dashboard|pin|unpin|close-drained [--json]',
         subcommands: {
             status: 'Report Zellij runtime capability and interactive-route readiness.',
             update: 'Check the latest stable Zellij release; apply the upgrade with --yes (Homebrew).',
@@ -330,6 +368,8 @@ function printHelp(json) {
             'focus-worker': 'Focus a visible right-column worker pane by slot.',
             'worker-logs': 'Print stdout/stderr log paths for worker slots.',
             dashboard: 'Render the latest dashboard snapshot; --watch prints watch metadata.',
+            pin: 'Pin a dynamic worker slot to a viewport.',
+            unpin: 'Remove a worker slot pin from a viewport.',
             'close-drained': 'Close drained right-column panes.',
             capability: 'Alias for status.'
         }
@@ -345,6 +385,8 @@ function printHelp(json) {
         console.log('  sks zellij focus-worker slot-001 [--mission M] [--json]');
         console.log('  sks zellij worker-logs [slot-001] [--mission M] [--json]');
         console.log('  sks zellij dashboard [--mission M] [--watch] [--json]');
+        console.log('  sks zellij pin slot-001 [--viewport 2] [--mission M] [--json]');
+        console.log('  sks zellij unpin slot-001 [--viewport 2] [--mission M] [--json]');
         console.log('  sks zellij close-drained [--mission M] [--json]');
     }
 }
@@ -380,4 +422,15 @@ function resolveMissionId(root, requested) {
         return 'latest';
     }
 }
+async function resolveLatestGenKey(root, missionId, rawSlot) {
+    const raw = String(rawSlot || '').trim();
+    if (raw.includes(':g'))
+        return raw;
+    const slotId = normalizeZellijSlot(raw);
+    const snapshot = await readZellijSlotTelemetrySnapshot(root, missionId).catch(() => null);
+    const candidates = Object.entries(snapshot?.slots || {})
+        .filter(([, row]) => normalizeZellijSlot(row.slot_id) === slotId)
+        .sort(([, a], [, b]) => Number(b.generation_index || 1) - Number(a.generation_index || 1));
+    return candidates[0]?.[0] || `${slotId}:g1`;
+}
 //# sourceMappingURL=zellij.js.map