claudemesh-cli 1.32.0 → 1.33.0

package/dist/entrypoints/cli.js

@@ -104,7 +104,7 @@ __export(exports_urls, {
   VERSION: () => VERSION,
   URLS: () => URLS
 });
-var URLS, VERSION = "1.32.0", env;
+var URLS, VERSION = "1.33.0", env;
 var init_urls = __esm(() => {
   URLS = {
     BROKER: process.env.CLAUDEMESH_BROKER_URL ?? "wss://ic.claudemesh.com/ws",
@@ -7948,8 +7948,15 @@ async function listPeersForMesh(slug) {
 function annotateSelf(peer, selfMemberPubkey, selfSessionPubkey) {
   const isSelf = !!(selfMemberPubkey && peer.memberPubkey && peer.memberPubkey === selfMemberPubkey);
   const isThisSession = !!(isSelf && selfSessionPubkey && peer.pubkey === selfSessionPubkey);
-  const role = peer.profile?.role?.trim() || undefined;
-  return { ...peer, ...role ? { role } : {}, isSelf, isThisSession };
+  const peerRole = peer.peerRole ?? "session";
+  const profileRole = peer.profile?.role?.trim() || undefined;
+  return {
+    ...peer,
+    ...profileRole ? { role: profileRole } : {},
+    peerRole,
+    isSelf,
+    isThisSession
+  };
 }
 async function runPeers(flags) {
   const config = readConfig();
@@ -7977,13 +7984,13 @@ async function runPeers(flags) {
         allJson.push({ mesh: slug, peers: projected });
         continue;
       }
-      const visible = flags.all ? peers : peers.filter((p) => p.channel !== "claudemesh-daemon");
+      const visible = flags.all ? peers : peers.filter((p) => p.peerRole !== "control-plane");
       const sorted = visible.slice().sort((a, b) => {
         const score = (p) => p.isThisSession ? 0 : p.isSelf ? 1 : 2;
         return score(a) - score(b);
       });
-      const hiddenDaemons = peers.length - visible.length;
-      const header = hiddenDaemons > 0 ? `peers on ${slug} (${sorted.length}, ${hiddenDaemons} daemon hidden — use --all)` : `peers on ${slug} (${sorted.length})`;
+      const hiddenControlPlane = peers.length - visible.length;
+      const header = hiddenControlPlane > 0 ? `peers on ${slug} (${sorted.length}, ${hiddenControlPlane} control-plane hidden — use --all)` : `peers on ${slug} (${sorted.length})`;
       render.section(header);
       if (sorted.length === 0) {
         render.info(dim("  (no peers connected)"));
@@ -10450,9 +10457,7 @@ async function resolveAndEncrypt(req, broker, meshSecretKey, meshSlug) {
     return { target_spec: to, ciphertext, nonce, mesh: meshSlug ?? "" };
   }
   if (/^[0-9a-f]{64}$/i.test(to)) {
-    const sessionKeys2 = broker.getSessionKeys();
-    const senderSecret2 = sessionKeys2?.sessionSecretKey ?? meshSecretKey;
-    const env3 = await encryptDirect2(req.message, to, senderSecret2);
+    const env3 = await encryptDirect2(req.message, to, meshSecretKey);
     return { target_spec: to, ciphertext: env3.ciphertext, nonce: env3.nonce, mesh: meshSlug ?? "" };
   }
   const peers = await broker.listPeers().catch(() => []);
@@ -10463,18 +10468,14 @@ async function resolveAndEncrypt(req, broker, meshSecretKey, meshSlug) {
     if (matches2.length > 1)
       throw new Error(`prefix "${to}" is ambiguous (${matches2.length} matches)`);
     const recipient2 = matches2[0].pubkey;
-    const sessionKeys2 = broker.getSessionKeys();
-    const senderSecret2 = sessionKeys2?.sessionSecretKey ?? meshSecretKey;
-    const env3 = await encryptDirect2(req.message, recipient2, senderSecret2);
+    const env3 = await encryptDirect2(req.message, recipient2, meshSecretKey);
     return { target_spec: recipient2, ciphertext: env3.ciphertext, nonce: env3.nonce, mesh: meshSlug ?? "" };
   }
   const match = peers.find((p) => p.displayName.toLowerCase() === to.toLowerCase());
   if (!match)
     throw new Error(`peer "${to}" not found`);
   const recipient = match.pubkey;
-  const sessionKeys = broker.getSessionKeys();
-  const senderSecret = sessionKeys?.sessionSecretKey ?? meshSecretKey;
-  const env2 = await encryptDirect2(req.message, recipient, senderSecret);
+  const env2 = await encryptDirect2(req.message, recipient, meshSecretKey);
   return { target_spec: recipient, ciphertext: env2.ciphertext, nonce: env2.nonce, mesh: meshSlug ?? "" };
 }
 function respond(res, status, body) {
@@ -10491,18 +10492,149 @@ var init_server = __esm(() => {
   init_urls();
 });
 
-// src/daemon/broker.ts
+// src/daemon/ws-lifecycle.ts
 import WebSocket2 from "ws";
+function connectWsWithBackoff(opts) {
+  const helloAckTimeoutMs = opts.helloAckTimeoutMs ?? DEFAULT_HELLO_ACK_TIMEOUT_MS;
+  const backoffCapsMs = opts.backoffCapsMs ?? DEFAULT_BACKOFF_CAPS_MS;
+  const log2 = opts.log ?? defaultLog;
+  let ws = null;
+  let status = "closed";
+  let closed = false;
+  let reconnectAttempt = 0;
+  let reconnectTimer = null;
+  let helloTimer = null;
+  const setStatus = (s) => {
+    if (status === s)
+      return;
+    status = s;
+    opts.onStatusChange?.(s);
+  };
+  const openOnce = () => {
+    if (closed)
+      return Promise.reject(new Error("client_closed"));
+    setStatus("connecting");
+    log2("info", "ws_open_attempt", { url: opts.url });
+    const sock = new WebSocket2(opts.url);
+    ws = sock;
+    return new Promise((resolve, reject) => {
+      sock.on("open", () => {
+        log2("info", "ws_open_ok", { url: opts.url });
+        (async () => {
+          try {
+            const hello = await opts.buildHello();
+            sock.send(JSON.stringify(hello));
+            log2("info", "ws_hello_sent", { url: opts.url });
+            helloTimer = setTimeout(() => {
+              log2("warn", "hello_ack_timeout", { url: opts.url });
+              try {
+                sock.close();
+              } catch {}
+              reject(new Error("hello_ack_timeout"));
+            }, helloAckTimeoutMs);
+          } catch (e) {
+            log2("warn", "ws_build_hello_threw", { err: String(e) });
+            reject(e instanceof Error ? e : new Error(String(e)));
+          }
+        })();
+      });
+      sock.on("message", (raw) => {
+        let msg;
+        try {
+          msg = JSON.parse(raw.toString());
+        } catch {
+          return;
+        }
+        if (opts.isHelloAck(msg)) {
+          if (helloTimer) {
+            clearTimeout(helloTimer);
+            helloTimer = null;
+          }
+          setStatus("open");
+          reconnectAttempt = 0;
+          log2("info", "ws_hello_acked", { url: opts.url });
+          resolve();
+          return;
+        }
+        opts.onMessage(msg);
+      });
+      sock.on("close", (code, reason) => {
+        if (helloTimer) {
+          clearTimeout(helloTimer);
+          helloTimer = null;
+        }
+        const reasonStr = reason.toString("utf8");
+        log2("warn", "ws_closed", { url: opts.url, code, reason: reasonStr, status });
+        opts.onBeforeReconnect?.(code, reasonStr);
+        if (closed) {
+          setStatus("closed");
+          return;
+        }
+        setStatus("reconnecting");
+        const wait = backoffCapsMs[Math.min(reconnectAttempt, backoffCapsMs.length - 1)] ?? 30000;
+        reconnectAttempt++;
+        log2("info", "ws_reconnect_scheduled", { url: opts.url, wait_ms: wait, code, reason: reasonStr });
+        reconnectTimer = setTimeout(() => openOnce().catch((err) => log2("warn", "ws_reconnect_failed", { url: opts.url, err: String(err) })), wait);
+        if (status === "connecting" || status === "reconnecting") {
+          reject(new Error(`closed_before_hello_${code}`));
+        }
+      });
+      sock.on("error", (err) => log2("warn", "ws_error", { url: opts.url, err: err.message }));
+    });
+  };
+  return openOnce().then(() => {
+    const handle = {
+      get status() {
+        return status;
+      },
+      get ws() {
+        return ws;
+      },
+      send(payload) {
+        if (!ws || ws.readyState !== ws.OPEN) {
+          throw new Error("ws_not_open");
+        }
+        ws.send(JSON.stringify(payload));
+      },
+      async close() {
+        closed = true;
+        if (reconnectTimer) {
+          clearTimeout(reconnectTimer);
+          reconnectTimer = null;
+        }
+        if (helloTimer) {
+          clearTimeout(helloTimer);
+          helloTimer = null;
+        }
+        try {
+          ws?.close();
+        } catch {}
+        setStatus("closed");
+      }
+    };
+    return handle;
+  });
+}
+var DEFAULT_HELLO_ACK_TIMEOUT_MS = 5000, DEFAULT_BACKOFF_CAPS_MS, defaultLog = (level, msg, meta) => {
+  const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
+  if (level === "info")
+    process.stdout.write(line + `
+`);
+  else
+    process.stderr.write(line + `
+`);
+};
+var init_ws_lifecycle = __esm(() => {
+  DEFAULT_BACKOFF_CAPS_MS = [1000, 2000, 4000, 8000, 16000, 30000];
+});
 
+// src/daemon/broker.ts
 class DaemonBrokerClient {
   mesh;
   opts;
-  ws = null;
+  lifecycle = null;
   _status = "closed";
   closed = false;
-  reconnectAttempt = 0;
-  reconnectTimer = null;
-  helloTimer = null;
   pendingAcks = new Map;
   peerListResolvers = new Map;
   skillListResolvers = new Map;
@@ -10511,8 +10643,6 @@ class DaemonBrokerClient {
   stateListResolvers = new Map;
   memoryStoreResolvers = new Map;
   memoryRecallResolvers = new Map;
-  sessionPubkey = null;
-  sessionSecretKey = null;
   opens = [];
   reqCounter = 0;
   constructor(mesh, opts = {}) {
@@ -10529,72 +10659,39 @@ class DaemonBrokerClient {
     return this.mesh.meshId;
   }
   log = (level, msg, meta) => {
-    (this.opts.log ?? defaultLog)(level, msg, { mesh: this.mesh.slug, ...meta });
+    (this.opts.log ?? defaultLog2)(level, msg, { mesh: this.mesh.slug, ...meta });
   };
-  setConnStatus(s) {
-    if (this._status === s)
-      return;
-    this._status = s;
-    this.opts.onStatusChange?.(s);
-  }
   async connect() {
     if (this.closed)
       throw new Error("client_closed");
     if (this._status === "connecting" || this._status === "open")
       return;
-    this.setConnStatus("connecting");
-    const ws = new WebSocket2(this.mesh.brokerUrl);
-    this.ws = ws;
-    return new Promise((resolve, reject) => {
-      ws.on("open", async () => {
-        try {
-          if (!this.sessionPubkey) {
-            const { generateKeypair: generateKeypair4 } = await Promise.resolve().then(() => (init_facade7(), exports_facade4));
-            const kp = await generateKeypair4();
-            this.sessionPubkey = kp.publicKey;
-            this.sessionSecretKey = kp.secretKey;
-          }
-          const { timestamp: timestamp2, signature } = await signHello(this.mesh.meshId, this.mesh.memberId, this.mesh.pubkey, this.mesh.secretKey);
-          ws.send(JSON.stringify({
-            type: "hello",
-            meshId: this.mesh.meshId,
-            memberId: this.mesh.memberId,
-            pubkey: this.mesh.pubkey,
-            sessionPubkey: this.sessionPubkey,
-            displayName: this.opts.displayName,
-            sessionId: `daemon-${process.pid}`,
-            pid: process.pid,
-            cwd: process.cwd(),
-            hostname: __require("node:os").hostname(),
-            peerType: "ai",
-            channel: "claudemesh-daemon",
-            timestamp: timestamp2,
-            signature
-          }));
-          this.helloTimer = setTimeout(() => {
-            this.log("warn", "broker_hello_ack_timeout");
-            try {
-              ws.close();
-            } catch {}
-            reject(new Error("hello_ack_timeout"));
-          }, HELLO_ACK_TIMEOUT_MS2);
-        } catch (e) {
-          reject(e instanceof Error ? e : new Error(String(e)));
-        }
-      });
-      ws.on("message", (raw) => {
-        let msg;
-        try {
-          msg = JSON.parse(raw.toString());
-        } catch {
-          return;
-        }
-        if (msg.type === "hello_ack") {
-          if (this.helloTimer)
-            clearTimeout(this.helloTimer);
-          this.helloTimer = null;
-          this.setConnStatus("open");
-          this.reconnectAttempt = 0;
+    this.lifecycle = await connectWsWithBackoff({
+      url: this.mesh.brokerUrl,
+      buildHello: async () => {
+        const { timestamp: timestamp2, signature } = await signHello(this.mesh.meshId, this.mesh.memberId, this.mesh.pubkey, this.mesh.secretKey);
+        return {
+          type: "hello",
+          meshId: this.mesh.meshId,
+          memberId: this.mesh.memberId,
+          pubkey: this.mesh.pubkey,
+          displayName: this.opts.displayName,
+          sessionId: `daemon-${process.pid}`,
+          pid: process.pid,
+          cwd: process.cwd(),
+          hostname: __require("node:os").hostname(),
+          peerType: "ai",
+          channel: "claudemesh-daemon",
+          timestamp: timestamp2,
+          signature
+        };
+      },
+      isHelloAck: (msg) => msg.type === "hello_ack",
+      onMessage: (msg) => this.handleMessage(msg),
+      onStatusChange: (s) => {
+        this._status = s;
+        this.opts.onStatusChange?.(s);
+        if (s === "open") {
           const queued = this.opens.slice();
           this.opens.length = 0;
           for (const fn of queued) {
@@ -10604,123 +10701,121 @@ class DaemonBrokerClient {
               this.log("warn", "open_handler_failed", { err: String(e) });
             }
           }
-          resolve();
-          return;
         }
-        if (msg.type === "ack") {
-          const id = String(msg.id ?? "");
-          const ack = this.pendingAcks.get(id);
-          if (ack) {
-            this.pendingAcks.delete(id);
-            clearTimeout(ack.timer);
-            if (typeof msg.error === "string" && msg.error.length > 0) {
-              ack.resolve({ ok: false, error: msg.error, permanent: classifyPermanent(msg.error) });
-            } else {
-              ack.resolve({ ok: true, messageId: String(msg.messageId ?? id) });
-            }
-          }
-          return;
-        }
-        if (msg.type === "peers_list") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.peerListResolvers.get(reqId);
-          if (pending) {
-            this.peerListResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(Array.isArray(msg.peers) ? msg.peers : []);
-          }
-          return;
-        }
-        if (msg.type === "skill_list") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.skillListResolvers.get(reqId);
-          if (pending) {
-            this.skillListResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(Array.isArray(msg.skills) ? msg.skills : []);
-          }
-          return;
-        }
-        if (msg.type === "skill_data") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.skillDataResolvers.get(reqId);
-          if (pending) {
-            this.skillDataResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(msg.skill ?? null);
-          }
-          return;
-        }
-        if (msg.type === "state_value" || msg.type === "state_data") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.stateGetResolvers.get(reqId);
-          if (pending) {
-            this.stateGetResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(msg.state ?? msg.row ?? null);
-          }
-          return;
-        }
-        if (msg.type === "state_list") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.stateListResolvers.get(reqId);
-          if (pending) {
-            this.stateListResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(Array.isArray(msg.entries) ? msg.entries : []);
-          }
-          return;
-        }
-        if (msg.type === "memory_stored") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.memoryStoreResolvers.get(reqId);
-          if (pending) {
-            this.memoryStoreResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(typeof msg.memoryId === "string" ? msg.memoryId : null);
-          }
-          return;
-        }
-        if (msg.type === "memory_recall_result") {
-          const reqId = String(msg._reqId ?? "");
-          const pending = this.memoryRecallResolvers.get(reqId);
-          if (pending) {
-            this.memoryRecallResolvers.delete(reqId);
-            clearTimeout(pending.timer);
-            pending.resolve(Array.isArray(msg.matches) ? msg.matches : []);
-          }
-          return;
-        }
-        if (msg.type === "push" || msg.type === "inbound") {
-          this.opts.onPush?.(msg);
-          return;
-        }
-      });
-      ws.on("close", (code, reason) => {
-        if (this.helloTimer) {
-          clearTimeout(this.helloTimer);
-          this.helloTimer = null;
-        }
-        this.failPendingAcks(`broker_disconnected_${code}`);
-        if (this.closed) {
-          this.setConnStatus("closed");
-          return;
+      },
+      onBeforeReconnect: (code) => this.failPendingAcks(`broker_disconnected_${code}`),
+      log: (level, msg, meta) => this.log(level, `broker_${msg}`, meta)
+    });
+  }
+  handleMessage(msg) {
+    if (msg.type === "ack") {
+      const id = String(msg.id ?? "");
+      const ack = this.pendingAcks.get(id);
+      if (ack) {
+        this.pendingAcks.delete(id);
+        clearTimeout(ack.timer);
+        if (typeof msg.error === "string" && msg.error.length > 0) {
+          ack.resolve({ ok: false, error: msg.error, permanent: classifyPermanent(msg.error) });
+        } else {
+          ack.resolve({ ok: true, messageId: String(msg.messageId ?? id) });
         }
-        this.setConnStatus("reconnecting");
-        const wait = BACKOFF_CAPS_MS[Math.min(this.reconnectAttempt, BACKOFF_CAPS_MS.length - 1)] ?? 30000;
-        this.reconnectAttempt++;
-        this.log("info", "broker_reconnect_scheduled", { wait_ms: wait, code, reason: reason.toString("utf8") });
-        this.reconnectTimer = setTimeout(() => this.connect().catch((err) => this.log("warn", "broker_reconnect_failed", { err: String(err) })), wait);
-        if (this._status === "connecting")
-          reject(new Error(`closed_before_hello_${code}`));
+      }
+      return;
+    }
+    if (msg.type === "peers_list") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.peerListResolvers.get(reqId);
+      if (pending) {
+        this.peerListResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(Array.isArray(msg.peers) ? msg.peers : []);
+      }
+      return;
+    }
+    if (msg.type === "skill_list") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.skillListResolvers.get(reqId);
+      if (pending) {
+        this.skillListResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(Array.isArray(msg.skills) ? msg.skills : []);
+      }
+      return;
+    }
+    if (msg.type === "skill_data") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.skillDataResolvers.get(reqId);
+      if (pending) {
+        this.skillDataResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(msg.skill ?? null);
+      }
+      return;
+    }
+    if (msg.type === "state_value" || msg.type === "state_data") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.stateGetResolvers.get(reqId);
+      if (pending) {
+        this.stateGetResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(msg.state ?? msg.row ?? null);
+      }
+      return;
+    }
+    if (msg.type === "state_list") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.stateListResolvers.get(reqId);
+      if (pending) {
+        this.stateListResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(Array.isArray(msg.entries) ? msg.entries : []);
+      }
+      return;
+    }
+    if (msg.type === "memory_stored") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.memoryStoreResolvers.get(reqId);
+      if (pending) {
+        this.memoryStoreResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(typeof msg.memoryId === "string" ? msg.memoryId : null);
+      }
+      return;
+    }
+    if (msg.type === "memory_recall_result") {
+      const reqId = String(msg._reqId ?? "");
+      const pending = this.memoryRecallResolvers.get(reqId);
+      if (pending) {
+        this.memoryRecallResolvers.delete(reqId);
+        clearTimeout(pending.timer);
+        pending.resolve(Array.isArray(msg.matches) ? msg.matches : []);
+      }
+      return;
+    }
+    if (msg.type === "push" || msg.type === "inbound") {
+      this.opts.onPush?.(msg);
+      return;
+    }
+  }
+  isOpen() {
+    const sock = this.lifecycle?.ws;
+    return !!sock && sock.readyState === sock.OPEN;
+  }
+  sendClientAck(clientMessageId, brokerMessageId) {
+    if (!this.isOpen())
+      return;
+    try {
+      this.lifecycle.send({
+        type: "client_ack",
+        clientMessageId,
+        ...brokerMessageId ? { brokerMessageId } : {}
       });
-      ws.on("error", (err) => this.log("warn", "broker_ws_error", { err: err.message }));
-    });
+    } catch {}
   }
   send(req) {
     return new Promise((resolve) => {
       const dispatch = () => {
-        if (!this.ws || this.ws.readyState !== this.ws.OPEN) {
+        if (!this.isOpen()) {
           resolve({ ok: false, error: "broker_not_open", permanent: false });
           return;
         }
@@ -10732,7 +10827,7 @@ class DaemonBrokerClient {
         }, SEND_ACK_TIMEOUT_MS);
         this.pendingAcks.set(id, { resolve, timer });
         try {
-          this.ws.send(JSON.stringify({
+          this.lifecycle.send({
             type: "send",
             id,
             client_message_id: id,
@@ -10741,7 +10836,7 @@ class DaemonBrokerClient {
             priority: req.priority,
             nonce: req.nonce,
             ciphertext: req.ciphertext
-          }));
+          });
         } catch (e) {
           this.pendingAcks.delete(id);
           clearTimeout(timer);
@@ -10755,7 +10850,7 @@ class DaemonBrokerClient {
     });
   }
   async listPeers(timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return [];
     return new Promise((resolve) => {
       const reqId = `pl-${++this.reqCounter}`;
@@ -10765,7 +10860,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.peerListResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "list_peers", _reqId: reqId }));
+        this.lifecycle.send({ type: "list_peers", _reqId: reqId });
       } catch {
         this.peerListResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10774,7 +10869,7 @@ class DaemonBrokerClient {
     });
   }
   async listSkills(query, timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return [];
     return new Promise((resolve) => {
       const reqId = `sl-${++this.reqCounter}`;
@@ -10784,7 +10879,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.skillListResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "list_skills", query, _reqId: reqId }));
+        this.lifecycle.send({ type: "list_skills", query, _reqId: reqId });
       } catch {
         this.skillListResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10793,7 +10888,7 @@ class DaemonBrokerClient {
     });
   }
   async getSkill(name, timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return null;
     return new Promise((resolve) => {
       const reqId = `sg-${++this.reqCounter}`;
@@ -10803,7 +10898,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.skillDataResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "get_skill", name, _reqId: reqId }));
+        this.lifecycle.send({ type: "get_skill", name, _reqId: reqId });
       } catch {
         this.skillDataResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10812,7 +10907,7 @@ class DaemonBrokerClient {
     });
   }
   async getState(key, timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return null;
     return new Promise((resolve) => {
       const reqId = `sg-${++this.reqCounter}`;
@@ -10822,7 +10917,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.stateGetResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "get_state", key, _reqId: reqId }));
+        this.lifecycle.send({ type: "get_state", key, _reqId: reqId });
       } catch {
         this.stateGetResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10831,7 +10926,7 @@ class DaemonBrokerClient {
     });
   }
   async listState(timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return [];
     return new Promise((resolve) => {
       const reqId = `sl-${++this.reqCounter}`;
@@ -10841,7 +10936,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.stateListResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "list_state", _reqId: reqId }));
+        this.lifecycle.send({ type: "list_state", _reqId: reqId });
       } catch {
         this.stateListResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10850,14 +10945,14 @@ class DaemonBrokerClient {
     });
   }
   setState(key, value) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return;
     try {
-      this.ws.send(JSON.stringify({ type: "set_state", key, value }));
+      this.lifecycle.send({ type: "set_state", key, value });
     } catch {}
   }
   async remember(content, tags, timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return null;
     return new Promise((resolve) => {
       const reqId = `mr-${++this.reqCounter}`;
@@ -10867,7 +10962,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.memoryStoreResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "remember", content, tags, _reqId: reqId }));
+        this.lifecycle.send({ type: "remember", content, tags, _reqId: reqId });
       } catch {
         this.memoryStoreResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10876,7 +10971,7 @@ class DaemonBrokerClient {
     });
   }
   async recall(query, timeoutMs = 5000) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return [];
     return new Promise((resolve) => {
       const reqId = `mc-${++this.reqCounter}`;
@@ -10886,7 +10981,7 @@ class DaemonBrokerClient {
       }, timeoutMs);
       this.memoryRecallResolvers.set(reqId, { resolve, timer });
       try {
-        this.ws.send(JSON.stringify({ type: "recall", query, _reqId: reqId }));
+        this.lifecycle.send({ type: "recall", query, _reqId: reqId });
       } catch {
         this.memoryRecallResolvers.delete(reqId);
         clearTimeout(timer);
@@ -10895,60 +10990,50 @@ class DaemonBrokerClient {
     });
   }
   forget(memoryId) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return;
     try {
-      this.ws.send(JSON.stringify({ type: "forget", memoryId }));
+      this.lifecycle.send({ type: "forget", memoryId });
     } catch {}
   }
   setProfile(profile) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return;
     try {
-      this.ws.send(JSON.stringify({ type: "set_profile", ...profile }));
+      this.lifecycle.send({ type: "set_profile", ...profile });
     } catch {}
   }
   setSummary(summary) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return;
     try {
-      this.ws.send(JSON.stringify({ type: "set_summary", summary }));
+      this.lifecycle.send({ type: "set_summary", summary });
     } catch {}
   }
   setStatus(status) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return;
     try {
-      this.ws.send(JSON.stringify({ type: "set_status", status }));
+      this.lifecycle.send({ type: "set_status", status });
     } catch {}
   }
   setVisible(visible) {
-    if (this._status !== "open" || !this.ws)
+    if (this._status !== "open" || !this.lifecycle)
       return;
     try {
-      this.ws.send(JSON.stringify({ type: "set_visible", visible }));
+      this.lifecycle.send({ type: "set_visible", visible });
     } catch {}
   }
   async close() {
     this.closed = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.helloTimer) {
-      clearTimeout(this.helloTimer);
-      this.helloTimer = null;
-    }
     this.failPendingAcks("daemon_shutdown");
-    try {
-      this.ws?.close();
-    } catch {}
-    this.setConnStatus("closed");
-  }
-  getSessionKeys() {
-    if (!this.sessionPubkey || !this.sessionSecretKey)
-      return null;
-    return { sessionPubkey: this.sessionPubkey, sessionSecretKey: this.sessionSecretKey };
+    if (this.lifecycle) {
+      try {
+        await this.lifecycle.close();
+      } catch {}
+      this.lifecycle = null;
+    }
+    this._status = "closed";
   }
   failPendingAcks(reason) {
     for (const [id, ack] of this.pendingAcks) {
@@ -10958,7 +11043,7 @@ class DaemonBrokerClient {
     }
   }
 }
-function defaultLog(level, msg, meta) {
+function defaultLog2(level, msg, meta) {
   const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
   if (level === "info")
     process.stdout.write(line + `
@@ -10970,24 +11055,21 @@ function defaultLog(level, msg, meta) {
 function classifyPermanent(err) {
   return /payload_too_large|forbidden|not_found|invalid|schema|auth|signature/i.test(err);
 }
-var HELLO_ACK_TIMEOUT_MS2 = 5000, SEND_ACK_TIMEOUT_MS = 15000, BACKOFF_CAPS_MS;
+var SEND_ACK_TIMEOUT_MS = 15000;
 var init_broker = __esm(() => {
   init_hello_sig();
-  BACKOFF_CAPS_MS = [1000, 2000, 4000, 8000, 16000, 30000];
+  init_ws_lifecycle();
 });
 
 // src/daemon/session-broker.ts
 import { hostname as osHostname } from "node:os";
-import WebSocket3 from "ws";
 
 class SessionBrokerClient {
   opts;
-  ws = null;
+  lifecycle = null;
   _status = "closed";
   closed = false;
-  reconnectAttempt = 0;
-  reconnectTimer = null;
-  helloTimer = null;
+  brokerUnsupported = false;
   constructor(opts) {
     this.opts = opts;
   }
@@ -11001,126 +11083,95 @@ class SessionBrokerClient {
     return this.opts.sessionPubkey;
   }
   log = (level, msg, meta) => {
-    (this.opts.log ?? defaultLog2)(level, msg, {
+    (this.opts.log ?? defaultLog3)(level, msg, {
       mesh: this.opts.mesh.slug,
       session_pubkey: this.opts.sessionPubkey.slice(0, 12),
       ...meta
     });
   };
-  setStatus(s) {
-    if (this._status === s)
-      return;
-    this._status = s;
-    this.opts.onStatusChange?.(s);
-  }
   async connect() {
     if (this.closed)
       throw new Error("client_closed");
     if (this._status === "connecting" || this._status === "open")
       return;
-    this.setStatus("connecting");
-    const ws = new WebSocket3(this.opts.mesh.brokerUrl);
-    this.ws = ws;
-    return new Promise((resolve, reject) => {
-      ws.on("open", async () => {
-        try {
-          const { timestamp: timestamp2, signature } = await signSessionHello({
-            meshId: this.opts.mesh.meshId,
-            parentMemberPubkey: this.opts.mesh.pubkey,
-            sessionPubkey: this.opts.sessionPubkey,
-            sessionSecretKey: this.opts.sessionSecretKey
-          });
-          ws.send(JSON.stringify({
-            type: "session_hello",
-            meshId: this.opts.mesh.meshId,
-            parentMemberId: this.opts.mesh.memberId,
-            parentMemberPubkey: this.opts.mesh.pubkey,
-            sessionPubkey: this.opts.sessionPubkey,
-            parentAttestation: this.opts.parentAttestation,
-            displayName: this.opts.displayName,
-            sessionId: this.opts.sessionId,
-            pid: this.opts.pid,
-            cwd: this.opts.cwd ?? process.cwd(),
-            hostname: osHostname(),
-            peerType: "ai",
-            channel: "claudemesh-session",
-            ...this.opts.groups && this.opts.groups.length > 0 ? { groups: this.opts.groups } : {},
-            ...this.opts.role ? { role: this.opts.role } : {},
-            timestamp: timestamp2,
-            signature
-          }));
-          this.helloTimer = setTimeout(() => {
-            this.log("warn", "session_hello_ack_timeout");
-            try {
-              ws.close();
-            } catch {}
-            reject(new Error("session_hello_ack_timeout"));
-          }, HELLO_ACK_TIMEOUT_MS3);
-        } catch (e) {
-          reject(e instanceof Error ? e : new Error(String(e)));
-        }
-      });
-      ws.on("message", (raw) => {
-        let msg;
-        try {
-          msg = JSON.parse(raw.toString());
-        } catch {
-          return;
-        }
-        if (msg.type === "hello_ack") {
-          if (this.helloTimer)
-            clearTimeout(this.helloTimer);
-          this.helloTimer = null;
-          this.setStatus("open");
-          this.reconnectAttempt = 0;
-          resolve();
-          return;
-        }
+    this.lifecycle = await connectWsWithBackoff({
+      url: this.opts.mesh.brokerUrl,
+      buildHello: async () => {
+        const { timestamp: timestamp2, signature } = await signSessionHello({
+          meshId: this.opts.mesh.meshId,
+          parentMemberPubkey: this.opts.mesh.pubkey,
+          sessionPubkey: this.opts.sessionPubkey,
+          sessionSecretKey: this.opts.sessionSecretKey
+        });
+        return {
+          type: "session_hello",
+          meshId: this.opts.mesh.meshId,
+          parentMemberId: this.opts.mesh.memberId,
+          parentMemberPubkey: this.opts.mesh.pubkey,
+          sessionPubkey: this.opts.sessionPubkey,
+          parentAttestation: this.opts.parentAttestation,
+          displayName: this.opts.displayName,
+          sessionId: this.opts.sessionId,
+          pid: this.opts.pid,
+          cwd: this.opts.cwd ?? process.cwd(),
+          hostname: osHostname(),
+          peerType: "ai",
+          channel: "claudemesh-session",
+          ...this.opts.groups && this.opts.groups.length > 0 ? { groups: this.opts.groups } : {},
+          ...this.opts.role ? { role: this.opts.role } : {},
+          timestamp: timestamp2,
+          signature
+        };
+      },
+      isHelloAck: (msg) => msg.type === "hello_ack",
+      onMessage: (msg) => {
         if (msg.type === "error") {
           this.log("warn", "broker_error", { code: msg.code, message: msg.message });
           if (msg.code === "unknown_message_type") {
+            this.brokerUnsupported = true;
             this.closed = true;
+            this.lifecycle?.close();
           }
           return;
         }
-      });
-      ws.on("close", (code, reason) => {
-        if (this.helloTimer) {
-          clearTimeout(this.helloTimer);
-          this.helloTimer = null;
-        }
-        if (this.closed) {
-          this.setStatus("closed");
+        if (msg.type === "push" || msg.type === "inbound") {
+          this.opts.onPush?.(msg);
           return;
         }
-        this.setStatus("reconnecting");
-        const wait = BACKOFF_CAPS_MS2[Math.min(this.reconnectAttempt, BACKOFF_CAPS_MS2.length - 1)] ?? 30000;
-        this.reconnectAttempt++;
-        this.log("info", "session_broker_reconnect_scheduled", { wait_ms: wait, code, reason: reason.toString("utf8") });
-        this.reconnectTimer = setTimeout(() => this.connect().catch((err) => this.log("warn", "session_broker_reconnect_failed", { err: String(err) })), wait);
-        if (this._status === "connecting")
-          reject(new Error(`closed_before_hello_${code}`));
-      });
-      ws.on("error", (err) => this.log("warn", "session_broker_ws_error", { err: err.message }));
+      },
+      onStatusChange: (s) => {
+        this._status = s;
+        this.opts.onStatusChange?.(s);
+      },
+      log: (level, msg, meta) => this.log(level, `session_broker_${msg}`, meta)
     });
   }
+  sendClientAck(clientMessageId, brokerMessageId) {
+    if (this._status !== "open" || !this.lifecycle)
+      return;
+    try {
+      this.lifecycle.send({
+        type: "client_ack",
+        clientMessageId,
+        ...brokerMessageId ? { brokerMessageId } : {}
+      });
+    } catch {}
+  }
   async close() {
     this.closed = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.helloTimer) {
-      clearTimeout(this.helloTimer);
-      this.helloTimer = null;
+    if (this.lifecycle) {
+      try {
+        await this.lifecycle.close();
+      } catch {}
+      this.lifecycle = null;
     }
-    try {
-      this.ws?.close();
-    } catch {}
-    this.setStatus("closed");
+    this._status = "closed";
+  }
+  get isBrokerUnsupported() {
+    return this.brokerUnsupported;
   }
 }
-function defaultLog2(level, msg, meta) {
+function defaultLog3(level, msg, meta) {
   const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
   if (level === "info")
     process.stdout.write(line + `
@@ -11129,15 +11180,14 @@ function defaultLog2(level, msg, meta) {
     process.stderr.write(line + `
 `);
 }
-var HELLO_ACK_TIMEOUT_MS3 = 5000, BACKOFF_CAPS_MS2;
 var init_session_broker = __esm(() => {
   init_session_hello_sig();
-  BACKOFF_CAPS_MS2 = [1000, 2000, 4000, 8000, 16000, 30000];
+  init_ws_lifecycle();
 });
 
 // src/daemon/drain.ts
 function startDrainWorker(opts) {
-  const log2 = opts.log ?? defaultLog3;
+  const log2 = opts.log ?? defaultLog4;
   let stopped = false;
   let wakeResolve = null;
   let wakePromise = new Promise((r) => {
@@ -11281,7 +11331,7 @@ async function randomNonce2() {
   const { randomBytes: randomBytes6 } = await import("node:crypto");
   return randomBytes6(24).toString("base64");
 }
-function defaultLog3(level, msg, meta) {
+function defaultLog4(level, msg, meta) {
   const line = JSON.stringify({ level, msg, ...meta, ts: new Date().toISOString() });
   if (level === "info")
     process.stdout.write(line + `
@@ -11338,6 +11388,7 @@ async function handleBrokerPush(msg, ctx) {
     received_at: Date.now(),
     reply_to_id: replyToId
   });
+  ctx.ackClientMessage?.(clientMessageId, brokerMessageId);
   if (!inserted)
     return;
   ctx.bus.publish("message", {
@@ -11608,13 +11659,12 @@ async function runDaemon(opts = {}) {
         bus.publish("broker_status", { mesh: mesh.slug, status: s });
       },
       onPush: (m) => {
-        const sessionKeys = broker.getSessionKeys();
         handleBrokerPush(m, {
           db: inboxDb,
           bus,
           meshSlug: mesh.slug,
           recipientSecretKeyHex: mesh.secretKey,
-          sessionSecretKeyHex: sessionKeys?.sessionSecretKey
+          ackClientMessage: (cmid, bmid) => broker.sendClientAck(cmid, bmid)
         });
       }
     });
@@ -11645,6 +11695,7 @@ async function runDaemon(opts = {}) {
         sessionBrokers.delete(info.token);
         prior.close().catch(() => {});
       }
+      const sessionSecretKeyHex = info.presence.sessionSecretKey;
       const client = new SessionBrokerClient({
         mesh: meshConfig,
         sessionPubkey: info.presence.sessionPubkey,
@@ -11654,7 +11705,17 @@ async function runDaemon(opts = {}) {
         displayName: info.displayName,
         ...info.role ? { role: info.role } : {},
         ...info.cwd ? { cwd: info.cwd } : {},
-        pid: info.pid
+        pid: info.pid,
+        onPush: (m) => {
+          handleBrokerPush(m, {
+            db: inboxDb,
+            bus,
+            meshSlug: meshConfig.slug,
+            recipientSecretKeyHex: meshConfig.secretKey,
+            sessionSecretKeyHex,
+            ackClientMessage: (cmid, bmid) => client.sendClientAck(cmid, bmid)
+          });
+        }
       });
       sessionBrokers.set(info.token, client);
       client.connect().catch((err) => process.stderr.write(JSON.stringify({
@@ -13062,8 +13123,8 @@ async function checkBrokerWs() {
   const wsUrl = URLS.BROKER;
   const start = Date.now();
   try {
-    const WebSocket4 = (await import("ws")).default;
-    const ws = new WebSocket4(wsUrl);
+    const WebSocket3 = (await import("ws")).default;
+    const ws = new WebSocket3(wsUrl);
     const result = await new Promise((resolve2) => {
       const timer = setTimeout(() => {
         try {
@@ -13174,11 +13235,11 @@ __export(exports_status, {
   runStatus: () => runStatus2
 });
 import { statSync as statSync4, existsSync as existsSync16 } from "node:fs";
-import WebSocket4 from "ws";
+import WebSocket3 from "ws";
 async function probeBroker(url, timeoutMs = 4000) {
   return new Promise((resolve2) => {
     const started = Date.now();
-    const ws = new WebSocket4(url);
+    const ws = new WebSocket3(url);
     const timer = setTimeout(() => {
       try {
         ws.terminate();
@@ -16388,7 +16449,7 @@ var require_client = __commonJS((exports) => {
   var ws_1 = __importDefault(__require("ws"));
   var crypto_js_1 = require_crypto();
   var MAX_QUEUED2 = 100;
-  var HELLO_ACK_TIMEOUT_MS4 = 5000;
+  var HELLO_ACK_TIMEOUT_MS2 = 5000;
   var BACKOFF_CAPS2 = [1000, 2000, 4000, 8000, 16000, 30000];
 
   class MeshClient extends node_events_1.EventEmitter {
@@ -16453,7 +16514,7 @@ var require_client = __commonJS((exports) => {
             this.debug("hello_ack timeout");
             ws.close();
             reject(new Error("hello_ack timeout"));
-          }, HELLO_ACK_TIMEOUT_MS4);
+          }, HELLO_ACK_TIMEOUT_MS2);
         };
         const onMessage = (raw) => {
           let msg;
@@ -20273,4 +20334,4 @@ main().catch((err) => {
   process.exit(EXIT.INTERNAL_ERROR);
 });
 
-//# debugId=9045DA825D3D7C3164756E2164756E21
+//# debugId=DC25A8288183DA4364756E2164756E21