@aiden-ade/sandbox-agent 0.1.24 → 0.1.26

package/dist/index.cjs

@@ -9598,7 +9598,7 @@ var PRIORITY_OPTIONS = [
     detail: "Low",
     color: CATEGORICAL_COLORS.blueBright,
     iconClass: "text-blue-500/70 dark:text-blue-400/70",
-    flagClass: "text-primary"
+    flagClass: "text-blue-600 dark:text-blue-400"
   },
   {
     value: "none",
@@ -10225,10 +10225,7 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
           stdin.write(`${message}
 `);
         },
-        keepStdinOpen: true,
-        allowContinuation: true,
-        continuationIdleMs: 10 * 60 * 1e3
-        // 10 minutes
+        keepStdinOpen: true
       }).run(context);
     }
   };
@@ -10251,6 +10248,10 @@ function createImageTempDirectory(cwd) {
   }
   return (0, import_fs2.mkdtempSync)((0, import_path2.join)((0, import_os2.tmpdir)(), "aiden-images-"));
 }
+function safeFilename(filename) {
+  const safe = filename.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+/, "");
+  return safe || "attachment";
+}
 function writeImagesToTempFiles(images, cwd) {
   if (!images?.length) return { paths: [], files: [], cleanup: () => {
   } };
@@ -10281,6 +10282,48 @@ function writeImagesToTempFiles(images, cwd) {
     }
   };
 }
+function writeFilesToTempFiles(files, cwd) {
+  if (!files?.length) return { paths: [], files: [], cleanup: () => {
+  } };
+  const dataFiles = files.filter((file) => file.data !== void 0);
+  const existingFiles = files.filter((file) => file.tempPath && file.data === void 0);
+  const directory = dataFiles.length > 0 ? createImageTempDirectory(cwd) : null;
+  const paths = [];
+  const tempFiles = [];
+  for (const file of existingFiles) {
+    if (!file.tempPath) continue;
+    paths.push(file.tempPath);
+    tempFiles.push({
+      filename: file.filename,
+      mimeType: file.mimeType,
+      label: file.label,
+      path: file.tempPath
+    });
+  }
+  for (const file of dataFiles) {
+    if (!directory || file.data === void 0) continue;
+    const filePath = (0, import_path2.join)(directory, `${file.id}-${safeFilename(file.filename)}`);
+    (0, import_fs2.writeFileSync)(filePath, Buffer.from(file.data, "base64"));
+    paths.push(filePath);
+    tempFiles.push({
+      filename: file.filename,
+      mimeType: file.mimeType,
+      label: file.label,
+      path: filePath
+    });
+  }
+  return {
+    paths,
+    files: tempFiles,
+    cleanup: () => {
+      if (!directory) return;
+      try {
+        (0, import_fs2.rmSync)(directory, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
 function appendImagePathReferences(prompt, images) {
   if (images.length === 0) return prompt;
   const imageLines = images.map((img) => {
@@ -11452,6 +11495,17 @@ function isOpenCodeToolError(parsed, part) {
   const state = getRecord(part?.state) ?? getRecord(parsed.state);
   return part?.is_error === true || part?.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(parsed, part));
 }
+function getOpenCodePartId(parsed, part) {
+  return getString(part?.id) || getString(parsed.id) || getString(parsed.partID);
+}
+function resolveOpenCodeTextDelta(text, partId, state) {
+  if (!partId) return text;
+  state.opencodeTextByPartId ??= /* @__PURE__ */ new Map();
+  const previous = state.opencodeTextByPartId.get(partId) ?? "";
+  state.opencodeTextByPartId.set(partId, text);
+  if (!previous || !text.startsWith(previous)) return text;
+  return text.slice(previous.length);
+}
 function parseOpencodeStructuredLine(line, context, state) {
   const presenter = context.presenter;
   let parsed = null;
@@ -11475,8 +11529,10 @@ function parseOpencodeStructuredLine(line, context, state) {
     case "text": {
       const text = part && typeof part.text === "string" ? part.text : "";
       if (text) {
-        state.summary += text;
-        void presenter.onAssistantText(text);
+        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(parsed, part), state);
+        if (!delta) break;
+        state.summary += delta;
+        void presenter.onAssistantText(delta);
       }
       break;
     }
@@ -11614,6 +11670,10 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
         context.config.images,
         context.cwd
       );
+      const { paths: filePaths, cleanup: cleanupFiles } = writeFilesToTempFiles(
+        context.config.files,
+        context.cwd
+      );
       try {
         const runContext = withAutonomousOpenCodePermissions(context);
         return await createGenericCliBackend({
@@ -11630,7 +11690,8 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
             if (resumeId) args.push("--session", resumeId);
             const model = ctx.config.selectedModel?.trim();
             if (model?.includes("/")) args.push("--model", model);
-            const fileArgs = imagePaths.flatMap((p) => ["--file", p]);
+            const attachmentPaths = [...imagePaths, ...filePaths];
+            const fileArgs = attachmentPaths.flatMap((p) => ["--file", p]);
             if (fileArgs.length > 0) {
               return [...args, ...fileArgs, ...defaultArgs, "--", prompt];
             }
@@ -11644,6 +11705,7 @@ function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
         }).run(runContext);
       } finally {
         cleanup();
+        cleanupFiles();
       }
     }
   };
@@ -11849,7 +11911,8 @@ function canonicalizePath(inputPath) {
 }
 function buildPromptWithFiles(task, files) {
   if (!files || files.length === 0) return task;
-  const fileList = files.map((file) => `- ${file.filename} (${file.label}): ${file.tempPath}`).join("\n");
+  const fileList = files.filter((file) => file.tempPath).map((file) => `- ${file.filename} (${file.label}): ${file.tempPath}`).join("\n");
+  if (!fileList) return task;
   return `${task}
 
 The user has attached the following files. You can read them using your available tools:
@@ -12607,7 +12670,7 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.24";
+var AGENT_VERSION = "0.1.26";
 
 // src/daemon.ts
 var OPENCODE_FREE_MODEL_IDS = [
@@ -12621,6 +12684,23 @@ var PRODUCTION_API_URL = "https://api.aiden-platform.com";
 var PRODUCTION_WS_URL = "wss://ws.aiden-platform.com";
 var LOCAL_API_URL = "http://localhost:8400";
 var LOCAL_WS_URL = "ws://localhost:8401";
+function correlationLogFields(input) {
+  return Object.fromEntries(
+    Object.entries({
+      taskId: input.taskId,
+      conversationId: input.conversationId,
+      runId: input.runId,
+      messageId: input.messageId,
+      cloudEnvironmentId: input.cloudEnvironmentId,
+      provider: input.backendKind,
+      backendKind: input.backendKind,
+      agentVersion: input.agentVersion
+    }).filter((entry) => {
+      const value2 = entry[1];
+      return typeof value2 === "string" && value2.trim().length > 0;
+    }).map(([key, value2]) => [key, value2.trim()])
+  );
+}
 async function probeLocalDaemonEndpoint(port, token, timeoutMs = 750) {
   try {
     const headers = {};
@@ -12857,12 +12937,13 @@ async function collectRuntimeMetadataWithProviderLimits() {
   return metadata;
 }
 var RuntimePresenter = class {
-  constructor(socket, conversationId, runId, cwd, touchRunnerActivity) {
+  constructor(socket, conversationId, runId, cwd, touchRunnerActivity, onRunComplete) {
     this.socket = socket;
     this.conversationId = conversationId;
     this.runId = runId;
     this.cwd = cwd;
     this.touchRunnerActivity = touchRunnerActivity;
+    this.onRunComplete = onRunComplete;
   }
   emittedGeneratedImageKeys = /* @__PURE__ */ new Set();
   toolNamesById = /* @__PURE__ */ new Map();
@@ -12949,6 +13030,7 @@ var RuntimePresenter = class {
   }
   onComplete(result) {
     this.emitEvent({ type: "query_complete", result, ts: Date.now() });
+    this.onRunComplete?.();
   }
 };
 async function setupDaemon(args) {
@@ -12957,7 +13039,6 @@ async function setupDaemon(args) {
   const setupToken = argValue(args, "--setup-token") ?? process.env.AIDEN_RUNTIME_SETUP_TOKEN;
   const token = argValue(args, "--token") ?? process.env.AIDEN_SETUP_TOKEN;
   const displayName = argValue(args, "--name") ?? (0, import_node_os4.hostname)();
-  const legacyLocalMachineId = argValue(args, "--legacy-local-machine-id") ?? process.env.AIDEN_LEGACY_LOCAL_MACHINE_ID;
   const scope = argValue(args, "--scope") ?? process.env.AIDEN_RUNTIME_SCOPE ?? "team";
   if (scope !== "team" && scope !== "user") {
     throw new Error("setup --scope must be either 'team' or 'user'");
@@ -12980,7 +13061,6 @@ async function setupDaemon(args) {
         ...setupToken ? { setupToken } : {},
         displayName,
         hostname: (0, import_node_os4.hostname)(),
-        ...legacyLocalMachineId ? { legacyLocalMachineId } : {},
         runtimeKind: "machine",
         managementKind: "user_managed",
         hostKind: "daemon",
@@ -13149,19 +13229,34 @@ async function startDaemon(args) {
       return;
     }
     socket.emit("agent.accepted", { runId: payload.runId });
+    const correlation = correlationLogFields({
+      taskId: payload.taskId ?? payload.taskMeta?.id,
+      conversationId: payload.conversationId,
+      runId: payload.runId,
+      messageId: payload.messageId,
+      cloudEnvironmentId: payload.cloudEnvironmentId,
+      backendKind,
+      agentVersion: AGENT_VERSION
+    });
     pushLog(`accepted run=${payload.runId}`);
+    console.info("[aiden-agent] Agent run accepted", correlation);
     const cwd = payload.projectPath ?? process.cwd();
     const nowMs = Date.now();
     const touchActivity = () => {
       const entry = activeAgents.get(payload.runId);
       if (entry) entry.lastActivityAtMs = Date.now();
     };
+    const releaseActiveRun = () => {
+      if (!activeAgents.delete(payload.runId)) return;
+      console.info("[aiden-agent] Agent run finished", correlation);
+    };
     const presenter = new RuntimePresenter(
       socket,
       payload.conversationId,
       payload.runId,
       cwd,
-      touchActivity
+      touchActivity,
+      releaseActiveRun
     );
     const agent = new CoreAgent(presenter, {
       backendKind,
@@ -13190,21 +13285,26 @@ async function startDaemon(args) {
       taskMeta: payload.taskMeta,
       prMeta: payload.prMeta,
       conversationId: payload.conversationId,
-      taskId: payload.taskMeta?.id,
+      taskId: payload.taskId ?? payload.taskMeta?.id,
       teamId: payload.teamId,
       currentUser: payload.currentUser,
       workflowTools: payload.workflowTools,
-      images: payload.images
+      images: payload.images,
+      files: payload.files
     }).catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
       pushLog(`failed run=${payload.runId} ${message}`);
+      console.error("[aiden-agent] Agent run failed", {
+        ...correlation,
+        error: message
+      });
       socket.emit("agent.event", {
         conversationId: payload.conversationId,
         runId: payload.runId,
         event: { type: "session_error", error: message }
       });
     }).finally(() => {
-      activeAgents.delete(payload.runId);
+      releaseActiveRun();
     });
   });
   socket.on("agent.abort", (payload) => {
@@ -13214,6 +13314,10 @@ async function startDaemon(args) {
     abortActiveAgent(entry);
     activeAgents.delete(payload.runId);
     pushLog(`aborted run=${payload.runId}`);
+    console.info("[aiden-agent] Agent run aborted", {
+      runId: payload.runId,
+      agentVersion: AGENT_VERSION
+    });
   });
   socket.on(
     "agent.tool_response",
@@ -13542,6 +13646,78 @@ async function printDoctor(args = []) {
   );
 }
 
+// src/lifecycle-logger.ts
+var AgentLifecycleLogger = class _AgentLifecycleLogger {
+  context;
+  constructor(context = {}) {
+    this.context = normalizeContext(context);
+  }
+  setContext(context) {
+    this.context = normalizeContext({ ...this.context, ...context });
+  }
+  child(context) {
+    return new _AgentLifecycleLogger({ ...this.context, ...context });
+  }
+  debug(event, fields = {}) {
+    this.log("debug", event, fields);
+  }
+  info(event, fields = {}) {
+    this.log("info", event, fields);
+  }
+  warn(event, fields = {}) {
+    this.log("warn", event, fields);
+  }
+  error(event, fields = {}) {
+    this.log("error", event, fields);
+  }
+  log(level, event, fields) {
+    const record = omitUndefined({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component: "sandbox-agent",
+      event,
+      ...this.context,
+      ...normalizeFields(fields)
+    });
+    console[level](JSON.stringify(record));
+  }
+};
+function lifecycleContextFromEnv(env) {
+  return normalizeContext({
+    taskId: env.AIDEN_TASK_ID,
+    conversationId: env.AIDEN_SESSION_ID,
+    runId: env.AIDEN_RUN_ID,
+    sandboxId: env.AIDEN_SANDBOX_ID,
+    provider: env.AIDEN_SANDBOX_PROVIDER,
+    backendKind: env.AIDEN_BACKEND_KIND,
+    agentVersion: AGENT_VERSION
+  });
+}
+function normalizeContext(context) {
+  return omitUndefined({
+    ...context,
+    agentVersion: context.agentVersion ?? AGENT_VERSION
+  });
+}
+function normalizeFields(fields) {
+  const normalized = {};
+  for (const [key, value2] of Object.entries(fields)) {
+    if (value2 instanceof Error) {
+      normalized[key] = {
+        name: value2.name,
+        message: value2.message,
+        stack: value2.stack
+      };
+    } else {
+      normalized[key] = value2;
+    }
+  }
+  return normalized;
+}
+function omitUndefined(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value2]) => value2 !== void 0));
+}
+
 // src/web-presenter.ts
 var WebPresenter = class {
   constructor(wsClient, _conversationId, cwd) {
@@ -13660,8 +13836,9 @@ var WebPresenter = class {
 
 // src/ws-client.ts
 var WSClient = class {
-  socket;
-  constructor(wsUrl, sessionId, taskId, token, callbacks, agentVersion) {
+  constructor(wsUrl, sessionId, taskId, token, callbacks, agentVersion, lifecycle) {
+    this.lifecycle = lifecycle;
+    this.lifecycle?.info("sandbox_agent_ws_socket_create", { wsUrl });
     this.socket = lookup(wsUrl, {
       query: { type: "agent", sessionId, taskId, agentVersion: agentVersion ?? "" },
       auth: { token },
@@ -13676,6 +13853,7 @@ var WSClient = class {
     });
     this.setupListeners(callbacks);
   }
+  socket;
   emitEvent(event) {
     this.socket.emit("agent_event", event);
   }
@@ -13702,20 +13880,26 @@ var WSClient = class {
   get connected() {
     return this.socket.connected;
   }
+  setLifecycleContext(context) {
+    this.lifecycle?.setContext(context);
+  }
   close() {
+    this.lifecycle?.info("sandbox_agent_ws_close_requested");
     this.socket.disconnect();
   }
   setupListeners(callbacks) {
     this.socket.on("connect", () => {
-      console.debug("[WSClient] Connected to WS server");
+      this.lifecycle?.info("sandbox_agent_ws_socket_connected", { socketId: this.socket.id });
       callbacks.onConnect?.();
     });
     this.socket.on("disconnect", (reason) => {
-      console.debug(`[WSClient] Disconnected: ${reason}`);
+      this.lifecycle?.info("sandbox_agent_ws_socket_disconnected", { reason });
       callbacks.onDisconnect?.(reason);
     });
     this.socket.on("connect_error", (error) => {
-      console.warn(`[WSClient] Connection error: ${error.message}`);
+      this.lifecycle?.warn("sandbox_agent_ws_socket_connect_error", {
+        error: error instanceof Error ? error : new Error(String(error))
+      });
     });
     this.socket.on(
       "user_message",
@@ -13724,6 +13908,7 @@ var WSClient = class {
         callbacks.onUserMessage({
           text: data.text,
           images: data.images,
+          files: data.files,
           providerSessionId: data.providerSessionId,
           backendKind: data.backendKind,
           agentId: data.agentId,
@@ -13739,6 +13924,7 @@ var WSClient = class {
           messageId: data.messageId,
           maxIterations: data.maxIterations,
           taskId: data.taskId,
+          cloudEnvironmentId: data.cloudEnvironmentId,
           conversationId: data.conversationId,
           teamId: data.teamId,
           currentUser: data.currentUser
@@ -13754,17 +13940,39 @@ var WSClient = class {
       }
     });
     this.socket.on("error", (data) => {
-      console.error(`[WSClient] Server error: ${data.message} (${data.code})`);
+      this.lifecycle?.error("sandbox_agent_ws_server_error", {
+        message: data.message,
+        code: data.code
+      });
     });
   }
 };
 
 // src/sandbox.ts
+function correlationLogFields2(input) {
+  return Object.fromEntries(
+    Object.entries({
+      taskId: input.taskId,
+      conversationId: input.conversationId,
+      runId: input.runId,
+      messageId: input.messageId,
+      cloudEnvironmentId: input.cloudEnvironmentId,
+      provider: input.backendKind,
+      backendKind: input.backendKind,
+      agentVersion: input.agentVersion
+    }).filter((entry) => {
+      const value2 = entry[1];
+      return typeof value2 === "string" && value2.trim().length > 0;
+    }).map(([key, value2]) => [key, value2.trim()])
+  );
+}
 async function runSandbox(config) {
   let currentTask = config.task;
   let currentImages = [];
+  let currentFiles = [];
   const stopped = false;
   let pendingMessageResolve = null;
+  const queuedMessages = [];
   let currentAgent = null;
   let currentTaskMeta;
   let currentPrMeta;
@@ -13772,15 +13980,26 @@ async function runSandbox(config) {
   let currentMaxIterations = config.maxIterations ?? 50;
   let currentTaskId = config.taskId;
   let currentConversationId = config.sessionId;
+  let currentRunId;
+  let currentMessageId;
+  let currentCloudEnvironmentId;
   let currentTeamId = config.teamId;
   const workflowId = config.workflowId;
   const workflowExecutionId = config.workflowExecutionId;
   let currentUser = config.currentUser;
   let currentTerminalContextRefs;
   let currentTerminalSnapshots;
-  console.info("[sandbox] Connecting to WS server", {
-    wsUrl: config.wsUrl,
-    sessionId: config.sessionId
+  const lifecycle = config.lifecycle ?? new AgentLifecycleLogger({
+    taskId: config.taskId,
+    conversationId: config.sessionId,
+    runId: config.runId,
+    sandboxId: config.sandboxId,
+    provider: config.provider,
+    backendKind: config.backendKind,
+    agentVersion: AGENT_VERSION
+  });
+  lifecycle.info("sandbox_agent_ws_connect_attempt", {
+    wsUrl: config.wsUrl
   });
   const wsClient = new WSClient(
     config.wsUrl,
@@ -13789,16 +14008,41 @@ async function runSandbox(config) {
     config.sessionToken,
     {
       onUserMessage: (payload) => {
+        if (payload === null) {
+          if (pendingMessageResolve) {
+            const resolve2 = pendingMessageResolve;
+            pendingMessageResolve = null;
+            resolve2(null);
+          }
+          return;
+        }
+        lifecycle.setContext({
+          runId: payload.runId,
+          taskId: payload.taskId,
+          conversationId: payload.conversationId,
+          backendKind: payload.backendKind
+        });
+        wsClient.setLifecycleContext({
+          runId: payload.runId,
+          taskId: payload.taskId,
+          conversationId: payload.conversationId,
+          backendKind: payload.backendKind
+        });
+        lifecycle.info("sandbox_agent_user_message_received", {
+          messageId: payload.messageId,
+          hasImages: Boolean(payload.images?.length),
+          fileCount: payload.files?.length ?? 0
+        });
         if (pendingMessageResolve) {
           const resolve2 = pendingMessageResolve;
           pendingMessageResolve = null;
           resolve2(payload);
         } else {
-          console.warn("[sandbox] No handler for user message \u2014 dropped");
+          queuedMessages.push(payload);
         }
       },
       onStop: () => {
-        console.info("[sandbox] Stop signal received");
+        lifecycle.info("sandbox_agent_stop_received");
         if (currentAgent) {
           const killed = currentAgent.kill();
           if (!killed) currentAgent.abort();
@@ -13808,21 +14052,24 @@ async function runSandbox(config) {
         if (currentAgent) {
           const sent = currentAgent.sendToolResponse(toolId, response);
           if (!sent) {
-            console.warn("[sandbox] Failed to deliver tool_response to agent stdin", { toolId });
+            lifecycle.warn("sandbox_agent_tool_response_delivery_failed", { toolId });
           }
         } else {
-          console.warn("[sandbox] No active agent for tool_response", { toolId });
+          lifecycle.warn("sandbox_agent_tool_response_without_active_agent", { toolId });
         }
       },
-      onConnect: () => console.info("[sandbox] WS connected"),
-      onDisconnect: (reason) => console.info(`[sandbox] WS disconnected: ${reason}`)
+      onConnect: () => lifecycle.info("sandbox_agent_ws_connected"),
+      onDisconnect: (reason) => lifecycle.info("sandbox_agent_ws_disconnected", { reason })
     },
-    AGENT_VERSION
+    AGENT_VERSION,
+    lifecycle
   );
   try {
     await wsClient.waitForConnection();
   } catch (error) {
-    console.error("[sandbox] Failed to connect to WS server:", error.message);
+    lifecycle.error("sandbox_agent_ws_connect_failed", {
+      error: error instanceof Error ? error : new Error(String(error))
+    });
     process.exit(1);
   }
   const presenter = new WebPresenter(wsClient, config.sessionId, config.projectPath);
@@ -13841,8 +14088,33 @@ async function runSandbox(config) {
         backendKind: activeBackendKind
       });
       currentAgent = agent;
+      const correlation = correlationLogFields2({
+        taskId: currentTaskId,
+        conversationId: currentConversationId,
+        runId: currentRunId,
+        messageId: currentMessageId,
+        cloudEnvironmentId: currentCloudEnvironmentId,
+        backendKind: activeBackendKind,
+        agentVersion: AGENT_VERSION
+      });
+      console.info("[sandbox] Agent run started", correlation);
       let result;
       try {
+        lifecycle.setContext({
+          taskId: currentTaskId,
+          conversationId: currentConversationId,
+          backendKind: activeBackendKind
+        });
+        wsClient.setLifecycleContext({
+          taskId: currentTaskId,
+          conversationId: currentConversationId,
+          backendKind: activeBackendKind
+        });
+        lifecycle.info("sandbox_agent_run_start", {
+          mode: activeMode,
+          model: activeModel,
+          maxIterations: currentMaxIterations
+        });
         result = await agent.run({
           task: currentTask,
           maxIterations: currentMaxIterations,
@@ -13874,11 +14146,25 @@ async function runSandbox(config) {
             filename: img.filename,
             width: 0,
             height: 0
+          })) : void 0,
+          files: currentFiles.length > 0 ? currentFiles.map((file) => ({
+            id: file.id,
+            data: file.data,
+            mimeType: file.mimeType,
+            filename: file.filename,
+            size: file.size,
+            label: file.label
           })) : void 0
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error("[sandbox] Agent run failed:", errorMessage);
+        console.error("[sandbox] Agent run failed", {
+          ...correlation,
+          error: errorMessage
+        });
+        lifecycle.error("sandbox_agent_run_failed", {
+          error: error instanceof Error ? error : new Error(errorMessage)
+        });
         result = {
           success: false,
           summary: "Agent run failed",
@@ -13889,12 +14175,22 @@ async function runSandbox(config) {
         };
       }
       currentAgent = null;
+      lifecycle.info("sandbox_agent_run_complete", {
+        success: result.success,
+        iterations: result.iterations,
+        error: result.error
+      });
       if (result?.providerSessionId) {
         lastProviderSessionId = result.providerSessionId;
       }
+      console.info("[sandbox] Agent run finished", {
+        ...correlation,
+        success: String(result.success),
+        iterations: String(result.iterations)
+      });
       if (stopped) break;
     }
-    const nextPayload = await new Promise((resolve2) => {
+    const nextPayload = queuedMessages.shift() ?? await new Promise((resolve2) => {
       pendingMessageResolve = resolve2;
     });
     if (nextPayload === null || stopped) {
@@ -13902,6 +14198,7 @@ async function runSandbox(config) {
     }
     currentTask = nextPayload.text;
     currentImages = nextPayload.images ?? [];
+    currentFiles = nextPayload.files ?? [];
     if (nextPayload.providerSessionId) {
       lastProviderSessionId = nextPayload.providerSessionId;
     }
@@ -13941,6 +14238,15 @@ async function runSandbox(config) {
     if (nextPayload.taskId !== void 0) {
       currentTaskId = nextPayload.taskId;
     }
+    if (nextPayload.runId !== void 0) {
+      currentRunId = nextPayload.runId;
+    }
+    if (nextPayload.messageId !== void 0) {
+      currentMessageId = nextPayload.messageId;
+    }
+    if (nextPayload.cloudEnvironmentId !== void 0) {
+      currentCloudEnvironmentId = nextPayload.cloudEnvironmentId;
+    }
     if (nextPayload.conversationId !== void 0) {
       currentConversationId = nextPayload.conversationId;
     }
@@ -13958,6 +14264,7 @@ async function runSandbox(config) {
     }
   }
   presenter.setSuppressSessionLifecycle(false);
+  lifecycle.info("sandbox_agent_process_exit");
   wsClient.close();
 }
 
@@ -13980,20 +14287,28 @@ async function runSessionFromEnv() {
   const providerSessionId = process.env.AIDEN_PROVIDER_SESSION_ID || void 0;
   const workflowId = process.env.AIDEN_WORKFLOW_ID || void 0;
   const workflowExecutionId = process.env.AIDEN_WORKFLOW_EXECUTION_ID || void 0;
+  const sandboxId = process.env.AIDEN_SANDBOX_ID || void 0;
+  const provider = process.env.AIDEN_SANDBOX_PROVIDER || void 0;
+  const runId = process.env.AIDEN_RUN_ID || void 0;
+  const lifecycle = new AgentLifecycleLogger(lifecycleContextFromEnv(process.env));
   if (!wsUrl || !sessionId || !taskId || !sessionToken || task == null) {
+    lifecycle.error("sandbox_agent_bootstrap_missing_env", {
+      hasWsUrl: Boolean(wsUrl),
+      hasConversationId: Boolean(sessionId),
+      hasTaskId: Boolean(taskId),
+      hasSessionToken: Boolean(sessionToken),
+      hasTask: task != null
+    });
     throw new Error(
       "run-session is an internal Aiden sandbox/session command and must be launched by Aiden with session env vars. Missing required env vars: AIDEN_WS_URL, AIDEN_SESSION_ID, AIDEN_TASK_ID, AIDEN_SESSION_TOKEN, AIDEN_TASK"
     );
   }
-  console.info("[aiden-agent] Starting", {
+  lifecycle.info("sandbox_agent_process_start", {
     sessionId,
-    taskId,
     projectPath,
-    backendKind,
     agentId,
     mode,
-    model,
-    version: AGENT_VERSION
+    model
   });
   await runSandbox({
     wsUrl,
@@ -14013,6 +14328,10 @@ async function runSessionFromEnv() {
     providerSessionId,
     workflowId,
     workflowExecutionId,
+    sandboxId,
+    provider,
+    runId,
+    lifecycle,
     maxIterations: 50
   });
 }
@@ -14072,7 +14391,9 @@ async function main() {
 ${HELP_TEXT}`);
 }
 main().catch((error) => {
-  console.error("[aiden-agent] Fatal error:", error instanceof Error ? error.message : error);
+  new AgentLifecycleLogger(lifecycleContextFromEnv(process.env)).error("sandbox_agent_fatal", {
+    error: error instanceof Error ? error : new Error(String(error))
+  });
   process.exit(1);
 });
 /*! Bundled license information: