sneakoscope 2.0.10 → 2.0.12

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

@@ -0,0 +1,218 @@
+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);
+    const header = `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+    const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
+    if (!workers.length)
+        return header;
+    const maxRows = Math.max(1, nonNegativeInt(input.maxWorkerRows, input.mode === 'full-debug' ? 24 : 12));
+    const visibleRows = workers.slice(0, maxRows);
+    const hidden = Math.max(0, workers.length - visibleRows.length);
+    return [
+        header,
+        ...visibleRows.map((row, index) => renderWorkerRow(row, index + 1)),
+        ...(hidden ? [`+${hidden} more worker${hidden === 1 ? '' : 's'}`] : [])
+    ].join('\n');
+}
+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 swarm = await readJson(path.join(root, 'agent-native-cli-session-swarm.json'))
+        || await readJson(path.join(missionDir, 'agents', 'agent-native-cli-session-swarm.json'));
+    const workerRows = await buildWorkerRows(root, missionDir, rightColumn, swarm);
+    const activeWorkers = Number(snapshot?.active_workers ?? workerRows.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 ?? workerRows.filter((row) => row.placement === 'headless' && (!row.status || row.status === 'running')).length ?? 0);
+    const queueDepth = Number(snapshot?.queue_depth ?? 0);
+    const anchorInput = { activeWorkers, visiblePaneCap, headlessWorkers, queueDepth, workerRows };
+    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;
+    }
+}
+async function buildWorkerRows(root, missionDir, rightColumn, swarm) {
+    const byKey = new Map();
+    const records = Array.isArray(swarm?.records) ? swarm.records : [];
+    const recordByKey = new Map();
+    for (const record of records) {
+        const key = workerKey(record?.slot_id, record?.generation_index);
+        if (key)
+            recordByKey.set(key, record);
+    }
+    for (const pane of Array.isArray(rightColumn?.visible_worker_panes) ? rightColumn.visible_worker_panes : []) {
+        const key = workerKey(pane?.slot_id, pane?.generation_index);
+        if (!key)
+            continue;
+        const record = recordByKey.get(key);
+        byKey.set(key, await hydrateWorkerRow(root, missionDir, {
+            slotId: String(pane.slot_id),
+            generationIndex: Number(pane.generation_index || 1),
+            placement: 'zellij-pane',
+            status: pane.status || record?.status || 'running',
+            paneId: pane.pane_id || record?.zellij_pane_id || null,
+            yOrder: Number(pane.y_order || 0)
+        }, record));
+    }
+    for (const row of Array.isArray(rightColumn?.headless_workers) ? rightColumn.headless_workers : []) {
+        const key = workerKey(row?.slot_id, row?.generation_index);
+        if (!key)
+            continue;
+        const record = recordByKey.get(key);
+        byKey.set(key, await hydrateWorkerRow(root, missionDir, {
+            slotId: String(row.slot_id),
+            generationIndex: Number(row.generation_index || 1),
+            placement: 'headless',
+            status: row.status || record?.status || 'running',
+            reason: row.reason || record?.headless_reason || null,
+            yOrder: 9000
+        }, record));
+    }
+    for (const record of records) {
+        const key = workerKey(record?.slot_id, record?.generation_index);
+        if (!key || byKey.has(key))
+            continue;
+        byKey.set(key, await hydrateWorkerRow(root, missionDir, {
+            slotId: String(record.slot_id || record.agent_id || 'slot-?'),
+            generationIndex: Number(record.generation_index || 1),
+            placement: record.worker_placement || (record.zellij_pane_id ? 'zellij-pane' : 'process'),
+            status: record.status || 'running',
+            paneId: record.zellij_pane_id || null,
+            yOrder: 5000
+        }, record));
+    }
+    return [...byKey.values()].sort((a, b) => {
+        const statusDelta = statusWeight(a.status) - statusWeight(b.status);
+        if (statusDelta)
+            return statusDelta;
+        const yDelta = Number(a.yOrder || 0) - Number(b.yOrder || 0);
+        if (yDelta)
+            return yDelta;
+        return String(a.slotId).localeCompare(String(b.slotId));
+    });
+}
+async function hydrateWorkerRow(root, missionDir, base, record) {
+    const artifactDir = resolveArtifactDir(root, missionDir, record?.worker_artifact_dir);
+    const result = artifactDir ? await readJson(path.join(artifactDir, 'worker-result.json')) : null;
+    const intake = artifactDir ? await readJson(path.join(artifactDir, 'worker-intake.json')) : null;
+    const heartbeatPath = artifactDir ? path.join(artifactDir, 'worker-heartbeat.jsonl') : null;
+    return {
+        ...base,
+        status: result?.status || base.status || record?.status || 'running',
+        backend: result?.backend || record?.backend || intake?.backend || null,
+        role: result?.persona_id || intake?.agent?.naruto_role || intake?.agent?.role || intake?.agent?.persona_id || null,
+        task: firstText([
+            result?.summary,
+            Array.isArray(result?.changed_files) ? result.changed_files[0] : null,
+            intake?.slice?.description,
+            intake?.slice?.title,
+            intake?.slice?.id,
+            base.reason
+        ]),
+        worktreeId: result?.worktree?.id || record?.worktree?.id || intake?.worktree?.id || null,
+        heartbeatAgeMs: heartbeatPath ? await heartbeatAgeMs(heartbeatPath) : null
+    };
+}
+function renderWorkerRow(row, index) {
+    const slot = `${trimInline(row.slotId || 'slot-?', 12)} g${Math.max(1, Math.floor(Number(row.generationIndex) || 1))}`;
+    const status = trimInline(row.status || 'running', 9);
+    const backend = trimInline(row.backend || row.placement || '-', 12);
+    const worktree = trimInline(row.worktreeId || row.role || '-', 10);
+    const task = trimInline(row.task || row.reason || '-', 38);
+    return `${String(index).padStart(2, '0')} ${slot} ${status} ${backend} ${worktree} · ${task} · hb ${formatHeartbeat(row.heartbeatAgeMs)}`;
+}
+function resolveArtifactDir(root, missionDir, value) {
+    if (!value)
+        return null;
+    const text = String(value);
+    if (path.isAbsolute(text))
+        return text;
+    return path.join(root, text);
+}
+async function heartbeatAgeMs(file) {
+    try {
+        return Date.now() - (await fs.promises.stat(file)).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+function formatHeartbeat(ageMs) {
+    if (ageMs == null)
+        return '?';
+    if (ageMs < 1000)
+        return 'now';
+    return `${Math.max(1, Math.round(ageMs / 1000))}s`;
+}
+function firstText(values) {
+    for (const value of values) {
+        const text = String(value || '').replace(/\s+/g, ' ').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function workerKey(slotId, generationIndex) {
+    const slot = String(slotId || '').trim();
+    if (!slot)
+        return null;
+    return `${slot}:g${Math.max(1, Math.floor(Number(generationIndex) || 1))}`;
+}
+function statusWeight(status) {
+    const text = String(status || '').toLowerCase();
+    if (text === 'running' || text === 'launching')
+        return 0;
+    if (text === 'failed')
+        return 1;
+    if (text === 'draining')
+        return 2;
+    if (text === 'closed')
+        return 3;
+    return 4;
+}
+function nonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return fallback;
+    return Math.floor(parsed);
+}
+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-column-anchor.js.map

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

@@ -4,7 +4,8 @@ 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';
+import { buildZellijSlotColumnAnchorCommand } from './zellij-slot-column-anchor.js';
+import { closeWorkerInRightColumn, prepareWorkerInRightColumn, recordSlotColumnAnchorInRightColumn, 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) {
@@ -25,6 +26,14 @@ export function buildWorkerPaneArtifact(input) {
     const blockers = input.blockers || [];
     const providerContext = normalizePaneProviderContext(input.providerContext, input.serviceTier);
     const paneTitle = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier, input.backend, input.statusLabel || input.status, input.worktree || null);
+    const commandText = String(input.workerCommand || '');
+    const isSlotRenderer = commandText.includes('zellij-slot-pane');
+    const paneKind = input.paneKind || (isSlotRenderer ? 'slot_status_renderer' : 'worker_codex_sdk');
+    const scalingPrimitive = input.scalingPrimitive || (isSlotRenderer
+        ? 'native_cli_process_with_zellij_slot_renderer'
+        : 'native_cli_process_in_zellij_worker_pane');
+    const directionRequested = input.directionRequested || 'down';
+    const directionApplied = input.directionApplied || 'not_applied';
     return {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
@@ -38,7 +47,7 @@ export function buildWorkerPaneArtifact(input) {
         session_id: input.sessionId,
         pane_name: paneTitle,
         pane_title: paneTitle,
-        pane_kind: 'worker_codex_sdk',
+        pane_kind: paneKind,
         pane_id: input.paneId || null,
         pane_id_source: paneIdSource,
         provider: providerContext.provider,
@@ -52,16 +61,21 @@ export function buildWorkerPaneArtifact(input) {
         stdout_log: input.stdoutLog,
         stderr_log: input.stderrLog,
         parent_child_transport: 'worker-result-json-and-heartbeat',
-        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>',
+        scaling_primitive: scalingPrimitive,
+        command: isSlotRenderer ? '<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: input.directionRequested || 'right',
-        direction_applied: input.directionApplied || 'not_applied',
+        direction_requested: directionRequested,
+        direction_applied: directionApplied,
+        column_creation_direction_requested: input.columnCreationDirectionRequested ?? null,
+        column_creation_direction_applied: input.columnCreationDirectionApplied ?? null,
+        worker_direction_requested: input.workerDirectionRequested || 'down',
+        worker_direction_applied: input.workerDirectionApplied || (directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied'),
+        slot_column_anchor_pane_id: input.slotColumnAnchorPaneId || null,
         right_column: input.rightColumn || null,
         sdk_thread_id: input.sdkThreadId || null,
         sdk_run_id: input.sdkRunId || null,
@@ -113,12 +127,18 @@ export async function openWorkerPane(input) {
             createSession,
             launch: null,
             paneReconciliation: null,
-            directionRequested: 'right',
+            directionRequested: 'down',
             directionApplied: 'not_applied',
+            columnCreationDirectionRequested: null,
+            columnCreationDirectionApplied: 'not_applied',
+            workerDirectionRequested: 'down',
+            workerDirectionApplied: 'not_applied',
+            slotColumnAnchorPaneId: rightColumn.state.slot_column_anchor_pane_id || null,
             rightColumn: {
                 mode: 'spawn-on-first-worker',
                 focus_pane_id: null,
-                y_order: null
+                y_order: null,
+                slot_column_anchor_pane_id: rightColumn.state.slot_column_anchor_pane_id || null
             },
             status: 'running',
             providerContext,
@@ -135,9 +155,42 @@ export async function openWorkerPane(input) {
         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)
+    let slotColumnAnchorPaneId = rightColumn?.state.slot_column_anchor_pane_id || null;
+    let anchorLaunch = null;
+    let columnCreationDirectionRequested = null;
+    let columnCreationDirectionApplied = null;
+    if (rightColumn && !rightColumn.focusPaneId && !slotColumnAnchorPaneId) {
+        columnCreationDirectionRequested = 'right';
+        const anchorCommand = buildZellijSlotColumnAnchorCommand({
+            cliPath: path.join(packageRoot(), 'dist', 'bin', 'sks.js'),
+            missionId: input.missionId,
+            mode: input.uiMode || 'compact-slots',
+            artifactRoot: root,
+            watch: true
+        });
+        anchorLaunch = createSession.ok
+            ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', 'SLOTS', '--', 'sh', '-lc', anchorCommand], {
+                cwd,
+                timeoutMs: 5000,
+                optional: false
+            })
+            : null;
+        slotColumnAnchorPaneId = anchorLaunch?.ok ? extractZellijPaneIdFromOutput(anchorLaunch.stdout_tail) : null;
+        columnCreationDirectionApplied = anchorLaunch?.ok ? (slotColumnAnchorPaneId ? 'right' : 'unknown') : 'not_applied';
+        if (slotColumnAnchorPaneId) {
+            await recordSlotColumnAnchorInRightColumn({
+                root,
+                ...(input.projectRoot ? { projectRoot: input.projectRoot } : {}),
+                missionId: input.missionId,
+                sessionName: input.sessionName,
+                paneId: slotColumnAnchorPaneId
+            });
+        }
+    }
+    const focusPaneId = rightColumn?.focusPaneId || slotColumnAnchorPaneId || null;
+    const directionRequested = 'down';
+    const focus = focusPaneId
+        ? await focusZellijPaneById(input.sessionName, 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
@@ -176,6 +229,8 @@ export async function openWorkerPane(input) {
     const blockers = [
         ...(createSession.ok ? [] : createSession.blockers.map((blocker) => `zellij_worker_session_${blocker}`)),
         ...(rightColumn && rightColumn.placement !== 'zellij-pane' ? [`zellij_worker_right_column_${rightColumn.placement}`] : []),
+        ...(rightColumn && columnCreationDirectionRequested === 'right' && columnCreationDirectionApplied !== 'right' ? ['zellij_worker_slot_column_anchor_not_created'] : []),
+        ...(anchorLaunch && !anchorLaunch.ok ? anchorLaunch.blockers.map((blocker) => `zellij_worker_slot_column_anchor_${blocker}`) : []),
         ...(launch && !launch.ok ? launch.blockers.map((blocker) => `zellij_worker_pane_${blocker}`) : []),
         ...(launch?.ok && !isRealZellijWorkerPaneIdSource(paneIdSource) ? ['zellij_worker_pane_id_real_source_missing'] : [])
     ];
@@ -189,11 +244,18 @@ export async function openWorkerPane(input) {
             ...(reconciledPane || {}),
             focus_pane: focus,
             focus_degraded: focus ? focus.ok !== true : false,
+            slot_column_anchor_pane_id: slotColumnAnchorPaneId,
+            slot_column_anchor_launch: anchorLaunch,
             rename_pane: renamePane
         },
         directionRequested,
         directionApplied,
-        rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: rightColumn.focusPaneId, y_order: rightColumn.yOrder } : null,
+        columnCreationDirectionRequested,
+        columnCreationDirectionApplied,
+        workerDirectionRequested: 'down',
+        workerDirectionApplied: directionApplied === 'down' ? 'down' : directionApplied === 'unknown' ? 'unknown' : 'not_applied',
+        slotColumnAnchorPaneId,
+        rightColumn: rightColumn ? { mode: 'spawn-on-first-worker', focus_pane_id: focusPaneId, y_order: rightColumn.yOrder, slot_column_anchor_pane_id: slotColumnAnchorPaneId } : null,
         status: blockers.length ? 'failed' : 'running',
         providerContext,
         serviceTier: input.serviceTier || providerContext.service_tier,
@@ -226,7 +288,7 @@ export async function openWorkerPane(input) {
         session_name: input.sessionName,
         pane_name: paneName,
         pane_title: paneName,
-        pane_kind: 'worker_codex_sdk',
+        pane_kind: record.pane_kind,
         pane_id: record.pane_id,
         pane_id_source: record.pane_id_source,
         provider: record.provider,
@@ -234,6 +296,11 @@ export async function openWorkerPane(input) {
         provider_context: record.provider_context,
         direction_requested: record.direction_requested,
         direction_applied: record.direction_applied,
+        column_creation_direction_requested: record.column_creation_direction_requested || null,
+        column_creation_direction_applied: record.column_creation_direction_applied || null,
+        worker_direction_requested: record.worker_direction_requested,
+        worker_direction_applied: record.worker_direction_applied,
+        slot_column_anchor_pane_id: record.slot_column_anchor_pane_id || null,
         command: record.command,
         worker_artifact_dir: input.workerArtifactDir,
         worker_result_path: input.resultPath,
@@ -241,7 +308,7 @@ export async function openWorkerPane(input) {
         patch_envelope_path: input.patchEnvelopePath,
         parent_child_transport: 'worker-result-json-and-heartbeat',
         persistent_slot_lane: false,
-        scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
+        scaling_primitive: record.scaling_primitive,
         blockers
     });
     return record;

package/dist/scripts/agent-real-codex-in-zellij-worker-pane-check.js

@@ -123,7 +123,7 @@ async function runRealGate({ sourceOk, eventProof }) {
 async function inspectRealLedger(ledgerRoot) {
     const swarm = await readJson(path.join(ledgerRoot, 'agent-native-cli-session-swarm.json'), null);
     const records = Array.isArray(swarm?.records) ? swarm.records : [];
-    const workerRecords = records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane');
+    const workerRecords = records.filter(isZellijCodexWorkerRecord);
     const eventsByWorker = [];
     for (const record of workerRecords) {
         const workerDir = String(record.worker_artifact_dir || '');
@@ -137,7 +137,7 @@ async function inspectRealLedger(ledgerRoot) {
     const blockers = [
         ...(swarm?.ok === true ? [] : ['real_codex_zellij_swarm_not_ok']),
         ...(workerRecords.length >= 1 ? [] : ['real_codex_zellij_worker_record_missing']),
-        ...(workerRecords.some((row) => row.pane_kind === 'worker_codex_sdk') ? [] : ['real_codex_zellij_worker_pane_kind_missing']),
+        ...(workerRecords.some((row) => row.pane_kind === 'worker_codex_sdk' || row.pane_kind === 'slot_status_renderer') ? [] : ['real_codex_zellij_worker_pane_kind_missing']),
         ...(workerRecords.every((row) => manager.isRealZellijWorkerPaneIdSource(row.zellij_pane_id_source)) ? [] : ['real_codex_zellij_pane_id_source_not_real']),
         ...(workerRecords.every((row) => row.zellij_pane_id) ? [] : ['real_codex_zellij_pane_id_missing']),
         ...(workerRecords.every((row) => row.sdk_thread_id) ? [] : ['real_codex_zellij_sdk_thread_missing']),
@@ -171,6 +171,12 @@ async function inspectRealLedger(ledgerRoot) {
         blockers
     };
 }
+function isZellijCodexWorkerRecord(row) {
+    return row?.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
+        || row?.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer'
+        || row?.pane_kind === 'worker_codex_sdk'
+        || row?.pane_kind === 'slot_status_renderer';
+}
 async function emit(report) {
     await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
     await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'agent-real-codex-in-zellij-worker-pane.json'), `${JSON.stringify(report, null, 2)}\n`);

package/dist/scripts/agent-slot-pane-binding-proof-check.js

@@ -14,10 +14,10 @@ const records = [1, 2, 3].map((index) => ({
     session_id: `slot-001-gen-${index}`,
     slot_id: 'slot-001',
     generation_index: index,
-    pane_kind: 'worker_codex_sdk',
+    pane_kind: index === 1 ? 'slot_status_renderer' : 'worker_codex_sdk',
     zellij_pane_id: String(100 + index),
     zellij_pane_id_source: index % 2 ? 'zellij_worker_new_pane_stdout' : 'zellij_worker_list_panes',
-    scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
+    scaling_primitive: index === 1 ? 'native_cli_process_with_zellij_slot_renderer' : 'native_cli_process_in_zellij_worker_pane',
     sdk_thread_id: `sdk-thread-${index}`,
     sdk_run_id: `sdk-run-${index}`,
     stream_event_count: 4,
@@ -35,9 +35,9 @@ await fs.writeFile(path.join(tmp, 'agent-native-cli-session-swarm.json'), `${JSO
 }, null, 2)}\n`);
 await fs.writeFile(path.join(tmp, 'agent-zellij-pane-launch-ledger.jsonl'), records.map((record) => JSON.stringify({
     schema: 'sks.agent-zellij-pane-launch.v1',
-    pane_kind: 'worker_codex_sdk',
+    pane_kind: record.pane_kind,
     persistent_slot_lane: false,
-    scaling_primitive: 'native_cli_process_in_zellij_worker_pane',
+    scaling_primitive: record.scaling_primitive,
     slot_id: record.slot_id,
     generation_index: record.generation_index,
     pane_id: record.zellij_pane_id,

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

@@ -3,10 +3,11 @@
 import { assertGate, emitGate, packageScripts, readText, releaseGateIds } from './lib/codex-sdk-gate-lib.js';
 const scripts = packageScripts();
 const releaseRealCheck = String(scripts['release:real-check'] || '');
+const releaseRealCheckSource = readText('src/scripts/release-real-check.ts');
 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(releaseRealCheck.includes('codex-sdk:real-smoke') || releaseRealCheckSource.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_gate_dag_contains_sdk: true });
 //# sourceMappingURL=codex-sdk-release-review-pipeline-check.js.map

package/dist/scripts/codex-sdk-zellij-pane-binding-check.js

@@ -7,7 +7,7 @@ const proofSource = readText('src/core/agents/agent-slot-pane-binding-proof.ts')
 const managerSource = readText('src/core/zellij/zellij-worker-pane-manager.ts');
 assertGate(fixture.proof.zellij_pane_id === 'pane-999', 'control proof must link zellij pane id', fixture.proof);
 assertGate(swarmSource.includes('codex_sdk_thread_started'), 'swarm must emit SDK thread event');
-assertGate(proofSource.includes('worker_codex_sdk'), 'slot-pane proof must require worker_codex_sdk pane kind');
-assertGate(managerSource.includes("pane_kind: 'worker_codex_sdk'"), 'worker pane manager must record worker_codex_sdk pane kind');
+assertGate(proofSource.includes('worker_codex_sdk') && proofSource.includes('slot_status_renderer'), 'slot-pane proof must accept worker command panes and compact slot renderer panes');
+assertGate(managerSource.includes('slot_status_renderer') && managerSource.includes('worker_codex_sdk'), 'worker pane manager must distinguish slot renderer and worker command pane kinds');
 emitGate('codex-sdk:zellij-pane-binding', { zellij_pane_id: fixture.proof.zellij_pane_id, sdk_thread_id: fixture.proof.sdk_thread_id });
 //# sourceMappingURL=codex-sdk-zellij-pane-binding-check.js.map

package/dist/scripts/git-worktree-checkpoint-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { checkpointWorkerWorktree } from '../core/git/git-worktree-checkpoint.js';
+import { runGitCommand } from '../core/git/git-worktree-runner.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-checkpoint-'));
+await runGitCommand(root, ['init']);
+await runGitCommand(root, ['config', 'user.email', 'sks@example.test']);
+await runGitCommand(root, ['config', 'user.name', 'SKS Test']);
+fs.writeFileSync(path.join(root, 'a.txt'), 'a\n');
+await runGitCommand(root, ['add', 'a.txt']);
+await runGitCommand(root, ['commit', '-m', 'base']);
+fs.writeFileSync(path.join(root, 'a.txt'), 'a2\n');
+fs.writeFileSync(path.join(root, 'b.txt'), 'b\n');
+const report = await checkpointWorkerWorktree({ worktreePath: root, repoRoot: root, workerId: 'W1', taskId: 'T1', mode: 'auto' });
+assertGate(report.ok && report.mode_applied === 'checkpoint-commit' && Boolean(report.commit_hash), 'Git worktree checkpoint must create checkpoint commits for multi-file changes', report);
+emitGate('git:worktree-checkpoint', report);
+//# sourceMappingURL=git-worktree-checkpoint-check.js.map

package/dist/scripts/git-worktree-cross-rebase-check.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { crossRebaseIdleWorktrees } from '../core/git/git-worktree-cross-rebase.js';
+import { runGitCommand, gitOutputLine } from '../core/git/git-worktree-runner.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-worktree-cross-rebase-'));
+await runGitCommand(root, ['init']);
+await runGitCommand(root, ['config', 'user.email', 'sks@example.test']);
+await runGitCommand(root, ['config', 'user.name', 'SKS Test']);
+fs.writeFileSync(path.join(root, 'base.txt'), 'base\n');
+await runGitCommand(root, ['add', 'base.txt']);
+await runGitCommand(root, ['commit', '-m', 'base']);
+const workerPath = path.join(root, '..', `worker-${process.pid}`);
+const dirtyWorkerPath = path.join(root, '..', `worker-dirty-${process.pid}`);
+const runningWorkerPath = path.join(root, '..', `worker-running-${process.pid}`);
+await runGitCommand(root, ['worktree', 'add', workerPath, 'HEAD']);
+await runGitCommand(root, ['worktree', 'add', dirtyWorkerPath, 'HEAD']);
+await runGitCommand(root, ['worktree', 'add', runningWorkerPath, 'HEAD']);
+fs.writeFileSync(path.join(dirtyWorkerPath, 'dirty.txt'), 'dirty\n');
+fs.writeFileSync(path.join(root, 'integration.txt'), 'integration\n');
+await runGitCommand(root, ['add', 'integration.txt']);
+await runGitCommand(root, ['commit', '-m', 'integration']);
+const head = gitOutputLine(await runGitCommand(root, ['rev-parse', 'HEAD']));
+const report = await crossRebaseIdleWorktrees({
+    integrationHead: head,
+    workers: [
+        { worker_id: 'W1', worktree_path: workerPath, state: 'idle' },
+        { worker_id: 'W-dirty', worktree_path: dirtyWorkerPath, state: 'idle' },
+        { worker_id: 'W-running', worktree_path: runningWorkerPath, state: 'running' }
+    ]
+});
+assertGate(report.ok && report.applied_count === 1, 'Idle worktrees must cross-rebase to the integration head', report);
+assertGate(report.skipped_count === 2, 'Dirty and running worktrees must be skipped during cross-rebase', report);
+assertGate(report.records.some((row) => row.worker_id === 'W-dirty' && row.status === 'skipped' && row.reason === 'dirty_worktree_skipped'), 'Dirty worktree must skip cross-rebase', report);
+assertGate(report.records.some((row) => row.worker_id === 'W-running' && row.status === 'skipped' && row.reason === 'worker_not_idle'), 'Running worktree must skip cross-rebase', report);
+emitGate('git:worktree-cross-rebase', report);
+//# sourceMappingURL=git-worktree-cross-rebase-check.js.map

package/dist/scripts/git-worktree-merge-queue-check.js

@@ -20,6 +20,7 @@ const diffB = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktree
 const integration = await integrationMod.createGitIntegrationWorktree({ repoRoot: repo, missionId: 'M-merge' });
 const report = await queueMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diffA, diffB] });
 assertGate(report.ok === true && report.applied_count === 2, 'merge queue must apply non-conflicting worktree diffs', report);
+assertGate((report.strategy_results || []).every((row) => row.strategy === 'diff-apply-3way'), 'merge queue must record the diff apply strategy for worktree diffs', report.strategy_results || []);
 assertGate(fs.readFileSync(path.join(integration.worktree_path, 'a.txt'), 'utf8').includes('from-a'), 'integration worktree must include first diff');
 assertGate(fs.readFileSync(path.join(integration.worktree_path, 'b.txt'), 'utf8').includes('from-b'), 'integration worktree must include second diff');
 assertGate(fs.readFileSync(path.join(repo, 'a.txt'), 'utf8') === 'alpha\n', 'main worktree must remain unchanged before integration commit');

package/dist/scripts/local-collab-worktree-gpt-final-apply-policy-check.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { gptFinalRequiredForPipeline } from '../core/pipeline/gpt-final-required.js';
+import { finalizePipelineResult } from '../core/pipeline/finalize-pipeline-result.js';
+import { selectFinalGptPatchSource } from '../core/pipeline/final-gpt-patch-stage.js';
+const worktreeEnvelope = {
+    schema: 'sks.agent-patch-envelope.v1',
+    source: 'git-worktree-diff',
+    git_worktree: {
+        worktree_path: '/tmp/sks-worker',
+        changed_files: ['src/core/example.ts']
+    },
+    operations: [{ op: 'git_apply_patch', path: '.', diff: 'diff --git a/src/core/example.ts b/src/core/example.ts\n' }]
+};
+const requirement = gptFinalRequiredForPipeline({
+    localParticipated: false,
+    candidateResults: [{ backend: 'codex-sdk', patch_envelopes: [worktreeEnvelope] }],
+    candidatePatchEnvelopes: [worktreeEnvelope]
+});
+const blocked = await finalizePipelineResult({
+    route: '$Naruto',
+    missionId: 'M-worktree-gpt-final-policy',
+    localParticipated: false,
+    candidateResults: [{ backend: 'codex-sdk', patch_envelopes: [worktreeEnvelope] }],
+    candidatePatchEnvelopes: [worktreeEnvelope],
+    verificationResults: [],
+    sideEffectReport: {},
+    mutationLedger: {},
+    rollbackPlan: {},
+    applyPatches: true,
+    forceGptFinalUnavailable: true
+});
+const modified = selectFinalGptPatchSource({
+    result: {
+        status: 'modified',
+        modified_patch_envelopes: [{ ...worktreeEnvelope, source: 'model_authored', operations: [{ op: 'replace', path: 'src/core/example.ts', search: 'old', replace: 'new' }] }]
+    }
+}, [worktreeEnvelope]);
+const rejected = selectFinalGptPatchSource({ result: { status: 'rejected' } }, [worktreeEnvelope]);
+const ok = requirement.gpt_final_required === true
+    && requirement.worktree_participated === true
+    && blocked.ok === false
+    && blocked.apply_allowed === false
+    && blocked.blockers.includes('gpt_final_arbiter_required_not_passed')
+    && modified.ok === true
+    && modified.final_patch_source === 'gpt_final_arbiter'
+    && modified.patch_envelopes[0]?.source === 'model_authored'
+    && rejected.ok === false
+    && rejected.final_patch_source === 'blocked';
+assertGate(ok, 'Worktree/local candidate output must require GPT Final before apply, and GPT modified/rejected decisions must control final patch source', {
+    requirement,
+    blocked,
+    modified,
+    rejected
+});
+emitGate('local-collab:worktree-gpt-final-apply-policy', {
+    requirement,
+    blocked_apply_allowed: blocked.apply_allowed,
+    modified_source: modified.final_patch_source,
+    rejected_source: rejected.final_patch_source
+});
+//# sourceMappingURL=local-collab-worktree-gpt-final-apply-policy-check.js.map