sneakoscope 2.0.9 → 2.0.11

package/dist/core/naruto/naruto-real-worker-runtime.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { allocateWorkerWorktree } from '../git/git-worktree-manager.js';
+import { cleanupGitWorktree } from '../git/git-worktree-cleanup.js';
+export async function spawnActualNarutoWorker(input) {
+    const workerDir = path.join(input.root, '.sneakoscope', 'missions', input.missionId, 'agents', 'naruto-real-workers', input.item.id);
+    await ensureDir(workerDir);
+    let worktree = null;
+    if (input.worktreePolicy?.mode === 'git-worktree' && input.item.write_allowed === true) {
+        const allocation = await allocateWorkerWorktree({
+            repoRoot: input.worktreePolicy.main_repo_root || input.root,
+            missionId: input.missionId,
+            workerId: input.item.id,
+            slotId: input.item.id.replace(/[^A-Za-z0-9_-]/g, '-'),
+            generationIndex: 1
+        }).catch((err) => ({ ok: false, blockers: [`git_worktree_allocate_exception:${err?.message || String(err)}`] }));
+        await writeJsonAtomic(path.join(workerDir, 'git-worktree-allocation.json'), allocation);
+        if (allocation.ok)
+            worktree = allocation;
+    }
+    const resultPath = path.join(workerDir, 'worker-result.json');
+    const heartbeatPath = path.join(workerDir, 'worker-heartbeat.jsonl');
+    const intakePath = path.join(workerDir, 'worker-intake.json');
+    await writeJsonAtomic(intakePath, {
+        schema: 'sks.naruto-actual-worker-intake.v1',
+        generated_at: nowIso(),
+        mission_id: input.missionId,
+        item: input.item,
+        placement: input.placement,
+        backend: input.backend,
+        result_path: resultPath,
+        heartbeat_path: heartbeatPath,
+        worktree_path: worktree?.worktree_path || null,
+        zellij_session_name: input.zellijSessionName || null,
+        visible_pane_cap: input.visiblePaneCap
+    });
+    const child = spawn(process.execPath, [actualWorkerEntrypoint(), intakePath], {
+        cwd: worktree?.worktree_path || input.root,
+        stdio: ['ignore', 'ignore', 'ignore']
+    });
+    const exit = waitForExit(child, 30000);
+    return {
+        id: input.item.id,
+        item: input.item,
+        placement: input.placement,
+        started_at: Date.now(),
+        pid: child.pid || null,
+        child,
+        worker_artifact_dir: workerDir,
+        result_path: resultPath,
+        heartbeat_path: heartbeatPath,
+        worktree,
+        exit
+    };
+}
+export async function collectActualNarutoWorker(handle) {
+    const exit = await handle.exit;
+    const result = await readJson(handle.result_path, null).catch(() => null);
+    const blockers = [
+        ...(exit.code === 0 ? [] : [`naruto_actual_worker_exit_${exit.code ?? exit.signal ?? 'unknown'}`]),
+        ...(result?.ok === false ? result.blockers || ['naruto_actual_worker_result_not_ok'] : []),
+        ...(result ? [] : ['naruto_actual_worker_result_missing'])
+    ];
+    if (handle.worktree?.worktree_path) {
+        const cleanup = await cleanupGitWorktree({
+            repoRoot: handle.worktree.main_repo_root || handle.worktree.repo_root || handle.worktree.repoRoot || '',
+            worktreePath: handle.worktree.worktree_path,
+            branch: handle.worktree.branch,
+            deleteBranch: true
+        }).catch((err) => ({ ok: false, blockers: [`git_worktree_cleanup_exception:${err?.message || String(err)}`] }));
+        await writeJsonAtomic(path.join(handle.worker_artifact_dir, 'git-worktree-cleanup.json'), cleanup);
+        blockers.push(...(cleanup.blockers || []));
+    }
+    return {
+        id: handle.id,
+        ok: blockers.length === 0,
+        item: handle.item,
+        placement: handle.placement,
+        completed_at: Date.now(),
+        pid: handle.pid,
+        worker_artifact_dir: handle.worker_artifact_dir,
+        blockers
+    };
+}
+function actualWorkerEntrypoint() {
+    return fileURLToPath(new URL('./naruto-real-worker-child.js', import.meta.url));
+}
+function waitForExit(child, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let killTimer = null;
+        const finish = (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolve({ code, signal });
+        };
+        const timer = setTimeout(() => {
+            if (!child.killed)
+                child.kill();
+            killTimer = setTimeout(() => {
+                if (!settled)
+                    child.kill('SIGKILL');
+                finish(null, 'SIGKILL');
+            }, 5000);
+        }, Math.max(1000, timeoutMs));
+        child.on('close', (code, signal) => {
+            finish(code, signal);
+        });
+        child.on('error', () => {
+            finish(1, null);
+        });
+    });
+}
+//# sourceMappingURL=naruto-real-worker-runtime.js.map

package/dist/core/naruto/naruto-rebalance-policy.js

@@ -0,0 +1,36 @@
+import { chooseNarutoTaskOwner } from './naruto-allocation-policy.js';
+export function rebalanceNarutoReadyWork(input) {
+    const completed = new Set((input.completedTaskIds || []).map(String));
+    const reclaimed = new Set((input.reclaimedTaskIds || []).map(String));
+    const idle = input.workers.filter((worker) => worker.alive && ['idle', 'done', 'unknown'].includes(worker.state));
+    if (!idle.length)
+        return [];
+    const ready = input.tasks
+        .filter((task) => (task.status || 'pending') === 'pending' && !task.owner)
+        .filter((task) => task.dependencies.every((dep) => completed.has(dep)))
+        .sort((left, right) => {
+        const reclaimedOrder = Number(!reclaimed.has(left.id)) - Number(!reclaimed.has(right.id));
+        return reclaimedOrder || left.id.localeCompare(right.id);
+    });
+    const decisions = [];
+    const assignments = [...(input.currentAssignments || [])];
+    for (const task of ready) {
+        const decision = chooseNarutoTaskOwner(task, idle, assignments);
+        decisions.push({
+            type: 'assign',
+            task_id: task.id,
+            worker_id: decision.owner,
+            reason: `${reclaimed.has(task.id) ? 'reclaimed ready work' : 'idle worker pickup'}; ${decision.reason}`
+        });
+        assignments.push({
+            task_id: task.id,
+            owner: decision.owner,
+            role: task.required_role,
+            paths: decision.hints.paths,
+            domains: decision.hints.domains,
+            write_paths: decision.hints.writePaths
+        });
+    }
+    return decisions;
+}
+//# sourceMappingURL=naruto-rebalance-policy.js.map

package/dist/core/naruto/naruto-task-hints.js

@@ -0,0 +1,71 @@
+import { normalizeNarutoPath } from './naruto-work-item.js';
+const PATH_PATTERN = /(?:^|[\s("'`])((?:src|scripts|schemas|docs|test|tests|packages|crates|bin)\/[A-Za-z0-9._/-]+)/g;
+const DOMAIN_STOP_WORDS = new Set([
+    'the', 'and', 'for', 'with', 'into', 'from', 'task', 'work', 'worker', 'workers',
+    'implement', 'implementation', 'test', 'tests', 'check', 'gate', 'runtime',
+    'naruto', 'sks', 'src', 'core', 'scripts', 'docs', 'file', 'files'
+]);
+export function extractNarutoTaskHints(task) {
+    const record = task;
+    const writePaths = normalizePaths(readArray(record, 'write_paths', 'writePaths'));
+    const readPaths = normalizePaths([
+        ...readArray(record, 'readonly_paths', 'readPaths'),
+        ...readArray(record, 'target_paths')
+    ]);
+    const paths = normalizePaths([
+        ...readArray(record, 'target_paths'),
+        ...readArray(record, 'readonly_paths'),
+        ...readArray(record, 'write_paths'),
+        ...extractPathsFromText(`${readString(record, 'title')}\n${readString(record, 'description')}\n${readString(record, 'summary')}`)
+    ]);
+    const domains = [...new Set([
+            ...paths.flatMap(pathDomains),
+            ...extractDomainsFromText(`${readString(record, 'kind')} ${readString(record, 'title')} ${readString(record, 'description')}`)
+        ])].sort();
+    return {
+        paths,
+        domains,
+        role: readString(record, 'required_role') || readString(record, 'role') || null,
+        writePaths,
+        readPaths
+    };
+}
+export function pathPrefix(pathValue) {
+    const parts = normalizeNarutoPath(pathValue).split('/').filter(Boolean);
+    if (parts.length <= 1)
+        return parts[0] || '';
+    if (parts[0] === 'src' && parts.length >= 3)
+        return parts.slice(0, 3).join('/');
+    return parts.slice(0, 2).join('/');
+}
+function normalizePaths(paths) {
+    return [...new Set(paths.map((file) => normalizeNarutoPath(String(file || ''))).filter(Boolean))].sort();
+}
+function readArray(record, ...keys) {
+    return keys.flatMap((key) => Array.isArray(record[key]) ? record[key].map(String) : []);
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+function extractPathsFromText(text) {
+    const out = [];
+    for (const match of String(text || '').matchAll(PATH_PATTERN)) {
+        if (match[1])
+            out.push(match[1]);
+    }
+    return out;
+}
+function extractDomainsFromText(text) {
+    return [...new Set(String(text || '').toLowerCase().match(/[a-z][a-z0-9_-]{2,}/g) || [])]
+        .filter((word) => !DOMAIN_STOP_WORDS.has(word))
+        .sort();
+}
+function pathDomains(pathValue) {
+    const normalized = normalizeNarutoPath(pathValue);
+    const parts = normalized.split('/').filter(Boolean);
+    const file = parts[parts.length - 1] || '';
+    const stem = file.replace(/\.[^.]+$/, '');
+    return [...new Set([pathPrefix(normalized), parts[0], parts[1], stem].filter((part) => Boolean(part)))];
+}
+//# sourceMappingURL=naruto-task-hints.js.map

package/dist/core/pipeline/finalize-pipeline-result.js

@@ -7,7 +7,8 @@ export async function finalizePipelineResult(input) {
     const root = path.resolve(input.mutationLedgerRoot || path.join(cwd, '.sneakoscope', 'tmp', 'pipeline-finalize', safeName(input.missionId)));
     const requirement = gptFinalRequiredForPipeline({
         localParticipated: input.localParticipated,
-        candidateResults: input.candidateResults
+        candidateResults: input.candidateResults,
+        candidatePatchEnvelopes: input.candidatePatchEnvelopes
     });
     let arbiter = null;
     let blockers = [];
@@ -36,6 +37,7 @@ export async function finalizePipelineResult(input) {
         route: input.route,
         mission_id: input.missionId,
         local_participated: requirement.local_participated,
+        worktree_participated: requirement.worktree_participated,
         gpt_final_required: requirement.gpt_final_required,
         gpt_final_arbiter: arbiter,
         final_status: blockers.length ? 'blocked' : 'accepted',

package/dist/core/pipeline/gpt-final-required.js

@@ -2,11 +2,31 @@ import { localCollaborationParticipated } from '../local-llm/local-collaboration
 export function gptFinalRequiredForPipeline(input) {
     const localParticipated = input.localParticipated === true
         || localCollaborationParticipated(Array.isArray(input.candidateResults) ? input.candidateResults : []);
+    const worktreeParticipated = worktreeCandidateParticipated(input.candidateResults)
+        || worktreeCandidateParticipated(input.candidatePatchEnvelopes);
     return {
         schema: 'sks.gpt-final-required.v1',
         local_participated: localParticipated,
-        gpt_final_required: localParticipated,
-        reason: localParticipated ? 'local_llm_outputs_are_drafts' : 'no_local_participation'
+        worktree_participated: worktreeParticipated,
+        gpt_final_required: localParticipated || worktreeParticipated,
+        reason: localParticipated
+            ? 'local_llm_outputs_are_drafts'
+            : worktreeParticipated
+                ? 'worktree_candidate_outputs_require_gpt_final'
+                : 'no_local_or_worktree_candidate_participation'
     };
 }
+function worktreeCandidateParticipated(values) {
+    return (Array.isArray(values) ? values : []).some((value) => {
+        if (!value || typeof value !== 'object')
+            return false;
+        if (value.source === 'git-worktree-diff')
+            return true;
+        if (value.git_worktree?.worktree_path || value.git_worktree?.checkpoint?.commit_hash)
+            return true;
+        if (value.git_worktree_diff || value.git_worktree_checkpoint)
+            return true;
+        return Array.isArray(value.patch_envelopes) && worktreeCandidateParticipated(value.patch_envelopes);
+    });
+}
 //# sourceMappingURL=gpt-final-required.js.map

package/dist/core/version.js

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

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

@@ -1,13 +1,21 @@
 import path from 'node:path';
 import { appendJsonl, ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { openZellijDashboardPane } from './zellij-dashboard-pane.js';
+import { zellijUiModeCreatesDashboard } from './zellij-ui-mode.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 uiMode = input.uiMode || 'compact-slots';
+    const createDashboard = input.createDashboard ?? zellijUiModeCreatesDashboard(uiMode);
     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() });
+    if (existing?.status === 'active') {
+        return writeRightColumnState(paths.statePath, {
+            ...existing,
+            updated_at: nowIso(),
+            slot_column_anchor_pane_id: existing.slot_column_anchor_pane_id || null,
+            ui_mode: existing.ui_mode || uiMode
+        });
     }
     const creating = await writeRightColumnState(paths.statePath, {
         schema: ZELLIJ_RIGHT_COLUMN_STATE_SCHEMA,
@@ -18,11 +26,31 @@ export async function ensureRightColumn(input) {
         status: 'creating',
         dashboard_pane_id: null,
         right_anchor_pane_id: null,
+        slot_column_anchor_pane_id: null,
+        ui_mode: uiMode,
         visible_worker_panes: [],
         headless_workers: [],
         blockers: []
     });
     await appendRightColumnEvent(paths.eventsPath, 'right_column_creating', creating, {});
+    if (!createDashboard) {
+        const active = await writeRightColumnState(paths.statePath, {
+            ...creating,
+            updated_at: nowIso(),
+            status: 'active',
+            dashboard_pane_id: null,
+            right_anchor_pane_id: null,
+            slot_column_anchor_pane_id: null,
+            ui_mode: uiMode,
+            blockers: []
+        });
+        await appendRightColumnEvent(paths.eventsPath, 'right_column_created', active, {
+            ok: true,
+            dashboard_created: false,
+            ui_mode: uiMode
+        });
+        return active;
+    }
     const dashboard = await openZellijDashboardPane({
         root: paths.projectRoot,
         missionId: input.missionId,
@@ -45,6 +73,8 @@ export async function ensureRightColumn(input) {
         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,
+        slot_column_anchor_pane_id: null,
+        ui_mode: uiMode,
         blockers
     });
     await appendRightColumnEvent(paths.eventsPath, 'right_column_created', active, { ok: active.status === 'active' });
@@ -52,6 +82,9 @@ export async function ensureRightColumn(input) {
     return active;
 }
 export async function prepareWorkerInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => prepareWorkerInRightColumnUnlocked(input));
+}
+async function prepareWorkerInRightColumnUnlocked(input) {
     const paths = resolveRightColumnPaths(input.root, input.missionId, input.projectRoot);
     const state = await ensureRightColumn({
         root: input.root,
@@ -59,12 +92,13 @@ export async function prepareWorkerInRightColumn(input) {
         missionId: input.missionId,
         sessionName: input.sessionName,
         cwd: input.cwd,
-        dashboardSnapshot: input.dashboardSnapshot
+        dashboardSnapshot: input.dashboardSnapshot,
+        uiMode: input.uiMode || 'compact-slots'
     });
     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({
+        const next = await recordHeadlessWorkerInRightColumnUnlocked({
             root: input.root,
             ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
             missionId: input.missionId,
@@ -76,7 +110,7 @@ export async function prepareWorkerInRightColumn(input) {
         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 focusPaneId = lastVisible?.pane_id || state.slot_column_anchor_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,
@@ -129,11 +163,52 @@ export async function recordWorkerPaneInRightColumn(input) {
         pane_id: input.record.pane_id,
         y_order: yOrder,
         direction_applied: input.record.direction_applied,
+        column_creation_direction_requested: input.record.column_creation_direction_requested || null,
+        column_creation_direction_applied: input.record.column_creation_direction_applied || null,
+        worker_direction_requested: input.record.worker_direction_requested,
+        worker_direction_applied: input.record.worker_direction_applied,
+        slot_column_anchor_pane_id: input.record.slot_column_anchor_pane_id || state.slot_column_anchor_pane_id || null,
         blockers: input.record.blockers
     });
     return next;
 }
+export async function recordSlotColumnAnchorInRightColumn(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: 'active',
+        dashboard_pane_id: null,
+        right_anchor_pane_id: null,
+        slot_column_anchor_pane_id: null,
+        ui_mode: 'compact-slots',
+        visible_worker_panes: [],
+        headless_workers: [],
+        blockers: []
+    };
+    const paneId = input.paneId ? String(input.paneId) : null;
+    const next = await writeRightColumnState(paths.statePath, {
+        ...state,
+        updated_at: nowIso(),
+        status: 'active',
+        session_name: input.sessionName || state.session_name,
+        right_anchor_pane_id: paneId || state.right_anchor_pane_id,
+        slot_column_anchor_pane_id: paneId || state.slot_column_anchor_pane_id
+    });
+    await appendRightColumnEvent(paths.eventsPath, 'slot_column_anchor_created', next, {
+        pane_id: paneId,
+        column_creation_direction_requested: 'right',
+        column_creation_direction_applied: paneId ? 'right' : 'unknown'
+    });
+    return next;
+}
 export async function recordHeadlessWorkerInRightColumn(input) {
+    return withRightColumnLock(input.root, input.missionId, async () => recordHeadlessWorkerInRightColumnUnlocked(input));
+}
+async function recordHeadlessWorkerInRightColumnUnlocked(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,
@@ -144,13 +219,15 @@ export async function recordHeadlessWorkerInRightColumn(input) {
         status: 'absent',
         dashboard_pane_id: null,
         right_anchor_pane_id: null,
+        slot_column_anchor_pane_id: null,
+        ui_mode: 'compact-slots',
         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 }
+        { slot_id: input.slotId, generation_index: input.generationIndex, reason: input.reason, status: 'running', closed_at: null }
     ];
     const next = await writeRightColumnState(paths.statePath, { ...state, updated_at: nowIso(), headless_workers: headless });
     await appendRightColumnEvent(paths.eventsPath, 'worker_headless_overflow', next, {
@@ -169,13 +246,19 @@ export async function closeWorkerInRightColumn(input) {
         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 headless = state.headless_workers.map((row) => {
+        const same = row.slot_id === input.slotId && row.generation_index === input.generationIndex;
+        return same ? { ...row, status: input.status === 'draining' ? 'closed' : input.status, closed_at: nowIso() } : row;
+    });
     const visibleStillActive = panes.filter((pane) => pane.status === 'launching' || pane.status === 'running');
+    const headlessStillActive = headless.filter((row) => !row.status || row.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
+        status: visibleStillActive.length || headlessStillActive.length ? 'active' : 'draining',
+        right_anchor_pane_id: visibleStillActive[visibleStillActive.length - 1]?.pane_id || state.slot_column_anchor_pane_id || state.dashboard_pane_id,
+        visible_worker_panes: panes,
+        headless_workers: headless
     });
     await appendRightColumnEvent(paths.eventsPath, 'worker_pane_drained', next, {
         slot_id: input.slotId,
@@ -242,4 +325,23 @@ function inferProjectRoot(root, missionId) {
     }
     return root;
 }
+const rightColumnLocks = new Map();
+async function withRightColumnLock(root, missionId, fn) {
+    const key = `${path.resolve(root)}:${missionId}`;
+    const previous = rightColumnLocks.get(key) || Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    rightColumnLocks.set(key, previous.then(() => current, () => current));
+    await previous.catch(() => undefined);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (rightColumnLocks.get(key) === current)
+            rightColumnLocks.delete(key);
+    }
+}
 //# sourceMappingURL=zellij-right-column-manager.js.map

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function renderZellijSlotColumnAnchor(input = {}) {
+    const active = nonNegativeInt(input.activeWorkers, 0);
+    const visible = Math.max(1, nonNegativeInt(input.visiblePaneCap, active || 1));
+    const headless = nonNegativeInt(input.headlessWorkers, 0);
+    const queue = nonNegativeInt(input.queueDepth, 0);
+    return `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+}
+export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
+    const root = path.resolve(input.artifactRoot);
+    const missionDir = inferMissionDir(root, input.missionId);
+    const snapshot = await readJson(path.join(missionDir, 'zellij-dashboard-snapshot.json'));
+    const rightColumn = await readJson(path.join(missionDir, 'zellij-right-column-state.json'));
+    const activeWorkers = Number(snapshot?.active_workers ?? rightColumn?.visible_worker_panes?.filter((row) => row?.status === 'running' || row?.status === 'launching').length ?? 0);
+    const visiblePaneCap = Number(snapshot?.visible_panes ?? Math.max(1, rightColumn?.visible_worker_panes?.length || activeWorkers || 1));
+    const headlessWorkers = Number(snapshot?.headless_workers ?? rightColumn?.headless_workers?.filter((row) => !row?.status || row?.status === 'running').length ?? 0);
+    const queueDepth = Number(snapshot?.queue_depth ?? 0);
+    const anchorInput = { activeWorkers, visiblePaneCap, headlessWorkers, queueDepth };
+    if (input.mode !== undefined)
+        anchorInput.mode = input.mode;
+    return renderZellijSlotColumnAnchor(anchorInput);
+}
+export function buildZellijSlotColumnAnchorCommand(input) {
+    const args = [
+        input.cliPath,
+        'zellij-slot-column-anchor',
+        '--mission', input.missionId,
+        '--mode', input.mode,
+        '--artifact-root', input.artifactRoot,
+        ...(input.watch ? ['--watch'] : [])
+    ];
+    return [input.nodePath || process.execPath, ...args].map(shellQuote).join(' ');
+}
+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 path.join(root, '.sneakoscope', 'missions', missionId);
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await fs.promises.readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function nonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return fallback;
+    return Math.floor(parsed);
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+//# sourceMappingURL=zellij-slot-column-anchor.js.map

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

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function renderZellijSlotPane(input) {
+    const mode = input.mode || 'compact-slots';
+    const maxLines = mode === 'compact-slots' ? 5 : mode === 'dashboard-plus-slots' ? 8 : 20;
+    const task = trimInline(input.currentFile || input.currentTask || '-', 56);
+    const heartbeat = input.heartbeatAgeMs == null
+        ? 'unknown'
+        : input.heartbeatAgeMs < 1000
+            ? 'now'
+            : `${Math.max(1, Math.round(input.heartbeatAgeMs / 1000))}s ago`;
+    const rows = [
+        `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
+        `${trimInline(input.role || 'worker', 18)} - ${trimInline(input.backend || 'codex-sdk', 18)} - ${trimInline(input.worktreeId || '-', 18)}`,
+        `status: ${trimInline(input.status || 'running', 14)} ${task}`,
+        `patch: ${trimInline(input.patchStatus || 'queued', 18)}  verify: ${trimInline(input.verifyStatus || 'queued', 18)}`,
+        `heartbeat: ${heartbeat}`
+    ];
+    return rows.slice(0, maxLines).join('\n');
+}
+export async function renderZellijSlotPaneFromArtifacts(input) {
+    const artifactDir = path.resolve(input.artifactDir);
+    const result = await readJson(path.join(artifactDir, 'worker-result.json'));
+    const heartbeatPath = path.join(artifactDir, 'worker-heartbeat.jsonl');
+    const heartbeatMtime = await statMtimeMs(heartbeatPath);
+    const now = Date.now();
+    return renderZellijSlotPane({
+        slotId: input.slotId,
+        generationIndex: input.generationIndex,
+        role: input.role || result?.persona_id || result?.agent_id || null,
+        backend: input.backend || result?.backend || null,
+        status: result?.status || (heartbeatMtime ? 'running' : 'launching'),
+        currentTask: result?.summary || null,
+        currentFile: Array.isArray(result?.changed_files) ? result.changed_files[0] : null,
+        patchStatus: Array.isArray(result?.patch_envelopes) && result.patch_envelopes.length ? 'candidate' : 'queued',
+        verifyStatus: result?.verification?.status || 'queued',
+        heartbeatAgeMs: heartbeatMtime ? now - heartbeatMtime : null,
+        worktreeId: result?.worktree?.id || null,
+        mode: input.mode || 'compact-slots'
+    });
+}
+export function buildZellijSlotPaneCommand(input) {
+    const args = [
+        input.cliPath,
+        'zellij-slot-pane',
+        '--mission', input.missionId,
+        '--slot', input.slotId,
+        '--generation', String(Math.max(1, Math.floor(Number(input.generationIndex) || 1))),
+        '--artifact-dir', input.artifactDir,
+        '--mode', input.mode || 'compact-slots',
+        ...(input.backend ? ['--backend', input.backend] : []),
+        ...(input.role ? ['--role', input.role] : []),
+        ...(input.watch ? ['--watch'] : [])
+    ];
+    return [input.nodePath || process.execPath, ...args].map(shellQuote).join(' ');
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await fs.promises.readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function statMtimeMs(file) {
+    try {
+        return (await fs.promises.stat(file)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function trimInline(value, max) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (text.length <= max)
+        return text;
+    return text.slice(0, Math.max(1, max - 3)) + '...';
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+//# sourceMappingURL=zellij-slot-pane-renderer.js.map

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

@@ -0,0 +1,16 @@
+export function resolveZellijUiMode(args = [], env = process.env) {
+    const fromEnv = String(env.SKS_ZELLIJ_UI_MODE || '').trim();
+    if (fromEnv === 'full-debug')
+        return 'full-debug';
+    if (fromEnv === 'dashboard-plus-slots')
+        return 'dashboard-plus-slots';
+    if (args.includes('--zellij-dashboard'))
+        return 'dashboard-plus-slots';
+    if (args.includes('--zellij-full-debug'))
+        return 'full-debug';
+    return 'compact-slots';
+}
+export function zellijUiModeCreatesDashboard(mode) {
+    return mode !== 'compact-slots';
+}
+//# sourceMappingURL=zellij-ui-mode.js.map