sneakoscope 2.0.7 → 2.0.9

package/dist/core/zellij/zellij-dashboard-pane.js

@@ -0,0 +1,71 @@
+import path from 'node:path';
+import { ensureDir, nowIso, writeJsonAtomic } from '../fsx.js';
+import { runZellij } from './zellij-command.js';
+import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
+import { buildZellijDashboardSnapshot } from './zellij-dashboard-renderer.js';
+export const ZELLIJ_DASHBOARD_PANE_SCHEMA = 'sks.zellij-dashboard-pane.v1';
+export async function openZellijDashboardPane(input) {
+    const root = path.resolve(input.root);
+    const cwd = input.cwd || root;
+    const paneTitle = `dashboard · ${input.missionId}`;
+    const dashboardDir = path.join(root, '.sneakoscope', 'missions', input.missionId);
+    await ensureDir(dashboardDir);
+    const snapshot = buildZellijDashboardSnapshot({ ...(input.snapshot || {}), mission_id: input.missionId });
+    const snapshotPath = path.join(dashboardDir, 'zellij-dashboard-snapshot.json');
+    await writeJsonAtomic(snapshotPath, snapshot);
+    const watchScript = path.join(root, 'dist', 'scripts', 'zellij-dashboard-watch.js');
+    const command = `${shellQuote(process.execPath)} ${shellQuote(watchScript)} --snapshot ${shellQuote(snapshotPath)} --interval-ms 1000`;
+    const createSession = await runZellij(['attach', '--create-background', input.sessionName], { cwd, timeoutMs: 5000, optional: true });
+    const launch = await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneTitle, '--', 'sh', '-lc', command], {
+        cwd,
+        timeoutMs: 5000,
+        optional: false
+    });
+    const stdoutPaneId = launch.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
+    const listed = await runZellij(['--session', input.sessionName, 'action', 'list-panes', '--json', '--all'], { cwd, timeoutMs: 5000, optional: true });
+    const rows = parseRows(listed.stdout_tail);
+    const pane = stdoutPaneId ? null : rows.find((row) => String(row.title || row.name || '').includes(paneTitle));
+    const paneId = stdoutPaneId || pane?.pane_id || pane?.paneId || pane?.id || null;
+    const dump = await runZellij(['--session', input.sessionName, 'action', 'dump-screen'], { cwd, timeoutMs: 5000, optional: true });
+    const source = stdoutPaneId ? 'zellij_dashboard_new_pane_stdout' : paneId ? 'zellij_dashboard_list_panes' : 'zellij_dashboard_missing';
+    const blockers = [
+        ...(createSession.ok || /Session already exists/i.test(createSession.stderr_tail || '') ? [] : createSession.blockers.map((blocker) => `zellij_dashboard_session_${blocker}`)),
+        ...(launch.ok ? [] : launch.blockers.map((blocker) => `zellij_dashboard_pane_${blocker}`)),
+        ...(paneId ? [] : ['zellij_dashboard_pane_id_missing'])
+    ];
+    const record = {
+        schema: ZELLIJ_DASHBOARD_PANE_SCHEMA,
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        mission_id: input.missionId,
+        session_name: input.sessionName,
+        pane_title: paneTitle,
+        pane_id: paneId == null ? null : String(paneId),
+        pane_id_source: source,
+        pane_kind: 'dashboard',
+        worker_pane: false,
+        command,
+        launch,
+        list_panes: listed,
+        dump_screen: dump,
+        snapshot,
+        blockers
+    };
+    await writeJsonAtomic(path.join(dashboardDir, 'zellij-dashboard-pane.json'), record);
+    return record;
+}
+function parseRows(text) {
+    if (!String(text || '').trim())
+        return [];
+    try {
+        const parsed = JSON.parse(String(text));
+        return Array.isArray(parsed) ? parsed : Array.isArray(parsed?.panes) ? parsed.panes : [];
+    }
+    catch {
+        return [];
+    }
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+//# sourceMappingURL=zellij-dashboard-pane.js.map

package/dist/core/zellij/zellij-dashboard-renderer.js

@@ -0,0 +1,58 @@
+import { nowIso } from '../fsx.js';
+export const ZELLIJ_DASHBOARD_RENDER_SCHEMA = 'sks.zellij-dashboard-render.v1';
+export function buildZellijDashboardSnapshot(input) {
+    return {
+        schema: ZELLIJ_DASHBOARD_RENDER_SCHEMA,
+        generated_at: nowIso(),
+        mission_id: input.mission_id,
+        mode: input.mode || 'naruto',
+        route: input.route || input.mode || '$Naruto',
+        provider: input.provider || 'unknown',
+        service_tier: input.service_tier || 'fast',
+        backpressure: input.backpressure || 'normal',
+        backend_counts: input.backend_counts || { 'codex-sdk': 1 },
+        placement_counts: input.placement_counts || { 'zellij-pane': 1 },
+        active_workers: Number(input.active_workers || 0),
+        visible_panes: Number(input.visible_panes || 0),
+        headless_workers: Number(input.headless_workers || 0),
+        queue_depth: Number(input.queue_depth || 0),
+        worktrees: input.worktrees || { active: 0, completed: 0, retained: 0 },
+        local_llm: input.local_llm || { tps: 0, queue: 0 },
+        gpt_final_status: input.gpt_final_status || 'not_started',
+        gate_progress: input.gate_progress || 'not_release',
+        patch_verify: input.patch_verify || {
+            patches: 0,
+            gpt_approved: 0,
+            conflicts: 0,
+            verification_running: 0,
+            verification_passed: 0,
+            verification_failed: 0
+        },
+        workers: input.workers || [],
+        latest_blockers: input.latest_blockers || []
+    };
+}
+export function renderZellijDashboardText(snapshot) {
+    const backendCounts = Object.entries(snapshot.backend_counts).map(([key, value]) => `${key}=${value}`).join(' ');
+    const placementCounts = Object.entries(snapshot.placement_counts).map(([key, value]) => `${key}=${value}`).join(' ');
+    return [
+        'SKS Dashboard',
+        `Mission: ${snapshot.mission_id}`,
+        `Route / mode: ${snapshot.route} / ${snapshot.mode} / ${snapshot.service_tier}`,
+        `Provider: ${snapshot.provider}`,
+        `Backend counts: ${backendCounts || 'none'}`,
+        `Placement counts: ${placementCounts || 'none'}`,
+        `Active / visible / headless / queued: ${snapshot.active_workers}/${snapshot.visible_panes}/${snapshot.headless_workers}/${snapshot.queue_depth}`,
+        `Backpressure: ${snapshot.backpressure}`,
+        `Worktrees active/completed/retained: ${snapshot.worktrees.active}/${snapshot.worktrees.completed}/${snapshot.worktrees.retained}`,
+        `Local LLM TPS / queue: ${snapshot.local_llm.tps}/${snapshot.local_llm.queue}`,
+        `GPT final status: ${snapshot.gpt_final_status}`,
+        `Gate progress: ${snapshot.gate_progress}`,
+        `Patch / verify: patches ${snapshot.patch_verify.patches} · approved ${snapshot.patch_verify.gpt_approved} · conflicts ${snapshot.patch_verify.conflicts} · verify ${snapshot.patch_verify.verification_running}/${snapshot.patch_verify.verification_passed}/${snapshot.patch_verify.verification_failed}`,
+        'Workers:',
+        ...(snapshot.workers.length ? snapshot.workers.slice(0, 12).map((worker) => `${worker.slot_id} gen-${worker.generation_index} ${worker.role} ${worker.backend}/${worker.provider}/${worker.service_tier} WT:${worker.worktree_id || '-'} ${worker.status} ${worker.current_file || ''} ${worker.latest_heartbeat || ''}`) : ['none']),
+        `Latest blockers: ${snapshot.latest_blockers.length ? snapshot.latest_blockers.join(', ') : 'none'}`,
+        'Controls: q detach | /stop selected | /focus slot | /logs'
+    ].join('\n');
+}
+//# sourceMappingURL=zellij-dashboard-renderer.js.map

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

@@ -19,7 +19,7 @@ export async function launchZellijLayout(opts = {}) {
         ledgerRoot,
         cwd: opts.cwd || root,
         kind: opts.kind || 'agent',
-        slotCount: opts.slotCount || 1,
+        slotCount: opts.slotCount ?? 1,
         title: `SKS ${opts.kind || 'agent'} ${missionId}`,
         codexArgs: opts.codexArgs || [],
         launchEnv: opts.launchEnv || {}
@@ -124,7 +124,7 @@ export async function launchMadZellijUi(args = [], opts = {}) {
     const launchOpts = {
         ...opts,
         kind: 'mad',
-        slotCount: opts.slotCount || 1
+        slotCount: opts.slotCount ?? 1
     };
     const resolvedSession = session || opts.session;
     if (resolvedSession)
@@ -135,7 +135,7 @@ export async function launchTeamZellijView(opts = {}) {
     return launchZellijLayout({
         ...opts,
         kind: 'team',
-        slotCount: opts.slotCount || 5
+        slotCount: opts.slotCount ?? 5
     });
 }
 /**

package/dist/core/zellij/zellij-layout-builder.js

@@ -3,7 +3,7 @@ import { ensureDir, nowIso, packageRoot, writeTextAtomic } from '../fsx.js';
 import { writeZellijLaneRuntimeManifest } from './zellij-lane-runtime.js';
 export const ZELLIJ_LAYOUT_SCHEMA = 'sks.zellij-layout.v1';
 export function buildZellijLayoutKdl(input) {
-    const slotCount = Math.max(1, Number(input.slotCount || 1));
+    const slotCount = Math.max(0, Number(input.slotCount ?? 1));
     const sessionName = input.sessionName || `sks-${input.missionId}`;
     const cwd = path.resolve(input.cwd || process.cwd());
     const ledgerRoot = path.resolve(input.ledgerRoot);

package/dist/core/zellij/zellij-right-column-layout-proof.js

@@ -0,0 +1,42 @@
+export function evaluateZellijRightColumnGeometry(input) {
+    const tolerance = Math.max(0, Number(input.tolerance ?? 2));
+    const main = input.panes.find((pane) => pane.role === 'main') || null;
+    const dashboard = input.panes.find((pane) => pane.role === 'dashboard') || null;
+    const workers = input.panes.filter((pane) => pane.role === 'worker');
+    const workerGeometries = workers.map((pane) => pane.geometry).filter(Boolean);
+    const baseX = workerGeometries[0]?.x;
+    const sameRightX = baseX == null ? null : workerGeometries.every((geometry) => geometry.x != null && Math.abs(geometry.x - baseX) <= tolerance);
+    const rightOfMain = !main?.geometry ? null : workerGeometries.every((geometry) => {
+        if (geometry.x == null || main.geometry?.x == null || main.geometry?.width == null)
+            return false;
+        return geometry.x >= main.geometry.x + main.geometry.width - tolerance;
+    });
+    const increasingY = workerGeometries.every((geometry, index) => {
+        if (index === 0)
+            return true;
+        const previous = workerGeometries[index - 1];
+        return geometry.y != null && previous?.y != null && geometry.y > previous.y;
+    });
+    const visibleCapOk = workers.length <= Math.max(0, Math.floor(Number(input.visiblePaneCap || 0)));
+    const blockers = [
+        ...(!main ? ['right_column_main_pane_missing'] : []),
+        ...(!dashboard ? ['right_column_dashboard_missing'] : []),
+        ...(sameRightX === false ? ['right_column_worker_x_range_mismatch'] : []),
+        ...(rightOfMain === false ? ['right_column_workers_not_right_of_main'] : []),
+        ...(increasingY === false ? ['right_column_workers_not_stacked_down'] : []),
+        ...(visibleCapOk ? [] : ['right_column_visible_cap_exceeded'])
+    ];
+    return {
+        schema: 'sks.zellij-right-column-layout-proof.v1',
+        ok: blockers.length === 0,
+        main_pane_id: main?.pane_id || null,
+        dashboard_pane_id: dashboard?.pane_id || null,
+        worker_pane_ids: workers.map((pane) => pane.pane_id),
+        same_right_x: sameRightX,
+        right_of_main: rightOfMain,
+        increasing_y: increasingY,
+        visible_cap_ok: visibleCapOk,
+        blockers
+    };
+}
+//# sourceMappingURL=zellij-right-column-layout-proof.js.map

package/dist/core/zellij/zellij-right-column-manager.js

@@ -0,0 +1,245 @@
+import path from 'node:path';
+import { appendJsonl, ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { openZellijDashboardPane } from './zellij-dashboard-pane.js';
+export const ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA = 'sks.zellij-right-column-state.v1';
+export async function ensureRightColumn(input) {
+    const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
+    await ensureDir(paths.missionDir);
+    const existing = await readRightColumnState(input.root, input.missionId, input.projectRoot);
+    if (existing?.status === 'active' && existing.dashboard_pane_id) {
+        return writeRightColumnState(paths.statePath, { ...existing, updated_at: nowIso() });
+    }
+    const creating = await writeRightColumnState(paths.statePath, {
+        schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
+        generated_at: nowIso(),
+        updated_at: nowIso(),
+        mission_id: input.missionId,
+        session_name: input.sessionName,
+        status: 'creating',
+        dashboard_pane_id: null,
+        right_anchor_pane_id: null,
+        visible_worker_panes: [],
+        headless_workers: [],
+        blockers: []
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'right_column_creating', creating, {});
+    const dashboard = await openZellijDashboardPane({
+        root: paths.projectRoot,
+        missionId: input.missionId,
+        sessionName: input.sessionName,
+        cwd: input.cwd || paths.projectRoot,
+        snapshot: {
+            ...input.dashboardSnapshot,
+            mission_id: input.missionId,
+            gate_progress: input.dashboardSnapshot.gate_progress || 'right-column:first-worker'
+        }
+    }).catch((err) => ({
+        ok: false,
+        pane_id: null,
+        blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
+    }));
+    const blockers = Array.isArray(dashboard.blockers) ? dashboard.blockers : [];
+    const active = await writeRightColumnState(paths.statePath, {
+        ...creating,
+        updated_at: nowIso(),
+        status: blockers.length ? 'creating' : 'active',
+        dashboard_pane_id: dashboard.pane_id ? String(dashboard.pane_id) : null,
+        right_anchor_pane_id: dashboard.pane_id ? String(dashboard.pane_id) : null,
+        blockers
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'right_column_created', active, { ok: active.status === 'active' });
+    await appendRightColumnEvent(paths.eventsPath, 'dashboard_pane_created', active, { pane_id: active.dashboard_pane_id, blockers });
+    return active;
+}
+export async function prepareWorkerInRightColumn(input) {
+    const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
+    const state = await ensureRightColumn({
+        root: input.root,
+        ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+        missionId: input.missionId,
+        sessionName: input.sessionName,
+        cwd: input.cwd,
+        dashboardSnapshot: input.dashboardSnapshot
+    });
+    const activeVisible = state.visible_worker_panes.filter((pane) => pane.status === 'launching' || pane.status === 'running');
+    const cap = Math.max(1, Math.floor(Number(input.visiblePaneCap || 1)));
+    if (activeVisible.length >= cap) {
+        const next = await recordHeadlessWorkerInRightColumn({
+            root: input.root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: input.missionId,
+            sessionName: input.sessionName,
+            slotId: input.worker.slotId,
+            generationIndex: input.worker.generationIndex,
+            reason: `visible_pane_cap:${cap}`
+        });
+        return { state: next, placement: 'headless', focusPaneId: null, yOrder: null };
+    }
+    const lastVisible = activeVisible[activeVisible.length - 1];
+    const focusPaneId = lastVisible?.pane_id || state.right_anchor_pane_id || state.dashboard_pane_id || null;
+    const yOrder = Math.max(1, ...state.visible_worker_panes.map((pane) => Number(pane.y_order || 0) + 1));
+    const next = await writeRightColumnState(paths.statePath, {
+        ...state,
+        updated_at: nowIso(),
+        right_anchor_pane_id: focusPaneId,
+        visible_worker_panes: [
+            ...state.visible_worker_panes,
+            {
+                pane_id: null,
+                slot_id: input.worker.slotId,
+                generation_index: input.worker.generationIndex,
+                y_order: yOrder,
+                status: 'launching'
+            }
+        ]
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'scheduler_slot_reserved', next, {
+        slot_id: input.worker.slotId,
+        generation_index: input.worker.generationIndex,
+        y_order: yOrder
+    });
+    return { state: next, placement: 'zellij-pane', focusPaneId, yOrder };
+}
+export async function recordWorkerPaneInRightColumn(input) {
+    const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
+    const state = await readRightColumnState(input.root, input.missionId, input.projectRoot);
+    if (!state)
+        return null;
+    const yOrder = Math.max(1, Math.floor(Number(input.yOrder || 0))) || Math.max(1, ...state.visible_worker_panes.map((pane) => pane.y_order + 1));
+    const slotId = input.record.slot_id;
+    const generationIndex = input.record.generation_index;
+    const rows = state.visible_worker_panes.filter((pane) => !(pane.slot_id === slotId && pane.generation_index === generationIndex && pane.pane_id == null));
+    rows.push({
+        pane_id: input.record.pane_id,
+        slot_id: slotId,
+        generation_index: generationIndex,
+        y_order: yOrder,
+        status: input.record.status === 'failed' ? 'failed' : 'running'
+    });
+    const next = await writeRightColumnState(paths.statePath, {
+        ...state,
+        updated_at: nowIso(),
+        right_anchor_pane_id: input.record.pane_id || state.right_anchor_pane_id,
+        visible_worker_panes: rows.sort((a, b) => a.y_order - b.y_order),
+        blockers: [...new Set([...state.blockers, ...(input.record.blockers || [])])]
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'worker_pane_created', next, {
+        slot_id: slotId,
+        generation_index: generationIndex,
+        pane_id: input.record.pane_id,
+        y_order: yOrder,
+        direction_applied: input.record.direction_applied,
+        blockers: input.record.blockers
+    });
+    return next;
+}
+export async function recordHeadlessWorkerInRightColumn(input) {
+    const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
+    const state = await readRightColumnState(input.root, input.missionId, input.projectRoot) || {
+        schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
+        generated_at: nowIso(),
+        updated_at: nowIso(),
+        mission_id: input.missionId,
+        session_name: input.sessionName,
+        status: 'absent',
+        dashboard_pane_id: null,
+        right_anchor_pane_id: null,
+        visible_worker_panes: [],
+        headless_workers: [],
+        blockers: []
+    };
+    const headless = [
+        ...state.headless_workers.filter((row) => !(row.slot_id === input.slotId && row.generation_index === input.generationIndex)),
+        { slot_id: input.slotId, generation_index: input.generationIndex, reason: input.reason }
+    ];
+    const next = await writeRightColumnState(paths.statePath, { ...state, updated_at: nowIso(), headless_workers: headless });
+    await appendRightColumnEvent(paths.eventsPath, 'worker_headless_overflow', next, {
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        reason: input.reason
+    });
+    return next;
+}
+export async function closeWorkerInRightColumn(input) {
+    const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
+    const state = await readRightColumnState(input.root, input.missionId, input.projectRoot);
+    if (!state)
+        return null;
+    const panes = state.visible_worker_panes.map((pane) => {
+        const same = pane.slot_id === input.slotId && pane.generation_index === input.generationIndex;
+        return same ? { ...pane, pane_id: input.paneId || pane.pane_id, status: input.status } : pane;
+    });
+    const visibleStillActive = panes.filter((pane) => pane.status === 'launching' || pane.status === 'running');
+    const next = await writeRightColumnState(paths.statePath, {
+        ...state,
+        updated_at: nowIso(),
+        status: visibleStillActive.length || state.headless_workers.length ? 'active' : 'draining',
+        right_anchor_pane_id: visibleStillActive[visibleStillActive.length - 1]?.pane_id || state.dashboard_pane_id,
+        visible_worker_panes: panes
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'worker_pane_drained', next, {
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        pane_id: input.paneId,
+        status: input.status
+    });
+    return next;
+}
+export async function openWorkerInRightColumn(input) {
+    const prepared = await prepareWorkerInRightColumn({
+        root: input.root,
+        missionId: input.state.mission_id,
+        sessionName: input.state.session_name,
+        cwd: input.worker.cwd || input.root,
+        worker: { slotId: input.worker.slotId, generationIndex: input.worker.generationIndex },
+        visiblePaneCap: input.visiblePaneCap,
+        dashboardSnapshot: { mission_id: input.state.mission_id }
+    });
+    return { state: prepared.state, pane: null, placement: prepared.placement };
+}
+export async function readRightColumnState(root, missionId, projectRoot) {
+    const paths = resolveRightColumnPaths(root, missionId, projectRoot);
+    return readJson(paths.statePath, null);
+}
+export function resolveRightColumnPaths(root, missionId, projectRoot) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedProjectRoot = projectRoot ? path.resolve(projectRoot) : inferProjectRoot(resolvedRoot, missionId);
+    const missionDir = inferMissionDir(resolvedRoot, missionId) || path.join(resolvedProjectRoot, '.sneakoscope', 'missions', missionId);
+    return {
+        projectRoot: resolvedProjectRoot,
+        missionDir,
+        statePath: path.join(missionDir, 'zellij-right-column-state.json'),
+        eventsPath: path.join(missionDir, 'zellij-right-column-events.jsonl')
+    };
+}
+async function writeRightColumnState(file, state) {
+    await writeJsonAtomic(file, state);
+    return state;
+}
+async function appendRightColumnEvent(file, eventType, state, payload) {
+    await appendJsonl(file, {
+        schema: 'sks.zellij-right-column-event.v1',
+        ts: nowIso(),
+        event_type: eventType,
+        mission_id: state.mission_id,
+        session_name: state.session_name,
+        ...payload
+    });
+}
+function inferMissionDir(root, missionId) {
+    if (path.basename(root) === 'agents' && path.basename(path.dirname(root)) === missionId)
+        return path.dirname(root);
+    if (path.basename(root) === missionId && path.basename(path.dirname(root)) === 'missions')
+        return root;
+    return null;
+}
+function inferProjectRoot(root, missionId) {
+    if (path.basename(root) === 'agents' && path.basename(path.dirname(root)) === missionId) {
+        return path.dirname(path.dirname(path.dirname(path.dirname(root))));
+    }
+    if (path.basename(root) === missionId && path.basename(path.dirname(root)) === 'missions') {
+        return path.dirname(path.dirname(path.dirname(root)));
+    }
+    return root;
+}
+//# sourceMappingURL=zellij-right-column-manager.js.map