sneakoscope 2.0.15 → 2.0.17

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

@@ -4,6 +4,7 @@ import { MAX_AGENT_COUNT } from './agent-schema.js';
 import { appendAgentWorkQueueEvent, completeWorkItem, createAgentWorkQueue, enqueueFollowUpWorkItems, leaseNextWorkItem, pendingWorkItems, writeAgentWorkQueue } from './agent-work-queue.js';
 import { closeWorkerSlotsAfterDrain, createAgentWorkerSlots, markWorkerSlotGenerationClosed, openWorkerSlotGeneration, writeAgentWorkerSlots } from './agent-worker-slot.js';
 import { closeAgentSessionGeneration, createAgentSessionGeneration, writeAgentSessionGeneration } from './agent-session-generation.js';
+import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 export const AGENT_SCHEDULER_SCHEMA = 'sks.agent-scheduler.v1';
 export const AGENT_SCHEDULER_EVENT_SCHEMA = 'sks.agent-scheduler-event.v1';
 export async function runAgentScheduler(input) {
@@ -19,6 +20,12 @@ export async function runAgentScheduler(input) {
     });
     const active = new Map();
     const results = [];
+    const schedulerStartedAt = Date.now();
+    let lastUtilizationUpdateMs = schedulerStartedAt;
+    let activeSlotTimeMs = 0;
+    let batchCounter = 0;
+    let batchLaunchSpanTotalMs = 0;
+    let batchDispatchInProgress = false;
     let state = buildState(input.missionId, targetActiveSlots, queue, slots, active, {
         status: 'initializing',
         refillDelayMs: input.refillDelayMs || 0,
@@ -27,7 +34,7 @@ export async function runAgentScheduler(input) {
     await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_initialized' }, input.onSchedulerEvent);
     await refillSlots(null);
     while (active.size > 0 || pendingWorkItems(queue).length > 0) {
-        if (active.size === 0 && pendingWorkItems(queue).length > 0) {
+        if (!batchDispatchInProgress && active.size === 0 && pendingWorkItems(queue).length > 0) {
             state.blockers.push('scheduler_pending_queue_without_active_sessions');
             state.status = 'blocked';
             await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_blocked', pending_count: pendingWorkItems(queue).length }, input.onSchedulerEvent);
@@ -38,6 +45,7 @@ export async function runAgentScheduler(input) {
         if (!entry)
             continue;
         const activeCountBeforeClose = active.size;
+        accumulateActiveSlotTime();
         active.delete(settled.session_id);
         const resultStatus = settled.result?.status === 'done' ? 'completed' : settled.result?.status === 'blocked' ? 'blocked' : 'failed';
         completeWorkItem(queue, entry.work_item_id, settled.session_id, resultStatus, settled.error || null);
@@ -65,6 +73,7 @@ export async function runAgentScheduler(input) {
         const pendingAfterClose = pendingWorkItems(queue).length;
         if (pendingAfterClose > 0)
             state.expected_backfill_count += 1;
+        updateUtilizationMetrics();
         await writeAll(input.root, state, slots, queue, active, {
             event_type: 'session_completed',
             session_id: settled.session_id,
@@ -80,6 +89,7 @@ export async function runAgentScheduler(input) {
             closed_at_ms: Date.now()
         } : null);
     }
+    updateUtilizationMetrics();
     state.status = 'draining';
     await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_draining' }, input.onSchedulerEvent);
     slots = closeWorkerSlotsAfterDrain(slots);
@@ -94,6 +104,7 @@ export async function runAgentScheduler(input) {
     state.all_generations_closed = true;
     if (!state.pending_queue_drained)
         state.blockers.push('scheduler_pending_queue_not_drained');
+    updateUtilizationMetrics();
     await writeAll(input.root, state, slots, queue, active, { event_type: 'scheduler_drained' }, input.onSchedulerEvent);
     return {
         schema: 'sks.agent-scheduler-result.v1',
@@ -105,9 +116,180 @@ export async function runAgentScheduler(input) {
     };
     async function refillSlots(backfill) {
         state.status = 'running';
+        const launches = collectLaunchBatch();
+        if (!launches.length)
+            return;
+        batchDispatchInProgress = true;
+        const batchId = `batch-${Date.now().toString(36)}-${batchCounter++}`;
+        const batchStart = Date.now();
         const launchEvents = [];
-        while (active.size < targetActiveSlots && pendingWorkItems(queue).length > 0) {
-            const slotIndex = slots.findIndex((slot) => slot.status === 'idle');
+        try {
+            for (const launch of launches)
+                slots[launch.slotIndex] = launch.openedSlot;
+            await Promise.all(launches.map((launch) => writeAgentSessionGeneration(input.root, launch.generation)));
+            await writeAll(input.root, state, slots, queue, active, {
+                event_type: 'batch_dispatch_started',
+                batch_id: batchId,
+                launch_count: launches.length,
+                session_ids: launches.map((launch) => launch.generation.session_id)
+            }, input.onSchedulerEvent);
+            await appendParallelRuntimeEvent(input.root, input.missionId, {
+                event_type: 'batch_dispatch_started',
+                slot_id: null,
+                generation_index: null,
+                session_id: null,
+                pid: null,
+                backend: 'scheduler',
+                placement: 'unknown',
+                batch_id: batchId,
+                meta: { launch_count: launches.length, active_count_before: active.size }
+            }).catch(() => undefined);
+            for (const launch of launches) {
+                const { slot, openedSlot, generation, agent, workItem } = launch;
+                await appendParallelRuntimeEvent(input.root, input.missionId, {
+                    event_type: 'slot_reserved',
+                    slot_id: slot.slot_id,
+                    generation_index: generation.generation_index,
+                    session_id: generation.session_id,
+                    pid: null,
+                    backend: 'scheduler',
+                    placement: 'unknown',
+                    batch_id: batchId,
+                    meta: { work_item_id: workItem.id }
+                }).catch(() => undefined);
+                await appendParallelRuntimeEvent(input.root, input.missionId, {
+                    event_type: 'worker_launch_invoked',
+                    slot_id: slot.slot_id,
+                    generation_index: generation.generation_index,
+                    session_id: generation.session_id,
+                    pid: null,
+                    backend: 'scheduler',
+                    placement: 'unknown',
+                    batch_id: batchId,
+                    meta: { work_item_id: workItem.id }
+                }).catch(() => undefined);
+                const promise = Promise.resolve()
+                    .then(() => input.launchSession({ agent, workItem, generation, slot: openedSlot, queue, state }))
+                    .then((result) => ({
+                    result,
+                    session_id: generation.session_id,
+                    slot_id: slot.slot_id,
+                    generation_index: generation.generation_index,
+                    terminal_close_report_path: path.join(generation.artifact_dir, 'agent-terminal-close-report.json')
+                }))
+                    .catch((err) => ({
+                    result: {
+                        schema: 'sks.agent-result.v1',
+                        mission_id: input.missionId,
+                        agent_id: agent.id,
+                        session_id: generation.session_id,
+                        persona_id: agent.persona_id,
+                        task_slice_id: workItem.id,
+                        status: 'failed',
+                        backend: 'fake',
+                        summary: err instanceof Error ? err.message : String(err),
+                        findings: [],
+                        proposed_changes: [],
+                        changed_files: [],
+                        lease_compliance: { ok: true, violations: [] },
+                        artifacts: [],
+                        blockers: ['scheduler_launch_failed'],
+                        confidence: 'failed',
+                        handoff_notes: '',
+                        unverified: [],
+                        writes: [],
+                        recursion_guard: { ok: true, violations: [] },
+                        verification: { status: 'failed', checks: [] },
+                        source_intelligence_refs: input.sourceIntelligenceRefs || null,
+                        goal_mode_ref: input.goalModeRef || null
+                    },
+                    session_id: generation.session_id,
+                    slot_id: slot.slot_id,
+                    generation_index: generation.generation_index,
+                    error: err instanceof Error ? err.message : String(err),
+                    terminal_close_report_path: path.join(generation.artifact_dir, 'agent-terminal-close-report.json')
+                }));
+                accumulateActiveSlotTime();
+                active.set(generation.session_id, { slot_id: slot.slot_id, work_item_id: workItem.id, session_id: generation.session_id, promise });
+            }
+            await appendAgentWorkQueueEvent(input.root, 'batch_work_items_dispatched', {
+                batch_id: batchId,
+                launch_count: launches.length,
+                session_ids: launches.map((launch) => launch.generation.session_id),
+                work_item_ids: launches.map((launch) => launch.workItem.id)
+            });
+            for (const launch of launches)
+                await appendAgentWorkQueueEvent(input.root, 'work_item_dispatched', { work_item_id: launch.workItem.id, session_id: launch.generation.session_id, slot_id: launch.slot.slot_id });
+            if (backfill) {
+                const firstLaunch = launches[0];
+                const refillLatencyMs = Math.max(0, Date.now() - backfill.closed_at_ms);
+                state.backfill_count += 1;
+                state.refill_latency_events_ms.push(refillLatencyMs);
+                state.refill_latency_p95_ms = percentile95(state.refill_latency_events_ms);
+                launchEvents.push({
+                    event_type: 'backfill_event',
+                    closed_session_id: backfill.closed_session_id,
+                    new_session_id: firstLaunch?.generation.session_id || null,
+                    slot_id: firstLaunch?.slot.slot_id || null,
+                    batch_id: batchId,
+                    launch_count: launches.length,
+                    active_count_before: backfill.active_count_before,
+                    active_count_after: active.size,
+                    refill_latency_ms: refillLatencyMs
+                });
+                backfill = null;
+            }
+            else {
+                for (const launch of launches)
+                    launchEvents.push({
+                        event_type: 'session_launched',
+                        session_id: launch.generation.session_id,
+                        slot_id: launch.slot.slot_id,
+                        work_item_id: launch.workItem.id,
+                        active_count_after: active.size
+                    });
+            }
+            if (input.refillDelayMs && input.refillDelayMs > 0)
+                await delay(input.refillDelayMs);
+            const launchSpanMs = Math.max(0, Date.now() - batchStart);
+            batchLaunchSpanTotalMs += launchSpanMs;
+            state.batch_dispatch_count += 1;
+            state.largest_batch_size = Math.max(state.largest_batch_size, launches.length);
+            if (state.first_batch_launch_span_ms === 0)
+                state.first_batch_launch_span_ms = launchSpanMs;
+            state.average_batch_launch_span_ms = Math.round(batchLaunchSpanTotalMs / Math.max(1, state.batch_dispatch_count));
+            updateUtilizationMetrics();
+            await appendParallelRuntimeEvent(input.root, input.missionId, {
+                event_type: 'batch_dispatch_completed',
+                slot_id: null,
+                generation_index: null,
+                session_id: null,
+                pid: null,
+                backend: 'scheduler',
+                placement: 'unknown',
+                batch_id: batchId,
+                meta: { launch_count: launches.length, launch_span_ms: launchSpanMs, active_count_after: active.size }
+            }).catch(() => undefined);
+            await writeAll(input.root, state, slots, queue, active, {
+                event_type: 'batch_dispatch_completed',
+                batch_id: batchId,
+                launch_count: launches.length,
+                launch_span_ms: launchSpanMs,
+                active_count_after: active.size,
+                session_ids: launches.map((launch) => launch.generation.session_id)
+            }, input.onSchedulerEvent);
+        }
+        finally {
+            batchDispatchInProgress = false;
+        }
+        for (const event of launchEvents)
+            await appendJsonl(path.join(input.root, 'agent-scheduler-events.jsonl'), { schema: AGENT_SCHEDULER_EVENT_SCHEMA, ts: nowIso(), ...event });
+    }
+    function collectLaunchBatch() {
+        const launches = [];
+        const reservedSlots = new Set();
+        while (active.size + launches.length < targetActiveSlots && pendingWorkItems(queue).length > 0) {
+            const slotIndex = slots.findIndex((slot, index) => slot.status === 'idle' && !reservedSlots.has(index));
             if (slotIndex < 0)
                 break;
             const slot = slots[slotIndex];
@@ -133,90 +315,25 @@ export async function runAgentScheduler(input) {
                 goalModeRef: workItem.goal_mode_ref
             });
             workItem.running_session_id = generation.session_id;
-            await writeAgentSessionGeneration(input.root, generation);
-            const agent = buildAgentForGeneration(slot, generation, workItem);
             const openedSlot = openWorkerSlotGeneration(slot, generation);
-            slots[slotIndex] = openedSlot;
-            await writeAll(input.root, state, slots, queue, active, {
-                event_type: 'session_launch_started',
-                session_id: generation.session_id,
-                slot_id: slot.slot_id,
-                generation_index: generation.generation_index,
-                work_item_id: workItem.id
-            }, input.onSchedulerEvent);
-            const promise = Promise.resolve()
-                .then(() => input.launchSession({ agent, workItem, generation, slot: openedSlot, queue, state }))
-                .then((result) => ({
-                result,
-                session_id: generation.session_id,
-                slot_id: slot.slot_id,
-                generation_index: generation.generation_index,
-                terminal_close_report_path: path.join(generation.artifact_dir, 'agent-terminal-close-report.json')
-            }))
-                .catch((err) => ({
-                result: {
-                    schema: 'sks.agent-result.v1',
-                    mission_id: input.missionId,
-                    agent_id: agent.id,
-                    session_id: generation.session_id,
-                    persona_id: agent.persona_id,
-                    task_slice_id: workItem.id,
-                    status: 'failed',
-                    backend: 'fake',
-                    summary: err instanceof Error ? err.message : String(err),
-                    findings: [],
-                    proposed_changes: [],
-                    changed_files: [],
-                    lease_compliance: { ok: true, violations: [] },
-                    artifacts: [],
-                    blockers: ['scheduler_launch_failed'],
-                    confidence: 'failed',
-                    handoff_notes: '',
-                    unverified: [],
-                    writes: [],
-                    recursion_guard: { ok: true, violations: [] },
-                    verification: { status: 'failed', checks: [] },
-                    source_intelligence_refs: input.sourceIntelligenceRefs || null,
-                    goal_mode_ref: input.goalModeRef || null
-                },
-                session_id: generation.session_id,
-                slot_id: slot.slot_id,
-                generation_index: generation.generation_index,
-                error: err instanceof Error ? err.message : String(err),
-                terminal_close_report_path: path.join(generation.artifact_dir, 'agent-terminal-close-report.json')
-            }));
-            active.set(generation.session_id, { slot_id: slot.slot_id, work_item_id: workItem.id, session_id: generation.session_id, promise });
-            await appendAgentWorkQueueEvent(input.root, 'work_item_dispatched', { work_item_id: workItem.id, session_id: generation.session_id, slot_id: slot.slot_id });
-            if (backfill) {
-                const refillLatencyMs = Math.max(0, Date.now() - backfill.closed_at_ms);
-                state.backfill_count += 1;
-                state.refill_latency_events_ms.push(refillLatencyMs);
-                state.refill_latency_p95_ms = percentile95(state.refill_latency_events_ms);
-                launchEvents.push({
-                    event_type: 'backfill_event',
-                    closed_session_id: backfill.closed_session_id,
-                    new_session_id: generation.session_id,
-                    slot_id: slot.slot_id,
-                    active_count_before: backfill.active_count_before,
-                    active_count_after: active.size,
-                    refill_latency_ms: refillLatencyMs
-                });
-                backfill = null;
-            }
-            else {
-                launchEvents.push({
-                    event_type: 'session_launched',
-                    session_id: generation.session_id,
-                    slot_id: slot.slot_id,
-                    work_item_id: workItem.id,
-                    active_count_after: active.size
-                });
-            }
-            if (input.refillDelayMs && input.refillDelayMs > 0)
-                await delay(input.refillDelayMs);
+            const agent = buildAgentForGeneration(slot, generation, workItem);
+            launches.push({ slotIndex, slot, openedSlot, generation, agent, workItem, provisionalSessionId });
+            reservedSlots.add(slotIndex);
         }
-        for (const event of launchEvents)
-            await writeAll(input.root, state, slots, queue, active, event, input.onSchedulerEvent);
+        return launches;
+    }
+    function updateUtilizationMetrics() {
+        accumulateActiveSlotTime();
+        state.wall_time_ms = Math.max(0, Date.now() - schedulerStartedAt);
+        state.active_slot_time_ms = activeSlotTimeMs;
+        const denominator = Math.max(1, state.wall_time_ms * targetActiveSlots);
+        state.scheduler_utilization = Number(Math.min(1, state.active_slot_time_ms / denominator).toFixed(3));
+    }
+    function accumulateActiveSlotTime() {
+        const now = Date.now();
+        const delta = Math.max(0, now - lastUtilizationUpdateMs);
+        activeSlotTimeMs += active.size * delta;
+        lastUtilizationUpdateMs = now;
     }
 }
 export function normalizeTargetActiveSlots(value, maxActiveSlots = MAX_AGENT_COUNT) {
@@ -261,7 +378,14 @@ function buildState(missionId, targetActiveSlots, queue, slots, active, opts) {
         pending_queue_drained: pendingCount === 0,
         all_slots_closed_after_drain: slots.length > 0 && slots.every((slot) => slot.status === 'closed'),
         all_generations_closed: false,
-        blockers: [...(previous?.blockers || [])]
+        blockers: [...(previous?.blockers || [])],
+        batch_dispatch_count: previous?.batch_dispatch_count || 0,
+        largest_batch_size: previous?.largest_batch_size || 0,
+        first_batch_launch_span_ms: previous?.first_batch_launch_span_ms || 0,
+        average_batch_launch_span_ms: previous?.average_batch_launch_span_ms || 0,
+        scheduler_utilization: previous?.scheduler_utilization || 0,
+        active_slot_time_ms: previous?.active_slot_time_ms || 0,
+        wall_time_ms: previous?.wall_time_ms || 0
     };
 }
 async function writeAll(root, currentState, slots, queue, active, event, onSchedulerEvent) {
@@ -289,6 +413,13 @@ async function writeAll(root, currentState, slots, queue, active, event, onSched
     currentState.blocked = nextState.blocked;
     currentState.pending_queue_drained = nextState.pending_queue_drained;
     currentState.all_slots_closed_after_drain = nextState.all_slots_closed_after_drain;
+    currentState.batch_dispatch_count = nextState.batch_dispatch_count;
+    currentState.largest_batch_size = nextState.largest_batch_size;
+    currentState.first_batch_launch_span_ms = nextState.first_batch_launch_span_ms;
+    currentState.average_batch_launch_span_ms = nextState.average_batch_launch_span_ms;
+    currentState.scheduler_utilization = nextState.scheduler_utilization;
+    currentState.active_slot_time_ms = nextState.active_slot_time_ms;
+    currentState.wall_time_ms = nextState.wall_time_ms;
     await writeAgentWorkQueue(root, queue);
     await writeAgentWorkerSlots(root, slots);
     await writeJsonAtomic(path.join(root, 'agent-scheduler-state.json'), currentState);

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

@@ -13,7 +13,7 @@ export const DEFAULT_AGENT_CONCURRENCY = 5;
 // ceiling to up to 100 concurrent clone sessions. Only the naruto path opts into this
 // cap; every other roster/scheduler caller keeps MAX_AGENT_COUNT as the default.
 export const MAX_NARUTO_AGENT_COUNT = 100;
-export const DEFAULT_NARUTO_CLONES = 12;
+export const DEFAULT_NARUTO_CLONES = 32;
 export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'zellij', 'ollama', 'local-llm'];
 export function normalizeAgentBackend(input) {
     const value = String(input || 'codex-sdk');

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

@@ -8,8 +8,9 @@ import { closeWorkerPane, openWorkerPane } from '../zellij/zellij-worker-pane-ma
 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';
+import { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
 import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
+import { appendParallelRuntimeEvent } from './parallel-runtime-proof.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);
@@ -175,6 +176,16 @@ class NativeCliSessionSwarmRecorder {
         record.pid = child.pid || null;
         record.process_id = child.pid || null;
         record.status = 'running';
+        await appendParallelRuntimeEvent(this.root, this.input.missionId, {
+            event_type: 'worker_process_spawned',
+            slot_id: ctx.agent.slot_id || ctx.agent.id || null,
+            generation_index: ctx.agent.generation_index || null,
+            session_id: ctx.agent.session_id || null,
+            pid: child.pid || null,
+            backend: this.input.backend,
+            placement: record.worker_placement === 'headless' ? 'headless' : 'process',
+            worktree_id: worktree?.id || null
+        }).catch(() => undefined);
         await this.telemetry(ctx, {
             eventType: 'worker_spawned',
             status: 'launching',
@@ -267,7 +278,8 @@ class NativeCliSessionSwarmRecorder {
             route: this.input.route,
             serviceTier: this.input.fastModePolicy.service_tier
         });
-        const uiMode = resolveZellijUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const uiMode = resolveZellijWorkerPaneUiMode(Array.isArray(input.ctx.opts.args) ? input.ctx.opts.args : [], process.env);
+        const liveWorkerPane = uiMode !== 'compact-slots';
         const workerEnv = {
             ...(input.ctx.opts.env || {}),
             ...fastModeEnv(this.input.fastModePolicy),
@@ -289,7 +301,7 @@ class NativeCliSessionSwarmRecorder {
             artifacts: [path.join(input.workerDirRel, 'worker-intake.json'), input.heartbeatRel, input.resultRel],
             logTail: `zellij=${sessionName}`
         });
-        const workerCommand = uiMode === 'full-debug'
+        const workerCommand = liveWorkerPane
             ? buildPaneWorkerCommand({
                 args: input.args,
                 stdoutPath: path.join(this.root, input.stdoutRel),
@@ -321,6 +333,30 @@ class NativeCliSessionSwarmRecorder {
                 mode: uiMode,
                 watch: true
             });
+        const processRun = liveWorkerPane
+            ? 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 appendParallelRuntimeEvent(this.root, this.input.missionId, {
+                event_type: 'worker_process_spawned',
+                slot_id: slotId,
+                generation_index: Number(input.ctx.agent.generation_index || 1),
+                session_id: input.ctx.agent.session_id || null,
+                pid: processRun.pid,
+                backend: this.input.backend,
+                placement: 'zellij-pane',
+                worktree_id: worktree?.id || null
+            }).catch(() => undefined);
+            await this.record(input.record);
+        }
         let paneRecord;
         try {
             paneRecord = await openWorkerPane({
@@ -367,8 +403,10 @@ class NativeCliSessionSwarmRecorder {
             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', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
+        const zellijRequired = process.env.SKS_REQUIRE_ZELLIJ === '1';
+        const launchBlockers = zellijRequired ? paneRecord.blockers || [] : [];
+        const launchWarnings = zellijRequired ? [] : paneRecord.blockers || [];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', liveWorkerPane ? '<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;
@@ -382,9 +420,10 @@ class NativeCliSessionSwarmRecorder {
         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.slot_visualization = liveWorkerPane ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
+        input.record.warnings = [...(input.record.warnings || []), ...launchWarnings];
         await this.telemetry(input.ctx, {
             eventType: 'worker_spawned',
             status: launchBlockers.length ? 'failed' : 'launching',
@@ -422,27 +461,18 @@ 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
+        const heartbeatSeen = await waitForWorkerHeartbeat(path.join(this.root, input.heartbeatRel), Number(process.env.SKS_ZELLIJ_WORKER_HEARTBEAT_TIMEOUT_MS || 5000));
+        if (heartbeatSeen) {
+            await this.telemetry(input.ctx, {
+                eventType: 'heartbeat',
+                status: 'running',
+                artifacts: [input.heartbeatRel],
+                logTail: await tailFile(path.join(this.root, input.heartbeatRel), 600)
             });
-        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 this.telemetry(input.ctx, {
-            eventType: 'heartbeat',
-            status: 'running',
-            artifacts: [input.heartbeatRel],
-            logTail: await tailFile(path.join(this.root, input.heartbeatRel), 600)
-        });
+        else {
+            input.record.warnings = [...(input.record.warnings || []), 'zellij_worker_heartbeat_missing_launch_warning'];
+        }
         await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
             schema: 'sks.zellij-worker-pane-event.v1',
             ts: nowIso(),
@@ -505,8 +535,10 @@ class NativeCliSessionSwarmRecorder {
         const heartbeatOk = await hasHeartbeat(path.join(this.root, input.heartbeatRel));
         input.record.blockers = [
             ...(parsed ? parsed.blockers || [] : ['zellij_worker_result_timeout']),
-            ...(heartbeatOk ? [] : ['zellij_worker_heartbeat_missing'])
+            ...(heartbeatOk ? [] : [])
         ];
+        if (!heartbeatOk)
+            input.record.warnings = [...(input.record.warnings || []), 'zellij_worker_heartbeat_missing'];
         paneRecord = await closeWorkerPane({
             root: this.root,
             paneRecord,
@@ -593,6 +625,24 @@ class NativeCliSessionSwarmRecorder {
             log_tail: input.logTail || '',
             blockers: input.blockers || []
         }).catch(() => undefined);
+        const parallelEvent = mapTelemetryToParallelEvent(input.eventType);
+        if (parallelEvent) {
+            await appendParallelRuntimeEvent(this.root, this.input.missionId, {
+                event_type: parallelEvent,
+                slot_id: String(ctx.agent?.slot_id || ctx.agent?.id || 'slot-001'),
+                generation_index: Number(ctx.agent?.generation_index || 1),
+                session_id: ctx.agent?.session_id == null ? null : String(ctx.agent.session_id),
+                pid: null,
+                backend: this.input.backend,
+                placement: normalizeParallelPlacement(ctx.opts?.workerPlacement || this.input.workerPlacement || (input.status === 'headless' ? 'headless' : 'unknown')),
+                worktree_id: ctx.agent?.worktree?.id || ctx.slice?.worktree?.id || null,
+                meta: {
+                    status: input.status,
+                    artifacts: input.artifacts || [],
+                    blockers: input.blockers || []
+                }
+            }).catch(() => undefined);
+        }
     }
     async persist() {
         this.writeLock = this.writeLock.catch(() => undefined).then(async () => {
@@ -692,7 +742,10 @@ export function buildPaneWorkerCommand(input) {
     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)))}` : ':';
     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();
+    const exitPath = `${input.heartbeatPath}.exit`;
+    const visibleCommand = `(${command}; printf '%s' "$?" > ${shellQuote(exitPath)}) 2>&1 | tee -a ${shellQuote(input.stdoutPath)}`;
+    const readExit = `code=$(cat ${shellQuote(exitPath)} 2>/dev/null || printf '1'); rm -f ${shellQuote(exitPath)}`;
+    return `${envPrefix.join(' ')} ${header} ${visibleCommand}; ${readExit}; ${heartbeat}; ${hold}; exit $code`.trim();
 }
 function buildPaneWorkerHeader(input) {
     return [
@@ -765,6 +818,23 @@ function firstString(values) {
     }
     return null;
 }
+function mapTelemetryToParallelEvent(eventType) {
+    if (eventType === 'slot_reserved')
+        return 'slot_reserved';
+    if (eventType === 'heartbeat')
+        return 'worker_heartbeat_seen';
+    if (eventType === 'worker_completed')
+        return 'worker_completed';
+    if (eventType === 'worker_failed')
+        return 'worker_failed';
+    return null;
+}
+function normalizeParallelPlacement(value) {
+    const text = String(value || '');
+    if (text === 'zellij-pane' || text === 'process' || text === 'headless')
+        return text;
+    return 'unknown';
+}
 async function tailFile(file, max) {
     try {
         const text = await fs.promises.readFile(file, 'utf8');