sneakoscope 2.0.8 → 2.0.10

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

@@ -0,0 +1,304 @@
+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') {
+        return writeRightColumnState(paths.statePath, {
+            ...existing,
+            updated_at: nowIso(),
+            ui_mode: existing.ui_mode || uiMode
+        });
+    }
+    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,
+        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,
+            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,
+        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,
+        ui_mode: uiMode,
+        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) {
+    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,
+        ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+        missionId: input.missionId,
+        sessionName: input.sessionName,
+        cwd: input.cwd,
+        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 recordHeadlessWorkerInRightColumnUnlocked({
+            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) {
+    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,
+        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,
+        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, 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, {
+        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 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 || headlessStillActive.length ? 'active' : 'draining',
+        right_anchor_pane_id: visibleStillActive[visibleStillActive.length - 1]?.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,
+        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;
+}
+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-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

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -4,6 +4,7 @@ import { providerPaneLabel } from '../provider/provider-badge.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 import { runZellij } from './zellij-command.js';
 import { extractZellijPaneIdFromOutput } from './zellij-lane-runtime.js';
+import { closeWorkerInRightColumn, prepareWorkerInRightColumn, recordWorkerPaneInRightColumn } from './zellij-right-column-manager.js';
 export const ZELLIJ_WORKER_PANE_SCHEMA = 'sks.zellij-worker-pane.v1';
 export const ZELLIJ_WORKER_PANE_EVENT_SCHEMA = 'sks.zellij-worker-pane-event.v1';
 export function buildWorkerPaneName(slotId, generationIndex) {
@@ -28,7 +29,7 @@ export function buildWorkerPaneArtifact(input) {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
         updated_at: now,
-        ok: blockers.length === 0 && isRealZellijWorkerPaneIdSource(paneIdSource) && Boolean(input.paneId),
+        ok: blockers.length === 0 && (paneIdSource === 'zellij_worker_headless_overflow' || (isRealZellijWorkerPaneIdSource(paneIdSource) && Boolean(input.paneId))),
         status: input.status || 'launching',
         mission_id: input.missionId,
         session_name: input.sessionName,
@@ -51,16 +52,17 @@ export function buildWorkerPaneArtifact(input) {
         stdout_log: input.stdoutLog,
         stderr_log: input.stderrLog,
         parent_child_transport: 'worker-result-json-and-heartbeat',
-        scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
-        command: '<native-cli-worker-command>',
+        scaling_primitive: input.scalingPrimitive || 'native_cli_process_in_zellij_worker_pane',
+        command: String(input.workerCommand || '').includes('zellij-slot-pane') ? '<zellij-slot-pane-renderer-command>' : '<native-cli-worker-command>',
         create_session: input.createSession || null,
         launch: input.launch || null,
         pane_reconciliation: input.paneReconciliation || null,
         opened_at: now,
         closed_at: null,
         close: null,
-        direction_requested: 'right',
+        direction_requested: input.directionRequested || 'right',
         direction_applied: input.directionApplied || 'not_applied',
+        right_column: input.rightColumn || null,
         sdk_thread_id: input.sdkThreadId || null,
         sdk_run_id: input.sdkRunId || null,
         stream_event_count: Number(input.streamEventCount || 0),
@@ -85,24 +87,79 @@ export async function openWorkerPane(input) {
         optional: false
     });
     const createSession = normalizeExistingZellijSession(input.sessionName, createSessionRaw);
+    const rightColumn = input.rightColumnMode === 'spawn-on-first-worker'
+        ? await prepareWorkerInRightColumn({
+            root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: input.missionId,
+            sessionName: input.sessionName,
+            cwd,
+            worker: { slotId: input.slotId, generationIndex: input.generationIndex },
+            visiblePaneCap: input.visiblePaneCap || 1,
+            uiMode: input.uiMode || 'compact-slots',
+            dashboardSnapshot: {
+                ...(input.dashboardSnapshot || {}),
+                mode: String(input.dashboardSnapshot?.mode || 'naruto'),
+                active_workers: Number(input.dashboardSnapshot?.active_workers || input.visiblePaneCap || 1),
+                visible_panes: Number(input.dashboardSnapshot?.visible_panes || input.visiblePaneCap || 1)
+            }
+        })
+        : null;
+    if (rightColumn?.placement === 'headless') {
+        const record = buildWorkerPaneArtifact({
+            ...input,
+            paneId: null,
+            paneIdSource: 'zellij_worker_headless_overflow',
+            createSession,
+            launch: null,
+            paneReconciliation: null,
+            directionRequested: 'right',
+            directionApplied: 'not_applied',
+            rightColumn: {
+                mode: 'spawn-on-first-worker',
+                focus_pane_id: null,
+                y_order: null
+            },
+            status: 'running',
+            providerContext,
+            serviceTier: input.serviceTier || providerContext.service_tier,
+            scalingPrimitive: 'native_cli_process_headless_with_slot_dashboard',
+            blockers: []
+        });
+        await writeWorkerPaneArtifact(root, record);
+        await appendWorkerPaneEvent(root, 'worker_headless_overflow', input, {
+            slot_id: input.slotId,
+            generation_index: input.generationIndex,
+            reason: `visible_pane_cap:${input.visiblePaneCap || 1}`
+        });
+        return record;
+    }
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
+    const directionRequested = rightColumn?.focusPaneId ? 'down' : 'right';
+    const focus = rightColumn?.focusPaneId
+        ? await focusZellijPaneById(input.sessionName, rightColumn.focusPaneId, cwd)
+        : null;
+    const newPaneArgs = ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, ...(directionRequested === 'down' ? ['--near-current-pane'] : []), '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
     let launch = createSession.ok
-        ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
+        ? await runZellij(newPaneArgs, {
             cwd,
             timeoutMs: 5000,
             optional: false
         })
         : null;
-    let directionApplied = launch?.ok ? 'right' : 'not_applied';
+    let directionApplied = launch?.ok ? directionRequested : 'not_applied';
     if (createSession.ok && launch && !launch.ok) {
-        const fallback = await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
+        const fallbackArgs = rightColumn && directionRequested === 'down'
+            ? ['--session', input.sessionName, 'action', 'new-pane', '--direction', 'down', '--name', paneName, '--', 'sh', '-lc', input.workerCommand]
+            : ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, '--name', paneName, '--', 'sh', '-lc', input.workerCommand];
+        const fallback = await runZellij(fallbackArgs, {
             cwd,
             timeoutMs: 5000,
             optional: false
         });
         if (fallback.ok) {
             launch = fallback;
-            directionApplied = 'unknown';
+            directionApplied = rightColumn ? 'down' : 'unknown';
         }
     }
     const stdoutPaneId = launch?.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
@@ -118,6 +175,7 @@ export async function openWorkerPane(input) {
                 : 'zellij_worker_pane_launch_failed';
     const blockers = [
         ...(createSession.ok ? [] : createSession.blockers.map((blocker) => `zellij_worker_session_${blocker}`)),
+        ...(rightColumn && rightColumn.placement !== 'zellij-pane' ? [`zellij_worker_right_column_${rightColumn.placement}`] : []),
         ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
         ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
     ];
@@ -127,14 +185,30 @@ export async function openWorkerPane(input) {
         paneIdSource,
         createSession,
         launch,
-        paneReconciliation: { ...(reconciledPane || {}), rename_pane: renamePane },
+        paneReconciliation: {
+            ...(reconciledPane || {}),
+            focus_pane: focus,
+            focus_degraded: focus ? focus.ok !== true : false,
+            rename_pane: renamePane
+        },
+        directionRequested,
         directionApplied,
+        rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: rightColumn.focusPaneId, y_order: rightColumn.yOrder } : null,
         status: blockers.length ? 'failed' : 'running',
         providerContext,
         serviceTier: input.serviceTier || providerContext.service_tier,
         blockers
     });
     await writeWorkerPaneArtifact(root, record);
+    if (rightColumn) {
+        await recordWorkerPaneInRightColumn({
+            root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: input.missionId,
+            record,
+            yOrder: rightColumn.yOrder
+        });
+    }
     await appendWorkerPaneEvent(root, 'zellij_worker_pane_created', input, {
         ok: record.ok,
         pane_id: record.pane_id,
@@ -160,7 +234,7 @@ export async function openWorkerPane(input) {
         provider_context: record.provider_context,
         direction_requested: record.direction_requested,
         direction_applied: record.direction_applied,
-        command: '<native-cli-worker-command>',
+        command: record.command,
         worker_artifact_dir: input.workerArtifactDir,
         worker_result_path: input.resultPath,
         heartbeat_path: input.heartbeatPath,
@@ -174,12 +248,16 @@ export async function openWorkerPane(input) {
 }
 export async function closeWorkerPane(input) {
     const root = path.resolve(input.root);
-    const close = process.env.SKS_ZELLIJ_CLOSE_WORKER_PANE === '1' && input.paneRecord.pane_id
-        ? await runZellij(['--session', input.paneRecord.session_name, 'action', 'close-pane', '--pane-id', input.paneRecord.pane_id], {
-            cwd: input.cwd || packageRoot(),
-            timeoutMs: 5000,
-            optional: true
-        })
+    const success = (input.status || 'closed') === 'closed' && !(input.blockers || []).length;
+    const closeSuccess = process.env.SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0';
+    const closeFailed = process.env.SKS_ZELLIJ_CLOSE_FAILED_PANE === '1' || process.env.SKS_ZELLIJ_KEEP_FAILED_PANE === '0';
+    const paneId = input.paneRecord.pane_id;
+    const shouldClose = Boolean(paneId) && (success ? closeSuccess : closeFailed);
+    const close = shouldClose
+        ? await closeZellijPaneById(input.paneRecord.session_name, paneId || '', input.cwd || packageRoot())
+        : null;
+    const rename = !shouldClose && paneId
+        ? await renameZellijPaneById(input.paneRecord.session_name, paneId, `${input.paneRecord.pane_title} · ${success ? 'drained' : 'failed'}`, input.cwd || packageRoot())
         : null;
     const next = {
         ...input.paneRecord,
@@ -193,9 +271,25 @@ export async function closeWorkerPane(input) {
         stream_event_count: Number(input.streamEventCount || input.paneRecord.stream_event_count || 0),
         structured_output_valid: input.structuredOutputValid === true || input.paneRecord.structured_output_valid === true,
         worker_result_path: input.workerResultPath || input.paneRecord.worker_result_path,
-        blockers: [...input.paneRecord.blockers, ...(input.blockers || []), ...(close && !close.ok ? close.blockers.map((blocker) => `zellij_worker_close_${blocker}`) : [])]
+        blockers: [
+            ...input.paneRecord.blockers,
+            ...(input.blockers || []),
+            ...(close && !close.ok ? close.blockers.map((blocker) => `zellij_worker_close_${blocker}`) : []),
+            ...(rename && !rename.ok ? rename.blockers.map((blocker) => `zellij_worker_rename_${blocker}`) : [])
+        ]
     };
     await writeWorkerPaneArtifact(root, next);
+    if (next.right_column?.mode === 'spawn-on-first-worker') {
+        await closeWorkerInRightColumn({
+            root,
+            ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+            missionId: next.mission_id,
+            slotId: next.slot_id,
+            generationIndex: next.generation_index,
+            paneId: next.pane_id,
+            status: next.status === 'failed' ? 'failed' : close?.ok ? 'closed' : 'draining'
+        });
+    }
     await appendWorkerPaneEvent(root, 'pane_closed', {
         root,
         missionId: next.mission_id,
@@ -374,6 +468,47 @@ async function renameZellijPaneById(sessionName, paneId, paneName, cwd) {
     }
     return last;
 }
+async function focusZellijPaneById(sessionName, paneId, cwd) {
+    const candidates = zellijPaneIdCandidates(paneId);
+    let last = null;
+    for (const candidate of candidates) {
+        const focus = await runZellij(['--session', sessionName, 'action', 'focus-pane-id', candidate], {
+            cwd,
+            timeoutMs: 5000,
+            optional: true
+        });
+        last = focus;
+        if (focus.ok)
+            return focus;
+    }
+    return last;
+}
+async function closeZellijPaneById(sessionName, paneId, cwd) {
+    const candidates = zellijPaneIdCandidates(paneId);
+    let last = null;
+    for (const candidate of candidates) {
+        const close = await runZellij(['--session', sessionName, 'action', 'close-pane', '--pane-id', candidate], {
+            cwd,
+            timeoutMs: 5000,
+            optional: true
+        });
+        last = close;
+        if (close.ok)
+            return close;
+    }
+    return last;
+}
+function zellijPaneIdCandidates(paneId) {
+    const raw = String(paneId || '').trim();
+    const numeric = raw.replace(/^terminal_/, '');
+    const parsed = Number.parseInt(numeric, 10);
+    return [...new Set([
+            raw,
+            numeric,
+            Number.isFinite(parsed) ? String(parsed) : '',
+            Number.isFinite(parsed) ? `terminal_${parsed}` : ''
+        ].filter(Boolean))];
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }