@standardagents/code 0.9.11 → 0.10.1

package/dist/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import os7, { homedir } from 'os';
-import path3 from 'path';
+import os8, { homedir } from 'os';
+import path4 from 'path';
 import readline2 from 'readline/promises';
 import { stdout, stdin } from 'process';
-import fs4 from 'fs';
+import net from 'net';
+import fs5 from 'fs';
 import fsp from 'fs/promises';
 import crypto from 'crypto';
 import { spawn, execFileSync, spawnSync, execFile } from 'child_process';
@@ -365,6 +366,25 @@ var ApiClient = class {
       user_id: t.user_id ?? null
     })).filter((t) => !me || !t.user_id || t.user_id === me).filter((t) => requireTags.every((tag) => t.tags.includes(tag)));
   }
+  /**
+   * Fetch one thread's summary (id, tags, created_at, terminated). Used by the
+   * daemon's hub wake handler to resolve a cold thread's runner tag + project
+   * before attaching. Returns null if the thread is gone or unreadable.
+   */
+  async getThread(threadId) {
+    try {
+      const t = await this.json(`/api/threads/${threadId}`);
+      if (!t || !t.id) return null;
+      return {
+        id: t.id,
+        tags: Array.isArray(t.tags) ? t.tags : [],
+        created_at: t.created_at,
+        terminated: t.terminated ?? null
+      };
+    } catch {
+      return null;
+    }
+  }
   /** The authenticated user's id (cached). Null when the instance doesn't
    *  report one (super-admin sessions, very old instances). */
   meUserId;
@@ -805,6 +825,185 @@ var Heartbeat = class {
     this.onDead();
   }
 };
+var ALLOWED_HOST = "chatgpt.com";
+var ALLOWED_PORT = 443;
+var CHUNK_BYTES = 256 * 1024;
+var TunnelManager = class {
+  constructor(send) {
+    this.send = send;
+  }
+  send;
+  tunnels = /* @__PURE__ */ new Map();
+  /** Whether a stream_* frame belongs to this manager. */
+  handles(type) {
+    return type === "stream_open" || type === "stream_data" || type === "stream_end" || type === "stream_abort";
+  }
+  /** Dispatch one decoded stream_* frame. */
+  handleFrame(msg) {
+    const id = typeof msg.id === "string" ? msg.id : null;
+    if (!id) return;
+    switch (msg.type) {
+      case "stream_open":
+        this.open(msg);
+        return;
+      case "stream_data": {
+        const tunnel = this.tunnels.get(id);
+        if (!tunnel) return;
+        if (typeof msg.data !== "string") return;
+        try {
+          tunnel.socket.write(Buffer.from(msg.data, "base64"));
+        } catch {
+          this.fail(id, "write to upstream failed");
+        }
+        return;
+      }
+      case "stream_end": {
+        const tunnel = this.tunnels.get(id);
+        if (tunnel) {
+          try {
+            tunnel.socket.end();
+          } catch {
+          }
+        }
+        return;
+      }
+      case "stream_abort": {
+        this.teardown(id);
+        return;
+      }
+    }
+  }
+  open(frame) {
+    const id = frame.id;
+    if (frame.tool !== "tcp_tunnel") {
+      this.send({ type: "stream_error", id, error: `Unsupported stream tool: ${frame.tool}` });
+      return;
+    }
+    const host = typeof frame.meta?.host === "string" ? frame.meta.host : "";
+    const port = typeof frame.meta?.port === "number" ? frame.meta.port : 0;
+    if (host !== ALLOWED_HOST || port !== ALLOWED_PORT) {
+      this.send({
+        type: "stream_error",
+        id,
+        error: `Tunnel refused: only ${ALLOWED_HOST}:${ALLOWED_PORT} is allowed (requested ${host}:${port}).`
+      });
+      return;
+    }
+    let opened = false;
+    const socket = net.connect({ host, port });
+    socket.setNoDelay(true);
+    this.tunnels.set(id, { socket });
+    socket.on("connect", () => {
+      opened = true;
+      this.send({ type: "stream_opened", id });
+    });
+    socket.on("data", (data) => {
+      for (let i = 0; i < data.length; i += CHUNK_BYTES) {
+        const slice = data.subarray(i, i + CHUNK_BYTES);
+        this.send({ type: "stream_data", id, data: slice.toString("base64") });
+      }
+    });
+    socket.on("end", () => {
+      this.send({ type: "stream_end", id });
+      this.tunnels.delete(id);
+    });
+    socket.on("error", (error) => {
+      if (!opened) {
+        this.send({ type: "stream_error", id, error: `Tunnel connect failed: ${error.message}` });
+      } else {
+        this.send({ type: "stream_abort", id, error: error.message });
+      }
+      this.tunnels.delete(id);
+    });
+    socket.on("close", () => {
+      if (this.tunnels.has(id)) {
+        this.send({ type: "stream_end", id });
+        this.tunnels.delete(id);
+      }
+    });
+  }
+  fail(id, error) {
+    this.send({ type: "stream_abort", id, error });
+    this.teardown(id);
+  }
+  teardown(id) {
+    const tunnel = this.tunnels.get(id);
+    if (!tunnel) return;
+    this.tunnels.delete(id);
+    try {
+      tunnel.socket.destroy();
+    } catch {
+    }
+  }
+  /** Destroy every open tunnel (bridge teardown). */
+  closeAll() {
+    for (const id of Array.from(this.tunnels.keys())) {
+      this.teardown(id);
+    }
+  }
+};
+var MAX_ENTRIES = 200;
+var MAX_RESULT_BYTES = 256 * 1024;
+function ledgerDir() {
+  return path4.join(os8.homedir(), ".standardagents", "tool-ledger");
+}
+var ToolLedger = class {
+  constructor(threadId) {
+    this.threadId = threadId;
+    const safe = encodeURIComponent(threadId);
+    this.file = path4.join(ledgerDir(), `${safe}.json`);
+  }
+  threadId;
+  entries = /* @__PURE__ */ new Map();
+  file;
+  loaded = false;
+  load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      const raw = fs5.readFileSync(this.file, "utf8");
+      const parsed = JSON.parse(raw);
+      for (const [id, entry] of Object.entries(parsed)) {
+        if (entry && typeof entry.ok === "boolean") this.entries.set(id, entry);
+      }
+    } catch {
+    }
+  }
+  /** The cached result for a completed call, or null if we have not run it. */
+  get(toolCallId) {
+    this.load();
+    return this.entries.get(toolCallId) ?? null;
+  }
+  /** Record a completed call's result, then persist (best effort). */
+  record(toolCallId, result) {
+    this.load();
+    this.entries.set(toolCallId, { ...result, at: Date.now() });
+    this.evict();
+    this.persist();
+  }
+  evict() {
+    if (this.entries.size <= MAX_ENTRIES) return;
+    const overflow = this.entries.size - MAX_ENTRIES;
+    let dropped = 0;
+    for (const key of this.entries.keys()) {
+      if (dropped >= overflow) break;
+      this.entries.delete(key);
+      dropped++;
+    }
+  }
+  persist() {
+    try {
+      fs5.mkdirSync(ledgerDir(), { recursive: true });
+      const out = {};
+      for (const [id, entry] of this.entries) {
+        const size = entry.result ? Buffer.byteLength(entry.result) : 0;
+        out[id] = size > MAX_RESULT_BYTES ? { ...entry, result: void 0 } : entry;
+      }
+      fs5.writeFileSync(this.file, JSON.stringify(out), { mode: 384 });
+    } catch {
+    }
+  }
+};
 
 // src/render.ts
 var RESET = "\x1B[0m";
@@ -1025,6 +1224,8 @@ var Bridge = class {
     this.perm = perm;
     this.hooks = hooks;
     this.identity = identity;
+    this.tunnels = new TunnelManager((payload) => this.send(payload));
+    this.ledger = new ToolLedger(this.threadId);
   }
   api;
   threadId;
@@ -1042,6 +1243,14 @@ var Bridge = class {
   // Durable forwarded calls we've started handling, so a server re-send (after a
   // reconnect) doesn't prompt or run them twice.
   handledDurable = /* @__PURE__ */ new Set();
+  // Raw TCP tunnels: the provider owns TLS over these runtime bytes; this
+  // execution-owner bridge only shuttles ciphertext and tears it down on close.
+  tunnels;
+  // Durable, exactly-once ledger of completed forwarded calls. Survives a crash
+  // AFTER execution but BEFORE delivery: on redelivery we return the cached
+  // result instead of re-running the side-effecting operation. A cache — the
+  // server's pending table stays the source of truth.
+  ledger;
   // Whether this client currently holds execution ownership. Starts true so an
   // instance that predates the owner concept (no owner field in bridge_ready)
   // behaves exactly as before; an owner-aware instance sets it on every connect.
@@ -1144,6 +1353,7 @@ var Bridge = class {
     if (this.ws !== ws) return;
     this.ws = null;
     this.stopHeartbeat();
+    this.tunnels.closeAll();
     this.scheduleReconnect();
   }
   scheduleReconnect() {
@@ -1176,6 +1386,7 @@ var Bridge = class {
   close() {
     this.closed = true;
     this.stopHeartbeat();
+    this.tunnels.closeAll();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -1249,6 +1460,11 @@ var Bridge = class {
       this.hooks.onSuperseded?.();
       return;
     }
+    if (this.tunnels.handles(msg.type)) {
+      if (!this.owner) return;
+      this.tunnels.handleFrame(msg);
+      return;
+    }
     if (msg.type !== "tool_request") return;
     if (!this.owner) return;
     const req = msg;
@@ -1281,6 +1497,11 @@ var Bridge = class {
     if (req.durable && req.toolCallId) {
       if (this.handledDurable.has(req.toolCallId)) return;
       this.handledDurable.add(req.toolCallId);
+      const cached = this.ledger.get(req.toolCallId);
+      if (cached) {
+        this.respond(req, cached.ok, cached.result, cached.error);
+        return;
+      }
     }
     const summary = describe(req);
     let effectiveRisk = typeof req.risk === "number" ? req.risk : req.requestPermission ? 3 : 1;
@@ -1328,6 +1549,13 @@ var Bridge = class {
     } finally {
       this.hooks.onStatus?.(callKey, null);
     }
+    if (req.durable && req.toolCallId) {
+      this.ledger.record(req.toolCallId, {
+        ok: result.ok,
+        result: result.ok ? result.result ?? "" : void 0,
+        error: result.ok ? void 0 : result.error
+      });
+    }
     if (result.ok) {
       const { display, detail } = activityPresentation(req, summary);
       this.hooks.onActivity(`\u2713 ${display}${detailSuffix(req.tool, result.result)}`, detail);
@@ -1433,7 +1661,7 @@ function detailSuffix(tool, result) {
   const lines = result.split("\n").length;
   return ` (${lines} line${lines === 1 ? "" : "s"})`;
 }
-var LOG_DIR = path3.join(os7.homedir(), ".standardagents", "process-logs");
+var LOG_DIR = path4.join(os8.homedir(), ".standardagents", "process-logs");
 var KEY2 = "bg_processes";
 function isAlive(pid) {
   try {
@@ -1510,11 +1738,11 @@ var ProcessRegistry = class {
   }
 };
 function configFile() {
-  return process.env.STANDARDAGENTS_MCP_CONFIG || path3.join(os7.homedir(), ".standardagents", "mcp.json");
+  return process.env.STANDARDAGENTS_MCP_CONFIG || path4.join(os8.homedir(), ".standardagents", "mcp.json");
 }
 function loadMcpConfig() {
   try {
-    const raw = fs4.readFileSync(configFile(), "utf8");
+    const raw = fs5.readFileSync(configFile(), "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed.servers || typeof parsed.servers !== "object") parsed.servers = {};
     return parsed;
@@ -1545,8 +1773,8 @@ function setMcpServerEnabled(name, enabled) {
 }
 function write(cfg) {
   const file2 = configFile();
-  fs4.mkdirSync(path3.dirname(file2), { recursive: true });
-  fs4.writeFileSync(file2, JSON.stringify(cfg, null, 2), { mode: 384 });
+  fs5.mkdirSync(path4.dirname(file2), { recursive: true });
+  fs5.writeFileSync(file2, JSON.stringify(cfg, null, 2), { mode: 384 });
 }
 function parseServerSpec(spec) {
   const trimmed = spec.trim();
@@ -1629,13 +1857,13 @@ var HostTools = class {
   /** Resolve a user/model-supplied path against the project directory. */
   resolve(p) {
     if (!p || p === ".") return this.projectDir;
-    return path3.resolve(this.projectDir, p);
+    return path4.resolve(this.projectDir, p);
   }
   /** True when the resolved path escapes the project directory. */
   isOutsideProject(p) {
     const abs = this.resolve(p);
-    const rel = path3.relative(this.projectDir, abs);
-    return rel.startsWith("..") || path3.isAbsolute(rel);
+    const rel = path4.relative(this.projectDir, abs);
+    return rel.startsWith("..") || path4.isAbsolute(rel);
   }
   async execute(tool, args) {
     try {
@@ -1722,18 +1950,18 @@ var HostTools = class {
       const matches = await this.walkGlob(base, pattern);
       return { ok: true, result: matches.slice(0, 300).join("\n") || "(no files)" };
     }
-    const rel = rg.stdout.trim().split("\n").filter(Boolean).map((p) => path3.relative(this.projectDir, p)).slice(0, 300);
+    const rel = rg.stdout.trim().split("\n").filter(Boolean).map((p) => path4.relative(this.projectDir, p)).slice(0, 300);
     return { ok: true, result: rel.join("\n") || "(no files)" };
   }
   async writeFile(args) {
     const file2 = this.resolve(String(args.path || ""));
     const content = String(args.content ?? "");
-    await fsp.mkdir(path3.dirname(file2), { recursive: true });
-    const existed = fs4.existsSync(file2);
+    await fsp.mkdir(path4.dirname(file2), { recursive: true });
+    const existed = fs5.existsSync(file2);
     await fsp.writeFile(file2, content, "utf8");
     return {
       ok: true,
-      result: `${existed ? "Overwrote" : "Created"} ${path3.relative(this.projectDir, file2)} (${Buffer.byteLength(content)} bytes)`
+      result: `${existed ? "Overwrote" : "Created"} ${path4.relative(this.projectDir, file2)} (${Buffer.byteLength(content)} bytes)`
     };
   }
   async editFile(args) {
@@ -1752,7 +1980,7 @@ 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 ${path3.relative(this.projectDir, file2)} (${count} replacement${count === 1 ? "" : "s"})` };
+    return { ok: true, result: `Edited ${path4.relative(this.projectDir, file2)} (${count} replacement${count === 1 ? "" : "s"})` };
   }
   /**
    * Copy a file from the THREAD filesystem (e.g. a generated /attachments/*
@@ -1769,12 +1997,12 @@ var HostTools = class {
     const bytes = await this.api.fetchFile(this.threadId, source);
     if (!bytes) return { ok: false, error: `Could not download ${source} from the thread filesystem.` };
     const dest = this.resolve(destArg);
-    await fsp.mkdir(path3.dirname(dest), { recursive: true });
-    const existed = fs4.existsSync(dest);
+    await fsp.mkdir(path4.dirname(dest), { recursive: true });
+    const existed = fs5.existsSync(dest);
     await fsp.writeFile(dest, bytes);
     return {
       ok: true,
-      result: `${existed ? "Overwrote" : "Saved"} ${path3.relative(this.projectDir, dest)} (${bytes.length} bytes) from ${source}`
+      result: `${existed ? "Overwrote" : "Saved"} ${path4.relative(this.projectDir, dest)} (${bytes.length} bytes) from ${source}`
     };
   }
   /**
@@ -1812,16 +2040,16 @@ var HostTools = class {
       }
     }
     const hash = crypto.createHash("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
-    const skillDir = path3.join(os7.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
+    const skillDir = path4.join(os8.tmpdir(), "standardcode-skills", `${skill}-${hash}`);
     for (const f of files) {
-      const dest = path3.resolve(skillDir, f.path);
-      if (path3.relative(skillDir, dest).startsWith("..")) {
+      const dest = path4.resolve(skillDir, f.path);
+      if (path4.relative(skillDir, dest).startsWith("..")) {
         return { ok: false, error: `Skill file escapes its directory: ${f.path}` };
       }
-      await fsp.mkdir(path3.dirname(dest), { recursive: true });
+      await fsp.mkdir(path4.dirname(dest), { recursive: true });
       await fsp.writeFile(dest, f.content, "utf8");
     }
-    const entryPath = path3.resolve(skillDir, entry);
+    const entryPath = path4.resolve(skillDir, entry);
     const entryContent = files.find((f) => f.path === entry).content;
     let cmd;
     let argv;
@@ -1830,7 +2058,7 @@ var HostTools = class {
       cmd = entryPath;
       argv = scriptArgs;
     } else {
-      const ext = path3.extname(entry).toLowerCase();
+      const ext = path4.extname(entry).toLowerCase();
       const interp = {
         ".py": ["python3"],
         ".sh": ["bash"],
@@ -1900,15 +2128,15 @@ ${truncated}`
     const command = String(args.command || "");
     if (!command.trim()) return { ok: false, error: "command is required" };
     const cwd = args.cwd ? this.resolve(String(args.cwd)) : this.projectDir;
-    if (!fs4.existsSync(cwd)) {
+    if (!fs5.existsSync(cwd)) {
       return { ok: false, error: `cwd does not exist: ${cwd}` };
     }
     const id = crypto.randomUUID().slice(0, 8);
-    const logPath = path3.join(LOG_DIR, `${id}.log`);
+    const logPath = path4.join(LOG_DIR, `${id}.log`);
     let out;
     try {
       await fsp.mkdir(LOG_DIR, { recursive: true });
-      out = fs4.openSync(logPath, "a");
+      out = fs5.openSync(logPath, "a");
     } catch (err) {
       return { ok: false, error: `Could not open log file: ${err instanceof Error ? err.message : String(err)}` };
     }
@@ -1916,14 +2144,14 @@ ${truncated}`
     try {
       child = spawn("bash", ["-lc", command], { cwd, detached: true, stdio: ["ignore", out, out] });
     } catch (err) {
-      fs4.closeSync(out);
+      fs5.closeSync(out);
       return { ok: false, error: `Failed to start: ${err instanceof Error ? err.message : String(err)}` };
     }
     let spawnError = null;
     child.on("error", (err) => {
       spawnError = err;
     });
-    fs4.closeSync(out);
+    fs5.closeSync(out);
     const pid = child.pid;
     let earlyExit;
     const onEarlyExit = (code) => {
@@ -2179,10 +2407,10 @@ ${tail}` : " No output was captured.")
       const entries = await fsp.readdir(dir2, { withFileTypes: true }).catch(() => []);
       for (const e of entries) {
         if (e.name === ".git" || e.name === "node_modules") continue;
-        const full = path3.join(dir2, e.name);
+        const full = path4.join(dir2, e.name);
         if (e.isDirectory()) await walk(full);
         else {
-          const rel = path3.relative(this.projectDir, full);
+          const rel = path4.relative(this.projectDir, full);
           if (re.test(rel) || re.test(e.name)) out.push(rel);
         }
       }
@@ -3053,14 +3281,37 @@ function parseToolCalls(message) {
   });
 }
 var EMPTY_BOUNDARY_STALE_MS = 15e4;
+var WAITING_FOR_CLIENT_MARKER = "Waiting for your machine to reconnect";
+var PENDING_TAIL_STALE_MS = 10 * 6e4;
+var BUSY_TAIL_STALE_MS = 30 * 6e4;
+function toMs(raw) {
+  return raw > 1e14 ? raw / 1e3 : raw < 1e12 ? raw * 1e3 : raw;
+}
 function deriveSessionActivity(messages, nowMs = Date.now()) {
   const visible = messages.filter((message) => message.silent !== true && message.metadata?.silent !== true).sort((a, b) => createdAt(a) - createdAt(b));
-  if (visible.some((message) => message.status === "pending")) return { busy: true, currentTool: unresolvedTool(visible) };
+  if (visible.some((message) => message.status === "pending")) {
+    const lastPending = [...visible].reverse().find((m) => m.status === "pending");
+    const pendingMs = lastPending ? toMs(createdAt(lastPending)) : 0;
+    if (pendingMs > 0 && nowMs - pendingMs > PENDING_TAIL_STALE_MS) {
+      return { busy: false, currentTool: null };
+    }
+    return { busy: true, currentTool: unresolvedTool(visible) };
+  }
   const last = visible.at(-1);
   if (!last) return { busy: false, currentTool: null };
+  if (last.role === "tool" && messageText(last.content).includes(WAITING_FOR_CLIENT_MARKER)) {
+    const tool = unresolvedTool(visible);
+    return { busy: true, currentTool: { ...tool ?? { id: last.tool_call_id ?? "", name: "forwarded", arguments: {} }, waitingForHost: true } };
+  }
   const currentTool = unresolvedTool(visible);
   if (currentTool) return { busy: true, currentTool };
-  if (last.role === "user" || last.role === "tool") return { busy: true, currentTool: null };
+  if (last.role === "user" || last.role === "tool") {
+    const lastMs = toMs(createdAt(last));
+    if (lastMs > 0 && nowMs - lastMs > BUSY_TAIL_STALE_MS) {
+      return { busy: false, currentTool: null };
+    }
+    return { busy: true, currentTool: null };
+  }
   if (last.role === "assistant" && last.status !== "failed" && !messageText(last.content).trim()) {
     const raw = createdAt(last);
     const lastMs = raw > 1e14 ? raw / 1e3 : raw < 1e12 ? raw * 1e3 : raw;
@@ -3809,18 +4060,18 @@ function run(cmd, args, maxBuffer = MAX_IMAGE_BYTES * 2) {
   });
 }
 function fromFile(filePath) {
-  const mime = FILE_MIMES[path3.extname(filePath).toLowerCase()];
+  const mime = FILE_MIMES[path4.extname(filePath).toLowerCase()];
   if (!mime) return null;
   try {
-    const stat = fs4.statSync(filePath);
+    const stat = fs5.statSync(filePath);
     if (!stat.isFile() || stat.size === 0 || stat.size > MAX_IMAGE_BYTES) return null;
-    return { data: fs4.readFileSync(filePath).toString("base64"), mime };
+    return { data: fs5.readFileSync(filePath).toString("base64"), mime };
   } catch {
     return null;
   }
 }
 async function readDarwin() {
-  const tmp = path3.join(os7.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const tmp = path4.join(os8.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
   const script = [
     `set d to the clipboard as \xABclass PNGf\xBB`,
     `set f to open for access POSIX file "${tmp}" with write permission`,
@@ -3832,7 +4083,7 @@ async function readDarwin() {
   if (png.ok) {
     const img = fromFile(tmp);
     try {
-      fs4.unlinkSync(tmp);
+      fs5.unlinkSync(tmp);
     } catch {
     }
     if (img) return img;
@@ -3857,7 +4108,7 @@ async function readLinux() {
   return null;
 }
 async function readWindows() {
-  const tmp = path3.join(os7.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
+  const tmp = path4.join(os8.tmpdir(), `sc-clip-${process.pid}-${Date.now()}.png`);
   const ps = [
     "Add-Type -AssemblyName System.Windows.Forms;",
     "$img = [System.Windows.Forms.Clipboard]::GetImage();",
@@ -3866,7 +4117,7 @@ async function readWindows() {
   await run("powershell", ["-NoProfile", "-STA", "-Command", ps]);
   const img = fromFile(tmp);
   try {
-    fs4.unlinkSync(tmp);
+    fs5.unlinkSync(tmp);
   } catch {
   }
   return img;
@@ -5803,10 +6054,10 @@ ${C.cyan}\u2503${C.reset} ${question}
 
 // src/history.ts
 var HISTORY_KEY = "input_history";
-var MAX_ENTRIES = 100;
+var MAX_ENTRIES2 = 100;
 function clean(value) {
   if (!Array.isArray(value)) return [];
-  return value.filter((e) => typeof e === "string" && e.trim() !== "").slice(-MAX_ENTRIES);
+  return value.filter((e) => typeof e === "string" && e.trim() !== "").slice(-MAX_ENTRIES2);
 }
 async function loadHistory(store, threadId, seedThreadId) {
   const own = clean(await store.kvGet(threadId, HISTORY_KEY));
@@ -5824,12 +6075,12 @@ function appendHistory(store, threadId, history, text) {
   const t = text.trim();
   if (!t || history[history.length - 1] === t) return history;
   history.push(t);
-  if (history.length > MAX_ENTRIES) history.splice(0, history.length - MAX_ENTRIES);
+  if (history.length > MAX_ENTRIES2) history.splice(0, history.length - MAX_ENTRIES2);
   void store.kvSet(threadId, HISTORY_KEY, [...history]);
   return history;
 }
-var DIR = path3.join(os7.homedir(), ".standardagents");
-var FILE = path3.join(DIR, "credentials");
+var DIR = path4.join(os8.homedir(), ".standardagents");
+var FILE = path4.join(DIR, "credentials");
 function normalizeEndpoint(endpoint) {
   let e = endpoint.trim();
   if (!/^https?:\/\//i.test(e)) e = "http://" + e;
@@ -5837,7 +6088,7 @@ function normalizeEndpoint(endpoint) {
 }
 function loadCredentials() {
   try {
-    const raw = fs4.readFileSync(FILE, "utf8");
+    const raw = fs5.readFileSync(FILE, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed.instances) parsed.instances = {};
     return parsed;
@@ -5856,20 +6107,20 @@ function saveCredential(cred, options = {}) {
   if (options.updateDefault ?? true) {
     creds.default_endpoint = endpoint;
   }
-  fs4.mkdirSync(DIR, { recursive: true });
-  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+  fs5.mkdirSync(DIR, { recursive: true });
+  fs5.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
   try {
-    fs4.chmodSync(FILE, 384);
+    fs5.chmodSync(FILE, 384);
   } catch {
   }
 }
 function deleteCredential(endpoint) {
   const creds = loadCredentials();
   delete creds.instances[normalizeEndpoint(endpoint)];
-  fs4.mkdirSync(DIR, { recursive: true });
-  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+  fs5.mkdirSync(DIR, { recursive: true });
+  fs5.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
   try {
-    fs4.chmodSync(FILE, 384);
+    fs5.chmodSync(FILE, 384);
   } catch {
   }
 }
@@ -5879,10 +6130,10 @@ function defaultEndpoint() {
 function saveDefaultEndpoint(endpoint) {
   const creds = loadCredentials();
   creds.default_endpoint = normalizeEndpoint(endpoint);
-  fs4.mkdirSync(DIR, { recursive: true });
-  fs4.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
+  fs5.mkdirSync(DIR, { recursive: true });
+  fs5.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 384 });
   try {
-    fs4.chmodSync(FILE, 384);
+    fs5.chmodSync(FILE, 384);
   } catch {
   }
 }
@@ -5943,7 +6194,7 @@ var AGENT_CHOICES = [
 var PRODUCTION_ENDPOINT = "https://api.standardcode.ai";
 function readVersion() {
   try {
-    const pkg = JSON.parse(fs4.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(fs5.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "";
   } catch {
     return "";
@@ -5969,11 +6220,11 @@ function relaxTlsForLocalEndpoint(endpoint) {
   process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
   return true;
 }
-var dir = () => path3.join(os7.homedir(), ".standardagents");
-var file = () => path3.join(dir(), "machine.json");
+var dir = () => path4.join(os8.homedir(), ".standardagents");
+var file = () => path4.join(dir(), "machine.json");
 function loadMachineIdentity() {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(file(), "utf8"));
+    const parsed = JSON.parse(fs5.readFileSync(file(), "utf8"));
     if (typeof parsed.machine_id === "string" && parsed.machine_id.length > 0) {
       return { machine_id: parsed.machine_id, created_at: parsed.created_at ?? Date.now() };
     }
@@ -5987,8 +6238,8 @@ function loadMachineIdentity() {
   return identity;
 }
 function saveMachineIdentity(identity) {
-  fs4.mkdirSync(dir(), { recursive: true });
-  fs4.writeFileSync(file(), JSON.stringify(identity, null, 2), { mode: 384 });
+  fs5.mkdirSync(dir(), { recursive: true });
+  fs5.writeFileSync(file(), JSON.stringify(identity, null, 2), { mode: 384 });
 }
 function daemonClientId(identity) {
   return `daemon:${identity.machine_id}`;
@@ -6169,8 +6420,8 @@ function newRecord(identity) {
   const now = Date.now();
   return {
     id: identity.machine_id,
-    name: os7.hostname(),
-    hostname: os7.hostname(),
+    name: os8.hostname(),
+    hostname: os8.hostname(),
     platform: process.platform,
     arch: process.arch,
     version: readVersion() || void 0,
@@ -6183,7 +6434,7 @@ function newRecord(identity) {
 async function updateOwnMachineRecord(api, identity, mutate) {
   const existing = await loadRawMachine(api, identity.machine_id);
   const record2 = existing ?? newRecord(identity);
-  record2.hostname = os7.hostname();
+  record2.hostname = os8.hostname();
   record2.platform = process.platform;
   record2.arch = process.arch;
   record2.version = readVersion() || record2.version;
@@ -6207,9 +6458,9 @@ function projectRepository(projectDir) {
 function normalizeProjectDir(projectDir) {
   let p = projectDir.trim();
   if (!p) return p;
-  if (p === "~") p = os7.homedir();
-  else if (p.startsWith("~/")) p = path3.join(os7.homedir(), p.slice(2));
-  return path3.resolve(p);
+  if (p === "~") p = os8.homedir();
+  else if (p.startsWith("~/")) p = path4.join(os8.homedir(), p.slice(2));
+  return path4.resolve(p);
 }
 async function registerProject(api, identity, projectDir) {
   const dir2 = normalizeProjectDir(projectDir);
@@ -6287,16 +6538,16 @@ async function clearMachineCommands(api, machineId, appliedIds) {
 async function applyMachineCommand(api, identity, cmd) {
   switch (cmd.kind) {
     case "add_project": {
-      const path14 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
-      if (!path14) return "add_project: ignored (no path)";
-      await registerProject(api, identity, path14);
-      return `added project ${path14}`;
+      const path15 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
+      if (!path15) return "add_project: ignored (no path)";
+      await registerProject(api, identity, path15);
+      return `added project ${path15}`;
     }
     case "remove_project": {
-      const path14 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
-      if (!path14) return "remove_project: ignored (no path)";
-      await unregisterProject(api, identity, path14);
-      return `removed project ${path14}`;
+      const path15 = typeof cmd.args?.path === "string" ? cmd.args.path : "";
+      if (!path15) return "remove_project: ignored (no path)";
+      await unregisterProject(api, identity, path15);
+      return `removed project ${path15}`;
     }
     case "update":
       return "update requested";
@@ -6358,6 +6609,101 @@ async function awaitApprovalViaRelay(api, threadId, request, options = {}) {
     });
   }
 }
+
+// src/hub.ts
+var HubSocket = class {
+  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/hub?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);
+    });
+    ws.addEventListener("message", (ev) => {
+      if (this.ws === ws) this.heartbeat?.markAlive();
+      this.onMessage(String(ev.data));
+    });
+    ws.addEventListener("error", () => this.handleDrop(ws));
+    ws.addEventListener("close", () => this.handleDrop(ws));
+  }
+  onMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg && typeof msg === "object" && msg.type === "wake" && typeof msg.threadId === "string") {
+      this.hooks.onWake(msg.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;
+    }
+  }
+  close() {
+    this.closed = true;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+  }
+};
 var PROJECT_MARKERS = [
   ".git",
   "package.json",
@@ -6371,14 +6717,14 @@ var PROJECT_MARKERS = [
   "requirements.txt",
   ".standardagents"
 ];
-var MAX_ENTRIES2 = 500;
+var MAX_ENTRIES3 = 500;
 function resolveBrowsePath(input3) {
-  const home = os7.homedir();
+  const home = os8.homedir();
   let p = (input3 ?? "").trim();
   if (!p) return home;
   if (p === "~") return home;
-  if (p.startsWith("~/")) p = path3.join(home, p.slice(2));
-  return path3.resolve(p);
+  if (p.startsWith("~/")) p = path4.join(home, p.slice(2));
+  return path4.resolve(p);
 }
 function markers(dirPath) {
   let repo = false;
@@ -6386,7 +6732,7 @@ function markers(dirPath) {
   for (const marker of PROJECT_MARKERS) {
     let hit = false;
     try {
-      hit = fs4.existsSync(path3.join(dirPath, marker));
+      hit = fs5.existsSync(path4.join(dirPath, marker));
     } catch {
       hit = false;
     }
@@ -6398,9 +6744,9 @@ function markers(dirPath) {
   return { project, repo };
 }
 function browseDirectory(input3, opts = {}) {
-  const home = os7.homedir();
+  const home = os8.homedir();
   const abs = resolveBrowsePath(input3);
-  const parent = path3.dirname(abs);
+  const parent = path4.dirname(abs);
   const base = {
     path: abs,
     parent: parent === abs ? null : parent,
@@ -6408,11 +6754,11 @@ function browseDirectory(input3, opts = {}) {
   };
   let dirents;
   try {
-    const stat = fs4.statSync(abs);
+    const stat = fs5.statSync(abs);
     if (!stat.isDirectory()) {
       return { ...base, entries: [], truncated: false, error: "Not a directory" };
     }
-    dirents = fs4.readdirSync(abs, { withFileTypes: true });
+    dirents = fs5.readdirSync(abs, { withFileTypes: true });
   } catch (err) {
     const code = err?.code;
     const message = code === "EACCES" || code === "EPERM" ? "Permission denied" : code === "ENOENT" ? "Folder not found" : "Could not read this folder";
@@ -6427,13 +6773,13 @@ function browseDirectory(input3, opts = {}) {
     let isDir = d.isDirectory();
     if (d.isSymbolicLink()) {
       try {
-        isDir = fs4.statSync(path3.join(abs, name)).isDirectory();
+        isDir = fs5.statSync(path4.join(abs, name)).isDirectory();
       } catch {
         isDir = false;
       }
     }
     if (isDir) {
-      const { project, repo } = markers(path3.join(abs, name));
+      const { project, repo } = markers(path4.join(abs, name));
       rawDirs.push({ name, dir: true, project: project || void 0, repo: repo || void 0 });
     } else {
       rawFiles.push({ name, dir: false });
@@ -6443,8 +6789,8 @@ function browseDirectory(input3, opts = {}) {
   rawDirs.sort(cmp);
   rawFiles.sort(cmp);
   const all = [...rawDirs, ...rawFiles];
-  const truncated = all.length > MAX_ENTRIES2;
-  return { ...base, entries: truncated ? all.slice(0, MAX_ENTRIES2) : all, truncated };
+  const truncated = all.length > MAX_ENTRIES3;
+  return { ...base, entries: truncated ? all.slice(0, MAX_ENTRIES3) : all, truncated };
 }
 function mkdirDirectory(parentInput, name, opts = {}) {
   const parent = resolveBrowsePath(parentInput);
@@ -6453,12 +6799,12 @@ function mkdirDirectory(parentInput, name, opts = {}) {
   if (!clean2 || clean2 === "." || clean2 === ".." || clean2.includes("/") || clean2.includes("\\") || clean2.includes("\0")) {
     return { ...listParent(), error: "Invalid folder name." };
   }
-  const target = path3.join(parent, clean2);
-  if (path3.dirname(target) !== parent) {
+  const target = path4.join(parent, clean2);
+  if (path4.dirname(target) !== parent) {
     return { ...listParent(), error: "Invalid folder name." };
   }
   try {
-    fs4.mkdirSync(target, { recursive: false });
+    fs5.mkdirSync(target, { recursive: false });
   } catch (err) {
     const code = err?.code;
     const message = code === "EEXIST" ? "A folder with that name already exists." : code === "EACCES" || code === "EPERM" ? "Permission denied." : code === "ENOENT" ? "The parent folder no longer exists." : "Could not create the folder.";
@@ -6475,14 +6821,14 @@ var CACHE_TTL_MS = 1e3 * 60 * 60 * 6;
 var CHECK_TIMEOUT_MS = 4e3;
 var IN_FLIGHT_TTL_MS = 15 * 60 * 1e3;
 function cacheDir() {
-  return path3.join(homedir(), CACHE_REL_DIR);
+  return path4.join(homedir(), CACHE_REL_DIR);
 }
 function cachePath() {
-  return path3.join(cacheDir(), CACHE_FILE);
+  return path4.join(cacheDir(), CACHE_FILE);
 }
 function readCache() {
   try {
-    const raw = fs4.readFileSync(cachePath(), "utf-8");
+    const raw = fs5.readFileSync(cachePath(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -6491,14 +6837,14 @@ function readCache() {
 function writeCache(latest) {
   try {
     const dir2 = cacheDir();
-    if (!fs4.existsSync(dir2)) fs4.mkdirSync(dir2, { recursive: true });
-    fs4.writeFileSync(cachePath(), JSON.stringify({ latest, timestamp: Date.now() }));
+    if (!fs5.existsSync(dir2)) fs5.mkdirSync(dir2, { recursive: true });
+    fs5.writeFileSync(cachePath(), JSON.stringify({ latest, timestamp: Date.now() }));
   } catch {
   }
 }
 function readAutoUpdateState(dir2 = cacheDir()) {
   try {
-    const raw = fs4.readFileSync(path3.join(dir2, STATE_FILE), "utf-8");
+    const raw = fs5.readFileSync(path4.join(dir2, STATE_FILE), "utf-8");
     const state = JSON.parse(raw);
     return typeof state?.version === "string" ? state : null;
   } catch {
@@ -6507,14 +6853,14 @@ function readAutoUpdateState(dir2 = cacheDir()) {
 }
 function writeAutoUpdateState(state, dir2 = cacheDir()) {
   try {
-    if (!fs4.existsSync(dir2)) fs4.mkdirSync(dir2, { recursive: true });
-    fs4.writeFileSync(path3.join(dir2, STATE_FILE), JSON.stringify(state));
+    if (!fs5.existsSync(dir2)) fs5.mkdirSync(dir2, { recursive: true });
+    fs5.writeFileSync(path4.join(dir2, STATE_FILE), JSON.stringify(state));
   } catch {
   }
 }
 function clearAutoUpdateState(dir2 = cacheDir()) {
   try {
-    fs4.unlinkSync(path3.join(dir2, STATE_FILE));
+    fs5.unlinkSync(path4.join(dir2, STATE_FILE));
   } catch {
   }
 }
@@ -6557,7 +6903,7 @@ function decideAutoUpdate(info, opts) {
 function startBackgroundUpdate(latest, pm, dir2 = cacheDir()) {
   const startedAt = Date.now();
   writeAutoUpdateState({ version: latest, startedAt, exitCode: null }, dir2);
-  const stateFile = path3.join(dir2, STATE_FILE);
+  const stateFile = path4.join(dir2, STATE_FILE);
   const { cmd, args } = updateCommand(pm);
   const script = `const cp=require('child_process');const fs=require('fs');const r=cp.spawnSync(${JSON.stringify(cmd)},${JSON.stringify(args)},{shell:process.platform==='win32',encoding:'utf8'});const out=((r.stdout||'')+(r.stderr||'')).slice(-2000);fs.writeFileSync(${JSON.stringify(stateFile)},JSON.stringify({version:${JSON.stringify(latest)},startedAt:${startedAt},exitCode:r.status==null?-1:r.status,finishedAt:Date.now(),output:out}));`;
   try {
@@ -6652,17 +6998,17 @@ var UPDATE_CHECK_MS = 6 * 60 * 6e4;
 var SWEEP_MS = 10 * 6e4;
 var MAX_WORKERS = 30;
 var LOG_MAX_BYTES = 1e6;
-var LOG_FILE = path3.join(os7.homedir(), ".standardagents", "daemon.log");
+var LOG_FILE = path4.join(os8.homedir(), ".standardagents", "daemon.log");
 function daemonLog(line) {
   try {
-    fs4.mkdirSync(path3.dirname(LOG_FILE), { recursive: true });
+    fs5.mkdirSync(path4.dirname(LOG_FILE), { recursive: true });
     try {
-      if (fs4.statSync(LOG_FILE).size > LOG_MAX_BYTES) {
-        fs4.renameSync(LOG_FILE, `${LOG_FILE}.old`);
+      if (fs5.statSync(LOG_FILE).size > LOG_MAX_BYTES) {
+        fs5.renameSync(LOG_FILE, `${LOG_FILE}.old`);
       }
     } catch {
     }
-    fs4.appendFileSync(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+    fs5.appendFileSync(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
   } catch {
   }
@@ -6671,7 +7017,7 @@ function pathFromTags(tags) {
   const tag = tags.find((t) => t.startsWith("path:"));
   if (!tag) return null;
   const raw = tag.slice("path:".length);
-  return raw.replace(/^~(?=\/|$)/, os7.homedir());
+  return raw.replace(/^~(?=\/|$)/, os8.homedir());
 }
 var ThreadWorker = class {
   constructor(api, identity, machineName, threadId, projectDir, createdAt2) {
@@ -6803,7 +7149,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     process.exit(1);
   }
   let displayName = machineDisplayName(await loadMachine(api, identity.machine_id).catch(() => null) ?? {
-    hostname: os7.hostname(),
+    hostname: os8.hostname(),
     id: identity.machine_id
   });
   const applied = consumeAppliedUpdate(version);
@@ -6841,7 +7187,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
       daemonLog(`detached ${oldest.threadId.slice(0, 8)} (worker cap)`);
     }
     try {
-      fs4.mkdirSync(projectDir, { recursive: true });
+      fs5.mkdirSync(projectDir, { recursive: true });
     } catch (e) {
       daemonLog(`cannot prepare project dir ${projectDir}: ${e instanceof Error ? e.message : String(e)}`);
       return;
@@ -6890,6 +7236,31 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     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()) {
@@ -7013,6 +7384,7 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
     clearInterval(sweeper);
     for (const worker of workers.values()) worker.stop();
     events.close();
+    hub.close();
     daemonLog(`daemon exiting (code ${code})`);
     process.exit(code);
   };
@@ -7025,19 +7397,19 @@ Run \`standardcode daemon install\` (or plain \`standardcode\`) once to sign in.
 var SERVICE_LABEL = "ai.standardcode.daemon";
 var SYSTEMD_UNIT = "standardcode-daemon.service";
 function resolveDaemonCommand(extraArgs = []) {
-  const entry = path3.resolve(process.argv[1] ?? "");
+  const entry = path4.resolve(process.argv[1] ?? "");
   if (!entry) throw new Error("Cannot determine how this CLI was launched.");
   const argv = [process.execPath];
   if (entry.endsWith(".ts")) {
-    let dir2 = path3.dirname(entry);
+    let dir2 = path4.dirname(entry);
     let tsx = null;
-    for (let i = 0; i < 6 && dir2 !== path3.dirname(dir2); i++) {
-      const candidate = path3.join(dir2, "node_modules", "tsx", "dist", "cli.mjs");
-      if (fs4.existsSync(candidate)) {
+    for (let i = 0; i < 6 && dir2 !== path4.dirname(dir2); i++) {
+      const candidate = path4.join(dir2, "node_modules", "tsx", "dist", "cli.mjs");
+      if (fs5.existsSync(candidate)) {
         tsx = candidate;
         break;
       }
-      dir2 = path3.dirname(dir2);
+      dir2 = path4.dirname(dir2);
     }
     if (!tsx) {
       throw new Error(
@@ -7051,7 +7423,7 @@ function resolveDaemonCommand(extraArgs = []) {
 }
 function servicePath() {
   const parts = [
-    path3.dirname(process.execPath),
+    path4.dirname(process.execPath),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -7067,8 +7439,8 @@ function run2(cmd, args) {
   const output4 = `${res.stdout ?? ""}${res.stderr ?? ""}`.trim();
   return { ok: res.status === 0, output: output4 };
 }
-var plistPath = () => path3.join(os7.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
-var unitPath = () => path3.join(os7.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
+var plistPath = () => path4.join(os8.homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+var unitPath = () => path4.join(os8.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT);
 var xmlEscape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function installService(command, endpoint) {
   if (process.platform === "darwin") return installLaunchd(command, endpoint);
@@ -7080,9 +7452,9 @@ function installService(command, endpoint) {
   };
 }
 function installLaunchd(command, endpoint) {
-  const logDir = path3.join(os7.homedir(), ".standardagents");
-  fs4.mkdirSync(logDir, { recursive: true });
-  fs4.mkdirSync(path3.dirname(plistPath()), { recursive: true });
+  const logDir = path4.join(os8.homedir(), ".standardagents");
+  fs5.mkdirSync(logDir, { recursive: true });
+  fs5.mkdirSync(path4.dirname(plistPath()), { recursive: true });
   const envEntries = [
     `      <key>PATH</key><string>${xmlEscape(servicePath())}</string>`,
     ...endpoint ? [`      <key>STANDARD_CODE_DAEMON_ENDPOINT</key><string>${xmlEscape(endpoint)}</string>`] : []
@@ -7099,8 +7471,8 @@ ${command.argv.map((a) => `      <string>${xmlEscape(a)}</string>`).join("\n")}
     <key>RunAtLoad</key><true/>
     <key>KeepAlive</key><true/>
     <key>ThrottleInterval</key><integer>5</integer>
-    <key>StandardOutPath</key><string>${xmlEscape(path3.join(logDir, "daemon.out.log"))}</string>
-    <key>StandardErrorPath</key><string>${xmlEscape(path3.join(logDir, "daemon.err.log"))}</string>
+    <key>StandardOutPath</key><string>${xmlEscape(path4.join(logDir, "daemon.out.log"))}</string>
+    <key>StandardErrorPath</key><string>${xmlEscape(path4.join(logDir, "daemon.err.log"))}</string>
     <key>EnvironmentVariables</key>
     <dict>
 ${envEntries}
@@ -7108,7 +7480,7 @@ ${envEntries}
   </dict>
 </plist>
 `;
-  fs4.writeFileSync(plistPath(), plist);
+  fs5.writeFileSync(plistPath(), plist);
   const uid = typeof process.getuid === "function" ? process.getuid() : 501;
   run2("launchctl", ["bootout", `gui/${uid}`, plistPath()]);
   const boot = run2("launchctl", ["bootstrap", `gui/${uid}`, plistPath()]);
@@ -7125,7 +7497,7 @@ ${envEntries}
   return { ok: true, detail: `LaunchAgent installed (${plistPath()})` };
 }
 function installSystemd(command, endpoint) {
-  fs4.mkdirSync(path3.dirname(unitPath()), { recursive: true });
+  fs5.mkdirSync(path4.dirname(unitPath()), { recursive: true });
   const unit = `[Unit]
 Description=Standard Code daemon (headless coding-agent execution client)
 After=network-online.target
@@ -7140,7 +7512,7 @@ ${endpoint ? `Environment=STANDARD_CODE_DAEMON_ENDPOINT=${endpoint}
 [Install]
 WantedBy=default.target
 `;
-  fs4.writeFileSync(unitPath(), unit);
+  fs5.writeFileSync(unitPath(), unit);
   const reload = run2("systemctl", ["--user", "daemon-reload"]);
   if (!reload.ok) {
     return {
@@ -7153,10 +7525,10 @@ WantedBy=default.target
   if (!enable.ok) {
     return { ok: false, detail: `systemctl enable failed: ${enable.output}` };
   }
-  const linger = run2("loginctl", ["enable-linger", os7.userInfo().username]);
+  const linger = run2("loginctl", ["enable-linger", os8.userInfo().username]);
   return {
     ok: true,
-    detail: `systemd user unit installed (${unitPath()})` + (linger.ok ? ", lingering enabled" : ` \u2014 enable lingering manually: sudo loginctl enable-linger ${os7.userInfo().username}`)
+    detail: `systemd user unit installed (${unitPath()})` + (linger.ok ? ", lingering enabled" : ` \u2014 enable lingering manually: sudo loginctl enable-linger ${os8.userInfo().username}`)
   };
 }
 function uninstallService() {
@@ -7164,7 +7536,7 @@ function uninstallService() {
     const uid = typeof process.getuid === "function" ? process.getuid() : 501;
     run2("launchctl", ["bootout", `gui/${uid}`, plistPath()]);
     try {
-      fs4.unlinkSync(plistPath());
+      fs5.unlinkSync(plistPath());
     } catch {
     }
     return { ok: true, detail: "LaunchAgent removed" };
@@ -7172,7 +7544,7 @@ function uninstallService() {
   if (process.platform === "linux") {
     run2("systemctl", ["--user", "disable", "--now", SYSTEMD_UNIT]);
     try {
-      fs4.unlinkSync(unitPath());
+      fs5.unlinkSync(unitPath());
     } catch {
     }
     run2("systemctl", ["--user", "daemon-reload"]);
@@ -7182,7 +7554,7 @@ function uninstallService() {
 }
 function serviceStatus() {
   if (process.platform === "darwin") {
-    const installed = fs4.existsSync(plistPath());
+    const installed = fs5.existsSync(plistPath());
     const list = run2("launchctl", ["list", SERVICE_LABEL]);
     const pidMatch = list.output.match(/"PID"\s*=\s*(\d+)/);
     return {
@@ -7192,7 +7564,7 @@ function serviceStatus() {
     };
   }
   if (process.platform === "linux") {
-    const installed = fs4.existsSync(unitPath());
+    const installed = fs5.existsSync(unitPath());
     const active = run2("systemctl", ["--user", "is-active", SYSTEMD_UNIT]);
     return {
       installed,
@@ -7284,7 +7656,7 @@ async function installCommand(endpointFlag) {
   const api = await ensureSignedIn(endpoint);
   const identity = loadMachineIdentity();
   const existing = await loadMachine(api, identity.machine_id).catch(() => null);
-  const suggested = machineDisplayName(existing ?? { hostname: os7.hostname(), id: identity.machine_id });
+  const suggested = machineDisplayName(existing ?? { hostname: os8.hostname(), id: identity.machine_id });
   const rl = readline2.createInterface({ input: stdin, output: stdout });
   const answer = (await rl.question(
     `${c2.bold}Machine name${c2.reset} ${c2.dim}(shown in the session picker)${c2.reset} [${suggested}]: `
@@ -7344,7 +7716,7 @@ async function statusCommand() {
   const cred = getCredential(endpoint);
   if (!cred) {
     stdout.write(
-      `${c2.bold}Machine:${c2.reset}  ${os7.hostname()} ${c2.dim}(${identity.machine_id})${c2.reset}
+      `${c2.bold}Machine:${c2.reset}  ${os8.hostname()} ${c2.dim}(${identity.machine_id})${c2.reset}
 `
     );
     stdout.write(`${c2.bold}Account:${c2.reset}  ${c2.yellow}not signed in to ${endpoint}${c2.reset}
@@ -7355,7 +7727,7 @@ async function statusCommand() {
   const api = new ApiClient(endpoint, cred.access_token);
   const record2 = await loadMachine(api, identity.machine_id).catch(() => null);
   stdout.write(
-    `${c2.bold}Machine:${c2.reset}  ${machineDisplayName(record2 ?? { hostname: os7.hostname(), id: identity.machine_id })} ${c2.dim}(${identity.machine_id})${c2.reset}
+    `${c2.bold}Machine:${c2.reset}  ${machineDisplayName(record2 ?? { hostname: os8.hostname(), id: identity.machine_id })} ${c2.dim}(${identity.machine_id})${c2.reset}
 `
   );
   if (!record2) {
@@ -7379,8 +7751,8 @@ async function projectCommand(action, target) {
 `);
     process.exit(1);
   }
-  const dir2 = path3.resolve(target);
-  if (action === "add" && !fs4.existsSync(dir2)) {
+  const dir2 = path4.resolve(target);
+  if (action === "add" && !fs5.existsSync(dir2)) {
     stdout.write(`${c2.red}\u2717${c2.reset} ${dir2} does not exist on this machine.
 `);
     process.exit(1);
@@ -7389,7 +7761,7 @@ async function projectCommand(action, target) {
   const api = await ensureSignedIn(endpoint);
   const identity = loadMachineIdentity();
   const record2 = await loadMachine(api, identity.machine_id).catch(() => null);
-  const displayName = machineDisplayName(record2 ?? { hostname: os7.hostname(), id: identity.machine_id });
+  const displayName = machineDisplayName(record2 ?? { hostname: os8.hostname(), id: identity.machine_id });
   if (action === "add") {
     await registerProject(api, identity, dir2);
     stdout.write(`${c2.green}\u2713${c2.reset} Registered ${dir2} for remote sessions on ${displayName}.
@@ -7604,7 +7976,7 @@ ${c3.teal}\u25C7${c3.reset} ${c3.dim}Standard Code \u2014 see you soon.${c3.rese
 `);
 }
 function printWelcome(endpoint, projectDir) {
-  const home = os7.homedir();
+  const home = os8.homedir();
   const dir2 = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
   const version = readVersion();
@@ -7674,8 +8046,8 @@ async function main() {
   const endpointArg = cliArgs.endpoint;
   const endpointOverride = cliArgs.promptEndpoint || typeof endpointArg === "string" && endpointArg.trim() !== "";
   const dirArg = cliArgs.dir;
-  const projectDir = path3.resolve(dirArg || process.cwd());
-  const machine = os7.hostname();
+  const projectDir = path4.resolve(dirArg || process.cwd());
+  const machine = os8.hostname();
   const reader = { rl: null };
   let handoffClosing = false;
   let preflightArmed = false;
@@ -7889,7 +8261,7 @@ ${c3.dim}Press Control-C again to exit${c3.reset}
     const ok = await ensureSamaAuth(tui, api);
     if (!ok) process.exit(0);
   }
-  const home = os7.homedir();
+  const home = os8.homedir();
   const tildeDir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
   const shortDir = tildeDir.length > 38 ? "\u2026" + tildeDir.slice(-37) : tildeDir;
   const session = { mode: "local", identity };
@@ -9063,7 +9435,10 @@ ${c3.dim}runs on ${request.machine || runnerName}${c3.reset}`,
     }
     const polledBusy = (serverBusy ?? false) || threadBusy(msgs);
     if (serverTool && !activeSteps.has(serverTool.id)) {
-      activeSteps.set(serverTool.id, serverTool.name || "working");
+      activeSteps.set(
+        serverTool.id,
+        serverTool.waitingForHost ? "waiting for your machine to reconnect" : serverTool.name || "working"
+      );
       refreshStatus();
     } else if (serverBusy !== null && !serverTool && activeSteps.size) {
       activeSteps.clear();
@@ -9320,12 +9695,12 @@ async function manageMachineProjects(tui, api, self, machine, dispatch, applyNot
   );
   if (!picked) return;
   if (picked === ADD) {
-    const path14 = await tui.prompt(
+    const path15 = await tui.prompt(
       `Absolute project path on ${machine.name}`,
       machine.id === self.machine_id ? process.cwd() : "/home/you/project"
     );
-    if (!path14 || !path14.trim()) return;
-    const trimmed = path14.trim();
+    if (!path15 || !path15.trim()) return;
+    const trimmed = path15.trim();
     if (!trimmed.startsWith("/") && !trimmed.startsWith("~")) {
       tui.print(`${c3.yellow}Use an absolute path (starting with / or ~).${c3.reset}`);
       return;