@aiden-ade/sandbox-agent 0.1.25 → 0.1.27

package/dist/index.cjs

@@ -4856,11 +4856,11 @@ function resolveCommand(args, env) {
 
 // src/daemon.ts
 var import_node_child_process3 = require("child_process");
-var import_node_crypto2 = require("crypto");
-var import_node_fs4 = require("fs");
+var import_node_crypto = require("crypto");
+var import_node_fs3 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
 var import_node_os4 = require("os");
-var import_node_path4 = require("path");
+var import_node_path3 = require("path");
 
 // ../shared/dist/node/provider-limits.js
 var import_node_child_process = require("child_process");
@@ -4974,8 +4974,8 @@ async function withTimeout(promise, timeoutMs, fallback) {
   try {
     return await Promise.race([
       promise,
-      new Promise((resolve2) => {
-        timer = setTimeout(() => resolve2(fallback), timeoutMs);
+      new Promise((resolve3) => {
+        timer = setTimeout(() => resolve3(fallback), timeoutMs);
       })
     ]);
   } finally {
@@ -4988,7 +4988,7 @@ async function collectCodexLimits(env) {
   const codexCommand = resolveExecutable("codex", runtimeEnv, "AIDEN_CODEX_PATH");
   if (!codexCommand)
     return [];
-  return withTimeout(new Promise((resolve2) => {
+  return withTimeout(new Promise((resolve3) => {
     const child = (0, import_node_child_process.spawn)(codexCommand, ["-s", "read-only", "-a", "untrusted", "app-server"], {
       env: runtimeEnv,
       stdio: ["pipe", "pipe", "ignore"]
@@ -5000,7 +5000,7 @@ async function collectCodexLimits(env) {
       pending.clear();
       if (!child.killed)
         child.kill();
-      resolve2(windows);
+      resolve3(windows);
     };
     const request = (method, params = {}) => {
       const id = nextId++;
@@ -7685,9 +7685,9 @@ var Socket2 = class extends Emitter {
    * @return a Promise that will be fulfilled when the server acknowledges the event
    */
   emitWithAck(ev, ...args) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const fn = (arg1, arg2) => {
-        return arg1 ? reject(arg1) : resolve2(arg2);
+        return arg1 ? reject(arg1) : resolve3(arg2);
       };
       fn.withError = true;
       args.push(fn);
@@ -8691,22 +8691,33 @@ var import_node_fs2 = require("fs");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
 var PROVIDER_CLI_COMMANDS = {
-  claude_cli: { provider: "claude_cli", command: "claude", envVar: "AIDEN_CLAUDE_PATH" },
-  codex_app_server: { provider: "codex_app_server", command: "codex", envVar: "AIDEN_CODEX_PATH" },
-  copilot_cli: { provider: "copilot_cli", command: "copilot", envVar: "AIDEN_COPILOT_PATH" },
+  claude_cli: { provider: "claude_cli", command: "claude", envVars: ["AIDEN_CLAUDE_PATH"] },
+  codex_app_server: {
+    provider: "codex_app_server",
+    command: "codex",
+    envVars: ["AIDEN_CODEX_PATH"]
+  },
+  copilot_cli: { provider: "copilot_cli", command: "copilot", envVars: ["AIDEN_COPILOT_PATH"] },
   cursor_agent_cli: {
     provider: "cursor_agent_cli",
     command: "cursor-agent",
-    envVar: "AIDEN_CURSOR_AGENT_PATH"
+    envVars: ["AIDEN_CURSOR_AGENT_PATH"]
   },
-  gemini_cli: { provider: "gemini_cli", command: "gemini", envVar: "AIDEN_GEMINI_PATH" },
-  kimi_cli: { provider: "kimi_cli", command: "kimi-cli", envVar: "AIDEN_KIMI_PATH" },
-  opencode_cli: { provider: "opencode_cli", command: "opencode", envVar: "AIDEN_OPENCODE_PATH" },
-  droid_cli: { provider: "droid_cli", command: "droid", envVar: "AIDEN_DROID_PATH" },
-  supatest_cli: { provider: "supatest_cli", command: "supatest", envVar: "AIDEN_SUPATEST_PATH" }
+  gemini_cli: {
+    provider: "gemini_cli",
+    command: "agy",
+    envVars: ["AIDEN_ANTIGRAVITY_PATH", "AIDEN_GEMINI_PATH"]
+  },
+  kimi_cli: { provider: "kimi_cli", command: "kimi-cli", envVars: ["AIDEN_KIMI_PATH"] },
+  opencode_cli: { provider: "opencode_cli", command: "opencode", envVars: ["AIDEN_OPENCODE_PATH"] },
+  droid_cli: { provider: "droid_cli", command: "droid", envVars: ["AIDEN_DROID_PATH"] },
+  supatest_cli: { provider: "supatest_cli", command: "supatest", envVars: ["AIDEN_SUPATEST_PATH"] }
 };
 var DISCOVERABLE_PROVIDER_KINDS = Object.keys(PROVIDER_CLI_COMMANDS);
 var PROVIDER_ALIASES = {
+  agy: "gemini_cli",
+  antigravity: "gemini_cli",
+  antigravity_cli: "gemini_cli",
   codex: "codex_app_server",
   gemini: "gemini_cli"
 };
@@ -8716,8 +8727,11 @@ var BACKEND_CLI_COMMANDS = {
   codex_app_server: "codex",
   copilot_cli: "copilot",
   cursor_agent_cli: "cursor-agent",
-  gemini_cli: "gemini",
-  gemini: "gemini",
+  agy: "agy",
+  antigravity: "agy",
+  antigravity_cli: "agy",
+  gemini_cli: "agy",
+  gemini: "agy",
   kimi_cli: "kimi-cli",
   opencode_cli: "opencode",
   droid_cli: "droid",
@@ -8905,7 +8919,7 @@ function resolveProviderCliCommand(provider, env = getDaemonCliEnvironment()) {
   const normalized = normalizeDiscoverableProvider(provider);
   if (!normalized) return null;
   const spec = PROVIDER_CLI_COMMANDS[normalized];
-  const override = process.env[spec.envVar]?.trim();
+  const override = spec.envVars.map((name) => process.env[name]?.trim() || env[name]?.trim()).find(Boolean);
   if (override) {
     const resolved2 = resolveCliExecutable(override, env) ?? (isRunnableFile(override) ? override : null);
     if (resolved2) cacheResolvedCli(spec.command, resolved2);
@@ -8922,7 +8936,7 @@ function resolveBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment
   const cached = getCachedResolvedCli(command);
   if (cached && isRunnableFile(cached)) return cached;
   const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
-  const envOverride = spec ? env[spec.envVar] : void 0;
+  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
   const resolved = resolveCliExecutable(envOverride?.trim() || command, env);
   if (resolved) cacheResolvedCli(command, resolved);
   return resolved ?? void 0;
@@ -9321,6 +9335,64 @@ function isReadOnlyAgent(agentId) {
   return !agent.capabilities.canEditFiles;
 }
 
+// ../shared/dist/agent/generated-images.js
+var GENERATED_IMAGE_TOOL_NAMES = [
+  "image_generation",
+  "image_generate",
+  "image_gen",
+  "imagegen",
+  "generate_image",
+  "generate_images",
+  "edit_image",
+  "edit_images",
+  "image_edit",
+  "images_edit",
+  "text_to_image",
+  "images_generate"
+];
+var BROWSER_SCREENSHOT_TOOL_NAMES = [
+  "agent_browser_screenshot",
+  "agent_browser_take_screenshot",
+  "agent_browser_capture_screenshot",
+  "browser_screenshot",
+  "browser_take_screenshot",
+  "browser_capture_screenshot",
+  "screenshot"
+];
+var BROWSER_RECORDING_TOOL_NAMES = [
+  "agent_browser_record",
+  "agent_browser_recording",
+  "agent_browser_video",
+  "agent_browser_capture_video",
+  "agent_browser_screen_recording",
+  "browser_record",
+  "browser_recording",
+  "browser_video",
+  "browser_capture_video",
+  "browser_screen_recording"
+];
+function normalizeToolName(toolName) {
+  return toolName?.toLowerCase().replace(/[^a-z0-9]+/g, "_") ?? "";
+}
+function isGeneratedImageToolName(toolName) {
+  const normalized = normalizeToolName(toolName);
+  if (!normalized)
+    return false;
+  return GENERATED_IMAGE_TOOL_NAMES.some((token) => normalized.includes(token));
+}
+function isBrowserScreenshotToolName(toolName) {
+  const normalized = normalizeToolName(toolName);
+  if (!normalized)
+    return false;
+  return BROWSER_SCREENSHOT_TOOL_NAMES.some((token) => normalized === token || normalized.endsWith(`_${token}`));
+}
+function isBrowserRecordingToolName(toolName) {
+  const normalized = normalizeToolName(toolName);
+  if (!normalized)
+    return false;
+  return BROWSER_RECORDING_TOOL_NAMES.some((token) => normalized === token || normalized.endsWith(`_${token}`));
+}
+
 // ../shared/dist/agent/session-result.js
 var SESSION_RESUME_FAILED_MESSAGE = "Session resume failed. The previous session may have expired or is no longer available. Please start a new session.";
 
@@ -9621,6 +9693,12 @@ var import_path3 = require("path");
 var import_fs4 = require("fs");
 var import_os4 = require("os");
 var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_os5 = require("os");
+var import_path5 = require("path");
+var import_crypto2 = require("crypto");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 function shouldUseReadOnlyRuntimePermissions(config) {
   if (isReadOnlyAgent(config.agentId)) return true;
   switch (config.mode) {
@@ -9761,8 +9839,7 @@ function createGenericCliBackend(options) {
       const state = {
         process: null,
         iterations: 0,
-        summary: "",
-        allowContinuation: options.allowContinuation ?? false
+        summary: ""
       };
       const prompt = options.augmentPrompt?.(context) ?? (context.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText)) : buildPromptWithSystem(context.config, context.promptText));
       const args = options.buildArgs?.(context, prompt) ?? options.args.map((arg) => arg === "{{prompt}}" ? prompt : arg);
@@ -9819,12 +9896,13 @@ function createGenericCliBackend(options) {
         }
       });
       let exitCode;
+      let idleTimedOut = false;
       try {
-        const exitPromise = new Promise((resolve2, reject) => {
+        const exitPromise = new Promise((resolve22, reject) => {
           child.on("error", (error) => {
             reject(formatCliSpawnError(options.command, error));
           });
-          child.on("exit", (code) => resolve2(code ?? 0));
+          child.on("exit", (code) => resolve22(code ?? 0));
           const onAbort = () => {
             const pid = child.pid;
             if (!pid) return;
@@ -9840,53 +9918,67 @@ function createGenericCliBackend(options) {
           context.abortController.signal.addEventListener("abort", onAbort, { once: true });
         });
         if (options.keepStdinOpen) {
-          if (options.allowContinuation) {
-            const IDLE_MS = options.continuationIdleMs ?? 10 * 60 * 1e3;
-            let idleTimer = null;
-            const resetIdleTimer = () => {
+          const resultPromise = new Promise((resolve22) => {
+            state.onResultReceived = () => resolve22("result_received");
+            if (state.resultReceived) resolve22("result_received");
+          });
+          const IDLE_MS = options.resultIdleTimeoutMs ?? 10 * 60 * 1e3;
+          let idleTimer = null;
+          const idlePromise = new Promise((resolve22) => {
+            const armIdleTimer = () => {
               if (idleTimer) clearTimeout(idleTimer);
               idleTimer = setTimeout(() => {
-                if (state.stdin && !state.stdin.destroyed) {
-                  state.stdin.end();
-                  console.info(
-                    `[${options.kind}] Continuation idle timeout (${IDLE_MS}ms) \u2014 closing stdin`
-                  );
+                if (presenter.pendingAskUserToolIds?.size) {
+                  resolve22("idle_timeout");
+                } else {
+                  armIdleTimer();
                 }
               }, IDLE_MS);
             };
-            state.onNewOutput = resetIdleTimer;
-            resetIdleTimer();
-            exitCode = await exitPromise;
-            if (idleTimer) clearTimeout(idleTimer);
-          } else {
-            const resultPromise = new Promise((resolve2) => {
-              state.onResultReceived = () => resolve2("result_received");
-              if (state.resultReceived) resolve2("result_received");
-            });
-            const raceResult = await Promise.race([exitPromise, resultPromise]);
-            if (raceResult === "result_received") {
-              const GRACE_MS = 5e3;
-              const gracedExit = await Promise.race([
-                exitPromise,
-                new Promise((resolve2) => setTimeout(() => resolve2(0), GRACE_MS))
-              ]);
-              exitCode = typeof gracedExit === "number" ? gracedExit : 0;
-              if (child.exitCode === null && !child.killed) {
-                console.warn(
-                  `[${options.kind}] Process still alive ${GRACE_MS}ms after result event, killing`
-                );
-                try {
-                  if (process.platform === "win32") {
-                    child.kill("SIGKILL");
-                  } else if (child.pid) {
-                    process.kill(-child.pid, "SIGKILL");
-                  }
-                } catch {
+            state.onNewOutput = armIdleTimer;
+            armIdleTimer();
+          });
+          const raceResult = await Promise.race([exitPromise, resultPromise, idlePromise]);
+          if (idleTimer) clearTimeout(idleTimer);
+          if (raceResult === "idle_timeout") {
+            idleTimedOut = true;
+            console.warn(
+              `[${options.kind}] Idle timeout (${IDLE_MS}ms) waiting for a pending user answer \u2014 force-killing orphaned process`
+            );
+            try {
+              if (process.platform === "win32") {
+                child.kill("SIGKILL");
+              } else if (child.pid) {
+                process.kill(-child.pid, "SIGKILL");
+              }
+            } catch {
+            }
+            exitCode = await Promise.race([
+              exitPromise,
+              new Promise((resolve22) => setTimeout(() => resolve22(1), 5e3))
+            ]);
+          } else if (raceResult === "result_received") {
+            const GRACE_MS = 5e3;
+            const gracedExit = await Promise.race([
+              exitPromise,
+              new Promise((resolve22) => setTimeout(() => resolve22(0), GRACE_MS))
+            ]);
+            exitCode = typeof gracedExit === "number" ? gracedExit : 0;
+            if (child.exitCode === null && !child.killed) {
+              console.warn(
+                `[${options.kind}] Process still alive ${GRACE_MS}ms after result event, killing`
+              );
+              try {
+                if (process.platform === "win32") {
+                  child.kill("SIGKILL");
+                } else if (child.pid) {
+                  process.kill(-child.pid, "SIGKILL");
                 }
+              } catch {
               }
-            } else {
-              exitCode = raceResult;
             }
+          } else {
+            exitCode = raceResult;
           }
         } else {
           exitCode = await exitPromise;
@@ -9910,6 +10002,31 @@ function createGenericCliBackend(options) {
           usage: state.usage
         };
       }
+      if (idleTimedOut) {
+        console.error(`[${options.kind}] Process force-killed after idle timeout`, {
+          stderrLines: stderrLines.slice(-10),
+          summaryPreview: state.summary.slice(0, 200),
+          runtimeSessionId: state.runtimeSessionId
+        });
+        await options.afterExit?.(context, state);
+        const hasRenderableTurn2 = state.summary.trim().length > 0 || state.iterations > 0;
+        if (hasRenderableTurn2) {
+          await presenter.onTurnComplete([]);
+        }
+        return {
+          success: false,
+          summary: state.summary.trim() || "Agent execution timed out",
+          filesModified: [],
+          planFilesCreated: [],
+          iterations: Math.max(state.iterations, 1),
+          error: "Agent timed out waiting for your answer to its question \u2014 no response arrived, so the run was stopped. Send your reply as a new message to continue.",
+          providerSessionId: state.runtimeSessionId,
+          runtimeSessionId: state.runtimeSessionId,
+          backendKind: options.kind,
+          supportTier: options.supportTier,
+          usage: state.usage
+        };
+      }
       if (exitCode !== 0) {
         console.error(`[${options.kind}] Process exited with code ${exitCode}`, {
           stderrLines: stderrLines.slice(-10),
@@ -9982,11 +10099,6 @@ function parseClaudeStructuredLine(line, context, state) {
         );
         break;
       }
-      if (state.resultReceived && state.allowContinuation) {
-        console.info("[claude_cli] Continuation turn detected \u2014 restarting presenter");
-        state.resultReceived = false;
-        void presenter.onStart(context.config);
-      }
       state.onNewOutput?.();
       state.iterations += 1;
       const message = typeof parsed.message === "object" && parsed.message !== null ? parsed.message : null;
@@ -10115,31 +10227,10 @@ function parseClaudeStructuredLine(line, context, state) {
         break;
       }
       state.resultReceived = true;
-      if (state.allowContinuation) {
-        const continuationResult = {
-          success: !state.error,
-          summary: state.summary || state.error || "",
-          filesModified: [],
-          planFilesCreated: [],
-          iterations: Math.max(state.iterations, 1),
-          error: state.error ? classifyCliError(state.error, 0) : void 0,
-          providerSessionId: state.runtimeSessionId,
-          runtimeSessionId: state.runtimeSessionId,
-          backendKind: context.config.backendKind,
-          supportTier: context.config.supportTier,
-          usage: state.usage
-        };
-        void presenter.onComplete(continuationResult);
-        state.onNewOutput?.();
-        console.info(
-          "[claude_cli] Result received in continuation mode \u2014 keeping stdin open for background work"
-        );
-      } else {
-        state.onResultReceived?.();
-        if (state.stdin && !state.stdin.destroyed) {
-          state.stdin.end();
-          console.info("[claude_cli] Closed stdin after result event to signal CLI exit");
-        }
+      state.onResultReceived?.();
+      if (state.stdin && !state.stdin.destroyed) {
+        state.stdin.end();
+        console.info("[claude_cli] Closed stdin after result event to signal CLI exit");
       }
       break;
     }
@@ -10225,10 +10316,7 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
           stdin.write(`${message}
 `);
         },
-        keepStdinOpen: true,
-        allowContinuation: true,
-        continuationIdleMs: 10 * 60 * 1e3
-        // 10 minutes
+        keepStdinOpen: true
       }).run(context);
     }
   };
@@ -11336,7 +11424,33 @@ function parseGeminiStructuredLine(line, context, state) {
       break;
   }
 }
-function createGeminiCliBackend(command = "gemini", defaultArgs = []) {
+function parseAntigravityLine(line, context, state) {
+  try {
+    JSON.parse(line);
+    parseGeminiStructuredLine(line, context, state);
+    return;
+  } catch {
+  }
+  if (!line.trim()) return;
+  state.iterations = Math.max(state.iterations, 1);
+  state.summary += `${line}
+`;
+  void context.presenter.onAssistantText(`${line}
+`);
+}
+function buildAntigravityCliArgs(context, prompt, defaultArgs = []) {
+  const args = [];
+  const selectedModel = context.config.selectedModel?.trim();
+  const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+  if (selectedModel) args.push("--model", selectedModel);
+  if (resumeId) args.push("--conversation", resumeId);
+  if (!shouldUseReadOnlyRuntimePermissions(context.config)) {
+    args.push("--dangerously-skip-permissions");
+  }
+  args.push("--print-timeout", "10m");
+  return [...args, ...defaultArgs, "-p", prompt];
+}
+function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
   return {
     kind: "gemini_cli",
     supportTier: "structured",
@@ -11351,19 +11465,9 @@ function createGeminiCliBackend(command = "gemini", defaultArgs = []) {
           supportTier: "structured",
           command,
           args: [],
-          buildArgs: (ctx) => {
-            const args = ["-p", "", "--output-format", "stream-json"];
-            const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
-            const approvalMode = shouldUseReadOnlyRuntimePermissions(ctx.config) ? "plan" : "yolo";
-            args.push("--approval-mode", approvalMode);
-            if (resumeId) args.push("--resume", resumeId);
-            if (ctx.config.selectedModel?.trim())
-              args.push("--model", ctx.config.selectedModel.trim());
-            return [...args, ...defaultArgs];
-          },
-          promptViaStdin: true,
+          buildArgs: (ctx, prompt) => buildAntigravityCliArgs(ctx, prompt, defaultArgs),
           augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
-          parseStructuredLine: parseGeminiStructuredLine
+          parseStructuredLine: parseAntigravityLine
         }).run(context);
       } finally {
         cleanup();
@@ -11371,6 +11475,72 @@ function createGeminiCliBackend(command = "gemini", defaultArgs = []) {
     }
   };
 }
+function createGeminiCliBackend(command = "agy", defaultArgs = []) {
+  return createAntigravityCliBackend(command, defaultArgs);
+}
+var DEFAULT_SKILL_ROOTS = [
+  (0, import_path4.join)((0, import_os4.homedir)(), ".agents", "skills"),
+  (0, import_path4.join)((0, import_os4.homedir)(), ".claude", "skills"),
+  (0, import_path4.join)((0, import_os4.homedir)(), ".config", "opencode", "skills")
+];
+function parseFrontmatter(content) {
+  if (!content.startsWith("---\n")) return {};
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const result = {};
+  for (const line of content.slice(4, end).split("\n")) {
+    const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line.trim());
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    result[key] = rawValue.replace(/^["']|["']$/g, "").trim();
+  }
+  return result;
+}
+function listSkillFiles(root) {
+  if (!(0, import_fs4.existsSync)(root)) return [];
+  const files = [];
+  for (const entry of (0, import_fs4.readdirSync)(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillPath = (0, import_path4.join)(root, entry.name, "SKILL.md");
+    if ((0, import_fs4.existsSync)(skillPath)) files.push(skillPath);
+  }
+  return files;
+}
+function loadInstalledSkills(roots = DEFAULT_SKILL_ROOTS) {
+  const skills = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    for (const skillPath of listSkillFiles(root)) {
+      try {
+        const frontmatter = parseFrontmatter((0, import_fs4.readFileSync)(skillPath, "utf8"));
+        const name = frontmatter.name;
+        const description = frontmatter.description;
+        if (!name || !description || skills.has(name)) continue;
+        skills.set(name, { name, description, path: skillPath });
+      } catch {
+      }
+    }
+  }
+  return [...skills.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function buildInstalledSkillsPrompt(roots = DEFAULT_SKILL_ROOTS) {
+  const skills = loadInstalledSkills(roots);
+  if (skills.length === 0) return void 0;
+  return [
+    "## Installed Skills",
+    "",
+    "Use an installed skill before improvising when the task matches a skill description.",
+    "",
+    "Protocol:",
+    "1. Match the request against the skill names and descriptions below.",
+    "2. Before acting on a matching skill, read its SKILL.md file completely.",
+    "3. Resolve any referenced files such as references/, scripts/, or assets/ relative to the skill directory.",
+    "4. Use the smallest set of matching skills for the current turn only.",
+    "5. If a named skill is missing or unreadable, say so briefly and continue with the best fallback.",
+    "",
+    "Available skills:",
+    ...skills.map((skill) => `- ${skill.name}: ${skill.description} (file: ${skill.path})`)
+  ].join("\n");
+}
 var KIMI_RESUME_SESSION_RE = /To resume this session:\s*kimi(?:-cli)?\s+(?:-[rS]|--session|--resume)\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
 function parseKimiStderrLine(line, state) {
   const match = line.match(KIMI_RESUME_SESSION_RE);
@@ -11473,7 +11643,13 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
             if (model) args.push("--model", model);
             return [...args, ...defaultArgs, "--prompt", prompt];
           },
-          augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
+          augmentPrompt: (ctx) => {
+            const skillPrompt = buildInstalledSkillsPrompt();
+            const promptText = [skillPrompt, ctx.promptText].filter(Boolean).join("\n\n");
+            const basePrompt = buildPromptWithSystem(ctx.config, promptText);
+            const modePrompt = ctx.config.mode === "plan" ? buildPlanModePrefix(basePrompt) : basePrompt;
+            return appendImagePathReferences(modePrompt, imageFiles);
+          },
           parseStructuredLine: parseKimiStructuredLine,
           parseStderrLine: (line, _ctx, state) => parseKimiStderrLine(line, state)
         }).run(context);
@@ -11816,40 +11992,40 @@ function parseSkillInvocation(text) {
 function candidateRoots(cwd) {
   const roots = [];
   if (cwd) {
-    roots.push((0, import_path4.join)(cwd, ".agents", "skills"));
-    roots.push((0, import_path4.join)(cwd, ".claude", "skills"));
-    roots.push((0, import_path4.join)(cwd, ".codex", "skills"));
-    if ((0, import_fs4.existsSync)(cwd)) {
+    roots.push((0, import_path5.join)(cwd, ".agents", "skills"));
+    roots.push((0, import_path5.join)(cwd, ".claude", "skills"));
+    roots.push((0, import_path5.join)(cwd, ".codex", "skills"));
+    if ((0, import_fs5.existsSync)(cwd)) {
       let entries = [];
       try {
-        entries = (0, import_fs4.readdirSync)(cwd, { withFileTypes: true });
+        entries = (0, import_fs5.readdirSync)(cwd, { withFileTypes: true });
       } catch {
       }
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".")) continue;
-        const child = (0, import_path4.join)(cwd, entry.name);
-        roots.push((0, import_path4.join)(child, ".agents", "skills"));
-        roots.push((0, import_path4.join)(child, ".claude", "skills"));
-        roots.push((0, import_path4.join)(child, ".codex", "skills"));
+        const child = (0, import_path5.join)(cwd, entry.name);
+        roots.push((0, import_path5.join)(child, ".agents", "skills"));
+        roots.push((0, import_path5.join)(child, ".claude", "skills"));
+        roots.push((0, import_path5.join)(child, ".codex", "skills"));
       }
     }
   }
-  const home = (0, import_os4.homedir)();
-  roots.push((0, import_path4.join)(home, ".agents", "skills"));
-  roots.push((0, import_path4.join)(home, ".claude", "skills"));
-  roots.push((0, import_path4.join)(home, ".codex", "skills"));
+  const home = (0, import_os5.homedir)();
+  roots.push((0, import_path5.join)(home, ".agents", "skills"));
+  roots.push((0, import_path5.join)(home, ".claude", "skills"));
+  roots.push((0, import_path5.join)(home, ".codex", "skills"));
   return Array.from(new Set(roots));
 }
 function resolveSkillInvocation(text, cwd) {
   const parsed = parseSkillInvocation(text);
   if (!parsed) return null;
   for (const root of candidateRoots(cwd)) {
-    const skillPath = (0, import_path4.join)(root, parsed.command, "SKILL.md");
-    if (!(0, import_fs4.existsSync)(skillPath)) continue;
+    const skillPath = (0, import_path5.join)(root, parsed.command, "SKILL.md");
+    if (!(0, import_fs5.existsSync)(skillPath)) continue;
     let content;
     try {
-      content = (0, import_fs4.readFileSync)(skillPath, "utf-8");
+      content = (0, import_fs5.readFileSync)(skillPath, "utf-8");
     } catch {
       continue;
     }
@@ -11898,6 +12074,8 @@ function defaultSelectedModelForBackend(backendKind) {
       return void 0;
     case "opencode_cli":
       return void 0;
+    case "gemini_cli":
+      return void 0;
     case "supatest_cli":
       return "medium";
     default:
@@ -12099,7 +12277,7 @@ Prefer relative paths and keep your work scoped to this project.`
     const promptText = this.buildPromptText(runtimeConfig);
     const runtimeCommand = runtimeConfig.runtimeCommand || this.runtime.runtimeCommand;
     const runtimeArgs = runtimeConfig.runtimeArgs || this.runtime.runtimeArgs || [];
-    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "gemini_cli" ? createGeminiCliBackend(runtimeCommand || "gemini", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
+    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "gemini_cli" ? createGeminiCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
       runtimeCommand || "generic-cli",
       runtimeArgs
     );
@@ -12165,18 +12343,18 @@ Prefer relative paths and keep your work scoped to this project.`
           `[base-machine-agent] Transient error (attempt ${attempt + 1}/${_BaseMachineAgent.MAX_RETRIES + 1}), retrying in ${delayMs}ms: ${lastResult.error}`
         );
         void this.presenter.onLog(`Transient error, retrying in ${Math.round(delayMs / 1e3)}s...`);
-        await new Promise((resolve2) => {
+        await new Promise((resolve22) => {
           const signal = this.abortController?.signal;
           if (signal?.aborted) {
-            resolve2();
+            resolve22();
             return;
           }
-          const timeoutId = setTimeout(resolve2, delayMs);
+          const timeoutId = setTimeout(resolve22, delayMs);
           signal?.addEventListener(
             "abort",
             () => {
               clearTimeout(timeoutId);
-              resolve2();
+              resolve22();
             },
             { once: true }
           );
@@ -12246,6 +12424,195 @@ Prefer relative paths and keep your work scoped to this project.`
     }
   }
 };
+var IMAGE_MIME_BY_EXT = {
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+var VIDEO_MIME_BY_EXT = {
+  ".mov": "video/quicktime",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm"
+};
+var MAX_GENERATED_IMAGE_BYTES = 20 * 1024 * 1024;
+var MAX_SESSION_VIDEO_BYTES = 100 * 1024 * 1024;
+function isRecord(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function shouldExtractGeneratedImagesFromToolResult(toolName, content, options = {}) {
+  return isGeneratedImageToolName(toolName) || isBrowserScreenshotToolName(toolName) || isAgentBrowserMediaInvocation(toolName, content, options.toolInput, "image");
+}
+function collectStringValues(value2, out) {
+  if (typeof value2 === "string") {
+    out.push(value2);
+    return;
+  }
+  if (Array.isArray(value2)) {
+    for (const item of value2) collectStringValues(item, out);
+    return;
+  }
+  if (!value2 || typeof value2 !== "object") return;
+  for (const entry of Object.values(value2)) {
+    collectStringValues(entry, out);
+  }
+}
+function collectContentStrings(content, toolInput) {
+  const values = [];
+  if (content) {
+    values.push(content);
+    try {
+      collectStringValues(JSON.parse(content), values);
+    } catch {
+    }
+  }
+  collectStringValues(toolInput, values);
+  return values;
+}
+function isAgentBrowserMediaInvocation(toolName, content, toolInput, kind) {
+  if (kind === "image" && isBrowserScreenshotToolName(toolName)) return true;
+  if (kind === "video" && isBrowserRecordingToolName(toolName)) return true;
+  const haystack = collectContentStrings(content, toolInput).join("\n").toLowerCase();
+  if (!/(^|[^a-z0-9_-])agent[-_]browser([^a-z0-9_-]|$)/.test(haystack)) return false;
+  return kind === "image" ? /\b(screenshot|capture)\b/.test(haystack) : /\b(record|recording|video)\b/.test(haystack);
+}
+function extractPathCandidatesFromValues(values, extensionsPattern = "png|jpe?g|gif|webp") {
+  const paths = /* @__PURE__ */ new Set();
+  const filePathPattern = new RegExp(
+    `(?:file:\\/\\/)?(?:~|\\.{1,2}|\\/)?[^\\s"'\`)\\]}<>]+?\\.(?:${extensionsPattern})\\b`,
+    "gi"
+  );
+  for (const value2 of values) {
+    for (const match of value2.matchAll(filePathPattern)) {
+      paths.add(match[0]);
+    }
+  }
+  return [...paths];
+}
+function extractPathCandidates(content, options, extensionsPattern = "png|jpe?g|gif|webp") {
+  return [
+    ...extractPathCandidatesFromValues(
+      collectContentStrings(content, options.toolInput),
+      extensionsPattern
+    ),
+    ...options.pathHints ?? []
+  ];
+}
+function normalizePath(candidate, cwd) {
+  let path = candidate.trim().replace(/^file:\/\//, "");
+  try {
+    path = decodeURI(path);
+  } catch {
+  }
+  if (path.startsWith("~/")) return null;
+  if ((0, import_path6.isAbsolute)(path)) return path;
+  return cwd ? (0, import_path6.join)(cwd, path) : null;
+}
+function resolveToolCwd(cwd, toolInput) {
+  if (!isRecord(toolInput)) return cwd;
+  const raw = typeof toolInput.cwd === "string" ? toolInput.cwd : typeof toolInput.workdir === "string" ? toolInput.workdir : typeof toolInput.workingDirectory === "string" ? toolInput.workingDirectory : null;
+  if (!raw) return cwd;
+  return (0, import_path6.isAbsolute)(raw) || !cwd ? raw : (0, import_path6.join)(cwd, raw);
+}
+function extractBrowserMediaPathHints(content, cwd, toolName, options = {}, kind = "video") {
+  if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, kind)) return [];
+  const extensionsPattern = kind === "video" ? "mp4|webm|mov" : "png|jpe?g|gif|webp";
+  const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
+  return extractPathCandidatesFromValues(
+    collectContentStrings(content, options.toolInput),
+    extensionsPattern
+  ).map((candidate) => normalizePath(candidate, effectiveCwd)).filter((path) => Boolean(path));
+}
+function readImageDimensions2(buffer, mimeType) {
+  if (mimeType === "image/png" && buffer.length >= 24 && buffer.toString("ascii", 1, 4) === "PNG") {
+    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+  }
+  if (mimeType === "image/gif" && buffer.length >= 10 && buffer.toString("ascii", 0, 3) === "GIF") {
+    return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+  }
+  if (mimeType === "image/jpeg" && buffer.length > 4) {
+    let offset = 2;
+    while (offset + 9 < buffer.length) {
+      if (buffer[offset] !== 255) break;
+      const marker = buffer[offset + 1];
+      const length = buffer.readUInt16BE(offset + 2);
+      if (length < 2) break;
+      if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+        return {
+          width: buffer.readUInt16BE(offset + 7),
+          height: buffer.readUInt16BE(offset + 5)
+        };
+      }
+      offset += 2 + length;
+    }
+  }
+  return { width: null, height: null };
+}
+function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, options = {}) {
+  if (!shouldExtractGeneratedImagesFromToolResult(toolName, content, options)) return [];
+  const images = [];
+  const seen = /* @__PURE__ */ new Set();
+  const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
+  for (const candidate of extractPathCandidates(content, options)) {
+    const path = normalizePath(candidate, effectiveCwd);
+    if (!path || seen.has(path) || !(0, import_fs6.existsSync)(path)) continue;
+    seen.add(path);
+    const ext = (0, import_path6.extname)(path).toLowerCase();
+    const mimeType = IMAGE_MIME_BY_EXT[ext];
+    if (!mimeType) continue;
+    const stat = (0, import_fs6.statSync)(path);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_GENERATED_IMAGE_BYTES) continue;
+    const buffer = (0, import_fs6.readFileSync)(path);
+    const { width, height } = readImageDimensions2(buffer, mimeType);
+    images.push({
+      type: "generated_image",
+      id: (0, import_crypto2.randomUUID)(),
+      filename: (0, import_path6.basename)(path),
+      mimeType,
+      size: buffer.length,
+      width,
+      height,
+      data: buffer.toString("base64"),
+      sourcePath: path,
+      sourceHash: (0, import_crypto2.createHash)("sha256").update(buffer).digest("hex"),
+      toolId,
+      ts: Date.now()
+    });
+  }
+  return images;
+}
+function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, options = {}) {
+  if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, "video")) return [];
+  const media = [];
+  const seen = /* @__PURE__ */ new Set();
+  const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
+  for (const candidate of extractPathCandidates(content, options, "mp4|webm|mov")) {
+    const path = normalizePath(candidate, effectiveCwd);
+    if (!path || seen.has(path) || !(0, import_fs6.existsSync)(path)) continue;
+    seen.add(path);
+    const ext = (0, import_path6.extname)(path).toLowerCase();
+    const mimeType = VIDEO_MIME_BY_EXT[ext];
+    if (!mimeType) continue;
+    const stat = (0, import_fs6.statSync)(path);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_SESSION_VIDEO_BYTES) continue;
+    const buffer = (0, import_fs6.readFileSync)(path);
+    media.push({
+      type: "session_media",
+      kind: "video",
+      id: (0, import_crypto2.randomUUID)(),
+      filename: (0, import_path6.basename)(path),
+      mimeType,
+      size: buffer.length,
+      data: buffer.toString("base64"),
+      sourcePath: path,
+      sourceHash: (0, import_crypto2.createHash)("sha256").update(buffer).digest("hex"),
+      toolId,
+      ts: Date.now()
+    });
+  }
+  return media;
+}
 
 // src/core-agent.ts
 var CoreAgent = class _CoreAgent extends BaseMachineAgent {
@@ -12544,149 +12911,179 @@ ${meta.description}`);
   }
 };
 
-// src/generated-images.ts
-var import_node_crypto = require("crypto");
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
-var IMAGE_MIME_BY_EXT = {
-  ".gif": "image/gif",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".png": "image/png",
-  ".webp": "image/webp"
-};
-var MAX_GENERATED_IMAGE_BYTES = 20 * 1024 * 1024;
-function isGeneratedImageToolName(toolName) {
-  if (!toolName) return false;
-  const normalized = toolName.toLowerCase().replace(/[^a-z0-9]+/g, "_");
-  return [
-    "image_generation",
-    "image_gen",
-    "imagegen",
-    "generate_image",
-    "edit_image",
-    "text_to_image",
-    "images_generate"
-  ].some((token) => normalized.includes(token));
-}
-function shouldExtractGeneratedImagesFromToolResult(toolName) {
-  return isGeneratedImageToolName(toolName);
-}
-function collectStringValues(value2, out) {
-  if (typeof value2 === "string") {
-    out.push(value2);
-    return;
-  }
-  if (Array.isArray(value2)) {
-    for (const item of value2) collectStringValues(item, out);
-    return;
+// src/version.ts
+var AGENT_VERSION = "0.1.27";
+
+// src/daemon.ts
+var OPENCODE_FREE_MODEL_IDS = [
+  "opencode/north-mini-code-free",
+  "opencode/nemotron-3-ultra-free",
+  "opencode/deepseek-v4-flash-free",
+  "opencode/mimo-v2.5-free",
+  "opencode/big-pickle"
+];
+var MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
+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 requiredString(params, key) {
+  const value2 = params[key];
+  if (typeof value2 !== "string" || value2.trim() === "") {
+    throw new Error(`${key} is required`);
   }
-  if (!value2 || typeof value2 !== "object") return;
-  for (const entry of Object.values(value2)) {
-    collectStringValues(entry, out);
+  return value2;
+}
+function assertValidGitRef(ref, label) {
+  if (!ref || ref.startsWith("-") || ref.includes("\0")) {
+    throw new Error(`${label} is not a safe git ref`);
   }
+  const result = (0, import_node_child_process3.spawnSync)("git", ["check-ref-format", "--branch", ref], {
+    env: getDaemonCliEnvironment(),
+    encoding: "utf8"
+  });
+  if (result.status !== 0) throw new Error(`${label} is not a valid git ref`);
 }
-function candidateStrings(content) {
-  const values = [content];
-  try {
-    collectStringValues(JSON.parse(content), values);
-  } catch {
+function isPathContained(childPath, parentPath) {
+  const rel = (0, import_node_path3.relative)((0, import_node_path3.resolve)(parentPath), (0, import_node_path3.resolve)(childPath));
+  return rel === "" || !(0, import_node_path3.isAbsolute)(rel) && rel !== ".." && !rel.startsWith(`..${import_node_path3.sep}`);
+}
+function assertPathContained(childPath, parentPath, label) {
+  if (!isPathContained(childPath, parentPath)) {
+    throw new Error(`${label} escapes allowed directory`);
   }
-  return values;
 }
-function extractPathCandidates(content) {
-  const paths = /* @__PURE__ */ new Set();
-  const imagePathPattern = /(?:file:\/\/)?(?:~|\.{1,2}|\/)?[^\s"'`)\]}<>]+?\.(?:png|jpe?g|gif|webp)\b/gi;
-  for (const value2 of candidateStrings(content)) {
-    for (const match of value2.matchAll(imagePathPattern)) {
-      paths.add(match[0]);
-    }
+function git(cwd, args) {
+  const result = (0, import_node_child_process3.spawnSync)("git", args, {
+    cwd,
+    env: getDaemonCliEnvironment(),
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  if (result.status !== 0) {
+    throw new Error((result.stderr || result.stdout || "git command failed").trim());
   }
-  return [...paths];
+  return result.stdout.trim();
 }
-function normalizePath(candidate, cwd) {
-  let path = candidate.trim().replace(/^file:\/\//, "");
+function gitSafe(cwd, args) {
   try {
-    path = decodeURI(path);
+    return git(cwd, args);
   } catch {
+    return "";
   }
-  if (path.startsWith("~/")) return null;
-  if ((0, import_node_path3.isAbsolute)(path)) return path;
-  return cwd ? (0, import_node_path3.join)(cwd, path) : null;
 }
-function readImageDimensions2(buffer, mimeType) {
-  if (mimeType === "image/png" && buffer.length >= 24 && buffer.toString("ascii", 1, 4) === "PNG") {
-    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
-  }
-  if (mimeType === "image/gif" && buffer.length >= 10 && buffer.toString("ascii", 0, 3) === "GIF") {
-    return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
+function worktreeDir(projectPath) {
+  const resolved = (0, import_node_path3.resolve)(projectPath);
+  return (0, import_node_path3.join)((0, import_node_path3.dirname)(resolved), `${(0, import_node_path3.basename)(resolved)}-aiden-worktrees`);
+}
+function pathSegment(value2) {
+  return value2.toLowerCase().replace(/^aiden\//, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "task";
+}
+function repoName(repoUrl, localPath) {
+  return repoUrl.replace(/\.git$/, "").split("/").pop() || (0, import_node_path3.basename)(localPath) || "repo";
+}
+function findWorktreeByBranch(repoPath, branchName) {
+  const output = gitSafe(repoPath, ["worktree", "list", "--porcelain"]);
+  const entries = output ? output.split("\n\n") : [];
+  for (const entry of entries) {
+    const lines = entry.split("\n");
+    const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+    const branch = lines.find((line) => line.startsWith("branch "))?.slice("branch ".length).replace("refs/heads/", "");
+    if (path && branch === branchName) return path;
   }
-  if (mimeType === "image/jpeg" && buffer.length > 4) {
-    let offset = 2;
-    while (offset + 9 < buffer.length) {
-      if (buffer[offset] !== 255) break;
-      const marker = buffer[offset + 1];
-      const length = buffer.readUInt16BE(offset + 2);
-      if (length < 2) break;
-      if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+  return null;
+}
+function ensureGitWorktree(input) {
+  assertValidGitRef(input.branchName, "branchName");
+  assertValidGitRef(input.baseBranch, "baseBranch");
+  const repoPath = (0, import_node_path3.resolve)(input.repoPath);
+  const root = input.allowedRoot ?? worktreeDir(repoPath);
+  const existingPath = findWorktreeByBranch(input.repoPath, input.branchName);
+  if (existingPath) {
+    if ((0, import_node_path3.resolve)(existingPath) === repoPath) {
+      throw new Error(`${input.branchName} is checked out in the shared checkout`);
+    }
+    return existingPath;
+  }
+  assertPathContained(input.worktreePath, root, "worktreePath");
+  (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(input.worktreePath), { recursive: true });
+  if (!gitSafe(input.repoPath, ["branch", "--list", input.branchName])) {
+    git(input.repoPath, ["branch", input.branchName, input.baseBranch]);
+  }
+  if ((0, import_node_fs3.existsSync)(input.worktreePath)) {
+    if (gitSafe(input.worktreePath, ["branch", "--show-current"]) === input.branchName) {
+      return input.worktreePath;
+    }
+    throw new Error("worktree path already exists for a different checkout");
+  }
+  git(input.repoPath, ["worktree", "add", input.worktreePath, input.branchName]);
+  return input.worktreePath;
+}
+function ensureWorktree(params) {
+  const input = {
+    projectPath: requiredString(params, "projectPath"),
+    taskId: requiredString(params, "taskId"),
+    branchName: requiredString(params, "branchName"),
+    baseBranch: typeof params.baseBranch === "string" ? params.baseBranch : "main",
+    repoLocalPaths: Array.isArray(params.repoLocalPaths) ? params.repoLocalPaths : []
+  };
+  const taskRoot = (0, import_node_path3.join)(
+    worktreeDir(input.projectPath),
+    `${pathSegment(input.branchName)}-${input.taskId.slice(0, 8)}`
+  );
+  if (input.repoLocalPaths?.length) {
+    return {
+      worktrees: input.repoLocalPaths.map((repo) => {
+        const baseBranch = repo.branch || input.baseBranch || "main";
+        const worktreePath2 = ensureGitWorktree({
+          repoPath: repo.localPath,
+          worktreePath: (0, import_node_path3.join)(taskRoot, pathSegment(repoName(repo.repoUrl, repo.localPath))),
+          branchName: input.branchName,
+          baseBranch,
+          allowedRoot: worktreeDir(input.projectPath)
+        });
         return {
-          width: buffer.readUInt16BE(offset + 7),
-          height: buffer.readUInt16BE(offset + 5)
+          repoId: repo.repoId ?? null,
+          repoUrl: repo.repoUrl,
+          worktreePath: worktreePath2,
+          branchName: input.branchName,
+          baseBranch
         };
-      }
-      offset += 2 + length;
-    }
+      })
+    };
   }
-  return { width: null, height: null };
+  const worktreePath = ensureGitWorktree({
+    repoPath: input.projectPath,
+    worktreePath: taskRoot,
+    branchName: input.branchName,
+    baseBranch: input.baseBranch
+  });
+  return {
+    worktrees: [{ worktreePath, branchName: input.branchName, baseBranch: input.baseBranch }]
+  };
 }
-function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName) {
-  if (!shouldExtractGeneratedImagesFromToolResult(toolName)) return [];
-  const images = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of extractPathCandidates(content)) {
-    const path = normalizePath(candidate, cwd);
-    if (!path || seen.has(path) || !(0, import_node_fs3.existsSync)(path)) continue;
-    seen.add(path);
-    const ext = (0, import_node_path3.extname)(path).toLowerCase();
-    const mimeType = IMAGE_MIME_BY_EXT[ext];
-    if (!mimeType) continue;
-    const stat = (0, import_node_fs3.statSync)(path);
-    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_GENERATED_IMAGE_BYTES) continue;
-    const buffer = (0, import_node_fs3.readFileSync)(path);
-    const { width, height } = readImageDimensions2(buffer, mimeType);
-    images.push({
-      type: "generated_image",
-      id: (0, import_node_crypto.randomUUID)(),
-      filename: (0, import_node_path3.basename)(path),
-      mimeType,
-      size: buffer.length,
-      width,
-      height,
-      data: buffer.toString("base64"),
-      sourcePath: path,
-      sourceHash: (0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex"),
-      toolId,
-      ts: Date.now()
-    });
-  }
-  return images;
+function resolveRuntimeCwd(payload) {
+  const multiRepoWorktree = payload.worktreeInfo?.allWorktrees?.[0]?.worktreePath;
+  if (multiRepoWorktree) return (0, import_node_path3.dirname)(multiRepoWorktree);
+  return payload.worktreeInfo?.worktreePath ?? payload.projectPath ?? process.cwd();
+}
+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()])
+  );
 }
-
-// src/version.ts
-var AGENT_VERSION = "0.1.25";
-
-// src/daemon.ts
-var OPENCODE_FREE_MODEL_IDS = [
-  "opencode/north-mini-code-free",
-  "opencode/nemotron-3-ultra-free",
-  "opencode/deepseek-v4-flash-free",
-  "opencode/mimo-v2.5-free",
-  "opencode/big-pickle"
-];
-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";
 async function probeLocalDaemonEndpoint(port, token, timeoutMs = 750) {
   try {
     const headers = {};
@@ -12708,33 +13105,33 @@ function describeOccupiedLocalDaemon(port) {
   return `local daemon API port ${port} is already in use. If Aiden desktop is open, it manages the daemon automatically. Quit Aiden desktop or stop the existing daemon before starting another.`;
 }
 function getConfigPath() {
-  return process.env.AIDEN_AGENT_CONFIG_PATH ?? (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".aiden", "agent", "config.json");
+  return process.env.AIDEN_AGENT_CONFIG_PATH ?? (0, import_node_path3.join)((0, import_node_os4.homedir)(), ".aiden", "agent", "config.json");
 }
 function getEndpointDefaultsPath() {
-  return process.env.AIDEN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path4.join)((0, import_node_path4.dirname)(getConfigPath()), "endpoints.json");
+  return process.env.AIDEN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path3.join)((0, import_node_path3.dirname)(getConfigPath()), "endpoints.json");
 }
 function readConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_node_fs4.existsSync)(configPath)) return {};
-  return JSON.parse((0, import_node_fs4.readFileSync)(configPath, "utf8"));
+  if (!(0, import_node_fs3.existsSync)(configPath)) return {};
+  return JSON.parse((0, import_node_fs3.readFileSync)(configPath, "utf8"));
 }
 function readEndpointDefaults() {
   const endpointsPath = getEndpointDefaultsPath();
-  if (!(0, import_node_fs4.existsSync)(endpointsPath)) return {};
+  if (!(0, import_node_fs3.existsSync)(endpointsPath)) return {};
   try {
-    return JSON.parse((0, import_node_fs4.readFileSync)(endpointsPath, "utf8"));
+    return JSON.parse((0, import_node_fs3.readFileSync)(endpointsPath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
   const configPath = getConfigPath();
-  (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(configPath), { recursive: true, mode: 448 });
-  (0, import_node_fs4.writeFileSync)(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+  (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(configPath), { recursive: true, mode: 448 });
+  (0, import_node_fs3.writeFileSync)(configPath, JSON.stringify(config, null, 2), { mode: 384 });
 }
 function removeConfig() {
   const configPath = getConfigPath();
-  if ((0, import_node_fs4.existsSync)(configPath)) (0, import_node_fs4.rmSync)(configPath, { force: true });
+  if ((0, import_node_fs3.existsSync)(configPath)) (0, import_node_fs3.rmSync)(configPath, { force: true });
 }
 function argValue(args, name) {
   const index = args.indexOf(name);
@@ -12770,7 +13167,7 @@ function getLocalApiPort(args, stored) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function normalizeBackendKind(backendKind) {
   if (backendKind === "codex") return "codex_app_server";
@@ -12802,6 +13199,14 @@ function extractModelIdsFromJson(value2) {
   }
   return [];
 }
+function extractModelIdsFromText(value2) {
+  const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+  const ignoredLinePattern = /^(available models|models|usage|error|flag provided|try |agy\b)/i;
+  const ids = value2.split(/\r?\n/).map(
+    (line) => line.replace(ansiPattern, "").replace(/^[-*•]\s*/, "").trim()
+  ).filter((line) => line.length > 0 && !ignoredLinePattern.test(line));
+  return [...new Set(ids)];
+}
 function discoverOpenCodeModels(executable, env) {
   for (const args of [
     ["models", "--json"],
@@ -12810,7 +13215,7 @@ function discoverOpenCodeModels(executable, env) {
   ]) {
     const result = (0, import_node_child_process3.spawnSync)(executable, args, {
       encoding: "utf8",
-      timeout: 5e3,
+      timeout: MODEL_DISCOVERY_TIMEOUT_MS,
       env,
       windowsHide: true
     });
@@ -12823,7 +13228,27 @@ function discoverOpenCodeModels(executable, env) {
   }
   return OPENCODE_FREE_MODEL_IDS;
 }
+function discoverAntigravityModels(executable, env) {
+  for (const args of [["models", "--json"], ["models"]]) {
+    const result = (0, import_node_child_process3.spawnSync)(executable, args, {
+      encoding: "utf8",
+      timeout: MODEL_DISCOVERY_TIMEOUT_MS,
+      env,
+      windowsHide: true
+    });
+    if (!result || result.error || result.status !== 0 || !result.stdout.trim()) continue;
+    try {
+      const models = extractModelIdsFromJson(JSON.parse(result.stdout));
+      if (models.length > 0) return models;
+    } catch {
+      const models = extractModelIdsFromText(result.stdout);
+      if (models.length > 0) return models;
+    }
+  }
+  return [];
+}
 function discoverProviderModels(provider, executable, env) {
+  if (provider === "gemini_cli") return discoverAntigravityModels(executable, env);
   if (provider === "opencode_cli") return discoverOpenCodeModels(executable, env);
   return [];
 }
@@ -12904,7 +13329,7 @@ function collectRuntimeMetadata() {
     metadata.cpuCores = cpuList.length;
   }
   try {
-    const disk = (0, import_node_fs4.statfsSync)((0, import_node_os4.homedir)());
+    const disk = (0, import_node_fs3.statfsSync)((0, import_node_os4.homedir)());
     metadata.diskFreeBytes = disk.bavail * disk.bsize;
     metadata.diskTotalBytes = disk.blocks * disk.bsize;
   } catch {
@@ -12923,15 +13348,19 @@ 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();
+  emittedSessionMediaKeys = /* @__PURE__ */ new Set();
   toolNamesById = /* @__PURE__ */ new Map();
+  toolInputsById = /* @__PURE__ */ new Map();
+  browserRecordingPathHints = /* @__PURE__ */ new Set();
   emitEvent(event) {
     this.touchRunnerActivity?.();
     this.socket.emit("agent.event", {
@@ -12954,6 +13383,12 @@ var RuntimePresenter = class {
   }
   onToolUse(tool, input, toolId) {
     this.toolNamesById.set(toolId, tool);
+    this.toolInputsById.set(toolId, input);
+    for (const path of extractBrowserMediaPathHints(void 0, this.cwd, tool, {
+      toolInput: input
+    })) {
+      this.browserRecordingPathHints.add(path);
+    }
     this.emitEvent({ type: "tool_use", id: toolId, name: tool, input, ts: Date.now() });
   }
   onToolResult(toolId, content, isError) {
@@ -12966,9 +13401,27 @@ var RuntimePresenter = class {
     });
     if (isError) return;
     const toolName = this.toolNamesById.get(toolId);
-    for (const image of extractGeneratedImagesFromToolResult(toolId, content, this.cwd, toolName)) {
+    const toolInput = this.toolInputsById.get(toolId);
+    const options = { toolInput, pathHints: [...this.browserRecordingPathHints] };
+    for (const image of extractGeneratedImagesFromToolResult(
+      toolId,
+      content,
+      this.cwd,
+      toolName,
+      options
+    )) {
       this.emitGeneratedImage(image);
     }
+    for (const media of extractSessionMediaFromToolResult(
+      toolId,
+      content,
+      this.cwd,
+      toolName,
+      options
+    )) {
+      this.emitSessionMedia(media);
+      if (media.sourcePath) this.browserRecordingPathHints.delete(media.sourcePath);
+    }
   }
   onGeneratedImage(image) {
     this.emitGeneratedImage(image);
@@ -12979,6 +13432,15 @@ var RuntimePresenter = class {
     this.emittedGeneratedImageKeys.add(key);
     this.emitEvent(image);
   }
+  onSessionMedia(media) {
+    this.emitSessionMedia(media);
+  }
+  emitSessionMedia(media) {
+    const key = media.sourceHash ?? `${media.sourcePath ?? media.id}:${media.size}`;
+    if (this.emittedSessionMediaKeys.has(key)) return;
+    this.emittedSessionMediaKeys.add(key);
+    this.emitEvent(media);
+  }
   onTurnComplete(content) {
     this.emitEvent({ type: "turn_complete", content, ts: Date.now() });
   }
@@ -13015,6 +13477,7 @@ var RuntimePresenter = class {
   }
   onComplete(result) {
     this.emitEvent({ type: "query_complete", result, ts: Date.now() });
+    this.onRunComplete?.();
   }
 };
 async function setupDaemon(args) {
@@ -13068,7 +13531,7 @@ async function setupDaemon(args) {
     runtimeId: body.runtime.id,
     runtimeToken: body.runtimeToken,
     localApiPort: getLocalApiPort(args, {}),
-    localApiToken: (0, import_node_crypto2.randomBytes)(24).toString("hex"),
+    localApiToken: (0, import_node_crypto.randomBytes)(24).toString("hex"),
     displayName: body.runtime.displayName ?? displayName
   });
   console.info("[aiden-agent] Runtime registered", {
@@ -13119,7 +13582,7 @@ async function loginWithDeviceCode(args) {
       runtimeId: body.runtime.id,
       runtimeToken: body.runtimeToken,
       localApiPort: getLocalApiPort(args, {}),
-      localApiToken: (0, import_node_crypto2.randomBytes)(24).toString("hex"),
+      localApiToken: (0, import_node_crypto.randomBytes)(24).toString("hex"),
       displayName: body.runtime.displayName ?? displayName
     });
     console.info("[aiden-agent] Runtime registered", {
@@ -13136,7 +13599,7 @@ async function startDaemon(args) {
   const runtimeToken = argValue(args, "--token") ?? process.env.AIDEN_RUNTIME_TOKEN ?? stored.runtimeToken;
   const wsUrl = argValue(args, "--ws-url") ?? process.env.AIDEN_WS_URL ?? stored.wsUrl;
   let localApiPort = getLocalApiPort(args, stored);
-  const localApiToken = stored.localApiToken ?? (0, import_node_crypto2.randomBytes)(24).toString("hex");
+  const localApiToken = stored.localApiToken ?? (0, import_node_crypto.randomBytes)(24).toString("hex");
   if (!runtimeId || !runtimeToken || !wsUrl) {
     throw new Error(
       "daemon requires runtimeId, runtime token, and wsUrl. Run setup first or pass --runtime-id/--token/--ws-url."
@@ -13195,6 +13658,23 @@ async function startDaemon(args) {
     pushLog(`disconnected ${reason}`);
     console.info("[aiden-agent] Daemon disconnected:", reason);
   });
+  socket.on("desktop:rpc", (message) => {
+    if (!message?.id || !message.method) return;
+    try {
+      const params = message.params ?? {};
+      if (message.method !== "worktree.ensure") {
+        throw new Error(`Method not found: ${message.method}`);
+      }
+      const result = ensureWorktree(params);
+      socket.emit("desktop:rpc", { jsonrpc: "2.0", id: message.id, result });
+    } catch (error) {
+      socket.emit("desktop:rpc", {
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: -32e3, message: error.message }
+      });
+    }
+  });
   socket.on("agent.execute", (payload) => {
     if (!payload?.runId || !payload.conversationId || typeof payload.content !== "string") {
       return;
@@ -13213,19 +13693,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}`);
-    const cwd = payload.projectPath ?? process.cwd();
+    console.info("[aiden-agent] Agent run accepted", correlation);
+    const cwd = resolveRuntimeCwd(payload);
     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,
@@ -13254,7 +13749,7 @@ 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,
@@ -13263,13 +13758,17 @@ async function startDaemon(args) {
     }).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) => {
@@ -13279,6 +13778,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",
@@ -13362,7 +13865,7 @@ async function startDaemon(args) {
       `${describeOccupiedLocalDaemon(localApiPort)} The token in ${getConfigPath()} no longer matches the running daemon; quit Aiden desktop or run setup again.`
     );
   }
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const onError = (error) => {
       clearInterval(heartbeat);
       socket.disconnect();
@@ -13389,7 +13892,7 @@ async function startDaemon(args) {
       if (address && typeof address === "object") localApiPort = address.port;
       pushLog(`local_api listening port=${localApiPort}`);
       console.info("[aiden-agent] Local daemon API listening", { port: localApiPort });
-      resolve2();
+      resolve3();
     });
   });
   let stopped = false;
@@ -13402,8 +13905,8 @@ async function startDaemon(args) {
     }
     activeAgents.clear();
     socket.disconnect();
-    await new Promise((resolve2) => {
-      localServer.close(() => resolve2());
+    await new Promise((resolve3) => {
+      localServer.close(() => resolve3());
     });
   };
   const controller = {
@@ -13607,6 +14110,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) {
@@ -13615,7 +14190,10 @@ var WebPresenter = class {
   }
   wsClient;
   emittedGeneratedImageKeys = /* @__PURE__ */ new Set();
+  emittedSessionMediaKeys = /* @__PURE__ */ new Set();
   toolNamesById = /* @__PURE__ */ new Map();
+  toolInputsById = /* @__PURE__ */ new Map();
+  browserRecordingPathHints = /* @__PURE__ */ new Set();
   suppressSessionLifecycle = false;
   setSuppressSessionLifecycle(suppress) {
     this.suppressSessionLifecycle = suppress;
@@ -13634,6 +14212,12 @@ var WebPresenter = class {
   }
   onToolUse(tool, input, toolId) {
     this.toolNamesById.set(toolId, tool);
+    this.toolInputsById.set(toolId, input);
+    for (const path of extractBrowserMediaPathHints(void 0, this.cwd, tool, {
+      toolInput: input
+    })) {
+      this.browserRecordingPathHints.add(path);
+    }
     this.wsClient.emitEvent({ type: "tool_use", id: toolId, name: tool, input, ts: Date.now() });
   }
   onToolResult(toolId, content, isError) {
@@ -13646,9 +14230,27 @@ var WebPresenter = class {
     });
     if (isError) return;
     const toolName = this.toolNamesById.get(toolId);
-    for (const image of extractGeneratedImagesFromToolResult(toolId, content, this.cwd, toolName)) {
+    const toolInput = this.toolInputsById.get(toolId);
+    const options = { toolInput, pathHints: [...this.browserRecordingPathHints] };
+    for (const image of extractGeneratedImagesFromToolResult(
+      toolId,
+      content,
+      this.cwd,
+      toolName,
+      options
+    )) {
       this.emitGeneratedImage(image);
     }
+    for (const media of extractSessionMediaFromToolResult(
+      toolId,
+      content,
+      this.cwd,
+      toolName,
+      options
+    )) {
+      this.emitSessionMedia(media);
+      if (media.sourcePath) this.browserRecordingPathHints.delete(media.sourcePath);
+    }
   }
   onGeneratedImage(image) {
     this.emitGeneratedImage(image);
@@ -13659,6 +14261,15 @@ var WebPresenter = class {
     this.emittedGeneratedImageKeys.add(key);
     this.wsClient.emitEvent(image);
   }
+  onSessionMedia(media) {
+    this.emitSessionMedia(media);
+  }
+  emitSessionMedia(media) {
+    const key = media.sourceHash ?? `${media.sourcePath ?? media.id}:${media.size}`;
+    if (this.emittedSessionMediaKeys.has(key)) return;
+    this.emittedSessionMediaKeys.add(key);
+    this.wsClient.emitEvent(media);
+  }
   onTurnComplete(content) {
     this.wsClient.emitEvent({ type: "turn_complete", content, ts: Date.now() });
   }
@@ -13725,8 +14336,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 },
@@ -13741,13 +14353,14 @@ var WSClient = class {
     });
     this.setupListeners(callbacks);
   }
+  socket;
   emitEvent(event) {
     this.socket.emit("agent_event", event);
   }
   waitForConnection(timeoutMs = 15e3) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       if (this.socket.connected) {
-        resolve2();
+        resolve3();
         return;
       }
       const timeout = setTimeout(
@@ -13756,7 +14369,7 @@ var WSClient = class {
       );
       this.socket.once("connect", () => {
         clearTimeout(timeout);
-        resolve2();
+        resolve3();
       });
       this.socket.once("connect_error", (err) => {
         clearTimeout(timeout);
@@ -13767,20 +14380,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",
@@ -13805,6 +14424,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
@@ -13820,12 +14440,32 @@ 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 = [];
@@ -13840,15 +14480,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,
@@ -13857,16 +14508,41 @@ async function runSandbox(config) {
     config.sessionToken,
     {
       onUserMessage: (payload) => {
+        if (payload === null) {
+          if (pendingMessageResolve) {
+            const resolve3 = pendingMessageResolve;
+            pendingMessageResolve = null;
+            resolve3(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;
+          const resolve3 = pendingMessageResolve;
           pendingMessageResolve = null;
-          resolve2(payload);
+          resolve3(payload);
         } else {
           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();
@@ -13876,21 +14552,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);
@@ -13909,8 +14588,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,
@@ -13954,7 +14658,13 @@ async function runSandbox(config) {
         });
       } 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",
@@ -13965,13 +14675,23 @@ 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 = queuedMessages.shift() ?? await new Promise((resolve2) => {
-      pendingMessageResolve = resolve2;
+    const nextPayload = queuedMessages.shift() ?? await new Promise((resolve3) => {
+      pendingMessageResolve = resolve3;
     });
     if (nextPayload === null || stopped) {
       break;
@@ -14018,6 +14738,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;
     }
@@ -14035,6 +14764,7 @@ async function runSandbox(config) {
     }
   }
   presenter.setSuppressSessionLifecycle(false);
+  lifecycle.info("sandbox_agent_process_exit");
   wsClient.close();
 }
 
@@ -14057,20 +14787,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,
@@ -14090,6 +14828,10 @@ async function runSessionFromEnv() {
     providerSessionId,
     workflowId,
     workflowExecutionId,
+    sandboxId,
+    provider,
+    runId,
+    lifecycle,
     maxIterations: 50
   });
 }
@@ -14149,7 +14891,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: