@standardagents/code 0.13.2 → 0.13.4

package/dist/index.js

@@ -5,9 +5,7 @@ import readline3 from 'readline/promises';
 import { stdout, stdin } from 'process';
 import * as api_star from '@standardagents/code-network/api';
 import * as stream_star from '@standardagents/code-network/stream';
-import crypto2 from 'crypto';
-import * as heartbeat_star from '@standardagents/code-network/heartbeat';
-import * as events_stream_star from '@standardagents/code-network/events-stream';
+import * as hub_star from '@standardagents/code-network/hub';
 import * as subagent_streams_star from '@standardagents/code-network/subagent-streams';
 import * as session_state_star from '@standardagents/code-network/session-state';
 import * as transcript_delivery_star from '@standardagents/code-network/transcript-delivery';
@@ -26,6 +24,7 @@ import { startDeviceLogin, pollDeviceLogin } from '@standardagents/code-network/
 import * as recorder_star from '@standardagents/code-network/recorder';
 import * as recorder_node_star from '@standardagents/code-network/recorder-node';
 import { PRODUCTION_ENDPOINT, OPENSAMA_AGENT_ID, AGENT_ID, AGENT_ID_VARIANTS, AGENT_CHOICES } from '@standardagents/code-network/agents';
+import crypto from 'crypto';
 import { parseStopProcessArgs } from '@standardagents/code-network/registry';
 import * as relay_star from '@standardagents/code-network/relay';
 import fsp2 from 'fs/promises';
@@ -71,33 +70,37 @@ var themeGray = isLightTheme ? "\x1B[38;5;244m" : "\x1B[90m";
 var stream_exports = {};
 __reExport(stream_exports, stream_star);
 
-// src/heartbeat.ts
-var heartbeat_exports = {};
-__reExport(heartbeat_exports, heartbeat_star);
+// src/hub.ts
+var hub_exports = {};
+__reExport(hub_exports, hub_star);
 
 // src/account-user-stream.ts
 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;
+  hub;
   eventListeners = /* @__PURE__ */ new Set();
   connectionListeners = /* @__PURE__ */ new Set();
   connected = false;
+  constructor(api, clientId, options) {
+    this.hub = new hub_exports.HubSocket(
+      api,
+      clientId,
+      {
+        onEvent: (event, data) => this.emitEvent(event, data),
+        onConnection: (state, attempt) => {
+          this.connected = state === "connected";
+          this.emitConnection(state, attempt);
+        }
+      },
+      options.clientName,
+      options.clientKind,
+      options.uniqueConnectionId
+    );
+  }
   start() {
-    if (this.started || this.closed) return;
+    if (this.started) return;
     this.started = true;
-    this.openSocket();
+    this.hub.start();
   }
   onEvent(listener) {
     this.eventListeners.add(listener);
@@ -125,102 +128,65 @@ var AccountUserStream = class {
       }, timeoutMs);
     });
   }
-  openSocket() {
-    if (this.closed) return;
-    const clientId = this.options.uniqueConnectionId ? `${this.clientId}:${crypto2.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_exports.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.hub.close();
     this.eventListeners.clear();
     this.connectionListeners.clear();
   }
 };
 
-// src/events-stream.ts
-var events_stream_exports = {};
-__reExport(events_stream_exports, events_stream_star);
+// packages/core/src/session-events.ts
+var SESSION_CHANGED_EVENT = "standardcode.sessions_changed";
+var SESSION_CHANGES = /* @__PURE__ */ new Set([
+  "created",
+  "updated",
+  "deleted",
+  "metadata",
+  "activity",
+  "subagents"
+]);
+function parseSessionChangedData(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  if (typeof raw.change !== "string" || !SESSION_CHANGES.has(raw.change)) {
+    return null;
+  }
+  const parsed = {
+    change: raw.change,
+    ...typeof raw.thread_id === "string" && raw.thread_id ? { thread_id: raw.thread_id } : {}
+  };
+  if (Object.prototype.hasOwnProperty.call(raw, "name") && (raw.name === null || typeof raw.name === "string")) {
+    parsed.name = raw.name;
+  }
+  if (typeof raw.archived === "boolean") parsed.archived = raw.archived;
+  if (raw.thread && typeof raw.thread === "object" && !Array.isArray(raw.thread)) {
+    const thread = raw.thread;
+    const id = typeof thread.id === "string" && thread.id ? thread.id : parsed.thread_id;
+    if (id && (!parsed.thread_id || parsed.thread_id === id)) {
+      const delta = { id };
+      if (typeof thread.agent_id === "string") delta.agent_id = thread.agent_id;
+      if (Array.isArray(thread.tags)) {
+        delta.tags = thread.tags.filter((tag) => typeof tag === "string");
+      }
+      for (const key of ["created_at", "updated_at", "last_message_at"]) {
+        if (typeof thread[key] === "number" && Number.isFinite(thread[key])) delta[key] = thread[key];
+      }
+      for (const key of ["title", "preview"]) {
+        if (typeof thread[key] === "string") delta[key] = thread[key];
+      }
+      if (typeof thread.executing === "boolean") delta.executing = thread.executing;
+      parsed.thread = delta;
+    }
+  }
+  return parsed;
+}
 
 // src/subagent-streams.ts
 var subagent_streams_exports = {};
@@ -1628,6 +1594,11 @@ function ensureImagePlaceholders(text, images) {
   if (!missing.length) return text;
   return [text.trimEnd(), ...missing].filter(Boolean).join(" ");
 }
+function restoreTuiInput(input3 = process.stdin) {
+  readline.emitKeypressEvents(input3);
+  if (input3.isTTY) input3.setRawMode(true);
+  input3.resume();
+}
 var INPUT_BOX_MARGIN = 1;
 function inputBoxBorderColor() {
   return "\x1B[38;5;240m";
@@ -1903,10 +1874,10 @@ function sanitizeHudRow(s) {
 var Tui = class _Tui {
   constructor(level = 1) {
     this.level = level;
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) process.stdin.setRawMode(true);
-    process.stdin.on("keypress", (str, key) => this.dispatch(str, key));
-    process.stdin.resume();
+    process.stdin.on("keypress", (str, key) => {
+      if (this.inputSuspendDepth === 0) this.dispatch(str, key);
+    });
+    restoreTuiInput();
     process.stdout.write("\x1B[?2004h");
     process.on("exit", () => process.stdout.write("\x1B[?2004l\x1B[?25h"));
     process.stdout.on("resize", () => this.scheduleResizeRedraw());
@@ -1989,6 +1960,10 @@ var Tui = class _Tui {
   // takeover (approval / menu) state
   takeoverHandler = null;
   bufferedPrints = [];
+  // Plain readline prompts (notably the inline daemon installer) temporarily
+  // own stdin. While they do, ignore the duplicate keypress events delivered
+  // to this TUI; the outermost handoff restores raw/resumed input on return.
+  inputSuspendDepth = 0;
   // double-press-to-quit state: the first ctrl-c arms a brief window and shows a
   // transient hint; a second ctrl-c within the window actually quits.
   quitArmed = false;
@@ -2034,6 +2009,25 @@ var Tui = class _Tui {
   lastDraftSeen = "";
   onQuit = () => process.exit(0);
   levelListeners = [];
+  /**
+   * Let a plain readline flow own stdin, then reliably hand it back to the TUI.
+   * Supports nesting so a shared command may open more than one prompt.
+   */
+  async withSuspendedInput(run3) {
+    this.inputSuspendDepth++;
+    if (this.inputSuspendDepth === 1) {
+      process.stdout.write("\x1B[?2004l\x1B[?25h");
+    }
+    try {
+      return await run3();
+    } finally {
+      this.inputSuspendDepth--;
+      if (this.inputSuspendDepth === 0) {
+        restoreTuiInput();
+        process.stdout.write("\x1B[?2004h");
+      }
+    }
+  }
   /**
    * Terminal resize fires continuously while the user drags. Redrawing on every
    * event desyncs the region-height math (each paint uses a half-rewrapped
@@ -3910,7 +3904,7 @@ function readVersion() {
     if (typeof pkg.version === "string" && pkg.version) return pkg.version;
   } catch {
   }
-  return "0.13.2" ;
+  return "0.13.4" ;
 }
 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);
@@ -3943,7 +3937,7 @@ function loadMachineIdentity() {
   } catch {
   }
   const identity = {
-    machine_id: crypto2.randomUUID(),
+    machine_id: crypto.randomUUID(),
     created_at: Date.now()
   };
   saveMachineIdentity(identity);
@@ -3957,7 +3951,7 @@ function daemonClientId(identity) {
   return `daemon:${identity.machine_id}`;
 }
 function interactiveClientId(identity) {
-  return `cli:${identity.machine_id}:${crypto2.randomBytes(4).toString("hex")}`;
+  return `cli:${identity.machine_id}:${crypto.randomBytes(4).toString("hex")}`;
 }
 var KEY_PREFIX = "standardcode.machine.";
 var CMD_SUFFIX = ".cmd";
@@ -4338,7 +4332,7 @@ async function enqueueMachineCommand(api, machineId, kind, args) {
   const key = commandKey(machineId);
   const queue = parseCommands(await api.userKvGet(key));
   const cmd = {
-    id: crypto2.randomBytes(6).toString("hex"),
+    id: crypto.randomBytes(6).toString("hex"),
     kind,
     args,
     requested_at: Date.now()
@@ -4576,7 +4570,7 @@ function parseBrowseResult(value) {
 }
 function remoteBrowseBackend(api, accountStream, machineId, label) {
   const rpc = async (req) => {
-    const nonce = crypto2.randomBytes(8).toString("hex");
+    const nonce = crypto.randomBytes(8).toString("hex");
     const res = await requestFsBrowse(api, accountStream, machineId, { nonce, ...req }).catch(
       (error) => {
         throw new Error(
@@ -4793,7 +4787,7 @@ function download(url, dest, redirects = 5) {
   });
 }
 async function sha256File(file2) {
-  const hash = crypto2.createHash("sha256");
+  const hash = crypto.createHash("sha256");
   await new Promise((resolve, reject) => {
     const stream = fs11.createReadStream(file2);
     stream.on("data", (chunk) => hash.update(chunk));
@@ -5105,7 +5099,7 @@ var HostTools = class {
         return { ok: false, error: "args_json must be a JSON array of strings" };
       }
     }
-    const hash = crypto2.createHash("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
+    const hash = crypto.createHash("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
     const skillDir = path9.join(os6.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
     for (const f of files) {
       const dest = path9.resolve(skillDir, f.path);
@@ -5197,7 +5191,7 @@ ${truncated}`
     if (!fs11.existsSync(cwd)) {
       return { ok: false, error: `cwd does not exist: ${cwd}` };
     }
-    const id = crypto2.randomUUID().slice(0, 8);
+    const id = crypto.randomUUID().slice(0, 8);
     const logPath = path9.join(LOG_DIR, `${id}.log`);
     let out;
     try {
@@ -5601,7 +5595,7 @@ ${stderrTail.trim()}` : msg;
       target,
       argsSha256: sha256(canonicalJson(args)),
       resultSha256: sha256(text),
-      nonce: crypto2.randomBytes(8).toString("hex"),
+      nonce: crypto.randomBytes(8).toString("hex"),
       isError,
       at: Date.now()
     };
@@ -5871,7 +5865,7 @@ function sortKeys(value) {
   return value;
 }
 function sha256(input3) {
-  return crypto2.createHash("sha256").update(input3).digest("hex");
+  return crypto.createHash("sha256").update(input3).digest("hex");
 }
 
 // src/execution-session.ts
@@ -5993,6 +5987,27 @@ var DaemonUserStream = class {
     this.stream.close();
   }
 };
+
+// src/daemon-activity.ts
+var DaemonWorkerActivity = class {
+  activeTools = /* @__PURE__ */ new Set();
+  approvalLeases = /* @__PURE__ */ new Set();
+  setToolActive(toolCallId, active) {
+    if (active) this.activeTools.add(toolCallId);
+    else this.activeTools.delete(toolCallId);
+  }
+  /** Hold the worker active until the returned idempotent release runs. */
+  beginApproval() {
+    const lease = /* @__PURE__ */ Symbol("approval");
+    this.approvalLeases.add(lease);
+    return () => {
+      this.approvalLeases.delete(lease);
+    };
+  }
+  get busy() {
+    return this.activeTools.size > 0 || this.approvalLeases.size > 0;
+  }
+};
 var PKG_NAME = "@standardagents/code";
 var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PKG_NAME)}`;
 var CACHE_REL_DIR = ".config/standardagents-cli";
@@ -6171,19 +6186,7 @@ function runUpdate(pm) {
 }
 
 // src/daemon.ts
-var approvalWakes = /* @__PURE__ */ new Map();
-function subscribeApprovalWake(threadId, wake) {
-  const set = approvalWakes.get(threadId) ?? /* @__PURE__ */ new Set();
-  set.add(wake);
-  approvalWakes.set(threadId, set);
-  return () => {
-    set.delete(wake);
-    if (set.size === 0) approvalWakes.delete(threadId);
-  };
-}
-function wakeApprovals(threadId) {
-  for (const wake of approvalWakes.get(threadId) ?? []) wake();
-}
+var approvalWakes = new relay_exports.ApprovalWakeRegistry();
 var UPDATE_CHECK_MS = 6 * 60 * 6e4;
 var MAX_WORKERS = 30;
 var BRIDGE_ATTACH_GRACE_MS = 15e3;
@@ -6230,11 +6233,11 @@ var ThreadWorker = class {
       },
       hooks: {
         onActivity: (line) => daemonLog(`[${threadId.slice(0, 8)}] ${line}`),
-        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);
+        onStatus: (id, summary) => {
+          const wasBusy = this.busy;
+          this.activity.setToolActive(id, summary !== null);
+          if (this.busy) this.clearIdleTimer();
+          else if (wasBusy) this.scheduleIdle(BRIDGE_IDLE_MS);
         },
         onConnection: (state, attempt) => {
           if (state !== "reconnecting" || attempt === 1 || attempt % 10 === 0) {
@@ -6272,29 +6275,36 @@ var ThreadWorker = class {
             return { choice: "deny", reason: "No one is available to approve this right now." };
           }
           daemonLog(`[${threadId.slice(0, 8)}] relaying approval: ${summary} (risk ${effectiveRisk})`);
-          const response = await (0, relay_exports.awaitApprovalViaRelay)(
-            api,
-            threadId,
-            {
-              tool_call_id: req.toolCallId,
-              tool: req.tool,
-              summary,
-              permission: req.requestPermission,
-              risk: effectiveRisk,
-              machine: machineName,
-              requested_at: Date.now()
-            },
-            { subscribe: (wake) => subscribeApprovalWake(threadId, wake) }
-          );
-          if (!response) {
-            return { choice: "deny", reason: "The approval request timed out with no one to approve it." };
-          }
-          if (response.choice === "always") this.perm.alwaysAllow.add(permKey);
-          if (response.choice === "always_risk") this.perm.allowRisk.add(effectiveRisk);
-          if (response.choice === "always" || response.choice === "always_risk") {
-            (0, approvals_exports.saveApprovals)(api, threadId, this.perm);
+          const releaseApproval = this.activity.beginApproval();
+          this.clearIdleTimer();
+          try {
+            const response = await (0, relay_exports.awaitApprovalViaRelay)(
+              api,
+              threadId,
+              {
+                tool_call_id: req.toolCallId,
+                tool: req.tool,
+                summary,
+                permission: req.requestPermission,
+                risk: effectiveRisk,
+                machine: machineName,
+                requested_at: Date.now()
+              },
+              { subscribe: (wake) => approvalWakes.subscribe(threadId, wake) }
+            );
+            if (!response) {
+              return { choice: "deny", reason: "The approval request timed out with no one to approve it." };
+            }
+            if (response.choice === "always") this.perm.alwaysAllow.add(permKey);
+            if (response.choice === "always_risk") this.perm.allowRisk.add(effectiveRisk);
+            if (response.choice === "always" || response.choice === "always_risk") {
+              (0, approvals_exports.saveApprovals)(api, threadId, this.perm);
+            }
+            return { choice: response.choice, reason: response.reason };
+          } finally {
+            releaseApproval();
+            if (!this.busy) this.scheduleIdle(BRIDGE_IDLE_MS);
           }
-          return { choice: response.choice, reason: response.reason };
         }
       }
     });
@@ -6309,7 +6319,7 @@ var ThreadWorker = class {
   createdAt;
   session;
   perm;
-  inFlight = 0;
+  activity = new DaemonWorkerActivity();
   idleTimer = null;
   watchedAnotherOwner = false;
   /** Set by the daemon so a superseded worker can remove itself. */
@@ -6317,7 +6327,7 @@ var ThreadWorker = class {
   /** Set by the daemon so an inactive bridge removes itself. */
   onIdle;
   get busy() {
-    return this.inFlight > 0;
+    return this.activity.busy;
   }
   clearIdleTimer() {
     if (!this.idleTimer) return;
@@ -6686,7 +6696,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       onEvent: (event, data) => {
         if (event === "standardcode.approval_changed") {
           const threadId = data && typeof data === "object" ? data.thread_id : null;
-          if (typeof threadId === "string") wakeApprovals(threadId);
+          if (typeof threadId === "string") approvalWakes.wake(threadId);
           return;
         }
         if (event === "standardcode.lines_changed") {
@@ -6706,16 +6716,21 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
           return;
         }
         if (event !== "standardcode.machine_changed") return;
-        const key = data && typeof data === "object" ? data.key : null;
+        const frame = data && typeof data === "object" ? data : null;
+        const key = frame?.key;
         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 || os6.hostname();
-          }).catch(() => {
-          });
+          if (frame && Object.prototype.hasOwnProperty.call(frame, "value")) {
+            displayName = typeof frame.value === "string" && frame.value.trim() ? frame.value.trim() : os6.hostname();
+          } else {
+            void getMachineName(api, identity.machine_id).then((name) => {
+              displayName = name || os6.hostname();
+            }).catch(() => {
+            });
+          }
         }
       },
       onConnection: (state, attempt) => {
@@ -6727,6 +6742,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
           return;
         }
         daemonLog("user stream: connected");
+        approvalWakes.wakeAll();
         void publishPresence(true).then(() => recoverOnConnect());
       }
     },
@@ -7125,6 +7141,11 @@ async function runDaemonCommand(argv) {
   const { endpoint, rest } = parseEndpointFlag(restArgs);
   switch (command) {
     case "run":
+      if (rest.includes("--ephemeral") || process.env.STANDARD_CODE_EPHEMERAL === "1") {
+        process.stdin.resume();
+        process.stdin.on("end", () => process.exit(0));
+        process.stdin.on("close", () => process.exit(0));
+      }
       await runDaemon({ endpoint: endpoint || process.env.STANDARD_CODE_DAEMON_ENDPOINT });
       return;
     case "install":
@@ -7802,45 +7823,47 @@ ${c5.dim}Install it with \`standardcode daemon install\`, or run this session on
       return false;
     }
     localOfferAnswered = true;
-    stdout.write(
-      `
+    return tui.withSuspendedInput(async () => {
+      stdout.write(
+        `
 ${c5.bold}This machine has no always-on daemon${c5.reset} ${c5.dim}\u2014 the daemon is what runs sessions here.${c5.reset}
 `
-    );
-    const promptRl = readline3.createInterface({ input: stdin, output: stdout });
-    let answer = "";
-    try {
-      answer = (await promptRl.question(
-        `${c5.white}Install it now so this machine can run sessions?${c5.reset} ${c5.dim}[Y/n]${c5.reset} `
-      )).trim().toLowerCase();
-    } catch {
-      answer = "n";
-    } finally {
-      promptRl.close();
-    }
-    if (answer !== "" && answer !== "y" && answer !== "yes") {
-      savePrefs({ daemon_install_declined_at: Date.now() });
-      stdout.write(
-        `${c5.dim}Okay \u2014 this machine can't run sessions until the daemon is installed.
+      );
+      const promptRl = readline3.createInterface({ input: stdin, output: stdout });
+      let answer = "";
+      try {
+        answer = (await promptRl.question(
+          `${c5.white}Install it now so this machine can run sessions?${c5.reset} ${c5.dim}[Y/n]${c5.reset} `
+        )).trim().toLowerCase();
+      } catch {
+        answer = "n";
+      } finally {
+        promptRl.close();
+      }
+      if (answer !== "" && answer !== "y" && answer !== "yes") {
+        savePrefs({ daemon_install_declined_at: Date.now() });
+        stdout.write(
+          `${c5.dim}Okay \u2014 this machine can't run sessions until the daemon is installed.
 Run \`standardcode daemon install\` any time, or pick another machine.${c5.reset}
 
 `
-      );
-      return false;
-    }
-    await runDaemonCommand(endpointOverride ? ["install", "--endpoint", endpoint] : ["install"]);
-    stdout.write("\n");
-    self = await loadMachine(api, identity.machine_id).catch(() => null) ?? self;
-    localDaemonOnline = Boolean(self && daemonOnline(self));
-    if (self) session.localName = machineDisplayName(self);
-    if (!localDaemonOnline) {
-      stdout.write(
-        `${c5.dim}The daemon hasn't connected yet \u2014 check \`standardcode daemon status\`, or pick another machine.${c5.reset}
+        );
+        return false;
+      }
+      await runDaemonCommand(endpointOverride ? ["install", "--endpoint", endpoint] : ["install"]);
+      stdout.write("\n");
+      self = await loadMachine(api, identity.machine_id).catch(() => null) ?? self;
+      localDaemonOnline = Boolean(self && daemonOnline(self));
+      if (self) session.localName = machineDisplayName(self);
+      if (!localDaemonOnline) {
+        stdout.write(
+          `${c5.dim}The daemon hasn't connected yet \u2014 check \`standardcode daemon status\`, or pick another machine.${c5.reset}
 
 `
-      );
-    }
-    return localDaemonOnline;
+        );
+      }
+      return localDaemonOnline;
+    });
   };
   const launchDir = projectDir;
   let tags = [];
@@ -7855,6 +7878,14 @@ Run \`standardcode daemon install\` any time, or pick another machine.${c5.reset
       void enqueueMachineCommand(api, session.runner.id, "add_project", { path: runnerPath }).catch(() => {
       });
     }
+    const createdAt = Math.floor(Date.now() / 1e3);
+    await api.notifySessionsChanged(id, "created", {
+      id,
+      agent_id: selectedAgent,
+      tags,
+      created_at: createdAt,
+      updated_at: createdAt
+    });
     return id;
   };
   let threadId = "";
@@ -8121,6 +8152,7 @@ async function runAgentSwitchMenu(tui, api, threadId) {
   const title = AGENT_CHOICES.find((choice) => choice.id === picked)?.title ?? picked;
   try {
     await api.setThreadAgent(threadId, picked);
+    await api.notifySessionsChanged(threadId, "updated", { id: threadId, agent_id: picked });
     tui.setAgentLabel(title);
     tui.print(`${c5.green}\u2713${c5.reset} Session handed to ${c5.bold}${title}${c5.reset} \u2014 applies from your next message.`);
   } catch (e) {
@@ -8351,15 +8383,12 @@ async function runInteractive(tui, api, accountStream, threadId, projectDir, mac
       if (eventType === "generation" && typeof data?.outputTokens === "number") {
         liveOut = data.outputTokens;
         refreshStatus();
-        scheduleProjectionRefresh();
       } else if (eventType === "tool_call_started" && data?.id) {
         activeSteps.set(data.id, data.progress || data.name || "working");
         refreshStatus();
-        scheduleProjectionRefresh();
       } else if (eventType === "tool_call_done" && data?.id) {
         activeSteps.delete(data.id);
         refreshStatus();
-        scheduleProjectionRefresh();
       } else if (eventType === "goal_updated" && data) {
         tui.setGoal(data);
       } else if (eventType === "standardcode.approval_changed") {
@@ -8423,25 +8452,18 @@ async function runInteractive(tui, api, accountStream, threadId, projectDir, mac
       }
     }, 150);
   };
-  const events = new events_stream_exports.SystemEvents(api, {
-    onOpen: () => scheduleReconcile(),
-    onThreadCreated: (t) => {
-      if (t.parent === threadId) scheduleReconcile();
-    },
-    onThreadUpdated: (t) => {
-      if (t.parent === threadId) scheduleReconcile();
-    },
-    onThreadDeleted: (id) => {
-      if (activeSubagents.has(id)) scheduleReconcile();
-    }
+  const stopSessionEvents = accountStream.onEvent((event, data) => {
+    if (event !== SESSION_CHANGED_EVENT) return;
+    const changed = parseSessionChangedData(data);
+    if (changed?.thread_id === threadId && changed.change === "subagents") scheduleReconcile();
   });
   let endSession;
   const sessionEnded = new Promise((r) => endSession = r);
   const quit = async () => {
     tui.end();
     stopWatchingConnection();
+    stopSessionEvents();
     stream.close();
-    events.close();
     subActivity.closeAll();
     farewell(busy ? runnerName : void 0);
     process.exit(0);
@@ -9023,16 +9045,17 @@ ${c5.gray}Close another session (its slot frees within ~90s), then resend your m
       if (attempt >= 4) tui.setConnected(false);
     } else {
       tui.setConnected(true);
+      scheduleReconcile();
     }
   });
-  events.connect();
+  scheduleReconcile();
   await stream.connect();
   void api.getGoal(threadId).then((g) => tui.setGoal(g)).catch(() => {
   });
   attaching.stop();
   const header = `${c5.bold}${c5.magenta}Standard Code${c5.reset} ${c5.dim}\u2014 ${agentTitle}${c5.reset}`;
   const daemonVersion = remote ? session.runner?.daemon?.version : (await loadMachine(api, session.identity.machine_id).catch(() => null))?.daemon?.version;
-  const execLine = `${c5.gray}tool execution:${c5.reset} daemon${daemonVersion ? ` v${daemonVersion}` : ""} on ${runnerName}  ${c5.dim}(this terminal watches)${c5.reset}`;
+  const execLine = `${c5.gray}tool execution:${c5.reset} daemon${daemonVersion ? ` v${daemonVersion}` : ""} on ${runnerName}`;
   tui.setAgentLabel(agentTitle);
   tui.banner(
     remote ? [
@@ -9222,8 +9245,8 @@ ${c5.dim}runs on ${request.machine || runnerName}${c5.reset}`,
   const stopped = api.stopThread(threadId).catch(() => {
   });
   stopWatchingConnection();
+  stopSessionEvents();
   stream.close();
-  events.close();
   subActivity.closeAll();
   await Promise.race([stopped, new Promise((r) => setTimeout(r, 1500))]);
   tui.setWorking(false);