sneakoscope 2.0.8 → 2.0.10

package/dist/core/agents/native-cli-session-swarm.js

@@ -5,7 +5,10 @@ import { appendJsonl, ensureDir, exists, nowIso, packageRoot, readJson, writeJso
 import { fastModeEnv } from './fast-mode-policy.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { closeWorkerPane, openWorkerPane } from '../zellij/zellij-worker-pane-manager.js';
+import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
+import { buildZellijSlotPaneCommand } from '../zellij/zellij-slot-pane-renderer.js';
+import { resolveZellijUiMode } from '../zellij/zellij-ui-mode.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
     return new NativeCliSessionSwarmRecorder(root, input);
@@ -18,6 +21,7 @@ class NativeCliSessionSwarmRecorder {
     maxObserved = 0;
     writeLock = Promise.resolve();
     nextPaneToken = -1;
+    visibleZellijReservations = new Set();
     constructor(root, input) {
         this.root = root;
         this.input = input;
@@ -102,9 +106,12 @@ class NativeCliSessionSwarmRecorder {
         const stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
         const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
         const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
-        const useZellijPane = placement === 'zellij-pane'
+        const zellijReservation = placement === 'zellij-pane'
             && ctx.opts.zellijPaneWorker !== false
-            && (ctx.opts.zellijSessionName || this.input.missionId);
+            && (ctx.opts.zellijSessionName || this.input.missionId)
+            ? this.reserveVisibleZellijPane(ctx.opts, String(ctx.agent.session_id || ctx.agent.id || `${Date.now()}:${Math.random()}`))
+            : null;
+        const useZellijPane = Boolean(zellijReservation);
         if (useZellijPane) {
             stdout.end();
             stderr.end();
@@ -116,9 +123,26 @@ class NativeCliSessionSwarmRecorder {
                 stdoutRel,
                 stderrRel,
                 heartbeatRel,
-                workerDirRel
+                workerDirRel,
+                zellijReservation
             });
         }
+        if (placement === 'zellij-pane' && ctx.opts.zellijPaneWorker !== false && !useZellijPane) {
+            record.worker_placement = 'headless';
+            record.headless_reason = `visible_pane_cap:${this.zellijVisiblePaneCap(ctx.opts)}`;
+            await recordHeadlessWorkerInRightColumn({
+                root: this.root,
+                projectRoot: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd,
+                missionId: this.input.missionId,
+                sessionName: String(ctx.opts.zellijSessionName || (this.input.missionId ? `sks-${this.input.missionId}` : 'sks-agent-runtime')),
+                slotId: String(ctx.agent.slot_id || ctx.agent.id || 'slot-001'),
+                generationIndex: Number(ctx.agent.generation_index || 1),
+                reason: record.headless_reason
+            }).catch(() => null);
+        }
+        else {
+            record.worker_placement = placement === 'zellij-pane' ? 'zellij-pane' : 'process';
+        }
         const child = spawn(process.execPath, args, {
             cwd: workerCwd,
             env: {
@@ -156,6 +180,17 @@ class NativeCliSessionSwarmRecorder {
         record.exit_code = exit.code;
         record.signal = exit.signal;
         record.status = exit.code === 0 ? 'closed' : 'failed';
+        if (record.worker_placement === 'headless') {
+            await closeWorkerInRightColumn({
+                root: this.root,
+                projectRoot: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd,
+                missionId: this.input.missionId,
+                slotId: String(ctx.agent.slot_id || ctx.agent.id || 'slot-001'),
+                generationIndex: Number(ctx.agent.generation_index || 1),
+                paneId: null,
+                status: record.status === 'closed' ? 'closed' : 'failed'
+            }).catch(() => null);
+        }
         const parsed = await readJson(path.join(this.root, resultRel), null).catch(() => null);
         if (!parsed) {
             record.blockers = ['native_cli_worker_result_missing'];
@@ -194,54 +229,107 @@ class NativeCliSessionSwarmRecorder {
         const activeToken = this.nextPaneToken--;
         this.active.add(activeToken);
         this.maxObserved = Math.max(this.maxObserved, this.active.size);
-        const workerCommand = buildPaneWorkerCommand({
-            args: input.args,
-            stdoutPath: path.join(this.root, input.stdoutRel),
-            stderrPath: path.join(this.root, input.stderrRel),
-            heartbeatPath: path.join(this.root, input.heartbeatRel),
-            env: {
-                ...(input.ctx.opts.env || {}),
-                ...fastModeEnv(this.input.fastModePolicy),
-                SKS_AGENT_WORKER: '1',
-                SKS_PIPELINE_MODE: 'agent-worker',
-                SKS_DISABLE_ROUTE_RECURSION: '1',
-                SKS_PARENT_MISSION_ID: this.input.missionId,
-                SKS_AGENT_SESSION_ID: String(input.ctx.agent.session_id || ''),
-                SKS_AGENT_SLOT_ID: slotId,
-                SKS_AGENT_GENERATION_INDEX: String(input.ctx.agent.generation_index || 1),
-                ...(input.ctx.opts.ollamaModel ? { SKS_OLLAMA_MODEL: String(input.ctx.opts.ollamaModel) } : {}),
-                ...(input.ctx.opts.ollamaBaseUrl ? { SKS_OLLAMA_BASE_URL: String(input.ctx.opts.ollamaBaseUrl) } : {}),
-                SKS_ZELLIJ_WORKER_PANE: '1',
-                SKS_ZELLIJ_SESSION_NAME: sessionName
-            }
-        });
         const providerContext = await resolveProviderContext({
             root: this.root,
             route: this.input.route,
             serviceTier: this.input.fastModePolicy.service_tier
         });
-        let paneRecord = await openWorkerPane({
-            root: this.root,
-            missionId: this.input.missionId,
-            sessionName,
-            slotId,
-            generationIndex: Number(input.ctx.agent.generation_index || 1),
-            sessionId: String(input.ctx.agent.session_id || ''),
-            workerArtifactDir: input.workerDirRel,
-            workerCommand,
-            resultPath: input.resultRel,
-            heartbeatPath: input.heartbeatRel,
-            patchEnvelopePath: input.record.patch_envelope_path,
-            stdoutLog: input.stdoutRel,
-            stderrLog: input.stderrRel,
-            cwd: workerCwd,
-            providerContext,
-            serviceTier: this.input.fastModePolicy.service_tier,
-            worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
-            backend: this.input.backend
-        });
+        const uiMode = resolveZellijUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const workerEnv = {
+            ...(input.ctx.opts.env || {}),
+            ...fastModeEnv(this.input.fastModePolicy),
+            SKS_AGENT_WORKER: '1',
+            SKS_PIPELINE_MODE: 'agent-worker',
+            SKS_DISABLE_ROUTE_RECURSION: '1',
+            SKS_PARENT_MISSION_ID: this.input.missionId,
+            SKS_AGENT_SESSION_ID: String(input.ctx.agent.session_id || ''),
+            SKS_AGENT_SLOT_ID: slotId,
+            SKS_AGENT_GENERATION_INDEX: String(input.ctx.agent.generation_index || 1),
+            ...(input.ctx.opts.ollamaModel ? { SKS_OLLAMA_MODEL: String(input.ctx.opts.ollamaModel) } : {}),
+            ...(input.ctx.opts.ollamaBaseUrl ? { SKS_OLLAMA_BASE_URL: String(input.ctx.opts.ollamaBaseUrl) } : {}),
+            SKS_ZELLIJ_SESSION_NAME: sessionName
+        };
+        const role = String(input.ctx.agent.naruto_role || input.ctx.agent.role || input.ctx.agent.persona_id || 'worker');
+        const workerCommand = uiMode === 'full-debug'
+            ? buildPaneWorkerCommand({
+                args: input.args,
+                stdoutPath: path.join(this.root, input.stdoutRel),
+                stderrPath: path.join(this.root, input.stderrRel),
+                heartbeatPath: path.join(this.root, input.heartbeatRel),
+                header: buildPaneWorkerHeader({
+                    slotId,
+                    generationIndex: Number(input.ctx.agent.generation_index || 1),
+                    role,
+                    backend: this.input.backend,
+                    provider: providerContext.provider,
+                    serviceTier: this.input.fastModePolicy.service_tier,
+                    worktree,
+                    task: input.ctx.slice?.description || input.ctx.slice?.title || input.ctx.slice?.id || ''
+                }),
+                env: {
+                    ...workerEnv,
+                    SKS_ZELLIJ_WORKER_PANE: '1'
+                }
+            })
+            : buildZellijSlotPaneCommand({
+                cliPath: String(input.args[0] || ''),
+                missionId: this.input.missionId,
+                slotId,
+                generationIndex: Number(input.ctx.agent.generation_index || 1),
+                artifactDir: path.join(this.root, input.workerDirRel),
+                backend: this.input.backend,
+                role,
+                mode: uiMode,
+                watch: true
+            });
+        let paneRecord;
+        try {
+            paneRecord = await openWorkerPane({
+                root: this.root,
+                missionId: this.input.missionId,
+                sessionName,
+                slotId,
+                generationIndex: Number(input.ctx.agent.generation_index || 1),
+                sessionId: String(input.ctx.agent.session_id || ''),
+                workerArtifactDir: input.workerDirRel,
+                workerCommand,
+                resultPath: input.resultRel,
+                heartbeatPath: input.heartbeatRel,
+                patchEnvelopePath: input.record.patch_envelope_path,
+                stdoutLog: input.stdoutRel,
+                stderrLog: input.stderrRel,
+                cwd: workerCwd,
+                providerContext,
+                serviceTier: this.input.fastModePolicy.service_tier,
+                worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
+                backend: this.input.backend,
+                uiMode,
+                projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
+                rightColumnMode: 'spawn-on-first-worker',
+                visiblePaneCap: this.zellijVisiblePaneCap(input.ctx.opts),
+                dashboardSnapshot: {
+                    mode: this.input.route || '$Agent',
+                    backend_counts: { [this.input.backend]: this.input.targetActiveSlots },
+                    placement_counts: {
+                        'zellij-pane': this.zellijVisiblePaneCap(input.ctx.opts),
+                        headless: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts))
+                    },
+                    active_workers: this.input.targetActiveSlots,
+                    visible_panes: this.zellijVisiblePaneCap(input.ctx.opts),
+                    headless_workers: Math.max(0, this.input.targetActiveSlots - this.zellijVisiblePaneCap(input.ctx.opts)),
+                    queue_depth: Math.max(0, this.input.requestedAgents - this.input.targetActiveSlots),
+                    local_llm: { tps: 0, queue: 0 },
+                    gpt_final_status: 'pending',
+                    gate_progress: 'worker-spawn'
+                }
+            });
+        }
+        finally {
+            if (input.zellijReservation)
+                this.releaseVisibleZellijReservation(input.zellijReservation);
+        }
         const launchBlockers = paneRecord.blockers || [];
-        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', '<native-cli-worker-command>'];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
         input.record.zellij_pane_id_source = paneRecord.pane_id_source;
@@ -254,6 +342,8 @@ class NativeCliSessionSwarmRecorder {
         input.record.service_tier = paneRecord.service_tier;
         input.record.provider_context = paneRecord.provider_context;
         input.record.worktree = worktree;
+        input.record.zellij_ui_mode = uiMode;
+        input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
         await this.record(input.record);
@@ -279,6 +369,20 @@ class NativeCliSessionSwarmRecorder {
                 goal_mode_ref: input.ctx.agent.goal_mode_ref || null
             });
         }
+        const processRun = uiMode === 'full-debug'
+            ? null
+            : await this.spawnCompactSlotWorkerProcess({
+                args: input.args,
+                cwd: workerCwd,
+                env: workerEnv,
+                stdoutRel: input.stdoutRel,
+                stderrRel: input.stderrRel
+            });
+        if (processRun?.pid) {
+            input.record.pid = processRun.pid;
+            input.record.process_id = processRun.pid;
+            await this.record(input.record);
+        }
         await waitForWorkerHeartbeat(path.join(this.root, input.heartbeatRel), Number(process.env.SKS_ZELLIJ_WORKER_HEARTBEAT_TIMEOUT_MS || 30000));
         await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
             schema: 'sks.zellij-worker-pane-event.v1',
@@ -291,6 +395,7 @@ class NativeCliSessionSwarmRecorder {
             worker_artifact_dir: input.workerDirRel
         });
         const parsed = await waitForWorkerResult(path.join(this.root, input.resultRel), Number(process.env.SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS || 120000));
+        const compactExit = processRun ? await processRun.wait(parsed ? 10000 : 1000) : null;
         this.active.delete(activeToken);
         input.record.closed_at = nowIso();
         const workerProcessReport = await readJson(path.join(this.root, input.workerDirRel, 'worker-process-report.json'), null).catch(() => null);
@@ -322,8 +427,10 @@ class NativeCliSessionSwarmRecorder {
                 result_path: input.resultRel
             });
         }
-        input.record.pid = Number(workerProcessReport?.pid) || null;
+        input.record.pid = Number(workerProcessReport?.pid || processRun?.pid) || null;
         input.record.process_id = input.record.pid;
+        input.record.compact_worker_exit_code = compactExit?.code ?? null;
+        input.record.compact_worker_signal = compactExit?.signal ?? null;
         input.record.sdk_thread_id = sdkThreadId;
         input.record.sdk_run_id = sdkRunId;
         input.record.stream_event_count = Number(workerProcessReport?.stream_event_count || workerProcessReport?.backend_router_report?.stream_event_count || 0);
@@ -339,6 +446,7 @@ class NativeCliSessionSwarmRecorder {
             root: this.root,
             paneRecord,
             cwd: workerCwd,
+            projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
             status: input.record.status === 'closed' ? 'closed' : 'failed',
             blockers: input.record.blockers,
             sdkThreadId,
@@ -409,6 +517,8 @@ class NativeCliSessionSwarmRecorder {
             closed_worker_process_count: closed.length,
             max_observed_worker_process_count: this.maxObserved,
             active_worker_process_count: this.active.size,
+            visible_zellij_pane_cap: this.input.zellijVisiblePaneCap || null,
+            headless_overflow_worker_count: this.records.filter((row) => row.worker_placement === 'headless').length,
             unique_worker_session_count: new Set(this.records.map((row) => row.session_id).filter(Boolean)).size,
             unique_slot_count: new Set(this.records.map((row) => row.slot_id).filter(Boolean)).size,
             unique_generation_count: new Set(this.records.map((row) => `${row.slot_id}:${row.generation_index}`).filter(Boolean)).size,
@@ -423,17 +533,75 @@ class NativeCliSessionSwarmRecorder {
             blockers: this.records.flatMap((row) => row.blockers || [])
         };
     }
+    zellijVisiblePaneCap(opts = {}) {
+        const raw = Number(opts.zellijVisiblePaneCap || this.input.zellijVisiblePaneCap || this.input.targetActiveSlots || 1);
+        return Math.max(1, Math.floor(Number.isFinite(raw) ? raw : 1));
+    }
+    visibleZellijPaneCount() {
+        return this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane' && (row.status === 'launching' || row.status === 'running')).length;
+    }
+    reserveVisibleZellijPane(opts = {}, token) {
+        const cap = this.zellijVisiblePaneCap(opts);
+        if (this.visibleZellijPaneCount() + this.visibleZellijReservations.size >= cap)
+            return null;
+        this.visibleZellijReservations.add(token);
+        return token;
+    }
+    releaseVisibleZellijReservation(token) {
+        this.visibleZellijReservations.delete(token);
+    }
+    async spawnCompactSlotWorkerProcess(input) {
+        const stdout = fs.createWriteStream(path.join(this.root, input.stdoutRel), { flags: 'a' });
+        const stderr = fs.createWriteStream(path.join(this.root, input.stderrRel), { flags: 'a' });
+        const child = spawn(process.execPath, input.args, {
+            cwd: input.cwd,
+            env: {
+                ...process.env,
+                ...Object.fromEntries(Object.entries(input.env).filter(([, value]) => value != null).map(([key, value]) => [key, String(value)]))
+            },
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        child.stdout?.pipe(stdout);
+        child.stderr?.pipe(stderr);
+        const exitPromise = new Promise((resolve) => {
+            child.on('close', (code, signal) => {
+                stdout.end();
+                stderr.end();
+                resolve({ code, signal });
+            });
+            child.on('error', () => {
+                stdout.end();
+                stderr.end();
+                resolve({ code: 1, signal: null });
+            });
+        });
+        return {
+            pid: child.pid || null,
+            wait: async (timeoutMs) => waitForChildExit(child, exitPromise, timeoutMs)
+        };
+    }
 }
 export function buildPaneWorkerCommand(input) {
     const envPrefix = Object.entries(input.env)
         .filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value != null)
-        .map(([key, value]) => `${key}=${shellQuote(String(value))}`)
+        .map(([key, value]) => `export ${key}=${shellQuote(String(value))};`)
         .sort();
     const command = [shellQuote(process.execPath), ...input.args.map(shellQuote)].join(' ');
     const heartbeat = `printf '%s\\n' ${shellQuote(JSON.stringify({ schema: 'sks.zellij-worker-pane-event.v1', event: 'worker_command_exited' }))} >> ${shellQuote(input.heartbeatPath)}`;
     const holdMs = Math.max(0, Number(process.env.SKS_ZELLIJ_WORKER_PANE_HOLD_MS || 1500));
     const hold = holdMs > 0 ? `sleep ${shellQuote(String(Math.min(30, holdMs / 1000)))}` : ':';
-    return `${envPrefix.join(' ')} ${command} > ${shellQuote(input.stdoutPath)} 2> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+    const header = input.header ? `printf '%s\\n' ${shellQuote(input.header)} | tee -a ${shellQuote(input.stdoutPath)};` : '';
+    return `${envPrefix.join(' ')} ${header} ${command} >> ${shellQuote(input.stdoutPath)} 2>> ${shellQuote(input.stderrPath)}; code=$?; ${heartbeat}; ${hold}; exit $code`.trim();
+}
+function buildPaneWorkerHeader(input) {
+    return [
+        'SKS Worker',
+        `slot: ${input.slotId} gen: ${input.generationIndex} role: ${input.role}`,
+        `backend: ${input.backend} provider: ${input.provider} service: ${input.serviceTier}`,
+        `worktree: ${input.worktree ? `${input.worktree.id} branch: ${input.worktree.branch}` : '-'}`,
+        `task: ${String(input.task || '').slice(0, 160)}`,
+        'status: running'
+    ].join('\n');
 }
 async function waitForWorkerResult(file, timeoutMs) {
     const deadline = Date.now() + Math.max(1000, timeoutMs);
@@ -488,4 +656,18 @@ function normalizeWorkerWorktree(value) {
         main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
     };
 }
+async function waitForChildExit(child, exitPromise, timeoutMs) {
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            if (!child.killed)
+                child.kill();
+            resolve({ code: null, signal: 'SIGTERM' });
+        }, Math.max(1000, timeoutMs));
+    });
+    const result = await Promise.race([exitPromise, timeout]);
+    if (timer)
+        clearTimeout(timer);
+    return result;
+}
 //# sourceMappingURL=native-cli-session-swarm.js.map

package/dist/core/commands/mad-sks-command.js

@@ -7,7 +7,6 @@ import { createMission, setCurrent } from '../mission.js';
 import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
 import { permissionGateSummary } from '../permission-gates.js';
 import { attachZellijSessionInteractive, launchMadZellijUi, sanitizeZellijSessionName } from '../zellij/zellij-launcher.js';
-import { openZellijDashboardPane } from '../zellij/zellij-dashboard-pane.js';
 import { createMadSksAuthorizationManifest, validateMadSksAuthorizationManifest } from '../mad-sks/authorization-manifest.js';
 import { createMadSksAuditLedger, madSksAuditAction, writeMadSksAuditLedger } from '../mad-sks/audit-ledger.js';
 import { compareProtectedCoreSnapshots, evaluateMadSksWrite, resolveProtectedCore, snapshotProtectedCore } from '../mad-sks/immutable-harness-guard.js';
@@ -114,36 +113,24 @@ export async function madHighCommand(args = [], deps = {}) {
         console.log(`MAD Zellij action: ${formatMadZellijAction(launch)}`);
         return launch;
     }
-    launch.dashboard_pane = await openZellijDashboardPane({
-        root: madLaunch.root,
-        missionId: madLaunch.mission_id,
-        sessionName: launch.session_name,
-        cwd: process.cwd(),
-        snapshot: {
-            mode: 'mad-sks',
-            backend_counts: { zellij: 1 },
-            placement_counts: { 'zellij-pane': 1, headless: 0 },
-            active_workers: 1,
-            visible_panes: 1,
-            headless_workers: 0,
-            queue_depth: 0,
-            worktrees: { active: 0, completed: 0, retained: 0 },
-            local_llm: { tps: 0, queue: 0 },
-            gpt_final_status: 'pending',
-            gate_progress: 'mad-sks:session-open'
-        }
-    }).catch((err) => ({
-        ok: false,
-        pane_kind: 'dashboard',
-        worker_pane: false,
-        blockers: [`zellij_dashboard_exception:${err?.message || String(err)}`]
-    }));
+    await writeJsonAtomic(path.join(madLaunch.dir, 'zellij-initial-ui.json'), {
+        schema: 'sks.zellij-initial-ui.v1',
+        ok: true,
+        mission_id: madLaunch.mission_id,
+        session_name: launch.session_name,
+        initial_panes: 'main-only',
+        dashboard_created: false,
+        worker_panes_created: 0,
+        right_column_mode: 'spawn-on-first-worker'
+    });
     const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, profile, {
         env: {
             ...madSksEnv,
             SKS_ZELLIJ_SESSION_NAME: launch.session_name
         },
-        zellijSessionName: launch.session_name
+        zellijSessionName: launch.session_name,
+        workerPlacement: shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
+        zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 8)
     });
     // The launcher only creates a detached background session. In an interactive
     // terminal, immediately attach so the session actually opens for the user
@@ -218,6 +205,8 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         command.push('--real');
         command.push('--zellij-session-name', opts.zellijSessionName || `sks-${madLaunch.mission_id}`);
         command.push('--zellij-pane-worker');
+        command.push('--worker-placement', opts.workerPlacement || 'zellij-pane');
+        command.push('--zellij-visible-pane-cap', String(opts.zellijVisiblePaneCap || swarm.agents));
     }
     const baseReport = {
         schema: 'sks.mad-sks-native-swarm.v1',
@@ -234,6 +223,8 @@ export async function startMadNativeSwarm(root, madLaunch, args = [], profile =
         work_items: swarm.workItems,
         backend: swarm.backend,
         zellij_session_name: opts.zellijSessionName || null,
+        worker_placement: opts.workerPlacement || (swarm.backend === 'zellij' ? 'zellij-pane' : 'process'),
+        zellij_visible_pane_cap: opts.zellijVisiblePaneCap || null,
         readonly: true,
         command,
         stdout_log: path.relative(root, stdoutLog),