@alook/cli 0.0.110 → 0.0.112

package/dist/index.js

@@ -16854,10 +16854,18 @@ function semverGte(a, b) {
   return true;
 }
 // ../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";
@@ -16875,7 +16883,21 @@ function cliCommand(mode) {
       return "npx @alook/cli";
   }
 }
+var DEFAULT_BASE_URL = "https://alook.ai";
+var DEV_BASE_URL = "http://localhost:3000";
+function getBaseUrl(signals) {
+  if (signals.serverUrl)
+    return signals.serverUrl;
+  if (signals.appUrl)
+    return signals.appUrl;
+  if (signals.nodeEnv === "development")
+    return DEV_BASE_URL;
+  return DEFAULT_BASE_URL;
+}
 // lib/env.ts
+function getServerUrl() {
+  return getBaseUrl({ serverUrl: process.env.ALOOK_SERVER_URL });
+}
 function isDev() {
   return resolveMode({
     serverUrl: process.env.ALOOK_SERVER_URL,
@@ -17027,7 +17049,7 @@ function loadDaemonConfig(profile) {
   const defaultRoot = join3(configDir(), profile ? `workspaces_${profile}` : "workspaces");
   const workspacesRoot = process.env.ALOOK_WORKSPACES_ROOT || defaultRoot;
   return {
-    serverURL: normalizeServerBaseURL(process.env.ALOOK_SERVER_URL || "https://alook.ai"),
+    serverURL: normalizeServerBaseURL(getServerUrl()),
     claudePath: process.env.ALOOK_CLAUDE_PATH || "claude",
     codexPath: process.env.ALOOK_CODEX_PATH || "codex",
     opencodePath: process.env.ALOOK_OPENCODE_PATH || "opencode",
@@ -17329,7 +17351,7 @@ function registerCommand() {
   const cmd = new Command("register").description("Register CLI with your Alook account").requiredOption("--token <token>", "API token (starts with al_)").option("--server <url>", "Server URL").option("--profile <name>", "Profile name").action(async (opts, command) => {
     const token = opts.token;
     const profile = opts.profile || command.parent?.opts().profile;
-    const serverUrl = opts.server || command.parent?.opts().server || process.env.ALOOK_SERVER_URL || "https://alook.ai";
+    const serverUrl = opts.server || command.parent?.opts().server || getServerUrl();
     if (!token) {
       console.error(`Error: --token is required
 Usage: ${cmdPrefix()} register --token <token>`);
@@ -17457,10 +17479,55 @@ if (process.argv.includes("--__login-poll")) {
   }
   pollAndActivate(data).catch(() => process.exit(1));
 }
+async function checkExistingAuth(serverUrl, profile) {
+  const config2 = loadCLIConfigForProfile(profile);
+  const workspaces = config2.watched_workspaces || [];
+  if (workspaces.length === 0) {
+    return { valid: false };
+  }
+  const ws = workspaces[0];
+  if (!ws.token) {
+    return { valid: false };
+  }
+  try {
+    const res = await fetch(`${serverUrl}/api/workspaces`, {
+      headers: { Authorization: `Bearer ${ws.token}` }
+    });
+    if (!res.ok) {
+      return { valid: false };
+    }
+    let email3;
+    try {
+      const meRes = await fetch(`${serverUrl}/api/me`, {
+        headers: { Authorization: `Bearer ${ws.token}` }
+      });
+      if (meRes.ok) {
+        const me = await meRes.json();
+        email3 = me.email;
+      }
+    } catch {}
+    return { valid: true, email: email3, workspaceName: ws.name };
+  } catch {
+    return { valid: false };
+  }
+}
 function loginCommand() {
-  const cmd = new Command2("login").description("Log in to Alook via browser (device code flow)").option("--server <url>", "Server URL").option("--profile <name>", "Profile name").action(async (opts, command) => {
+  const cmd = new Command2("login").description("Log in to Alook via browser (device code flow)").option("--server <url>", "Server URL").option("--profile <name>", "Profile name").option("--force", "Re-authenticate even if already logged in").action(async (opts, command) => {
     const profile = opts.profile || command.parent?.opts().profile;
-    const serverUrl = opts.server || command.parent?.opts().server || process.env.ALOOK_SERVER_URL || "https://alook.ai";
+    const serverUrl = opts.server || command.parent?.opts().server || getServerUrl();
+    if (!opts.force) {
+      const existing = await checkExistingAuth(serverUrl, profile);
+      if (existing.valid) {
+        const parts = ["Already logged in"];
+        if (existing.email)
+          parts[0] += ` as ${existing.email}`;
+        if (existing.workspaceName)
+          parts[0] += ` (workspace: ${existing.workspaceName})`;
+        parts[0] += ".";
+        console.log(parts[0]);
+        return;
+      }
+    }
     console.log("Requesting device code...");
     let deviceResp;
     try {
@@ -17501,7 +17568,7 @@ function loginCommand() {
       });
       child.unref();
       console.log("  Polling for authorization in the background (timeout: 5min).");
-      console.log("  Once approved, run `npx @alook/cli status` to verify.");
+      console.log(`  Once approved, run \`${cmdPrefix()} status\` to verify.`);
       return;
     }
     openBrowser(verificationUrl);
@@ -17699,6 +17766,68 @@ function createHealthServer(port = DEFAULT_HEALTH_PORT) {
 import { spawn as spawn2 } from "child_process";
 import { createInterface } from "readline";
 
+// daemon/kill-tree.ts
+import { execSync as execSync2 } from "child_process";
+var log3 = 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 {
+      execSync2(`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)) {
+    log3.warn(`pid=${pid} survived SIGTERM after ${graceMs}ms — escalating to SIGKILL`);
+    signalTree(pid, "SIGKILL");
+  }
+}
+
+// daemon/agent/claude.ts
 class ClaudeBackend {
   cliPath;
   name = "claude";
@@ -17729,7 +17858,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?`;
@@ -17746,7 +17876,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();
@@ -17998,7 +18129,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?`;
@@ -18015,7 +18147,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();
@@ -18467,7 +18600,6 @@ class CodexBackend {
 // daemon/agent/opencode.ts
 import { spawn as spawn4 } from "child_process";
 import { createInterface as createInterface3 } from "readline";
-
 class OpenCodeBackend {
   cliPath;
   name = "opencode";
@@ -18488,7 +18620,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?`;
@@ -18505,7 +18638,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();
@@ -18721,7 +18855,7 @@ class OpenCodeBackend {
 }
 
 // daemon/agent/index.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function createBackend(provider, cliPath) {
   switch (provider) {
     case "claude":
@@ -18736,7 +18870,7 @@ function createBackend(provider, cliPath) {
 }
 async function detectVersion2(cliPath) {
   try {
-    return execSync2(`${cliPath} --version`, { encoding: "utf-8" }).trim();
+    return execSync3(`${cliPath} --version`, { encoding: "utf-8" }).trim();
   } catch {
     return "unknown";
   }
@@ -18814,55 +18948,55 @@ import {
 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.
+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;
@@ -18890,17 +19024,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++) {
@@ -18932,40 +19065,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).
@@ -18982,7 +19132,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.
@@ -18991,16 +19140,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.
@@ -19009,12 +19155,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
@@ -19031,7 +19175,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
@@ -19040,7 +19183,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:
@@ -19052,7 +19195,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.
@@ -19074,7 +19217,6 @@ Edit an existing event (preserves event id and recurring state):
 
 Delete an event:
 - Run '${cmdPrefix()} calendar delete --event_id <EVENT_ID>'
----
 `;
   return content;
 }
@@ -19201,7 +19343,7 @@ function releaseLock(lockPath) {
 }
 
 // daemon/execenv/timeline.ts
-var log3 = createLogger2({ module: "timeline" });
+var log4 = createLogger2({ module: "timeline" });
 function readJsonl(filePath) {
   let content;
   try {
@@ -19239,8 +19381,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);
@@ -19271,7 +19412,7 @@ async function initEntryAsync(timelineDir, entry) {
       acquired = acquireLock(lockPath);
     }
     if (!acquired) {
-      log3.debug(`Timeline initEntry: could not acquire lock for ${filename}`);
+      log4.debug(`Timeline initEntry: could not acquire lock for ${filename}`);
       return;
     }
     try {
@@ -19281,7 +19422,7 @@ async function initEntryAsync(timelineDir, entry) {
       releaseLock(lockPath);
     }
   } catch (err) {
-    log3.debug("Timeline initEntry failed", err);
+    log4.debug("Timeline initEntry failed", err);
   }
 }
 function updateEntry(timelineDir, taskId, updater) {
@@ -19291,7 +19432,7 @@ function updateEntry(timelineDir, taskId, updater) {
     try {
       const acquired = acquireLock(lockPath);
       if (!acquired) {
-        log3.debug(`Timeline updateEntry: lock held for ${filename}, skipping`);
+        log4.debug(`Timeline updateEntry: lock held for ${filename}, skipping`);
         continue;
       }
       try {
@@ -19324,10 +19465,10 @@ function updateEntry(timelineDir, taskId, updater) {
         releaseLock(lockPath);
       }
     } catch (err) {
-      log3.debug(`Timeline updateEntry failed for ${filename}`, err);
+      log4.debug(`Timeline updateEntry failed for ${filename}`, err);
     }
   }
-  log3.debug(`Timeline updateEntry: task_id ${taskId} not found in last 7 days`);
+  log4.debug(`Timeline updateEntry: task_id ${taskId} not found in last 7 days`);
 }
 function createTimelineEntry(taskId, prompt, type, sessionId, pid, provider, contextKey, detailedLog) {
   return {
@@ -19388,7 +19529,7 @@ function findRunningEntryByContextKey(timelineDir, contextKey, provider) {
 // 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 log5 = createLogger2({ module: "steering" });
 var INTENT_DIR_NAME = ".kill_intents";
 var STEERING_LOCK_DIR = ".steering_locks";
 var INTENT_STALE_MS = 10 * 60 * 1000;
@@ -19442,7 +19583,7 @@ function cleanupStaleIntents(baseDir) {
       const stat = statSync2(filePath);
       if (now - stat.mtimeMs > INTENT_STALE_MS) {
         unlinkSync3(filePath);
-        log4.debug(`Cleaned up stale kill intent for task ${intent.targetTaskId}`);
+        log5.debug(`Cleaned up stale kill intent for task ${intent.targetTaskId}`);
       }
     } catch {}
   }
@@ -19468,7 +19609,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;
   }
@@ -19531,7 +19678,7 @@ function buildPrompt(task, attachments) {
 }
 
 // daemon/session-runner.ts
-var log5 = createLogger2({ module: "session-runner" });
+var log6 = createLogger2({ module: "session-runner" });
 var ATTACHMENTS_BASE = tempDir("alook-attachments");
 async function writeMarkerFile(workspacesRoot, marker) {
   const dir = path.join(workspacesRoot, ".pending_completions");
@@ -19579,20 +19726,20 @@ async function reportToServer(fn, markerData, workspacesRoot) {
     } catch (e) {
       lastErr = e;
       if (isClientError(e)) {
-        log5.info(`server report for task ${markerData.taskId}: task already in terminal state (${e})`);
+        log6.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`);
+        log6.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}`);
+  log6.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}`);
+    log6.error(`marker write also failed for task ${markerData.taskId}: ${writeErr}`);
   }
 }
 function sanitizeFilename(name) {
@@ -19623,7 +19770,7 @@ async function downloadAttachments(client, token, workspaceId, taskId, attachmen
 }
 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"})`);
+  log6.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");
@@ -19632,11 +19779,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) {
+      log6.debug("message report failed", e);
+    }
+  };
+  const onKill = async () => {
     if (killed)
       return;
     killed = true;
-    log5.info(`killed by signal (messages=0, tools=0)`);
+    log6.info(`killed by signal (messages=${seq}, tools=${toolCount})`);
+    if (agentPid !== undefined) {
+      log6.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);
@@ -19667,34 +19840,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) {
-    log5.info(`downloading ${attachmentIds.length} attachment(s)`);
+    log6.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))`);
+      log6.info(`attachments ready (${attachments.length} file(s))`);
     } catch (e) {
       await cleanupAttachments(task.id);
       const errMsg = `failed to download attachments: ${e}`;
-      log5.error(errMsg);
+      log6.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) {
-    log5.info(`resuming session ${resumeSessionId} (context_key: ${task.contextKey})`);
+    log6.info(`resuming session ${resumeSessionId} (context_key: ${task.contextKey})`);
   }
   const session2 = backend.execute(prompt, {
     cwd: workDir,
@@ -19703,77 +19878,21 @@ async function runSession(input) {
     timeout: agentTimeout,
     resumeSessionId
   });
-  const agentPid = session2.pid;
+  agentPid = session2.pid;
+  if (killed) {
+    if (agentPid !== undefined) {
+      log6.info(`kill landed during spawn — reaping inner agent group (pid=${agentPid})`);
+      await killProcessTree(agentPid);
+    }
+    process.exit(1);
+  }
   const earlySessionId = await session2.sessionId;
-  log5.info(`agent started (pid=${agentPid ?? "unknown"}, session=${earlySessionId})`);
-  log5.info(JSON.stringify({ role: "user", type: "text", content: prompt }));
+  log6.info(`agent started (pid=${agentPid ?? "unknown"}, session=${earlySessionId})`);
+  log6.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);
+  flushTimer = setInterval(flushMessages, FLUSH_INTERVAL_MS);
   const INACTIVITY_TIMEOUT_MS = messageInactivityTimeout ?? 5 * 60 * 1000;
   let inactivityTimedOut = false;
   try {
@@ -19789,11 +19908,9 @@ async function runSession(input) {
       ]) : 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 {}
+        log6.warn(`message inactivity timeout (${INACTIVITY_TIMEOUT_MS / 1000}s) — killing agent`);
+        if (session2.pid !== undefined) {
+          await killProcessTree(session2.pid);
         }
         iter.return?.(undefined);
         break;
@@ -19806,9 +19923,9 @@ async function runSession(input) {
       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)` }));
+        log6.info(JSON.stringify({ role: "assistant", ...msg, output: msg.output.slice(0, 500) + `... (${msg.output.length} chars)` }));
       } else {
-        log5.info(JSON.stringify({ role: "assistant", ...msg }));
+        log6.info(JSON.stringify({ role: "assistant", ...msg }));
       }
       if (msg.type === "status" || msg.type === "log")
         continue;
@@ -19833,14 +19950,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);
@@ -19872,18 +19986,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);
-    log5.info(`completed (duration=${dur}s, messages=${seq}, tools=${toolCount})`);
+    log6.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}`);
+    log6.info(`failed (duration=${dur}s, messages=${seq}, tools=${toolCount}) — ${result.error}`);
   }
 }
 async function main() {
   const encoded = process.argv[2];
   if (!encoded) {
-    log5.error("session-runner: missing base64-encoded input argument");
+    log6.error("session-runner: missing base64-encoded input argument");
     process.exit(1);
   }
   let input;
@@ -19891,14 +20005,14 @@ async function main() {
     const json2 = Buffer.from(encoded, "base64").toString("utf-8");
     input = JSON.parse(json2);
   } catch (e) {
-    log5.error("session-runner: failed to parse input", e);
+    log6.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);
+    log6.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) => {
@@ -19917,7 +20031,7 @@ if (isDirectExecution) {
 }
 
 // daemon/ws-client.ts
-var log6 = createLogger2({ module: "ws-client" });
+var log7 = createLogger2({ module: "ws-client" });
 var WS_RECONNECT_INIT = 1000;
 var WS_RECONNECT_MAX = 30000;
 var WS_PING_INTERVAL = 25000;
@@ -19954,11 +20068,11 @@ class DaemonWsClient {
       return;
     this.cleanup();
     const wsUrl = this.getUrl();
-    log6.info("connecting", { url: wsUrl });
+    log7.info("connecting", { url: wsUrl });
     try {
       this.ws = new WebSocket(wsUrl);
     } catch (err) {
-      log6.warn("ws creation failed", { err: String(err) });
+      log7.warn("ws creation failed", { err: String(err) });
       this.scheduleReconnect();
       return;
     }
@@ -19980,23 +20094,23 @@ class DaemonWsClient {
       try {
         const msg = JSON.parse(str);
         if (msg.type === "auth.ok") {
-          log6.info("authenticated");
+          log7.info("authenticated");
           this.connected = true;
           this.opts.onConnected();
           return;
         }
         const parsed = DaemonPushMessageSchema.safeParse(msg);
         if (!parsed.success) {
-          log6.warn("invalid push message", { err: parsed.error.message });
+          log7.warn("invalid push message", { err: parsed.error.message });
           return;
         }
         this.opts.onMessage(parsed.data);
       } catch (err) {
-        log6.debug("message parse error", { err: String(err) });
+        log7.debug("message parse error", { err: String(err) });
       }
     });
     this.ws.addEventListener("error", () => {
-      log6.debug("ws error");
+      log7.debug("ws error");
     });
     this.ws.addEventListener("close", () => {
       const wasConnected = this.connected;
@@ -20034,7 +20148,7 @@ class DaemonWsClient {
     const delay = Math.min(this.reconnectDelay, WS_RECONNECT_MAX);
     this.reconnectDelay = Math.min(delay * 2, WS_RECONNECT_MAX);
     const jitter = Math.random() * 500;
-    log6.debug("reconnecting", { delayMs: Math.round(delay + jitter) });
+    log7.debug("reconnecting", { delayMs: Math.round(delay + jitter) });
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connect();
@@ -20048,7 +20162,7 @@ class DaemonWsClient {
     }, WS_PING_INTERVAL);
     this.livenessInterval = setInterval(() => {
       if (Date.now() - this.lastMessageAt > WS_LIVENESS_TIMEOUT) {
-        log6.warn("liveness timeout, closing");
+        log7.warn("liveness timeout, closing");
         this.ws?.close();
       }
     }, 5000);
@@ -20096,7 +20210,7 @@ function runNpmUpdate(targetVersion) {
 }
 
 // daemon/update-handler.ts
-var log7 = createLogger2({ module: "updater" });
+var log8 = createLogger2({ module: "updater" });
 var updating = false;
 var retryCount = 0;
 var MAX_RETRIES = 3;
@@ -20126,29 +20240,29 @@ async function handleCliUpdate(version3, onSuccess, profile) {
   if (retryCount >= MAX_RETRIES)
     return;
   if (process.env.ALOOK_CMD_PREFIX) {
-    log7.info(`Skipping auto-update in app mode — user should run: npx @alook/app@latest update`);
+    log8.info(`Skipping auto-update in app mode — user should run: npx @alook/app@latest update`);
     return;
   }
   const marker = readUpdateMarker(profile);
   if (marker === version3) {
-    log7.info(`Skipping update to v${version3} — already attempted (marker exists)`);
+    log8.info(`Skipping update to v${version3} — already attempted (marker exists)`);
     return;
   }
   updating = true;
   try {
-    log7.info(`Updating CLI to v${version3}...`);
+    log8.info(`Updating CLI to v${version3}...`);
     const result = await runNpmUpdate(version3);
     if (result.success) {
       writeUpdateMarker(version3, profile);
-      log7.info(`CLI updated to v${version3} — restarting`);
+      log8.info(`CLI updated to v${version3} — restarting`);
       onSuccess();
     } else {
       retryCount++;
-      log7.error(`CLI update failed (attempt ${retryCount}/${MAX_RETRIES}): ${result.output}`);
+      log8.error(`CLI update failed (attempt ${retryCount}/${MAX_RETRIES}): ${result.output}`);
     }
   } catch (e) {
     retryCount++;
-    log7.error(`CLI update error (attempt ${retryCount}/${MAX_RETRIES})`, e);
+    log8.error(`CLI update error (attempt ${retryCount}/${MAX_RETRIES})`, e);
   } finally {
     updating = false;
   }
@@ -20257,7 +20371,7 @@ import { existsSync as existsSync2, mkdirSync as mkdirSync7, readFileSync as rea
 import { join as join10, basename } from "path";
 import { homedir as homedir2 } from "os";
 import { createHash as createHash2 } from "crypto";
-var log8 = createLogger2({ module: "skill-scanner" });
+var log9 = createLogger2({ module: "skill-scanner" });
 function getCacheDir() {
   return join10(configDir(), "skills");
 }
@@ -20543,7 +20657,7 @@ function runScan() {
       const prevHash = readCacheHash(globalCachePath(scannerConfig.daemonId, runtime));
       if (prevHash !== hash2) {
         const skillItems = skills.map((s) => ({ name: s.name, description: s.description }));
-        log8.debug(`Syncing global ${runtime} — ${skills.length} skills`);
+        log9.debug(`Syncing global ${runtime} — ${skills.length} skills`);
         const daemonId = scannerConfig.daemonId;
         const syncPromises = scannerConfig.workspaces.map((ws) => clientRef.syncSkills(ws.token, {
           scope: "global",
@@ -20553,10 +20667,10 @@ function runScan() {
         }));
         Promise.all(syncPromises).then(() => {
           writeCacheFile(globalCachePath(daemonId, runtime), hash2, skills);
-        }).catch((e) => log8.debug("Global skill sync failed", e));
+        }).catch((e) => log9.debug("Global skill sync failed", e));
       }
     } catch (e) {
-      log8.debug(`Global scan error for ${runtime}`, e);
+      log9.debug(`Global scan error for ${runtime}`, e);
     }
   }
   const targets = discoverTargets();
@@ -20569,7 +20683,7 @@ function runScan() {
       const prevHash = readCacheHash(agentCachePath(target.agentId, target.runtime));
       if (prevHash !== hash2) {
         const skillItems = skills.map((s) => ({ name: s.name, description: s.description }));
-        log8.debug(`Syncing ${target.agentId}:${target.runtime} — ${skills.length} agent skills`);
+        log9.debug(`Syncing ${target.agentId}:${target.runtime} — ${skills.length} agent skills`);
         clientRef.syncSkills(target.token, {
           scope: "agent",
           agent_id: target.agentId,
@@ -20577,10 +20691,10 @@ function runScan() {
           skills: skillItems
         }).then(() => {
           writeCacheFile(agentCachePath(target.agentId, target.runtime), hash2, skills);
-        }).catch((e) => log8.debug("Agent skill sync failed", e));
+        }).catch((e) => log9.debug("Agent skill sync failed", e));
       }
     } catch (e) {
-      log8.debug(`Agent scan error for ${target.agentId}:${target.runtime}`, e);
+      log9.debug(`Agent scan error for ${target.agentId}:${target.runtime}`, e);
     }
   }
 }
@@ -20598,7 +20712,7 @@ function stopSkillScanner() {
 }
 
 // lib/shell-env.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var PASSTHROUGH_VARS = ["ALOOK_PROJECT_ROOT", "ALOOK_SERVER_URL", "ALOOK_CMD_PREFIX", "ALOOK_HEALTH_PORT"];
 function resolveLoginShellEnv() {
   if (isWindows) {
@@ -20606,7 +20720,7 @@ function resolveLoginShellEnv() {
   }
   const shell = process.env.SHELL || "/bin/zsh";
   try {
-    const output = execSync3(`${shell} -ilc 'env'`, {
+    const output = execSync4(`${shell} -ilc 'env'`, {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["ignore", "pipe", "ignore"]
@@ -20633,17 +20747,17 @@ function resolveLoginShellEnv() {
 // daemon/daemon.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync8, openSync, closeSync, readdirSync as readdirSync3, statSync as statSync4, 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 spawn6 } from "child_process";
+import { execSync as execSync5, spawn as spawn6 } from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { dirname as dirname3, join as join11 } from "path";
-var log9 = createLogger2({ module: "daemon" });
+var log10 = createLogger2({ module: "daemon" });
 var _dir = dirname3(fileURLToPath3(import.meta.url));
 var sessionRunnerPath = existsSync3(join11(_dir, "session-runner.js")) ? join11(_dir, "session-runner.js") : join11(_dir, "session-runner.ts");
 var meetingRunnerPath = existsSync3(join11(_dir, "meeting-runner.js")) ? join11(_dir, "meeting-runner.js") : join11(_dir, "meeting-runner.ts");
 function isCommandAvailable2(cmd) {
   try {
     const check2 = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync4(check2, { stdio: "ignore" });
+    execSync5(check2, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -20743,14 +20857,14 @@ async function reconcilePendingCompletions(workspacesRoot) {
       try {
         parsed = JSON.parse(raw);
       } catch {
-        log9.warn(`reconcile: malformed marker ${name}, deleting`);
+        log10.warn(`reconcile: malformed marker ${name}, deleting`);
         try {
           await unlink(filePath);
         } catch {}
         continue;
       }
       if (!isValidMarker(parsed)) {
-        log9.warn(`reconcile: invalid marker structure ${name}, deleting`);
+        log10.warn(`reconcile: invalid marker structure ${name}, deleting`);
         try {
           await unlink(filePath);
         } catch {}
@@ -20759,7 +20873,7 @@ async function reconcilePendingCompletions(workspacesRoot) {
       const marker = parsed;
       const age = Date.now() - new Date(marker.createdAt).getTime();
       if (age > MARKER_STALE_MS) {
-        log9.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
+        log10.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
         try {
           await unlink(filePath);
         } catch {}
@@ -20775,7 +20889,7 @@ async function reconcilePendingCompletions(workspacesRoot) {
         try {
           await unlink(filePath);
         } catch (delErr) {
-          log9.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
+          log10.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
         }
       } catch (deliverErr) {
         if (isClientError2(deliverErr)) {
@@ -20783,11 +20897,11 @@ async function reconcilePendingCompletions(workspacesRoot) {
             await unlink(filePath);
           } catch {}
         } else {
-          log9.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
+          log10.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
         }
       }
     } catch (e) {
-      log9.debug(`reconcile: error processing ${name}`, e);
+      log10.debug(`reconcile: error processing ${name}`, e);
     }
   }
 }
@@ -20798,7 +20912,7 @@ async function startDaemon(profile, serverUrl) {
   }
   process.once("exit", () => releaseDaemonPid(profile));
   const bailOnUnexpected = (label, err) => {
-    log9.error(`${label} — shutting down`, err);
+    log10.error(`${label} — shutting down`, err);
     releaseDaemonPid(profile);
     process.exit(1);
   };
@@ -20811,21 +20925,21 @@ async function startDaemon(profile, serverUrl) {
   if (marker) {
     clearUpdateMarker(profile);
     if (marker === config2.cliVersion) {
-      log9.info(`Cleared update marker — now running v${config2.cliVersion}`);
+      log10.info(`Cleared update marker — now running v${config2.cliVersion}`);
     } else {
-      log9.info(`Cleared stale update marker (was v${marker}, running v${config2.cliVersion}) — update will be retried`);
+      log10.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) {
-    log9.error("No watched workspaces configured.");
+    log10.error("No watched workspaces configured.");
     process.exit(1);
     return;
   }
   const hasPerWorkspaceTokens = workspaces.every((ws) => !!ws.token);
   if (!hasPerWorkspaceTokens) {
-    log9.error(`Config uses old format. Run '${cmdPrefix()} register --token <token>' for each workspace to upgrade.`);
+    log10.error(`Config uses old format. Run '${cmdPrefix()} register --token <token>' for each workspace to upgrade.`);
     process.exit(1);
     return;
   }
@@ -20845,11 +20959,11 @@ async function startDaemon(profile, serverUrl) {
     }
   }
   if (providers.length === 0) {
-    log9.error("No agent CLI tools found on PATH.");
+    log10.error("No agent CLI tools found on PATH.");
     process.exit(1);
     return;
   }
-  log9.info(`Detected providers: ${providers.map((p) => `${p.type}@${p.version}`).join(", ")}`);
+  log10.info(`Detected providers: ${providers.map((p) => `${p.type}@${p.version}`).join(", ")}`);
   const workspaceStates = [];
   const runtimeIndex = new Map;
   for (const ws of workspaces) {
@@ -20857,7 +20971,7 @@ async function startDaemon(profile, serverUrl) {
       type: p.type,
       version: p.version
     }));
-    log9.info(`Registering workspace ${ws.id} (${ws.name ?? "unnamed"}) with ${runtimes.length} runtime(s)...`);
+    log10.info(`Registering workspace ${ws.id} (${ws.name ?? "unnamed"}) with ${runtimes.length} runtime(s)...`);
     let resp;
     try {
       resp = await client.register(ws.token, {
@@ -20870,13 +20984,13 @@ async function startDaemon(profile, serverUrl) {
       });
     } catch (e) {
       if (e instanceof Error && e.message.startsWith("HTTP 401")) {
-        log9.warn(`Workspace ${ws.id} token invalid — skipping (run '${cmdPrefix()} register --token <token>' to fix)`);
+        log10.warn(`Workspace ${ws.id} token invalid — skipping (run '${cmdPrefix()} register --token <token>' to fix)`);
       } else {
-        log9.error(`Failed to register workspace ${ws.id}, skipping`, e);
+        log10.error(`Failed to register workspace ${ws.id}, skipping`, e);
       }
       continue;
     }
-    log9.info(`Workspace ${ws.id} registered — ${resp.runtimes.length} runtime(s)`);
+    log10.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++) {
@@ -20888,13 +21002,13 @@ async function startDaemon(profile, serverUrl) {
     }
   }
   if (workspaceStates.length === 0) {
-    log9.error("No workspaces registered successfully.");
+    log10.error("No workspaces registered successfully.");
     process.exit(1);
     return;
   }
   const allRuntimeIds = workspaceStates.flatMap((ws) => ws.runtimeIds);
   health.setRuntimeCount(allRuntimeIds.length);
-  log9.info(`Daemon started — ${allRuntimeIds.length} runtime(s) across ${workspaceStates.length} workspace(s)`);
+  log10.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) {
@@ -20929,7 +21043,7 @@ async function startDaemon(profile, serverUrl) {
       cfg.watched_workspaces = (cfg.watched_workspaces || []).filter((w) => w.id !== workspaceId);
       saveCLIConfigForProfile(profile, cfg);
     } catch {}
-    log9.info(`Workspace ${workspaceId} deleted server-side — removed from config`);
+    log10.info(`Workspace ${workspaceId} deleted server-side — removed from config`);
   }
   const pollCycle = async () => {
     let remaining = config2.maxConcurrentTasks - activeTasks.size;
@@ -20955,7 +21069,7 @@ async function startDaemon(profile, serverUrl) {
           handleCliUpdate(pending_update.version, () => requestRestart(), profile);
         }
         if (pending_rescan) {
-          log9.info("Rescan requested — restarting daemon to re-detect runtimes");
+          log10.info("Rescan requested — restarting daemon to re-detect runtimes");
           for (const id of evictedIds) {
             evictWorkspace(id);
           }
@@ -20968,13 +21082,13 @@ async function startDaemon(profile, serverUrl) {
           activeTasks.add(task.id);
           remaining--;
           handleTask(client, config2, runtimeIndex, task, ws.token, activeTasks).catch((e) => {
-            log9.error("Task error", e);
+            log10.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) => log9.debug("File request error", e));
+            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log10.debug("File request error", e));
           }
         }
         if (meetings) {
@@ -20997,9 +21111,9 @@ async function startDaemon(profile, serverUrl) {
         }
       } catch (e) {
         if (e instanceof Error && e.message.startsWith("HTTP 401")) {
-          log9.warn(`Workspace ${ws.workspaceId} poll returned 401 — will retry next cycle`);
+          log10.warn(`Workspace ${ws.workspaceId} poll returned 401 — will retry next cycle`);
         } else {
-          log9.debug("Poll error", e);
+          log10.debug("Poll error", e);
         }
       }
     }
@@ -21007,7 +21121,7 @@ async function startDaemon(profile, serverUrl) {
       evictWorkspace(id);
     }
     if (workspaceStates.length === 0) {
-      log9.info("All workspaces evicted — shutting down");
+      log10.info("All workspaces evicted — shutting down");
       shutdown();
     }
   };
@@ -21015,7 +21129,7 @@ async function startDaemon(profile, serverUrl) {
   const heartbeatPing = () => {
     for (const ws of workspaceStates) {
       client.heartbeat(ws.token, config2.daemonId).catch((e) => {
-        log9.debug("heartbeat failed", { workspaceId: ws.workspaceId, err: String(e) });
+        log10.debug("heartbeat failed", { workspaceId: ws.workspaceId, err: String(e) });
       });
     }
   };
@@ -21041,7 +21155,7 @@ async function startDaemon(profile, serverUrl) {
           syncAgentId(task.agentId, ws.workspaceId);
           activeTasks.add(task.id);
           handleTask(client, config2, runtimeIndex, task, ws.token, activeTasks).catch((e) => {
-            log9.error("WS task error", e);
+            log10.error("WS task error", e);
             activeTasks.delete(task.id);
           });
         }
@@ -21050,7 +21164,7 @@ async function startDaemon(profile, serverUrl) {
         const ws = wsMap.get(msg.workspaceId);
         if (ws) {
           for (const req of msg.requests) {
-            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log9.debug("WS file request error", e));
+            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log10.debug("WS file request error", e));
           }
         }
         break;
@@ -21085,7 +21199,7 @@ async function startDaemon(profile, serverUrl) {
         }
         break;
       case "daemon.rescan":
-        log9.info("WS rescan requested — restarting daemon");
+        log10.info("WS rescan requested — restarting daemon");
         requestRestart();
         break;
       case "daemon.kill": {
@@ -21113,7 +21227,7 @@ async function startDaemon(profile, serverUrl) {
           });
           activeTasks.add(killTask.id);
           handleTask(client, config2, runtimeIndex, killTask, ws.token, activeTasks).catch((e) => {
-            log9.error("WS kill task error", e);
+            log10.error("WS kill task error", e);
             activeTasks.delete(killTask.id);
           });
         }
@@ -21127,11 +21241,11 @@ async function startDaemon(profile, serverUrl) {
     machineToken: firstToken,
     onMessage: handleWsPush,
     onConnected: () => {
-      log9.info("WS connected — switching to low-frequency poll");
+      log10.info("WS connected — switching to low-frequency poll");
       updatePollInterval(config2.wsPollInterval);
     },
     onDisconnected: () => {
-      log9.info("WS disconnected — reverting to high-frequency poll");
+      log10.info("WS disconnected — reverting to high-frequency poll");
       updatePollInterval(config2.pollInterval);
     }
   }) : null;
@@ -21139,13 +21253,13 @@ async function startDaemon(profile, serverUrl) {
   const sweepTick = async () => {
     for (const ws of workspaceStates) {
       client.sweep(ws.token, config2.daemonId).catch((e) => {
-        log9.debug("sweep ping failed", { workspaceId: ws.workspaceId, err: String(e) });
+        log10.debug("sweep ping failed", { workspaceId: ws.workspaceId, err: String(e) });
       });
     }
     try {
       await reconcilePendingCompletions(config2.workspacesRoot);
     } catch (e) {
-      log9.debug("reconciliation error", e);
+      log10.debug("reconciliation error", e);
     }
   };
   const sweepTimer = setInterval(sweepTick, config2.sweepInterval);
@@ -21169,7 +21283,7 @@ async function startDaemon(profile, serverUrl) {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log9.info(restartRequested ? "Restarting..." : "Shutting down...");
+    log10.info(restartRequested ? "Restarting..." : "Shutting down...");
     clearInterval(pollTimer);
     clearInterval(heartbeatTimer);
     clearInterval(sweepTimer);
@@ -21197,7 +21311,7 @@ async function startDaemon(profile, serverUrl) {
           mkdirSync8(dirname3(logPath), { recursive: true, mode: 448 });
           logFd = openSync(logPath, "a", 384);
         } catch (e) {
-          log9.error(`Failed to open daemon log file ${logPath}`, e);
+          log10.error(`Failed to open daemon log file ${logPath}`, e);
         }
         const child = spawn6(process.execPath, args, {
           detached: true,
@@ -21207,7 +21321,7 @@ async function startDaemon(profile, serverUrl) {
         child.unref();
         if (logFd != null)
           closeSync(logFd);
-        log9.info(`Spawned new daemon (pid=${child.pid}), logs: ${logPath}`);
+        log10.info(`Spawned new daemon (pid=${child.pid}), logs: ${logPath}`);
       }
       clearTimeout(timeout);
       process.exit(0);
@@ -21218,7 +21332,7 @@ async function startDaemon(profile, serverUrl) {
   process.on("SIGHUP", async () => {
     if (shuttingDown)
       return;
-    log9.info("SIGHUP received — reloading config...");
+    log10.info("SIGHUP received — reloading config...");
     try {
       const freshConfig = loadCLIConfigForProfile(profile);
       const freshWorkspaces = freshConfig.watched_workspaces || [];
@@ -21226,7 +21340,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 }));
-        log9.info(`Registering new workspace ${ws.id} (${ws.name ?? "unnamed"})...`);
+        log10.info(`Registering new workspace ${ws.id} (${ws.name ?? "unnamed"})...`);
         try {
           const resp = await client.register(ws.token, {
             workspace_id: ws.id,
@@ -21245,19 +21359,19 @@ async function startDaemon(profile, serverUrl) {
               provider: providers[i].type
             });
           }
-          log9.info(`Workspace ${ws.id} added — ${runtimeIds.length} runtime(s)`);
+          log10.info(`Workspace ${ws.id} added — ${runtimeIds.length} runtime(s)`);
         } catch (e) {
-          log9.error(`Failed to register new workspace ${ws.id}`, e);
+          log10.error(`Failed to register new workspace ${ws.id}`, e);
         }
       }
       if (newWorkspaces.length > 0) {
         health.setRuntimeCount(workspaceStates.reduce((sum, w) => sum + w.runtimeIds.length, 0));
-        log9.info(`Reload complete — now polling ${workspaceStates.length} workspace(s)`);
+        log10.info(`Reload complete — now polling ${workspaceStates.length} workspace(s)`);
       } else {
-        log9.info("Reload complete — no new workspaces found");
+        log10.info("Reload complete — no new workspaces found");
       }
     } catch (e) {
-      log9.error("Failed to reload config", e);
+      log10.error("Failed to reload config", e);
     }
   });
   await pollCycle();
@@ -21272,7 +21386,7 @@ function spawnSessionRunner(input) {
   try {
     fd = openSync(logFilePath, "a");
   } catch (e) {
-    log9.error(`Failed to open log file ${logFilePath}`, e);
+    log10.error(`Failed to open log file ${logFilePath}`, e);
   }
   const child = spawn6(process.execPath, [sessionRunnerPath, encoded], {
     detached: true,
@@ -21292,7 +21406,7 @@ function spawnMeetingRunner(input) {
   try {
     fd = openSync(logFilePath, "a");
   } catch (e) {
-    log9.error(`Failed to open meeting log file ${logFilePath}`, e);
+    log10.error(`Failed to open meeting log file ${logFilePath}`, e);
   }
   const child = spawn6(process.execPath, [meetingRunnerPath, encoded], {
     detached: true,
@@ -21301,7 +21415,7 @@ function spawnMeetingRunner(input) {
   child.unref();
   if (fd != null)
     closeSync(fd);
-  log9.info(`Spawned meeting runner for ${input.meetingId} (pid=${child.pid})`);
+  log10.info(`Spawned meeting runner for ${input.meetingId} (pid=${child.pid})`);
   return child;
 }
 async function handleFileRequest(client, config2, workspaceId, req, token) {
@@ -21327,8 +21441,31 @@ async function handleFileRequest(client, config2, workspaceId, req, token) {
     });
   }
 }
+async function killAndVerify(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (e) {
+    if (e?.code === "ESRCH")
+      return false;
+    throw e;
+  }
+  const verifyMs = Math.max(Number(process.env.ALOOK_KILL_VERIFY_MS) || 3000, killGraceMs() + 500);
+  const deadline = Date.now() + verifyMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid))
+      return true;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (isAlive(pid)) {
+    log10.warn(`session-runner pid=${pid} survived SIGTERM after ${verifyMs}ms — escalating to SIGKILL`);
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }
+  return true;
+}
 async function handleTask(client, config2, runtimeIndex, task, token, activeTasks) {
-  log9.info(`Task ${task.id} claimed agent=${task.agentId}`);
+  log10.info(`Task ${task.id} claimed agent=${task.agentId}`);
   if (task.type === TASK_TYPES.KILL_TASK) {
     const targetTaskId = task.context?.target_task_id;
     if (!targetTaskId) {
@@ -21339,14 +21476,14 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
     const agentBaseDir = join11(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
     const timelineDir = join11(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 POLL_MS2 = Number(process.env.ALOOK_KILL_TASK_POLL_MS) || 200;
     const waitStart = Date.now();
     let pid = null;
     while (Date.now() - waitStart < MAX_WAIT_MS) {
       pid = findRunningPidByTaskId(timelineDir, targetTaskId);
       if (pid != null)
         break;
-      await new Promise((r) => setTimeout(r, POLL_MS));
+      await new Promise((r) => setTimeout(r, POLL_MS2));
     }
     if (pid != null) {
       writeKillIntent(agentBaseDir, {
@@ -21355,20 +21492,20 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
         expectedPid: pid
       });
       try {
-        process.kill(pid, "SIGTERM");
-        await client.failTask(token, task.id, "killed");
-        log9.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");
-          log9.info(`Kill task ${task.id}: target pid=${pid} already exited`);
+        const delivered = await killAndVerify(pid);
+        if (delivered) {
+          await client.failTask(token, task.id, "killed");
+          log10.info(`Kill task ${task.id}: terminated pid=${pid} for target=${targetTaskId}`);
         } else {
-          await client.failTask(token, task.id, `kill failed: ${e}`);
+          await client.failTask(token, task.id, "target process already exited");
+          log10.info(`Kill task ${task.id}: target pid=${pid} already exited`);
         }
+      } catch (e) {
+        await client.failTask(token, task.id, `kill failed: ${e}`);
       }
     } else {
       await client.failTask(token, task.id, "target not found in timeline");
-      log9.info(`Kill task ${task.id}: target ${targetTaskId} not found in timeline`);
+      log10.info(`Kill task ${task.id}: target ${targetTaskId} not found in timeline`);
     }
     activeTasks.delete(task.id);
     return;
@@ -21393,12 +21530,12 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
     const timelineDir = join11(agentBaseDir, ".context_timeline");
     const lockAcquired = acquireSteeringLock(agentBaseDir, task.contextKey);
     if (!lockAcquired) {
-      log9.warn(`Steering lock contention for context_key=${task.contextKey}, proceeding without steering`);
+      log10.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) {
-          log9.info(`Steering: task ${task.id} supersedes predecessor ${predecessor.task_id} (context_key=${task.contextKey})`);
+          log10.info(`Steering: task ${task.id} supersedes predecessor ${predecessor.task_id} (context_key=${task.contextKey})`);
           if (predecessor.pid != null) {
             writeKillIntent(agentBaseDir, {
               reason: "superseded",
@@ -21407,33 +21544,29 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
               successorTaskId: task.id
             });
             try {
-              process.kill(predecessor.pid, "SIGTERM");
-              log9.info(`Steering: sent SIGTERM to predecessor pid=${predecessor.pid}`);
+              const delivered = await killAndVerify(predecessor.pid);
+              log10.info(delivered ? `Steering: terminated predecessor pid=${predecessor.pid}` : `Steering: predecessor pid=${predecessor.pid} already exited`);
             } catch (e) {
-              if (e?.code === "ESRCH") {
-                log9.info(`Steering: predecessor pid=${predecessor.pid} already exited`);
-              } else {
-                log9.warn(`Steering: kill failed for pid=${predecessor.pid}`, e);
-              }
+              log10.warn(`Steering: kill failed for pid=${predecessor.pid}`, e);
             }
             const waitStart = Date.now();
             const MAX_WAIT_MS = 15000;
-            const POLL_MS = 200;
+            const POLL_MS2 = 200;
             while (Date.now() - waitStart < MAX_WAIT_MS) {
               const stillRunning = findRunningPidByTaskId(timelineDir, predecessor.task_id);
               if (stillRunning == null)
                 break;
-              await new Promise((r) => setTimeout(r, POLL_MS));
+              await new Promise((r) => setTimeout(r, POLL_MS2));
             }
             if (findRunningPidByTaskId(timelineDir, predecessor.task_id) != null) {
-              log9.warn(`Steering: predecessor pid=${predecessor.pid} did not exit within ${MAX_WAIT_MS}ms, proceeding anyway`);
+              log10.warn(`Steering: predecessor pid=${predecessor.pid} did not exit within ${MAX_WAIT_MS}ms, proceeding anyway`);
             }
           }
           try {
             await client.supersedeTask(token, predecessor.task_id);
-            log9.info(`Steering: predecessor ${predecessor.task_id} marked superseded`);
+            log10.info(`Steering: predecessor ${predecessor.task_id} marked superseded`);
           } catch (e) {
-            log9.warn(`Steering: failed to mark predecessor superseded server-side`, e);
+            log10.warn(`Steering: failed to mark predecessor superseded server-side`, e);
           }
         }
       } finally {
@@ -21463,12 +21596,12 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
       const agentBaseDir = join11(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir");
       const killIntent = readKillIntent(agentBaseDir, task.id);
       if (killIntent) {
-        log9.info(`Task ${task.id} exited due to kill intent — skipping failTask`);
+        log10.info(`Task ${task.id} exited due to kill intent — skipping failTask`);
         clearKillIntent(agentBaseDir, task.id);
         return;
       }
       const msg = code === null ? `session-runner killed by signal (task ${task.id})` : `session-runner crashed (exit code ${code}, task ${task.id})`;
-      log9.warn(msg);
+      log10.warn(msg);
       const timelineDir = join11(agentBaseDir, ".context_timeline");
       updateEntry(timelineDir, task.id, (entry) => {
         entry.pid = null;
@@ -21479,10 +21612,10 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
         await client.failTask(token, task.id, msg);
       } catch (e) {
         if (isClientError2(e)) {
-          log9.info(`Backstop: task ${task.id} already in terminal state`);
+          log10.info(`Backstop: task ${task.id} already in terminal state`);
           return;
         }
-        log9.error(`Backstop: failed to report crash for task ${task.id}`, e);
+        log10.error(`Backstop: failed to report crash for task ${task.id}`, e);
         try {
           await writeMarkerFile(config2.workspacesRoot, {
             taskId: task.id,
@@ -21496,7 +21629,7 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
       }
     }
   });
-  log9.info(`Task ${task.id} dispatched to session-runner (pid=${child.pid})`);
+  log10.info(`Task ${task.id} dispatched to session-runner (pid=${child.pid})`);
 }
 
 // commands/daemon.ts
@@ -21806,7 +21939,7 @@ function gatherContextEnvVars() {
 }
 
 // commands/email.ts
-var log10 = createLogger2({ module: "email" });
+var log11 = createLogger2({ module: "email" });
 var VALID_STATUSES = ["unread", "read", "archived", "sent"];
 var VALID_FOLDERS = ["inbox", "sent", "untrust"];
 var EMAIL_BASE = tempDir("alook-emails");
@@ -21893,7 +22026,7 @@ function emailCommand() {
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           if (msg.includes("404")) {
-            log10.warn(`email body not available for ${email3.id}, skipping`);
+            log11.warn(`email body not available for ${email3.id}, skipping`);
             continue;
           }
           throw err;
@@ -21987,7 +22120,7 @@ function emailCommand() {
             references = [parentEmail.references, parentEmail.message_id].filter(Boolean).join(" ").trim() || undefined;
           }
         } catch {
-          log10.warn(`could not fetch parent email ${opts.inReplyTo}, sending without threading`);
+          log11.warn(`could not fetch parent email ${opts.inReplyTo}, sending without threading`);
         }
       }
       const ctx = gatherContextEnvVars();
@@ -22691,7 +22824,7 @@ function workspaceCommand() {
       process.exit(1);
     }
     if (runtimes.length === 0) {
-      console.error("Error: No daemon registered. Run 'npx @alook/cli daemon start' first.");
+      console.error(`Error: No daemon registered. Run '${cmdPrefix()} daemon start' first.`);
       process.exit(1);
     }
     const OFFLINE_THRESHOLD_MS2 = 5 * 60 * 1000;
@@ -22702,7 +22835,7 @@ function workspaceCommand() {
       const lastSeen = new Date(r.machineLastSeenAt.includes("Z") ? r.machineLastSeenAt : r.machineLastSeenAt + "Z").getTime();
       return now - lastSeen < OFFLINE_THRESHOLD_MS2;
     });
-    const runtime = onlineRuntime || runtimes[0];
+    let runtime = onlineRuntime || runtimes[0];
     let targetWorkspaceId = workspaceId;
     let targetClient = client;
     try {
@@ -22714,6 +22847,22 @@ function workspaceCommand() {
         targetWorkspaceId = newWs.id;
         targetClient = new APIClient(serverUrl, token, targetWorkspaceId);
         console.log(`Created workspace: ${newWs.name} (${newWs.id})`);
+        try {
+          const newRuntimes = await targetClient.getJSON("/api/runtimes");
+          if (newRuntimes.length > 0) {
+            const newOnlineRuntime = newRuntimes.find((r) => {
+              if (!r.machineLastSeenAt)
+                return false;
+              const lastSeen = new Date(r.machineLastSeenAt.includes("Z") ? r.machineLastSeenAt : r.machineLastSeenAt + "Z").getTime();
+              return now - lastSeen < OFFLINE_THRESHOLD_MS2;
+            });
+            runtime = newOnlineRuntime || newRuntimes[0];
+          } else {
+            await targetClient.postJSON("/api/runtimes", { id: runtime.id });
+          }
+        } catch (err) {
+          console.warn(`Warning: could not refresh runtimes for new workspace: ${err instanceof Error ? err.message : err}`);
+        }
       }
     } catch (err) {
       console.warn(`Warning: could not check existing agents: ${err instanceof Error ? err.message : err}`);
@@ -22735,9 +22884,11 @@ function workspaceCommand() {
 Workspace initialized: ${res.studio.name || res.workspace.name}`);
       console.log("Agents created:");
       for (const agent2 of res.agents) {
-        const email3 = agent2.email_handle ? `${agent2.email_handle}@alook.ai` : "no email";
+        const email3 = agent2.email_handle ? toAlookAddress(agent2.email_handle) : "no email";
         console.log(`  - ${agent2.name} (${email3})`);
       }
+      console.log(`
+  Open: ${serverUrl}/w/${res.workspace.slug}`);
     } catch (err) {
       console.error(`Error: failed to create workspace: ${err instanceof Error ? err.message : err}`);
       process.exit(1);