sneakoscope 2.0.8 → 2.0.9

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

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) {
@@ -59,8 +60,9 @@ export function buildWorkerPaneArtifact(input) {
         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,49 @@ 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,
+            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;
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || 'running', input.worktree || null);
+    const directionRequested = rightColumn ? 'down' : 'right';
+    const focus = rightColumn?.focusPaneId
+        ? await focusZellijPaneById(input.sessionName, rightColumn.focusPaneId, cwd)
+        : null;
+    const newPaneArgs = ['--session', input.sessionName, 'action', 'new-pane', '--direction', directionRequested, ...(rightColumn ? ['--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
+            ? ['--session', input.sessionName, 'action', 'new-pane', '--direction', 'down', '--name', paneName, '--', 'sh', '-lc', input.workerCommand]
+            : ['--session', input.sessionName, 'action', 'new-pane', '--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 +145,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 +155,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,
@@ -174,12 +218,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 +241,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 +438,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));
 }

package/dist/scripts/codex-sdk-release-review-pipeline-check.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 // @ts-nocheck
-import { assertGate, emitGate, packageScripts, readText } from './lib/codex-sdk-gate-lib.js';
+import { assertGate, emitGate, packageScripts, readText, releaseGateIds } from './lib/codex-sdk-gate-lib.js';
 const scripts = packageScripts();
-const releaseCheck = String(scripts['release:check'] || '');
 const releaseRealCheck = String(scripts['release:real-check'] || '');
-assertGate(releaseCheck.includes('codex-sdk:capability'), 'release:check must include Codex SDK capability gate');
-assertGate(releaseCheck.includes('codex-sdk:all-pipelines'), 'release:check must include Codex SDK all-pipelines gate');
+const releaseGates = releaseGateIds();
+assertGate(releaseGates.has('codex-sdk:capability'), 'release gate DAG must include Codex SDK capability gate');
+assertGate(releaseGates.has('codex-sdk:all-pipelines'), 'release gate DAG must include Codex SDK all-pipelines gate');
 assertGate(releaseRealCheck.includes('codex-sdk:real-smoke'), 'release:real-check must include Codex SDK real smoke');
 assertGate(readText('src/core/agents/agent-orchestrator.ts').includes('legacy_codex_exec_runtime_removed'), 'orchestrator must block legacy codex-exec requests');
-emitGate('codex-sdk:release-review-pipeline', { release_check_contains_sdk: true });
+emitGate('codex-sdk:release-review-pipeline', { release_gate_dag_contains_sdk: true });
 //# sourceMappingURL=codex-sdk-release-review-pipeline-check.js.map

package/dist/scripts/doctor-fix-proves-codex-read-check.js

@@ -25,19 +25,40 @@ const run = spawnSync(process.execPath, [
         SKS_DISABLE_UPDATE_CHECK: '1'
     },
     encoding: 'utf8',
-    timeout: 60000
+    timeout: 180000
 });
 const parsed = parseLastJson(run.stdout || '{}');
 const ok = run.status !== 0
     && parsed.ready?.ready === false
     && parsed.ready?.blockers?.includes('codex_cli_config_eperm')
     && parsed.ready?.next_actions?.length > 0;
-console.log(JSON.stringify({ schema: 'sks.doctor-fix-proves-codex-read-check.v1', ok, status: run.status, parsed }, null, 2));
+console.log(JSON.stringify({
+    schema: 'sks.doctor-fix-proves-codex-read-check.v1',
+    ok,
+    status: run.status,
+    signal: run.signal,
+    error: run.error ? String(run.error.message || run.error) : null,
+    parsed,
+    stdout_tail: String(run.stdout || '').slice(-1000),
+    stderr_tail: String(run.stderr || '').slice(-1000)
+}, null, 2));
 if (!ok)
     process.exitCode = 1;
 function parseLastJson(text) {
-    const index = String(text).lastIndexOf('\n{');
-    const jsonText = index >= 0 ? String(text).slice(index + 1) : String(text).slice(String(text).indexOf('{'));
-    return JSON.parse(jsonText || '{}');
+    const source = String(text || '').trim();
+    if (!source)
+        return {};
+    const starts = [];
+    for (let index = source.indexOf('{'); index >= 0; index = source.indexOf('{', index + 1))
+        starts.push(index);
+    for (let i = starts.length - 1; i >= 0; i -= 1) {
+        try {
+            return JSON.parse(source.slice(starts[i]));
+        }
+        catch {
+            // Continue searching for the outer JSON object; pretty JSON may contain nested objects.
+        }
+    }
+    return {};
 }
 //# sourceMappingURL=doctor-fix-proves-codex-read-check.js.map

package/dist/scripts/lib/codex-sdk-gate-lib.js

@@ -59,6 +59,10 @@ export async function runFakeCodexSdkTaskFixture(label = 'fixture', extra = {})
 export function packageScripts() {
     return readJson('package.json').scripts || {};
 }
+export function releaseGateIds() {
+    const manifest = readJson('release-gates.v2.json');
+    return new Set((manifest.gates || []).map((gate) => gate.id));
+}
 export function assertSourceIncludes(file, tokens) {
     const text = readText(file);
     for (const token of tokens)

package/dist/scripts/mad-sks-zellij-default-pane-worker-check.js

@@ -17,10 +17,10 @@ const checks = {
     zellij_session_before_swarm: launchIndex >= 0 && swarmIndex >= 0 && launchIndex < swarmIndex,
     main_only_session: mad.includes('slotCount: 0'),
     zellij_default_backend: /return 'zellij'/.test(mad) && mad.includes("list.includes('--json')") && mad.includes("list.includes('--no-attach')"),
-    worker_command_real_zellij: mad.includes("command.push('--real')") && mad.includes("command.push('--zellij-session-name'") && mad.includes("command.push('--zellij-pane-worker')"),
+    worker_command_real_zellij: mad.includes("command.push('--real')") && mad.includes("command.push('--zellij-session-name'") && mad.includes("command.push('--zellij-pane-worker')") && mad.includes("command.push('--worker-placement'"),
     parser_accepts_worker_flags: parser.includes('--zellij-session-name') && parser.includes('--zellij-pane-worker') && parser.includes('--no-zellij-pane-worker'),
     native_worker_pane_path: swarm.includes("this.input.backend === 'zellij'") && swarm.includes('ctx.opts.zellijPaneWorker !== false') && swarm.includes('openWorkerPane({'),
-    right_pane_requested: manager.includes("'--direction', 'right'")
+    right_pane_requested: manager.includes("'--direction', directionRequested") && manager.includes("'--near-current-pane'")
 };
 const ok = Object.values(checks).every(Boolean);
 emit({

package/dist/scripts/naruto-concurrency-governor-check.js

@@ -10,6 +10,7 @@ const normal = governorMod.decideNarutoConcurrency({
     zellijVisiblePaneCap: 12,
     hardware: {
         cores: 32,
+        loadAverage: [0, 0, 0],
         freeMemoryBytes: 48 * 1024 * 1024 * 1024,
         totalMemoryBytes: 64 * 1024 * 1024 * 1024,
         fileDescriptorLimit: 4096,
@@ -37,7 +38,7 @@ const pressure = governorMod.decideNarutoConcurrency({
         diskIoPressure: 0.9
     }
 });
-assertGate(normal.safe_active_workers <= 32, 'requested_clones=200 fixture must cap active workers safely', { normal });
+assertGate(normal.safe_active_workers >= 32 && normal.safe_active_workers <= 100, 'requested_clones=200 fixture must cap active workers safely while allowing aggressive process-pool fanout', { normal });
 assertGate(normal.safe_zellij_visible_panes === 12 && normal.headless_workers === normal.safe_active_workers - 12, 'zellij visible panes must stay within UI cap', { normal });
 assertGate(normal.local_llm_parallel <= 4, 'local LLM active requests must respect max_parallel_requests=4', { normal });
 assertGate(pressure.safe_active_workers < normal.safe_active_workers, 'memory/load pressure fixture must decrease active workers', { normal: normal.safe_active_workers, pressure: pressure.safe_active_workers });

package/dist/scripts/naruto-extreme-parallelism-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
+import { decideNarutoConcurrency } from '../core/naruto/naruto-concurrency-governor.js';
+const graph = buildNarutoWorkGraph({ requestedClones: 100, writeCapable: true, maxActiveWorkers: 32 });
+const governor = decideNarutoConcurrency({
+    requestedClones: 100,
+    totalWorkItems: graph.total_work_items,
+    pendingWorkQueueSize: graph.total_work_items,
+    backend: 'codex-sdk',
+    hardware: { cores: 16, loadAverage: [1, 1, 1], freeMemoryBytes: 64 * 1024 * 1024 * 1024, totalMemoryBytes: 128 * 1024 * 1024 * 1024, fileDescriptorLimit: 8192, processCount: 100, terminalRows: 48, remoteApiRateLimitBudget: 32, localLlmMaxParallelRequests: 8 }
+});
+const report = {
+    schema: 'sks.naruto-extreme-parallelism-check.v1',
+    ok: graph.total_work_items >= 200 && governor.safe_active_workers >= 16 && governor.safe_zellij_visible_panes <= governor.safe_active_workers && graph.mixed_work_kinds.length >= 6,
+    graph: { total_work_items: graph.total_work_items, mixed_work_kinds: graph.mixed_work_kinds, write_allowed_count: graph.write_allowed_count },
+    governor
+};
+assertGate(report.ok, 'Naruto extreme parallelism must fan out >=2x clones and keep a high safe active pool', report);
+emitGate('naruto:extreme-parallelism', report);
+//# sourceMappingURL=naruto-extreme-parallelism-check.js.map