sneakoscope 2.0.14 → 2.0.16

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

@@ -9,6 +9,8 @@ import { closeWorkerInRightColumn, recordHeadlessWorkerInRightColumn } from '../
 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 { 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);
@@ -112,6 +114,12 @@ class NativeCliSessionSwarmRecorder {
             ? this.reserveVisibleZellijPane(ctx.opts, String(ctx.agent.session_id || ctx.agent.id || `${Date.now()}:${Math.random()}`))
             : null;
         const useZellijPane = Boolean(zellijReservation);
+        await this.telemetry(ctx, {
+            eventType: 'slot_reserved',
+            status: placement === 'zellij-pane' && !useZellijPane ? 'headless' : 'queued',
+            artifacts: [intakeRel, heartbeatRel, resultRel],
+            logTail: `placement=${placement}`
+        });
         if (useZellijPane) {
             stdout.end();
             stderr.end();
@@ -130,6 +138,12 @@ class NativeCliSessionSwarmRecorder {
         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,
@@ -162,6 +176,22 @@ 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',
+            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);
@@ -194,6 +224,13 @@ class NativeCliSessionSwarmRecorder {
         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, {
+                eventType: 'worker_failed',
+                status: 'failed',
+                artifacts: [stdoutRel, stderrRel],
+                blockers: record.blockers,
+                logTail: 'Native CLI worker result missing.'
+            });
             await this.record(record);
             return validateAgentWorkerResult({
                 mission_id: this.input.missionId,
@@ -218,6 +255,13 @@ class NativeCliSessionSwarmRecorder {
         });
         record.status = result.status === 'done' ? 'closed' : result.status;
         record.blockers = result.blockers || [];
+        await this.telemetry(ctx, {
+            eventType: result.status === 'done' ? 'worker_completed' : 'worker_failed',
+            status: result.status === 'done' ? 'completed' : 'failed',
+            artifacts: result.artifacts || [],
+            blockers: result.blockers || [],
+            logTail: result.summary || ''
+        });
         await this.record(record);
         return result;
     }
@@ -250,6 +294,12 @@ class NativeCliSessionSwarmRecorder {
             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 = uiMode === 'full-debug'
             ? buildPaneWorkerCommand({
                 args: input.args,
@@ -282,6 +332,30 @@ class NativeCliSessionSwarmRecorder {
                 mode: uiMode,
                 watch: true
             });
+        const processRun = uiMode === 'full-debug'
+            ? null
+            : await this.spawnCompactSlotWorkerProcess({
+                args: input.args,
+                cwd: workerCwd,
+                env: workerEnv,
+                stdoutRel: input.stdoutRel,
+                stderrRel: input.stderrRel
+            });
+        if (processRun?.pid) {
+            input.record.pid = processRun.pid;
+            input.record.process_id = processRun.pid;
+            await 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({
@@ -328,7 +402,9 @@ class NativeCliSessionSwarmRecorder {
             if (input.zellijReservation)
                 this.releaseVisibleZellijReservation(input.zellijReservation);
         }
-        const launchBlockers = paneRecord.blockers || [];
+        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', uiMode === 'full-debug' ? '<native-cli-worker-command>' : '<zellij-slot-pane-renderer-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
@@ -346,11 +422,26 @@ class NativeCliSessionSwarmRecorder {
         input.record.slot_visualization = uiMode === 'full-debug' ? 'worker-command-pane' : 'zellij-slot-pane-renderer';
         input.record.status = launchBlockers.length ? 'failed' : 'running';
         input.record.blockers = launchBlockers;
+        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,
@@ -369,21 +460,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));
+        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(),
@@ -426,6 +514,12 @@ class NativeCliSessionSwarmRecorder {
                 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;
@@ -440,8 +534,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,
@@ -458,6 +554,13 @@ class NativeCliSessionSwarmRecorder {
         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,
@@ -475,6 +578,13 @@ class NativeCliSessionSwarmRecorder {
                 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,
+            logTail: parsed.summary || ''
+        });
         return validateAgentWorkerResult({
             ...parsed,
             blockers: input.record.blockers,
@@ -493,6 +603,46 @@ class NativeCliSessionSwarmRecorder {
             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);
+        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 () => {
             await writeJsonAtomic(path.join(this.root, 'agent-native-cli-session-swarm.json'), this.summary());
@@ -656,6 +806,40 @@ 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) {
+    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');
+        return text.length > max ? text.slice(-max) : text;
+    }
+    catch {
+        return '';
+    }
+}
 async function waitForChildExit(child, exitPromise, timeoutMs) {
     let timer = null;
     const timeout = new Promise((resolve) => {

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

@@ -4,6 +4,7 @@ import { scanAgentTextForRecursion } from './agent-recursion-guard.js';
 import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
 import { resolveFastModePolicy } from './fast-mode-policy.js';
 import { runNativeWorkerBackendRouter } from './native-worker-backend-router.js';
+import { appendZellijSlotTelemetry } from '../zellij/zellij-slot-telemetry.js';
 export const NATIVE_CLI_WORKER_SCHEMA = 'sks.native-cli-worker.v1';
 export async function runNativeCliWorkerFromArgs(args = []) {
     const parsed = parseNativeCliWorkerArgs(args);
@@ -85,6 +86,14 @@ export async function runNativeCliWorker(input = {}) {
         strategy_refs: slice.strategy_refs || intake.strategy_refs || null,
         no_recursive_orchestrator_guard: guard.ok
     });
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: 'task_started',
+        status: 'running',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: [path.join(workerDirRel, 'worker-intake.json'), heartbeatRel],
+        logTail: String(slice.description || slice.title || slice.id || 'worker task started')
+    });
     await appendJsonl(path.resolve(agentRoot, heartbeatRel), {
         schema: 'sks.native-cli-worker-heartbeat.v1',
         ts: nowIso(),
@@ -96,6 +105,14 @@ export async function runNativeCliWorker(input = {}) {
         fast_mode: policy.fast_mode,
         service_tier: policy.service_tier
     });
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: 'heartbeat',
+        status: 'running',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: [heartbeatRel],
+        logTail: 'worker heartbeat started'
+    });
     await writeJsonAtomic(path.join(workerDir, 'worker-fast-mode.json'), {
         schema: 'sks.native-cli-worker-fast-mode.v1',
         generated_at: nowIso(),
@@ -131,6 +148,14 @@ export async function runNativeCliWorker(input = {}) {
             proof_level: routed.report.proof_level,
             envelopes: patchEnvelopes
         });
+        await workerTelemetry(agentRoot, intake, agent, slice, {
+            eventType: 'patch_candidate',
+            status: 'running',
+            backend,
+            serviceTier: policy.service_tier,
+            artifacts: [patchRel],
+            logTail: `patch envelopes ${patchEnvelopes.length}`
+        });
     }
     else {
         noPatchReason = {
@@ -145,6 +170,15 @@ export async function runNativeCliWorker(input = {}) {
             blockers: Array.isArray(slice.write_paths) && slice.write_paths.length && backend !== 'fake' ? ['write_capable_no_patch_envelope'] : []
         };
         await writeJsonAtomic(path.join(workerDir, 'worker-no-patch-reason.json'), noPatchReason);
+        await workerTelemetry(agentRoot, intake, agent, slice, {
+            eventType: 'artifact_written',
+            status: 'running',
+            backend,
+            serviceTier: policy.service_tier,
+            artifacts: [path.join(workerDirRel, 'worker-no-patch-reason.json')],
+            blockers: noPatchReason.blockers || [],
+            logTail: noPatchReason.reason
+        });
     }
     const minRuntimeMs = Number(intake.min_runtime_ms || input.minRuntimeMs || 0);
     if (Number.isFinite(minRuntimeMs) && minRuntimeMs > 0)
@@ -226,6 +260,15 @@ export async function runNativeCliWorker(input = {}) {
         recursion_guard: { ok: guard.ok, violations: guard.violations }
     });
     await writeJsonAtomic(path.resolve(agentRoot, resultRel), result);
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: result.status === 'done' ? 'worker_completed' : 'worker_failed',
+        status: result.status === 'done' ? 'completed' : 'failed',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: result.artifacts || [],
+        blockers: result.blockers || [],
+        logTail: result.summary || ''
+    });
     await writeJsonAtomic(path.join(workerDir, 'worker-session-proof.json'), {
         schema: 'sks.native-cli-worker-session-proof.v1',
         generated_at: nowIso(),
@@ -260,6 +303,15 @@ export async function runNativeCliWorker(input = {}) {
         session_id: agent.session_id,
         status: result.status
     });
+    await workerTelemetry(agentRoot, intake, agent, slice, {
+        eventType: 'heartbeat',
+        status: result.status === 'done' ? 'completed' : 'failed',
+        backend,
+        serviceTier: policy.service_tier,
+        artifacts: [heartbeatRel, resultRel],
+        blockers: result.blockers || [],
+        logTail: 'worker heartbeat finished'
+    });
     await writeJsonAtomic(path.join(workerDir, 'worker-terminal-close-report.json'), {
         schema: 'sks.native-cli-worker-terminal-close-report.v1',
         generated_at: nowIso(),
@@ -317,4 +369,37 @@ function normalizeWorkerWorktree(value) {
         main_repo_root: value?.main_repo_root == null ? null : String(value.main_repo_root)
     };
 }
+async function workerTelemetry(agentRoot, intake, agent, slice, input) {
+    const missionId = String(intake.mission_id || intake.parent_mission_id || '');
+    if (!missionId)
+        return;
+    await appendZellijSlotTelemetry(agentRoot, {
+        schema: 'sks.zellij-slot-telemetry-event.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        slot_id: String(agent.slot_id || agent.id || 'slot-001'),
+        generation_index: Number(agent.generation_index || 1),
+        worker_id: String(agent.id || agent.slot_id || 'worker'),
+        event_type: input.eventType,
+        status: input.status,
+        role: String(agent.naruto_role || agent.role || agent.persona_id || agent.id || 'worker'),
+        backend: input.backend,
+        service_tier: input.serviceTier,
+        worktree_id: agent.worktree?.id || slice.worktree?.id || intake.worktree?.id || null,
+        worktree_path: agent.worktree?.path || slice.worktree?.path || intake.worktree?.path || null,
+        task_title: String(slice.description || slice.title || slice.id || 'worker task'),
+        current_file: firstString([slice.write_paths?.[0], slice.readonly_paths?.[0], slice.input_files?.[0]]) || null,
+        artifact_paths: input.artifacts || [],
+        log_tail: input.logTail || '',
+        blockers: input.blockers || []
+    }).catch(() => undefined);
+}
+function firstString(values) {
+    for (const value of values) {
+        const text = String(value || '').trim();
+        if (text)
+            return text;
+    }
+    return null;
+}
 //# sourceMappingURL=native-cli-worker.js.map