@vm0/runner 2.8.1 → 2.8.3

package/index.js

@@ -27,7 +27,12 @@ var runnerConfigSchema = z.object({
     vcpu: z.number().int().min(1).default(2),
     memory_mb: z.number().int().min(128).default(2048),
     poll_interval_ms: z.number().int().min(1e3).default(5e3)
-  }).default({}),
+  }).default({
+    max_concurrent: 1,
+    vcpu: 2,
+    memory_mb: 2048,
+    poll_interval_ms: 5e3
+  }),
   firecracker: z.object({
     binary: z.string().min(1, "Firecracker binary path is required"),
     kernel: z.string().min(1, "Kernel path is required"),
@@ -35,7 +40,9 @@ var runnerConfigSchema = z.object({
   }),
   proxy: z.object({
     port: z.number().int().min(1024).max(65535).default(8080)
-  }).default({})
+  }).default({
+    port: 8080
+  })
 });
 var debugConfigSchema = z.object({
   name: z.string().default("debug-runner"),
@@ -43,13 +50,21 @@ var debugConfigSchema = z.object({
   server: z.object({
     url: z.string().url().default("http://localhost:3000"),
     token: z.string().default("debug-token")
-  }).default({}),
+  }).default({
+    url: "http://localhost:3000",
+    token: "debug-token"
+  }),
   sandbox: z.object({
     max_concurrent: z.number().int().min(1).default(1),
     vcpu: z.number().int().min(1).default(2),
     memory_mb: z.number().int().min(128).default(2048),
     poll_interval_ms: z.number().int().min(1e3).default(5e3)
-  }).default({}),
+  }).default({
+    max_concurrent: 1,
+    vcpu: 2,
+    memory_mb: 2048,
+    poll_interval_ms: 5e3
+  }),
   firecracker: z.object({
     binary: z.string().min(1, "Firecracker binary path is required"),
     kernel: z.string().min(1, "Kernel path is required"),
@@ -57,7 +72,9 @@ var debugConfigSchema = z.object({
   }),
   proxy: z.object({
     port: z.number().int().min(1024).max(65535).default(8080)
-  }).default({})
+  }).default({
+    port: 8080
+  })
 });
 function loadDebugConfig(configPath) {
   if (!fs.existsSync(configPath)) {
@@ -67,7 +84,7 @@ function loadDebugConfig(configPath) {
   const raw = yaml.parse(content);
   const result = debugConfigSchema.safeParse(raw);
   if (!result.success) {
-    const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+    const errors = result.error.issues.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
   }
@@ -81,7 +98,7 @@ function loadConfig(configPath) {
   const raw = yaml.parse(content);
   const result = runnerConfigSchema.safeParse(raw);
   if (!result.success) {
-    const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+    const errors = result.error.issues.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
     throw new Error(`Invalid configuration:
 ${errors}`);
   }
@@ -5897,6 +5914,13 @@ var metricDataSchema = z8.object({
   disk_used: z8.number(),
   disk_total: z8.number()
 });
+var sandboxOperationSchema = z8.object({
+  ts: z8.string(),
+  action_type: z8.string(),
+  duration_ms: z8.number(),
+  success: z8.boolean(),
+  error: z8.string().optional()
+});
 var networkLogSchema = z8.object({
   timestamp: z8.string(),
   // Common fields (all modes)
@@ -5916,7 +5940,7 @@ var networkLogSchema = z8.object({
 var webhookTelemetryContract = c5.router({
   /**
    * POST /api/webhooks/agent/telemetry
-   * Receive telemetry data (system log, metrics, and network logs) from sandbox
+   * Receive telemetry data (system log, metrics, network logs, and sandbox operations) from sandbox
    */
   send: {
     method: "POST",
@@ -5925,7 +5949,8 @@ var webhookTelemetryContract = c5.router({
       runId: z8.string().min(1, "runId is required"),
       systemLog: z8.string().optional(),
       metrics: z8.array(metricDataSchema).optional(),
-      networkLogs: z8.array(networkLogSchema).optional()
+      networkLogs: z8.array(networkLogSchema).optional(),
+      sandboxOperations: z8.array(sandboxOperationSchema).optional()
     }),
     responses: {
       200: z8.object({
@@ -7124,6 +7149,10 @@ NETWORK_LOG_FILE = f"/tmp/vm0-network-{RUN_ID}.jsonl"
 TELEMETRY_LOG_POS_FILE = f"/tmp/vm0-telemetry-log-pos-{RUN_ID}.txt"
 TELEMETRY_METRICS_POS_FILE = f"/tmp/vm0-telemetry-metrics-pos-{RUN_ID}.txt"
 TELEMETRY_NETWORK_POS_FILE = f"/tmp/vm0-telemetry-network-pos-{RUN_ID}.txt"
+TELEMETRY_SANDBOX_OPS_POS_FILE = f"/tmp/vm0-telemetry-sandbox-ops-pos-{RUN_ID}.txt"
+
+# Sandbox operations log file (JSONL format)
+SANDBOX_OPS_LOG_FILE = f"/tmp/vm0-sandbox-ops-{RUN_ID}.jsonl"
 
 # Metrics collection configuration
 METRICS_INTERVAL = 5  # seconds
@@ -7137,6 +7166,36 @@ def validate_config() -> bool:
     if not WORKING_DIR:
         raise ValueError("VM0_WORKING_DIR is required but not set")
     return True
+
+def record_sandbox_op(
+    action_type: str,
+    duration_ms: int,
+    success: bool,
+    error: str = None
+) -> None:
+    """
+    Record a sandbox operation to JSONL file for telemetry upload.
+
+    Args:
+        action_type: Operation name (e.g., "init_total", "storage_download", "cli_execution")
+        duration_ms: Duration in milliseconds
+        success: Whether the operation succeeded
+        error: Optional error message if failed
+    """
+    from datetime import datetime, timezone
+    import json
+
+    entry = {
+        "ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z",
+        "action_type": action_type,
+        "duration_ms": duration_ms,
+        "success": success,
+    }
+    if error:
+        entry["error"] = error
+
+    with open(SANDBOX_OPS_LOG_FILE, "a") as f:
+        f.write(json.dumps(entry) + "\\n")
 `;
 
 // ../../packages/core/src/sandbox/scripts/lib/log.py.ts
@@ -7575,10 +7634,11 @@ import hashlib
 import tarfile
 import tempfile
 import shutil
+import time
 from typing import Optional, Dict, Any, List
 from datetime import datetime
 
-from common import RUN_ID, STORAGE_PREPARE_URL, STORAGE_COMMIT_URL
+from common import RUN_ID, STORAGE_PREPARE_URL, STORAGE_COMMIT_URL, record_sandbox_op
 from log import log_info, log_warn, log_error, log_debug
 from http_client import http_post_json, http_put_presigned
 
@@ -7719,7 +7779,9 @@ def create_direct_upload_snapshot(
 
     # Step 1: Collect file metadata
     log_info("Computing file hashes...")
+    hash_start = time.time()
     files = collect_file_metadata(mount_path)
+    record_sandbox_op("artifact_hash_compute", int((time.time() - hash_start) * 1000), True)
     log_info(f"Found {len(files)} files")
 
     if not files:
@@ -7727,6 +7789,7 @@ def create_direct_upload_snapshot(
 
     # Step 2: Call prepare endpoint
     log_info("Calling prepare endpoint...")
+    prepare_start = time.time()
     prepare_payload = {
         "storageName": storage_name,
         "storageType": storage_type,
@@ -7738,12 +7801,15 @@ def create_direct_upload_snapshot(
     prepare_response = http_post_json(STORAGE_PREPARE_URL, prepare_payload)
     if not prepare_response:
         log_error("Failed to call prepare endpoint")
+        record_sandbox_op("artifact_prepare_api", int((time.time() - prepare_start) * 1000), False)
         return None
 
     version_id = prepare_response.get("versionId")
     if not version_id:
         log_error(f"Invalid prepare response: {prepare_response}")
+        record_sandbox_op("artifact_prepare_api", int((time.time() - prepare_start) * 1000), False)
         return None
+    record_sandbox_op("artifact_prepare_api", int((time.time() - prepare_start) * 1000), True)
 
     # Step 3: Check if version already exists (deduplication)
     # Still call commit to update HEAD pointer (fixes #649)
@@ -7786,10 +7852,13 @@ def create_direct_upload_snapshot(
     try:
         # Create archive
         log_info("Creating archive...")
+        archive_start = time.time()
         archive_path = os.path.join(temp_dir, "archive.tar.gz")
         if not create_archive(mount_path, archive_path):
             log_error("Failed to create archive")
+            record_sandbox_op("artifact_archive_create", int((time.time() - archive_start) * 1000), False)
             return None
+        record_sandbox_op("artifact_archive_create", int((time.time() - archive_start) * 1000), True)
 
         # Create manifest
         log_info("Creating manifest...")
@@ -7800,12 +7869,14 @@ def create_direct_upload_snapshot(
 
         # Upload archive to S3
         log_info("Uploading archive to S3...")
+        s3_upload_start = time.time()
         if not http_put_presigned(
             archive_info["presignedUrl"],
             archive_path,
             "application/gzip"
         ):
             log_error("Failed to upload archive to S3")
+            record_sandbox_op("artifact_s3_upload", int((time.time() - s3_upload_start) * 1000), False)
             return None
 
         # Upload manifest to S3
@@ -7816,10 +7887,13 @@ def create_direct_upload_snapshot(
             "application/json"
         ):
             log_error("Failed to upload manifest to S3")
+            record_sandbox_op("artifact_s3_upload", int((time.time() - s3_upload_start) * 1000), False)
             return None
+        record_sandbox_op("artifact_s3_upload", int((time.time() - s3_upload_start) * 1000), True)
 
         # Step 6: Call commit endpoint
         log_info("Calling commit endpoint...")
+        commit_start = time.time()
         commit_payload = {
             "storageName": storage_name,
             "storageType": storage_type,
@@ -7834,11 +7908,14 @@ def create_direct_upload_snapshot(
         commit_response = http_post_json(STORAGE_COMMIT_URL, commit_payload)
         if not commit_response:
             log_error("Failed to call commit endpoint")
+            record_sandbox_op("artifact_commit_api", int((time.time() - commit_start) * 1000), False)
             return None
 
         if not commit_response.get("success"):
             log_error(f"Commit failed: {commit_response}")
+            record_sandbox_op("artifact_commit_api", int((time.time() - commit_start) * 1000), False)
             return None
+        record_sandbox_op("artifact_commit_api", int((time.time() - commit_start) * 1000), True)
 
         log_info(f"Direct upload snapshot created: {version_id[:8]}")
         return {"versionId": version_id}
@@ -7861,11 +7938,12 @@ import sys
 import json
 import tarfile
 import tempfile
+import time
 
 # Add lib to path for imports
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
-from common import validate_config
+from common import validate_config, record_sandbox_op
 from log import log_info, log_error
 from http_client import http_download
 
@@ -7945,13 +8023,21 @@ def main():
 
     log_info(f"Found {storage_count} storages, artifact: {has_artifact}")
 
+    # Track total download time
+    download_total_start = time.time()
+    download_success = True
+
     # Process storages
     for storage in storages:
         mount_path = storage.get("mountPath")
         archive_url = storage.get("archiveUrl")
 
         if archive_url and archive_url != "null":
-            download_storage(mount_path, archive_url)
+            storage_start = time.time()
+            success = download_storage(mount_path, archive_url)
+            record_sandbox_op("storage_download", int((time.time() - storage_start) * 1000), success)
+            if not success:
+                download_success = False
 
     # Process artifact
     if artifact:
@@ -7959,8 +8045,14 @@ def main():
         artifact_url = artifact.get("archiveUrl")
 
         if artifact_url and artifact_url != "null":
-            download_storage(artifact_mount, artifact_url)
-
+            artifact_start = time.time()
+            success = download_storage(artifact_mount, artifact_url)
+            record_sandbox_op("artifact_download", int((time.time() - artifact_start) * 1000), success)
+            if not success:
+                download_success = False
+
+    # Record total download time
+    record_sandbox_op("download_total", int((time.time() - download_total_start) * 1000), download_success)
     log_info("All storages downloaded successfully")
 
 
@@ -7977,12 +8069,14 @@ Uses direct S3 upload exclusively (no fallback to legacy methods).
 """
 import os
 import glob
+import time
 from typing import Optional, Dict, Any
 
 from common import (
     RUN_ID, CHECKPOINT_URL,
     SESSION_ID_FILE, SESSION_HISTORY_PATH_FILE,
-    ARTIFACT_DRIVER, ARTIFACT_MOUNT_PATH, ARTIFACT_VOLUME_NAME
+    ARTIFACT_DRIVER, ARTIFACT_MOUNT_PATH, ARTIFACT_VOLUME_NAME,
+    record_sandbox_op
 )
 from log import log_info, log_error
 from http_client import http_post_json
@@ -8038,19 +8132,27 @@ def create_checkpoint() -> bool:
     Returns:
         True on success, False on failure
     """
+    checkpoint_start = time.time()
     log_info("Creating checkpoint...")
 
     # Read session ID from temp file
+    session_id_start = time.time()
     if not os.path.exists(SESSION_ID_FILE):
         log_error("No session ID found, checkpoint creation failed")
+        record_sandbox_op("session_id_read", int((time.time() - session_id_start) * 1000), False, "Session ID file not found")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     with open(SESSION_ID_FILE) as f:
         cli_agent_session_id = f.read().strip()
+    record_sandbox_op("session_id_read", int((time.time() - session_id_start) * 1000), True)
 
     # Read session history path from temp file
+    session_history_start = time.time()
     if not os.path.exists(SESSION_HISTORY_PATH_FILE):
         log_error("No session history path found, checkpoint creation failed")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Session history path file not found")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     with open(SESSION_HISTORY_PATH_FILE) as f:
@@ -8061,6 +8163,8 @@ def create_checkpoint() -> bool:
         parts = session_history_path_raw.split(":", 2)
         if len(parts) != 3:
             log_error(f"Invalid Codex search marker format: {session_history_path_raw}")
+            record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Invalid Codex search marker")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
         sessions_dir = parts[1]
         codex_session_id = parts[2]
@@ -8068,6 +8172,8 @@ def create_checkpoint() -> bool:
         session_history_path = find_codex_session_file(sessions_dir, codex_session_id)
         if not session_history_path:
             log_error(f"Could not find Codex session file for {codex_session_id} in {sessions_dir}")
+            record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Codex session file not found")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
     else:
         session_history_path = session_history_path_raw
@@ -8075,6 +8181,8 @@ def create_checkpoint() -> bool:
     # Check if session history file exists
     if not os.path.exists(session_history_path):
         log_error(f"Session history file not found at {session_history_path}, checkpoint creation failed")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Session history file not found")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     # Read session history
@@ -8083,14 +8191,19 @@ def create_checkpoint() -> bool:
             cli_agent_session_history = f.read()
     except IOError as e:
         log_error(f"Failed to read session history: {e}")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, str(e))
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     if not cli_agent_session_history.strip():
         log_error("Session history is empty, checkpoint creation failed")
+        record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), False, "Session history empty")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 
     line_count = len(cli_agent_session_history.strip().split("\\n"))
     log_info(f"Session history loaded ({line_count} lines)")
+    record_sandbox_op("session_history_read", int((time.time() - session_history_start) * 1000), True)
 
     # CLI agent type (default to claude-code)
     cli_agent_type = os.environ.get("CLI_AGENT_TYPE", "claude-code")
@@ -8104,6 +8217,7 @@ def create_checkpoint() -> bool:
 
         if ARTIFACT_DRIVER != "vas":
             log_error(f"Unknown artifact driver: {ARTIFACT_DRIVER} (only 'vas' is supported)")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
 
         # VAS artifact: create snapshot using direct S3 upload (bypasses Vercel 4.5MB limit)
@@ -8120,12 +8234,14 @@ def create_checkpoint() -> bool:
 
         if not snapshot:
             log_error("Failed to create VAS snapshot for artifact")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
 
         # Extract versionId from snapshot response
         artifact_version = snapshot.get("versionId")
         if not artifact_version:
             log_error("Failed to extract versionId from snapshot")
+            record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
             return False
 
         # Build artifact snapshot JSON with new format (artifactName + artifactVersion)
@@ -8153,6 +8269,7 @@ def create_checkpoint() -> bool:
         checkpoint_payload["artifactSnapshot"] = artifact_snapshot
 
     # Call checkpoint API
+    api_call_start = time.time()
     result = http_post_json(CHECKPOINT_URL, checkpoint_payload)
 
     # Validate response contains checkpointId to confirm checkpoint was actually created
@@ -8160,9 +8277,13 @@ def create_checkpoint() -> bool:
     if result and result.get("checkpointId"):
         checkpoint_id = result.get("checkpointId")
         log_info(f"Checkpoint created successfully: {checkpoint_id}")
+        record_sandbox_op("checkpoint_api_call", int((time.time() - api_call_start) * 1000), True)
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), True)
         return True
     else:
         log_error(f"Checkpoint API returned invalid response: {result}")
+        record_sandbox_op("checkpoint_api_call", int((time.time() - api_call_start) * 1000), False, "Invalid API response")
+        record_sandbox_op("checkpoint_total", int((time.time() - checkpoint_start) * 1000), False)
         return False
 `;
 
@@ -8556,8 +8677,9 @@ from typing import List, Dict, Any
 
 from common import (
     RUN_ID, TELEMETRY_URL, TELEMETRY_INTERVAL,
-    SYSTEM_LOG_FILE, METRICS_LOG_FILE, NETWORK_LOG_FILE,
-    TELEMETRY_LOG_POS_FILE, TELEMETRY_METRICS_POS_FILE, TELEMETRY_NETWORK_POS_FILE
+    SYSTEM_LOG_FILE, METRICS_LOG_FILE, NETWORK_LOG_FILE, SANDBOX_OPS_LOG_FILE,
+    TELEMETRY_LOG_POS_FILE, TELEMETRY_METRICS_POS_FILE, TELEMETRY_NETWORK_POS_FILE,
+    TELEMETRY_SANDBOX_OPS_POS_FILE
 )
 from log import log_info, log_error, log_debug, log_warn
 from http_client import http_post_json
@@ -8660,6 +8782,19 @@ def read_network_logs_from_position(pos_file: str) -> tuple[List[Dict[str, Any]]
     return read_jsonl_from_position(NETWORK_LOG_FILE, pos_file)
 
 
+def read_sandbox_ops_from_position(pos_file: str) -> tuple[List[Dict[str, Any]], int]:
+    """
+    Read new sandbox operations from JSONL file starting from last position.
+
+    Args:
+        pos_file: Path to position tracking file
+
+    Returns:
+        Tuple of (sandbox operations list, new_position)
+    """
+    return read_jsonl_from_position(SANDBOX_OPS_LOG_FILE, pos_file)
+
+
 def upload_telemetry() -> bool:
     """
     Upload telemetry data to VM0 API.
@@ -8676,8 +8811,11 @@ def upload_telemetry() -> bool:
     # Read new network logs
     network_logs, network_pos = read_network_logs_from_position(TELEMETRY_NETWORK_POS_FILE)
 
+    # Read new sandbox operations
+    sandbox_ops, sandbox_ops_pos = read_sandbox_ops_from_position(TELEMETRY_SANDBOX_OPS_POS_FILE)
+
     # Skip if nothing new
-    if not system_log and not metrics and not network_logs:
+    if not system_log and not metrics and not network_logs and not sandbox_ops:
         log_debug("No new telemetry data to upload")
         return True
 
@@ -8691,10 +8829,11 @@ def upload_telemetry() -> bool:
         "runId": RUN_ID,
         "systemLog": masked_system_log,
         "metrics": metrics,  # Metrics don't contain secrets (just numbers)
-        "networkLogs": masked_network_logs
+        "networkLogs": masked_network_logs,
+        "sandboxOperations": sandbox_ops  # Sandbox ops don't contain secrets (just timing data)
     }
 
-    log_debug(f"Uploading telemetry: {len(system_log)} bytes log, {len(metrics)} metrics, {len(network_logs)} network logs")
+    log_debug(f"Uploading telemetry: {len(system_log)} bytes log, {len(metrics)} metrics, {len(network_logs)} network logs, {len(sandbox_ops)} sandbox ops")
 
     result = http_post_json(TELEMETRY_URL, payload, max_retries=1)
 
@@ -8703,6 +8842,7 @@ def upload_telemetry() -> bool:
         save_position(TELEMETRY_LOG_POS_FILE, log_pos)
         save_position(TELEMETRY_METRICS_POS_FILE, metrics_pos)
         save_position(TELEMETRY_NETWORK_POS_FILE, network_pos)
+        save_position(TELEMETRY_SANDBOX_OPS_POS_FILE, sandbox_ops_pos)
         log_debug(f"Telemetry uploaded successfully: {result.get('id', 'unknown')}")
         return True
     else:
@@ -8940,7 +9080,7 @@ sys.path.insert(0, "/usr/local/bin/vm0-agent/lib")
 from common import (
     WORKING_DIR, PROMPT, RESUME_SESSION_ID, COMPLETE_URL, RUN_ID,
     EVENT_ERROR_FLAG, HEARTBEAT_URL, HEARTBEAT_INTERVAL, AGENT_LOG_FILE,
-    CLI_AGENT_TYPE, OPENAI_MODEL, validate_config
+    CLI_AGENT_TYPE, OPENAI_MODEL, validate_config, record_sandbox_op
 )
 from log import log_info, log_error, log_warn
 from events import send_event
@@ -8976,10 +9116,14 @@ def _cleanup(exit_code: int, error_message: str):
 
     # Perform final telemetry upload before completion
     # This ensures all remaining data is captured
+    telemetry_start = time.time()
+    telemetry_success = True
     try:
         final_telemetry_upload()
     except Exception as e:
+        telemetry_success = False
         log_error(f"Final telemetry upload failed: {e}")
+    record_sandbox_op("final_telemetry_upload", int((time.time() - telemetry_start) * 1000), telemetry_success)
 
     # Always call complete API at the end
     # This sends vm0_result (on success) or vm0_error (on failure) and kills the sandbox
@@ -8992,13 +9136,17 @@ def _cleanup(exit_code: int, error_message: str):
     if error_message:
         complete_payload["error"] = error_message
 
+    complete_start = time.time()
+    complete_success = False
     try:
         if http_post_json(COMPLETE_URL, complete_payload):
             log_info("Complete API called successfully")
+            complete_success = True
         else:
             log_error("Failed to call complete API (sandbox may not be cleaned up)")
     except Exception as e:
         log_error(f"Complete API call failed: {e}")
+    record_sandbox_op("complete_api_call", int((time.time() - complete_start) * 1000), complete_success)
 
     # Stop heartbeat thread
     shutdown_event.set()
@@ -9030,25 +9178,36 @@ def _run() -> tuple[int, str]:
     log_info(f"Working directory: {WORKING_DIR}")
 
     # Start heartbeat thread
+    heartbeat_start = time.time()
     heartbeat_thread = threading.Thread(target=heartbeat_loop, daemon=True)
     heartbeat_thread.start()
     log_info("Heartbeat thread started")
+    record_sandbox_op("heartbeat_start", int((time.time() - heartbeat_start) * 1000), True)
 
     # Start metrics collector thread
+    metrics_start = time.time()
     start_metrics_collector(shutdown_event)
     log_info("Metrics collector thread started")
+    record_sandbox_op("metrics_collector_start", int((time.time() - metrics_start) * 1000), True)
 
     # Start telemetry upload thread
+    telemetry_start = time.time()
     start_telemetry_upload(shutdown_event)
     log_info("Telemetry upload thread started")
+    record_sandbox_op("telemetry_upload_start", int((time.time() - telemetry_start) * 1000), True)
 
     # Create and change to working directory - raises RuntimeError if fails
     # Directory may not exist if no artifact/storage was downloaded (e.g., first run)
+    working_dir_start = time.time()
+    working_dir_success = True
     try:
         os.makedirs(WORKING_DIR, exist_ok=True)
         os.chdir(WORKING_DIR)
     except OSError as e:
+        working_dir_success = False
+        record_sandbox_op("working_dir_setup", int((time.time() - working_dir_start) * 1000), False, str(e))
         raise RuntimeError(f"Failed to create/change to working directory: {WORKING_DIR} - {e}") from e
+    record_sandbox_op("working_dir_setup", int((time.time() - working_dir_start) * 1000), working_dir_success)
 
     # Set up Codex configuration if using Codex CLI
     # Claude Code uses ~/.claude by default (no configuration needed)
@@ -9061,6 +9220,8 @@ def _run() -> tuple[int, str]:
         log_info(f"Codex home directory: {codex_home}")
 
         # Login with API key via stdin (recommended method)
+        codex_login_start = time.time()
+        codex_login_success = False
         api_key = os.environ.get("OPENAI_API_KEY", "")
         if api_key:
             result = subprocess.run(
@@ -9071,13 +9232,16 @@ def _run() -> tuple[int, str]:
             )
             if result.returncode == 0:
                 log_info("Codex authenticated with API key")
+                codex_login_success = True
             else:
                 log_error(f"Codex login failed: {result.stderr}")
         else:
             log_error("OPENAI_API_KEY not set")
+        record_sandbox_op("codex_login", int((time.time() - codex_login_start) * 1000), codex_login_success)
 
-    init_duration = int(time.time() - init_start_time)
-    log_info(f"\u2713 Initialization complete ({init_duration}s)")
+    init_duration_ms = int((time.time() - init_start_time) * 1000)
+    record_sandbox_op("init_total", init_duration_ms, True)
+    log_info(f"\u2713 Initialization complete ({init_duration_ms // 1000}s)")
 
     # Lifecycle: Execution
     log_info("\u25B7 Execution")
@@ -9241,12 +9405,13 @@ def _run() -> tuple[int, str]:
         final_exit_code = 1
         error_message = "Some events failed to send"
 
-    # Log execution result
-    exec_duration = int(time.time() - exec_start_time)
+    # Log execution result and record metric
+    exec_duration_ms = int((time.time() - exec_start_time) * 1000)
+    record_sandbox_op("cli_execution", exec_duration_ms, agent_exit_code == 0)
     if agent_exit_code == 0 and final_exit_code == 0:
-        log_info(f"\u2713 Execution complete ({exec_duration}s)")
+        log_info(f"\u2713 Execution complete ({exec_duration_ms // 1000}s)")
     else:
-        log_info(f"\u2717 Execution failed ({exec_duration}s)")
+        log_info(f"\u2717 Execution failed ({exec_duration_ms // 1000}s)")
 
     # Handle completion
     if agent_exit_code == 0 and final_exit_code == 0:
@@ -10230,7 +10395,7 @@ function initMetrics(config) {
     url: "https://api.axiom.co/v1/metrics",
     headers: {
       Authorization: `Bearer ${config.axiomToken}`,
-      "X-Axiom-Dataset": `runner-metrics-${env}`
+      "X-Axiom-Dataset": `vm0-sandbox-op-log-${env}`
     }
   });
   meterProvider = new MeterProvider({
@@ -10700,6 +10865,42 @@ async function executeJob(context, config, options = {}) {
         completed = true;
         break;
       }
+      if (!options.benchmarkMode) {
+        const processCheck = await ssh.exec(
+          `pgrep -f "env-loader.py" > /dev/null 2>&1 && echo "RUNNING" || echo "DEAD"`
+        );
+        if (processCheck.stdout.trim() === "DEAD") {
+          log(
+            `[Executor] Agent process died unexpectedly without writing exit code`
+          );
+          const logContent = await ssh.exec(
+            `tail -50 ${systemLogFile} 2>/dev/null`
+          );
+          const dmesgCheck = await ssh.exec(
+            `dmesg | tail -20 | grep -iE "killed|oom" 2>/dev/null`
+          );
+          let errorMsg = "Agent process terminated unexpectedly";
+          if (dmesgCheck.stdout.toLowerCase().includes("oom") || dmesgCheck.stdout.toLowerCase().includes("killed")) {
+            errorMsg = "Agent process killed by OOM killer";
+            log(`[Executor] OOM detected: ${dmesgCheck.stdout}`);
+          }
+          if (logContent.stdout) {
+            log(
+              `[Executor] Last log output: ${logContent.stdout.substring(0, 500)}`
+            );
+          }
+          const durationMs2 = Date.now() - startTime;
+          recordRunnerOperation({
+            actionType: "agent_execute",
+            durationMs: durationMs2,
+            success: false
+          });
+          return {
+            exitCode: 1,
+            error: errorMsg
+          };
+        }
+      }
     }
     const durationMs = Date.now() - startTime;
     const duration = Math.round(durationMs / 1e3);
@@ -11099,7 +11300,7 @@ var benchmarkCommand = new Command3("benchmark").description(
 });
 
 // src/index.ts
-var version = true ? "2.8.1" : "0.1.0";
+var version = true ? "2.8.3" : "0.1.0";
 program.name("vm0-runner").version(version).description("Self-hosted runner for VM0 agents");
 program.addCommand(startCommand);
 program.addCommand(statusCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vm0/runner",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "description": "Self-hosted runner for VM0 agents",
   "repository": {
     "type": "git",
@@ -22,6 +22,6 @@
     "@opentelemetry/semantic-conventions": "^1.25.0",
     "commander": "^14.0.0",
     "yaml": "^2.3.4",
-    "zod": "^3.25.64"
+    "zod": "^4.1.12"
   }
 }