sneakoscope 8.0.2 → 8.0.4

package/dist/core/agents/native-cli-worker-runtime.js

@@ -1,19 +1,13 @@
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-import { appendJsonl, ensureDir, exists, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
+import { ensureDir, exists, nowIso, packageRoot, readJson, writeJsonAtomic } from '../fsx.js';
 import { fastModeEnv } from './fast-mode-policy.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
-import { closeWorkerPane, openHeadlessByDesignViewportWorker } 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 { resolveZellijWorkerPaneUiMode } from '../zellij/zellij-ui-mode.js';
-import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 import { appendParallelRuntimeEvent } from './parallel-runtime-proof.js';
 import { appendAgentMessage } from './agent-message-bus.js';
 import { markLoopWorkerInterrupted, registerLoopActiveWorker } from '../loops/loop-interrupt-registry.js';
-export const NATIVE_CLI_WORKER_RUNTIME_SCHEMA = 'sks.native-cli-worker-runtime.v2';
+export const NATIVE_CLI_WORKER_RUNTIME_SCHEMA = 'sks.native-cli-worker-runtime.v3';
 export function createNativeCliWorkerRuntimeRecorder(root, input) {
     return new NativeCliWorkerRuntimeRecorder(root, input);
 }
@@ -24,7 +18,6 @@ class NativeCliWorkerRuntimeRecorder {
     active = new Set();
     maxObserved = 0;
     writeLock = Promise.resolve();
-    nextPaneToken = -1;
     constructor(root, input) {
         this.root = root;
         this.input = input;
@@ -76,9 +69,8 @@ class NativeCliWorkerRuntimeRecorder {
         await writeJsonAtomic(path.join(this.root, intakeRel), intake);
         const workerEntrypoint = await resolveWorkerEntrypointPath();
         const args = [workerEntrypoint, '--intake', path.join(this.root, intakeRel), '--json'];
-        const commandLine = [process.execPath, ...redactWorkerArgs(args)];
         const record = {
-            schema: 'sks.native-cli-worker-session-record.v1',
+            schema: 'sks.native-cli-worker-session-record.v2',
             launched_at: nowIso(),
             closed_at: null,
             mission_id: this.input.missionId,
@@ -90,7 +82,7 @@ class NativeCliWorkerRuntimeRecorder {
             backend: this.input.backend,
             pid: null,
             process_id: null,
-            command_line: commandLine,
+            command_line: [process.execPath, ...redactWorkerArgs(args)],
             stdout_log: stdoutRel,
             stderr_log: stderrRel,
             worker_artifact_dir: workerDirRel,
@@ -101,59 +93,20 @@ class NativeCliWorkerRuntimeRecorder {
             fast_mode: this.input.fastModePolicy.fast_mode,
             service_tier: this.input.fastModePolicy.service_tier,
             cwd: workerCwd,
+            worker_placement: 'process',
+            scaling_primitive: 'native_cli_process',
             status: 'launching',
             exit_code: null,
             blockers: []
         };
-        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 wantsZellijUi = placement === 'zellij-pane'
-            && ctx.opts.zellijPaneWorker !== false
-            && (ctx.opts.zellijSessionName || this.input.missionId);
-        const useZellijPane = Boolean(wantsZellijUi);
-        await this.telemetry(ctx, {
+        await this.lifecycle(ctx, {
             eventType: 'slot_reserved',
-            status: placement === 'zellij-pane' && !useZellijPane ? 'headless' : 'queued',
+            status: 'queued',
             artifacts: [intakeRel, heartbeatRel, resultRel],
-            logTail: `placement=${placement}${wantsZellijUi ? ';viewport-ui=headless-by-design' : ''}`
+            logTail: 'placement=process'
         });
-        if (useZellijPane) {
-            stdout.end();
-            stderr.end();
-            return this.launchWorkerInZellijPane({
-                ctx,
-                record,
-                args,
-                resultRel,
-                stdoutRel,
-                stderrRel,
-                heartbeatRel,
-                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 this.telemetry(ctx, {
-                eventType: 'headless_overflow',
-                status: 'headless',
-                artifacts: [intakeRel, heartbeatRel, resultRel],
-                logTail: record.headless_reason
-            });
-            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 stdout = fs.createWriteStream(path.join(this.root, stdoutRel), { flags: 'a' });
+        const stderr = fs.createWriteStream(path.join(this.root, stderrRel), { flags: 'a' });
         const child = spawn(process.execPath, args, {
             cwd: workerCwd,
             env: {
@@ -170,12 +123,18 @@ class NativeCliWorkerRuntimeRecorder {
             },
             stdio: ['ignore', 'pipe', 'pipe']
         });
+        const removeAbortListener = terminateChildOnAbort(child, ctx.opts?.signal);
         const exitPromise = new Promise((resolve) => {
             child.once('close', (code, signal) => resolve({ code, signal }));
             child.once('error', () => resolve({ code: 1, signal: null }));
         });
         record.pid = child.pid || null;
         record.process_id = child.pid || null;
+        record.status = 'running';
+        if (child.pid)
+            this.active.add(child.pid);
+        this.maxObserved = Math.max(this.maxObserved, this.active.size);
+        await this.record(record);
         const loopHandle = await registerLoopWorkerHandle({
             root: ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd || packageRoot(),
             env: ctx.opts.env || {},
@@ -183,7 +142,6 @@ class NativeCliWorkerRuntimeRecorder {
             sessionId: ctx.agent.session_id || null,
             pid: 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,
@@ -191,22 +149,19 @@ class NativeCliWorkerRuntimeRecorder {
             session_id: ctx.agent.session_id || null,
             pid: child.pid || null,
             backend: this.input.backend,
-            placement: record.worker_placement === 'headless' ? 'headless' : 'process',
+            placement: 'process',
             worktree_id: worktree?.id || null
         }).catch(() => undefined);
-        await this.telemetry(ctx, {
+        await this.lifecycle(ctx, {
             eventType: 'worker_spawned',
             status: 'launching',
             artifacts: [intakeRel, heartbeatRel, resultRel, stdoutRel, stderrRel],
             logTail: `pid=${child.pid || 'unknown'}`
         });
-        if (child.pid)
-            this.active.add(child.pid);
-        this.maxObserved = Math.max(this.maxObserved, this.active.size);
-        await this.record(record);
         child.stdout?.pipe(stdout);
         child.stderr?.pipe(stderr);
         const exit = await exitPromise;
+        removeAbortListener();
         stdout.end();
         stderr.end();
         if (child.pid)
@@ -218,21 +173,10 @@ class NativeCliWorkerRuntimeRecorder {
         if (loopHandle) {
             await markLoopWorkerInterrupted(ctx.opts.projectRoot || this.input.projectRoot || ctx.opts.cwd || packageRoot(), loopHandle.mission_id, loopHandle.worker_id, record.status === 'closed' ? 'completed' : 'failed').catch(() => undefined);
         }
-        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'];
-            await this.telemetry(ctx, {
+            await this.lifecycle(ctx, {
                 eventType: 'worker_failed',
                 status: 'failed',
                 artifacts: [stdoutRel, stderrRel],
@@ -259,11 +203,11 @@ class NativeCliWorkerRuntimeRecorder {
         }
         const result = validateAgentWorkerResult({
             ...parsed,
-            artifacts: [...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), stdoutRel, stderrRel]
+            artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), stdoutRel, stderrRel])]
         });
         record.status = result.status === 'done' ? 'closed' : result.status;
         record.blockers = result.blockers || [];
-        await this.telemetry(ctx, {
+        await this.lifecycle(ctx, {
             eventType: result.status === 'done' ? 'worker_completed' : 'worker_failed',
             status: result.status === 'done' ? 'completed' : 'failed',
             artifacts: result.artifacts || [],
@@ -274,392 +218,6 @@ class NativeCliWorkerRuntimeRecorder {
         await this.record(record);
         return result;
     }
-    async launchWorkerInZellijPane(input) {
-        const sessionName = String(input.ctx.opts.zellijSessionName || (this.input.missionId ? `sks-${this.input.missionId}` : 'sks-agent-runtime'));
-        const slotId = String(input.ctx.agent.slot_id || input.ctx.agent.id || 'slot-001');
-        const worktree = normalizeWorkerWorktree(input.ctx.agent?.worktree || input.ctx.slice?.worktree || input.ctx.opts?.worktree || null);
-        const workerCwd = worktree?.path || input.ctx.opts.cwd || packageRoot();
-        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 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),
-            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');
-        await this.telemetry(input.ctx, {
-            eventType: 'slot_reserved',
-            status: 'queued',
-            artifacts: [path.join(input.workerDirRel, 'worker-intake.json'), input.heartbeatRel, input.resultRel],
-            logTail: `zellij=${sessionName}`
-        });
-        const workerCommand = liveWorkerPane
-            ? 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,
-                provider: providerContext.provider,
-                model: String(process.env.SKS_MODEL || process.env.OPENAI_MODEL || process.env.CODEX_MODEL || ''),
-                serviceTier: this.input.fastModePolicy.service_tier,
-                reasoningEffort: String(input.ctx.agent.model_reasoning_effort || input.ctx.agent.reasoning_effort || process.env.SKS_REASONING_EFFORT || ''),
-                currentTask: String(input.ctx.slice?.title || input.ctx.slice?.description || input.ctx.slice?.id || ''),
-                mode: uiMode,
-                watch: true
-            });
-        const processRun = liveWorkerPane
-            ? null
-            : await this.spawnCompactSlotWorkerProcess({
-                args: input.args,
-                cwd: workerCwd,
-                env: workerEnv,
-                stdoutRel: input.stdoutRel,
-                stderrRel: input.stderrRel
-            });
-        let loopHandle = await registerLoopWorkerHandle({
-            root: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(),
-            env: input.ctx.opts.env || {},
-            agentId: String(input.ctx.agent.id || input.ctx.agent.session_id || 'agent'),
-            sessionId: input.ctx.agent.session_id || null,
-            pid: processRun?.pid || null
-        });
-        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: 'headless_by_design_viewport_ui',
-                worktree_id: worktree?.id || null
-            }).catch(() => undefined);
-            await this.record(input.record);
-        }
-        const paneInput = {
-            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,
-            taskTitle: String(input.ctx.slice?.title || input.ctx.slice?.description || input.ctx.slice?.id || '') || null,
-            uiMode,
-            projectRoot: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd,
-            rightColumnMode: 'spawn-on-first-worker',
-            visiblePaneCap: this.zellijVisiblePaneCap(input.ctx.opts),
-            plannedAgentCount: this.input.targetActiveSlots
-        };
-        let paneRecord = await openHeadlessByDesignViewportWorker(paneInput);
-        const zellijRequired = process.env.SKS_REQUIRE_ZELLIJ === '1';
-        const launchBlockers = zellijRequired ? paneRecord.blockers || [] : [];
-        const launchWarnings = zellijRequired ? [] : paneRecord.blockers || [];
-        input.record.command_line = paneRecord.pane_id_source === 'headless_by_design_viewport_ui'
-            ? ['node', '<native-cli-worker-command>', '# headless-by-design viewport UI']
-            : ['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;
-        input.record.zellij_create_session = paneRecord.create_session;
-        input.record.zellij_launch = paneRecord.launch;
-        input.record.zellij_worker_pane = path.join(input.workerDirRel, 'zellij-worker-pane.json');
-        input.record.pane_kind = paneRecord.pane_kind;
-        input.record.scaling_primitive = paneRecord.scaling_primitive;
-        input.record.provider = paneRecord.provider;
-        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 = liveWorkerPane ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
-        if (paneRecord.pane_id_source === 'headless_by_design_viewport_ui') {
-            input.record.worker_placement = 'headless_by_design_viewport_ui';
-            input.record.slot_visualization = 'monitor-plus-viewport';
-        }
-        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',
-            artifacts: [input.resultRel, input.heartbeatRel, input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
-            blockers: launchBlockers,
-            logTail: paneRecord.pane_title || ''
-        });
-        await this.record(input.record);
-        if (launchBlockers.length) {
-            this.active.delete(activeToken);
-            input.record.closed_at = nowIso();
-            input.record.status = 'failed';
-            await this.telemetry(input.ctx, {
-                eventType: 'worker_failed',
-                status: 'failed',
-                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
-                blockers: launchBlockers,
-                logTail: 'Zellij worker pane launch failed.'
-            });
-            await this.record(input.record);
-            return validateAgentWorkerResult({
-                mission_id: this.input.missionId,
-                agent_id: input.ctx.agent.id,
-                session_id: input.ctx.agent.session_id,
-                persona_id: input.ctx.agent.persona_id || input.ctx.agent.id,
-                task_slice_id: input.ctx.slice?.id || '',
-                status: 'failed',
-                backend: this.input.backend,
-                summary: 'Zellij worker pane launch failed.',
-                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
-                blockers: launchBlockers,
-                unverified: [],
-                writes: [],
-                source_intelligence_refs: input.ctx.agent.source_intelligence_refs || null,
-                goal_mode_ref: input.ctx.agent.goal_mode_ref || null
-            });
-        }
-        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)
-            });
-        }
-        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(),
-            event_type: 'worker_started',
-            mission_id: this.input.missionId,
-            slot_id: slotId,
-            generation_index: input.ctx.agent.generation_index || null,
-            session_id: input.ctx.agent.session_id,
-            worker_artifact_dir: input.workerDirRel
-        });
-        const parsed = await this.waitForWorkerResultWithActivity({
-            resultPath: path.join(this.root, input.resultRel),
-            activityPaths: [
-                path.join(this.root, input.heartbeatRel),
-                path.join(this.root, input.stdoutRel),
-                path.join(this.root, input.stderrRel),
-                path.join(this.root, input.workerDirRel, 'codex-sdk-events.jsonl'),
-                path.join(this.root, input.workerDirRel, 'python-codex-sdk-events.jsonl'),
-                path.join(this.root, input.workerDirRel, 'local-llm-events.jsonl')
-            ],
-            stdoutPath: path.join(this.root, input.stdoutRel),
-            ctx: input.ctx,
-            heartbeatRel: input.heartbeatRel,
-            resultRel: input.resultRel,
-            stdoutRel: input.stdoutRel,
-            stderrRel: input.stderrRel
-        });
-        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);
-        const sdkThreadId = workerProcessReport?.sdk_thread_id || workerProcessReport?.backend_router_report?.sdk_thread_id || parsed?.codex_sdk_thread?.sdk_thread_id || parsed?.codex_child_report?.sdk_thread_id || null;
-        const sdkRunId = workerProcessReport?.sdk_run_id || workerProcessReport?.backend_router_report?.sdk_run_id || parsed?.codex_sdk_thread?.sdk_run_id || parsed?.codex_child_report?.sdk_run_id || null;
-        if ((workerProcessReport?.backend_child_process_ids || []).length || sdkThreadId) {
-            await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
-                schema: 'sks.zellij-worker-pane-event.v1',
-                ts: nowIso(),
-                event_type: 'codex_sdk_thread_started',
-                mission_id: this.input.missionId,
-                slot_id: slotId,
-                generation_index: input.ctx.agent.generation_index || null,
-                session_id: input.ctx.agent.session_id,
-                child_process_ids: workerProcessReport?.backend_child_process_ids || [],
-                sdk_thread_id: sdkThreadId,
-                sdk_run_id: sdkRunId
-            });
-        }
-        if (parsed) {
-            await appendJsonl(path.join(this.root, input.workerDirRel, 'zellij-worker-pane-events.jsonl'), {
-                schema: 'sks.zellij-worker-pane-event.v1',
-                ts: nowIso(),
-                event_type: 'result_written',
-                mission_id: this.input.missionId,
-                slot_id: slotId,
-                generation_index: input.ctx.agent.generation_index || null,
-                session_id: input.ctx.agent.session_id,
-                result_path: input.resultRel
-            });
-            await this.telemetry(input.ctx, {
-                eventType: 'artifact_written',
-                status: 'verifying',
-                artifacts: [input.resultRel],
-                logTail: parsed.summary || 'worker result written'
-            });
-        }
-        input.record.pid = Number(workerProcessReport?.pid || processRun?.pid) || null;
-        input.record.process_id = input.record.pid;
-        if (!loopHandle && input.record.pid) {
-            loopHandle = await registerLoopWorkerHandle({
-                root: input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(),
-                env: input.ctx.opts.env || {},
-                agentId: String(input.ctx.agent.id || input.ctx.agent.session_id || 'agent'),
-                sessionId: input.ctx.agent.session_id || null,
-                pid: 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);
-        input.record.structured_output_valid = workerProcessReport?.structured_output_valid === true || workerProcessReport?.backend_router_report?.structured_output_valid === true;
-        input.record.exit_code = parsed ? (parsed.status === 'done' ? 0 : 1) : 1;
-        input.record.status = parsed?.status === 'done' ? 'closed' : 'failed';
-        if (loopHandle) {
-            await markLoopWorkerInterrupted(input.ctx.opts.projectRoot || this.input.projectRoot || input.ctx.opts.cwd || packageRoot(), loopHandle.mission_id, loopHandle.worker_id, input.record.status === 'closed' ? 'completed' : 'failed').catch(() => undefined);
-        }
-        const heartbeatOk = await hasHeartbeat(path.join(this.root, input.heartbeatRel));
-        input.record.blockers = [
-            ...(parsed ? parsed.blockers || [] : ['zellij_worker_result_timeout']),
-            ...(heartbeatOk ? [] : [])
-        ];
-        if (!heartbeatOk)
-            input.record.warnings = [...(input.record.warnings || []), 'zellij_worker_heartbeat_missing'];
-        paneRecord = await closeWorkerPane({
-            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,
-            sdkRunId,
-            streamEventCount: input.record.stream_event_count,
-            structuredOutputValid: input.record.structured_output_valid,
-            workerResultPath: input.resultRel
-        });
-        input.record.zellij_worker_pane_closed_at = paneRecord.closed_at;
-        await this.record(input.record);
-        if (!parsed) {
-            await this.telemetry(input.ctx, {
-                eventType: 'worker_failed',
-                status: 'failed',
-                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
-                blockers: input.record.blockers,
-                logTail: 'Zellij pane worker result timed out.'
-            });
-            return validateAgentWorkerResult({
-                mission_id: this.input.missionId,
-                agent_id: input.ctx.agent.id,
-                session_id: input.ctx.agent.session_id,
-                persona_id: input.ctx.agent.persona_id || input.ctx.agent.id,
-                task_slice_id: input.ctx.slice?.id || '',
-                status: 'failed',
-                backend: this.input.backend,
-                summary: 'Zellij pane worker result timed out.',
-                artifacts: [input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')],
-                blockers: input.record.blockers,
-                unverified: [],
-                writes: [],
-                source_intelligence_refs: input.ctx.agent.source_intelligence_refs || null,
-                goal_mode_ref: input.ctx.agent.goal_mode_ref || null
-            });
-        }
-        await this.telemetry(input.ctx, {
-            eventType: parsed.status === 'done' ? 'worker_completed' : 'worker_failed',
-            status: parsed.status === 'done' ? 'completed' : 'failed',
-            artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')])],
-            blockers: input.record.blockers,
-            changedFiles: changedFilesFromWorkerResult(parsed),
-            logTail: parsed.summary || ''
-        });
-        return validateAgentWorkerResult({
-            ...parsed,
-            blockers: input.record.blockers,
-            artifacts: [...new Set([...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), input.stdoutRel, input.stderrRel, path.join(input.workerDirRel, 'zellij-worker-pane.json')])]
-        });
-    }
-    async waitForWorkerResultWithActivity(input) {
-        const inactivityTimeoutMs = Math.max(1000, Number(process.env.SKS_ZELLIJ_WORKER_INACTIVITY_TIMEOUT_MS || 300000));
-        const absoluteCapRaw = Number(process.env.SKS_ZELLIJ_WORKER_RESULT_TIMEOUT_MS ?? 3600000);
-        const absoluteCapMs = Number.isFinite(absoluteCapRaw) ? absoluteCapRaw : 3600000;
-        const start = Date.now();
-        let lastActivityMs = start;
-        let lastHeartbeatEmit = 0;
-        for (;;) {
-            const result = await readJson(input.resultPath, null).catch(() => null);
-            if (result)
-                return result;
-            const now = Date.now();
-            const newestActivity = await newestMtimeMs(input.activityPaths);
-            if (newestActivity != null && newestActivity > lastActivityMs)
-                lastActivityMs = newestActivity;
-            if (absoluteCapMs > 0 && now - start >= absoluteCapMs)
-                return null;
-            if (now - lastActivityMs >= inactivityTimeoutMs)
-                return null;
-            if (now - lastHeartbeatEmit >= 10000) {
-                lastHeartbeatEmit = now;
-                await this.telemetry(input.ctx, {
-                    eventType: 'heartbeat',
-                    status: 'running',
-                    artifacts: [input.heartbeatRel, input.resultRel, input.stdoutRel, input.stderrRel],
-                    logTail: await tailFile(input.stdoutPath, 600)
-                });
-            }
-            await new Promise((resolve) => setTimeout(resolve, 250));
-        }
-    }
     async finalize() {
         await this.persist();
         return this.summary();
@@ -672,27 +230,7 @@ class NativeCliWorkerRuntimeRecorder {
             this.records.push(record);
         await this.persist();
     }
-    async telemetry(ctx, input) {
-        await appendZellijSlotTelemetry(this.root, {
-            schema: 'sks.zellij-slot-telemetry-event.v1',
-            ts: nowIso(),
-            mission_id: this.input.missionId,
-            slot_id: String(ctx.agent?.slot_id || ctx.agent?.id || 'slot-001'),
-            generation_index: Number(ctx.agent?.generation_index || 1),
-            worker_id: String(ctx.agent?.id || ctx.agent?.slot_id || 'worker'),
-            event_type: input.eventType,
-            status: input.status,
-            role: String(ctx.agent?.naruto_role || ctx.agent?.role || ctx.agent?.persona_id || ctx.agent?.id || 'worker'),
-            backend: this.input.backend,
-            service_tier: this.input.fastModePolicy.service_tier,
-            worktree_id: ctx.agent?.worktree?.id || ctx.slice?.worktree?.id || null,
-            worktree_path: ctx.agent?.worktree?.path || ctx.slice?.worktree?.path || null,
-            task_title: String(ctx.slice?.description || ctx.slice?.title || ctx.slice?.id || 'worker task'),
-            current_file: firstString([ctx.slice?.write_paths?.[0], ctx.slice?.readonly_paths?.[0], ctx.slice?.input_files?.[0]]) || null,
-            artifact_paths: input.artifacts || [],
-            log_tail: input.logTail || '',
-            blockers: input.blockers || []
-        }).catch(() => undefined);
+    async lifecycle(ctx, input) {
         if (input.eventType === 'worker_completed' || input.eventType === 'worker_failed') {
             await appendAgentMessage(this.root, {
                 from: String(ctx.agent?.slot_id || ctx.agent?.id || 'worker'),
@@ -702,25 +240,25 @@ class NativeCliWorkerRuntimeRecorder {
                 body: input.logTail || input.eventType
             }).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 || [],
-                    changed_files: input.changedFiles || [],
-                    blockers: input.blockers || []
-                }
-            }).catch(() => undefined);
-        }
+        const parallelEvent = mapLifecycleToParallelEvent(input.eventType);
+        if (!parallelEvent)
+            return;
+        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: 'process',
+            worktree_id: ctx.agent?.worktree?.id || ctx.slice?.worktree?.id || null,
+            meta: {
+                status: input.status,
+                artifacts: input.artifacts || [],
+                changed_files: input.changedFiles || [],
+                blockers: input.blockers || []
+            }
+        }).catch(() => undefined);
     }
     async persist() {
         this.writeLock = this.writeLock.catch(() => undefined).then(async () => {
@@ -730,9 +268,6 @@ class NativeCliWorkerRuntimeRecorder {
     }
     summary() {
         const closed = this.records.filter((row) => row.status === 'closed');
-        const processIds = this.records.map((row) => row.pid).filter((pid) => Number.isFinite(Number(pid)));
-        const paneBackedRecords = this.records.filter((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane'
-            || row.scaling_primitive === 'native_cli_process_with_zellij_slot_renderer');
         return {
             schema: NATIVE_CLI_WORKER_RUNTIME_SCHEMA,
             generated_at: nowIso(),
@@ -740,24 +275,17 @@ class NativeCliWorkerRuntimeRecorder {
             mission_id: this.input.missionId,
             route: this.input.route,
             backend: this.input.backend,
-            scaling_primitive: this.records.some((row) => row.scaling_primitive === 'native_cli_process_in_zellij_worker_pane')
-                ? 'native_cli_process_in_zellij_worker_pane'
-                : paneBackedRecords.length
-                    ? 'native_cli_process_with_zellij_slot_renderer'
-                    : 'native_cli_process',
-            zellij_pane_worker_sessions: paneBackedRecords.length,
+            scaling_primitive: 'native_cli_process',
             requested_agents: this.input.requestedAgents,
             target_active_slots: this.input.targetActiveSlots,
             spawned_worker_process_count: this.records.length,
             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,
-            process_ids: processIds,
+            process_ids: this.records.map((row) => row.pid).filter((pid) => Number.isFinite(Number(pid))),
             worker_command_lines: this.records.map((row) => row.command_line),
             stdout_logs: this.records.map((row) => row.stdout_log),
             stderr_logs: this.records.map((row) => row.stderr_log),
@@ -768,96 +296,30 @@ class NativeCliWorkerRuntimeRecorder {
             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));
-    }
-    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]) => `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)))}` : ':';
-    const header = input.header ? `printf '%s\\n' ${shellQuote(input.header)} | tee -a ${shellQuote(input.stdoutPath)};` : '';
-    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 [
-        '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 newestMtimeMs(files) {
-    let newest = null;
-    for (const file of files) {
-        try {
-            const mtime = (await fs.promises.stat(file)).mtimeMs;
-            if (newest == null || mtime > newest)
-                newest = mtime;
-        }
-        catch {
-        }
-    }
-    return newest;
-}
-async function waitForWorkerHeartbeat(file, timeoutMs) {
-    const deadline = Date.now() + Math.max(1000, timeoutMs);
-    while (Date.now() < deadline) {
-        if (await hasHeartbeat(file))
-            return true;
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    return false;
 }
-async function hasHeartbeat(file) {
-    try {
-        const text = await fs.promises.readFile(file, 'utf8');
-        return text.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
+function terminateChildOnAbort(child, signal) {
+    if (!signal)
+        return () => undefined;
+    let hardKillTimer = null;
+    const terminate = () => {
+        if (child.exitCode !== null || child.signalCode !== null)
+            return;
+        child.kill('SIGTERM');
+        hardKillTimer = setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL');
+        }, 1500);
+        hardKillTimer.unref?.();
+    };
+    if (signal.aborted)
+        terminate();
+    else
+        signal.addEventListener('abort', terminate, { once: true });
+    return () => {
+        signal.removeEventListener('abort', terminate);
+        if (hardKillTimer)
+            clearTimeout(hardKillTimer);
+    };
 }
 async function resolveWorkerEntrypointPath() {
     const distEntrypoint = path.join(packageRoot(), 'dist', 'core', 'agents', 'native-cli-worker-entry.js');
@@ -868,9 +330,6 @@ async function resolveWorkerEntrypointPath() {
 function redactWorkerArgs(args) {
     return args.map((arg, index) => index > 0 && args[index - 1] === '--intake' ? '<worker-intake.json>' : arg);
 }
-function shellQuote(value) {
-    return `'${String(value).replace(/'/g, `'\\''`)}'`;
-}
 function normalizeWorkerWorktree(value) {
     const pathValue = value?.path || value?.worktree_path;
     if (!pathValue)
@@ -882,15 +341,7 @@ function normalizeWorkerWorktree(value) {
         main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
     };
 }
-function firstString(values) {
-    for (const value of values) {
-        const text = String(value || '').trim();
-        if (text)
-            return text;
-    }
-    return null;
-}
-function mapTelemetryToParallelEvent(eventType) {
+function mapLifecycleToParallelEvent(eventType) {
     if (eventType === 'slot_reserved')
         return 'slot_reserved';
     if (eventType === 'heartbeat')
@@ -911,12 +362,6 @@ function changedFilesFromWorkerResult(result) {
     ]);
     return [...new Set([...direct, ...envelopeFiles].map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\/+/, '')).filter(Boolean))];
 }
-function normalizeParallelPlacement(value) {
-    const text = String(value || '');
-    if (text === 'zellij-pane' || text === 'process' || text === 'headless' || text === 'headless_by_design_viewport_ui')
-        return text;
-    return 'unknown';
-}
 async function registerLoopWorkerHandle(input) {
     const missionId = String(input.env.SKS_MISSION_ID || input.env.SKS_PARENT_MISSION_ID || '').trim();
     const loopId = String(input.env.SKS_LOOP_ID || '').trim();
@@ -933,26 +378,3 @@ async function registerLoopWorkerHandle(input) {
         interrupt_supported: Boolean(input.pid || input.sessionId)
     }).catch(() => null);
 }
-async function tailFile(file, max) {
-    try {
-        const text = await fs.promises.readFile(file, 'utf8');
-        return text.length > max ? text.slice(-max) : text;
-    }
-    catch {
-        return '';
-    }
-}
-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;
-}