sneakoscope 2.0.8 → 2.0.9

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **2.0.8** makes the release path DAG-parallel by default and hardens the Naruto/MAD-SKS worktree proof chain. `release:check` now runs a manifest-backed DAG runner with resource-aware scheduling, hermetic per-gate environments, bounded logs, per-gate reports, cache proof, and parallel speed-budget evidence. Git worktree coding now preserves allocation manifests, detects dirty main worktrees, includes untracked content in exported diffs, emits one `git_apply_patch` envelope operation, applies worktree diffs through an integration queue, and locks retained dirty worktrees.
+SKS **2.0.9** makes the release path DAG-parallel by default and hardens the Naruto/MAD-SKS worktree proof chain. `release:check` now runs a manifest-backed DAG runner with resource-aware scheduling, hermetic per-gate environments, bounded logs, per-gate reports, cache proof, and parallel speed-budget evidence. Git worktree coding now preserves allocation manifests, detects dirty main worktrees, includes untracked content in exported diffs, emits one `git_apply_patch` envelope operation, applies worktree diffs through an integration queue, and locks retained dirty worktrees.
 
 What changed:
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "2.0.8"
+version = "2.0.9"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "2.0.8"
+version = "2.0.9"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 2.0.8"),
+        Some("--version") => println!("sks-rs 2.0.9"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "2.0.8",
-  "source_digest": "5009938d20628f783aa7ac19da170d2737fef89481b49d9c8dc3f2f97c0dcf9d",
-  "source_file_count": 2004,
-  "built_at_source_time": 1780739165211
+  "package_version": "2.0.9",
+  "source_digest": "a2c7c47838f03483ee3a406fe6435876148d688fa16037d1b4eab45da1f930c4",
+  "source_file_count": 2017,
+  "built_at_source_time": 1780749751025
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '2.0.8';
+const FAST_PACKAGE_VERSION = '2.0.9';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "2.0.8",
-  "package_version": "2.0.8",
+  "version": "2.0.9",
+  "package_version": "2.0.9",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 1067,
-  "compiled_js_count": 1067,
+  "compiled_file_count": 1079,
+  "compiled_js_count": 1079,
   "compiled_dts_count": 0,
-  "source_digest": "5009938d20628f783aa7ac19da170d2737fef89481b49d9c8dc3f2f97c0dcf9d",
-  "source_file_count": 2004,
-  "source_files_hash": "045de0cf4e0b27b18838e5826c77f19ee281908588bbfde4a00a448b5a3c03eb",
-  "source_list_hash": "045de0cf4e0b27b18838e5826c77f19ee281908588bbfde4a00a448b5a3c03eb",
+  "source_digest": "a2c7c47838f03483ee3a406fe6435876148d688fa16037d1b4eab45da1f930c4",
+  "source_file_count": 2017,
+  "source_files_hash": "b69bf6184e62a1136caf9dc353eea79dcae63e3ba260a10fbc8eb6a38de7541a",
+  "source_list_hash": "b69bf6184e62a1136caf9dc353eea79dcae63e3ba260a10fbc8eb6a38de7541a",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -631,6 +631,8 @@
     "core/zellij/zellij-layout-builder.js",
     "core/zellij/zellij-naruto-dashboard.js",
     "core/zellij/zellij-pane-proof.js",
+    "core/zellij/zellij-right-column-layout-proof.js",
+    "core/zellij/zellij-right-column-manager.js",
     "core/zellij/zellij-screen-proof.js",
     "core/zellij/zellij-worker-pane-manager.js",
     "scripts/agent-ast-aware-work-graph-check.js",
@@ -922,9 +924,11 @@
     "scripts/mutation-callsite-coverage-check.js",
     "scripts/naruto-active-pool-check.js",
     "scripts/naruto-concurrency-governor-check.js",
+    "scripts/naruto-extreme-parallelism-check.js",
     "scripts/naruto-gpt-final-pack-check.js",
     "scripts/naruto-parallel-patch-apply-check.js",
     "scripts/naruto-readonly-routing-check.js",
+    "scripts/naruto-real-active-pool-check.js",
     "scripts/naruto-real-local-gpt-final-smoke.js",
     "scripts/naruto-role-distribution-check.js",
     "scripts/naruto-shadow-clone-swarm-check.js",
@@ -934,6 +938,7 @@
     "scripts/naruto-worktree-coding-check.js",
     "scripts/naruto-worktree-gpt-final-check.js",
     "scripts/naruto-worktree-zellij-ui-check.js",
+    "scripts/naruto-zellij-dynamic-right-column-check.js",
     "scripts/naruto-zellij-massive-ui-check.js",
     "scripts/non-recursive-pipeline-check.js",
     "scripts/npm-publish-performance-check.js",
@@ -973,9 +978,11 @@
     "scripts/qa-backfill-route-blackbox.js",
     "scripts/qa-patch-swarm-route-blackbox.js",
     "scripts/readme-architecture-imagegen-official-check.js",
+    "scripts/release-cache-glob-hashing-check.js",
     "scripts/release-check-dynamic-execute.js",
     "scripts/release-check-dynamic.js",
     "scripts/release-check-stamp.js",
+    "scripts/release-dag-full-coverage-check.js",
     "scripts/release-dist-freshness-check.js",
     "scripts/release-dynamic-performance-check.js",
     "scripts/release-gate-budget-check.js",
@@ -1067,7 +1074,10 @@
     "scripts/zellij-capability-check.js",
     "scripts/zellij-dashboard-pane-check.js",
     "scripts/zellij-dashboard-watch.js",
+    "scripts/zellij-developer-controls-check.js",
     "scripts/zellij-doctor-readiness-check.js",
+    "scripts/zellij-dynamic-pane-lifecycle-check.js",
+    "scripts/zellij-initial-main-only-blackbox.js",
     "scripts/zellij-lane-renderer-check.js",
     "scripts/zellij-launch-command-truth-check.js",
     "scripts/zellij-layout-valid-check.js",
@@ -1075,6 +1085,8 @@
     "scripts/zellij-real-session-cleanup-check.js",
     "scripts/zellij-real-session-heartbeat-check.js",
     "scripts/zellij-real-session-launch-check.js",
+    "scripts/zellij-right-column-geometry-proof.js",
+    "scripts/zellij-right-column-manager-check.js",
     "scripts/zellij-screen-proof-check.js",
     "scripts/zellij-spawn-on-demand-layout-check.js",
     "scripts/zellij-ui-design-check.js",

package/dist/commands/zellij.js

@@ -1,10 +1,12 @@
 import path from 'node:path';
+import fs from 'node:fs';
 import { projectRoot, readJson } from '../core/fsx.js';
 import { flag } from '../cli/args.js';
 import { printJson } from '../cli/output.js';
 import { checkZellijCapability } from '../core/zellij/zellij-capability.js';
 import { runZellij } from '../core/zellij/zellij-command.js';
 import { appendZellijLaneCommand, normalizeZellijSlot } from '../core/zellij/zellij-lane-runtime.js';
+import { buildZellijDashboardSnapshot, renderZellijDashboardText } from '../core/zellij/zellij-dashboard-renderer.js';
 export const ZELLIJ_COMMAND_SCHEMA = 'sks.zellij-command.v1';
 export const ZELLIJ_REPAIR_SCHEMA = 'sks.zellij-repair.v1';
 function installHint() {
@@ -24,6 +26,14 @@ export async function run(_command = 'zellij', args = []) {
         return zellijRepair(root, args, json);
     if (sub === 'dispatch' || sub === 'send')
         return zellijDispatch(root, args, json);
+    if (sub === 'focus-worker')
+        return zellijFocusWorker(root, args, json);
+    if (sub === 'worker-logs')
+        return zellijWorkerLogs(root, args, json);
+    if (sub === 'dashboard')
+        return zellijDashboard(root, args, json);
+    if (sub === 'close-drained')
+        return zellijCloseDrained(root, args, json);
     return zellijStatus(root, args, json);
 }
 async function zellijStatus(root, args, json) {
@@ -63,6 +73,108 @@ async function zellijStatus(root, args, json) {
     if (!result.ok)
         process.exitCode = 1;
 }
+async function zellijFocusWorker(root, args, json) {
+    const missionId = resolveMissionId(root, readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest');
+    const slotId = normalizeZellijSlot(readOption(args, '--slot', positionalAfter(args, 'focus-worker') || 'slot-001'));
+    const state = await readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-right-column-state.json'), null);
+    const worker = state?.visible_worker_panes?.find?.((row) => normalizeZellijSlot(row.slot_id) === slotId && row.pane_id);
+    const result = worker?.pane_id
+        ? await runZellij(['--session', state.session_name, 'action', 'focus-pane-id', String(worker.pane_id)], { cwd: root, timeoutMs: 5000, optional: true })
+        : null;
+    const out = {
+        schema: 'sks.zellij-focus-worker.v1',
+        ok: Boolean(worker?.pane_id) && (result?.ok !== false),
+        mission_id: missionId,
+        slot_id: slotId,
+        pane_id: worker?.pane_id || null,
+        session_name: state?.session_name || null,
+        result,
+        blockers: worker?.pane_id ? (result && !result.ok ? result.blockers : []) : ['worker_pane_not_found']
+    };
+    if (json)
+        printJson(out);
+    else
+        console.log(out.ok ? `Focused ${slotId} (${out.pane_id})` : `Worker pane not found: ${slotId}`);
+    if (!out.ok)
+        process.exitCode = 1;
+}
+async function zellijWorkerLogs(root, args, json) {
+    const missionId = resolveMissionId(root, readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest');
+    const slotArg = positionalAfter(args, 'worker-logs') || readOption(args, '--slot', '');
+    const slotId = slotArg ? normalizeZellijSlot(slotArg) : null;
+    const swarm = await readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'agent-native-cli-session-swarm.json'), null);
+    const records = Array.isArray(swarm?.records) ? swarm.records : [];
+    const filtered = slotId ? records.filter((row) => normalizeZellijSlot(row.slot_id) === slotId) : records;
+    const out = {
+        schema: 'sks.zellij-worker-logs.v1',
+        ok: filtered.length > 0,
+        mission_id: missionId,
+        slot_id: slotId,
+        logs: filtered.map((row) => ({
+            slot_id: row.slot_id,
+            generation_index: row.generation_index,
+            status: row.status,
+            stdout_log: row.stdout_log ? path.join(root, '.sneakoscope', 'missions', missionId, 'agents', row.stdout_log) : null,
+            stderr_log: row.stderr_log ? path.join(root, '.sneakoscope', 'missions', missionId, 'agents', row.stderr_log) : null,
+            worker_artifact_dir: row.worker_artifact_dir
+        })),
+        blockers: filtered.length ? [] : ['worker_log_records_missing']
+    };
+    if (json)
+        printJson(out);
+    else
+        for (const log of out.logs)
+            console.log(`${log.slot_id} gen-${log.generation_index} ${log.status}\nstdout: ${log.stdout_log}\nstderr: ${log.stderr_log}`);
+    if (!out.ok)
+        process.exitCode = 1;
+}
+async function zellijDashboard(root, args, json) {
+    const missionId = resolveMissionId(root, readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest');
+    const snapshot = await readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-dashboard-snapshot.json'), null);
+    const state = await readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-right-column-state.json'), null);
+    const watch = flag(args, '--watch');
+    const out = {
+        schema: 'sks.zellij-dashboard-command.v1',
+        ok: Boolean(snapshot || state),
+        mission_id: missionId,
+        snapshot,
+        right_column_state: state,
+        watch,
+        watch_command: `sks zellij dashboard --mission ${missionId} --watch`
+    };
+    if (json)
+        printJson(out);
+    else if (snapshot)
+        console.log(renderZellijDashboardText(buildZellijDashboardSnapshot({ ...snapshot, mission_id: snapshot.mission_id || missionId })));
+    else
+        console.log(JSON.stringify(state || out, null, 2));
+    if (!out.ok)
+        process.exitCode = 1;
+}
+async function zellijCloseDrained(root, args, json) {
+    const missionId = resolveMissionId(root, readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest');
+    const state = await readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-right-column-state.json'), null);
+    const rows = Array.isArray(state?.visible_worker_panes) ? state.visible_worker_panes.filter((row) => row.pane_id && (row.status === 'draining' || row.status === 'closed')) : [];
+    const results = [];
+    for (const row of rows) {
+        results.push(await runZellij(['--session', state.session_name, 'action', 'close-pane', '--pane-id', String(row.pane_id)], { cwd: root, timeoutMs: 5000, optional: true }));
+    }
+    const out = {
+        schema: 'sks.zellij-close-drained.v1',
+        ok: results.every((result) => result.ok !== false),
+        mission_id: missionId,
+        closed_count: results.filter((result) => result.ok).length,
+        attempted_count: results.length,
+        results,
+        blockers: results.flatMap((result) => result.ok ? [] : result.blockers)
+    };
+    if (json)
+        printJson(out);
+    else
+        console.log(`Closed drained panes: ${out.closed_count}/${out.attempted_count}`);
+    if (!out.ok)
+        process.exitCode = 1;
+}
 async function zellijDispatch(root, args, json) {
     const missionId = readOption(args, '--mission', readOption(args, '--mission-id', 'latest') || 'latest') || 'latest';
     const slotId = normalizeZellijSlot(readOption(args, '--slot', 'slot-001'));
@@ -153,12 +265,16 @@ function printHelp(json) {
         schema: ZELLIJ_COMMAND_SCHEMA,
         subcommand: 'help',
         ok: true,
-        usage: 'sks zellij status|repair|dispatch|send|capability [--require-real] [--json]',
+        usage: 'sks zellij status|repair|dispatch|send|focus-worker|worker-logs|dashboard|close-drained [--json]',
         subcommands: {
             status: 'Report Zellij runtime capability and interactive-route readiness.',
             repair: 'Explain how to install/repair Zellij (no automatic install).',
             dispatch: 'Append a nonblocking JSONL command for a lane; optionally write to a reconciled pane id with --write-pane.',
             send: 'Alias for dispatch.',
+            'focus-worker': 'Focus a visible right-column worker pane by slot.',
+            'worker-logs': 'Print stdout/stderr log paths for worker slots.',
+            dashboard: 'Render the latest dashboard snapshot; --watch prints watch metadata.',
+            'close-drained': 'Close drained right-column panes.',
             capability: 'Alias for status.'
         }
     };
@@ -169,6 +285,10 @@ function printHelp(json) {
         console.log('  sks zellij status [--require-real] [--json]');
         console.log('  sks zellij repair [--explain] [--json]');
         console.log('  sks zellij dispatch --mission M --slot slot-001 --text "..." [--write-pane] [--json]');
+        console.log('  sks zellij focus-worker slot-001 [--mission M] [--json]');
+        console.log('  sks zellij worker-logs [slot-001] [--mission M] [--json]');
+        console.log('  sks zellij dashboard [--mission M] [--watch] [--json]');
+        console.log('  sks zellij close-drained [--mission M] [--json]');
     }
 }
 function defaultLedgerRoot(root, missionId) {
@@ -180,4 +300,27 @@ function readOption(args, name, fallback) {
     const index = args.indexOf(name);
     return index >= 0 && args[index + 1] ? String(args[index + 1]) : fallback;
 }
+function positionalAfter(args, subcommand) {
+    const index = args.indexOf(subcommand);
+    for (const arg of args.slice(index >= 0 ? index + 1 : 1)) {
+        if (!String(arg).startsWith('-'))
+            return String(arg);
+    }
+    return null;
+}
+function resolveMissionId(root, requested) {
+    if (requested && requested !== 'latest')
+        return requested;
+    const dir = path.join(root, '.sneakoscope', 'missions');
+    try {
+        const rows = fs.readdirSync(dir)
+            .filter((name) => /^M-/.test(name))
+            .map((name) => ({ name, mtime: fs.statSync(path.join(dir, name)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime);
+        return rows[0]?.name || 'latest';
+    }
+    catch {
+        return 'latest';
+    }
+}
 //# sourceMappingURL=zellij.js.map

package/dist/core/agents/agent-orchestrator.js

@@ -281,7 +281,9 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         noOllama: opts.noOllama === true,
         route,
         fastModePolicy,
-        ...(opts.workerPlacement === undefined ? {} : { workerPlacement: String(opts.workerPlacement) })
+        ...(opts.workerPlacement === undefined ? {} : { workerPlacement: String(opts.workerPlacement) }),
+        zellijVisiblePaneCap: Number(opts.zellijVisiblePaneCap || visualLaneCount || targetActiveSlots),
+        projectRoot: root
     });
     await nativeCliSwarm.initialize();
     await setCurrent(root, { mission_id: missionId, mode: 'AGENT', phase: 'AGENT_NATIVE_KERNEL_RUNNING', route_command: routeCommand, native_agent_backend: backend });
@@ -334,7 +336,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
                 generationIndex: agent.generation_index,
                 requireGeneration: true
             });
-            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
+            const backendOpts = { ...opts, missionId, agentRoot: ledgerRoot, cwd: workerWorktree?.context.path || root, projectRoot: root, route, prompt, fastMode: fastModePolicy.fast_mode, serviceTier: fastModePolicy.service_tier, ...(workerWorktree ? { worktree: workerWorktree.context } : {}) };
             const result = opts.nativeCliSwarm === false
                 ? await runAgentByBackend(backend, runtimeAgent, runtimeSlice, backendOpts)
                 : await nativeCliSwarm.launchWorker({ agent: runtimeAgent, slice: runtimeSlice, opts: backendOpts });

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

@@ -5,6 +5,7 @@ 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 { recordHeadlessWorkerInRightColumn } from '../zellij/zellij-right-column-manager.js';
 import { resolveProviderContext } from '../provider/provider-context.js';
 export const NATIVE_CLI_SESSION_SWARM_SCHEMA = 'sks.agent-native-cli-session-swarm.v1';
 export function createNativeCliSessionSwarmRecorder(root, input) {
@@ -104,7 +105,8 @@ class NativeCliSessionSwarmRecorder {
         const placement = String(ctx.opts.workerPlacement || this.input.workerPlacement || (this.input.backend === 'zellij' ? 'zellij-pane' : 'process'));
         const useZellijPane = placement === 'zellij-pane'
             && ctx.opts.zellijPaneWorker !== false
-            && (ctx.opts.zellijSessionName || this.input.missionId);
+            && (ctx.opts.zellijSessionName || this.input.missionId)
+            && this.visibleZellijPaneCount() < this.zellijVisiblePaneCap(ctx.opts);
         if (useZellijPane) {
             stdout.end();
             stderr.end();
@@ -119,6 +121,22 @@ class NativeCliSessionSwarmRecorder {
                 workerDirRel
             });
         }
+        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: {
@@ -194,11 +212,26 @@ class NativeCliSessionSwarmRecorder {
         const activeToken = this.nextPaneToken--;
         this.active.add(activeToken);
         this.maxObserved = Math.max(this.maxObserved, this.active.size);
+        const providerContext = await resolveProviderContext({
+            root: this.root,
+            route: this.input.route,
+            serviceTier: this.input.fastModePolicy.service_tier
+        });
         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),
+            header: buildPaneWorkerHeader({
+                slotId,
+                generationIndex: Number(input.ctx.agent.generation_index || 1),
+                role: input.ctx.agent.naruto_role || input.ctx.agent.role || input.ctx.agent.persona_id || 'worker',
+                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: {
                 ...(input.ctx.opts.env || {}),
                 ...fastModeEnv(this.input.fastModePolicy),
@@ -215,11 +248,6 @@ class NativeCliSessionSwarmRecorder {
                 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,
@@ -238,7 +266,25 @@ class NativeCliSessionSwarmRecorder {
             providerContext,
             serviceTier: this.input.fastModePolicy.service_tier,
             worktree: worktree ? { id: worktree.id, path: worktree.path, branch: worktree.branch } : null,
-            backend: this.input.backend
+            backend: this.input.backend,
+            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'
+            }
         });
         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>'];
@@ -339,6 +385,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 +456,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 +472,35 @@ 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;
+    }
 }
 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);

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),