sneakoscope 2.0.11 → 2.0.13

package/dist/core/version.js

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

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

@@ -5,18 +5,34 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const visible = Math.max(1, nonNegativeInt(input.visiblePaneCap, active || 1));
     const headless = nonNegativeInt(input.headlessWorkers, 0);
     const queue = nonNegativeInt(input.queueDepth, 0);
-    return `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+    const header = `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}`;
+    const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
+    if (!workers.length)
+        return `${header}\nvisible slot panes stack below this anchor`;
+    const maxRows = Math.max(1, nonNegativeInt(input.maxWorkerRows, input.mode === 'full-debug' ? 24 : 12));
+    const overflowRows = workers.filter((row) => row.placement === 'headless').slice(0, maxRows);
+    const visibleRows = overflowRows.length ? overflowRows : workers.filter((row) => row.placement !== 'zellij-pane').slice(0, maxRows);
+    const hidden = Math.max(0, workers.length - visibleRows.length);
+    return [
+        header,
+        `visible slot panes stack below this anchor`,
+        ...visibleRows.map((row, index) => renderWorkerRow(row, index + 1)),
+        ...(hidden && visibleRows.length ? [`+${hidden} worker${hidden === 1 ? '' : 's'} in dedicated panes or overflow`] : [])
+    ].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 activeWorkers = Number(snapshot?.active_workers ?? rightColumn?.visible_worker_panes?.filter((row) => row?.status === 'running' || row?.status === 'launching').length ?? 0);
+    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 ?? rightColumn?.headless_workers?.filter((row) => !row?.status || row?.status === 'running').length ?? 0);
+    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 };
+    const anchorInput = { activeWorkers, visiblePaneCap, headlessWorkers, queueDepth, workerRows };
     if (input.mode !== undefined)
         anchorInput.mode = input.mode;
     return renderZellijSlotColumnAnchor(anchorInput);
@@ -47,12 +63,157 @@ async function readJson(file) {
         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, `'\\''`)}'`;
 }

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

@@ -2,40 +2,121 @@ 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 maxLines = mode === 'compact-slots' ? 17 : mode === 'dashboard-plus-slots' ? 20 : 32;
+    const task = trimInline(input.currentTask || input.currentFile || 'waiting for worker intake', 78);
     const heartbeat = input.heartbeatAgeMs == null
         ? 'unknown'
         : input.heartbeatAgeMs < 1000
             ? 'now'
             : `${Math.max(1, Math.round(input.heartbeatAgeMs / 1000))}s ago`;
+    const files = firstNonEmptyList(input.changedFiles, input.patchFiles, input.plannedFiles, input.currentFile ? [input.currentFile] : []);
+    const events = (input.eventLines || []).filter(Boolean).slice(-3);
+    const stdout = (input.stdoutTail || []).filter(Boolean).slice(-2);
+    const stderr = (input.stderrTail || []).filter(Boolean).slice(-1);
     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');
+        `slot: ${input.slotId} / gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))} / ${trimInline(input.status || 'running', 18)}`,
+        `role: ${trimInline(input.role || 'worker', 18)}  backend: ${trimInline(input.backend || 'codex-sdk', 20)}  worktree: ${trimInline(input.worktreeId || '-', 18)}`,
+        `runtime: fast ${formatFastMode(input.fastMode, input.serviceTier)}  tier: ${trimInline(input.serviceTier || 'unknown', 12)}  provider: ${trimInline(input.provider || 'unknown', 18)}`,
+        `model: ${trimInline(input.model || 'unknown', 28)}  reasoning: ${trimInline(input.reasoningEffort || 'unknown', 16)}${input.authMode ? `  auth: ${trimInline(input.authMode, 14)}` : ''}`,
+        input.sessionId ? `session: ${trimInline(input.sessionId, 62)}` : null,
+        `heartbeat: ${heartbeat}${input.heartbeatEvent ? `  event: ${trimInline(input.heartbeatEvent, 40)}` : ''}`,
+        `doing: ${task}`,
+        `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
+        `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
+        ...events.map((event) => `event: ${trimInline(event, 78)}`),
+        ...stdout.map((line) => `out: ${trimInline(line, 79)}`),
+        ...stderr.map((line) => `err: ${trimInline(line, 79)}`)
+    ].filter((row) => Boolean(row));
+    return frameSlotPane(`LIVE SLOT ${input.slotId}`, rows.slice(0, Math.max(1, maxLines - 2)));
 }
 export async function renderZellijSlotPaneFromArtifacts(input) {
     const artifactDir = path.resolve(input.artifactDir);
     const result = await readJson(path.join(artifactDir, 'worker-result.json'));
+    const intake = await readJson(path.join(artifactDir, 'worker-intake.json'));
+    const backendReport = await readJson(path.join(artifactDir, 'worker-backend-router-report.json'));
+    const fastReport = await readJson(path.join(artifactDir, 'worker-fast-mode.json'));
+    const paneReport = await readJson(path.join(artifactDir, 'zellij-worker-pane.json'));
+    const codexProof = await readJson(path.join(artifactDir, 'codex-control-proof.json'));
+    const localProof = await readJson(path.join(artifactDir, 'local-llm-proof.json'));
+    const patch = await firstJson([
+        path.join(artifactDir, 'worker-patch-envelope.json'),
+        path.join(artifactDir, 'codex-sdk-patch-envelope.json'),
+        path.join(artifactDir, 'python-codex-sdk-patch-envelope.json'),
+        path.join(artifactDir, 'local-llm-patch-envelope.json')
+    ]);
     const heartbeatPath = path.join(artifactDir, 'worker-heartbeat.jsonl');
     const heartbeatMtime = await statMtimeMs(heartbeatPath);
+    const heartbeatRows = await readJsonlTail(heartbeatPath, 2);
+    const eventRows = await readJsonlTails([
+        path.join(artifactDir, 'codex-sdk-events.jsonl'),
+        path.join(artifactDir, 'python-codex-sdk-events.jsonl'),
+        path.join(artifactDir, 'local-llm-events.jsonl'),
+        path.join(artifactDir, 'zellij-worker-pane-events.jsonl')
+    ], 6);
+    const patchFiles = patchPaths(patch || result);
+    const changedFiles = normalizeList(result?.changed_files);
+    const plannedFiles = normalizeList([
+        ...(Array.isArray(intake?.slice?.write_paths) ? intake.slice.write_paths : []),
+        ...(Array.isArray(intake?.slice?.readonly_paths) ? intake.slice.readonly_paths : []),
+        ...(Array.isArray(intake?.input_files) ? intake.input_files : [])
+    ]);
     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',
+        sessionId: result?.session_id || intake?.agent?.session_id || backendReport?.session_id || null,
+        role: input.role || result?.persona_id || intake?.agent?.naruto_role || intake?.agent?.role || intake?.agent?.persona_id || result?.agent_id || null,
+        backend: input.backend || result?.backend || backendReport?.selected_backend || intake?.backend || null,
+        status: result?.status || statusFromEvents(eventRows) || (heartbeatMtime ? 'running' : 'launching'),
+        fastMode: firstDefined(fastReport?.fast_mode, backendReport?.fast_mode, result?.fast_mode, intake?.fast_mode),
+        serviceTier: firstText([
+            fastReport?.service_tier,
+            paneReport?.service_tier,
+            backendReport?.service_tier,
+            codexProof?.config?.service_tier,
+            result?.service_tier,
+            intake?.service_tier
+        ]),
+        provider: firstText([
+            paneReport?.provider_context?.provider,
+            paneReport?.provider,
+            codexProof?.config?.model_provider,
+            localProof?.provider
+        ]),
+        authMode: firstText([
+            paneReport?.provider_context?.auth_mode,
+            codexProof?.config?.model_provider ? 'api_key' : null
+        ]),
+        model: firstText([
+            codexProof?.config?.model,
+            localProof?.model,
+            intake?.ollama_model,
+            intake?.local_model_model
+        ]),
+        reasoningEffort: firstText([
+            codexProof?.config?.model_reasoning_effort,
+            intake?.agent?.model_reasoning_effort,
+            intake?.agent?.reasoning_effort
+        ]),
+        currentTask: firstText([
+            result?.summary,
+            intake?.slice?.description,
+            intake?.slice?.title,
+            intake?.slice?.id,
+            lastEventLine(eventRows)
+        ]),
+        currentFile: changedFiles[0] || patchFiles[0] || plannedFiles[0] || null,
+        changedFiles,
+        plannedFiles,
+        patchFiles,
+        patchStatus: patchStatus(result, patch, patchFiles),
         verifyStatus: result?.verification?.status || 'queued',
         heartbeatAgeMs: heartbeatMtime ? now - heartbeatMtime : null,
-        worktreeId: result?.worktree?.id || null,
+        heartbeatEvent: heartbeatRows.length ? formatArtifactEvent(heartbeatRows[heartbeatRows.length - 1]) : null,
+        worktreeId: result?.worktree?.id || intake?.worktree?.id || null,
+        eventLines: eventRows.map(formatArtifactEvent).filter(Boolean),
+        stdoutTail: await readTextTailLines(path.join(artifactDir, 'worker.stdout.log'), 2),
+        stderrTail: await readTextTailLines(path.join(artifactDir, 'worker.stderr.log'), 1),
         mode: input.mode || 'compact-slots'
     });
 }
@@ -62,6 +143,14 @@ async function readJson(file) {
         return null;
     }
 }
+async function firstJson(files) {
+    for (const file of files) {
+        const value = await readJson(file);
+        if (value)
+            return value;
+    }
+    return null;
+}
 async function statMtimeMs(file) {
     try {
         return (await fs.promises.stat(file)).mtimeMs;
@@ -70,12 +159,166 @@ async function statMtimeMs(file) {
         return null;
     }
 }
+async function readJsonlTails(files, max) {
+    const rows = [];
+    for (const file of files)
+        rows.push(...await readJsonlTail(file, max));
+    return rows
+        .sort((a, b) => timestampMs(a) - timestampMs(b))
+        .slice(-max);
+}
+async function readJsonlTail(file, max) {
+    try {
+        const lines = (await fs.promises.readFile(file, 'utf8')).split(/\r?\n/).filter((line) => line.trim());
+        return lines.slice(-Math.max(1, max)).map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return { message: line };
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function readTextTailLines(file, max) {
+    try {
+        const lines = (await fs.promises.readFile(file, 'utf8')).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return lines.slice(-Math.max(1, max));
+    }
+    catch {
+        return [];
+    }
+}
+function patchStatus(result, patch, files) {
+    const resultCount = Array.isArray(result?.patch_envelopes) ? result.patch_envelopes.length : 0;
+    const patchCount = Number(patch?.envelope_count || (Array.isArray(patch?.envelopes) ? patch.envelopes.length : 0));
+    const count = Math.max(resultCount, Number.isFinite(patchCount) ? patchCount : 0);
+    if (count > 0)
+        return `candidate (${count})`;
+    if (files.length)
+        return 'candidate';
+    return 'queued';
+}
+function patchPaths(value) {
+    const envelopes = [
+        ...(Array.isArray(value?.envelopes) ? value.envelopes : []),
+        ...(Array.isArray(value?.patch_envelopes) ? value.patch_envelopes : [])
+    ];
+    return normalizeList(envelopes.flatMap((envelope) => {
+        const paths = [
+            ...(Array.isArray(envelope?.operations) ? envelope.operations.map((operation) => operation?.path) : []),
+            ...(Array.isArray(envelope?.allowed_paths) ? envelope.allowed_paths : [])
+        ];
+        return paths;
+    }));
+}
+function statusFromEvents(rows) {
+    const last = rows[rows.length - 1];
+    const status = String(last?.lane_status || last?.status || '').trim();
+    if (status)
+        return status;
+    const type = String(last?.event_type || last?.type || '').trim();
+    if (/failed|blocked/i.test(type))
+        return 'blocked';
+    if (/completed|finished|closed/i.test(type))
+        return 'done';
+    if (type)
+        return 'running';
+    return null;
+}
+function lastEventLine(rows) {
+    for (const row of [...rows].reverse()) {
+        const text = formatArtifactEvent(row);
+        if (text)
+            return text;
+    }
+    return null;
+}
+function formatArtifactEvent(row) {
+    if (!row)
+        return '';
+    const status = trimInline(row.lane_status || row.status || row.event || row.event_type || row.type || row.sdk_event_type || 'event', 18);
+    const detail = firstText([
+        row.current_tool && row.current_file ? `tool ${row.current_tool} file ${row.current_file}` : null,
+        row.current_file ? `file ${row.current_file}` : null,
+        row.current_tool ? `tool ${row.current_tool}` : null,
+        row.message_tail,
+        row.blocker ? `blocker ${row.blocker}` : null,
+        row.request_id,
+        row.pane_id ? `pane ${row.pane_id}` : null,
+        row.message,
+        row.reason
+    ]);
+    return trimInline(detail ? `${status}: ${detail}` : status, 96);
+}
+function timestampMs(row) {
+    const raw = row?.ts || row?.generated_at || row?.updated_at || row?.created_at;
+    const parsed = raw ? Date.parse(String(raw)) : NaN;
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function firstText(values) {
+    for (const value of values) {
+        const text = String(value || '').replace(/\s+/g, ' ').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
+function firstDefined(...values) {
+    for (const value of values) {
+        if (value === true || value === false)
+            return value;
+        if (typeof value === 'string' && value.trim())
+            return value;
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+    }
+    return null;
+}
+function firstNonEmptyList(...values) {
+    for (const value of values) {
+        const normalized = normalizeList(value || []);
+        if (normalized.length)
+            return normalized;
+    }
+    return [];
+}
+function normalizeList(values) {
+    return [...new Set((Array.isArray(values) ? values : [values]).map((value) => String(value || '').trim()).filter(Boolean))];
+}
 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 formatFastMode(value, serviceTier) {
+    const text = String(value ?? '').trim().toLowerCase();
+    if (value === true || text === 'true' || text === '1' || text === 'on' || text === 'fast')
+        return 'on';
+    if (value === false || text === 'false' || text === '0' || text === 'off' || text === 'standard')
+        return 'off';
+    const tier = String(serviceTier || '').trim().toLowerCase();
+    if (tier === 'fast' || tier === 'priority')
+        return 'on';
+    if (tier === 'standard' || tier === 'default')
+        return 'off';
+    return 'unknown';
+}
+function frameSlotPane(title, rows) {
+    const width = Math.min(96, Math.max(44, title.length + 6, ...rows.map((row) => row.length + 4)));
+    const line = '+' + '-'.repeat(width - 2) + '+';
+    const label = ` ${trimInline(title, width - 4)} `;
+    const titleLine = '|' + label.padEnd(width - 2, ' ') + '|';
+    const body = rows.map((row) => {
+        const text = ` ${trimInline(row, width - 4)} `;
+        return '|' + text.padEnd(width - 2, ' ') + '|';
+    });
+    return [line, titleLine, line, ...body, line].join('\n');
+}
 function shellQuote(value) {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }

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

@@ -26,7 +26,13 @@ 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 directionRequested = input.directionRequested || 'right';
+    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,
@@ -41,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,
@@ -55,8 +61,8 @@ 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,
@@ -182,7 +188,7 @@ export async function openWorkerPane(input) {
         }
     }
     const focusPaneId = rightColumn?.focusPaneId || slotColumnAnchorPaneId || null;
-    const directionRequested = rightColumn ? 'down' : 'right';
+    const directionRequested = 'down';
     const focus = focusPaneId
         ? await focusZellijPaneById(input.sessionName, focusPaneId, cwd)
         : null;
@@ -282,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,
@@ -302,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