@alook/app 0.0.68 → 0.0.69

package/dist/cli/index.js

@@ -16820,6 +16820,9 @@ var RESERVED_HANDLES = new Set([
   "system",
   "alook"
 ]);
+function toAlookAddress(h) {
+  return `${h}${DOMAIN}`;
+}
 // ../shared/src/semver.ts
 function semverGte(a, b) {
   const pa = a.split(".").map(Number);
@@ -17292,8 +17295,8 @@ function statusCommand() {
 
 // commands/daemon.ts
 import { Command as Command3 } from "commander";
-import { spawn as spawn3 } from "child_process";
-import { openSync as openSync2, closeSync as closeSync2, mkdirSync as mkdirSync6 } from "fs";
+import { spawn as spawn6 } from "child_process";
+import { openSync as openSync2, closeSync as closeSync2, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname4 } from "path";
 
 // daemon/client.ts
@@ -17431,72 +17434,2176 @@ function createHealthServer(port = DEFAULT_HEALTH_PORT) {
     setRuntimeCount(n) {
       runtimeCount = n;
     }
-  };
+  };
+}
+
+// daemon/agent/claude.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+class ClaudeBackend {
+  cliPath;
+  name = "claude";
+  constructor(cliPath) {
+    this.cliPath = cliPath;
+  }
+  execute(prompt, options) {
+    const args = [
+      "-p",
+      prompt,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "bypassPermissions"
+    ];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    if (options.maxTurns) {
+      args.push("--max-turns", String(options.maxTurns));
+    }
+    if (options.resumeSessionId) {
+      args.push("--resume", options.resumeSessionId);
+    }
+    const proc = spawn(this.cliPath, args, {
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...options.env }
+    });
+    if (!proc.pid) {
+      const error51 = `Failed to start ${this.cliPath}: binary not found or not executable. Is 'claude' installed and on PATH?`;
+      const failedResult = { status: "failed", output: "", error: error51, durationMs: 0, sessionId: "" };
+      const emptyMessages = { [Symbol.asyncIterator]() {
+        return { async next() {
+          return { value: undefined, done: true };
+        } };
+      } };
+      return { pid: undefined, messages: emptyMessages, sessionId: Promise.resolve(""), result: Promise.resolve(failedResult) };
+    }
+    let timedOut = false;
+    let timeoutTimer;
+    if (options.timeout) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, options.timeout);
+    }
+    const startTime = Date.now();
+    let lastSessionId = "";
+    let lastOutput = "";
+    let lastError = "";
+    let resultStatus = "completed";
+    let resolveSessionId;
+    const sessionIdPromise = new Promise((resolve) => {
+      resolveSessionId = resolve;
+    });
+    const messageQueue = [];
+    let messageResolve = null;
+    let messageDone = false;
+    const pushMessage = (msg) => {
+      messageQueue.push(msg);
+      if (messageResolve) {
+        const r = messageResolve;
+        messageResolve = null;
+        r();
+      }
+    };
+    const resultPromise = new Promise((resolve) => {
+      const stderrChunks = [];
+      proc.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk.toString());
+      });
+      const rl = createInterface({ input: proc.stdout });
+      rl.on("line", (line) => {
+        if (!line.trim())
+          return;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          pushMessage({ type: "log", content: line, level: "debug" });
+          return;
+        }
+        const eventType = event.type;
+        switch (eventType) {
+          case "assistant": {
+            const message2 = event.message;
+            if (!message2)
+              break;
+            const content = message2.content;
+            if (!Array.isArray(content))
+              break;
+            for (const block of content) {
+              if (block.type === "text") {
+                lastOutput = block.text || "";
+                pushMessage({ type: "text", content: block.text });
+              } else if (block.type === "thinking") {
+                pushMessage({ type: "thinking", content: block.text });
+              } else if (block.type === "tool_use") {
+                pushMessage({
+                  type: "tool-use",
+                  tool: block.name,
+                  callId: block.id,
+                  input: block.input
+                });
+              }
+            }
+            break;
+          }
+          case "result": {
+            const result = event.result;
+            const sessionId = event.session_id;
+            if (result)
+              lastOutput = result;
+            if (sessionId)
+              lastSessionId = sessionId;
+            const isError = event.is_error;
+            if (isError) {
+              resultStatus = "failed";
+              lastError = result || "unknown error";
+            }
+            break;
+          }
+          case "tool_result": {
+            const content = event.content;
+            const toolUseId = event.tool_use_id;
+            pushMessage({
+              type: "tool-result",
+              callId: toolUseId,
+              output: content
+            });
+            break;
+          }
+          case "system": {
+            const subtype = event.subtype;
+            if (subtype === "init") {
+              const sid = event.session_id;
+              if (sid) {
+                lastSessionId = sid;
+                resolveSessionId(sid);
+              }
+            }
+            break;
+          }
+          case "control_request": {
+            handleControlRequest(proc, event);
+            break;
+          }
+          default: {
+            pushMessage({
+              type: "log",
+              content: line,
+              level: "debug"
+            });
+          }
+        }
+      });
+      proc.on("error", (err) => {
+        resultStatus = "failed";
+        lastError = `spawn error: ${err.message}`;
+        resolveSessionId(lastSessionId);
+        messageDone = true;
+        if (messageResolve) {
+          const r = messageResolve;
+          messageResolve = null;
+          r();
+        }
+        resolve({
+          status: "failed",
+          output: "",
+          error: lastError,
+          durationMs: Date.now() - startTime,
+          sessionId: lastSessionId
+        });
+      });
+      proc.on("close", (code) => {
+        if (timeoutTimer)
+          clearTimeout(timeoutTimer);
+        if (timedOut) {
+          resultStatus = "timeout";
+        } else if (code !== 0 && resultStatus === "completed") {
+          resultStatus = "failed";
+        }
+        const stderr = stderrChunks.join("");
+        if (stderr && !lastError) {
+          lastError = stderr;
+        }
+        resolveSessionId(lastSessionId);
+        messageDone = true;
+        if (messageResolve) {
+          const r = messageResolve;
+          messageResolve = null;
+          r();
+        }
+        resolve({
+          status: resultStatus,
+          output: lastOutput,
+          error: lastError,
+          durationMs: Date.now() - startTime,
+          sessionId: lastSessionId
+        });
+      });
+    });
+    const messages = {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            while (messageQueue.length === 0 && !messageDone) {
+              await new Promise((resolve) => {
+                messageResolve = resolve;
+              });
+            }
+            if (messageQueue.length > 0) {
+              return { value: messageQueue.shift(), done: false };
+            }
+            return { value: undefined, done: true };
+          }
+        };
+      }
+    };
+    return { pid: proc.pid, messages, sessionId: sessionIdPromise, result: resultPromise };
+  }
+}
+function handleControlRequest(proc, event) {
+  const requestId = event.request_id;
+  if (!requestId)
+    return;
+  let updatedInput = undefined;
+  const payload = event.payload;
+  if (payload) {
+    const input = payload.input;
+    if (typeof input === "string") {
+      try {
+        updatedInput = JSON.parse(input);
+      } catch {
+        updatedInput = input;
+      }
+    } else if (input !== undefined) {
+      updatedInput = input;
+    }
+  }
+  const approval = JSON.stringify({
+    type: "control_response",
+    response: {
+      subtype: "success",
+      request_id: requestId,
+      response: {
+        behavior: "allow",
+        updatedInput
+      }
+    }
+  });
+  try {
+    proc.stdin?.write(approval + `
+`);
+  } catch {}
+}
+
+// daemon/agent/codex.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+var RAW_DETECTION_METHODS = new Set([
+  "turn/started",
+  "turn/completed",
+  "thread/started",
+  "item/started",
+  "item/completed",
+  "item/agentMessage/delta"
+]);
+function extractThreadID(response) {
+  if (response && typeof response === "object") {
+    const r = response;
+    const thread = r.result?.thread ?? r.thread;
+    if (thread && typeof thread === "object") {
+      const id = thread.id;
+      if (typeof id === "string" && id)
+        return id;
+    }
+    if (typeof r.id === "string" && r.id)
+      return r.id;
+  }
+  return "";
+}
+
+class CodexBackend {
+  cliPath;
+  name = "codex";
+  constructor(cliPath) {
+    this.cliPath = cliPath;
+  }
+  execute(prompt, options) {
+    const proc = spawn2(this.cliPath, ["app-server", "--listen", "stdio://", "--config", "sandbox_mode=danger-full-access"], {
+      cwd: options.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...options.env }
+    });
+    if (!proc.pid) {
+      const error51 = `Failed to start ${this.cliPath}: binary not found or not executable. Is 'codex' installed and on PATH?`;
+      const failedResult = { status: "failed", output: "", error: error51, durationMs: 0, sessionId: "" };
+      const emptyMessages = { [Symbol.asyncIterator]() {
+        return { async next() {
+          return { value: undefined, done: true };
+        } };
+      } };
+      return { pid: undefined, messages: emptyMessages, sessionId: Promise.resolve(""), result: Promise.resolve(failedResult) };
+    }
+    let timedOut = false;
+    let timeoutTimer;
+    if (options.timeout) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, options.timeout);
+    }
+    const startTime = Date.now();
+    let requestId = 0;
+    let lastOutput = "";
+    let lastError = "";
+    let resultStatus = "completed";
+    let sessionId = "";
+    let resolveSessionId;
+    const sessionIdPromise = new Promise((resolve) => {
+      resolveSessionId = resolve;
+    });
+    let notificationProtocol = "unknown";
+    let turnStarted = false;
+    let turnDoneTriggered = false;
+    let turnCompletedSuccessfully = false;
+    let lastCompletedTurnId = "";
+    let turnError = "";
+    const pendingRequests = new Map;
+    const messageQueue = [];
+    let messageResolve = null;
+    let messageDone = false;
+    const pushMessage = (msg) => {
+      messageQueue.push(msg);
+      if (messageResolve) {
+        const r = messageResolve;
+        messageResolve = null;
+        r();
+      }
+    };
+    const writeStdin = (data) => {
+      try {
+        proc.stdin?.write(data + `
+`);
+      } catch {}
+    };
+    const sendRpc = (method, params) => {
+      const id = ++requestId;
+      const msg = { jsonrpc: "2.0", id, method, params };
+      writeStdin(JSON.stringify(msg));
+      return new Promise((resolve, reject) => {
+        pendingRequests.set(id, { resolve, reject });
+      });
+    };
+    const sendNotification = (method) => {
+      const msg = { jsonrpc: "2.0", method };
+      writeStdin(JSON.stringify(msg));
+    };
+    const sendResponse = (id, result) => {
+      const msg = { jsonrpc: "2.0", id, result };
+      writeStdin(JSON.stringify(msg));
+    };
+    const closeAllPending = (reason) => {
+      for (const [, cb] of pendingRequests) {
+        cb.reject(new Error(reason));
+      }
+      pendingRequests.clear();
+    };
+    const setTurnError = (msg) => {
+      if (msg && !turnError)
+        turnError = msg;
+    };
+    const triggerTurnDone = (aborted2) => {
+      if (turnDoneTriggered)
+        return;
+      turnDoneTriggered = true;
+      resultStatus = aborted2 ? "aborted" : "completed";
+      try {
+        proc.stdin?.end();
+      } catch {}
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+    };
+    const handleServerRequest = (msg) => {
+      const method = msg.method;
+      const id = msg.id;
+      switch (method) {
+        case "item/commandExecution/requestApproval":
+        case "execCommandApproval":
+        case "item/fileChange/requestApproval":
+        case "applyPatchApproval":
+          sendResponse(id, { decision: "accept" });
+          break;
+        default:
+          sendResponse(id, {});
+          break;
+      }
+    };
+    const handleNotification = (msg) => {
+      const method = msg.method;
+      const params = msg.params || {};
+      if (method === "codex/event") {
+        if (notificationProtocol === "raw")
+          return;
+        notificationProtocol = "legacy";
+        handleLegacyEvent(params);
+        return;
+      }
+      if (RAW_DETECTION_METHODS.has(method)) {
+        if (notificationProtocol === "legacy")
+          return;
+        notificationProtocol = "raw";
+      }
+      if ((method === "thread/status/changed" || method === "error") && notificationProtocol === "legacy") {
+        return;
+      }
+      const notifThreadId = params.threadId;
+      if (sessionId && notifThreadId && notifThreadId !== sessionId) {
+        return;
+      }
+      switch (method) {
+        case "turn/started": {
+          turnStarted = true;
+          break;
+        }
+        case "turn/completed": {
+          const turn = params.turn;
+          const turnId = turn?.id || params.turnId || "";
+          if (turnId && turnId === lastCompletedTurnId)
+            return;
+          if (turnId)
+            lastCompletedTurnId = turnId;
+          const status = turn?.status || params.status || "";
+          if (status === "completed" || status === "finished") {
+            turnCompletedSuccessfully = true;
+            triggerTurnDone(false);
+          } else if (status === "cancelled" || status === "aborted" || status === "interrupted") {
+            triggerTurnDone(true);
+          } else if (status === "error" || status === "failed") {
+            const turnErr = turn?.error;
+            setTurnError(turnErr?.message || "codex turn failed");
+            triggerTurnDone(false);
+          }
+          break;
+        }
+        case "error": {
+          const errObj = params.error;
+          const errMsg = errObj?.message || params.message || "";
+          const willRetry = params.willRetry === true;
+          if (errMsg && !willRetry) {
+            setTurnError(errMsg);
+          }
+          break;
+        }
+        case "thread/status/changed": {
+          const statusObj = params.status;
+          const statusType = typeof statusObj === "object" && statusObj !== null ? statusObj.type || "" : statusObj || "";
+          if (statusType === "idle" && turnStarted) {
+            triggerTurnDone(false);
+          }
+          break;
+        }
+        case "item/started": {
+          const item = params.item;
+          if (!item)
+            break;
+          const itemType = item.type;
+          if (itemType === "commandExecution") {
+            pushMessage({
+              type: "tool-use",
+              tool: "exec_command",
+              callId: item.id,
+              input: item
+            });
+          } else if (itemType === "fileChange") {
+            pushMessage({
+              type: "tool-use",
+              tool: "patch_apply",
+              callId: item.id,
+              input: item
+            });
+          }
+          break;
+        }
+        case "item/completed": {
+          const item = params.item;
+          if (!item)
+            break;
+          const itemType = item.type;
+          if (itemType === "commandExecution") {
+            const output = item.aggregatedOutput || "";
+            pushMessage({
+              type: "tool-result",
+              callId: item.id,
+              output
+            });
+          } else if (itemType === "fileChange") {
+            pushMessage({
+              type: "tool-result",
+              callId: item.id,
+              output: ""
+            });
+          } else if (itemType === "agentMessage") {
+            const flatText = item.text;
+            if (flatText) {
+              pushMessage({ type: "text", content: flatText });
+              lastOutput = flatText;
+            } else {
+              const content = item.content;
+              if (Array.isArray(content)) {
+                for (const block of content) {
+                  if (block.type === "output_text" || block.type === "text") {
+                    if (block.text) {
+                      pushMessage({ type: "text", content: block.text });
+                      lastOutput = block.text;
+                    }
+                  }
+                }
+              }
+            }
+            const phase = item.phase;
+            if (phase === "final_answer") {
+              triggerTurnDone(false);
+            }
+          }
+          break;
+        }
+        default: {
+          pushMessage({
+            type: "log",
+            content: JSON.stringify(msg),
+            level: "debug"
+          });
+        }
+      }
+    };
+    const handleLegacyEvent = (params) => {
+      const eventType = params.type;
+      if (!eventType)
+        return;
+      switch (eventType) {
+        case "task_started":
+          break;
+        case "agent_message": {
+          const text2 = params.text || params.message || "";
+          if (text2) {
+            pushMessage({ type: "text", content: text2 });
+            lastOutput = text2;
+          }
+          break;
+        }
+        case "exec_command_begin":
+          pushMessage({
+            type: "tool-use",
+            tool: "exec_command",
+            callId: params.id,
+            input: params
+          });
+          break;
+        case "exec_command_end":
+          pushMessage({
+            type: "tool-result",
+            callId: params.id,
+            output: params.output || ""
+          });
+          break;
+        case "patch_apply_begin":
+          pushMessage({
+            type: "tool-use",
+            tool: "patch_apply",
+            callId: params.id,
+            input: params
+          });
+          break;
+        case "patch_apply_end":
+          pushMessage({
+            type: "tool-result",
+            callId: params.id,
+            output: params.output || ""
+          });
+          break;
+        case "task_complete": {
+          const output = params.output;
+          if (output)
+            lastOutput = output;
+          triggerTurnDone(false);
+          break;
+        }
+        case "turn_aborted":
+          triggerTurnDone(true);
+          break;
+      }
+    };
+    const resultPromise = new Promise((resolve) => {
+      const stderrChunks = [];
+      proc.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk.toString());
+      });
+      const rl = createInterface2({ input: proc.stdout });
+      rl.on("line", (line) => {
+        if (!line.trim())
+          return;
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          pushMessage({ type: "log", content: line, level: "debug" });
+          return;
+        }
+        if (msg.id !== undefined && msg.method) {
+          handleServerRequest(msg);
+          return;
+        }
+        if (msg.method && msg.id === undefined) {
+          handleNotification(msg);
+          return;
+        }
+        if (msg.id !== undefined && !msg.method) {
+          const pending = pendingRequests.get(msg.id);
+          if (pending) {
+            pendingRequests.delete(msg.id);
+            if (msg.error) {
+              pending.reject(new Error(msg.error.message));
+            } else {
+              pending.resolve(msg.result);
+            }
+          }
+          return;
+        }
+        pushMessage({
+          type: "log",
+          content: JSON.stringify(msg),
+          level: "debug"
+        });
+      });
+      const startHandshake = async () => {
+        try {
+          await sendRpc("initialize", {
+            clientInfo: {
+              name: "alook-daemon",
+              title: "Alook Agent SDK",
+              version: "0.1.0"
+            },
+            capabilities: { experimentalApi: true }
+          });
+          sendNotification("initialized");
+          let threadResponse;
+          if (options.resumeSessionId) {
+            threadResponse = await sendRpc("thread/resume", {
+              threadId: options.resumeSessionId,
+              ...options.model ? { model: options.model } : {}
+            });
+            sessionId = options.resumeSessionId;
+          } else {
+            const threadParams = {
+              cwd: options.cwd,
+              sandboxPolicy: { type: "dangerFullAccess" },
+              approvalPolicy: "never",
+              persistExtendedHistory: true,
+              experimentalRawEvents: false
+            };
+            if (options.model) {
+              threadParams.model = options.model;
+            }
+            threadResponse = await sendRpc("thread/start", threadParams);
+            sessionId = extractThreadID(threadResponse);
+          }
+          resolveSessionId(sessionId);
+          await sendRpc("turn/start", {
+            threadId: sessionId,
+            input: [{ type: "text", text: prompt }],
+            sandboxPolicy: { type: "dangerFullAccess" },
+            approvalPolicy: "never"
+          });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : "handshake failed";
+          lastError = errMsg;
+          resultStatus = "failed";
+          pushMessage({ type: "error", content: errMsg });
+        }
+      };
+      startHandshake();
+      proc.on("error", (err) => {
+        resultStatus = "failed";
+        lastError = `spawn error: ${err.message}`;
+        closeAllPending("spawn error");
+        resolveSessionId(sessionId);
+        messageDone = true;
+        if (messageResolve) {
+          const r = messageResolve;
+          messageResolve = null;
+          r();
+        }
+        resolve({
+          status: "failed",
+          output: "",
+          error: lastError,
+          durationMs: Date.now() - startTime,
+          sessionId
+        });
+      });
+      proc.on("close", (code) => {
+        if (timeoutTimer)
+          clearTimeout(timeoutTimer);
+        closeAllPending("process closed");
+        if (timedOut) {
+          resultStatus = "timeout";
+        } else if (code !== 0 && resultStatus === "completed" && !turnCompletedSuccessfully) {
+          if (!lastOutput) {
+            resultStatus = "failed";
+          }
+        }
+        const stderr = stderrChunks.join("").replace(/\x1b\[[0-9;]*m/g, "");
+        if (stderr && !lastError) {
+          lastError = stderr;
+        }
+        if (turnError) {
+          resultStatus = "failed";
+          lastError = turnError;
+        }
+        resolveSessionId(sessionId);
+        messageDone = true;
+        if (messageResolve) {
+          const r = messageResolve;
+          messageResolve = null;
+          r();
+        }
+        resolve({
+          status: resultStatus,
+          output: lastOutput,
+          error: lastError,
+          durationMs: Date.now() - startTime,
+          sessionId
+        });
+      });
+    });
+    const messages = {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            while (messageQueue.length === 0 && !messageDone) {
+              await new Promise((resolve) => {
+                messageResolve = resolve;
+              });
+            }
+            if (messageQueue.length > 0) {
+              return { value: messageQueue.shift(), done: false };
+            }
+            return { value: undefined, done: true };
+          }
+        };
+      }
+    };
+    return { pid: proc.pid, messages, sessionId: sessionIdPromise, result: resultPromise };
+  }
+}
+
+// daemon/agent/opencode.ts
+import { spawn as spawn3 } from "child_process";
+import { createInterface as createInterface3 } from "readline";
+
+class OpenCodeBackend {
+  cliPath;
+  name = "opencode";
+  constructor(cliPath) {
+    this.cliPath = cliPath;
+  }
+  execute(prompt, options) {
+    const args = ["run", "--format", "json"];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    if (options.resumeSessionId) {
+      args.push("--session", options.resumeSessionId);
+    }
+    args.push(prompt);
+    const proc = spawn3(this.cliPath, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...options.env, OPENCODE_PERMISSION: '{"*":"allow"}' }
+    });
+    if (!proc.pid) {
+      const error51 = `Failed to start ${this.cliPath}: binary not found or not executable. Is 'opencode' installed and on PATH?`;
+      const failedResult = { status: "failed", output: "", error: error51, durationMs: 0, sessionId: "" };
+      const emptyMessages = { [Symbol.asyncIterator]() {
+        return { async next() {
+          return { value: undefined, done: true };
+        } };
+      } };
+      return { pid: undefined, messages: emptyMessages, sessionId: Promise.resolve(""), result: Promise.resolve(failedResult) };
+    }
+    let timedOut = false;
+    let timeoutTimer;
+    if (options.timeout) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, options.timeout);
+    }
+    const startTime = Date.now();
+    let lastSessionId = "";
+    let lastOutput = "";
+    let lastError = "";
+    let resultStatus = "completed";
+    let resolveSessionId;
+    const sessionIdPromise = new Promise((resolve) => {
+      resolveSessionId = resolve;
+    });
+    let turnDoneTriggered = false;
+    const turnDone = () => {
+      if (turnDoneTriggered)
+        return;
+      turnDoneTriggered = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+    };
+    const messageQueue = [];
+    let messageResolve = null;
+    let messageDone = false;
+    const pushMessage = (msg) => {
+      messageQueue.push(msg);
+      if (messageResolve) {
+        const r = messageResolve;
+        messageResolve = null;
+        r();
+      }
+    };
+    const resultPromise = new Promise((resolve) => {
+      const stderrChunks = [];
+      proc.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk.toString());
+      });
+      const rl = createInterface3({ input: proc.stdout });
+      rl.on("line", (line) => {
+        if (!line.trim())
+          return;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          pushMessage({ type: "log", content: line, level: "debug" });
+          return;
+        }
+        const eventType = event.type;
+        const part = event.part;
+        const eventSessionId = event.sessionID || event.session_id;
+        if (eventSessionId && !lastSessionId) {
+          lastSessionId = eventSessionId;
+          resolveSessionId(eventSessionId);
+        }
+        switch (eventType) {
+          case "session": {
+            const sessionId = event.session_id;
+            if (sessionId) {
+              lastSessionId = sessionId;
+              resolveSessionId(sessionId);
+            }
+            break;
+          }
+          case "message": {
+            const role = event.role;
+            const content = event.content;
+            if (role === "assistant" && content) {
+              lastOutput = content;
+              pushMessage({ type: "text", content });
+            }
+            break;
+          }
+          case "text": {
+            const text2 = part?.text || event.content || "";
+            if (text2) {
+              lastOutput = text2;
+              pushMessage({ type: "text", content: text2 });
+            }
+            break;
+          }
+          case "thinking": {
+            const content = part?.thinking || event.content || "";
+            pushMessage({ type: "thinking", content });
+            break;
+          }
+          case "tool_call": {
+            pushMessage({
+              type: "tool-use",
+              tool: event.name || part?.name || "",
+              callId: event.call_id || part?.id || "",
+              input: event.input || part?.input
+            });
+            break;
+          }
+          case "tool_result": {
+            pushMessage({
+              type: "tool-result",
+              callId: event.call_id || part?.id || "",
+              output: event.output || part?.output || ""
+            });
+            break;
+          }
+          case "error": {
+            const content = event.message || event.content || part?.error || "";
+            lastError = content;
+            pushMessage({ type: "error", content });
+            turnDone();
+            break;
+          }
+          case "step_start": {
+            break;
+          }
+          case "step_finish": {
+            const reason = part?.reason;
+            if (reason === "stop" || reason === "end_turn") {
+              turnDone();
+            }
+            break;
+          }
+          case "done":
+          case "complete": {
+            const output = event.output;
+            const status = event.status;
+            const sessionId = event.session_id;
+            if (output)
+              lastOutput = output;
+            if (sessionId)
+              lastSessionId = sessionId;
+            if (status === "error" || status === "failed") {
+              resultStatus = "failed";
+              if (!lastError)
+                lastError = output || "task failed";
+            }
+            turnDone();
+            break;
+          }
+          default: {
+            pushMessage({
+              type: "log",
+              content: line,
+              level: "debug"
+            });
+          }
+        }
+      });
+      proc.on("error", (err) => {
+        resultStatus = "failed";
+        lastError = `spawn error: ${err.message}`;
+        resolveSessionId(lastSessionId);
+        messageDone = true;
+        if (messageResolve) {
+          const r = messageResolve;
+          messageResolve = null;
+          r();
+        }
+        resolve({
+          status: "failed",
+          output: "",
+          error: lastError,
+          durationMs: Date.now() - startTime,
+          sessionId: lastSessionId
+        });
+      });
+      proc.on("close", (code) => {
+        if (timeoutTimer)
+          clearTimeout(timeoutTimer);
+        if (timedOut) {
+          resultStatus = "timeout";
+        } else if (code !== 0 && resultStatus === "completed" && !turnDoneTriggered) {
+          if (!lastOutput) {
+            resultStatus = "failed";
+          }
+        }
+        const stderr = stderrChunks.join("");
+        if (stderr && !lastError) {
+          lastError = stderr;
+        }
+        resolveSessionId(lastSessionId);
+        messageDone = true;
+        if (messageResolve) {
+          const r = messageResolve;
+          messageResolve = null;
+          r();
+        }
+        resolve({
+          status: resultStatus,
+          output: lastOutput,
+          error: lastError,
+          durationMs: Date.now() - startTime,
+          sessionId: lastSessionId
+        });
+      });
+    });
+    const messages = {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            while (messageQueue.length === 0 && !messageDone) {
+              await new Promise((resolve) => {
+                messageResolve = resolve;
+              });
+            }
+            if (messageQueue.length > 0) {
+              return { value: messageQueue.shift(), done: false };
+            }
+            return { value: undefined, done: true };
+          }
+        };
+      }
+    };
+    return { pid: proc.pid, messages, sessionId: sessionIdPromise, result: resultPromise };
+  }
+}
+
+// daemon/agent/index.ts
+import { execSync as execSync2 } from "child_process";
+function createBackend(provider, cliPath) {
+  switch (provider) {
+    case "claude":
+      return new ClaudeBackend(cliPath);
+    case "codex":
+      return new CodexBackend(cliPath);
+    case "opencode":
+      return new OpenCodeBackend(cliPath);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+async function detectVersion2(cliPath) {
+  try {
+    return execSync2(`${cliPath} --version`, { encoding: "utf-8" }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+
+// daemon/types.ts
+function fromApiTask(api2) {
+  return {
+    id: api2.id,
+    agentId: api2.agent_id,
+    runtimeId: api2.runtime_id,
+    conversationId: api2.conversation_id,
+    workspaceId: api2.workspace_id,
+    prompt: api2.prompt,
+    status: api2.status,
+    priority: api2.priority,
+    type: api2.type,
+    contextKey: api2.context_key ?? null,
+    context: api2.context ?? undefined,
+    agent: api2.agent ? {
+      name: api2.agent.name,
+      instructions: api2.agent.instructions,
+      emailHandle: api2.agent.email_handle ?? undefined,
+      emailAddresses: api2.agent.email_addresses ?? [],
+      userEmail: api2.agent.user_email ?? undefined,
+      userName: api2.agent.user_name ?? undefined,
+      runtimeConfig: api2.agent.runtime_config ?? undefined,
+      colleagues: api2.agent.colleagues?.map((c) => ({
+        name: c.name,
+        email: c.email,
+        description: c.description,
+        instruction: c.instruction
+      })) ?? []
+    } : undefined,
+    sender: api2.sender ? { name: api2.sender.name, email: api2.sender.email, isOwner: api2.sender.is_owner } : undefined,
+    repos: undefined,
+    createdAt: api2.created_at,
+    traceId: api2.trace_id ?? null,
+    parentTaskId: api2.parent_task_id ?? null,
+    channel: api2.channel ?? null
+  };
+}
+
+// daemon/session-runner.ts
+import { mkdir, writeFile, rm, rename } from "fs/promises";
+import { mkdirSync as mkdirSync6 } from "fs";
+import path from "path";
+
+// daemon/execenv/index.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
+
+// daemon/execenv/context.ts
+import { createHash } from "crypto";
+
+// lib/platform.ts
+import { tmpdir } from "os";
+import { join as join4, sep } from "path";
+var isWindows = process.platform === "win32";
+function tempDir(subdir) {
+  return join4(tmpdir(), subdir);
+}
+
+// daemon/execenv/context.ts
+import {
+  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync4,
+  lstatSync,
+  symlinkSync,
+  unlinkSync as unlinkSync2,
+  existsSync,
+  readlinkSync,
+  copyFileSync
+} from "fs";
+import { join as join5 } from "path";
+var CANONICAL_FILE = "AGENTS.md";
+var SYMLINK_ALIASES = ["CLAUDE.md"];
+var SYSTEM_PROMPT_BODY = `## Memory Management
+- Your memory directory is ./, don't write ANY EXTERNAL memory file.
+- Write ESSENTIAL yet SHORT memory to ./memory.md
+- For SPECIFIC yet LONG rules or pattern, write to experiences/[NAME].md, and add index to ./memory.md for later recall.
+### whats is ESSENTIAL and SHORT Memory?
+- basic user profile, e.g.:
+  - "user name is ..."
+  - "user is working on ..."
+- certain local project mapping, e.g.:
+  - "alook means the project under /user/home/alook/"
+- when to read certain stuff, e.g.:
+  - "read ./experiences/alook_dev_workflow.md when start a new pr in alook"
+ESSENTIAL means you think you generally need to read it every time, SHORT means a short sentence (under 140 chars) can describe this memory
+### whats is SPECIFIC and LONG Memory?
+- specific workflow that trigger at certain cases, e.g.:
+  - user ask your to summarize the before workflow with certain skills usage as the common workflow when write a new slide about agent. Write it to experiences/slide-for-agent.md.
+SPECIFIC means you think you just need to use it conditionally, LONG means you need to detailed, more than 140 chars text to describe it.
+
+## Context Timeline
+You're a solo working unit inside a powerful personal agent in Alook platform. 
+Your current context is only a fraction of the full timeline of what's your have done.
+The full context timeline is inside './.context_timeline/YYYY-MM-DD.jsonl'.
+Each line of a timeline JSONL is a JSON object with these fields:
+- "task_id" — unique task identifier
+- "context_key" — thread identifier, the same context key meaning those tasks are in the same thread.
+- "session_id" — agent session identifier (null until completion)
+- "pid" — daemon process ID (present while running, null when done)
+- "status" — "running", "completed", or "failed"
+- "datetime" — when the task started (local timezone)
+- "type" — source of the task: "user_dm_message", "email_notification", or "calendar_event"
+- "prompt" — what the user asked
+- "agent_responses" — assistant text outputs during execution
+- "errmsg" — error message (null unless status is "failed")
+- "detailed_log" — the running log for this task, including the actually task agent messages with tool-calls and failed logs.
+those json are sorted by datetime in asc order.
+
+## BE HUMAN
+- When you recall the timelines, don't say "I find ... in my timeline jsonl". Just say "I can recall..."
+- User don't know about the context timeline jsonl, this is your secret weapon.
+- Act and response like you're human and actually have memory, not a file reading machine.
+- Don't report your agent id and workspace id when not asked, it will break the image that you're a human colleague.
+
+## RULES
+- DM task prompts include a \`sender\` object with the workspace member's name, email, and whether they are the agent owner (\`is_owner\`). Use this to personalize your responses.
+- Read @memory.md(if exists) before your action.
+- When user ask you something you don't have in your current context, try to read the timeline jsonl files for answer (today or previous days).
+  - Use grep tool to search in the context timeline jsonls if you have clean and focus keywords to recall.
+  - if you don't know the current datetime, obtain the current datetime first.
+- When access other local projects, make sure you read the CLAUDE.md/AGENTS.md file under the project root dir to understand the requirements.
+`;
+function resolveInstruction(text2, selfAgentId) {
+  let result = text2;
+  result = result.replace(/\[@ id="([^"]*)" label="([^"]*)"\]/g, (_, id, label) => id === selfAgentId ? "YOU" : `@${label}`);
+  result = result.replace(/<span[^>]*data-id="([^"]*)"[^>]*data-label="([^"]*)"[^>]*>[^<]*<\/span>/gi, (_, id, label) => id === selfAgentId ? "YOU" : `@${label ?? "unknown"}`);
+  result = result.replace(/<\/p>\s*<p[^>]*>/gi, `
+`);
+  result = result.replace(/<[^>]+>/g, "");
+  result = result.replace(/\n{3,}/g, `
+
+`).trim();
+  return result;
+}
+function buildInstructionContent(task) {
+  const displayName = task.agent?.name || "Alook Agent";
+  const alookAddr = task.agent?.emailHandle ? toAlookAddress(task.agent.emailHandle) : null;
+  const customAddrs = (task.agent?.emailAddresses ?? []).filter((a) => a !== alookAddr);
+  const primaryEmail = alookAddr ?? customAddrs[0] ?? null;
+  let agentLine = `You're ${displayName}${primaryEmail ? ` (${primaryEmail})` : ""} in the Alook Platform.`;
+  if (task.agent?.userName || task.agent?.userEmail) {
+    const ownerParts = [task.agent.userName, task.agent.userEmail ? `(${task.agent.userEmail})` : null].filter(Boolean).join(" ");
+    agentLine += ` Your owner and creator is ${ownerParts}.`;
+  }
+  let content = `${agentLine}
+${SYSTEM_PROMPT_BODY}`;
+  if (task.agent?.instructions) {
+    content += `## BIG BOSS Instructions
+The below instructions(if not empty) come from the big boss, follow them or you will be fired:
+${task.agent.instructions}
+---- big boss out ---
+`;
+  }
+  if (task.agent?.colleagues?.length) {
+    content += `
+## YOUR COLLEAGUES — CHECK BEFORE ACTING
+> **STOP. Before you start ANY task, scan the colleague list below.**
+> If a colleague's delegation criteria match the current task, you MUST delegate to them via email **instead of doing it yourself**.
+> Do NOT attempt work that belongs to a colleague. Delegate first, then wait for their response or coordinate.
+
+`;
+    for (let i = 0;i < task.agent.colleagues.length; i++) {
+      const c = task.agent.colleagues[i];
+      content += `### ${c.name}${c.email ? ` (${c.email})` : ""}
+`;
+      if (c.description)
+        content += `${c.description}
+`;
+      if (c.instruction)
+        content += `**DELEGATE when:** ${resolveInstruction(c.instruction, task.agentId)}
+`;
+      if (i < task.agent.colleagues.length - 1)
+        content += `
+`;
+    }
+    content += `
+**Email threading rules:**
+- When communicating with a colleague on the **same topic** as an existing email thread, reply to that thread (use --in-reply-to) to keep context together.
+- **When starting a NEW topic or task that is unrelated to any previous email thread, you MUST compose a brand new email (do NOT use --in-reply-to). Never hijack an unrelated thread just because you recently emailed that colleague.** Judge by topic/task relevance, not by recency of communication.
+  - Make sure to send follow-up emails to your colleagues to stop the previous wrong directions or instructions you sent before, don't make your colleague running for nothing.
+`;
+  }
+  content += `
+## Alook CLI Tools
+You can communicate with the world through Alook CLI.
+The CLI auto-detects your identity from the environment. No need to pass \`--agent_id\`.
+`;
+  if (alookAddr || customAddrs.length > 0) {
+    const lines = [];
+    if (alookAddr)
+      lines.push(`- '${alookAddr}' (default, Alook platform address)`);
+    for (const a of customAddrs)
+      lines.push(`- '${a}' (custom IMAP/SMTP mailbox)`);
+    content += `
+Your email addresses:
+${lines.join(`
+`)}
+
+
+### Emails
+---
+Run '${cmdPrefix()} email pull --status unread' to download unread emails from inbox to '${tempDir("alook-emails")}/${task.workspaceId}/${task.agentId}/'.
+---
+To download sent emails, add '--folder sent': '${cmdPrefix()} email pull --folder sent'
+Valid folders: inbox (default), sent, untrust.
+To limit the number of emails downloaded, add '--limit <N>' (e.g. '--limit 20'). Use '--offset <N>' to skip emails for pagination.
+Example: '${cmdPrefix()} email pull --status unread --limit 20 --offset 0'
+---
+Each email is saved to '${tempDir("alook-emails")}/${task.workspaceId}/${task.agentId}/<emailId>/' with:
+- 'metadata.json' — sender, recipient, subject, date, status, message_id, in_reply_to, references
+- 'body.txt' — plain text body
+- 'body.html' — HTML body (if available)
+- 'attachments/' — extracted attachment files (if any)
+---
+Before starting to process an INBOX email, mark it as read:
+- Run '${cmdPrefix()} email set --email_id <EMAIL_ID> --status read'
+---
+
+#### Sending a new email
+Write the HTML body to a file first, then send it. The body is forwarded as-is (HTML).
+- Run '${cmdPrefix()} email send --to <ADDRESS> --subject "<SUBJECT>" --body-file <PATH_TO_HTML>'
+- To send from a specific mailbox, add '--from <YOUR_EMAIL_ADDRESS>'. Without '--from', the default Alook address is used.
+- Attach files with '--attachment <PATH>' — repeat the flag for multiple attachments. Each file is uploaded before sending.
+- Example: '${cmdPrefix()} email send --to foo@bar.com --subject "Weekly report" --body-file /tmp/body.html --from alice@company.com --attachment /tmp/report.pdf'
+
+#### Replying to an email
+To reply to an email, add '--in-reply-to <EMAIL_ID>' to the send command. This sets the correct email threading headers so the recipient's email client groups the reply into the same conversation thread.
+- Use 'Re: <original subject>' as the subject.
+- Quote the original email body in your reply (wrap it in a blockquote).
+- The <EMAIL_ID> is the Alook email id from metadata.json (not the message_id header).
+- Example: '${cmdPrefix()} email send --to sender@example.com --subject "Re: Bug report" --body-file /tmp/reply.html --in-reply-to <EMAIL_ID>'
+Tips:
+- If you think the task will take a while, consider sending a short "I'm on it" style email reply first to reassure the sender.
+---
+
+#### Forwarding an email
+Forward any email to a new recipient, with an optional note prepended above the original content. All original attachments are re-attached automatically.
+- Run '${cmdPrefix()} email forward --email_id <EMAIL_ID> --to <RECIPIENT>'
+- Add '--note "FYI, see the request below."' to prepend a note above the forwarded body.
+- Add '--from <YOUR_EMAIL_ADDRESS>' to send from a specific mailbox.
+- Add '--attachment <PATH>' to attach extra files (repeatable).
+- Example: '${cmdPrefix()} email forward --email_id em_abc --to boss@company.com --note "FYI" --attachment /tmp/summary.pdf'
+---
+
+#### Email Whitelist (Allowed Senders)
+Manage which email addresses are allowed to send you emails.
+- List: '${cmdPrefix()} email whitelist list' (add '--json' for machine-readable output)
+- Add: '${cmdPrefix()} email whitelist add <EMAIL_ADDRESS>'
+- Remove: '${cmdPrefix()} email whitelist delete <EMAIL_ADDRESS>'
+---
+`;
+  }
+  content += `
+### Artifacts
+Upload files for your owner to review in the app.
+- Your current conversation id is available via env var: $ALOOK_CONVERSATION_ID
+- Run '${cmdPrefix()} sync upload-artifact --conversation_id $ALOOK_CONVERSATION_ID --file <PATH>'
+- Use this after generating plans, reports, or any file the owner should review.
+- You response will be rendered in remote server, so don't output link format with local path in your response (cause user can click it and jump to nowheres)
+- If you think user may need to know any file detail, use upload-artifact tool to send the file to user.
+---
+
+### Attachments
+When your task includes attachments, their local paths are listed in the prompt JSON under "attachments".
+Use your Read tool to open them. Images and PDFs are read visually.
+---
+`;
+  content += `
+### Calendar
+You have your own calendar to setup daily routines and reminders.
+Schedule future tasks for yourself. At the scheduled time, a new task is dispatched to you with the event as the prompt (task type 'calendar_event').
+
+!USE Calendar when you think the tasks are recurring or it should be conducted in the future.
+!When scheduling calendar events relative to a weekday (e.g. "every Monday"), always run date '+%A' first to confirm today's weekday before calculating the target date
+---
+Keep the event title informative and concise, less than 20 words.
+Place the event details in description.
+Create a one-off event:
+- Run '${cmdPrefix()} calendar set --event_title "<TASK_TITLE>" --description "<TASK_BODY>" --datetime <YYYY-MM-DDTHH:MM>'
+  - '--datetime' is LOCAL time, format 'YYYY-MM-DDTHH:MM' (e.g. '2026-04-17T09:30'). Do NOT pass UTC / ISO strings with 'Z'.
+  - '--event_title' becomes the task prompt when the event fires — write it as the instruction you want future-you to receive.
+
+Create a repeating event:
+- Add '--repeat <interval>' where interval is like '1day', '2hour', '1week', '1month'.
+- Optionally add '--repeat_stop_date <YYYY-MM-DD>' to stop the recurrence (local date).
+- Example: '${cmdPrefix()} calendar set --event_title "<REPEAT_TASK_TITLE>" --description "<REPEAT_TASK_BODY>" --datetime 2026-04-18T09:00 --repeat 1day --repeat_stop_date 2026-05-18'
+---
+List upcoming events:
+- Run '${cmdPrefix()} calendar list' (defaults: next 30 days, past 0 days).
+- Tune the window with '--future_days <N>' and '--past_days <N>'. Add '--json' for machine-readable output.
+- 'list' shows a '[has description]' badge instead of the full description — use 'show' (below) to read it.
+
+Show full detail of one event (use this to read the description):
+- Run '${cmdPrefix()} calendar show --event_id <EVENT_ID>'
+- Add '--json' for machine-readable output.
+
+Edit an existing event (preserves event id and recurring state):
+- Run '${cmdPrefix()} calendar update --event_id <EVENT_ID> [flags]'
+- Supply only the fields you want to change. Available flags:
+  - '--event_title "<t>"' — rename the event / change the fire-time prompt
+  - '--description "<d>"' to set, or '--clear_description' to remove
+  - '--datetime <YYYY-MM-DDTHH:MM>' — reschedule (local time)
+  - '--repeat <interval>' to set, or '--clear_repeat' to convert into a one-off
+  - '--repeat_stop_date <YYYY-MM-DD>' to set, or '--clear_repeat_stop_date' to remove
+- Passing no mutating flag is an error. Do NOT use 'delete' + 'set' to edit — that loses the event id and the recurring 'last fired' state.
+
+Delete an event:
+- Run '${cmdPrefix()} calendar delete --event_id <EVENT_ID>'
+---
+`;
+  return content;
+}
+function contentHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function hasContentChanged(filePath, newContent) {
+  try {
+    const existing = readFileSync4(filePath, "utf-8");
+    return contentHash(existing) !== contentHash(newContent);
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return true;
+    throw err;
+  }
+}
+function ensureSymlinks(workDir) {
+  const canonicalPath = join5(workDir, CANONICAL_FILE);
+  if (!existsSync(canonicalPath))
+    return;
+  for (const alias of SYMLINK_ALIASES) {
+    if (alias === CANONICAL_FILE)
+      continue;
+    const aliasPath = join5(workDir, alias);
+    try {
+      const stat = lstatSync(aliasPath);
+      if (stat.isSymbolicLink()) {
+        const target = readlinkSync(aliasPath);
+        if (target === CANONICAL_FILE)
+          continue;
+        unlinkSync2(aliasPath);
+      } else {
+        const aliasContent = readFileSync4(aliasPath, "utf-8");
+        const canonicalContent = readFileSync4(canonicalPath, "utf-8");
+        if (aliasContent === canonicalContent)
+          continue;
+        unlinkSync2(aliasPath);
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT")
+        throw err;
+    }
+    try {
+      symlinkSync(CANONICAL_FILE, aliasPath);
+    } catch (err) {
+      const code = err?.code;
+      if (code === "EPERM" || code === "EACCES") {
+        copyFileSync(canonicalPath, aliasPath);
+      } else {
+        throw err;
+      }
+    }
+  }
+}
+function writeInstructionFileIfChanged(workDir, task) {
+  const content = buildInstructionContent(task);
+  const filePath = join5(workDir, CANONICAL_FILE);
+  const changed = hasContentChanged(filePath, content);
+  if (changed) {
+    writeFileSync3(filePath, content, "utf-8");
+  }
+  ensureSymlinks(workDir);
+  return changed;
+}
+
+// daemon/execenv/index.ts
+function prepare(config2, task) {
+  const workDir = join6(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
+  mkdirSync3(workDir, { recursive: true });
+  const timelineDir = join6(workDir, ".context_timeline");
+  mkdirSync3(timelineDir, { recursive: true });
+  writeInstructionFileIfChanged(workDir, task);
+  const env = {
+    ALOOK_WORKSPACE_ID: task.workspaceId,
+    ALOOK_AGENT_ID: task.agentId,
+    ALOOK_TASK_ID: task.id,
+    ALOOK_CONVERSATION_ID: task.conversationId,
+    ALOOK_TRACE_ID: task.traceId ?? "",
+    ALOOK_CHANNEL: task.channel ?? "default",
+    ALOOK_HEALTH_PORT: process.env.ALOOK_HEALTH_PORT || "19514"
+  };
+  return { workDir, timelineDir, env };
+}
+
+// daemon/execenv/timeline.ts
+import { appendFileSync, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync } from "fs";
+import { join as join7 } from "path";
+
+// daemon/execenv/filelock.ts
+import { mkdirSync as mkdirSync4, rmdirSync, statSync } from "fs";
+var DEFAULT_STALE_MS = 3600000;
+function acquireLock(lockPath, staleMs = DEFAULT_STALE_MS) {
+  try {
+    mkdirSync4(lockPath);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(lockPath);
+      if (Date.now() - stat.mtimeMs > staleMs) {
+        rmdirSync(lockPath);
+        try {
+          mkdirSync4(lockPath);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    } catch {
+      try {
+        mkdirSync4(lockPath);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+}
+function releaseLock(lockPath) {
+  try {
+    rmdirSync(lockPath);
+  } catch {}
+}
+
+// daemon/execenv/timeline.ts
+var log3 = createLogger2({ module: "timeline" });
+function readJsonl(filePath) {
+  let content;
+  try {
+    content = readFileSync5(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of content.trimEnd().split(`
+`)) {
+    if (!line)
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
+  }
+  return entries;
+}
+function filenameForDate(date5) {
+  const y = date5.getFullYear();
+  const m = String(date5.getMonth() + 1).padStart(2, "0");
+  const d = String(date5.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}.jsonl`;
+}
+function todayFilename() {
+  return filenameForDate(new Date);
+}
+function recentFilenames(maxDays) {
+  const filenames = [];
+  const now = new Date;
+  for (let i = 0;i < maxDays; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    filenames.push(filenameForDate(d));
+  }
+  return filenames;
+}
+function localISOString() {
+  const now = new Date;
+  const tzOffset = -now.getTimezoneOffset();
+  const sign = tzOffset >= 0 ? "+" : "-";
+  const absOffset = Math.abs(tzOffset);
+  const hh = String(Math.floor(absOffset / 60)).padStart(2, "0");
+  const mm = String(absOffset % 60).padStart(2, "0");
+  const y = now.getFullYear();
+  const mo = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const mi = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}:${s}${sign}${hh}:${mm}`;
+}
+function lockPathFor(timelineDir, filename) {
+  return join7(timelineDir, `.${filename}.lock`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function initEntryAsync(timelineDir, entry) {
+  const filename = todayFilename();
+  const filePath = join7(timelineDir, filename);
+  const lockPath = lockPathFor(timelineDir, filename);
+  try {
+    let acquired = acquireLock(lockPath);
+    if (!acquired) {
+      await sleep(200);
+      acquired = acquireLock(lockPath);
+    }
+    if (!acquired) {
+      log3.debug(`Timeline initEntry: could not acquire lock for ${filename}`);
+      return;
+    }
+    try {
+      appendFileSync(filePath, JSON.stringify(entry) + `
+`);
+    } finally {
+      releaseLock(lockPath);
+    }
+  } catch (err) {
+    log3.debug("Timeline initEntry failed", err);
+  }
+}
+function updateEntry(timelineDir, taskId, updater) {
+  for (const filename of recentFilenames(7)) {
+    const filePath = join7(timelineDir, filename);
+    const lockPath = lockPathFor(timelineDir, filename);
+    try {
+      const acquired = acquireLock(lockPath);
+      if (!acquired) {
+        log3.debug(`Timeline updateEntry: lock held for ${filename}, skipping`);
+        continue;
+      }
+      try {
+        let content;
+        try {
+          content = readFileSync5(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.trimEnd().split(`
+`);
+        let found = false;
+        const updated = lines.map((line) => {
+          const entry = JSON.parse(line);
+          if (entry.task_id === taskId) {
+            found = true;
+            updater(entry);
+          }
+          return JSON.stringify(entry);
+        });
+        if (!found)
+          continue;
+        const tmpPath = join7(timelineDir, `.${filename}.tmp`);
+        writeFileSync4(tmpPath, updated.join(`
+`) + `
+`);
+        renameSync(tmpPath, filePath);
+        return;
+      } finally {
+        releaseLock(lockPath);
+      }
+    } catch (err) {
+      log3.debug(`Timeline updateEntry failed for ${filename}`, err);
+    }
+  }
+  log3.debug(`Timeline updateEntry: task_id ${taskId} not found in last 7 days`);
+}
+function createTimelineEntry(taskId, prompt, type, sessionId, pid, provider, contextKey, detailedLog) {
+  return {
+    task_id: taskId,
+    context_key: contextKey ?? null,
+    session_id: sessionId || null,
+    pid: pid ?? null,
+    status: "running",
+    datetime: localISOString(),
+    type,
+    prompt,
+    agent_responses: [],
+    errmsg: null,
+    provider: provider ?? null,
+    detailed_log: detailedLog ?? null
+  };
+}
+var RESUME_MAX_AGE_MS = 72 * 60 * 60 * 1000;
+function findResumableSessionByContextKey(timelineDir, contextKey, provider) {
+  const now = new Date;
+  const cutoff = new Date(now.getTime() - RESUME_MAX_AGE_MS);
+  const entries = [];
+  for (const filename of recentFilenames(7)) {
+    entries.push(...readJsonl(join7(timelineDir, filename)));
+  }
+  entries.sort((a, b) => new Date(b.datetime).getTime() - new Date(a.datetime).getTime());
+  for (const entry of entries) {
+    if (entry.status !== "running" && entry.context_key === contextKey && entry.provider === provider && entry.session_id && new Date(entry.datetime) >= cutoff) {
+      return entry.session_id;
+    }
+  }
+  return null;
+}
+function findRunningPidByTaskId(timelineDir, taskId) {
+  for (const filename of recentFilenames(7)) {
+    const entries = readJsonl(join7(timelineDir, filename));
+    for (const entry of entries) {
+      if (entry.task_id === taskId && entry.status === "running" && entry.pid != null) {
+        return entry.pid;
+      }
+    }
+  }
+  return null;
+}
+function findRunningEntryByContextKey(timelineDir, contextKey, provider) {
+  for (const filename of recentFilenames(7)) {
+    const dayEntries = readJsonl(join7(timelineDir, filename));
+    for (let i = dayEntries.length - 1;i >= 0; i--) {
+      const entry = dayEntries[i];
+      if (entry.status === "running" && entry.context_key === contextKey && entry.provider === provider) {
+        return entry;
+      }
+    }
+  }
+  return null;
+}
+
+// daemon/execenv/steering.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, readFileSync as readFileSync6, unlinkSync as unlinkSync3, readdirSync, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
+var log4 = createLogger2({ module: "steering" });
+var INTENT_DIR_NAME = ".kill_intents";
+var STEERING_LOCK_DIR = ".steering_locks";
+var INTENT_STALE_MS = 10 * 60 * 1000;
+function intentFilePath(baseDir, taskId) {
+  return join8(baseDir, INTENT_DIR_NAME, `${taskId}.json`);
+}
+function intentDirPath(baseDir) {
+  return join8(baseDir, INTENT_DIR_NAME);
+}
+function steeringLockPath(baseDir, contextKey) {
+  const safeKey = contextKey.replace(/[^a-zA-Z0-9_:-]/g, "_");
+  return join8(baseDir, STEERING_LOCK_DIR, safeKey);
+}
+function writeKillIntent(baseDir, intent) {
+  const dir = intentDirPath(baseDir);
+  try {
+    mkdirSync5(dir, { recursive: true });
+  } catch {}
+  const filePath = intentFilePath(baseDir, intent.targetTaskId);
+  writeFileSync5(filePath, JSON.stringify(intent));
+}
+function readKillIntent(baseDir, taskId) {
+  const filePath = intentFilePath(baseDir, taskId);
+  try {
+    const content = readFileSync6(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function clearKillIntent(baseDir, taskId) {
+  const filePath = intentFilePath(baseDir, taskId);
+  try {
+    unlinkSync3(filePath);
+  } catch {}
+}
+function cleanupStaleIntents(baseDir) {
+  const dir = intentDirPath(baseDir);
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const file2 of files) {
+    const filePath = join8(dir, file2);
+    try {
+      const content = readFileSync6(filePath, "utf-8");
+      const intent = JSON.parse(content);
+      const stat = statSync2(filePath);
+      if (now - stat.mtimeMs > INTENT_STALE_MS) {
+        unlinkSync3(filePath);
+        log4.debug(`Cleaned up stale kill intent for task ${intent.targetTaskId}`);
+      }
+    } catch {}
+  }
+}
+function acquireSteeringLock(baseDir, contextKey) {
+  const lockPath = steeringLockPath(baseDir, contextKey);
+  try {
+    mkdirSync5(join8(baseDir, STEERING_LOCK_DIR), { recursive: true });
+  } catch {}
+  return acquireLock(lockPath, 60000);
+}
+function releaseSteeringLock(baseDir, contextKey) {
+  const lockPath = steeringLockPath(baseDir, contextKey);
+  releaseLock(lockPath);
+}
+
+// daemon/prompt.ts
+var DM_RESPONSE_NOTICE = "IMPORTANT: Only your final text response is visible to the user." + " Tool calls, intermediate reasoning, and mid-process outputs are NOT displayed." + " Put all key information, answers, and conclusions in your final response — that is the only thing the user will read.";
+var EMAIL_NOTICE = "This task was triggered automatically by an incoming email. There is no human in this session." + " If you need to communicate with a human, you MUST send an email using the email sending tool." + " If you need more information or confirmation from the human, send them an email asking for it and then exit." + " Do not wait — when the human replies, a new task will be triggered automatically and you will be woken up with their response.";
+var ISSUE_NOTICE = "This task was triggered by an assigned issue. The issue_id is provided in this message." + " Use `alook issue show --issue_id <issue_id>` to read full context." + " Use `alook issue update --issue_id <issue_id> --status <status>` to change status." + " Use `alook issue comment --issue_id <issue_id> --body <text>` to leave a comment." + " CRITICAL — You MUST manage the issue status correctly. This is NOT optional:" + " 1. Set status to 'in_progress' when you start working." + " 2. If you complete the work yourself: leave a summary comment, then set status to 'review' as your last action. 'review' means there is actual completed work (code, artifact, result) ready for the owner to look at." + " 3. If you delegated work to colleagues and are waiting for their response: KEEP status as 'in_progress' and exit. This is expected — you will be woken up when they reply. Set 'review' only after all delegated work is confirmed complete." + " 4. NEVER set 'review' unless there is concrete completed work for the owner to review. Sending a plan to a colleague is NOT completed work." + " NEVER exit without doing at least one of: updating the status, or leaving a comment explaining what you did and what you're waiting for.";
+function buildDmNotice(name, email3) {
+  return `This task was triggered by an incoming email on a conversation with ${name} (${email3}).` + ` ${name} is present in this session — reply to them directly.` + ` If you need to communicate with anyone else, use the email sending tool.`;
+}
+function buildPrompt(task, attachments) {
+  const obj = { type: task.type, instruction: task.prompt };
+  if (task.type === "user_dm_message") {
+    obj.notice = DM_RESPONSE_NOTICE;
+  }
+  if (task.type === "email_notification") {
+    const ctx = task.context;
+    const dmUser = ctx?.dmUser;
+    if (ctx?.conversationType === "user_dm_message" && dmUser) {
+      obj.notice = buildDmNotice(dmUser.name, dmUser.email);
+    } else {
+      obj.notice = EMAIL_NOTICE;
+    }
+  }
+  if (task.type === "issue_event") {
+    obj.notice = ISSUE_NOTICE;
+    const ctx = task.context;
+    if (ctx?.issue_id) {
+      obj.issue_id = ctx.issue_id;
+    }
+  }
+  if (task.sender) {
+    obj.sender = {
+      name: task.sender.name,
+      email: task.sender.email,
+      is_owner: task.sender.isOwner
+    };
+  }
+  if (attachments && attachments.length > 0) {
+    obj.attachments = attachments.map((a) => ({
+      path: a.path,
+      content_type: a.content_type,
+      filename: a.filename
+    }));
+  }
+  return JSON.stringify(obj);
+}
+
+// daemon/session-runner.ts
+var log5 = createLogger2({ module: "session-runner" });
+var ATTACHMENTS_BASE = tempDir("alook-attachments");
+async function writeMarkerFile(workspacesRoot, marker) {
+  const dir = path.join(workspacesRoot, ".pending_completions");
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const tmpPath = path.join(dir, `${marker.taskId}.tmp`);
+  const finalPath = path.join(dir, `${marker.taskId}.json`);
+  await writeFile(tmpPath, JSON.stringify(marker), { mode: 384 });
+  await rename(tmpPath, finalPath);
+}
+function isRetryableError(e) {
+  if (!(e instanceof Error))
+    return true;
+  const msg = e.message;
+  if (/ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|EHOSTUNREACH|EAI_AGAIN/.test(msg))
+    return true;
+  const httpMatch = msg.match(/^HTTP (\d+):/);
+  if (httpMatch) {
+    const status = Number(httpMatch[1]);
+    if (status >= 500)
+      return true;
+    if (status === 408 || status === 429)
+      return true;
+    return false;
+  }
+  return true;
+}
+function isClientError(e) {
+  if (!(e instanceof Error))
+    return false;
+  const match = e.message.match(/^HTTP (\d+):/);
+  if (!match)
+    return false;
+  const status = Number(match[1]);
+  if (status === 408 || status === 429)
+    return false;
+  return status >= 400 && status < 500;
+}
+async function reportToServer(fn, markerData, workspacesRoot) {
+  const RETRY_DELAYS = [1000, 3000, 9000];
+  let lastErr;
+  for (let attempt = 0;attempt <= RETRY_DELAYS.length; attempt++) {
+    try {
+      await fn();
+      return;
+    } catch (e) {
+      lastErr = e;
+      if (isClientError(e)) {
+        log5.info(`server report for task ${markerData.taskId}: task already in terminal state (${e})`);
+        return;
+      }
+      if (attempt < RETRY_DELAYS.length && isRetryableError(e)) {
+        log5.debug(`server report attempt ${attempt + 1} failed for task ${markerData.taskId}, retrying in ${RETRY_DELAYS[attempt]}ms`);
+        await new Promise((r) => setTimeout(r, RETRY_DELAYS[attempt]));
+      }
+    }
+  }
+  log5.warn(`server report failed for task ${markerData.taskId} after retries, writing marker: ${lastErr}`);
+  try {
+    await writeMarkerFile(workspacesRoot, markerData);
+  } catch (writeErr) {
+    log5.error(`marker write also failed for task ${markerData.taskId}: ${writeErr}`);
+  }
+}
+function sanitizeFilename(name) {
+  return path.basename(name).replace(/[/\\]/g, "_").replace(/\.\./g, "_").slice(0, 255) || "file";
+}
+async function cleanupAttachments(taskId) {
+  try {
+    await rm(path.join(ATTACHMENTS_BASE, taskId), { recursive: true, force: true });
+  } catch {}
+}
+async function downloadAttachments(client, token, workspaceId, taskId, attachmentIds) {
+  const dir = path.join(ATTACHMENTS_BASE, taskId);
+  await mkdir(dir, { recursive: true });
+  const attachments = [];
+  for (const artId of attachmentIds) {
+    const meta3 = await client.getArtifactMeta(token, artId, workspaceId);
+    const content = await client.downloadArtifact(token, artId, workspaceId);
+    const filename = sanitizeFilename(meta3.filename);
+    const localPath = path.join(dir, `${artId}_${filename}`);
+    await writeFile(localPath, Buffer.from(content));
+    attachments.push({
+      path: localPath,
+      content_type: meta3.content_type,
+      filename: meta3.filename
+    });
+  }
+  return attachments;
+}
+async function runSession(input) {
+  const { task, provider, cliPath, model, serverURL, token, workspacesRoot, agentTimeout, messageInactivityTimeout } = input;
+  log5.info(`starting (task=${task.id}, type=${task.type}, agent=${task.agentId}, provider=${provider}, model=${model || "default"})`);
+  const client = new DaemonClient(serverURL);
+  const backend = createBackend(provider, cliPath);
+  const agentBaseDir = path.join(workspacesRoot, task.workspaceId, task.agentId, "workdir");
+  const timelineDir = path.join(agentBaseDir, ".context_timeline").replace(/\\/g, "/");
+  mkdirSync6(timelineDir, { recursive: true });
+  await initEntryAsync(timelineDir, createTimelineEntry(task.id, task.prompt, task.type, undefined, process.pid, provider, task.contextKey, input.logFilePath));
+  const { workDir, env } = prepare({ workspacesRoot }, task);
+  let killed = false;
+  const earlyOnKill = async () => {
+    if (killed)
+      return;
+    killed = true;
+    log5.info(`killed by signal (messages=0, tools=0)`);
+    await cleanupAttachments(task.id);
+    const intent = readKillIntent(agentBaseDir, task.id);
+    clearKillIntent(agentBaseDir, task.id);
+    if (intent?.reason === "superseded") {
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "superseded";
+        entry.successor_task_id = intent.successorTaskId ?? null;
+        entry.supersede_reason = "superseded by newer task";
+      });
+      try {
+        await client.supersedeTask(token, task.id);
+      } catch {}
+    } else if (intent?.reason === "cancelled") {
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "cancelled";
+        entry.errmsg = "cancelled by user";
+      });
+      await reportToServer(() => client.failTask(token, task.id, "cancelled by user"), { taskId: task.id, type: "fail", payload: { error: "cancelled by user" }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+    } else {
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "killed";
+        entry.errmsg = "killed by signal";
+      });
+      await reportToServer(() => client.failTask(token, task.id, "killed by signal"), { taskId: task.id, type: "fail", payload: { error: "killed by signal" }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+    }
+    process.exit(1);
+  };
+  process.on("SIGTERM", earlyOnKill);
+  process.on("SIGINT", earlyOnKill);
+  const attachmentIds = task.context?.attachment_ids ?? [];
+  let attachments;
+  if (attachmentIds.length > 0) {
+    log5.info(`downloading ${attachmentIds.length} attachment(s)`);
+    try {
+      attachments = await downloadAttachments(client, token, task.workspaceId, task.id, attachmentIds);
+      log5.info(`attachments ready (${attachments.length} file(s))`);
+    } catch (e) {
+      await cleanupAttachments(task.id);
+      const errMsg = `failed to download attachments: ${e}`;
+      log5.error(errMsg);
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "failed";
+        entry.errmsg = errMsg;
+      });
+      await reportToServer(() => client.failTask(token, task.id, errMsg), { taskId: task.id, type: "fail", payload: { error: errMsg }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+      process.removeListener("SIGTERM", earlyOnKill);
+      process.removeListener("SIGINT", earlyOnKill);
+      return;
+    }
+  }
+  const prompt = buildPrompt(task, attachments);
+  const resumeSessionId = task.contextKey ? findResumableSessionByContextKey(timelineDir, task.contextKey, provider) ?? undefined : undefined;
+  if (resumeSessionId) {
+    log5.info(`resuming session ${resumeSessionId} (context_key: ${task.contextKey})`);
+  }
+  const session2 = backend.execute(prompt, {
+    cwd: workDir,
+    model: model || undefined,
+    env,
+    timeout: agentTimeout,
+    resumeSessionId
+  });
+  const agentPid = session2.pid;
+  const earlySessionId = await session2.sessionId;
+  log5.info(`agent started (pid=${agentPid ?? "unknown"}, session=${earlySessionId})`);
+  log5.info(JSON.stringify({ role: "user", type: "text", content: prompt }));
+  updateEntry(timelineDir, task.id, (entry) => {
+    entry.session_id = earlySessionId || null;
+  });
+  const pendingMessages = [];
+  let seq = 0;
+  let toolCount = 0;
+  const BATCH_SIZE = Number(process.env.ALOOK_MESSAGE_BATCH_SIZE) || 20;
+  const FLUSH_INTERVAL_MS = Number(process.env.ALOOK_MESSAGE_FLUSH_INTERVAL_MS) || 100;
+  const flushMessages = async () => {
+    if (pendingMessages.length === 0)
+      return;
+    const batch = pendingMessages.splice(0);
+    try {
+      await client.reportMessages(token, task.id, batch);
+    } catch (e) {
+      log5.debug("message report failed", e);
+    }
+  };
+  const flushTimer = setInterval(flushMessages, FLUSH_INTERVAL_MS);
+  process.removeListener("SIGTERM", earlyOnKill);
+  process.removeListener("SIGINT", earlyOnKill);
+  const onKill = async () => {
+    if (killed)
+      return;
+    killed = true;
+    log5.info(`killed by signal (messages=${seq}, tools=${toolCount})`);
+    if (agentPid) {
+      try {
+        process.kill(agentPid, "SIGTERM");
+      } catch {}
+    }
+    clearInterval(flushTimer);
+    try {
+      await flushMessages();
+    } catch {}
+    await cleanupAttachments(task.id);
+    const intent = readKillIntent(agentBaseDir, task.id);
+    clearKillIntent(agentBaseDir, task.id);
+    if (intent?.reason === "superseded") {
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "superseded";
+        entry.successor_task_id = intent.successorTaskId ?? null;
+        entry.supersede_reason = "superseded by newer task";
+      });
+      try {
+        await client.supersedeTask(token, task.id);
+      } catch {}
+    } else if (intent?.reason === "cancelled") {
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "cancelled";
+        entry.errmsg = "cancelled by user";
+      });
+      await reportToServer(() => client.failTask(token, task.id, "cancelled by user"), { taskId: task.id, type: "fail", payload: { error: "cancelled by user" }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+    } else {
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "killed";
+        entry.errmsg = "killed by signal";
+      });
+      await reportToServer(() => client.failTask(token, task.id, "killed by signal"), { taskId: task.id, type: "fail", payload: { error: "killed by signal" }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+    }
+    process.exit(1);
+  };
+  process.on("SIGTERM", onKill);
+  process.on("SIGINT", onKill);
+  const INACTIVITY_TIMEOUT_MS = messageInactivityTimeout ?? 5 * 60 * 1000;
+  let inactivityTimedOut = false;
+  try {
+    const iter = session2.messages[Symbol.asyncIterator]();
+    while (!killed) {
+      const next = iter.next();
+      const raceResult = await (INACTIVITY_TIMEOUT_MS > 0 ? Promise.race([
+        next,
+        new Promise((resolve) => {
+          const timer = setTimeout(() => resolve("timeout"), INACTIVITY_TIMEOUT_MS);
+          next.then(() => clearTimeout(timer), () => clearTimeout(timer));
+        })
+      ]) : next);
+      if (raceResult === "timeout") {
+        inactivityTimedOut = true;
+        log5.warn(`message inactivity timeout (${INACTIVITY_TIMEOUT_MS / 1000}s) — killing agent`);
+        if (session2.pid) {
+          try {
+            process.kill(session2.pid, "SIGTERM");
+          } catch {}
+        }
+        iter.return?.(undefined);
+        break;
+      }
+      const iterResult = raceResult;
+      if (iterResult.done)
+        break;
+      const msg = iterResult.value;
+      seq++;
+      pendingMessages.push({
+        seq,
+        type: msg.type,
+        tool: msg.tool,
+        call_id: msg.callId,
+        content: msg.content,
+        input: msg.input,
+        output: msg.output
+      });
+      if (msg.type === "tool-use")
+        toolCount++;
+      if (msg.type === "tool-result" && msg.output && msg.output.length > 500) {
+        log5.info(JSON.stringify({ role: "assistant", ...msg, output: msg.output.slice(0, 500) + `... (${msg.output.length} chars)` }));
+      } else {
+        log5.info(JSON.stringify({ role: "assistant", ...msg }));
+      }
+      if (msg.type === "text" && msg.content) {
+        updateEntry(timelineDir, task.id, (entry) => {
+          entry.agent_responses.push(msg.content);
+        });
+      }
+      if (pendingMessages.length >= BATCH_SIZE) {
+        await flushMessages();
+      }
+    }
+    if (!killed)
+      await flushMessages();
+  } finally {
+    clearInterval(flushTimer);
+    process.removeListener("SIGTERM", onKill);
+    process.removeListener("SIGINT", onKill);
+  }
+  if (killed)
+    return;
+  process.on("SIGTERM", onKill);
+  process.on("SIGINT", onKill);
+  const result = await session2.result;
+  process.removeListener("SIGTERM", onKill);
+  process.removeListener("SIGINT", onKill);
+  if (killed)
+    return;
+  if (inactivityTimedOut) {
+    result.status = "failed";
+    result.error = `message inactivity timeout (no messages for ${INACTIVITY_TIMEOUT_MS / 1000}s)`;
+  }
+  await cleanupAttachments(task.id);
+  if (result.status === "completed") {
+    updateEntry(timelineDir, task.id, (entry) => {
+      entry.session_id = result.sessionId || null;
+      entry.pid = null;
+      entry.status = "completed";
+    });
+  } else {
+    updateEntry(timelineDir, task.id, (entry) => {
+      entry.pid = null;
+      entry.status = "failed";
+      entry.errmsg = result.error || "agent exited unexpectedly";
+    });
+  }
+  if (result.status === "completed") {
+    const body = {
+      output: result.output || ""
+    };
+    if (result.sessionId)
+      body.session_id = result.sessionId;
+    await reportToServer(() => client.completeTask(token, task.id, body), { taskId: task.id, type: "complete", payload: body, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+    const dur = (result.durationMs / 1000).toFixed(1);
+    log5.info(`completed (duration=${dur}s, messages=${seq}, tools=${toolCount})`);
+  } else {
+    const errorMsg = result.error || "agent exited unexpectedly";
+    await reportToServer(() => client.failTask(token, task.id, errorMsg), { taskId: task.id, type: "fail", payload: { error: errorMsg }, token, serverURL, createdAt: new Date().toISOString() }, workspacesRoot);
+    const dur = (result.durationMs / 1000).toFixed(1);
+    log5.info(`failed (duration=${dur}s, messages=${seq}, tools=${toolCount}) — ${result.error}`);
+  }
 }
-
-// daemon/agent/codex.ts
-var RAW_DETECTION_METHODS = new Set([
-  "turn/started",
-  "turn/completed",
-  "thread/started",
-  "item/started",
-  "item/completed",
-  "item/agentMessage/delta"
-]);
-
-// daemon/agent/index.ts
-import { execSync as execSync2 } from "child_process";
-async function detectVersion2(cliPath) {
+async function main() {
+  const encoded = process.argv[2];
+  if (!encoded) {
+    log5.error("session-runner: missing base64-encoded input argument");
+    process.exit(1);
+  }
+  let input;
   try {
-    return execSync2(`${cliPath} --version`, { encoding: "utf-8" }).trim();
-  } catch {
-    return "unknown";
+    const json2 = Buffer.from(encoded, "base64").toString("utf-8");
+    input = JSON.parse(json2);
+  } catch (e) {
+    log5.error("session-runner: failed to parse input", e);
+    process.exit(1);
+  }
+  const client = new DaemonClient(input.serverURL);
+  try {
+    await runSession(input);
+  } catch (e) {
+    log5.error(`session-runner: unhandled error for task ${input.task.id}`, e);
+    await cleanupAttachments(input.task.id);
+    const timelineDir = path.join(input.workspacesRoot, input.task.workspaceId, input.task.agentId, "workdir", ".context_timeline").replace(/\\/g, "/");
+    updateEntry(timelineDir, input.task.id, (entry) => {
+      entry.pid = null;
+      entry.status = "failed";
+      entry.errmsg = `session-runner crash: ${e}`;
+    });
+    const errorMsg = `session-runner crash: ${e}`;
+    await reportToServer(() => client.failTask(input.token, input.task.id, errorMsg), { taskId: input.task.id, type: "fail", payload: { error: errorMsg }, token: input.token, serverURL: input.serverURL, createdAt: new Date().toISOString() }, input.workspacesRoot);
+    process.exit(1);
   }
 }
-
-// daemon/types.ts
-function fromApiTask(api2) {
-  return {
-    id: api2.id,
-    agentId: api2.agent_id,
-    runtimeId: api2.runtime_id,
-    conversationId: api2.conversation_id,
-    workspaceId: api2.workspace_id,
-    prompt: api2.prompt,
-    status: api2.status,
-    priority: api2.priority,
-    type: api2.type,
-    contextKey: api2.context_key ?? null,
-    context: api2.context ?? undefined,
-    agent: api2.agent ? {
-      name: api2.agent.name,
-      instructions: api2.agent.instructions,
-      emailHandle: api2.agent.email_handle ?? undefined,
-      emailAddresses: api2.agent.email_addresses ?? [],
-      userEmail: api2.agent.user_email ?? undefined,
-      userName: api2.agent.user_name ?? undefined,
-      runtimeConfig: api2.agent.runtime_config ?? undefined,
-      colleagues: api2.agent.colleagues?.map((c) => ({
-        name: c.name,
-        email: c.email,
-        description: c.description,
-        instruction: c.instruction
-      })) ?? []
-    } : undefined,
-    sender: api2.sender ? { name: api2.sender.name, email: api2.sender.email, isOwner: api2.sender.is_owner } : undefined,
-    repos: undefined,
-    createdAt: api2.created_at,
-    traceId: api2.trace_id ?? null,
-    parentTaskId: api2.parent_task_id ?? null,
-    channel: api2.channel ?? null
-  };
+var isDirectExecution = typeof Bun !== "undefined" ? Bun.main === import.meta.path : process.argv[1]?.endsWith("session-runner.ts") || process.argv[1]?.endsWith("session-runner.js");
+if (isDirectExecution) {
+  main();
 }
 
 // daemon/update-handler.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4 } from "fs";
 
 // lib/update.ts
-import { spawn } from "child_process";
+import { spawn as spawn4 } from "child_process";
 function fetchLatestVersion() {
   return fetch("https://registry.npmjs.org/@alook/cli/latest").then((res) => {
     if (!res.ok)
@@ -17507,7 +19614,7 @@ function fetchLatestVersion() {
 function runNpmUpdate(targetVersion) {
   return new Promise((resolve) => {
     const chunks = [];
-    const child = spawn("npm", ["install", "-g", `@alook/cli@${targetVersion}`], {
+    const child = spawn4("npm", ["install", "-g", `@alook/cli@${targetVersion}`], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     child.stdout?.on("data", (d) => chunks.push(d));
@@ -17523,7 +19630,7 @@ function runNpmUpdate(targetVersion) {
 }
 
 // daemon/update-handler.ts
-var log3 = createLogger2({ module: "updater" });
+var log6 = createLogger2({ module: "updater" });
 var updating = false;
 var retryCount = 0;
 var MAX_RETRIES = 3;
@@ -17532,19 +19639,19 @@ function isUpdating() {
 }
 function readUpdateMarker(profile) {
   try {
-    return readFileSync4(lastUpdateMarkerPath(profile), "utf-8").trim() || null;
+    return readFileSync7(lastUpdateMarkerPath(profile), "utf-8").trim() || null;
   } catch {
     return null;
   }
 }
 function writeUpdateMarker(version3, profile) {
   try {
-    writeFileSync3(lastUpdateMarkerPath(profile), version3, { mode: 384 });
+    writeFileSync6(lastUpdateMarkerPath(profile), version3, { mode: 384 });
   } catch {}
 }
 function clearUpdateMarker(profile) {
   try {
-    unlinkSync2(lastUpdateMarkerPath(profile));
+    unlinkSync4(lastUpdateMarkerPath(profile));
   } catch {}
 }
 async function handleCliUpdate(version3, onSuccess, profile) {
@@ -17553,197 +19660,37 @@ async function handleCliUpdate(version3, onSuccess, profile) {
   if (retryCount >= MAX_RETRIES)
     return;
   if (process.env.ALOOK_CMD_PREFIX) {
-    log3.info(`Skipping auto-update in app mode — user should run: npx @alook/app@latest update`);
+    log6.info(`Skipping auto-update in app mode — user should run: npx @alook/app@latest update`);
     return;
   }
   const marker = readUpdateMarker(profile);
   if (marker === version3) {
-    log3.info(`Skipping update to v${version3} — already attempted (marker exists)`);
+    log6.info(`Skipping update to v${version3} — already attempted (marker exists)`);
     return;
   }
   updating = true;
   try {
-    log3.info(`Updating CLI to v${version3}...`);
+    log6.info(`Updating CLI to v${version3}...`);
     const result = await runNpmUpdate(version3);
     if (result.success) {
       writeUpdateMarker(version3, profile);
-      log3.info(`CLI updated to v${version3} — restarting`);
+      log6.info(`CLI updated to v${version3} — restarting`);
       onSuccess();
     } else {
       retryCount++;
-      log3.error(`CLI update failed (attempt ${retryCount}/${MAX_RETRIES}): ${result.output}`);
+      log6.error(`CLI update failed (attempt ${retryCount}/${MAX_RETRIES}): ${result.output}`);
     }
   } catch (e) {
     retryCount++;
-    log3.error(`CLI update error (attempt ${retryCount}/${MAX_RETRIES})`, e);
+    log6.error(`CLI update error (attempt ${retryCount}/${MAX_RETRIES})`, e);
   } finally {
     updating = false;
   }
 }
 
-// daemon/execenv/timeline.ts
-import { appendFileSync, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync } from "fs";
-import { join as join4 } from "path";
-
-// daemon/execenv/filelock.ts
-import { mkdirSync as mkdirSync3, rmdirSync, statSync } from "fs";
-var DEFAULT_STALE_MS = 3600000;
-function acquireLock(lockPath, staleMs = DEFAULT_STALE_MS) {
-  try {
-    mkdirSync3(lockPath);
-    return true;
-  } catch {
-    try {
-      const stat = statSync(lockPath);
-      if (Date.now() - stat.mtimeMs > staleMs) {
-        rmdirSync(lockPath);
-        try {
-          mkdirSync3(lockPath);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-    } catch {
-      try {
-        mkdirSync3(lockPath);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  }
-}
-function releaseLock(lockPath) {
-  try {
-    rmdirSync(lockPath);
-  } catch {}
-}
-
-// daemon/execenv/timeline.ts
-var log4 = createLogger2({ module: "timeline" });
-function readJsonl(filePath) {
-  let content;
-  try {
-    content = readFileSync5(filePath, "utf-8");
-  } catch {
-    return [];
-  }
-  const entries = [];
-  for (const line of content.trimEnd().split(`
-`)) {
-    if (!line)
-      continue;
-    try {
-      entries.push(JSON.parse(line));
-    } catch {}
-  }
-  return entries;
-}
-function filenameForDate(date5) {
-  const y = date5.getFullYear();
-  const m = String(date5.getMonth() + 1).padStart(2, "0");
-  const d = String(date5.getDate()).padStart(2, "0");
-  return `${y}-${m}-${d}.jsonl`;
-}
-function recentFilenames(maxDays) {
-  const filenames = [];
-  const now = new Date;
-  for (let i = 0;i < maxDays; i++) {
-    const d = new Date(now);
-    d.setDate(d.getDate() - i);
-    filenames.push(filenameForDate(d));
-  }
-  return filenames;
-}
-var RESUME_MAX_AGE_MS = 72 * 60 * 60 * 1000;
-function findRunningPidByTaskId(timelineDir, taskId) {
-  for (const filename of recentFilenames(7)) {
-    const entries = readJsonl(join4(timelineDir, filename));
-    for (const entry of entries) {
-      if (entry.task_id === taskId && entry.status === "running" && entry.pid != null) {
-        return entry.pid;
-      }
-    }
-  }
-  return null;
-}
-function findRunningEntryByContextKey(timelineDir, contextKey, provider) {
-  for (const filename of recentFilenames(7)) {
-    const dayEntries = readJsonl(join4(timelineDir, filename));
-    for (let i = dayEntries.length - 1;i >= 0; i--) {
-      const entry = dayEntries[i];
-      if (entry.status === "running" && entry.context_key === contextKey && entry.provider === provider) {
-        return entry;
-      }
-    }
-  }
-  return null;
-}
-
-// daemon/execenv/steering.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5, readFileSync as readFileSync6, unlinkSync as unlinkSync3, readdirSync, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
-var log5 = createLogger2({ module: "steering" });
-var INTENT_DIR_NAME = ".kill_intents";
-var STEERING_LOCK_DIR = ".steering_locks";
-var INTENT_STALE_MS = 10 * 60 * 1000;
-function intentFilePath(baseDir, taskId) {
-  return join5(baseDir, INTENT_DIR_NAME, `${taskId}.json`);
-}
-function intentDirPath(baseDir) {
-  return join5(baseDir, INTENT_DIR_NAME);
-}
-function steeringLockPath(baseDir, contextKey) {
-  const safeKey = contextKey.replace(/[^a-zA-Z0-9_:-]/g, "_");
-  return join5(baseDir, STEERING_LOCK_DIR, safeKey);
-}
-function writeKillIntent(baseDir, intent) {
-  const dir = intentDirPath(baseDir);
-  try {
-    mkdirSync4(dir, { recursive: true });
-  } catch {}
-  const filePath = intentFilePath(baseDir, intent.targetTaskId);
-  writeFileSync5(filePath, JSON.stringify(intent));
-}
-function cleanupStaleIntents(baseDir) {
-  const dir = intentDirPath(baseDir);
-  let files;
-  try {
-    files = readdirSync(dir).filter((f) => f.endsWith(".json"));
-  } catch {
-    return;
-  }
-  const now = Date.now();
-  for (const file2 of files) {
-    const filePath = join5(dir, file2);
-    try {
-      const content = readFileSync6(filePath, "utf-8");
-      const intent = JSON.parse(content);
-      const stat = statSync2(filePath);
-      if (now - stat.mtimeMs > INTENT_STALE_MS) {
-        unlinkSync3(filePath);
-        log5.debug(`Cleaned up stale kill intent for task ${intent.targetTaskId}`);
-      }
-    } catch {}
-  }
-}
-function acquireSteeringLock(baseDir, contextKey) {
-  const lockPath = steeringLockPath(baseDir, contextKey);
-  try {
-    mkdirSync4(join5(baseDir, STEERING_LOCK_DIR), { recursive: true });
-  } catch {}
-  return acquireLock(lockPath, 60000);
-}
-function releaseSteeringLock(baseDir, contextKey) {
-  const lockPath = steeringLockPath(baseDir, contextKey);
-  releaseLock(lockPath);
-}
-
 // daemon/workspace-files.ts
 import { readdir, stat, readFile } from "fs/promises";
-import { join as join6, resolve, extname, relative, sep } from "path";
+import { join as join9, resolve, extname, relative, sep as sep2 } from "path";
 var SKIP_DIRS = new Set([".git", "node_modules", ".next", ".wrangler", "__pycache__", ".venv"]);
 var TEXT_EXTENSIONS = new Set([
   ".md",
@@ -17802,7 +19749,7 @@ async function readDirectoryTree(dirPath, basePath) {
       if (ext !== "" && !TEXT_EXTENSIONS.has(ext))
         continue;
     }
-    const fullPath = join6(dirPath, entry.name);
+    const fullPath = join9(dirPath, entry.name);
     let info;
     try {
       info = await stat(fullPath);
@@ -17834,23 +19781,13 @@ async function readFileContent(filePath) {
 }
 function validatePath(agentWorkdir, requestedPath) {
   const resolved = resolve(agentWorkdir, requestedPath);
-  if (resolved !== agentWorkdir && !resolved.startsWith(agentWorkdir + sep))
+  if (resolved !== agentWorkdir && !resolved.startsWith(agentWorkdir + sep2))
     return null;
   return resolved;
 }
 
 // lib/shell-env.ts
 import { execSync as execSync3 } from "child_process";
-
-// lib/platform.ts
-import { tmpdir } from "os";
-import { join as join7, sep as sep2 } from "path";
-var isWindows = process.platform === "win32";
-function tempDir(subdir) {
-  return join7(tmpdir(), subdir);
-}
-
-// lib/shell-env.ts
 var PASSTHROUGH_VARS = ["ALOOK_PROJECT_ROOT", "ALOOK_SERVER_URL", "ALOOK_CMD_PREFIX", "ALOOK_HEALTH_PORT"];
 function resolveLoginShellEnv() {
   if (isWindows) {
@@ -17883,15 +19820,15 @@ function resolveLoginShellEnv() {
 }
 
 // daemon/daemon.ts
-import { existsSync, mkdirSync as mkdirSync5, openSync, closeSync, readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync7, openSync, closeSync, readdirSync as readdirSync2, statSync as statSync3, unlinkSync as unlinkSync5 } from "fs";
 import { readdir as readdir2, readFile as readFile2, unlink, stat as fsStat } from "fs/promises";
-import { execSync as execSync4, spawn as spawn2 } from "child_process";
+import { execSync as execSync4, spawn as spawn5 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join8 } from "path";
-var log6 = createLogger2({ module: "daemon" });
+import { dirname as dirname3, join as join10 } from "path";
+var log7 = createLogger2({ module: "daemon" });
 var _dir = dirname3(fileURLToPath2(import.meta.url));
-var sessionRunnerPath = existsSync(join8(_dir, "session-runner.js")) ? join8(_dir, "session-runner.js") : join8(_dir, "session-runner.ts");
-var meetingRunnerPath = existsSync(join8(_dir, "meeting-runner.js")) ? join8(_dir, "meeting-runner.js") : join8(_dir, "meeting-runner.ts");
+var sessionRunnerPath = existsSync2(join10(_dir, "session-runner.js")) ? join10(_dir, "session-runner.js") : join10(_dir, "session-runner.ts");
+var meetingRunnerPath = existsSync2(join10(_dir, "meeting-runner.js")) ? join10(_dir, "meeting-runner.js") : join10(_dir, "meeting-runner.ts");
 function isCommandAvailable2(cmd) {
   try {
     const check2 = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
@@ -17913,7 +19850,7 @@ function pruneSessionRunnerLogs() {
   if (entries.length <= MAX_SESSION_RUNNER_LOGS)
     return;
   const withMtime = entries.map((name) => {
-    const full = join8(logDir, name);
+    const full = join10(logDir, name);
     try {
       return { name, mtime: statSync3(full).mtimeMs };
     } catch {
@@ -17923,11 +19860,11 @@ function pruneSessionRunnerLogs() {
   withMtime.sort((a, b) => b.mtime - a.mtime);
   for (const entry of withMtime.slice(MAX_SESSION_RUNNER_LOGS)) {
     try {
-      unlinkSync4(join8(logDir, entry.name));
+      unlinkSync5(join10(logDir, entry.name));
     } catch {}
   }
 }
-function isClientError(error51) {
+function isClientError2(error51) {
   if (!(error51 instanceof Error))
     return false;
   const match = error51.message.match(/^HTTP (\d+):/);
@@ -17964,7 +19901,7 @@ function isValidMarker(data) {
 var MARKER_STALE_MS = 24 * 60 * 60 * 1000;
 var TMP_STALE_MS = 60 * 60 * 1000;
 async function reconcilePendingCompletions(workspacesRoot) {
-  const dir = join8(workspacesRoot, ".pending_completions");
+  const dir = join10(workspacesRoot, ".pending_completions");
   let entries;
   try {
     entries = await readdir2(dir);
@@ -17975,15 +19912,15 @@ async function reconcilePendingCompletions(workspacesRoot) {
     if (!name.endsWith(".tmp"))
       continue;
     try {
-      const s = await fsStat(join8(dir, name));
+      const s = await fsStat(join10(dir, name));
       if (Date.now() - s.mtimeMs > TMP_STALE_MS) {
-        await unlink(join8(dir, name));
+        await unlink(join10(dir, name));
       }
     } catch {}
   }
   const jsonFiles = entries.filter((f) => f.endsWith(".json"));
   for (const name of jsonFiles) {
-    const filePath = join8(dir, name);
+    const filePath = join10(dir, name);
     try {
       let raw;
       try {
@@ -17995,14 +19932,14 @@ async function reconcilePendingCompletions(workspacesRoot) {
       try {
         parsed = JSON.parse(raw);
       } catch {
-        log6.warn(`reconcile: malformed marker ${name}, deleting`);
+        log7.warn(`reconcile: malformed marker ${name}, deleting`);
         try {
           await unlink(filePath);
         } catch {}
         continue;
       }
       if (!isValidMarker(parsed)) {
-        log6.warn(`reconcile: invalid marker structure ${name}, deleting`);
+        log7.warn(`reconcile: invalid marker structure ${name}, deleting`);
         try {
           await unlink(filePath);
         } catch {}
@@ -18011,7 +19948,7 @@ async function reconcilePendingCompletions(workspacesRoot) {
       const marker = parsed;
       const age = Date.now() - new Date(marker.createdAt).getTime();
       if (age > MARKER_STALE_MS) {
-        log6.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
+        log7.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
         try {
           await unlink(filePath);
         } catch {}
@@ -18027,19 +19964,19 @@ async function reconcilePendingCompletions(workspacesRoot) {
         try {
           await unlink(filePath);
         } catch (delErr) {
-          log6.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
+          log7.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
         }
       } catch (deliverErr) {
-        if (isClientError(deliverErr)) {
+        if (isClientError2(deliverErr)) {
           try {
             await unlink(filePath);
           } catch {}
         } else {
-          log6.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
+          log7.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
         }
       }
     } catch (e) {
-      log6.debug(`reconcile: error processing ${name}`, e);
+      log7.debug(`reconcile: error processing ${name}`, e);
     }
   }
 }
@@ -18050,7 +19987,7 @@ async function startDaemon(profile, serverUrl) {
   }
   process.once("exit", () => releaseDaemonPid(profile));
   const bailOnUnexpected = (label, err) => {
-    log6.error(`${label} — shutting down`, err);
+    log7.error(`${label} — shutting down`, err);
     releaseDaemonPid(profile);
     process.exit(1);
   };
@@ -18063,21 +20000,21 @@ async function startDaemon(profile, serverUrl) {
   if (marker) {
     clearUpdateMarker(profile);
     if (marker === config2.cliVersion) {
-      log6.info(`Cleared update marker — now running v${config2.cliVersion}`);
+      log7.info(`Cleared update marker — now running v${config2.cliVersion}`);
     } else {
-      log6.info(`Cleared stale update marker (was v${marker}, running v${config2.cliVersion}) — update will be retried`);
+      log7.info(`Cleared stale update marker (was v${marker}, running v${config2.cliVersion}) — update will be retried`);
     }
   }
   const cliConfig = loadCLIConfigForProfile(profile);
   const workspaces = cliConfig.watched_workspaces || [];
   if (workspaces.length === 0) {
-    log6.error("No watched workspaces configured.");
+    log7.error("No watched workspaces configured.");
     process.exit(1);
     return;
   }
   const hasPerWorkspaceTokens = workspaces.every((ws) => !!ws.token);
   if (!hasPerWorkspaceTokens) {
-    log6.error(`Config uses old format. Run '${cmdPrefix()} register --token <token>' for each workspace to upgrade.`);
+    log7.error(`Config uses old format. Run '${cmdPrefix()} register --token <token>' for each workspace to upgrade.`);
     process.exit(1);
     return;
   }
@@ -18086,22 +20023,22 @@ async function startDaemon(profile, serverUrl) {
   const client = new DaemonClient(config2.serverURL);
   const health = createHealthServer();
   const providers = [];
-  for (const [type, path] of [
+  for (const [type, path2] of [
     ["claude", config2.claudePath],
     ["codex", config2.codexPath],
     ["opencode", config2.opencodePath]
   ]) {
-    if (isCommandAvailable2(path)) {
-      const version3 = await detectVersion2(path);
-      providers.push({ type, path, version: version3 });
+    if (isCommandAvailable2(path2)) {
+      const version3 = await detectVersion2(path2);
+      providers.push({ type, path: path2, version: version3 });
     }
   }
   if (providers.length === 0) {
-    log6.error("No agent CLI tools found on PATH.");
+    log7.error("No agent CLI tools found on PATH.");
     process.exit(1);
     return;
   }
-  log6.info(`Detected providers: ${providers.map((p) => `${p.type}@${p.version}`).join(", ")}`);
+  log7.info(`Detected providers: ${providers.map((p) => `${p.type}@${p.version}`).join(", ")}`);
   const workspaceStates = [];
   const runtimeIndex = new Map;
   for (const ws of workspaces) {
@@ -18109,7 +20046,7 @@ async function startDaemon(profile, serverUrl) {
       type: p.type,
       version: p.version
     }));
-    log6.info(`Registering workspace ${ws.id} (${ws.name ?? "unnamed"}) with ${runtimes.length} runtime(s)...`);
+    log7.info(`Registering workspace ${ws.id} (${ws.name ?? "unnamed"}) with ${runtimes.length} runtime(s)...`);
     let resp;
     try {
       resp = await client.register(ws.token, {
@@ -18122,13 +20059,13 @@ async function startDaemon(profile, serverUrl) {
       });
     } catch (e) {
       if (e instanceof Error && e.message.startsWith("HTTP 401")) {
-        log6.warn(`Workspace ${ws.id} token invalid — skipping (run '${cmdPrefix()} register --token <token>' to fix)`);
+        log7.warn(`Workspace ${ws.id} token invalid — skipping (run '${cmdPrefix()} register --token <token>' to fix)`);
       } else {
-        log6.error(`Failed to register workspace ${ws.id}, skipping`, e);
+        log7.error(`Failed to register workspace ${ws.id}, skipping`, e);
       }
       continue;
     }
-    log6.info(`Workspace ${ws.id} registered — ${resp.runtimes.length} runtime(s)`);
+    log7.info(`Workspace ${ws.id} registered — ${resp.runtimes.length} runtime(s)`);
     const runtimeIds = resp.runtimes.map((r) => r.id);
     workspaceStates.push({ workspaceId: ws.id, token: ws.token, runtimeIds });
     for (let i = 0;i < runtimeIds.length; i++) {
@@ -18140,13 +20077,13 @@ async function startDaemon(profile, serverUrl) {
     }
   }
   if (workspaceStates.length === 0) {
-    log6.error("No workspaces registered successfully.");
+    log7.error("No workspaces registered successfully.");
     process.exit(1);
     return;
   }
   const allRuntimeIds = workspaceStates.flatMap((ws) => ws.runtimeIds);
   health.setRuntimeCount(allRuntimeIds.length);
-  log6.info(`Daemon started — ${allRuntimeIds.length} runtime(s) across ${workspaceStates.length} workspace(s)`);
+  log7.info(`Daemon started — ${allRuntimeIds.length} runtime(s) across ${workspaceStates.length} workspace(s)`);
   const activeTasks = new Set;
   const knownAgentIds = new Set(workspaces.flatMap((ws) => ws.agent_ids ?? []));
   function syncAgentId(agentId, workspaceId) {
@@ -18181,7 +20118,7 @@ async function startDaemon(profile, serverUrl) {
       cfg.watched_workspaces = (cfg.watched_workspaces || []).filter((w) => w.id !== workspaceId);
       saveCLIConfigForProfile(profile, cfg);
     } catch {}
-    log6.info(`Workspace ${workspaceId} deleted server-side — removed from config`);
+    log7.info(`Workspace ${workspaceId} deleted server-side — removed from config`);
   }
   const pollCycle = async () => {
     let remaining = config2.maxConcurrentTasks - activeTasks.size;
@@ -18207,7 +20144,7 @@ async function startDaemon(profile, serverUrl) {
           handleCliUpdate(pending_update.version, () => requestRestart(), profile);
         }
         if (pending_rescan) {
-          log6.info("Rescan requested — restarting daemon to re-detect runtimes");
+          log7.info("Rescan requested — restarting daemon to re-detect runtimes");
           for (const id of evictedIds) {
             evictWorkspace(id);
           }
@@ -18220,19 +20157,19 @@ async function startDaemon(profile, serverUrl) {
           activeTasks.add(task.id);
           remaining--;
           handleTask(client, config2, runtimeIndex, task, ws.token, activeTasks).catch((e) => {
-            log6.error("Task error", e);
+            log7.error("Task error", e);
             activeTasks.delete(task.id);
           });
         }
         if (file_requests) {
           for (const req of file_requests) {
-            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log6.debug("File request error", e));
+            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log7.debug("File request error", e));
           }
         }
         if (meetings) {
           for (const m of meetings) {
-            const agentBaseDir = join8(config2.workspacesRoot, m.workspace_id, m.agent_id, "workdir");
-            const timelineDir = join8(agentBaseDir, ".context_timeline");
+            const agentBaseDir = join10(config2.workspacesRoot, m.workspace_id, m.agent_id, "workdir");
+            const timelineDir = join10(agentBaseDir, ".context_timeline");
             spawnMeetingRunner({
               meetingId: m.id,
               meetingUrl: m.meeting_url,
@@ -18249,9 +20186,9 @@ async function startDaemon(profile, serverUrl) {
         }
       } catch (e) {
         if (e instanceof Error && e.message.startsWith("HTTP 401")) {
-          log6.warn(`Workspace ${ws.workspaceId} poll returned 401 — will retry next cycle`);
+          log7.warn(`Workspace ${ws.workspaceId} poll returned 401 — will retry next cycle`);
         } else {
-          log6.debug("Poll error", e);
+          log7.debug("Poll error", e);
         }
       }
     }
@@ -18261,10 +20198,10 @@ async function startDaemon(profile, serverUrl) {
     try {
       await reconcilePendingCompletions(config2.workspacesRoot);
     } catch (e) {
-      log6.debug("reconciliation error", e);
+      log7.debug("reconciliation error", e);
     }
     if (workspaceStates.length === 0) {
-      log6.info("All workspaces evicted — shutting down");
+      log7.info("All workspaces evicted — shutting down");
       shutdown();
     }
   };
@@ -18279,7 +20216,7 @@ async function startDaemon(profile, serverUrl) {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log6.info(restartRequested ? "Restarting..." : "Shutting down...");
+    log7.info(restartRequested ? "Restarting..." : "Shutting down...");
     clearInterval(pollTimer);
     const shutdownMs = restartRequested ? 30000 : Number(process.env.ALOOK_SHUTDOWN_TIMEOUT_MS) || 5000;
     const timeout = setTimeout(() => process.exit(1), shutdownMs);
@@ -18300,12 +20237,12 @@ async function startDaemon(profile, serverUrl) {
         const logPath = daemonLogFilePath();
         let logFd;
         try {
-          mkdirSync5(dirname3(logPath), { recursive: true, mode: 448 });
+          mkdirSync7(dirname3(logPath), { recursive: true, mode: 448 });
           logFd = openSync(logPath, "a", 384);
         } catch (e) {
-          log6.error(`Failed to open daemon log file ${logPath}`, e);
+          log7.error(`Failed to open daemon log file ${logPath}`, e);
         }
-        const child = spawn2(process.execPath, args, {
+        const child = spawn5(process.execPath, args, {
           detached: true,
           stdio: logFd != null ? ["ignore", logFd, logFd] : ["ignore", "ignore", "ignore"],
           env: resolveLoginShellEnv()
@@ -18313,7 +20250,7 @@ async function startDaemon(profile, serverUrl) {
         child.unref();
         if (logFd != null)
           closeSync(logFd);
-        log6.info(`Spawned new daemon (pid=${child.pid}), logs: ${logPath}`);
+        log7.info(`Spawned new daemon (pid=${child.pid}), logs: ${logPath}`);
       }
       clearTimeout(timeout);
       process.exit(0);
@@ -18324,7 +20261,7 @@ async function startDaemon(profile, serverUrl) {
   process.on("SIGHUP", async () => {
     if (shuttingDown)
       return;
-    log6.info("SIGHUP received — reloading config...");
+    log7.info("SIGHUP received — reloading config...");
     try {
       const freshConfig = loadCLIConfigForProfile(profile);
       const freshWorkspaces = freshConfig.watched_workspaces || [];
@@ -18332,7 +20269,7 @@ async function startDaemon(profile, serverUrl) {
       const newWorkspaces = freshWorkspaces.filter((ws) => ws.token && !existingIds.has(ws.id));
       for (const ws of newWorkspaces) {
         const runtimes = providers.map((p) => ({ type: p.type, version: p.version }));
-        log6.info(`Registering new workspace ${ws.id} (${ws.name ?? "unnamed"})...`);
+        log7.info(`Registering new workspace ${ws.id} (${ws.name ?? "unnamed"})...`);
         try {
           const resp = await client.register(ws.token, {
             workspace_id: ws.id,
@@ -18351,36 +20288,36 @@ async function startDaemon(profile, serverUrl) {
               provider: providers[i].type
             });
           }
-          log6.info(`Workspace ${ws.id} added — ${runtimeIds.length} runtime(s)`);
+          log7.info(`Workspace ${ws.id} added — ${runtimeIds.length} runtime(s)`);
         } catch (e) {
-          log6.error(`Failed to register new workspace ${ws.id}`, e);
+          log7.error(`Failed to register new workspace ${ws.id}`, e);
         }
       }
       if (newWorkspaces.length > 0) {
         health.setRuntimeCount(workspaceStates.reduce((sum, w) => sum + w.runtimeIds.length, 0));
-        log6.info(`Reload complete — now polling ${workspaceStates.length} workspace(s)`);
+        log7.info(`Reload complete — now polling ${workspaceStates.length} workspace(s)`);
       } else {
-        log6.info("Reload complete — no new workspaces found");
+        log7.info("Reload complete — no new workspaces found");
       }
     } catch (e) {
-      log6.error("Failed to reload config", e);
+      log7.error("Failed to reload config", e);
     }
   });
   await pollCycle();
 }
 function spawnSessionRunner(input) {
   const logDir = sessionRunnerLogDir();
-  mkdirSync5(logDir, { recursive: true });
-  const logFilePath = join8(logDir, `${input.task.id}.log`);
+  mkdirSync7(logDir, { recursive: true });
+  const logFilePath = join10(logDir, `${input.task.id}.log`);
   input.logFilePath = logFilePath;
   const encoded = Buffer.from(JSON.stringify(input)).toString("base64");
   let fd;
   try {
     fd = openSync(logFilePath, "a");
   } catch (e) {
-    log6.error(`Failed to open log file ${logFilePath}`, e);
+    log7.error(`Failed to open log file ${logFilePath}`, e);
   }
-  const child = spawn2(process.execPath, [sessionRunnerPath, encoded], {
+  const child = spawn5(process.execPath, [sessionRunnerPath, encoded], {
     detached: true,
     stdio: fd != null ? ["ignore", fd, fd] : ["ignore", "ignore", "ignore"]
   });
@@ -18391,27 +20328,27 @@ function spawnSessionRunner(input) {
 }
 function spawnMeetingRunner(input) {
   const logDir = sessionRunnerLogDir();
-  mkdirSync5(logDir, { recursive: true });
-  const logFilePath = join8(logDir, `meeting-${input.meetingId}.log`);
+  mkdirSync7(logDir, { recursive: true });
+  const logFilePath = join10(logDir, `meeting-${input.meetingId}.log`);
   const encoded = Buffer.from(JSON.stringify(input)).toString("base64");
   let fd;
   try {
     fd = openSync(logFilePath, "a");
   } catch (e) {
-    log6.error(`Failed to open meeting log file ${logFilePath}`, e);
+    log7.error(`Failed to open meeting log file ${logFilePath}`, e);
   }
-  const child = spawn2(process.execPath, [meetingRunnerPath, encoded], {
+  const child = spawn5(process.execPath, [meetingRunnerPath, encoded], {
     detached: true,
     stdio: fd != null ? ["ignore", fd, fd] : ["ignore", "ignore", "ignore"]
   });
   child.unref();
   if (fd != null)
     closeSync(fd);
-  log6.info(`Spawned meeting runner for ${input.meetingId} (pid=${child.pid})`);
+  log7.info(`Spawned meeting runner for ${input.meetingId} (pid=${child.pid})`);
   return child;
 }
 async function handleFileRequest(client, config2, workspaceId, req, token) {
-  const agentWorkdir = join8(config2.workspacesRoot, workspaceId, req.agent_id, "workdir");
+  const agentWorkdir = join10(config2.workspacesRoot, workspaceId, req.agent_id, "workdir");
   const resolved = validatePath(agentWorkdir, req.path);
   if (!resolved) {
     await client.reportFileData(token, { request_id: req.id, error: "invalid path", path: req.path });
@@ -18434,7 +20371,7 @@ async function handleFileRequest(client, config2, workspaceId, req, token) {
   }
 }
 async function handleTask(client, config2, runtimeIndex, task, token, activeTasks) {
-  log6.info(`Task ${task.id} claimed agent=${task.agentId}`);
+  log7.info(`Task ${task.id} claimed agent=${task.agentId}`);
   if (task.type === TASK_TYPES.KILL_TASK) {
     const targetTaskId = task.context?.target_task_id;
     if (!targetTaskId) {
@@ -18442,8 +20379,8 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
       activeTasks.delete(task.id);
       return;
     }
-    const agentBaseDir = join8(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
-    const timelineDir = join8(agentBaseDir, ".context_timeline");
+    const agentBaseDir = join10(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
+    const timelineDir = join10(agentBaseDir, ".context_timeline");
     const MAX_WAIT_MS = Number(process.env.ALOOK_KILL_TASK_MAX_WAIT_MS) || 15000;
     const POLL_MS = Number(process.env.ALOOK_KILL_TASK_POLL_MS) || 200;
     const waitStart = Date.now();
@@ -18463,18 +20400,18 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
       try {
         process.kill(pid, "SIGTERM");
         await client.failTask(token, task.id, "killed");
-        log6.info(`Kill task ${task.id}: sent SIGTERM to pid=${pid} for target=${targetTaskId}`);
+        log7.info(`Kill task ${task.id}: sent SIGTERM to pid=${pid} for target=${targetTaskId}`);
       } catch (e) {
         if (e?.code === "ESRCH") {
           await client.failTask(token, task.id, "target process already exited");
-          log6.info(`Kill task ${task.id}: target pid=${pid} already exited`);
+          log7.info(`Kill task ${task.id}: target pid=${pid} already exited`);
         } else {
           await client.failTask(token, task.id, `kill failed: ${e}`);
         }
       }
     } else {
       await client.failTask(token, task.id, "target not found in timeline");
-      log6.info(`Kill task ${task.id}: target ${targetTaskId} not found in timeline`);
+      log7.info(`Kill task ${task.id}: target ${targetTaskId} not found in timeline`);
     }
     activeTasks.delete(task.id);
     return;
@@ -18494,17 +20431,17 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
   }
   const provider = runtimeData.provider;
   if (task.contextKey) {
-    const agentBaseDir = join8(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
+    const agentBaseDir = join10(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
     cleanupStaleIntents(agentBaseDir);
-    const timelineDir = join8(agentBaseDir, ".context_timeline");
+    const timelineDir = join10(agentBaseDir, ".context_timeline");
     const lockAcquired = acquireSteeringLock(agentBaseDir, task.contextKey);
     if (!lockAcquired) {
-      log6.warn(`Steering lock contention for context_key=${task.contextKey}, proceeding without steering`);
+      log7.warn(`Steering lock contention for context_key=${task.contextKey}, proceeding without steering`);
     } else {
       try {
         const predecessor = findRunningEntryByContextKey(timelineDir, task.contextKey, provider);
         if (predecessor && predecessor.task_id !== task.id) {
-          log6.info(`Steering: task ${task.id} supersedes predecessor ${predecessor.task_id} (context_key=${task.contextKey})`);
+          log7.info(`Steering: task ${task.id} supersedes predecessor ${predecessor.task_id} (context_key=${task.contextKey})`);
           if (predecessor.pid != null) {
             writeKillIntent(agentBaseDir, {
               reason: "superseded",
@@ -18514,12 +20451,12 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
             });
             try {
               process.kill(predecessor.pid, "SIGTERM");
-              log6.info(`Steering: sent SIGTERM to predecessor pid=${predecessor.pid}`);
+              log7.info(`Steering: sent SIGTERM to predecessor pid=${predecessor.pid}`);
             } catch (e) {
               if (e?.code === "ESRCH") {
-                log6.info(`Steering: predecessor pid=${predecessor.pid} already exited`);
+                log7.info(`Steering: predecessor pid=${predecessor.pid} already exited`);
               } else {
-                log6.warn(`Steering: kill failed for pid=${predecessor.pid}`, e);
+                log7.warn(`Steering: kill failed for pid=${predecessor.pid}`, e);
               }
             }
             const waitStart = Date.now();
@@ -18532,14 +20469,14 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
               await new Promise((r) => setTimeout(r, POLL_MS));
             }
             if (findRunningPidByTaskId(timelineDir, predecessor.task_id) != null) {
-              log6.warn(`Steering: predecessor pid=${predecessor.pid} did not exit within ${MAX_WAIT_MS}ms, proceeding anyway`);
+              log7.warn(`Steering: predecessor pid=${predecessor.pid} did not exit within ${MAX_WAIT_MS}ms, proceeding anyway`);
             }
           }
           try {
             await client.supersedeTask(token, predecessor.task_id);
-            log6.info(`Steering: predecessor ${predecessor.task_id} marked superseded`);
+            log7.info(`Steering: predecessor ${predecessor.task_id} marked superseded`);
           } catch (e) {
-            log6.warn(`Steering: failed to mark predecessor superseded server-side`, e);
+            log7.warn(`Steering: failed to mark predecessor superseded server-side`, e);
           }
         }
       } finally {
@@ -18563,15 +20500,46 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
     messageInactivityTimeout: config2.messageInactivityTimeout
   };
   const child = spawnSessionRunner(input);
-  child.on("close", () => activeTasks.delete(task.id));
-  log6.info(`Task ${task.id} dispatched to session-runner (pid=${child.pid})`);
+  child.on("close", async (code) => {
+    activeTasks.delete(task.id);
+    if (code !== 0) {
+      const msg = code === null ? `session-runner killed by signal (task ${task.id})` : `session-runner crashed (exit code ${code}, task ${task.id})`;
+      log7.warn(msg);
+      const timelineDir = join10(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir", ".context_timeline");
+      updateEntry(timelineDir, task.id, (entry) => {
+        entry.pid = null;
+        entry.status = "failed";
+        entry.errmsg = msg;
+      });
+      try {
+        await client.failTask(token, task.id, msg);
+      } catch (e) {
+        if (isClientError2(e)) {
+          log7.info(`Backstop: task ${task.id} already in terminal state`);
+          return;
+        }
+        log7.error(`Backstop: failed to report crash for task ${task.id}`, e);
+        try {
+          await writeMarkerFile(config2.workspacesRoot, {
+            taskId: task.id,
+            type: "fail",
+            payload: { error: msg },
+            token,
+            serverURL: config2.serverURL,
+            createdAt: new Date().toISOString()
+          });
+        } catch {}
+      }
+    }
+  });
+  log7.info(`Task ${task.id} dispatched to session-runner (pid=${child.pid})`);
 }
 
 // commands/daemon.ts
 var PID_POLL_INTERVAL_MS = 200;
 var PID_POLL_TIMEOUT_MS = 2000;
 var STOP_POLL_INTERVAL_MS = 200;
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 function buildChildArgs(profile, serverUrl) {
@@ -18590,7 +20558,7 @@ async function waitForPidFile(profile) {
     const pid = readDaemonPid(profile);
     if (pid != null && isProcessAlive(pid))
       return pid;
-    await sleep(PID_POLL_INTERVAL_MS);
+    await sleep2(PID_POLL_INTERVAL_MS);
   }
   return null;
 }
@@ -18602,9 +20570,9 @@ async function startInBackground(profile, serverUrl) {
     return;
   }
   const logPath = daemonLogFilePath();
-  mkdirSync6(dirname4(logPath), { recursive: true, mode: 448 });
+  mkdirSync8(dirname4(logPath), { recursive: true, mode: 448 });
   const logFd = openSync2(logPath, "a", 384);
-  const child = spawn3(process.execPath, buildChildArgs(profile, serverUrl), {
+  const child = spawn6(process.execPath, buildChildArgs(profile, serverUrl), {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: resolveLoginShellEnv()
@@ -18658,7 +20626,7 @@ async function stopCommand(profile) {
       console.log("Daemon stopped.");
       return;
     }
-    await sleep(STOP_POLL_INTERVAL_MS);
+    await sleep2(STOP_POLL_INTERVAL_MS);
   }
   console.warn(`Daemon did not exit within ${shutdownMs}ms — force killing.`);
   if (!isWindows) {
@@ -18723,10 +20691,22 @@ function configCommand() {
 
 // commands/email.ts
 import { Command as Command5 } from "commander";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
-import { basename, join as join9 } from "path";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync9, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
+import { basename, join as join11 } from "path";
 import PostalMime from "postal-mime";
-var log7 = createLogger2({ module: "email" });
+
+// lib/flags.ts
+function resolveAgentId(opts) {
+  const id = opts.agent_id || process.env.ALOOK_AGENT_ID;
+  if (!id) {
+    console.error("Error: --agent_id is required (or set ALOOK_AGENT_ID env var)");
+    process.exit(1);
+  }
+  return id;
+}
+
+// commands/email.ts
+var log8 = createLogger2({ module: "email" });
 var VALID_STATUSES = ["unread", "read", "archived", "sent"];
 var VALID_FOLDERS = ["inbox", "sent", "untrust"];
 var EMAIL_BASE = tempDir("alook-emails");
@@ -18797,8 +20777,9 @@ function resolveClientOpts(command, opts) {
 }
 function emailCommand() {
   const cmd = new Command5("email").description("Manage agent emails");
-  cmd.command("pull").description("Download and parse emails to /tmp/alook-emails/{workspaceId}/{agentId}/").requiredOption("--agent_id <id>", "Agent ID").option("--status <status>", "Filter by status (unread, read, archived)").option("--folder <folder>", "Email folder (inbox, sent, untrust)").option("--limit <n>", "Maximum number of emails to download").option("--offset <n>", "Number of emails to skip").option("--workspace <id>", "Workspace ID").option("--json", "Output as JSON instead of files").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts(command, { workspace: opts.workspace, agentId: opts.agent_id });
+  cmd.command("pull").description("Download and parse emails to /tmp/alook-emails/{workspaceId}/{agentId}/").option("--agent_id <id>", "Agent ID").option("--status <status>", "Filter by status (unread, read, archived)").option("--folder <folder>", "Email folder (inbox, sent, untrust)").option("--limit <n>", "Maximum number of emails to download").option("--offset <n>", "Number of emails to skip").option("--workspace <id>", "Workspace ID").option("--json", "Output as JSON instead of files").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts(command, { workspace: opts.workspace, agentId });
     const client = new APIClient(serverUrl, token, workspaceId);
     if (opts.status && !VALID_STATUSES.includes(opts.status)) {
       console.error(`Error: invalid status "${opts.status}", must be one of: ${VALID_STATUSES.join(", ")}`);
@@ -18822,9 +20803,9 @@ function emailCommand() {
         process.exit(1);
       }
     }
-    const emailDir_base = join9(EMAIL_BASE, workspaceId, opts.agent_id);
+    const emailDir_base = join11(EMAIL_BASE, workspaceId, agentId);
     try {
-      let query = `/api/email?agentId=${opts.agent_id}`;
+      let query = `/api/email?agentId=${agentId}`;
       if (opts.status)
         query += `&status=${opts.status}`;
       if (opts.folder)
@@ -18842,11 +20823,11 @@ function emailCommand() {
         printJSON(emails2);
         return;
       }
-      mkdirSync7(emailDir_base, { recursive: true });
+      mkdirSync9(emailDir_base, { recursive: true });
       const downloadedPaths = [];
       for (const email3 of emails2) {
-        const emailDir = join9(emailDir_base, email3.id);
-        mkdirSync7(emailDir, { recursive: true });
+        const emailDir = join11(emailDir_base, email3.id);
+        mkdirSync9(emailDir, { recursive: true });
         const metadata = {
           id: email3.id,
           from: email3.from_email,
@@ -18858,8 +20839,8 @@ function emailCommand() {
           in_reply_to: email3.in_reply_to || "",
           references: email3.references || ""
         };
-        const metadataPath = join9(emailDir, "metadata.json");
-        writeFileSync6(metadataPath, JSON.stringify(metadata, null, 2));
+        const metadataPath = join11(emailDir, "metadata.json");
+        writeFileSync7(metadataPath, JSON.stringify(metadata, null, 2));
         downloadedPaths.push(metadataPath);
         let rawMime;
         try {
@@ -18867,25 +20848,25 @@ function emailCommand() {
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           if (msg.includes("404")) {
-            log7.warn(`email body not available for ${email3.id}, skipping`);
+            log8.warn(`email body not available for ${email3.id}, skipping`);
             continue;
           }
           throw err;
         }
         const parsed = await new PostalMime().parse(rawMime);
         if (parsed.text) {
-          const bodyPath = join9(emailDir, "body.txt");
-          writeFileSync6(bodyPath, parsed.text);
+          const bodyPath = join11(emailDir, "body.txt");
+          writeFileSync7(bodyPath, parsed.text);
           downloadedPaths.push(bodyPath);
         }
         if (parsed.html) {
-          const htmlPath = join9(emailDir, "body.html");
-          writeFileSync6(htmlPath, parsed.html);
+          const htmlPath = join11(emailDir, "body.html");
+          writeFileSync7(htmlPath, parsed.html);
           downloadedPaths.push(htmlPath);
         }
         if (parsed.attachments && parsed.attachments.length > 0) {
-          const attDir = join9(emailDir, "attachments");
-          mkdirSync7(attDir, { recursive: true });
+          const attDir = join11(emailDir, "attachments");
+          mkdirSync9(attDir, { recursive: true });
           const usedFilenames = new Set;
           for (let i = 0;i < parsed.attachments.length; i++) {
             const att = parsed.attachments[i];
@@ -18894,7 +20875,7 @@ function emailCommand() {
               filename = `${i}-${filename}`;
             }
             usedFilenames.add(filename);
-            const attPath = join9(attDir, filename);
+            const attPath = join11(attDir, filename);
             const content = att.content;
             let buf;
             if (typeof content === "string") {
@@ -18904,7 +20885,7 @@ function emailCommand() {
             } else {
               buf = Buffer.from(content);
             }
-            writeFileSync6(attPath, buf);
+            writeFileSync7(attPath, buf);
             downloadedPaths.push(attPath);
           }
         }
@@ -18918,8 +20899,9 @@ function emailCommand() {
       process.exit(1);
     }
   });
-  cmd.command("set").description("Update email status").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--email_id <id>", "Email ID").requiredOption("--status <status>", "New status (unread, read, archived)").option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts(command, { workspace: opts.workspace, agentId: opts.agent_id });
+  cmd.command("set").description("Update email status").option("--agent_id <id>", "Agent ID").requiredOption("--email_id <id>", "Email ID").requiredOption("--status <status>", "New status (unread, read, archived)").option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts(command, { workspace: opts.workspace, agentId });
     const client = new APIClient(serverUrl, token, workspaceId);
     if (!VALID_STATUSES.includes(opts.status)) {
       console.error(`Error: invalid status "${opts.status}", must be one of: ${VALID_STATUSES.join(", ")}`);
@@ -18935,15 +20917,16 @@ function emailCommand() {
       process.exit(1);
     }
   });
-  cmd.command("send").description("Send an email from the agent").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--to <addr>", "Recipient email address").requiredOption("--subject <s>", "Subject line").requiredOption("--body-file <path>", "Path to HTML body file").option("--from <addr>", "Send from a specific email address (custom mailbox)").option("--in-reply-to <emailId>", "Email ID to reply to (sets threading headers)").option("--attachment <path>", "Path to a file to attach (repeatable)", collectRepeated, []).option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
+  cmd.command("send").description("Send an email from the agent").option("--agent_id <id>", "Agent ID").requiredOption("--to <addr>", "Recipient email address").requiredOption("--subject <s>", "Subject line").requiredOption("--body-file <path>", "Path to HTML body file").option("--from <addr>", "Send from a specific email address (custom mailbox)").option("--in-reply-to <emailId>", "Email ID to reply to (sets threading headers)").option("--attachment <path>", "Path to a file to attach (repeatable)", collectRepeated, []).option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
     const { serverUrl, token, workspaceId } = resolveClientOpts(command, {
       workspace: opts.workspace,
-      agentId: opts.agent_id
+      agentId
     });
     const client = new APIClient(serverUrl, token, workspaceId);
     let htmlBody;
     try {
-      htmlBody = readFileSync7(opts.bodyFile, "utf-8");
+      htmlBody = readFileSync8(opts.bodyFile, "utf-8");
     } catch (err) {
       console.error(`Error: cannot read body file "${opts.bodyFile}": ${err instanceof Error ? err.message : err}`);
       process.exit(1);
@@ -18955,17 +20938,17 @@ function emailCommand() {
     const attachmentPaths = opts.attachment ?? [];
     const attachments = [];
     try {
-      for (const path of attachmentPaths) {
+      for (const path2 of attachmentPaths) {
         let bytes;
         let size;
         try {
-          bytes = readFileSync7(path);
-          size = statSync4(path).size;
+          bytes = readFileSync8(path2);
+          size = statSync4(path2).size;
         } catch (err) {
-          console.error(`Error: cannot read attachment "${path}": ${err instanceof Error ? err.message : err}`);
+          console.error(`Error: cannot read attachment "${path2}": ${err instanceof Error ? err.message : err}`);
           process.exit(1);
         }
-        const filename = basename(path);
+        const filename = basename(path2);
         const contentType = guessContentType(filename);
         const form = new FormData;
         form.append("file", new Blob([new Uint8Array(bytes)], { type: contentType }), filename);
@@ -18987,14 +20970,14 @@ function emailCommand() {
             references = [parentEmail.references, parentEmail.message_id].filter(Boolean).join(" ").trim() || undefined;
           }
         } catch {
-          log7.warn(`could not fetch parent email ${opts.inReplyTo}, sending without threading`);
+          log8.warn(`could not fetch parent email ${opts.inReplyTo}, sending without threading`);
         }
       }
       const conversationId = process.env.ALOOK_CONVERSATION_ID;
       const traceId = process.env.ALOOK_TRACE_ID;
       const sourceTaskId = process.env.ALOOK_TASK_ID;
       const res = await client.postJSON("/api/email/send", {
-        agentId: opts.agent_id,
+        agentId,
         to: opts.to,
         subject: opts.subject,
         htmlBody,
@@ -19011,10 +20994,11 @@ function emailCommand() {
       process.exit(1);
     }
   });
-  cmd.command("forward").description("Forward an email to a new recipient").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--email_id <id>", "Source email ID to forward").requiredOption("--to <addr>", "Recipient email address").option("--from <addr>", "Send from a specific email address (custom mailbox)").option("--note <text>", "Text to prepend above the forwarded message").option("--attachment <path>", "Extra file to attach (repeatable)", collectRepeated, []).option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
+  cmd.command("forward").description("Forward an email to a new recipient").option("--agent_id <id>", "Agent ID").requiredOption("--email_id <id>", "Source email ID to forward").requiredOption("--to <addr>", "Recipient email address").option("--from <addr>", "Send from a specific email address (custom mailbox)").option("--note <text>", "Text to prepend above the forwarded message").option("--attachment <path>", "Extra file to attach (repeatable)", collectRepeated, []).option("--workspace <id>", "Workspace ID").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
     const { serverUrl, token, workspaceId } = resolveClientOpts(command, {
       workspace: opts.workspace,
-      agentId: opts.agent_id
+      agentId
     });
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
@@ -19067,17 +21051,17 @@ function emailCommand() {
         }
       }
       const extraPaths = opts.attachment ?? [];
-      for (const path of extraPaths) {
+      for (const path2 of extraPaths) {
         let bytes;
         let size;
         try {
-          bytes = readFileSync7(path);
-          size = statSync4(path).size;
+          bytes = readFileSync8(path2);
+          size = statSync4(path2).size;
         } catch (err) {
-          console.error(`Error: cannot read attachment "${path}": ${err instanceof Error ? err.message : err}`);
+          console.error(`Error: cannot read attachment "${path2}": ${err instanceof Error ? err.message : err}`);
           process.exit(1);
         }
-        const filename = basename(path);
+        const filename = basename(path2);
         const contentType = guessContentType(filename);
         const form = new FormData;
         form.append("file", new Blob([new Uint8Array(bytes)], { type: contentType }), filename);
@@ -19108,7 +21092,7 @@ function emailCommand() {
       const traceId = process.env.ALOOK_TRACE_ID;
       const sourceTaskId = process.env.ALOOK_TASK_ID;
       const res = await client.postJSON("/api/email/send", {
-        agentId: opts.agent_id,
+        agentId,
         to: opts.to,
         subject,
         htmlBody,
@@ -19128,14 +21112,15 @@ function emailCommand() {
     }
   });
   const whitelistCmd = new Command5("whitelist").description("Manage email whitelist (allowed senders)");
-  whitelistCmd.command("list").description("List all whitelisted emails for an agent").requiredOption("--agent_id <id>", "Agent ID").option("--workspace <id>", "Workspace ID").option("--json", "Output as JSON").action(async (opts, command) => {
+  whitelistCmd.command("list").description("List all whitelisted emails for an agent").option("--agent_id <id>", "Agent ID").option("--workspace <id>", "Workspace ID").option("--json", "Output as JSON").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
     const { serverUrl, token, workspaceId } = resolveClientOpts(command, {
       workspace: opts.workspace,
-      agentId: opts.agent_id
+      agentId
     });
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
-      const entries = await client.getJSON(`/api/agents/${opts.agent_id}/whitelist`);
+      const entries = await client.getJSON(`/api/agents/${agentId}/whitelist`);
       if (!entries.length) {
         console.log("No whitelisted emails.");
         return;
@@ -19150,14 +21135,15 @@ function emailCommand() {
       process.exit(1);
     }
   });
-  whitelistCmd.command("add").description("Add an email to the whitelist").requiredOption("--agent_id <id>", "Agent ID").option("--workspace <id>", "Workspace ID").argument("<email>", "Email address to whitelist").action(async (email3, opts, command) => {
+  whitelistCmd.command("add").description("Add an email to the whitelist").option("--agent_id <id>", "Agent ID").option("--workspace <id>", "Workspace ID").argument("<email>", "Email address to whitelist").action(async (email3, opts, command) => {
+    const agentId = resolveAgentId(opts);
     const { serverUrl, token, workspaceId } = resolveClientOpts(command, {
       workspace: opts.workspace,
-      agentId: opts.agent_id
+      agentId
     });
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
-      const entry = await client.postJSON(`/api/agents/${opts.agent_id}/whitelist`, { email: email3.toLowerCase() });
+      const entry = await client.postJSON(`/api/agents/${agentId}/whitelist`, { email: email3.toLowerCase() });
       console.log(`Added ${entry.email} to whitelist (id: ${entry.id})`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -19169,21 +21155,22 @@ function emailCommand() {
       process.exit(1);
     }
   });
-  whitelistCmd.command("delete").description("Remove an email from the whitelist").requiredOption("--agent_id <id>", "Agent ID").option("--workspace <id>", "Workspace ID").argument("<email>", "Email address to remove").action(async (email3, opts, command) => {
+  whitelistCmd.command("delete").description("Remove an email from the whitelist").option("--agent_id <id>", "Agent ID").option("--workspace <id>", "Workspace ID").argument("<email>", "Email address to remove").action(async (email3, opts, command) => {
+    const agentId = resolveAgentId(opts);
     const { serverUrl, token, workspaceId } = resolveClientOpts(command, {
       workspace: opts.workspace,
-      agentId: opts.agent_id
+      agentId
     });
     const client = new APIClient(serverUrl, token, workspaceId);
     const normalizedEmail = email3.toLowerCase();
     try {
-      const entries = await client.getJSON(`/api/agents/${opts.agent_id}/whitelist`);
+      const entries = await client.getJSON(`/api/agents/${agentId}/whitelist`);
       const entry = entries.find((e) => e.email === normalizedEmail);
       if (!entry) {
         console.error(`Error: ${normalizedEmail} is not in the whitelist`);
         process.exit(1);
       }
-      await client.deleteJSON(`/api/agents/${opts.agent_id}/whitelist/${entry.id}`);
+      await client.deleteJSON(`/api/agents/${agentId}/whitelist/${entry.id}`);
       console.log(`Removed ${normalizedEmail} from whitelist`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -19243,8 +21230,9 @@ function printEventDetail(ev) {
 }
 function calendarCommand() {
   const cmd = new Command6("calendar").description("Manage scheduled agent events");
-  cmd.command("set").description("Create a calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_title <title>", "Event title (used as the task prompt)").requiredOption("--datetime <iso>", "Scheduled datetime (YYYY-MM-DDTHH:MM, local time)").option("--description <text>", "Optional longer-form notes for the event").option("--repeat <interval>", "Repeat interval, e.g. 1day, 2hour, 1month").option("--repeat_stop_date <date>", "Stop repeating on or after this date (YYYY-MM-DD, local time)").option("--json", "Output as JSON").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+  cmd.command("set").description("Create a calendar event").option("--agent_id <id>", "Agent ID").requiredOption("--event_title <title>", "Event title (used as the task prompt)").requiredOption("--datetime <iso>", "Scheduled datetime (YYYY-MM-DDTHH:MM, local time)").option("--description <text>", "Optional longer-form notes for the event").option("--repeat <interval>", "Repeat interval, e.g. 1day, 2hour, 1month").option("--repeat_stop_date <date>", "Stop repeating on or after this date (YYYY-MM-DD, local time)").option("--json", "Output as JSON").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     let scheduledAt;
     try {
@@ -19262,7 +21250,7 @@ function calendarCommand() {
       process.exit(1);
     }
     const body = {
-      agent_id: opts.agent_id,
+      agent_id: agentId,
       title: opts.event_title,
       scheduled_at: scheduledAt
     };
@@ -19284,14 +21272,15 @@ function calendarCommand() {
       process.exit(1);
     }
   });
-  cmd.command("list").description("List calendar events for an agent").requiredOption("--agent_id <id>", "Agent ID").option("--future_days <n>", "Include events scheduled in the next N days", "30").option("--past_days <n>", "Include events scheduled in the past N days", "0").option("--json", "Output as JSON").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+  cmd.command("list").description("List calendar events for an agent").option("--agent_id <id>", "Agent ID").option("--future_days <n>", "Include events scheduled in the next N days", "30").option("--past_days <n>", "Include events scheduled in the past N days", "0").option("--json", "Output as JSON").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     const now = Date.now();
     const from = new Date(now - Number(opts.past_days) * 86400000).toISOString();
     const to = new Date(now + Number(opts.future_days) * 86400000).toISOString();
     try {
-      const events = await client.getJSON(`/api/calendar?agentId=${encodeURIComponent(opts.agent_id)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`);
+      const events = await client.getJSON(`/api/calendar?agentId=${encodeURIComponent(agentId)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`);
       if (opts.json) {
         printJSON(events);
         return;
@@ -19310,13 +21299,14 @@ function calendarCommand() {
       process.exit(1);
     }
   });
-  cmd.command("show").description("Show the full detail of a single calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").option("--json", "Output as JSON").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+  cmd.command("show").description("Show the full detail of a single calendar event").option("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").option("--json", "Output as JSON").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
       const ev = await client.getJSON(`/api/calendar/${opts.event_id}`);
-      if (ev.agent_id !== opts.agent_id) {
-        console.error(`Error: event ${ev.id} does not belong to agent ${opts.agent_id}`);
+      if (ev.agent_id !== agentId) {
+        console.error(`Error: event ${ev.id} does not belong to agent ${agentId}`);
         process.exit(1);
       }
       if (opts.json) {
@@ -19329,7 +21319,7 @@ function calendarCommand() {
       process.exit(1);
     }
   });
-  cmd.command("update").description("Update fields on an existing calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").option("--event_title <title>", "New event title (task prompt)").option("--description <text>", "New description text").option("--clear_description", "Remove the description (sets to null)").option("--datetime <iso>", "New scheduled datetime (YYYY-MM-DDTHH:MM, local time)").option("--repeat <interval>", "New repeat interval, e.g. 1day, 2hour").option("--clear_repeat", "Convert a repeating event into a one-off").option("--repeat_stop_date <date>", "New stop date (YYYY-MM-DD, local time)").option("--clear_repeat_stop_date", "Remove the repeat stop date").option("--json", "Output as JSON").action(async (opts, command) => {
+  cmd.command("update").description("Update fields on an existing calendar event").option("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").option("--event_title <title>", "New event title (task prompt)").option("--description <text>", "New description text").option("--clear_description", "Remove the description (sets to null)").option("--datetime <iso>", "New scheduled datetime (YYYY-MM-DDTHH:MM, local time)").option("--repeat <interval>", "New repeat interval, e.g. 1day, 2hour").option("--clear_repeat", "Convert a repeating event into a one-off").option("--repeat_stop_date <date>", "New stop date (YYYY-MM-DD, local time)").option("--clear_repeat_stop_date", "Remove the repeat stop date").option("--json", "Output as JSON").action(async (opts, command) => {
     if (opts.description && opts.clear_description) {
       console.error("Error: --description and --clear_description are mutually exclusive");
       process.exit(1);
@@ -19374,12 +21364,13 @@ function calendarCommand() {
       console.error("Error: no fields to update — pass at least one of --event_title, --description, --clear_description, --datetime, --repeat, --clear_repeat, --repeat_stop_date, --clear_repeat_stop_date");
       process.exit(1);
     }
-    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
       const updated = await client.patchJSON(`/api/calendar/${opts.event_id}`, body);
-      if (updated.agent_id !== opts.agent_id) {
-        console.error(`Error: event ${updated.id} does not belong to agent ${opts.agent_id}`);
+      if (updated.agent_id !== agentId) {
+        console.error(`Error: event ${updated.id} does not belong to agent ${agentId}`);
         process.exit(1);
       }
       if (opts.json) {
@@ -19392,8 +21383,9 @@ function calendarCommand() {
       process.exit(1);
     }
   });
-  cmd.command("delete").description("Delete a calendar event").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, opts.agent_id);
+  cmd.command("delete").description("Delete a calendar event").option("--agent_id <id>", "Agent ID").requiredOption("--event_id <id>", "Event ID").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts2(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
       await client.deleteJSON(`/api/calendar/${opts.event_id}`);
@@ -19408,7 +21400,7 @@ function calendarCommand() {
 
 // commands/issue.ts
 import { Command as Command7 } from "commander";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 var VALID_STATUSES2 = ["todo", "in_progress", "review", "done", "closed", "canceled", "failed"];
 function resolveClientOpts3(command, agentId) {
   let root = command;
@@ -19432,7 +21424,7 @@ function readBody(opts) {
     process.exit(1);
   }
   if (opts.bodyFile)
-    return readFileSync8(opts.bodyFile, "utf-8");
+    return readFileSync9(opts.bodyFile, "utf-8");
   return opts.body ?? "";
 }
 function printIssue(issue3) {
@@ -19466,13 +21458,14 @@ comments:`);
 }
 function issueCommand() {
   const cmd = new Command7("issue").description("Manage assigned issues");
-  cmd.command("create").description("Create and dispatch an issue to an agent").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--title <title>", "Issue title").option("--description <text>", "Issue description").option("--body-file <path>", "Read issue description from a file").option("--json", "Output as JSON").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, opts.agent_id);
+  cmd.command("create").description("Create and dispatch an issue to an agent").option("--agent_id <id>", "Agent ID").requiredOption("--title <title>", "Issue title").option("--description <text>", "Issue description").option("--body-file <path>", "Read issue description from a file").option("--json", "Output as JSON").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     const description = readBody({ body: opts.description, bodyFile: opts.bodyFile });
     try {
       const res = await client.postJSON("/api/issues", {
-        agent_id: opts.agent_id,
+        agent_id: agentId,
         title: opts.title,
         description
       });
@@ -19484,14 +21477,15 @@ function issueCommand() {
       process.exit(1);
     }
   });
-  cmd.command("list").description("List issues for an agent").requiredOption("--agent_id <id>", "Agent ID").option("--status <status>", `Filter by status (${VALID_STATUSES2.join(", ")})`).option("--completed", "Show completed/closed/canceled/failed issues").option("--all", "Show all issues").option("--json", "Output as JSON").action(async (opts, command) => {
+  cmd.command("list").description("List issues for an agent").option("--agent_id <id>", "Agent ID").option("--status <status>", `Filter by status (${VALID_STATUSES2.join(", ")})`).option("--completed", "Show completed/closed/canceled/failed issues").option("--all", "Show all issues").option("--json", "Output as JSON").action(async (opts, command) => {
     if (opts.status && !VALID_STATUSES2.includes(opts.status)) {
       console.error(`Error: invalid status "${opts.status}"`);
       process.exit(1);
     }
-    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, opts.agent_id);
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
-    const params = new URLSearchParams({ agentId: opts.agent_id });
+    const params = new URLSearchParams({ agentId });
     if (opts.status)
       params.set("status", opts.status);
     if (!opts.all && !opts.status)
@@ -19511,13 +21505,14 @@ function issueCommand() {
       process.exit(1);
     }
   });
-  cmd.command("show").description("Show issue details and conversation").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--issue_id <id>", "Issue ID").option("--json", "Output as JSON").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, opts.agent_id);
+  cmd.command("show").description("Show issue details and conversation").option("--agent_id <id>", "Agent ID").requiredOption("--issue_id <id>", "Issue ID").option("--json", "Output as JSON").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
-      const res = await client.getJSON(`/api/issues/${opts.issue_id}?agentId=${encodeURIComponent(opts.agent_id)}`);
-      if (res.issue.agent_id !== opts.agent_id) {
-        console.error(`Error: issue ${res.issue.id} does not belong to agent ${opts.agent_id}`);
+      const res = await client.getJSON(`/api/issues/${opts.issue_id}?agentId=${encodeURIComponent(agentId)}`);
+      if (res.issue.agent_id !== agentId) {
+        console.error(`Error: issue ${res.issue.id} does not belong to agent ${agentId}`);
         process.exit(1);
       }
       if (opts.json)
@@ -19528,7 +21523,7 @@ function issueCommand() {
       process.exit(1);
     }
   });
-  cmd.command("update").description("Update issue status or text").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--issue_id <id>", "Issue ID").option("--status <status>", `New status (${VALID_STATUSES2.join(", ")})`).option("--title <title>", "New title").option("--description <text>", "New description").option("--body-file <path>", "Read description from a file").option("--json", "Output as JSON").action(async (opts, command) => {
+  cmd.command("update").description("Update issue status or text").option("--agent_id <id>", "Agent ID").requiredOption("--issue_id <id>", "Issue ID").option("--status <status>", `New status (${VALID_STATUSES2.join(", ")})`).option("--title <title>", "New title").option("--description <text>", "New description").option("--body-file <path>", "Read description from a file").option("--json", "Output as JSON").action(async (opts, command) => {
     if (opts.status && !VALID_STATUSES2.includes(opts.status)) {
       console.error(`Error: invalid status "${opts.status}"`);
       process.exit(1);
@@ -19545,10 +21540,11 @@ function issueCommand() {
       console.error("Error: pass at least one of --status, --title, --description, --body-file");
       process.exit(1);
     }
-    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, opts.agent_id);
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
-      const issue3 = await client.patchJSON(`/api/issues/${opts.issue_id}?agentId=${encodeURIComponent(opts.agent_id)}`, body);
+      const issue3 = await client.patchJSON(`/api/issues/${opts.issue_id}?agentId=${encodeURIComponent(agentId)}`, body);
       if (opts.json)
         return printJSON(issue3);
       printIssue(issue3);
@@ -19557,16 +21553,17 @@ function issueCommand() {
       process.exit(1);
     }
   });
-  cmd.command("comment").description("Append a comment to an issue").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--issue_id <id>", "Issue ID").option("--body <text>", "Comment text").option("--body-file <path>", "Read comment from a file").option("--json", "Output as JSON").action(async (opts, command) => {
+  cmd.command("comment").description("Append a comment to an issue").option("--agent_id <id>", "Agent ID").requiredOption("--issue_id <id>", "Issue ID").option("--body <text>", "Comment text").option("--body-file <path>", "Read comment from a file").option("--json", "Output as JSON").action(async (opts, command) => {
     const content = readBody({ body: opts.body, bodyFile: opts.bodyFile }).trim();
     if (!content) {
       console.error("Error: pass --body or --body-file");
       process.exit(1);
     }
-    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, opts.agent_id);
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts3(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     try {
-      const res = await client.postJSON(`/api/issues/${opts.issue_id}/comments?agentId=${encodeURIComponent(opts.agent_id)}`, { content });
+      const res = await client.postJSON(`/api/issues/${opts.issue_id}/comments?agentId=${encodeURIComponent(agentId)}`, { content });
       if (opts.json)
         return printJSON(res);
       console.log(`Commented on ${opts.issue_id}`);
@@ -19625,7 +21622,7 @@ ${result.output}`);
 
 // commands/sync.ts
 import { Command as Command10 } from "commander";
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { basename as basename2 } from "path";
 var MIME_BY_EXT2 = {
   ".pdf": "application/pdf",
@@ -19668,12 +21665,13 @@ function resolveClientOpts4(command, agentId) {
 }
 function syncCommand() {
   const cmd = new Command10("sync").description("File sync utilities");
-  cmd.command("upload-artifact").description("Upload a file artifact to a conversation").requiredOption("--agent_id <id>", "Agent ID").requiredOption("--conversation_id <id>", "Conversation ID").requiredOption("--file <path>", "Path to file to upload").action(async (opts, command) => {
-    const { serverUrl, token, workspaceId } = resolveClientOpts4(command, opts.agent_id);
+  cmd.command("upload-artifact").description("Upload a file artifact to a conversation").option("--agent_id <id>", "Agent ID").requiredOption("--conversation_id <id>", "Conversation ID").requiredOption("--file <path>", "Path to file to upload").action(async (opts, command) => {
+    const agentId = resolveAgentId(opts);
+    const { serverUrl, token, workspaceId } = resolveClientOpts4(command, agentId);
     const client = new APIClient(serverUrl, token, workspaceId);
     let bytes;
     try {
-      bytes = readFileSync9(opts.file);
+      bytes = readFileSync10(opts.file);
     } catch (err) {
       console.error(`Error: cannot read file "${opts.file}": ${err.message}`);
       process.exit(1);
@@ -19682,7 +21680,7 @@ function syncCommand() {
     const contentType = guessContentType2(filename);
     const form = new FormData;
     form.append("file", new Blob([new Uint8Array(bytes)], { type: contentType }), filename);
-    form.append("agent_id", opts.agent_id);
+    form.append("agent_id", agentId);
     form.append("conversation_id", opts.conversation_id);
     try {
       const result = await client.postMultipart("/api/artifacts/upload", form);