@standardagents/code 0.12.1 → 0.13.0

package/README.md

@@ -65,7 +65,9 @@ we're letting new folks in every week.
   transitions, stream and idle execution-bridge heartbeats use Durable Object hibernation
   auto-responses, and transcript safety requests run only while the agent is active. The bridge
   switches to an observable liveness heartbeat only during a forwarded tool or approval, so
-  leaving a terminal attached does not continuously wake an idle thread.
+  leaving a terminal attached does not continuously wake an idle thread. A machine daemon keeps
+  one account user stream and opens a per-thread execution bridge only while forwarded work is
+  active.
 - **Subagents & research built in.** Delegate focused subtasks to a coding subagent, or spin up a
   non-blocking web-research agent that returns source-backed findings.
 - **MCP, first-class.** The CLI is a Model Context Protocol host — connect local MCP servers

package/dist/index.js

@@ -2028,7 +2028,8 @@ var HostTools = class {
     }
     const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
     await fsp.writeFile(file2, updated, "utf8");
-    return { ok: true, result: `Edited ${path4.relative(this.projectDir, file2)} (${count} replacement${count === 1 ? "" : "s"})` };
+    const startLine = content.slice(0, content.indexOf(oldStr)).split("\n").length;
+    return { ok: true, result: `Edited ${path4.relative(this.projectDir, file2)} (${count} replacement${count === 1 ? "" : "s"}) @ line ${startLine}` };
   }
   /**
    * Copy a file from the THREAD filesystem (e.g. a generated /attachments/*
@@ -6491,7 +6492,7 @@ function readVersion() {
     if (typeof pkg.version === "string" && pkg.version) return pkg.version;
   } catch {
   }
-  return "0.12.1" ;
+  return "0.13.0" ;
 }
 function isLocalHost(host) {
   return host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local") || host.endsWith(".localhost") || /^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host);
@@ -6606,13 +6607,6 @@ async function readFsResponse(api, machineId) {
 async function readFsRequest(api, machineId) {
   return parseFsRequest(await api.userKvGet(fsRequestKey(machineId)));
 }
-var FS_POLL_HOT_MS = 1e3;
-var FS_POLL_IDLE_MS = 5e3;
-var FS_HOT_WINDOW_MS = 5 * 6e4;
-function fsPollDelay(lastRequestSeenAt, now) {
-  if (lastRequestSeenAt !== null && now - lastRequestSeenAt < FS_HOT_WINDOW_MS) return FS_POLL_HOT_MS;
-  return FS_POLL_IDLE_MS;
-}
 async function writeFsResponse(api, machineId, res) {
   await api.userKvSet(fsResponseKey(machineId), { ...res, responded_at: Date.now() });
 }
@@ -6838,17 +6832,6 @@ async function unregisterProject(api, identity, projectDir) {
     }
   });
 }
-async function touchDaemon(api, identity, version) {
-  await updateOwnMachineRecord(api, identity, (record2) => {
-    const now = Date.now();
-    record2.daemon = {
-      version,
-      installed_at: record2.daemon?.installed_at ?? now,
-      last_seen_at: now,
-      pid: process.pid
-    };
-  });
-}
 async function clearDaemon(api, identity) {
   await updateOwnMachineRecord(api, identity, (record2) => {
     record2.daemon = null;
@@ -7242,9 +7225,7 @@ async function awaitApprovalViaRelay(api, threadId, request, options = {}) {
     });
   }
 }
-
-// src/hub.ts
-var HubSocket = class {
+var DaemonUserStream = class {
   constructor(api, clientId, hooks, clientName) {
     this.api = api;
     this.clientId = clientId;
@@ -7260,13 +7241,13 @@ var HubSocket = class {
   heartbeat = null;
   reconnectAttempt = 0;
   reconnectTimer = null;
-  /** Open the socket and keep it connected (reconnect forever on drop). */
   start() {
     this.openSocket();
   }
   openSocket() {
     if (this.closed) return;
-    let url = `${this.api.wsEndpoint}/api/users/me/stream?token=${encodeURIComponent(this.api.bearer)}&client_id=${encodeURIComponent(this.clientId)}&client_kind=daemon`;
+    const connectionClientId = `${this.clientId}:${crypto.randomBytes(8).toString("hex")}`;
+    let url = `${this.api.wsEndpoint}/api/users/me/stream?token=${encodeURIComponent(this.api.bearer)}&client_id=${encodeURIComponent(connectionClientId)}&client_kind=daemon`;
     if (this.clientName) url += `&client_name=${encodeURIComponent(this.clientName)}`;
     let ws;
     try {
@@ -7281,25 +7262,29 @@ var HubSocket = class {
       this.startHeartbeat(ws);
       this.hooks.onConnection?.("connected", 0);
     });
-    ws.addEventListener("message", (ev) => {
+    ws.addEventListener("message", (event) => {
       if (this.ws === ws) this.heartbeat?.markAlive();
-      this.onMessage(String(ev.data));
+      this.onMessage(String(event.data));
     });
     ws.addEventListener("error", () => this.handleDrop(ws));
     ws.addEventListener("close", () => this.handleDrop(ws));
   }
   onMessage(raw) {
-    let msg;
+    let message;
     try {
-      msg = JSON.parse(raw);
+      message = JSON.parse(raw);
     } catch {
       return;
     }
-    if (!msg || typeof msg !== "object") return;
-    const frame = msg;
-    if (frame.event === "standardagents.wake") {
-      const threadId = frame.data?.thread_id;
-      if (typeof threadId === "string") this.hooks.onWake(threadId);
+    if (!message || typeof message !== "object") return;
+    const frame = message;
+    if (typeof frame.event === "string") {
+      if (frame.event === "standardagents.wake") {
+        const threadId = frame.data?.thread_id;
+        if (typeof threadId === "string") this.hooks.onWake(threadId);
+      } else {
+        this.hooks.onEvent(frame.event, frame.data);
+      }
       return;
     }
     if (frame.type === "wake" && typeof frame.threadId === "string") {
@@ -7329,10 +7314,8 @@ var HubSocket = class {
     this.heartbeat.start();
   }
   stopHeartbeat() {
-    if (this.heartbeat) {
-      this.heartbeat.stop();
-      this.heartbeat = null;
-    }
+    this.heartbeat?.stop();
+    this.heartbeat = null;
   }
   close() {
     this.closed = true;
@@ -7522,12 +7505,10 @@ function runUpdate(pm) {
 }
 
 // src/daemon.ts
-var HEARTBEAT_MS = 3e4;
-var COMMAND_POLL_MS = 8e3;
-var RECLAIM_PROBE_MS = 2 * 6e4;
 var UPDATE_CHECK_MS = 6 * 60 * 6e4;
-var SWEEP_MS = 10 * 6e4;
 var MAX_WORKERS = 30;
+var BRIDGE_ATTACH_GRACE_MS = 15e3;
+var BRIDGE_IDLE_MS = 2e3;
 var LOG_MAX_BYTES = 1e6;
 var LOG_FILE = path4.join(os8.homedir(), ".standardagents", "daemon.log");
 function daemonLog(line) {
@@ -7573,6 +7554,8 @@ var ThreadWorker = class {
         onStatus: (_id, summary) => {
           this.inFlight += summary ? 1 : -1;
           if (this.inFlight < 0) this.inFlight = 0;
+          if (summary) this.clearIdleTimer();
+          else if (this.inFlight === 0) this.scheduleIdle(BRIDGE_IDLE_MS);
         },
         onConnection: (state, attempt) => {
           if (state !== "reconnecting" || attempt === 1 || attempt % 10 === 0) {
@@ -7580,10 +7563,16 @@ var ThreadWorker = class {
           }
         },
         onOwnership: (isOwner, owner) => {
-          this.isOwner = isOwner;
           daemonLog(
             `[${threadId.slice(0, 8)}] ownership: ${isOwner ? "OWNER" : "watcher"}` + (owner ? ` (owner: ${owner.client_name || owner.client_id})` : "")
           );
+          if (isOwner) this.watchedAnotherOwner = false;
+          else if (owner) this.watchedAnotherOwner = true;
+          else if (this.watchedAnotherOwner) {
+            this.watchedAnotherOwner = false;
+            this.session.bridge.setClaim("if_unowned");
+            this.session.bridge.refresh();
+          }
         },
         onSuperseded: () => {
           daemonLog(`[${threadId.slice(0, 8)}] superseded by another process with this identity \u2014 standing down`);
@@ -7637,22 +7626,36 @@ var ThreadWorker = class {
   session;
   perm;
   inFlight = 0;
-  isOwner = false;
+  idleTimer = null;
+  watchedAnotherOwner = false;
   /** Set by the daemon so a superseded worker can remove itself. */
   onEvicted;
-  get bridge() {
-    return this.session.bridge;
-  }
+  /** Set by the daemon so an inactive bridge removes itself. */
+  onIdle;
   get busy() {
     return this.inFlight > 0;
   }
+  clearIdleTimer() {
+    if (!this.idleTimer) return;
+    clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+  scheduleIdle(delay) {
+    this.clearIdleTimer();
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      if (!this.busy) this.onIdle?.(this.threadId);
+    }, delay);
+  }
   async start() {
     await this.session.loadApprovals().catch(() => {
     });
     this.session.writeSessionInfo();
     await this.session.bridge.connect();
+    if (!this.busy) this.scheduleIdle(BRIDGE_ATTACH_GRACE_MS);
   }
   stop() {
+    this.clearIdleTimer();
     this.session.stop();
   }
 };
@@ -7694,18 +7697,62 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
   process.on("unhandledRejection", (err) => {
     daemonLog(`unhandledRejection: ${err instanceof Error ? err.stack : String(err)}`);
   });
-  await touchDaemon(api, identity, version).catch(
-    (e) => daemonLog(`heartbeat failed: ${e instanceof Error ? e.message : String(e)}`)
+  await updateOwnMachineRecord(api, identity, (record2) => {
+    const now = Date.now();
+    record2.daemon = {
+      version,
+      installed_at: record2.daemon?.installed_at ?? now,
+      last_seen_at: 0,
+      pid: process.pid
+    };
+  }).catch(
+    (e) => daemonLog(`machine registration failed: ${e instanceof Error ? e.message : String(e)}`)
   );
-  const heartbeat = setInterval(() => {
-    void touchDaemon(api, identity, version).catch(() => {
-    });
-    void getMachineName(api, identity.machine_id).then((n) => {
-      if (n) displayName = n;
-    }).catch(() => {
-    });
-  }, HEARTBEAT_MS);
   const workers = /* @__PURE__ */ new Map();
+  let lineActiveThreads = /* @__PURE__ */ new Set();
+  let samaActiveThreads = /* @__PURE__ */ new Set();
+  let hub = null;
+  let updateTimer = null;
+  let updateReady = false;
+  let forcedUpdatePending = false;
+  let restartInProgress = false;
+  let shuttingDown = false;
+  function shutdown(code) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (updateTimer) clearInterval(updateTimer);
+    for (const worker of workers.values()) worker.stop();
+    workers.clear();
+    hub?.close();
+    daemonLog(`daemon exiting (code ${code})`);
+    process.exit(code);
+  }
+  async function restartIfIdle() {
+    if (restartInProgress || [...workers.values()].some((worker) => worker.busy)) return;
+    if (forcedUpdatePending) {
+      const pm = detectPackageManager();
+      forcedUpdatePending = false;
+      if (!pm) {
+        daemonLog("forced update requested but this is not an installed build \u2014 ignoring");
+        return;
+      }
+      restartInProgress = true;
+      daemonLog(`forced update: running ${pm} install now`);
+      const { ok, output: output4 } = await runUpdate(pm);
+      daemonLog(`forced update ${ok ? "succeeded" : "failed"}: ${output4.trim().split("\n").slice(-2).join(" | ")}`);
+      if (ok) {
+        daemonLog("restarting to apply the forced update");
+        shutdown(0);
+        return;
+      }
+      restartInProgress = false;
+    }
+    if (updateReady) {
+      daemonLog("restarting to apply the installed update");
+      shutdown(0);
+    }
+  }
+  const threadIsActive = (threadId) => lineActiveThreads.has(threadId) || samaActiveThreads.has(threadId);
   const attach = async (threadId, tags, createdAt2 = 0) => {
     if (workers.has(threadId)) return;
     const projectDir = pathFromTags(tags);
@@ -7725,9 +7772,19 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     }
     const worker = new ThreadWorker(api, identity, displayName, threadId, projectDir, createdAt2 || Date.now());
     worker.onEvicted = (id) => detach(id);
+    worker.onIdle = (id) => {
+      if (threadIsActive(id)) return;
+      detach(id);
+      void restartIfIdle();
+    };
     workers.set(threadId, worker);
     daemonLog(`attached ${threadId.slice(0, 8)} \u2192 ${projectDir}`);
-    await worker.start();
+    try {
+      await worker.start();
+    } catch (error) {
+      detach(threadId);
+      throw error;
+    }
     void registerProject(api, identity, projectDir).catch(() => {
     });
     const rawPath = tags.find((t) => t.startsWith("path:"))?.slice("path:".length);
@@ -7744,66 +7801,17 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     workers.delete(threadId);
     daemonLog(`detached ${threadId.slice(0, 8)}`);
   };
-  const sweep = async () => {
+  const attachThreadById = async (threadId, reason) => {
+    if (workers.has(threadId)) return;
     try {
-      const threads = await api.listThreads([...AGENT_ID_VARIANTS, OPENSAMA_AGENT_ID], [runnerTag]);
-      const recent = threads.sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0)).slice(0, MAX_WORKERS);
-      for (const t of recent) {
-        await attach(t.id, t.tags, (t.created_at ?? 0) * 1e3);
-      }
+      const thread = await api.getThread(threadId);
+      if (!thread || thread.terminated || !thread.tags.includes(runnerTag)) return;
+      daemonLog(`${reason}: attaching ${threadId.slice(0, 8)}`);
+      await attach(threadId, thread.tags, (thread.created_at ?? 0) * 1e3);
     } catch (e) {
-      daemonLog(`sweep failed: ${e instanceof Error ? e.message : String(e)}`);
+      daemonLog(`${reason} attach failed: ${e instanceof Error ? e.message : String(e)}`);
     }
   };
-  const events = new SystemEvents(api, {
-    onOpen: () => void sweep(),
-    onThreadCreated: (t) => {
-      if (t.tags?.includes(runnerTag)) void attach(t.id, t.tags ?? [], (t.created_at ?? 0) * 1e3);
-    },
-    onThreadUpdated: (t) => {
-      if (t.terminated) detach(t.id);
-      else if (t.tags?.includes(runnerTag)) void attach(t.id, t.tags ?? [], (t.created_at ?? 0) * 1e3);
-    },
-    onThreadDeleted: (id) => detach(id)
-  });
-  events.connect();
-  const hub = new HubSocket(
-    api,
-    daemonClientId(identity),
-    {
-      onWake: (threadId) => {
-        if (workers.has(threadId)) return;
-        void (async () => {
-          try {
-            const thread = await api.getThread(threadId);
-            if (!thread || thread.terminated) return;
-            if (!thread.tags?.includes(runnerTag)) return;
-            daemonLog(`wake: attaching ${threadId.slice(0, 8)} on hub signal`);
-            await attach(threadId, thread.tags ?? [], (thread.created_at ?? 0) * 1e3);
-          } catch (e) {
-            daemonLog(`wake attach failed: ${e instanceof Error ? e.message : String(e)}`);
-          }
-        })();
-      },
-      onConnection: (state, attempt) => {
-        if (state === "reconnecting" && attempt === 1) daemonLog("hub: reconnecting");
-      }
-    },
-    displayName
-  );
-  hub.start();
-  await sweep();
-  const reclaim = setInterval(() => {
-    for (const worker of workers.values()) {
-      if (!worker.isOwner) {
-        worker.bridge.setClaim("if_stale");
-        worker.bridge.refresh();
-      } else {
-        worker.bridge.setClaim("if_unowned");
-      }
-    }
-  }, RECLAIM_PROBE_MS);
-  let updateReady = false;
   const checkUpdates = async () => {
     try {
       const info = await checkForUpdate(version);
@@ -7818,15 +7826,18 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       if (state && state.version === info.latest && state.exitCode === 0) {
         daemonLog(`auto-update: v${info.latest} installed \u2014 restarting when idle`);
         updateReady = true;
+        await restartIfIdle();
       }
     } catch {
     }
   };
-  void checkUpdates();
-  const updateTimer = setInterval(() => void checkUpdates(), UPDATE_CHECK_MS);
   let draining = false;
+  let drainAgain = false;
   const drainCommands = async () => {
-    if (draining) return;
+    if (draining) {
+      drainAgain = true;
+      return;
+    }
     draining = true;
     try {
       const cmds = await readMachineCommands(api, identity.machine_id);
@@ -7851,37 +7862,31 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       await clearMachineCommands(api, identity.machine_id, applied2).catch(() => {
       });
       if (forcedUpdate) {
-        const pm = detectPackageManager();
-        if (!pm) {
-          daemonLog("forced update requested but this is not an installed build \u2014 ignoring");
-        } else if (![...workers.values()].some((w) => w.busy)) {
-          daemonLog(`forced update: running ${pm} install now`);
-          const { ok, output: output4 } = await runUpdate(pm);
-          daemonLog(`forced update ${ok ? "succeeded" : "failed"}: ${output4.trim().split("\n").slice(-2).join(" | ")}`);
-          if (ok) {
-            daemonLog("restarting to apply the forced update");
-            shutdown(0);
-          }
-        } else {
-          daemonLog("forced update deferred \u2014 a session is busy; will retry");
-          void checkUpdates();
+        forcedUpdatePending = true;
+        if ([...workers.values()].some((worker) => worker.busy)) {
+          daemonLog("forced update deferred until active tool calls finish");
         }
+        await restartIfIdle();
       }
     } finally {
       draining = false;
+      if (drainAgain) {
+        drainAgain = false;
+        void drainCommands();
+      }
     }
   };
-  void drainCommands();
-  const commandTimer = setInterval(() => void drainCommands(), COMMAND_POLL_MS);
   let lastFsNonce = null;
-  let lastFsRequestSeenAt = null;
   let fsBusy = false;
+  let fsAgain = false;
   const drainFsRequests = async () => {
-    if (fsBusy) return;
+    if (fsBusy) {
+      fsAgain = true;
+      return;
+    }
     fsBusy = true;
     try {
       const req = await readFsRequest(api, identity.machine_id).catch(() => null);
-      if (req) lastFsRequestSeenAt = Math.max(lastFsRequestSeenAt ?? 0, req.requested_at);
       if (!req || req.nonce === lastFsNonce) return;
       lastFsNonce = req.nonce;
       let ok = true;
@@ -7897,42 +7902,131 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       });
     } finally {
       fsBusy = false;
+      if (fsAgain) {
+        fsAgain = false;
+        void drainFsRequests();
+      }
     }
   };
-  let fsTimer = null;
-  let fsStopped = false;
-  const scheduleFsPoll = () => {
-    if (fsStopped) return;
-    fsTimer = setTimeout(() => {
-      void drainFsRequests().finally(scheduleFsPoll);
-    }, fsPollDelay(lastFsRequestSeenAt, Date.now()));
+  const activeThreadSnapshot = async () => {
+    const response = await fetch(`${api.origin}/api/users/me/standardcode/sidebar`, {
+      headers: { Authorization: `Bearer ${api.bearer}` }
+    });
+    if (!response.ok) throw new Error(`sidebar snapshot returned ${response.status}`);
+    const snapshot = await response.json();
+    const lines = /* @__PURE__ */ new Set();
+    const sama = /* @__PURE__ */ new Set();
+    for (const entry of snapshot.lines?.active ?? []) {
+      if (typeof entry.thread_id === "string") lines.add(entry.thread_id);
+    }
+    for (const entry of snapshot.activity?.busy ?? []) {
+      if (typeof entry.thread_id === "string") sama.add(entry.thread_id);
+    }
+    return { lines, sama };
   };
-  scheduleFsPoll();
-  const sweeper = setInterval(() => {
-    if (updateReady && ![...workers.values()].some((w) => w.busy)) {
-      daemonLog("restarting to apply the installed update");
-      shutdown(0);
+  let recovering = false;
+  let recoverAgain = false;
+  const recoverOnConnect = async () => {
+    if (recovering) {
+      recoverAgain = true;
       return;
     }
-    void sweep();
-  }, SWEEP_MS);
-  const shutdown = (code) => {
-    clearInterval(heartbeat);
-    clearInterval(reclaim);
-    clearInterval(updateTimer);
-    clearInterval(commandTimer);
-    fsStopped = true;
-    if (fsTimer) clearTimeout(fsTimer);
-    clearInterval(sweeper);
-    for (const worker of workers.values()) worker.stop();
-    events.close();
-    hub.close();
-    daemonLog(`daemon exiting (code ${code})`);
-    process.exit(code);
+    recovering = true;
+    try {
+      await Promise.all([
+        drainCommands(),
+        drainFsRequests(),
+        getMachineName(api, identity.machine_id).then((name) => {
+          displayName = name || os8.hostname();
+        }).catch(() => {
+        })
+      ]);
+      const snapshot = await activeThreadSnapshot();
+      lineActiveThreads = snapshot.lines;
+      samaActiveThreads = snapshot.sama;
+      const active = [.../* @__PURE__ */ new Set([...snapshot.lines, ...snapshot.sama])].slice(0, MAX_WORKERS);
+      for (const threadId of active) {
+        await attachThreadById(threadId, "recovery");
+      }
+    } catch (error) {
+      daemonLog(`user-stream recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      recovering = false;
+      if (recoverAgain) {
+        recoverAgain = false;
+        void recoverOnConnect();
+      }
+    }
+  };
+  const idsFromEvent = (data, field) => {
+    if (!data || typeof data !== "object") return null;
+    const entries = data[field];
+    if (!Array.isArray(entries)) return null;
+    const ids = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (entry && typeof entry === "object" && typeof entry.thread_id === "string") {
+        ids.add(entry.thread_id);
+      }
+    }
+    return ids;
+  };
+  const releaseInactiveWorkers = () => {
+    for (const worker of [...workers.values()]) {
+      if (!worker.busy && !threadIsActive(worker.threadId)) detach(worker.threadId);
+    }
+    void restartIfIdle();
   };
+  const machinePrefix = `standardcode.machine.${identity.machine_id}`;
+  hub = new DaemonUserStream(
+    api,
+    daemonClientId(identity),
+    {
+      onWake: (threadId) => void attachThreadById(threadId, "wake"),
+      onEvent: (event, data) => {
+        if (event === "standardcode.lines_changed") {
+          const ids = idsFromEvent(data, "active");
+          if (ids) {
+            lineActiveThreads = ids;
+            releaseInactiveWorkers();
+          }
+          return;
+        }
+        if (event === "standardcode.activity_changed") {
+          const ids = idsFromEvent(data, "busy");
+          if (ids) {
+            samaActiveThreads = ids;
+            releaseInactiveWorkers();
+          }
+          return;
+        }
+        if (event !== "standardcode.machine_changed") return;
+        const key = data && typeof data === "object" ? data.key : null;
+        if (key === `${machinePrefix}.cmd`) void drainCommands();
+        else if (key === `${machinePrefix}.fsreq`) void drainFsRequests();
+        else if (key === `${machinePrefix}.name`) {
+          void getMachineName(api, identity.machine_id).then((name) => {
+            displayName = name || os8.hostname();
+          }).catch(() => {
+          });
+        }
+      },
+      onConnection: (state, attempt) => {
+        if (state === "reconnecting") {
+          if (attempt === 1) daemonLog("user stream: reconnecting");
+          return;
+        }
+        daemonLog("user stream: connected");
+        void recoverOnConnect();
+      }
+    },
+    displayName
+  );
+  hub.start();
+  void checkUpdates();
+  updateTimer = setInterval(() => void checkUpdates(), UPDATE_CHECK_MS);
   process.on("SIGTERM", () => shutdown(0));
   process.on("SIGINT", () => shutdown(0));
-  daemonLog(`daemon ready \u2014 watching for threads tagged ${runnerTag}`);
+  daemonLog(`daemon ready \u2014 waiting for work tagged ${runnerTag}`);
   await new Promise(() => {
   });
 }
@@ -8220,7 +8314,7 @@ async function installCommand(endpointFlag) {
   }
   stdout.write(`${c3.green}\u2713${c3.reset} ${result.detail}
 `);
-  stdout.write(`${c3.dim}Waiting for the daemon's first heartbeat\u2026${c3.reset}
+  stdout.write(`${c3.dim}Waiting for the daemon to connect\u2026${c3.reset}
 `);
   const deadline = Date.now() + 6e4;
   let alive = false;
@@ -8243,7 +8337,7 @@ or add one now: standardcode daemon add-project <path>${c3.reset}
     );
   } else {
     stdout.write(
-      `${c3.yellow}\u26A0${c3.reset} The service installed but no heartbeat arrived yet.
+      `${c3.yellow}\u26A0${c3.reset} The service installed but has not connected yet.
 ${c3.dim}Check ~/.standardagents/daemon.log and \`standardcode daemon status\`.${c3.reset}
 `
     );
@@ -8278,8 +8372,9 @@ async function statusCommand() {
     return;
   }
   const online = daemonOnline(record2);
-  const seen = record2.daemon ? `${Math.round((Date.now() - record2.daemon.last_seen_at) / 1e3)}s ago (v${record2.daemon.version})` : "never";
-  stdout.write(`${c3.bold}Registry:${c3.reset} ${online ? `${c3.green}online${c3.reset}` : `${c3.yellow}offline${c3.reset}`} \xB7 last heartbeat ${seen}
+  const streamConnected = !!record2.daemon && record2.daemon.last_seen_at > Date.now();
+  const seen = streamConnected && record2.daemon ? `user stream connected (v${record2.daemon.version})` : record2.daemon ? `last legacy heartbeat ${Math.round((Date.now() - record2.daemon.last_seen_at) / 1e3)}s ago (v${record2.daemon.version})` : "never";
+  stdout.write(`${c3.bold}Registry:${c3.reset} ${online ? `${c3.green}online${c3.reset}` : `${c3.yellow}offline${c3.reset}`} \xB7 ${seen}
 `);
   const projects = Object.keys(record2.projects);
   stdout.write(`${c3.bold}Projects:${c3.reset} ${projects.length ? "" : c3.dim + "none registered" + c3.reset}