@standardagents/code 0.12.1 → 0.13.1

package/dist/index.js

@@ -632,6 +632,17 @@ var ApiClient = class {
   }
   /** Write one value to the signed-in user's account-wide KV (null deletes). */
   async userKvSet(key, value) {
+    if (key.startsWith("standardcode.machine.")) {
+      try {
+        await this.json(`/api/users/me/standardcode/machine_value`, {
+          method: "POST",
+          body: JSON.stringify({ key, value })
+        });
+        return;
+      } catch (error) {
+        if (!(error instanceof ApiHttpError) || error.status !== 404) throw error;
+      }
+    }
     await this.json(`/api/users/me/kv`, {
       method: "POST",
       body: JSON.stringify({ key, value })
@@ -2028,7 +2039,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/*
@@ -3094,6 +3106,147 @@ var MessageStream = class {
     }
   }
 };
+var AccountUserStream = class {
+  constructor(api, clientId, options) {
+    this.api = api;
+    this.clientId = clientId;
+    this.options = options;
+  }
+  api;
+  clientId;
+  options;
+  ws = null;
+  closed = false;
+  started = false;
+  heartbeat = null;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  eventListeners = /* @__PURE__ */ new Set();
+  connectionListeners = /* @__PURE__ */ new Set();
+  connected = false;
+  start() {
+    if (this.started || this.closed) return;
+    this.started = true;
+    this.openSocket();
+  }
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => this.eventListeners.delete(listener);
+  }
+  onConnection(listener) {
+    this.connectionListeners.add(listener);
+    return () => this.connectionListeners.delete(listener);
+  }
+  /** Wait for a live socket. The timeout is local and performs no network work. */
+  waitUntilConnected(timeoutMs = 15e3) {
+    if (this.connected) return Promise.resolve();
+    this.start();
+    return new Promise((resolve, reject) => {
+      let timer;
+      const remove = this.onConnection((state) => {
+        if (state !== "connected") return;
+        clearTimeout(timer);
+        remove();
+        resolve();
+      });
+      timer = setTimeout(() => {
+        remove();
+        reject(new Error("The account stream did not connect in time."));
+      }, timeoutMs);
+    });
+  }
+  openSocket() {
+    if (this.closed) return;
+    const clientId = this.options.uniqueConnectionId ? `${this.clientId}:${crypto.randomBytes(8).toString("hex")}` : this.clientId;
+    let url = `${this.api.wsEndpoint}/api/users/me/stream?token=${encodeURIComponent(this.api.bearer)}&client_id=${encodeURIComponent(clientId)}&client_kind=${encodeURIComponent(this.options.clientKind)}`;
+    if (this.options.clientName) url += `&client_name=${encodeURIComponent(this.options.clientName)}`;
+    let ws;
+    try {
+      ws = new WebSocket(url);
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.addEventListener("open", () => {
+      if (this.ws !== ws) return;
+      this.connected = true;
+      this.reconnectAttempt = 0;
+      this.startHeartbeat(ws);
+      this.emitConnection("connected", 0);
+    });
+    ws.addEventListener("message", (event) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(event.data));
+    });
+    ws.addEventListener("error", () => this.handleDrop(ws));
+    ws.addEventListener("close", () => this.handleDrop(ws));
+  }
+  onMessage(raw) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!message || typeof message !== "object") return;
+    const frame = message;
+    if (typeof frame.event === "string") {
+      this.emitEvent(frame.event, frame.data);
+      return;
+    }
+    if (frame.type === "wake" && typeof frame.threadId === "string") {
+      this.emitEvent("standardagents.wake", { thread_id: frame.threadId });
+    }
+  }
+  emitEvent(event, data) {
+    for (const listener of this.eventListeners) listener(event, data);
+  }
+  emitConnection(state, attempt) {
+    for (const listener of this.connectionListeners) listener(state, attempt);
+  }
+  handleDrop(ws) {
+    if (this.ws !== ws) return;
+    this.ws = null;
+    this.connected = false;
+    this.stopHeartbeat();
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer) return;
+    this.reconnectAttempt++;
+    this.emitConnection("reconnecting", this.reconnectAttempt);
+    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15e3);
+    const delay = base + Math.floor(Math.random() * 400);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.openSocket();
+    }, delay);
+  }
+  startHeartbeat(ws) {
+    this.stopHeartbeat();
+    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws), { request: "stream_ping" });
+    this.heartbeat.start();
+  }
+  stopHeartbeat() {
+    this.heartbeat?.stop();
+    this.heartbeat = null;
+  }
+  close() {
+    this.closed = true;
+    this.connected = false;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close();
+    this.eventListeners.clear();
+    this.connectionListeners.clear();
+  }
+};
 
 // src/events-stream.ts
 var SystemEvents = class {
@@ -6491,7 +6644,7 @@ function readVersion() {
     if (typeof pkg.version === "string" && pkg.version) return pkg.version;
   } catch {
   }
-  return "0.12.1" ;
+  return "0.13.1" ;
 }
 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,12 +6759,67 @@ 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 requestFsBrowse(api, accountStream, machineId, req, timeoutMs = 15e3) {
+  await accountStream.waitUntilConnected(timeoutMs);
+  const responseKey = fsResponseKey(machineId);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let reading = false;
+    let readAgain = false;
+    let timer;
+    let removeEvent = () => {
+    };
+    let removeConnection = () => {
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      removeEvent();
+      removeConnection();
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const read = async () => {
+      if (settled) return;
+      if (reading) {
+        readAgain = true;
+        return;
+      }
+      reading = true;
+      try {
+        do {
+          readAgain = false;
+          const response = await readFsResponse(api, machineId);
+          if (response?.nonce === req.nonce) {
+            settled = true;
+            cleanup();
+            resolve(response);
+            return;
+          }
+        } while (readAgain && !settled);
+      } catch (error) {
+        fail(error);
+      } finally {
+        reading = false;
+      }
+    };
+    removeEvent = accountStream.onEvent((event, data) => {
+      if (event !== "standardcode.machine_changed") return;
+      const key = data && typeof data === "object" ? data.key : null;
+      if (key === responseKey) void read();
+    });
+    removeConnection = accountStream.onConnection((state) => {
+      if (state === "connected") void read();
+    });
+    timer = setTimeout(
+      () => fail(new Error("The remote machine did not answer in time.")),
+      timeoutMs
+    );
+    void writeFsRequest(api, machineId, req).catch(fail);
+  });
 }
 async function writeFsResponse(api, machineId, res) {
   await api.userKvSet(fsResponseKey(machineId), { ...res, responded_at: Date.now() });
@@ -6762,8 +6970,11 @@ async function loadMachine(api, machineId) {
   overlayProjectNames(rec, projNames);
   return rec;
 }
+var CONNECTED_LAST_SEEN_AT = Number.MAX_SAFE_INTEGER;
 function daemonOnline(record2, now = Date.now()) {
-  return !!record2.daemon && now - record2.daemon.last_seen_at < DAEMON_ONLINE_WINDOW_MS;
+  if (!record2.daemon) return false;
+  if (typeof record2.daemon.connected === "boolean") return record2.daemon.connected;
+  return now - record2.daemon.last_seen_at < DAEMON_ONLINE_WINDOW_MS;
 }
 function newRecord(identity) {
   const now = Date.now();
@@ -6792,6 +7003,18 @@ async function updateOwnMachineRecord(api, identity, mutate) {
   await api.userKvSet(machineKey(identity.machine_id), record2);
   return record2;
 }
+async function setDaemonPresence(api, identity, version, connected, pid = process.pid) {
+  await updateOwnMachineRecord(api, identity, (record2) => {
+    const now = Date.now();
+    record2.daemon = {
+      version,
+      installed_at: record2.daemon?.installed_at ?? now,
+      last_seen_at: connected ? CONNECTED_LAST_SEEN_AT : 0,
+      connected,
+      pid
+    };
+  });
+}
 function projectRepository(projectDir) {
   try {
     const url = execFileSync("git", ["-C", projectDir, "remote", "get-url", "origin"], {
@@ -6838,17 +7061,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;
@@ -7045,22 +7257,20 @@ function parseBrowseResult(value) {
     error: typeof r.error === "string" ? r.error : void 0
   };
 }
-function remoteBrowseBackend(api, machineId, label) {
+function remoteBrowseBackend(api, accountStream, machineId, label) {
   const rpc = async (req) => {
     const nonce = crypto.randomBytes(8).toString("hex");
-    await writeFsRequest(api, machineId, { nonce, ...req });
-    const deadline = Date.now() + 15e3;
-    while (Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, 700));
-      const res = await readFsResponse(api, machineId).catch(() => null);
-      if (res && res.nonce === nonce) {
-        if (!res.ok) throw new Error(res.error || "Browse failed on the remote machine.");
-        const parsed = parseBrowseResult(res.result);
-        if (!parsed) throw new Error("The remote machine sent an unreadable listing.");
-        return parsed;
+    const res = await requestFsBrowse(api, accountStream, machineId, { nonce, ...req }).catch(
+      (error) => {
+        throw new Error(
+          error instanceof Error && error.message === "The remote machine did not answer in time." ? `${label} didn't answer \u2014 is its daemon online?` : error instanceof Error ? error.message : String(error)
+        );
       }
-    }
-    throw new Error(`${label} didn't answer \u2014 is its daemon online?`);
+    );
+    if (!res.ok) throw new Error(res.error || "Browse failed on the remote machine.");
+    const parsed = parseBrowseResult(res.result);
+    if (!parsed) throw new Error("The remote machine sent an unreadable listing.");
+    return parsed;
   };
   return {
     label,
@@ -7243,105 +7453,30 @@ async function awaitApprovalViaRelay(api, threadId, request, options = {}) {
   }
 }
 
-// src/hub.ts
-var HubSocket = class {
+// src/daemon-user-stream.ts
+var DaemonUserStream = class {
+  stream;
   constructor(api, clientId, hooks, clientName) {
-    this.api = api;
-    this.clientId = clientId;
-    this.hooks = hooks;
-    this.clientName = clientName;
-  }
-  api;
-  clientId;
-  hooks;
-  clientName;
-  ws = null;
-  closed = false;
-  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`;
-    if (this.clientName) url += `&client_name=${encodeURIComponent(this.clientName)}`;
-    let ws;
-    try {
-      ws = new WebSocket(url);
-    } catch {
-      this.scheduleReconnect();
-      return;
-    }
-    this.ws = ws;
-    ws.addEventListener("open", () => {
-      this.reconnectAttempt = 0;
-      this.startHeartbeat(ws);
-      this.hooks.onConnection?.("connected", 0);
+    this.stream = new AccountUserStream(api, clientId, {
+      clientKind: "daemon",
+      clientName,
+      uniqueConnectionId: true
     });
-    ws.addEventListener("message", (ev) => {
-      if (this.ws === ws) this.heartbeat?.markAlive();
-      this.onMessage(String(ev.data));
+    this.stream.onEvent((event, data) => {
+      if (event === "standardagents.wake") {
+        const threadId = data?.thread_id;
+        if (typeof threadId === "string") hooks.onWake(threadId);
+        return;
+      }
+      hooks.onEvent(event, data);
     });
-    ws.addEventListener("error", () => this.handleDrop(ws));
-    ws.addEventListener("close", () => this.handleDrop(ws));
+    if (hooks.onConnection) this.stream.onConnection(hooks.onConnection);
   }
-  onMessage(raw) {
-    let msg;
-    try {
-      msg = 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);
-      return;
-    }
-    if (frame.type === "wake" && typeof frame.threadId === "string") {
-      this.hooks.onWake(frame.threadId);
-    }
-  }
-  handleDrop(ws) {
-    if (this.ws !== ws) return;
-    this.ws = null;
-    this.stopHeartbeat();
-    this.scheduleReconnect();
-  }
-  scheduleReconnect() {
-    if (this.closed || this.reconnectTimer) return;
-    this.reconnectAttempt++;
-    this.hooks.onConnection?.("reconnecting", this.reconnectAttempt);
-    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15e3);
-    const delay = base + Math.floor(Math.random() * 400);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.openSocket();
-    }, delay);
-  }
-  startHeartbeat(ws) {
-    this.stopHeartbeat();
-    this.heartbeat = new Heartbeat(ws, () => this.handleDrop(ws), { request: "stream_ping" });
-    this.heartbeat.start();
-  }
-  stopHeartbeat() {
-    if (this.heartbeat) {
-      this.heartbeat.stop();
-      this.heartbeat = null;
-    }
+  start() {
+    this.stream.start();
   }
   close() {
-    this.closed = true;
-    this.stopHeartbeat();
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.ws?.close();
+    this.stream.close();
   }
 };
 var PKG_NAME = "@standardagents/code";
@@ -7522,12 +7657,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 +7706,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 +7715,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 +7778,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 +7849,67 @@ 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 setDaemonPresence(api, identity, version, false).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;
+  let presenceWrite = Promise.resolve();
+  function publishPresence(connected) {
+    presenceWrite = presenceWrite.then(() => setDaemonPresence(api, identity, version, connected)).catch((error) => {
+      daemonLog(
+        `presence ${connected ? "publish" : "clear"} failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+    return presenceWrite;
+  }
+  async function shutdown(code) {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (updateTimer) clearInterval(updateTimer);
+    for (const worker of workers.values()) worker.stop();
+    workers.clear();
+    hub?.close();
+    await Promise.race([
+      publishPresence(false),
+      new Promise((resolve) => setTimeout(resolve, 2e3))
+    ]);
+    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");
+        await shutdown(0);
+        return;
+      }
+      restartInProgress = false;
+    }
+    if (updateReady) {
+      daemonLog("restarting to apply the installed update");
+      await 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 +7929,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 +7958,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 +7983,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,39 +8019,40 @@ 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);
+      let req;
+      try {
+        req = await readFsRequest(api, identity.machine_id);
+      } catch (error2) {
+        daemonLog(`fs-browse request read failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        return;
+      }
       if (!req || req.nonce === lastFsNonce) return;
       lastFsNonce = req.nonce;
+      daemonLog(`fs-browse ${req.op} received (${req.nonce})`);
       let ok = true;
       let result;
       let error;
@@ -7893,46 +8062,144 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
         ok = false;
         error = err instanceof Error ? err.message : "browse failed";
       }
-      await writeFsResponse(api, identity.machine_id, { nonce: req.nonce, ok, result, error }).catch(() => {
-      });
+      try {
+        await writeFsResponse(api, identity.machine_id, { nonce: req.nonce, ok, result, error });
+        daemonLog(`fs-browse ${req.op} ${ok ? "answered" : "failed"} (${req.nonce})${error ? `: ${error}` : ""}`);
+      } catch (writeError) {
+        daemonLog(`fs-browse response write failed (${req.nonce}): ${writeError instanceof Error ? writeError.message : String(writeError)}`);
+      }
     } 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();
+      }
+    }
   };
-  process.on("SIGTERM", () => shutdown(0));
-  process.on("SIGINT", () => shutdown(0));
-  daemonLog(`daemon ready \u2014 watching for threads tagged ${runnerTag}`);
+  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;
+        daemonLog(`machine event: ${typeof key === "string" ? key : "missing key"}`);
+        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");
+            void publishPresence(false);
+          }
+          return;
+        }
+        daemonLog("user stream: connected");
+        void publishPresence(true).then(() => recoverOnConnect());
+      }
+    },
+    displayName
+  );
+  hub.start();
+  void checkUpdates();
+  updateTimer = setInterval(() => void checkUpdates(), UPDATE_CHECK_MS);
+  process.on("SIGTERM", () => void shutdown(0));
+  process.on("SIGINT", () => void shutdown(0));
+  daemonLog(`daemon ready \u2014 waiting for work tagged ${runnerTag}`);
   await new Promise(() => {
   });
 }
@@ -8220,7 +8487,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 +8510,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 +8545,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.connected ?? record2.daemon.last_seen_at > Date.now());
+  const seen = streamConnected && record2.daemon ? `user stream connected (v${record2.daemon.version})` : record2.daemon?.connected === false ? `user stream disconnected (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}
@@ -8933,6 +9201,12 @@ ${c5.dim}Press Control-C again to exit${c5.reset}
   handoffClosing = true;
   reader.rl?.close();
   const identity = loadMachineIdentity();
+  const accountStream = new AccountUserStream(api, interactiveClientId(identity), {
+    clientKind: "cli",
+    clientName: `${machine} (terminal)`
+  });
+  accountStream.start();
+  process.once("exit", () => accountStream.close());
   void registerProject(api, identity, projectDir).catch(() => {
   });
   const tui = new Tui(1);
@@ -9060,7 +9334,7 @@ ${c5.bold}This machine has no always-on daemon${c5.reset} ${c5.dim}\u2014 sessio
       session.remotePath = void 0;
       projectDir = launchDir;
       if (where) {
-        const remotePath = await pickRemoteProject(tui, api, where);
+        const remotePath = await pickRemoteProject(tui, api, accountStream, where);
         if (!remotePath) {
           step = "machine";
           continue;
@@ -9180,7 +9454,18 @@ ${c5.bold}This machine has no always-on daemon${c5.reset} ${c5.dim}\u2014 sessio
   }
   for (; ; ) {
     const agentTitle = AGENT_CHOICES.find((a) => a.id === selectedAgent)?.title ?? selectedAgent;
-    await runInteractive(tui, api, threadId, projectDir, machine, resumed, session, agentTitle, historySeed);
+    await runInteractive(
+      tui,
+      api,
+      accountStream,
+      threadId,
+      projectDir,
+      machine,
+      resumed,
+      session,
+      agentTitle,
+      historySeed
+    );
     historySeed = threadId;
     threadId = await createSessionThread();
     await api.kvSet(threadId, "lease_supersedes", historySeed);
@@ -9284,7 +9569,7 @@ async function pickLocalProject(tui, api, self, cwd, machineName) {
   if (picked !== NEW) return picked;
   return await pickDirectory(tui, localBrowseBackend(label), { startPath: cwd, loader: startLoader });
 }
-async function pickRemoteProject(tui, api, runner) {
+async function pickRemoteProject(tui, api, accountStream, runner) {
   const ENTER_PATH = "__enter_path__";
   const projects = Object.entries(runner.projects).sort(
     (a, b) => (b[1]?.last_used_at ?? 0) - (a[1]?.last_used_at ?? 0)
@@ -9306,7 +9591,7 @@ async function pickRemoteProject(tui, api, runner) {
   );
   if (!picked) return null;
   if (picked !== ENTER_PATH) return picked;
-  return await pickDirectory(tui, remoteBrowseBackend(api, runner.id, runner.name), {
+  return await pickDirectory(tui, remoteBrowseBackend(api, accountStream, runner.id, runner.name), {
     loader: startLoader
   });
 }
@@ -9374,7 +9659,7 @@ async function printHistory(api, threadId, tui) {
     else printAssistant(tui, text);
   }
 }
-async function runInteractive(tui, api, threadId, projectDir, machine, resumed, session, agentTitle, historySeedThreadId) {
+async function runInteractive(tui, api, accountStream, threadId, projectDir, machine, resumed, session, agentTitle, historySeedThreadId) {
   const remote = session.mode === "remote";
   const runnerName = session.runner?.name ?? "the remote machine";
   let currentOwner = null;
@@ -10034,7 +10319,7 @@ ${c5.gray}Close another session (its slot frees within ~90s), then resend your m
       name: "machines",
       label: "Your machines",
       hint: "list, rename, update, manage projects",
-      run: () => runMachinesMenu(tui, api, session.identity)
+      run: () => runMachinesMenu(tui, api, accountStream, session.identity)
     },
     {
       name: "daemon",
@@ -10511,7 +10796,7 @@ async function runLevelMenu(tui, perm) {
     perm.level = picked;
   }
 }
-async function runMachinesMenu(tui, api, self) {
+async function runMachinesMenu(tui, api, accountStream, self) {
   let machines;
   try {
     machines = await loadMachines(api);
@@ -10540,9 +10825,9 @@ async function runMachinesMenu(tui, api, self) {
   );
   if (!picked) return;
   const machine = machines.find((m) => m.id === picked);
-  await manageMachine(tui, api, self, machine);
+  await manageMachine(tui, api, accountStream, self, machine);
 }
-async function manageMachine(tui, api, self, machine) {
+async function manageMachine(tui, api, accountStream, self, machine) {
   const isSelf = machine.id === self.machine_id;
   const online = daemonOnline(machine);
   const canRunCommands = isSelf || !!machine.daemon;
@@ -10580,7 +10865,7 @@ async function manageMachine(tui, api, self, machine) {
       machine.icon = trimmed || void 0;
       tui.print(`${c5.green}\u2713${c5.reset} icon ${trimmed ? `set to ${trimmed}` : "reset"} for ${machine.name}`);
     }
-    return manageMachine(tui, api, self, machine);
+    return manageMachine(tui, api, accountStream, self, machine);
   }
   const dispatch = async (kind, args) => {
     if (isSelf) {
@@ -10608,10 +10893,10 @@ async function manageMachine(tui, api, self, machine) {
       tui.print(`${c5.green}\u2713${c5.reset} Update ${c5.gray}${applyNote} (its daemon updates and restarts on the new version).${c5.reset}`);
     }
   } else if (action === "projects") {
-    await manageMachineProjects(tui, api, self, machine, dispatch, applyNote);
+    await manageMachineProjects(tui, api, accountStream, self, machine, dispatch, applyNote);
   }
 }
-async function manageMachineProjects(tui, api, self, machine, dispatch, applyNote) {
+async function manageMachineProjects(tui, api, accountStream, self, machine, dispatch, applyNote) {
   const ADD = "__add__";
   const paths = Object.keys(machine.projects).sort();
   const projLabels = projectDisplayLabels(machine.projects);
@@ -10630,7 +10915,7 @@ async function manageMachineProjects(tui, api, self, machine, dispatch, applyNot
   if (!picked) return;
   if (picked === ADD) {
     const isSelf = machine.id === self.machine_id;
-    const backend = isSelf ? localBrowseBackend(machine.name) : remoteBrowseBackend(api, machine.id, machine.name);
+    const backend = isSelf ? localBrowseBackend(machine.name) : remoteBrowseBackend(api, accountStream, machine.id, machine.name);
     const chosen = await pickDirectory(tui, backend, {
       startPath: isSelf ? process.cwd() : null,
       loader: startLoader