@alook/cli 0.0.110 → 0.0.112

package/dist/session-runner.js

@@ -16754,10 +16754,18 @@ function toAlookAddress(h) {
   return `${h}${DOMAIN}`;
 }
 // ../shared/src/mode.ts
+function isLocalUrl(url2) {
+  try {
+    const { hostname: hostname3 } = new URL(url2);
+    return ["localhost", "127.0.0.1", "0.0.0.0"].includes(hostname3);
+  } catch {
+    return false;
+  }
+}
 function resolveMode(signals) {
   if (signals.nodeEnv === "development" && !signals.cmdPrefix)
     return "dev";
-  if (signals.serverUrl && !signals.cmdPrefix)
+  if (signals.serverUrl && !signals.cmdPrefix && signals.nodeEnv !== "production" && isLocalUrl(signals.serverUrl))
     return "dev";
   if (signals.cmdPrefix)
     return "app";
@@ -16901,6 +16909,190 @@ class DaemonClient {
 import { spawn } from "child_process";
 import { createInterface } from "readline";
 
+// daemon/kill-tree.ts
+import { execSync } from "child_process";
+
+// lib/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var LABELS = {
+  debug: "DEBUG",
+  info: "INFO ",
+  warn: "WARN ",
+  error: "ERROR"
+};
+var COLORS = {
+  debug: "\x1B[90m",
+  info: "\x1B[36m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+function useColor() {
+  if (process.env.NO_COLOR !== undefined)
+    return false;
+  if (process.env.FORCE_COLOR !== undefined)
+    return true;
+  return process.stdout.isTTY === true;
+}
+function timestamp() {
+  const d = new Date;
+  const Y = d.getFullYear();
+  const M = String(d.getMonth() + 1).padStart(2, "0");
+  const D = String(d.getDate()).padStart(2, "0");
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  return `${Y}-${M}-${D} ${h}:${m}:${s}`;
+}
+
+class Logger2 {
+  level;
+  color;
+  module;
+  constructor(opts = {}) {
+    const envLevel = process.env.ALOOK_LOG_LEVEL;
+    this.level = LEVELS[opts.level ?? envLevel ?? "info"];
+    this.color = useColor();
+    this.module = opts.module;
+  }
+  setLevel(level) {
+    this.level = LEVELS[level];
+  }
+  child(module) {
+    const child = new Logger2({ level: this.levelName(), module });
+    return child;
+  }
+  debug(msg, ...args) {
+    this.write("debug", msg, args);
+  }
+  info(msg, ...args) {
+    this.write("info", msg, args);
+  }
+  warn(msg, ...args) {
+    this.write("warn", msg, args);
+  }
+  error(msg, ...args) {
+    this.write("error", msg, args);
+  }
+  levelName() {
+    for (const [name, num] of Object.entries(LEVELS)) {
+      if (num === this.level)
+        return name;
+    }
+    return "info";
+  }
+  write(level, msg, args) {
+    if (LEVELS[level] < this.level)
+      return;
+    const ts = timestamp();
+    const label = LABELS[level];
+    const mod = this.module ? `[${this.module}]` : "";
+    let line;
+    if (this.color) {
+      const c = COLORS[level];
+      const modStr = mod ? ` ${BOLD}${mod}${RESET}` : "";
+      line = `${DIM}${ts}${RESET} ${c}${label}${RESET}${modStr} ${msg}`;
+    } else {
+      const modStr = mod ? ` ${mod}` : "";
+      line = `${ts} ${label}${modStr} ${msg}`;
+    }
+    const dest = level === "error" ? process.stderr : process.stdout;
+    dest.write(line + `
+`);
+    for (const a of args) {
+      if (a instanceof Error) {
+        dest.write(`  ${a.message}
+`);
+        if (a.stack && this.level <= LEVELS.debug) {
+          dest.write(`  ${a.stack}
+`);
+        }
+      } else if (a !== null && typeof a === "object") {
+        const pairs = Object.entries(a).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
+        if (pairs)
+          dest.write(`  ${pairs}
+`);
+      } else if (a !== undefined) {
+        dest.write(`  ${String(a)}
+`);
+      }
+    }
+  }
+}
+function createLogger2(opts) {
+  return new Logger2(opts);
+}
+var log = createLogger2();
+
+// daemon/kill-tree.ts
+var log2 = createLogger2({ module: "kill-tree" });
+function killGraceMs() {
+  return Number(process.env.ALOOK_KILL_GRACE_MS) || 2000;
+}
+var POLL_MS = 100;
+var isPosix = process.platform !== "win32";
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
+function signalTree(pid, signal) {
+  if (isPosix) {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch (e) {
+      const code = e?.code;
+      if (code === "ESRCH")
+        return;
+    }
+  }
+  if (!isPosix) {
+    try {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore" });
+      return;
+    } catch {}
+    return;
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {}
+}
+async function killProcessTree(pid, opts) {
+  if (!pid || pid < 1)
+    return;
+  if (!isAlive(pid))
+    return;
+  if (!isPosix) {
+    signalTree(pid, "SIGTERM");
+    return;
+  }
+  const graceMs = opts?.graceMs ?? killGraceMs();
+  signalTree(pid, "SIGTERM");
+  const deadline = Date.now() + graceMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid))
+      return;
+    await new Promise((r) => setTimeout(r, POLL_MS));
+  }
+  if (isAlive(pid)) {
+    log2.warn(`pid=${pid} survived SIGTERM after ${graceMs}ms — escalating to SIGKILL`);
+    signalTree(pid, "SIGKILL");
+  }
+}
+
+// daemon/agent/claude.ts
 class ClaudeBackend {
   cliPath;
   name = "claude";
@@ -16931,7 +17123,8 @@ class ClaudeBackend {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...options.env },
       shell: process.platform === "win32",
-      windowsHide: true
+      windowsHide: true,
+      detached: process.platform !== "win32"
     });
     if (!proc.pid) {
       const error51 = `Failed to start ${this.cliPath}: binary not found or not executable. Is 'claude' installed and on PATH?`;
@@ -16948,7 +17141,8 @@ class ClaudeBackend {
     if (options.timeout) {
       timeoutTimer = setTimeout(() => {
         timedOut = true;
-        proc.kill("SIGTERM");
+        if (proc.pid !== undefined)
+          killProcessTree(proc.pid);
       }, options.timeout);
     }
     const startTime = Date.now();
@@ -17200,7 +17394,8 @@ class CodexBackend {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...options.env },
       shell: process.platform === "win32",
-      windowsHide: true
+      windowsHide: true,
+      detached: process.platform !== "win32"
     });
     if (!proc.pid) {
       const error51 = `Failed to start ${this.cliPath}: binary not found or not executable. Is 'codex' installed and on PATH?`;
@@ -17217,7 +17412,8 @@ class CodexBackend {
     if (options.timeout) {
       timeoutTimer = setTimeout(() => {
         timedOut = true;
-        proc.kill("SIGTERM");
+        if (proc.pid !== undefined)
+          killProcessTree(proc.pid);
       }, options.timeout);
     }
     const startTime = Date.now();
@@ -17669,7 +17865,6 @@ class CodexBackend {
 // daemon/agent/opencode.ts
 import { spawn as spawn3 } from "child_process";
 import { createInterface as createInterface3 } from "readline";
-
 class OpenCodeBackend {
   cliPath;
   name = "opencode";
@@ -17690,7 +17885,8 @@ class OpenCodeBackend {
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env, ...options.env, OPENCODE_PERMISSION: '{"*":"allow"}' },
       shell: process.platform === "win32",
-      windowsHide: true
+      windowsHide: true,
+      detached: process.platform !== "win32"
     });
     if (!proc.pid) {
       const error51 = `Failed to start ${this.cliPath}: binary not found or not executable. Is 'opencode' installed and on PATH?`;
@@ -17707,7 +17903,8 @@ class OpenCodeBackend {
     if (options.timeout) {
       timeoutTimer = setTimeout(() => {
         timedOut = true;
-        proc.kill("SIGTERM");
+        if (proc.pid !== undefined)
+          killProcessTree(proc.pid);
       }, options.timeout);
     }
     const startTime = Date.now();
@@ -17973,55 +18170,55 @@ import {
 import { join as join2 } 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.
+var SYSTEM_PROMPT_BODY = `## Memory
+
+Your memory directory is \`./\`. Write ONLY here — never write any external memory file.
+
+### memory.md — your memory index (CRITICAL)
+\`./memory.md\` is the entry point to everything you know, and the **first file you read on every startup (including after context compaction)**. Keep it scannable: basic facts inline, plus one-line index pointers to \`experiences/\`. Record only **key, durable facts** — things that stay true over time. Do NOT record time-sensitive state like what you're working on right now; that belongs to the Context Timeline (see below), not here.
+
+- Write ESSENTIAL yet SHORT memory directly to \`./memory.md\` (basic user profile, local project mapping, when-to-read pointers). ESSENTIAL = you generally need it every time; SHORT = one sentence under 140 chars.
+- For SPECIFIC yet LONG rules or workflows, write to \`experiences/[NAME].md\` and add an index line in \`./memory.md\`. SPECIFIC = used only conditionally; LONG = needs more than 140 chars to describe.
+
+### What to memorize
+Actively record, without being asked:
+- **User profile & preferences** — name, what they work on, how they like things done.
+- **Local project mapping** — e.g. "alook = the project under /Users/.../alook".
+- **When to read what** — e.g. "read ./experiences/alook_dev_workflow.md when starting a new PR in alook".
+- **Specific workflows** — conditionally-triggered procedures → \`experiences/[NAME].md\`.
+
+### What NOT to memorize
+Keep \`./memory.md\` free of time-sensitive state. Do NOT write what you're working on right now, in-progress task status, or anything that goes stale quickly — the Context Timeline already records the full history of your work and is where you recall such things. memory.md is for durable facts that stay true across many sessions.
 
 ## 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.
+You're a solo working unit inside a powerful personal agent in the Alook platform. Your current context is only a fraction of the full timeline of what you have done.
+
+The full context timeline lives in \`./.context_timeline/YYYY-MM-DD.jsonl\`. Each line is a JSON object, sorted by \`datetime\` ascending, with these fields:
+- \`task_id\` — unique task identifier
+- \`context_key\` — thread identifier; the same context key means 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 actual task agent messages with tool-calls and failed logs
 
 ## 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.
+- When you recall the timelines, don't say "I find ... in my timeline jsonl". Just say "I can recall...".
+- The user doesn't know about the context timeline jsonl — this is your secret weapon.
+- Act and respond 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 breaks 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.
+- Read @memory.md (if it exists) before your action.
+- When the user asks something you don't have in your current context, read the timeline jsonl files for the answer (today or previous days):
+  - Use the grep tool to search the context timeline jsonls when you have clean, focused keywords to recall.
+  - If you don't know the current datetime, obtain it first.
+- When accessing other local projects, read the CLAUDE.md/AGENTS.md file under the project root dir to understand the requirements.
 `;
 function resolveInstruction(text2, selfAgentId) {
   let result = text2;
@@ -18049,17 +18246,16 @@ function buildInstructionContent(task) {
 ${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:
+CRITICAL: The following instructions come from the big boss — follow them.
 ${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.
+CRITICAL: Before you start ANY task, scan the colleague list below.
+- If a colleague's delegation criteria match the current task, 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++) {
@@ -18091,40 +18287,57 @@ ${task.agent.instructions}
 ## 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\`.
+
+### Command quick reference
+| Capability | Command |
+|---|---|
+| Schedule / list / edit tasks | \`${cmdPrefix()} calendar set\` (also list, show, update, delete) |
+| Upload a file for your owner | \`${cmdPrefix()} sync upload-artifact\` |
+| Recruit a colleague agent | \`${cmdPrefix()} agent recruit\` |
+
+Detailed usage for each capability follows below.
 `;
-  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 += `
+  const emailLines = [];
+  if (alookAddr)
+    emailLines.push(`- '${alookAddr}' (default, Alook platform address)`);
+  for (const a of customAddrs)
+    emailLines.push(`- '${a}' (custom IMAP/SMTP mailbox)`);
+  content += `
 Your email addresses:
-${lines.join(`
+${emailLines.join(`
 `)}
 
 
+### Email command quick reference
+| Action | Command |
+|---|---|
+| Pull a specific email | \`${cmdPrefix()} email pull --email_id <EMAIL_ID>\` |
+| Pull unread inbox | \`${cmdPrefix()} email pull --status unread\` |
+| Mark read | \`${cmdPrefix()} email set --email_id <EMAIL_ID> --status read\` |
+| Send | \`${cmdPrefix()} email send --to <ADDRESS> --subject "<S>" --body-file <PATH>\` |
+| Reply (same thread) | \`${cmdPrefix()} email send ... --in-reply-to <EMAIL_ID>\` |
+| Forward | \`${cmdPrefix()} email forward --email_id <EMAIL_ID> --to <RECIPIENT>\` |
+| Whitelist | \`${cmdPrefix()} email whitelist list\` (also add, delete) |
+
 ### Emails
----
 When your task prompt includes an \`email_id\` field, fetch ONLY that specific email:
 - Run '${cmdPrefix()} email pull --email_id <EMAIL_ID>' (uses the email_id from the prompt)
 When no \`email_id\` is present, fall back to listing unread:
 - 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).
@@ -18141,7 +18354,6 @@ To reply to an email, add '--in-reply-to <EMAIL_ID>' to the send command. This s
 - 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.
@@ -18150,16 +18362,13 @@ Forward any email to a new recipient, with an optional note prepended above the
 - 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.
@@ -18168,12 +18377,10 @@ Upload files for your owner to review in the app.
 - 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 += `
 ### Agent Management
@@ -18190,7 +18397,6 @@ Recruit new colleague agents directly from the CLI. The server auto-generates a
 - Example: '${cmdPrefix()} agent recruit --instructions "You are a QA engineer..." --relationship "DELEGATE when: code is ready for review"'
 - Output: 'Recruited Felix (felix@alook.ai) — ag_xK9mPq2z'
 - The new agent shares your runtime, is automatically linked as your colleague, and receives a welcome task.
----
 `;
   content += `
 ### Calendar
@@ -18199,7 +18405,7 @@ Schedule future tasks for yourself. At the scheduled time, a new task is dispatc
 
 !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:
@@ -18211,7 +18417,7 @@ 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.
@@ -18233,7 +18439,6 @@ Edit an existing event (preserves event id and recurring state):
 
 Delete an event:
 - Run '${cmdPrefix()} calendar delete --event_id <EVENT_ID>'
----
 `;
   return content;
 }
@@ -18359,128 +18564,8 @@ function releaseLock(lockPath) {
   } catch {}
 }
 
-// lib/logger.ts
-var LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  silent: 4
-};
-var LABELS = {
-  debug: "DEBUG",
-  info: "INFO ",
-  warn: "WARN ",
-  error: "ERROR"
-};
-var COLORS = {
-  debug: "\x1B[90m",
-  info: "\x1B[36m",
-  warn: "\x1B[33m",
-  error: "\x1B[31m"
-};
-var RESET = "\x1B[0m";
-var DIM = "\x1B[2m";
-var BOLD = "\x1B[1m";
-function useColor() {
-  if (process.env.NO_COLOR !== undefined)
-    return false;
-  if (process.env.FORCE_COLOR !== undefined)
-    return true;
-  return process.stdout.isTTY === true;
-}
-function timestamp() {
-  const d = new Date;
-  const Y = d.getFullYear();
-  const M = String(d.getMonth() + 1).padStart(2, "0");
-  const D = String(d.getDate()).padStart(2, "0");
-  const h = String(d.getHours()).padStart(2, "0");
-  const m = String(d.getMinutes()).padStart(2, "0");
-  const s = String(d.getSeconds()).padStart(2, "0");
-  return `${Y}-${M}-${D} ${h}:${m}:${s}`;
-}
-
-class Logger2 {
-  level;
-  color;
-  module;
-  constructor(opts = {}) {
-    const envLevel = process.env.ALOOK_LOG_LEVEL;
-    this.level = LEVELS[opts.level ?? envLevel ?? "info"];
-    this.color = useColor();
-    this.module = opts.module;
-  }
-  setLevel(level) {
-    this.level = LEVELS[level];
-  }
-  child(module) {
-    const child = new Logger2({ level: this.levelName(), module });
-    return child;
-  }
-  debug(msg, ...args) {
-    this.write("debug", msg, args);
-  }
-  info(msg, ...args) {
-    this.write("info", msg, args);
-  }
-  warn(msg, ...args) {
-    this.write("warn", msg, args);
-  }
-  error(msg, ...args) {
-    this.write("error", msg, args);
-  }
-  levelName() {
-    for (const [name, num] of Object.entries(LEVELS)) {
-      if (num === this.level)
-        return name;
-    }
-    return "info";
-  }
-  write(level, msg, args) {
-    if (LEVELS[level] < this.level)
-      return;
-    const ts = timestamp();
-    const label = LABELS[level];
-    const mod = this.module ? `[${this.module}]` : "";
-    let line;
-    if (this.color) {
-      const c = COLORS[level];
-      const modStr = mod ? ` ${BOLD}${mod}${RESET}` : "";
-      line = `${DIM}${ts}${RESET} ${c}${label}${RESET}${modStr} ${msg}`;
-    } else {
-      const modStr = mod ? ` ${mod}` : "";
-      line = `${ts} ${label}${modStr} ${msg}`;
-    }
-    const dest = level === "error" ? process.stderr : process.stdout;
-    dest.write(line + `
-`);
-    for (const a of args) {
-      if (a instanceof Error) {
-        dest.write(`  ${a.message}
-`);
-        if (a.stack && this.level <= LEVELS.debug) {
-          dest.write(`  ${a.stack}
-`);
-        }
-      } else if (a !== null && typeof a === "object") {
-        const pairs = Object.entries(a).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : v}`).join(" ");
-        if (pairs)
-          dest.write(`  ${pairs}
-`);
-      } else if (a !== undefined) {
-        dest.write(`  ${String(a)}
-`);
-      }
-    }
-  }
-}
-function createLogger2(opts) {
-  return new Logger2(opts);
-}
-var log = createLogger2();
-
 // daemon/execenv/timeline.ts
-var log2 = createLogger2({ module: "timeline" });
+var log3 = createLogger2({ module: "timeline" });
 function readJsonl(filePath) {
   let content;
   try {
@@ -18518,8 +18603,7 @@ function recentFilenames(maxDays) {
   }
   return filenames;
 }
-function localISOString() {
-  const now = new Date;
+function localISOString(now = new Date) {
   const tzOffset = -now.getTimezoneOffset();
   const sign = tzOffset >= 0 ? "+" : "-";
   const absOffset = Math.abs(tzOffset);
@@ -18550,7 +18634,7 @@ async function initEntryAsync(timelineDir, entry) {
       acquired = acquireLock(lockPath);
     }
     if (!acquired) {
-      log2.debug(`Timeline initEntry: could not acquire lock for ${filename}`);
+      log3.debug(`Timeline initEntry: could not acquire lock for ${filename}`);
       return;
     }
     try {
@@ -18560,7 +18644,7 @@ async function initEntryAsync(timelineDir, entry) {
       releaseLock(lockPath);
     }
   } catch (err) {
-    log2.debug("Timeline initEntry failed", err);
+    log3.debug("Timeline initEntry failed", err);
   }
 }
 function updateEntry(timelineDir, taskId, updater) {
@@ -18570,7 +18654,7 @@ function updateEntry(timelineDir, taskId, updater) {
     try {
       const acquired = acquireLock(lockPath);
       if (!acquired) {
-        log2.debug(`Timeline updateEntry: lock held for ${filename}, skipping`);
+        log3.debug(`Timeline updateEntry: lock held for ${filename}, skipping`);
         continue;
       }
       try {
@@ -18603,10 +18687,10 @@ function updateEntry(timelineDir, taskId, updater) {
         releaseLock(lockPath);
       }
     } catch (err) {
-      log2.debug(`Timeline updateEntry failed for ${filename}`, err);
+      log3.debug(`Timeline updateEntry failed for ${filename}`, err);
     }
   }
-  log2.debug(`Timeline updateEntry: task_id ${taskId} not found in last 7 days`);
+  log3.debug(`Timeline updateEntry: task_id ${taskId} not found in last 7 days`);
 }
 function createTimelineEntry(taskId, prompt, type, sessionId, pid, provider, contextKey, detailedLog) {
   return {
@@ -18644,7 +18728,7 @@ function findResumableSessionByContextKey(timelineDir, contextKey, provider) {
 // daemon/execenv/steering.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync3, unlinkSync as unlinkSync2, readdirSync, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
-var log3 = createLogger2({ module: "steering" });
+var log4 = createLogger2({ module: "steering" });
 var INTENT_DIR_NAME = ".kill_intents";
 var INTENT_STALE_MS = 10 * 60 * 1000;
 function intentFilePath(baseDir, taskId) {
@@ -18675,7 +18759,13 @@ 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 };
+  const createdAt = new Date(task.createdAt);
+  const receivedAt = Number.isNaN(createdAt.getTime()) ? localISOString() : localISOString(createdAt);
+  const obj = {
+    type: task.type,
+    received_at: receivedAt,
+    instruction: task.prompt
+  };
   if (task.type === "user_dm_message") {
     obj.notice = DM_RESPONSE_NOTICE;
   }
@@ -18738,7 +18828,7 @@ function buildPrompt(task, attachments) {
 }
 
 // daemon/session-runner.ts
-var log4 = createLogger2({ module: "session-runner" });
+var log5 = createLogger2({ module: "session-runner" });
 var ATTACHMENTS_BASE = tempDir("alook-attachments");
 async function writeMarkerFile(workspacesRoot, marker) {
   const dir = path.join(workspacesRoot, ".pending_completions");
@@ -18786,20 +18876,20 @@ async function reportToServer(fn, markerData, workspacesRoot) {
     } catch (e) {
       lastErr = e;
       if (isClientError(e)) {
-        log4.info(`server report for task ${markerData.taskId}: task already in terminal state (${e})`);
+        log5.info(`server report for task ${markerData.taskId}: task already in terminal state (${e})`);
         return;
       }
       if (attempt < RETRY_DELAYS.length && isRetryableError(e)) {
-        log4.debug(`server report attempt ${attempt + 1} failed for task ${markerData.taskId}, retrying in ${RETRY_DELAYS[attempt]}ms`);
+        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]));
       }
     }
   }
-  log4.warn(`server report failed for task ${markerData.taskId} after retries, writing marker: ${lastErr}`);
+  log5.warn(`server report failed for task ${markerData.taskId} after retries, writing marker: ${lastErr}`);
   try {
     await writeMarkerFile(workspacesRoot, markerData);
   } catch (writeErr) {
-    log4.error(`marker write also failed for task ${markerData.taskId}: ${writeErr}`);
+    log5.error(`marker write also failed for task ${markerData.taskId}: ${writeErr}`);
   }
 }
 function sanitizeFilename(name) {
@@ -18830,7 +18920,7 @@ async function downloadAttachments(client, token, workspaceId, taskId, attachmen
 }
 async function runSession(input) {
   const { task, provider, cliPath, model, serverURL, token, workspacesRoot, agentTimeout, messageInactivityTimeout } = input;
-  log4.info(`starting (task=${task.id}, type=${task.type}, agent=${task.agentId}, provider=${provider}, model=${model || "default"})`);
+  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");
@@ -18839,11 +18929,37 @@ async function runSession(input) {
   await initEntryAsync(timelineDir, createTimelineEntry(task.id, task.prompt, task.type, undefined, process.pid, provider, task.contextKey, input.logFilePath));
   const { workDir, env } = prepare({ workspacesRoot, token }, task);
   let killed = false;
-  const earlyOnKill = async () => {
+  let agentPid = undefined;
+  let flushTimer = undefined;
+  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 onKill = async () => {
     if (killed)
       return;
     killed = true;
-    log4.info(`killed by signal (messages=0, tools=0)`);
+    log5.info(`killed by signal (messages=${seq}, tools=${toolCount})`);
+    if (agentPid !== undefined) {
+      log5.info(`killing inner agent group (pid=${agentPid})`);
+      await killProcessTree(agentPid);
+    }
+    if (flushTimer)
+      clearInterval(flushTimer);
+    try {
+      await flushMessages();
+    } catch {}
     await cleanupAttachments(task.id);
     const intent = readKillIntent(agentBaseDir, task.id);
     clearKillIntent(agentBaseDir, task.id);
@@ -18874,34 +18990,36 @@ async function runSession(input) {
     }
     process.exit(1);
   };
-  process.on("SIGTERM", earlyOnKill);
-  process.on("SIGINT", earlyOnKill);
+  process.on("SIGTERM", onKill);
+  process.on("SIGINT", onKill);
   const attachmentIds = task.context?.attachment_ids ?? [];
   let attachments;
   if (attachmentIds.length > 0) {
-    log4.info(`downloading ${attachmentIds.length} attachment(s)`);
+    log5.info(`downloading ${attachmentIds.length} attachment(s)`);
     try {
       attachments = await downloadAttachments(client, token, task.workspaceId, task.id, attachmentIds);
-      log4.info(`attachments ready (${attachments.length} file(s))`);
+      log5.info(`attachments ready (${attachments.length} file(s))`);
     } catch (e) {
       await cleanupAttachments(task.id);
       const errMsg = `failed to download attachments: ${e}`;
-      log4.error(errMsg);
+      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);
+      process.removeListener("SIGTERM", onKill);
+      process.removeListener("SIGINT", onKill);
       return;
     }
   }
+  if (killed)
+    return;
   const prompt = buildPrompt(task, attachments);
   const resumeSessionId = task.contextKey ? findResumableSessionByContextKey(timelineDir, task.contextKey, provider) ?? undefined : undefined;
   if (resumeSessionId) {
-    log4.info(`resuming session ${resumeSessionId} (context_key: ${task.contextKey})`);
+    log5.info(`resuming session ${resumeSessionId} (context_key: ${task.contextKey})`);
   }
   const session2 = backend.execute(prompt, {
     cwd: workDir,
@@ -18910,77 +19028,21 @@ async function runSession(input) {
     timeout: agentTimeout,
     resumeSessionId
   });
-  const agentPid = session2.pid;
+  agentPid = session2.pid;
+  if (killed) {
+    if (agentPid !== undefined) {
+      log5.info(`kill landed during spawn — reaping inner agent group (pid=${agentPid})`);
+      await killProcessTree(agentPid);
+    }
+    process.exit(1);
+  }
   const earlySessionId = await session2.sessionId;
-  log4.info(`agent started (pid=${agentPid ?? "unknown"}, session=${earlySessionId})`);
-  log4.info(JSON.stringify({ role: "user", type: "text", content: prompt }));
+  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) {
-      log4.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;
-    log4.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);
+  flushTimer = setInterval(flushMessages, FLUSH_INTERVAL_MS);
   const INACTIVITY_TIMEOUT_MS = messageInactivityTimeout ?? 5 * 60 * 1000;
   let inactivityTimedOut = false;
   try {
@@ -18996,11 +19058,9 @@ async function runSession(input) {
       ]) : next);
       if (raceResult === "timeout") {
         inactivityTimedOut = true;
-        log4.warn(`message inactivity timeout (${INACTIVITY_TIMEOUT_MS / 1000}s) — killing agent`);
-        if (session2.pid) {
-          try {
-            process.kill(session2.pid, "SIGTERM");
-          } catch {}
+        log5.warn(`message inactivity timeout (${INACTIVITY_TIMEOUT_MS / 1000}s) — killing agent`);
+        if (session2.pid !== undefined) {
+          await killProcessTree(session2.pid);
         }
         iter.return?.(undefined);
         break;
@@ -19013,9 +19073,9 @@ async function runSession(input) {
       if (msg.type === "tool-use")
         toolCount++;
       if (msg.type === "tool-result" && msg.output && msg.output.length > 500) {
-        log4.info(JSON.stringify({ role: "assistant", ...msg, output: msg.output.slice(0, 500) + `... (${msg.output.length} chars)` }));
+        log5.info(JSON.stringify({ role: "assistant", ...msg, output: msg.output.slice(0, 500) + `... (${msg.output.length} chars)` }));
       } else {
-        log4.info(JSON.stringify({ role: "assistant", ...msg }));
+        log5.info(JSON.stringify({ role: "assistant", ...msg }));
       }
       if (msg.type === "status" || msg.type === "log")
         continue;
@@ -19040,14 +19100,11 @@ async function runSession(input) {
     if (!killed)
       await flushMessages();
   } finally {
-    clearInterval(flushTimer);
-    process.removeListener("SIGTERM", onKill);
-    process.removeListener("SIGINT", onKill);
+    if (flushTimer)
+      clearInterval(flushTimer);
   }
   if (killed)
     return;
-  process.on("SIGTERM", onKill);
-  process.on("SIGINT", onKill);
   const result = await session2.result;
   process.removeListener("SIGTERM", onKill);
   process.removeListener("SIGINT", onKill);
@@ -19079,18 +19136,18 @@ async function runSession(input) {
       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);
-    log4.info(`completed (duration=${dur}s, messages=${seq}, tools=${toolCount})`);
+    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);
-    log4.info(`failed (duration=${dur}s, messages=${seq}, tools=${toolCount}) — ${result.error}`);
+    log5.info(`failed (duration=${dur}s, messages=${seq}, tools=${toolCount}) — ${result.error}`);
   }
 }
 async function main() {
   const encoded = process.argv[2];
   if (!encoded) {
-    log4.error("session-runner: missing base64-encoded input argument");
+    log5.error("session-runner: missing base64-encoded input argument");
     process.exit(1);
   }
   let input;
@@ -19098,14 +19155,14 @@ async function main() {
     const json2 = Buffer.from(encoded, "base64").toString("utf-8");
     input = JSON.parse(json2);
   } catch (e) {
-    log4.error("session-runner: failed to parse input", 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) {
-    log4.error(`session-runner: unhandled error for task ${input.task.id}`, 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) => {