@alook/app 0.0.79 → 0.0.81

package/dist/cli/index.js

@@ -195,7 +195,7 @@ var TERMINAL_ISSUE_STATUSES = [
   IssueStatus.FAILED
 ];
 var POLL_INTERVAL_MS = Number(process.env.POLL_INTERVAL_MS) || 3000;
-var OFFLINE_THRESHOLD_MS = Number(process.env.OFFLINE_THRESHOLD_MS) || 9000;
+var OFFLINE_THRESHOLD_MS = Number(process.env.OFFLINE_THRESHOLD_MS) || 30000;
 var EVENT_POLL_INTERVAL_MS = Number(process.env.EVENT_POLL_INTERVAL_MS) || 2000;
 var MeetingStatus = {
   PENDING: "pending",
@@ -14567,6 +14567,9 @@ var TaskApiSchema = TaskApiBaseSchema.extend({
   agent: TaskAgentDataApiSchema.nullable().optional(),
   sender: TaskSenderApiSchema.nullable().optional()
 });
+var HeartbeatRequestSchema = exports_external.object({
+  daemon_id: exports_external.string().min(1)
+});
 var PollRequestSchema = exports_external.object({
   daemon_id: exports_external.string().min(1),
   max_tasks: exports_external.number().int().min(1).default(1),
@@ -14595,6 +14598,15 @@ var PollResponseSchema = exports_external.object({
   file_requests: exports_external.array(FileRequestItemSchema).optional(),
   meetings: exports_external.array(PollMeetingItemSchema).optional()
 });
+var DaemonPushMessageSchema = exports_external.discriminatedUnion("type", [
+  exports_external.object({ type: exports_external.literal("daemon.tasks"), tasks: exports_external.array(TaskApiSchema) }),
+  exports_external.object({ type: exports_external.literal("daemon.file_requests"), workspaceId: exports_external.string(), requests: exports_external.array(FileRequestItemSchema) }),
+  exports_external.object({ type: exports_external.literal("daemon.meetings"), meetings: exports_external.array(PollMeetingItemSchema) }),
+  exports_external.object({ type: exports_external.literal("daemon.evict"), workspaceId: exports_external.string() }),
+  exports_external.object({ type: exports_external.literal("daemon.update"), version: exports_external.string() }),
+  exports_external.object({ type: exports_external.literal("daemon.rescan") }),
+  exports_external.object({ type: exports_external.literal("daemon.kill"), workspaceId: exports_external.string(), taskId: exports_external.string(), targetTaskId: exports_external.string() })
+]);
 var RegisterResponseSchema = exports_external.object({
   runtimes: exports_external.array(exports_external.object({ id: exports_external.string() }))
 });
@@ -16979,6 +16991,9 @@ function loadDaemonConfig(profile) {
     codexModel: process.env.ALOOK_CODEX_MODEL || "",
     opencodeModel: process.env.ALOOK_OPENCODE_MODEL || "",
     pollInterval: parseDuration(process.env.ALOOK_DAEMON_POLL_INTERVAL || "3s"),
+    wsPollInterval: parseDuration(process.env.ALOOK_DAEMON_WS_POLL_INTERVAL || "60s"),
+    heartbeatInterval: parseDuration(process.env.ALOOK_DAEMON_HEARTBEAT_INTERVAL || "15s"),
+    sweepInterval: parseDuration(process.env.ALOOK_DAEMON_SWEEP_INTERVAL || "60s"),
     agentTimeout: parseDuration(process.env.ALOOK_AGENT_TIMEOUT || "12h"),
     messageInactivityTimeout: parseDuration(process.env.ALOOK_MESSAGE_INACTIVITY_TIMEOUT || "20m"),
     maxConcurrentTasks: parseInt(process.env.ALOOK_DAEMON_MAX_CONCURRENT_TASKS || "20"),
@@ -17350,6 +17365,16 @@ class DaemonClient {
     const raw = await this.request("POST", "/api/daemon/register", token, body);
     return RegisterResponseSchema.parse(raw);
   }
+  heartbeat(token, daemonId) {
+    return this.request("POST", "/api/daemon/heartbeat", token, {
+      daemon_id: daemonId
+    });
+  }
+  sweep(token, daemonId) {
+    return this.request("POST", "/api/daemon/sweep", token, {
+      daemon_id: daemonId
+    });
+  }
   deregister(token, daemonId) {
     return this.request("POST", "/api/daemon/deregister", token, {
       daemon_id: daemonId
@@ -19615,6 +19640,155 @@ if (isDirectExecution) {
   main();
 }
 
+// daemon/ws-client.ts
+var log6 = createLogger2({ module: "ws-client" });
+var WS_RECONNECT_INIT = 1000;
+var WS_RECONNECT_MAX = 30000;
+var WS_PING_INTERVAL = 25000;
+var WS_LIVENESS_TIMEOUT = 50000;
+var WS_DO_DEV_PORT = 8789;
+
+class DaemonWsClient {
+  opts;
+  ws = null;
+  reconnectDelay = WS_RECONNECT_INIT;
+  reconnectTimer = null;
+  pingInterval = null;
+  livenessInterval = null;
+  lastMessageAt = 0;
+  connected = false;
+  closed = false;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  getUrl() {
+    const url2 = new URL(this.opts.serverURL);
+    const isLocal = url2.hostname === "localhost" || url2.hostname === "127.0.0.1";
+    if (isLocal) {
+      return `ws://localhost:${WS_DO_DEV_PORT}/?daemonId=${this.opts.daemonId}`;
+    }
+    const protocol = url2.protocol === "https:" ? "wss:" : "ws:";
+    return `${protocol}//${url2.host}/api/ws/daemon?daemonId=${this.opts.daemonId}`;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  connect() {
+    if (this.closed)
+      return;
+    this.cleanup();
+    const wsUrl = this.getUrl();
+    log6.info("connecting", { url: wsUrl });
+    try {
+      this.ws = new WebSocket(wsUrl);
+    } catch (err) {
+      log6.warn("ws creation failed", { err: String(err) });
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.addEventListener("open", () => {
+      this.reconnectDelay = WS_RECONNECT_INIT;
+      this.ws.send(JSON.stringify({
+        type: "auth",
+        machineToken: this.opts.machineToken,
+        daemonId: this.opts.daemonId
+      }));
+      this.lastMessageAt = Date.now();
+      this.startHeartbeat();
+    });
+    this.ws.addEventListener("message", (event) => {
+      this.lastMessageAt = Date.now();
+      const str = typeof event.data === "string" ? event.data : "";
+      if (str === "pong")
+        return;
+      try {
+        const msg = JSON.parse(str);
+        if (msg.type === "auth.ok") {
+          log6.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 });
+          return;
+        }
+        this.opts.onMessage(parsed.data);
+      } catch (err) {
+        log6.debug("message parse error", { err: String(err) });
+      }
+    });
+    this.ws.addEventListener("error", () => {
+      log6.debug("ws error");
+    });
+    this.ws.addEventListener("close", () => {
+      const wasConnected = this.connected;
+      this.connected = false;
+      this.stopHeartbeat();
+      if (wasConnected) {
+        this.opts.onDisconnected();
+      }
+      if (!this.closed) {
+        this.scheduleReconnect();
+      }
+    });
+  }
+  close() {
+    this.closed = true;
+    this.cleanup();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  cleanup() {
+    this.stopHeartbeat();
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {}
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  scheduleReconnect() {
+    if (this.closed)
+      return;
+    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) });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay + jitter);
+  }
+  startHeartbeat() {
+    this.pingInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send("ping");
+      }
+    }, WS_PING_INTERVAL);
+    this.livenessInterval = setInterval(() => {
+      if (Date.now() - this.lastMessageAt > WS_LIVENESS_TIMEOUT) {
+        log6.warn("liveness timeout, closing");
+        this.ws?.close();
+      }
+    }, 5000);
+  }
+  stopHeartbeat() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.livenessInterval) {
+      clearInterval(this.livenessInterval);
+      this.livenessInterval = null;
+    }
+  }
+}
+
 // daemon/update-handler.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, unlinkSync as unlinkSync4 } from "fs";
 
@@ -19646,7 +19820,7 @@ function runNpmUpdate(targetVersion) {
 }
 
 // daemon/update-handler.ts
-var log6 = createLogger2({ module: "updater" });
+var log7 = createLogger2({ module: "updater" });
 var updating = false;
 var retryCount = 0;
 var MAX_RETRIES = 3;
@@ -19676,29 +19850,29 @@ async function handleCliUpdate(version3, onSuccess, profile) {
   if (retryCount >= MAX_RETRIES)
     return;
   if (process.env.ALOOK_CMD_PREFIX) {
-    log6.info(`Skipping auto-update in app mode — user should run: npx @alook/app@latest update`);
+    log7.info(`Skipping auto-update in app mode — user should run: npx @alook/app@latest update`);
     return;
   }
   const marker = readUpdateMarker(profile);
   if (marker === version3) {
-    log6.info(`Skipping update to v${version3} — already attempted (marker exists)`);
+    log7.info(`Skipping update to v${version3} — already attempted (marker exists)`);
     return;
   }
   updating = true;
   try {
-    log6.info(`Updating CLI to v${version3}...`);
+    log7.info(`Updating CLI to v${version3}...`);
     const result = await runNpmUpdate(version3);
     if (result.success) {
       writeUpdateMarker(version3, profile);
-      log6.info(`CLI updated to v${version3} — restarting`);
+      log7.info(`CLI updated to v${version3} — restarting`);
       onSuccess();
     } else {
       retryCount++;
-      log6.error(`CLI update failed (attempt ${retryCount}/${MAX_RETRIES}): ${result.output}`);
+      log7.error(`CLI update failed (attempt ${retryCount}/${MAX_RETRIES}): ${result.output}`);
     }
   } catch (e) {
     retryCount++;
-    log6.error(`CLI update error (attempt ${retryCount}/${MAX_RETRIES})`, e);
+    log7.error(`CLI update error (attempt ${retryCount}/${MAX_RETRIES})`, e);
   } finally {
     updating = false;
   }
@@ -19841,7 +20015,7 @@ import { readdir as readdir2, readFile as readFile2, unlink, stat as fsStat } fr
 import { execSync as execSync4, spawn as spawn5 } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname3, join as join10 } from "path";
-var log7 = createLogger2({ module: "daemon" });
+var log8 = createLogger2({ module: "daemon" });
 var _dir = dirname3(fileURLToPath2(import.meta.url));
 var sessionRunnerPath = existsSync2(join10(_dir, "session-runner.js")) ? join10(_dir, "session-runner.js") : join10(_dir, "session-runner.ts");
 var meetingRunnerPath = existsSync2(join10(_dir, "meeting-runner.js")) ? join10(_dir, "meeting-runner.js") : join10(_dir, "meeting-runner.ts");
@@ -19948,14 +20122,14 @@ async function reconcilePendingCompletions(workspacesRoot) {
       try {
         parsed = JSON.parse(raw);
       } catch {
-        log7.warn(`reconcile: malformed marker ${name}, deleting`);
+        log8.warn(`reconcile: malformed marker ${name}, deleting`);
         try {
           await unlink(filePath);
         } catch {}
         continue;
       }
       if (!isValidMarker(parsed)) {
-        log7.warn(`reconcile: invalid marker structure ${name}, deleting`);
+        log8.warn(`reconcile: invalid marker structure ${name}, deleting`);
         try {
           await unlink(filePath);
         } catch {}
@@ -19964,7 +20138,7 @@ async function reconcilePendingCompletions(workspacesRoot) {
       const marker = parsed;
       const age = Date.now() - new Date(marker.createdAt).getTime();
       if (age > MARKER_STALE_MS) {
-        log7.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
+        log8.warn(`reconcile: stale marker ${name} (${Math.round(age / 3600000)}h old), deleting`);
         try {
           await unlink(filePath);
         } catch {}
@@ -19980,7 +20154,7 @@ async function reconcilePendingCompletions(workspacesRoot) {
         try {
           await unlink(filePath);
         } catch (delErr) {
-          log7.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
+          log8.warn(`reconcile: delivered marker ${name} but failed to delete: ${delErr}`);
         }
       } catch (deliverErr) {
         if (isClientError2(deliverErr)) {
@@ -19988,11 +20162,11 @@ async function reconcilePendingCompletions(workspacesRoot) {
             await unlink(filePath);
           } catch {}
         } else {
-          log7.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
+          log8.debug(`reconcile: delivery failed for ${name}, will retry next cycle`);
         }
       }
     } catch (e) {
-      log7.debug(`reconcile: error processing ${name}`, e);
+      log8.debug(`reconcile: error processing ${name}`, e);
     }
   }
 }
@@ -20003,7 +20177,7 @@ async function startDaemon(profile, serverUrl) {
   }
   process.once("exit", () => releaseDaemonPid(profile));
   const bailOnUnexpected = (label, err) => {
-    log7.error(`${label} — shutting down`, err);
+    log8.error(`${label} — shutting down`, err);
     releaseDaemonPid(profile);
     process.exit(1);
   };
@@ -20016,21 +20190,21 @@ async function startDaemon(profile, serverUrl) {
   if (marker) {
     clearUpdateMarker(profile);
     if (marker === config2.cliVersion) {
-      log7.info(`Cleared update marker — now running v${config2.cliVersion}`);
+      log8.info(`Cleared update marker — now running v${config2.cliVersion}`);
     } else {
-      log7.info(`Cleared stale update marker (was v${marker}, running v${config2.cliVersion}) — update will be retried`);
+      log8.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) {
-    log7.error("No watched workspaces configured.");
+    log8.error("No watched workspaces configured.");
     process.exit(1);
     return;
   }
   const hasPerWorkspaceTokens = workspaces.every((ws) => !!ws.token);
   if (!hasPerWorkspaceTokens) {
-    log7.error(`Config uses old format. Run '${cmdPrefix()} register --token <token>' for each workspace to upgrade.`);
+    log8.error(`Config uses old format. Run '${cmdPrefix()} register --token <token>' for each workspace to upgrade.`);
     process.exit(1);
     return;
   }
@@ -20050,11 +20224,11 @@ async function startDaemon(profile, serverUrl) {
     }
   }
   if (providers.length === 0) {
-    log7.error("No agent CLI tools found on PATH.");
+    log8.error("No agent CLI tools found on PATH.");
     process.exit(1);
     return;
   }
-  log7.info(`Detected providers: ${providers.map((p) => `${p.type}@${p.version}`).join(", ")}`);
+  log8.info(`Detected providers: ${providers.map((p) => `${p.type}@${p.version}`).join(", ")}`);
   const workspaceStates = [];
   const runtimeIndex = new Map;
   for (const ws of workspaces) {
@@ -20062,7 +20236,7 @@ async function startDaemon(profile, serverUrl) {
       type: p.type,
       version: p.version
     }));
-    log7.info(`Registering workspace ${ws.id} (${ws.name ?? "unnamed"}) with ${runtimes.length} runtime(s)...`);
+    log8.info(`Registering workspace ${ws.id} (${ws.name ?? "unnamed"}) with ${runtimes.length} runtime(s)...`);
     let resp;
     try {
       resp = await client.register(ws.token, {
@@ -20075,13 +20249,13 @@ async function startDaemon(profile, serverUrl) {
       });
     } catch (e) {
       if (e instanceof Error && e.message.startsWith("HTTP 401")) {
-        log7.warn(`Workspace ${ws.id} token invalid — skipping (run '${cmdPrefix()} register --token <token>' to fix)`);
+        log8.warn(`Workspace ${ws.id} token invalid — skipping (run '${cmdPrefix()} register --token <token>' to fix)`);
       } else {
-        log7.error(`Failed to register workspace ${ws.id}, skipping`, e);
+        log8.error(`Failed to register workspace ${ws.id}, skipping`, e);
       }
       continue;
     }
-    log7.info(`Workspace ${ws.id} registered — ${resp.runtimes.length} runtime(s)`);
+    log8.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++) {
@@ -20093,13 +20267,13 @@ async function startDaemon(profile, serverUrl) {
     }
   }
   if (workspaceStates.length === 0) {
-    log7.error("No workspaces registered successfully.");
+    log8.error("No workspaces registered successfully.");
     process.exit(1);
     return;
   }
   const allRuntimeIds = workspaceStates.flatMap((ws) => ws.runtimeIds);
   health.setRuntimeCount(allRuntimeIds.length);
-  log7.info(`Daemon started — ${allRuntimeIds.length} runtime(s) across ${workspaceStates.length} workspace(s)`);
+  log8.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) {
@@ -20134,7 +20308,7 @@ async function startDaemon(profile, serverUrl) {
       cfg.watched_workspaces = (cfg.watched_workspaces || []).filter((w) => w.id !== workspaceId);
       saveCLIConfigForProfile(profile, cfg);
     } catch {}
-    log7.info(`Workspace ${workspaceId} deleted server-side — removed from config`);
+    log8.info(`Workspace ${workspaceId} deleted server-side — removed from config`);
   }
   const pollCycle = async () => {
     let remaining = config2.maxConcurrentTasks - activeTasks.size;
@@ -20160,7 +20334,7 @@ async function startDaemon(profile, serverUrl) {
           handleCliUpdate(pending_update.version, () => requestRestart(), profile);
         }
         if (pending_rescan) {
-          log7.info("Rescan requested — restarting daemon to re-detect runtimes");
+          log8.info("Rescan requested — restarting daemon to re-detect runtimes");
           for (const id of evictedIds) {
             evictWorkspace(id);
           }
@@ -20173,13 +20347,13 @@ async function startDaemon(profile, serverUrl) {
           activeTasks.add(task.id);
           remaining--;
           handleTask(client, config2, runtimeIndex, task, ws.token, activeTasks).catch((e) => {
-            log7.error("Task error", e);
+            log8.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) => log7.debug("File request error", e));
+            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log8.debug("File request error", e));
           }
         }
         if (meetings) {
@@ -20202,26 +20376,157 @@ async function startDaemon(profile, serverUrl) {
         }
       } catch (e) {
         if (e instanceof Error && e.message.startsWith("HTTP 401")) {
-          log7.warn(`Workspace ${ws.workspaceId} poll returned 401 — will retry next cycle`);
+          log8.warn(`Workspace ${ws.workspaceId} poll returned 401 — will retry next cycle`);
         } else {
-          log7.debug("Poll error", e);
+          log8.debug("Poll error", e);
         }
       }
     }
     for (const id of evictedIds) {
       evictWorkspace(id);
     }
+    if (workspaceStates.length === 0) {
+      log8.info("All workspaces evicted — shutting down");
+      shutdown();
+    }
+  };
+  let pollTimer = setInterval(pollCycle, config2.pollInterval);
+  const heartbeatPing = () => {
+    for (const ws of workspaceStates) {
+      client.heartbeat(ws.token, config2.daemonId).catch((e) => {
+        log8.debug("heartbeat failed", { workspaceId: ws.workspaceId, err: String(e) });
+      });
+    }
+  };
+  const heartbeatTimer = setInterval(heartbeatPing, config2.heartbeatInterval);
+  const firstToken = workspaceStates[0]?.token;
+  function updatePollInterval(newInterval) {
+    clearInterval(pollTimer);
+    pollTimer = setInterval(pollCycle, newInterval);
+  }
+  function handleWsPush(msg) {
+    switch (msg.type) {
+      case "daemon.tasks":
+        for (const apiTask of msg.tasks) {
+          if (activeTasks.size >= config2.maxConcurrentTasks)
+            break;
+          const task = fromApiTask(apiTask);
+          if (activeTasks.has(task.id))
+            continue;
+          const ws = workspaceStates.find((w) => w.workspaceId === task.workspaceId);
+          if (!ws)
+            continue;
+          syncAgentId(task.agentId, ws.workspaceId);
+          activeTasks.add(task.id);
+          handleTask(client, config2, runtimeIndex, task, ws.token, activeTasks).catch((e) => {
+            log8.error("WS task error", e);
+            activeTasks.delete(task.id);
+          });
+        }
+        break;
+      case "daemon.file_requests": {
+        const ws = workspaceStates.find((w) => w.workspaceId === msg.workspaceId);
+        if (ws) {
+          for (const req of msg.requests) {
+            handleFileRequest(client, config2, ws.workspaceId, req, ws.token).catch((e) => log8.debug("WS file request error", e));
+          }
+        }
+        break;
+      }
+      case "daemon.meetings":
+        for (const m of msg.meetings) {
+          const ws = workspaceStates.find((w) => w.workspaceId === m.workspace_id);
+          if (!ws)
+            continue;
+          const agentBaseDir = join10(config2.workspacesRoot, m.workspace_id, m.agent_id, "workdir");
+          const timelineDir = join10(agentBaseDir, ".context_timeline");
+          spawnMeetingRunner({
+            meetingId: m.id,
+            meetingUrl: m.meeting_url,
+            participants: m.participants,
+            workspaceId: m.workspace_id,
+            callbackUrl: config2.serverURL,
+            authToken: ws.token,
+            agentName: m.agent_name,
+            agentId: m.agent_id,
+            timelineDir,
+            title: m.title
+          });
+        }
+        break;
+      case "daemon.evict":
+        evictWorkspace(msg.workspaceId);
+        break;
+      case "daemon.update":
+        if (!isUpdating() && msg.version !== config2.cliVersion) {
+          handleCliUpdate(msg.version, () => requestRestart(), profile);
+        }
+        break;
+      case "daemon.rescan":
+        log8.info("WS rescan requested — restarting daemon");
+        requestRestart();
+        break;
+      case "daemon.kill": {
+        const ws = workspaceStates.find((w) => w.workspaceId === msg.workspaceId);
+        if (ws) {
+          const killTask = fromApiTask({
+            id: msg.taskId,
+            agent_id: "",
+            runtime_id: "",
+            conversation_id: "",
+            workspace_id: ws.workspaceId,
+            prompt: "",
+            status: "queued",
+            priority: 0,
+            dispatched_at: null,
+            started_at: null,
+            completed_at: null,
+            result: null,
+            error: null,
+            created_at: new Date().toISOString(),
+            type: "kill_task",
+            context: { target_task_id: msg.targetTaskId },
+            agent: null,
+            sender: null
+          });
+          activeTasks.add(killTask.id);
+          handleTask(client, config2, runtimeIndex, killTask, ws.token, activeTasks).catch((e) => {
+            log8.error("WS kill task error", e);
+            activeTasks.delete(killTask.id);
+          });
+        }
+        break;
+      }
+    }
+  }
+  const wsClient = firstToken ? new DaemonWsClient({
+    serverURL: config2.serverURL,
+    daemonId: config2.daemonId,
+    machineToken: firstToken,
+    onMessage: handleWsPush,
+    onConnected: () => {
+      log8.info("WS connected — switching to low-frequency poll");
+      updatePollInterval(config2.wsPollInterval);
+    },
+    onDisconnected: () => {
+      log8.info("WS disconnected — reverting to high-frequency poll");
+      updatePollInterval(config2.pollInterval);
+    }
+  }) : null;
+  wsClient?.connect();
+  const sweepTick = async () => {
+    for (const ws of workspaceStates) {
+      client.sweep(ws.token, config2.daemonId).catch((e) => {
+        log8.debug("sweep ping failed", { workspaceId: ws.workspaceId, err: String(e) });
+      });
+    }
     try {
       await reconcilePendingCompletions(config2.workspacesRoot);
     } catch (e) {
-      log7.debug("reconciliation error", e);
-    }
-    if (workspaceStates.length === 0) {
-      log7.info("All workspaces evicted — shutting down");
-      shutdown();
+      log8.debug("reconciliation error", e);
     }
   };
-  const pollTimer = setInterval(pollCycle, config2.pollInterval);
+  const sweepTimer = setInterval(sweepTick, config2.sweepInterval);
   let shuttingDown = false;
   let restartRequested = false;
   const requestRestart = () => {
@@ -20232,8 +20537,11 @@ async function startDaemon(profile, serverUrl) {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log7.info(restartRequested ? "Restarting..." : "Shutting down...");
+    log8.info(restartRequested ? "Restarting..." : "Shutting down...");
     clearInterval(pollTimer);
+    clearInterval(heartbeatTimer);
+    clearInterval(sweepTimer);
+    wsClient?.close();
     const shutdownMs = restartRequested ? 30000 : Number(process.env.ALOOK_SHUTDOWN_TIMEOUT_MS) || 5000;
     const timeout = setTimeout(() => process.exit(1), shutdownMs);
     try {
@@ -20256,7 +20564,7 @@ async function startDaemon(profile, serverUrl) {
           mkdirSync7(dirname3(logPath), { recursive: true, mode: 448 });
           logFd = openSync(logPath, "a", 384);
         } catch (e) {
-          log7.error(`Failed to open daemon log file ${logPath}`, e);
+          log8.error(`Failed to open daemon log file ${logPath}`, e);
         }
         const child = spawn5(process.execPath, args, {
           detached: true,
@@ -20266,7 +20574,7 @@ async function startDaemon(profile, serverUrl) {
         child.unref();
         if (logFd != null)
           closeSync(logFd);
-        log7.info(`Spawned new daemon (pid=${child.pid}), logs: ${logPath}`);
+        log8.info(`Spawned new daemon (pid=${child.pid}), logs: ${logPath}`);
       }
       clearTimeout(timeout);
       process.exit(0);
@@ -20277,7 +20585,7 @@ async function startDaemon(profile, serverUrl) {
   process.on("SIGHUP", async () => {
     if (shuttingDown)
       return;
-    log7.info("SIGHUP received — reloading config...");
+    log8.info("SIGHUP received — reloading config...");
     try {
       const freshConfig = loadCLIConfigForProfile(profile);
       const freshWorkspaces = freshConfig.watched_workspaces || [];
@@ -20285,7 +20593,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 }));
-        log7.info(`Registering new workspace ${ws.id} (${ws.name ?? "unnamed"})...`);
+        log8.info(`Registering new workspace ${ws.id} (${ws.name ?? "unnamed"})...`);
         try {
           const resp = await client.register(ws.token, {
             workspace_id: ws.id,
@@ -20304,19 +20612,19 @@ async function startDaemon(profile, serverUrl) {
               provider: providers[i].type
             });
           }
-          log7.info(`Workspace ${ws.id} added — ${runtimeIds.length} runtime(s)`);
+          log8.info(`Workspace ${ws.id} added — ${runtimeIds.length} runtime(s)`);
         } catch (e) {
-          log7.error(`Failed to register new workspace ${ws.id}`, e);
+          log8.error(`Failed to register new workspace ${ws.id}`, e);
         }
       }
       if (newWorkspaces.length > 0) {
         health.setRuntimeCount(workspaceStates.reduce((sum, w) => sum + w.runtimeIds.length, 0));
-        log7.info(`Reload complete — now polling ${workspaceStates.length} workspace(s)`);
+        log8.info(`Reload complete — now polling ${workspaceStates.length} workspace(s)`);
       } else {
-        log7.info("Reload complete — no new workspaces found");
+        log8.info("Reload complete — no new workspaces found");
       }
     } catch (e) {
-      log7.error("Failed to reload config", e);
+      log8.error("Failed to reload config", e);
     }
   });
   await pollCycle();
@@ -20331,7 +20639,7 @@ function spawnSessionRunner(input) {
   try {
     fd = openSync(logFilePath, "a");
   } catch (e) {
-    log7.error(`Failed to open log file ${logFilePath}`, e);
+    log8.error(`Failed to open log file ${logFilePath}`, e);
   }
   const child = spawn5(process.execPath, [sessionRunnerPath, encoded], {
     detached: true,
@@ -20351,7 +20659,7 @@ function spawnMeetingRunner(input) {
   try {
     fd = openSync(logFilePath, "a");
   } catch (e) {
-    log7.error(`Failed to open meeting log file ${logFilePath}`, e);
+    log8.error(`Failed to open meeting log file ${logFilePath}`, e);
   }
   const child = spawn5(process.execPath, [meetingRunnerPath, encoded], {
     detached: true,
@@ -20360,7 +20668,7 @@ function spawnMeetingRunner(input) {
   child.unref();
   if (fd != null)
     closeSync(fd);
-  log7.info(`Spawned meeting runner for ${input.meetingId} (pid=${child.pid})`);
+  log8.info(`Spawned meeting runner for ${input.meetingId} (pid=${child.pid})`);
   return child;
 }
 async function handleFileRequest(client, config2, workspaceId, req, token) {
@@ -20387,7 +20695,7 @@ async function handleFileRequest(client, config2, workspaceId, req, token) {
   }
 }
 async function handleTask(client, config2, runtimeIndex, task, token, activeTasks) {
-  log7.info(`Task ${task.id} claimed agent=${task.agentId}`);
+  log8.info(`Task ${task.id} claimed agent=${task.agentId}`);
   if (task.type === TASK_TYPES.KILL_TASK) {
     const targetTaskId = task.context?.target_task_id;
     if (!targetTaskId) {
@@ -20416,18 +20724,18 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
       try {
         process.kill(pid, "SIGTERM");
         await client.failTask(token, task.id, "killed");
-        log7.info(`Kill task ${task.id}: sent SIGTERM to pid=${pid} for target=${targetTaskId}`);
+        log8.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");
-          log7.info(`Kill task ${task.id}: target pid=${pid} already exited`);
+          log8.info(`Kill task ${task.id}: target pid=${pid} already exited`);
         } else {
           await client.failTask(token, task.id, `kill failed: ${e}`);
         }
       }
     } else {
       await client.failTask(token, task.id, "target not found in timeline");
-      log7.info(`Kill task ${task.id}: target ${targetTaskId} not found in timeline`);
+      log8.info(`Kill task ${task.id}: target ${targetTaskId} not found in timeline`);
     }
     activeTasks.delete(task.id);
     return;
@@ -20452,12 +20760,12 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
     const timelineDir = join10(agentBaseDir, ".context_timeline");
     const lockAcquired = acquireSteeringLock(agentBaseDir, task.contextKey);
     if (!lockAcquired) {
-      log7.warn(`Steering lock contention for context_key=${task.contextKey}, proceeding without steering`);
+      log8.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) {
-          log7.info(`Steering: task ${task.id} supersedes predecessor ${predecessor.task_id} (context_key=${task.contextKey})`);
+          log8.info(`Steering: task ${task.id} supersedes predecessor ${predecessor.task_id} (context_key=${task.contextKey})`);
           if (predecessor.pid != null) {
             writeKillIntent(agentBaseDir, {
               reason: "superseded",
@@ -20467,12 +20775,12 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
             });
             try {
               process.kill(predecessor.pid, "SIGTERM");
-              log7.info(`Steering: sent SIGTERM to predecessor pid=${predecessor.pid}`);
+              log8.info(`Steering: sent SIGTERM to predecessor pid=${predecessor.pid}`);
             } catch (e) {
               if (e?.code === "ESRCH") {
-                log7.info(`Steering: predecessor pid=${predecessor.pid} already exited`);
+                log8.info(`Steering: predecessor pid=${predecessor.pid} already exited`);
               } else {
-                log7.warn(`Steering: kill failed for pid=${predecessor.pid}`, e);
+                log8.warn(`Steering: kill failed for pid=${predecessor.pid}`, e);
               }
             }
             const waitStart = Date.now();
@@ -20485,14 +20793,14 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
               await new Promise((r) => setTimeout(r, POLL_MS));
             }
             if (findRunningPidByTaskId(timelineDir, predecessor.task_id) != null) {
-              log7.warn(`Steering: predecessor pid=${predecessor.pid} did not exit within ${MAX_WAIT_MS}ms, proceeding anyway`);
+              log8.warn(`Steering: predecessor pid=${predecessor.pid} did not exit within ${MAX_WAIT_MS}ms, proceeding anyway`);
             }
           }
           try {
             await client.supersedeTask(token, predecessor.task_id);
-            log7.info(`Steering: predecessor ${predecessor.task_id} marked superseded`);
+            log8.info(`Steering: predecessor ${predecessor.task_id} marked superseded`);
           } catch (e) {
-            log7.warn(`Steering: failed to mark predecessor superseded server-side`, e);
+            log8.warn(`Steering: failed to mark predecessor superseded server-side`, e);
           }
         }
       } finally {
@@ -20520,7 +20828,7 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
     activeTasks.delete(task.id);
     if (code !== 0) {
       const msg = code === null ? `session-runner killed by signal (task ${task.id})` : `session-runner crashed (exit code ${code}, task ${task.id})`;
-      log7.warn(msg);
+      log8.warn(msg);
       const timelineDir = join10(config2.workspacesRoot, task.workspaceId, task.agentId, "workdir", ".context_timeline");
       updateEntry(timelineDir, task.id, (entry) => {
         entry.pid = null;
@@ -20531,10 +20839,10 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
         await client.failTask(token, task.id, msg);
       } catch (e) {
         if (isClientError2(e)) {
-          log7.info(`Backstop: task ${task.id} already in terminal state`);
+          log8.info(`Backstop: task ${task.id} already in terminal state`);
           return;
         }
-        log7.error(`Backstop: failed to report crash for task ${task.id}`, e);
+        log8.error(`Backstop: failed to report crash for task ${task.id}`, e);
         try {
           await writeMarkerFile(config2.workspacesRoot, {
             taskId: task.id,
@@ -20548,7 +20856,7 @@ async function handleTask(client, config2, runtimeIndex, task, token, activeTask
       }
     }
   });
-  log7.info(`Task ${task.id} dispatched to session-runner (pid=${child.pid})`);
+  log8.info(`Task ${task.id} dispatched to session-runner (pid=${child.pid})`);
 }
 
 // commands/daemon.ts
@@ -20722,7 +21030,7 @@ function resolveAgentId(opts) {
 }
 
 // commands/email.ts
-var log8 = createLogger2({ module: "email" });
+var log9 = createLogger2({ module: "email" });
 var VALID_STATUSES = ["unread", "read", "archived", "sent"];
 var VALID_FOLDERS = ["inbox", "sent", "untrust"];
 var EMAIL_BASE = tempDir("alook-emails");
@@ -20864,7 +21172,7 @@ function emailCommand() {
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           if (msg.includes("404")) {
-            log8.warn(`email body not available for ${email3.id}, skipping`);
+            log9.warn(`email body not available for ${email3.id}, skipping`);
             continue;
           }
           throw err;
@@ -20986,7 +21294,7 @@ function emailCommand() {
             references = [parentEmail.references, parentEmail.message_id].filter(Boolean).join(" ").trim() || undefined;
           }
         } catch {
-          log8.warn(`could not fetch parent email ${opts.inReplyTo}, sending without threading`);
+          log9.warn(`could not fetch parent email ${opts.inReplyTo}, sending without threading`);
         }
       }
       const conversationId = process.env.ALOOK_CONVERSATION_ID;