@unagents/messenger-broker 0.9.0 → 0.11.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Peer, Message, RelayedMessage } from '@unagents/messenger-protocol';
+import { Peer, Message, RelayedMessage, StoredProtocol } from '@unagents/messenger-protocol';
 
 /**
  * Broker configuration. Every field can be given to `startBroker(options)`;
@@ -22,6 +22,11 @@ interface BrokerOptions {
     discoveryPort?: number;
     /** UDP bind address when pinned (`AGENT_MESSENGER_DISCOVERY_ADDR`, default `""` = all interfaces). */
     discoveryAddr?: string;
+    /**
+     * Explicit discovery send targets, `host:port` each (`AGENT_MESSENGER_DISCOVERY_TARGETS`, comma separated).
+     * When non-empty, probes and announces go to these instead of broadcast (tests; LAN without broadcast).
+     */
+    discoveryTargets?: string[];
     /**
      * Run as a local fallback broker (`AGENT_MESSENGER_FALLBACK=1`, set by the client when it spawns one).
      * A fallback probes for other brokers every `fallbackIntervalMs`; when it finds one it relays its
@@ -38,16 +43,16 @@ interface BrokerOptions {
      */
     mesh?: boolean;
     /**
-     * Mesh members to sync with. Empty (default) = the `brokers` list of the client
-     * config file (`AGENT_MESSENGER_CONFIG`, default `~/.agent-messenger/config.json`), re-read every round.
+     * Test-only: a fixed list of mesh members that replaces discovery. Empty (default) = members are
+     * found by UDP discovery (announce / probe reply, token-checked). Not documented for users.
      */
     meshBrokers?: string[];
+    /** Mesh announce interval in ms (`AGENT_MESSENGER_MESH_ANNOUNCE_MS`, default 10000). */
+    meshAnnounceMs?: number;
     /** Mesh sync interval in ms (`AGENT_MESSENGER_MESH_INTERVAL_MS`, default 5000). */
     meshIntervalMs?: number;
     /** Replicated peers disappear this long after their origin stopped syncing (`AGENT_MESSENGER_MESH_PEER_TTL_MS`, default 300000). */
     meshPeerTtlMs?: number;
-    /** Client config file read for the mesh member list (`AGENT_MESSENGER_CONFIG`). */
-    configFile?: string;
 }
 type BrokerConfig = Required<Omit<BrokerOptions, "onSupersede">> & Pick<BrokerOptions, "onSupersede">;
 /** Marks a broker as a local fallback. Broker-private (not in the protocol ENV table, which mirrors legacy). */
@@ -78,6 +83,8 @@ interface BrokerStateFile {
     nextMsgId: number;
     /** Relayed messages waiting for their recipient to register (absent in files written before the fallback relay). */
     pending?: PendingRelay[];
+    /** Protocol definitions (absent in files written before the protocol registry, or when none is held). */
+    protocols?: StoredProtocol[];
 }
 /** A message relayed from a fallback broker whose recipient has not registered here yet. */
 interface PendingRelay extends RelayedMessage {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Peer, Message, RelayedMessage } from '@unagents/messenger-protocol';
+import { Peer, Message, RelayedMessage, StoredProtocol } from '@unagents/messenger-protocol';
 
 /**
  * Broker configuration. Every field can be given to `startBroker(options)`;
@@ -22,6 +22,11 @@ interface BrokerOptions {
     discoveryPort?: number;
     /** UDP bind address when pinned (`AGENT_MESSENGER_DISCOVERY_ADDR`, default `""` = all interfaces). */
     discoveryAddr?: string;
+    /**
+     * Explicit discovery send targets, `host:port` each (`AGENT_MESSENGER_DISCOVERY_TARGETS`, comma separated).
+     * When non-empty, probes and announces go to these instead of broadcast (tests; LAN without broadcast).
+     */
+    discoveryTargets?: string[];
     /**
      * Run as a local fallback broker (`AGENT_MESSENGER_FALLBACK=1`, set by the client when it spawns one).
      * A fallback probes for other brokers every `fallbackIntervalMs`; when it finds one it relays its
@@ -38,16 +43,16 @@ interface BrokerOptions {
      */
     mesh?: boolean;
     /**
-     * Mesh members to sync with. Empty (default) = the `brokers` list of the client
-     * config file (`AGENT_MESSENGER_CONFIG`, default `~/.agent-messenger/config.json`), re-read every round.
+     * Test-only: a fixed list of mesh members that replaces discovery. Empty (default) = members are
+     * found by UDP discovery (announce / probe reply, token-checked). Not documented for users.
      */
     meshBrokers?: string[];
+    /** Mesh announce interval in ms (`AGENT_MESSENGER_MESH_ANNOUNCE_MS`, default 10000). */
+    meshAnnounceMs?: number;
     /** Mesh sync interval in ms (`AGENT_MESSENGER_MESH_INTERVAL_MS`, default 5000). */
     meshIntervalMs?: number;
     /** Replicated peers disappear this long after their origin stopped syncing (`AGENT_MESSENGER_MESH_PEER_TTL_MS`, default 300000). */
     meshPeerTtlMs?: number;
-    /** Client config file read for the mesh member list (`AGENT_MESSENGER_CONFIG`). */
-    configFile?: string;
 }
 type BrokerConfig = Required<Omit<BrokerOptions, "onSupersede">> & Pick<BrokerOptions, "onSupersede">;
 /** Marks a broker as a local fallback. Broker-private (not in the protocol ENV table, which mirrors legacy). */
@@ -78,6 +83,8 @@ interface BrokerStateFile {
     nextMsgId: number;
     /** Relayed messages waiting for their recipient to register (absent in files written before the fallback relay). */
     pending?: PendingRelay[];
+    /** Protocol definitions (absent in files written before the protocol registry, or when none is held). */
+    protocols?: StoredProtocol[];
 }
 /** A message relayed from a fallback broker whose recipient has not registered here yet. */
 interface PendingRelay extends RelayedMessage {

package/dist/index.mjs

@@ -1,11 +1,12 @@
 import 'listhen';
 import 'h3';
 import '@unagents/messenger-protocol';
-export { D as DEFAULT_STATE_FILE, F as FALLBACK_ENV, a as FALLBACK_INTERVAL_ENV, M as MESH_ENV, S as STATE_DIR, V as VERSION, c as configFromEnv, r as resolveConfig, s as startBroker } from './shared/messenger-broker.CY2SPlVR.mjs';
+export { D as DEFAULT_STATE_FILE, F as FALLBACK_ENV, a as FALLBACK_INTERVAL_ENV, M as MESH_ENV, S as STATE_DIR, V as VERSION, c as configFromEnv, r as resolveConfig, s as startBroker } from './shared/messenger-broker.Co46RRtX.mjs';
 import 'node:os';
 import 'node:path';
 import 'defu';
 import 'node:fs';
 import 'consola';
+import 'node:crypto';
 import 'node:http';
 import 'node:dgram';

package/dist/main.mjs

@@ -1,4 +1,4 @@
-import { s as startBroker, l as log } from './shared/messenger-broker.CY2SPlVR.mjs';
+import { s as startBroker, l as log } from './shared/messenger-broker.Co46RRtX.mjs';
 import 'listhen';
 import 'h3';
 import '@unagents/messenger-protocol';
@@ -7,6 +7,7 @@ import 'node:path';
 import 'defu';
 import 'node:fs';
 import 'consola';
+import 'node:crypto';
 import 'node:http';
 import 'node:dgram';
 

package/dist/shared/{messenger-broker.CY2SPlVR.mjs → messenger-broker.Co46RRtX.mjs}

@@ -1,11 +1,12 @@
 import { listen } from 'listhen';
 import { createRouter, defineEventHandler, createApp, send, setResponseStatus, getRequestHeader, readRawBody, toNodeListener } from 'h3';
-import { DEFAULT_BIND, ENV, DEFAULT_DISCOVERY_PORT, DEFAULT_HTTP_PORT, HEARTBEAT_TIMEOUT_MS, MESH_SYNC_ROUTE, HEALTH_ROUTE, BROKER_POST_ROUTES, RELAY_ROUTE, DISCOVERY_KEY, DISCOVERY_PROBE_VALUE, DISCOVERY_REPLY_VALUE } from '@unagents/messenger-protocol';
+import { DEFAULT_BIND, MESH_ANNOUNCE_ENV, DISCOVERY_TARGETS_ENV, ENV, DEFAULT_DISCOVERY_PORT, DEFAULT_HTTP_PORT, PROTOCOL_NAME_PATTERN, PROTOCOL_META_MAX_LENGTH, PROTOCOL_MANIFEST_MAX_BYTES, PROTOCOL_DOC_MAX_BYTES, PROTOCOL_TOTAL_MAX_BYTES, canonicalJSON, HEARTBEAT_TIMEOUT_MS, PROTOCOL_MAX_STORED, MESH_SYNC_ROUTE, DISCOVERY_KEY, DISCOVERY_ANNOUNCE_VALUE, MESH_ANNOUNCE_MAX_SKEW_MS, DISCOVERY_REPLY_VALUE, meshMacEqual, meshMac, HEALTH_ROUTE, BROKER_POST_ROUTES, PROTOCOL_ROUTES, RELAY_ROUTE, DISCOVERY_PROBE_VALUE } from '@unagents/messenger-protocol';
 import { homedir, hostname, networkInterfaces } from 'node:os';
 import { join, dirname } from 'node:path';
 import { defu } from 'defu';
 import { readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
 import { createConsola } from 'consola';
+import { createHash, randomBytes } from 'node:crypto';
 import { request } from 'node:http';
 import { createSocket } from 'node:dgram';
 
@@ -29,13 +30,14 @@ function configFromEnv(env = process.env) {
     discovery: (env[ENV.DISCOVERY] ?? "on").toLowerCase() !== "off",
     discoveryPort: parseInt(env[ENV.DISCOVERY_PORT] ?? String(DEFAULT_DISCOVERY_PORT), 10),
     discoveryAddr: env[ENV.DISCOVERY_ADDR] ?? "",
+    discoveryTargets: (env[DISCOVERY_TARGETS_ENV] ?? "").split(",").map((s) => s.trim()).filter(Boolean),
     fallback: ["1", "true", "on", "yes"].includes((env[FALLBACK_ENV] ?? "").toLowerCase()),
     fallbackIntervalMs: parseInt(env[FALLBACK_INTERVAL_ENV] ?? String(DEFAULT_FALLBACK_INTERVAL_MS), 10),
     mesh: (env[MESH_ENV.MESH] ?? "off").toLowerCase() === "on",
     meshBrokers: [],
+    meshAnnounceMs: parseInt(env[MESH_ANNOUNCE_ENV] ?? "10000", 10),
     meshIntervalMs: parseInt(env[MESH_ENV.INTERVAL_MS] ?? "5000", 10),
-    meshPeerTtlMs: parseInt(env[MESH_ENV.PEER_TTL_MS] ?? "300000", 10),
-    configFile: env[ENV.CONFIG] ?? join(STATE_DIR, "config.json")
+    meshPeerTtlMs: parseInt(env[MESH_ENV.PEER_TTL_MS] ?? "300000", 10)
   };
 }
 function resolveConfig(options = {}) {
@@ -54,6 +56,8 @@ class BrokerState {
   messages = [];
   nextMsgId = 1;
   pending = [];
+  /** Protocol definitions by `"name@version"`. Kept while at least one alive peer declares them (see `BrokerHandlers.gcProtocols`). */
+  protocols = /* @__PURE__ */ new Map();
   /** Mesh: when each origin broker last synced with us (ms epoch, memory only). Replicated peers live as long as this is fresh. */
   originSeen = /* @__PURE__ */ new Map();
   saveTimer = null;
@@ -68,7 +72,12 @@ class BrokerState {
       this.messages = raw.messages ?? [];
       this.nextMsgId = raw.nextMsgId ?? 1;
       this.pending = raw.pending ?? [];
-      log.info(`Loaded state from ${this.file} (${this.peers.size} peer(s), ${this.messages.length} message(s))`);
+      for (const sp of raw.protocols ?? []) {
+        if (sp && typeof sp.name === "string" && typeof sp.version === "string") this.protocols.set(`${sp.name}@${sp.version}`, sp);
+      }
+      log.info(
+        `Loaded state from ${this.file} (${this.peers.size} peer(s), ${this.messages.length} message(s)${this.protocols.size ? `, ${this.protocols.size} protocol(s)` : ""})`
+      );
     } catch {
     }
   }
@@ -93,7 +102,8 @@ class BrokerState {
         peers: [...this.peers.values()],
         messages: this.messages,
         nextMsgId: this.nextMsgId,
-        ...this.pending.length ? { pending: this.pending } : {}
+        ...this.pending.length ? { pending: this.pending } : {},
+        ...this.protocols.size ? { protocols: [...this.protocols.values()] } : {}
       };
       writeFileSync(tmp, JSON.stringify(snapshot, null, 1));
       renameSync(tmp, this.file);
@@ -107,6 +117,112 @@ class BrokerState {
   }
 }
 
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const HASH_PATTERN = /^[0-9a-f]{64}$/;
+const MAX_FIELD_LENGTH = 1024;
+function protocolHash(manifest, doc) {
+  return createHash("sha256").update(canonicalJSON({ manifest, doc })).digest("hex");
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function checkDefinition(name, version, def) {
+  const bad = (error) => ({ ok: false, code: "INVALID_DEFINITION", error });
+  if (typeof name !== "string" || !PROTOCOL_NAME_PATTERN.test(name)) {
+    return bad(`invalid protocol name (expected ${String(PROTOCOL_NAME_PATTERN)})`);
+  }
+  if (typeof version !== "string" || version.length > MAX_FIELD_LENGTH || !VERSION_PATTERN.test(version)) {
+    return bad("invalid version (expected semver, e.g. 1.2.0 or 0.0.0+abc1234)");
+  }
+  if (!isPlainObject(def)) return bad("missing definition");
+  const { manifest, doc, source, ref } = def;
+  if (!isPlainObject(manifest)) return bad("definition.manifest must be an object");
+  if (typeof doc !== "string") return bad("definition.doc must be a string");
+  if (typeof source !== "string" || !source || source.length > MAX_FIELD_LENGTH) return bad("definition.source must be a non-empty string");
+  if (typeof ref !== "string" || !ref || ref.length > MAX_FIELD_LENGTH) return bad("definition.ref must be a non-empty string");
+  if (manifest.name !== name) return bad(`protocol.json "name" must equal "${name}"`);
+  if (manifest.description !== void 0 && typeof manifest.description !== "string") return bad('protocol.json "description" must be a string');
+  if (manifest.messages !== void 0) {
+    if (!isPlainObject(manifest.messages)) return bad('protocol.json "messages" must be an object');
+    for (const [k, schema] of Object.entries(manifest.messages)) {
+      if (!isPlainObject(schema)) return bad(`protocol.json messages.${k} must be an object (JSON Schema)`);
+    }
+  }
+  const manifestBytes = Buffer.byteLength(JSON.stringify(manifest));
+  const docBytes = Buffer.byteLength(doc);
+  if (manifestBytes > PROTOCOL_MANIFEST_MAX_BYTES) {
+    return { ok: false, code: "TOO_LARGE", error: `protocol.json is ${manifestBytes} bytes (limit ${PROTOCOL_MANIFEST_MAX_BYTES})` };
+  }
+  if (docBytes > PROTOCOL_DOC_MAX_BYTES) {
+    return { ok: false, code: "TOO_LARGE", error: `PROTOCOL.md is ${docBytes} bytes (limit ${PROTOCOL_DOC_MAX_BYTES})` };
+  }
+  if (manifestBytes + docBytes > PROTOCOL_TOTAL_MAX_BYTES) {
+    return { ok: false, code: "TOO_LARGE", error: `definition is ${manifestBytes + docBytes} bytes (limit ${PROTOCOL_TOTAL_MAX_BYTES})` };
+  }
+  return { ok: true };
+}
+function sanitizeDecls(list) {
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const d of list) {
+    if (!isPlainObject(d)) continue;
+    const { name, version, hash } = d;
+    if (typeof name !== "string" || !PROTOCOL_NAME_PATTERN.test(name)) continue;
+    if (typeof version !== "string" || version.length > MAX_FIELD_LENGTH || !VERSION_PATTERN.test(version)) continue;
+    if (typeof hash !== "string" || !HASH_PATTERN.test(hash)) continue;
+    if (out.some((o) => o.name === name)) continue;
+    out.push({ name, version, hash });
+  }
+  return out;
+}
+function checkMeta(meta) {
+  if (!isPlainObject(meta)) return null;
+  const { protocol, version } = meta;
+  if (typeof protocol !== "string" || typeof version !== "string") return null;
+  if (protocol.length > PROTOCOL_META_MAX_LENGTH || version.length > PROTOCOL_META_MAX_LENGTH) return null;
+  return { protocol, version };
+}
+function isTagless(v) {
+  return v.startsWith("0.0.0+");
+}
+const SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/;
+function compareVersions(a, b) {
+  const ta = isTagless(a);
+  const tb = isTagless(b);
+  if (ta || tb) return ta && tb ? 0 : ta ? -1 : 1;
+  const ma = SEMVER.exec(a);
+  const mb = SEMVER.exec(b);
+  if (!ma || !mb) return a < b ? -1 : a > b ? 1 : 0;
+  for (let i = 1; i <= 3; i++) {
+    const x = BigInt(ma[i]);
+    const y = BigInt(mb[i]);
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  const pa = ma[4];
+  const pb = mb[4];
+  if (pa === void 0 && pb === void 0) return 0;
+  if (pa === void 0) return 1;
+  if (pb === void 0) return -1;
+  const ia = pa.split(".");
+  const ib = pb.split(".");
+  for (let i = 0; i < Math.min(ia.length, ib.length); i++) {
+    const x = ia[i];
+    const y = ib[i];
+    const nx = /^\d+$/.test(x);
+    const ny = /^\d+$/.test(y);
+    if (nx && ny) {
+      const dx = BigInt(x);
+      const dy = BigInt(y);
+      if (dx !== dy) return dx < dy ? -1 : 1;
+    } else if (nx !== ny) {
+      return nx ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return ia.length === ib.length ? 0 : ia.length < ib.length ? -1 : 1;
+}
+
 const PENDING_RELAY_TTL_MS = 60 * 60 * 1e3;
 const DEFAULT_MESH_PEER_TTL_MS = 3e5;
 const MESH_KEY_MEMORY = 2e3;
@@ -116,6 +232,8 @@ class BrokerHandlers {
     this.opts = opts;
   }
   recentMeshKeys = /* @__PURE__ */ new Set();
+  /** Mesh protocol conflicts already logged (`name@version:hash`), so a standing conflict warns once, not every round. */
+  warnedProtocolConflicts = /* @__PURE__ */ new Set();
   // --- peer bookkeeping ---
   /** Cutoff `last_seen` (ISO) below which a peer counts as stale. */
   static cutoff() {
@@ -158,6 +276,56 @@ class BrokerHandlers {
       this.state.pending = kept;
       this.state.scheduleSave();
     }
+    this.gcProtocols();
+  }
+  // --- protocol store ---
+  /** Alive peers (replicas included) that declare `name@version`. */
+  serversOf(name, version) {
+    const cutoff = BrokerHandlers.cutoff();
+    return [...this.state.peers.values()].filter(
+      (p) => this.isAlive(p, cutoff) && p.protocols?.some((d) => d.name === name && d.version === version)
+    );
+  }
+  /**
+   * Drop stored definitions that no alive peer (replicas included) declares by `(name, version)` any more.
+   * Runs after `cleanStalePeers`, `register`, `unregister`, `/set-protocol`, `/unset-protocol`, `meshApplyPeers`
+   * and before `/get-protocol` answers.
+   */
+  gcProtocols() {
+    if (this.state.protocols.size === 0) return;
+    const cutoff = BrokerHandlers.cutoff();
+    const live = /* @__PURE__ */ new Set();
+    for (const p of this.state.peers.values()) {
+      if (!this.isAlive(p, cutoff)) continue;
+      for (const d of p.protocols ?? []) live.add(`${d.name}@${d.version}`);
+    }
+    let removed = 0;
+    for (const key of [...this.state.protocols.keys()]) {
+      if (!live.has(key)) {
+        this.state.protocols.delete(key);
+        removed++;
+      }
+    }
+    if (removed) {
+      log.info(`Dropped ${removed} protocol definition(s) without a declaring peer`);
+      this.state.scheduleSave();
+    }
+  }
+  /**
+   * Record `decls` on `peer` (hash only). A name the peer already declares is left alone (only `/set-protocol`
+   * changes a declaration, so a heartbeat that raced a change cannot undo it), and so is a declaration whose hash
+   * differs from the definition stored for the same `(name, version)`.
+   */
+  mergeDecls(peer, decls) {
+    let changed = false;
+    for (const d of decls) {
+      if (peer.protocols?.some((x) => x.name === d.name)) continue;
+      const stored = this.state.protocols.get(`${d.name}@${d.version}`);
+      if (stored && stored.hash !== d.hash) continue;
+      peer.protocols = [...peer.protocols ?? [], d];
+      changed = true;
+    }
+    return changed;
   }
   /** A peer that registered here (not a mesh replica). Only those can heartbeat / rename. */
   localPeer(id) {
@@ -206,7 +374,10 @@ class BrokerHandlers {
       registered_at: now,
       last_seen: now
     });
-    this.deliverPending(this.state.peers.get(id));
+    const peer = this.state.peers.get(id);
+    if (body.protocols !== void 0) this.mergeDecls(peer, sanitizeDecls(body.protocols));
+    this.deliverPending(peer);
+    this.gcProtocols();
     this.state.scheduleSave();
     return { id };
   }
@@ -214,8 +385,10 @@ class BrokerHandlers {
     const p = this.localPeer(body.id);
     if (!p) return { ok: false, error: "unknown peer (re-register)" };
     p.last_seen = (/* @__PURE__ */ new Date()).toISOString();
+    if (body.protocols !== void 0) this.mergeDecls(p, sanitizeDecls(body.protocols));
     this.state.scheduleSave();
-    return { ok: true };
+    const resend = (p.protocols ?? []).filter((d) => !this.state.protocols.has(`${d.name}@${d.version}`)).map((d) => `${d.name}@${d.version}`);
+    return resend.length ? { ok: true, resend } : { ok: true };
   }
   setSummary(body) {
     const p = this.localPeer(body.id);
@@ -247,6 +420,10 @@ class BrokerHandlers {
         break;
     }
     if (body.exclude_id) list = list.filter((p) => p.id !== body.exclude_id);
+    if (body.protocol) {
+      const { protocol, version } = body;
+      list = list.filter((p) => p.protocols?.some((d) => d.name === protocol && (!version || d.version === version)));
+    }
     return list.map(({ origin: _origin, ...p }) => p);
   }
   sendMessage(body) {
@@ -255,6 +432,12 @@ class BrokerHandlers {
     const { peer } = resolved;
     const mode = body.mode ?? "pull";
     if (mode !== "pull" && mode !== "push" && mode !== "ping") return { ok: false, error: `invalid mode: ${String(mode)}` };
+    let meta;
+    if (body.meta !== void 0) {
+      const checked = checkMeta(body.meta);
+      if (!checked) return { ok: false, error: "invalid meta: expected {protocol: string, version: string}, each at most 128 characters" };
+      meta = checked;
+    }
     const msg = {
       id: this.state.nextMsgId++,
       from_id: body.from_id ?? "cli",
@@ -264,7 +447,8 @@ class BrokerHandlers {
       mode,
       sent_at: (/* @__PURE__ */ new Date()).toISOString(),
       delivered: 0,
-      acknowledged: 0
+      acknowledged: 0,
+      ...meta ? { meta } : {}
     };
     this.state.messages.push(msg);
     this.state.scheduleSave();
@@ -293,12 +477,99 @@ class BrokerHandlers {
   }
   unregister(body) {
     this.removePeer(body.id);
+    this.gcProtocols();
     this.state.scheduleSave();
     return { ok: true };
   }
+  // --- protocol registry ---
+  protocolError(code, error, extra = {}) {
+    return { ok: false, error, code, ...extra };
+  }
+  /**
+   * `/set-protocol`. Order: unknown peer, definition shape / size (INVALID_DEFINITION, TOO_LARGE), hash
+   * re-computation (HASH_MISMATCH), different hash for the same `(name, version)` (PROTOCOL_CONFLICT), held
+   * definitions limit (LIMIT). The same hash again is a no-op success, so a client may re-send at will.
+   */
+  setProtocol(body) {
+    const peer = this.localPeer(body.id);
+    if (!peer) return { ok: false, error: "unknown peer" };
+    const checked = checkDefinition(body.name, body.version, body.definition);
+    if (!checked.ok) return this.protocolError(checked.code, checked.error);
+    const { name, version, definition } = body;
+    const hash = protocolHash(definition.manifest, definition.doc);
+    if (body.hash !== hash) {
+      return this.protocolError("HASH_MISMATCH", `hash mismatch for ${name}@${version}: sent ${String(body.hash)}, computed ${hash}`);
+    }
+    this.gcProtocols();
+    const key = `${name}@${version}`;
+    const existing = this.state.protocols.get(key);
+    if (existing && existing.hash !== hash) {
+      const servers = this.serversOf(name, version).map((p) => `${p.name || p.id}@${p.hostname}`);
+      return this.protocolError(
+        "PROTOCOL_CONFLICT",
+        `${key} is already registered with a different definition (hash ${existing.hash}, held by ${servers.join(", ") || "no server"}); every server of it must unset_protocol first`,
+        { existing_hash: existing.hash, servers }
+      );
+    }
+    if (!existing) {
+      if (this.state.protocols.size >= PROTOCOL_MAX_STORED) {
+        return this.protocolError("LIMIT", `this broker already holds ${PROTOCOL_MAX_STORED} protocol definitions (limit)`);
+      }
+      this.state.protocols.set(key, {
+        name,
+        version,
+        hash,
+        definition: { manifest: definition.manifest, doc: definition.doc, source: definition.source, ref: definition.ref },
+        registered_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    peer.protocols = [...(peer.protocols ?? []).filter((d) => d.name !== name), { name, version, hash }];
+    this.gcProtocols();
+    this.state.scheduleSave();
+    return { ok: true };
+  }
+  /** `/unset-protocol`: drop one declaration by `name`, or all of the peer's. Succeeds with `removed: 0` when there was none. */
+  unsetProtocol(body) {
+    const peer = this.localPeer(body.id);
+    if (!peer) return { ok: false, error: "unknown peer" };
+    if (body.name !== void 0 && typeof body.name !== "string") return { ok: false, error: "invalid name" };
+    const before = peer.protocols ?? [];
+    const kept = body.name === void 0 ? [] : before.filter((d) => d.name !== body.name);
+    const removed = before.length - kept.length;
+    if (kept.length) peer.protocols = kept;
+    else delete peer.protocols;
+    if (removed) {
+      this.gcProtocols();
+      this.state.scheduleSave();
+    }
+    return { ok: true, removed };
+  }
+  /** `/get-protocol`: the stored definition of `name` at `version`, or at the highest held version. No round trip to any server. */
+  getProtocol(body) {
+    if (typeof body.name !== "string" || !body.name) return this.protocolError("PROTOCOL_NOT_FOUND", "protocol name is required", { versions: [] });
+    this.gcProtocols();
+    const held = [...this.state.protocols.values()].filter((sp) => sp.name === body.name);
+    held.sort((a, b) => compareVersions(b.version, a.version) || (a.registered_at < b.registered_at ? 1 : -1));
+    const versions = held.map((sp) => sp.version);
+    const found = body.version === void 0 ? held[0] : held.find((sp) => sp.version === body.version);
+    if (!found) {
+      const what = body.version === void 0 ? `"${body.name}"` : `"${body.name}" version "${body.version}"`;
+      return this.protocolError("PROTOCOL_NOT_FOUND", `Protocol ${what} not found (registered versions: ${versions.join(", ") || "none"})`, { versions });
+    }
+    return { ok: true, protocol: found, servers: this.serversOf(found.name, found.version).length };
+  }
+  /** Route table of the protocol registry in `PROTOCOL_ROUTES` order. */
+  protocolRoutes() {
+    return {
+      "/set-protocol": (b) => this.setProtocol(b),
+      "/unset-protocol": (b) => this.unsetProtocol(b),
+      "/get-protocol": (b) => this.getProtocol(b)
+    };
+  }
   // --- relay from a fallback broker ---
   /** Queue a message for `peerId` exactly like `sendMessage` does. */
   enqueue(peerId, m) {
+    const meta = m.meta === void 0 ? null : checkMeta(m.meta);
     this.state.messages.push({
       id: this.state.nextMsgId++,
       from_id: m.from_id,
@@ -308,7 +579,8 @@ class BrokerHandlers {
       mode: m.mode ?? "pull",
       sent_at: m.sent_at,
       delivered: 0,
-      acknowledged: 0
+      acknowledged: 0,
+      ...meta ? { meta } : {}
     });
   }
   /** Give `peer` the relayed messages that were waiting for its name. */
@@ -384,8 +656,64 @@ class BrokerHandlers {
     for (const p of [...this.state.peers.values()]) {
       if (p.origin === origin && !incoming.has(p.id)) this.removePeer(p.id);
     }
+    this.gcProtocols();
     this.state.scheduleSave();
   }
+  /** Definitions declared by this broker's direct, alive peers (what a mesh sync sends). */
+  meshLocalProtocols() {
+    const out = /* @__PURE__ */ new Map();
+    for (const p of this.meshLocalPeers()) {
+      for (const d of p.protocols ?? []) {
+        const key = `${d.name}@${d.version}`;
+        const sp = this.state.protocols.get(key);
+        if (sp && sp.hash === d.hash) out.set(key, sp);
+      }
+    }
+    return [...out.values()];
+  }
+  /**
+   * Take over definitions another broker's direct peers declare. Only a definition that a peer we now hold
+   * declares with the same hash is stored (the rest would be collected at once). A `(name, version)` we already
+   * hold with another hash stays as it is (ours wins) and the received one is dropped with a warning.
+   */
+  meshApplyProtocols(from, protocols) {
+    let added = false;
+    for (const sp of protocols) {
+      const checked = checkDefinition(sp?.name, sp?.version, sp?.definition);
+      if (!checked.ok) {
+        log.warn(`mesh: dropped protocol from ${from}: ${checked.error}`);
+        continue;
+      }
+      const hash = protocolHash(sp.definition.manifest, sp.definition.doc);
+      if (hash !== sp.hash) {
+        log.warn(`mesh: dropped protocol ${sp.name}@${sp.version} from ${from}: hash mismatch`);
+        continue;
+      }
+      const key = `${sp.name}@${sp.version}`;
+      const mine = this.state.protocols.get(key);
+      if (mine) {
+        if (mine.hash !== hash && !this.warnedProtocolConflicts.has(`${key}:${hash}`)) {
+          this.warnedProtocolConflicts.add(`${key}:${hash}`);
+          log.warn(`mesh: protocol ${key} from ${from} differs from the one held here (${hash} vs ${mine.hash}); keeping ours`);
+        }
+        continue;
+      }
+      if (this.state.protocols.size >= PROTOCOL_MAX_STORED) {
+        log.warn(`mesh: dropped protocol ${key} from ${from}: ${PROTOCOL_MAX_STORED} definitions held (limit)`);
+        continue;
+      }
+      if (!this.serversOf(sp.name, sp.version).some((p) => p.protocols?.some((d) => d.name === sp.name && d.version === sp.version && d.hash === hash))) continue;
+      this.state.protocols.set(key, {
+        name: sp.name,
+        version: sp.version,
+        hash,
+        definition: { manifest: sp.definition.manifest, doc: sp.definition.doc, source: sp.definition.source, ref: sp.definition.ref },
+        registered_at: typeof sp.registered_at === "string" ? sp.registered_at : (/* @__PURE__ */ new Date()).toISOString()
+      });
+      added = true;
+    }
+    if (added) this.state.scheduleSave();
+  }
   /** Take over messages forwarded by broker `from`; returns the sender-side ids to drop (duplicates count as taken). */
   meshAccept(from, messages) {
     const accepted = [];
@@ -409,8 +737,10 @@ class BrokerHandlers {
     if (!body.from) throw new Error("mesh sync: missing from");
     if (body.from === this.opts.id) return { id: body.from, peers: [], accepted: [] };
     this.meshApplyPeers(body.from, body.peers ?? []);
+    this.meshApplyProtocols(body.from, body.protocols ?? []);
     const accepted = this.meshAccept(body.from, body.messages ?? []);
-    return { id: this.opts.id ?? "", peers: this.meshLocalPeers(), accepted };
+    const protocols = this.meshLocalProtocols();
+    return { id: this.opts.id ?? "", peers: this.meshLocalPeers(), accepted, ...protocols.length ? { protocols } : {} };
   }
   /** Route table in `BROKER_POST_ROUTES` order. */
   routes() {
@@ -451,6 +781,15 @@ class Mesh {
     if (this.timer) clearInterval(this.timer);
     this.timer = null;
   }
+  /** True while the last sync with `url` succeeded. */
+  linkUp(url) {
+    return this.links.get(url) === "up";
+  }
+  /** Forget everything learned about `url` (its broker left or moved). */
+  forget(url) {
+    this.links.delete(url);
+    this.origins.delete(url);
+  }
   /** Sync soon (coalesced). */
   kick() {
     if (this.running) this.again = true;
@@ -485,10 +824,12 @@ class Mesh {
     if (this.links.get(url) === "self" || this.stopped) return;
     const { handlers, id } = this.opts;
     const origin = this.origins.get(url);
+    const protocols = handlers.meshLocalProtocols();
     const req = {
       from: id,
       peers: handlers.meshLocalPeers(),
-      messages: origin ? handlers.meshOutbox(origin) : []
+      messages: origin ? handlers.meshOutbox(origin) : [],
+      ...protocols.length ? { protocols } : {}
     };
     let res;
     try {
@@ -506,29 +847,12 @@ class Mesh {
     const learned = this.origins.get(url) !== res.id;
     this.origins.set(url, res.id);
     handlers.meshApplyPeers(res.id, res.peers ?? []);
+    handlers.meshApplyProtocols(res.id, res.protocols ?? []);
     handlers.meshDrop(res.accepted ?? []);
     if (learned && handlers.meshOutbox(res.id).length) this.again = true;
     this.setLink(url, "up");
   }
 }
-function readMeshBrokers(configFile) {
-  try {
-    const parsed = JSON.parse(readFileSync(configFile, "utf8"));
-    const list = Array.isArray(parsed.brokers) ? parsed.brokers : parsed.broker ? [parsed.broker] : [];
-    const out = [];
-    for (const s of list) {
-      if (typeof s !== "string" || !s.trim()) continue;
-      try {
-        out.push(normalizeBrokerUrl(s));
-      } catch {
-        log.warn(`mesh: ignoring unparsable broker entry "${s}"`);
-      }
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
 function normalizeBrokerUrl(s) {
   s = s.trim();
   if (!/^https?:\/\//.test(s)) s = `http://${s}`;
@@ -550,8 +874,84 @@ function postJson(url, headers, body, timeoutMs) {
   });
 }
 
+function meshExpireMs(announceMs) {
+  return announceMs * 3 + 5e3;
+}
+class MeshPeerTable {
+  constructor(opts) {
+    this.opts = opts;
+    this.now = opts.now ?? Date.now;
+  }
+  byId = /* @__PURE__ */ new Map();
+  mismatchLogged = /* @__PURE__ */ new Set();
+  now;
+  /** Current sync targets. */
+  urls() {
+    return [...this.byId.values()].map((e) => e.url);
+  }
+  entries() {
+    return [...this.byId.values()];
+  }
+  /** `announce` packet from `address` (UDP source). Returns true when accepted. */
+  handleAnnounce(m, address) {
+    if (m[DISCOVERY_KEY] !== DISCOVERY_ANNOUNCE_VALUE || m.mesh !== true) return false;
+    const ts = m.ts;
+    if (typeof ts !== "number" || !Number.isFinite(ts) || Math.abs(this.now() - ts) > MESH_ANNOUNCE_MAX_SKEW_MS) return false;
+    return this.accept(m, address, String(ts));
+  }
+  /** `broker` reply to our probe that carried `nonce`. Returns true when accepted. */
+  handleReply(m, address, nonce) {
+    if (m[DISCOVERY_KEY] !== DISCOVERY_REPLY_VALUE || m.mesh !== true) return false;
+    return this.accept(m, address, nonce);
+  }
+  accept(m, address, nonce) {
+    const { id, port, version, mac } = m;
+    if (typeof id !== "string" || !id || typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535) return false;
+    if (typeof mac !== "string") return false;
+    if (!meshMacEqual(meshMac(this.opts.token, nonce, id, port), mac)) {
+      const key = `${id}@${address}`;
+      if (!this.mismatchLogged.has(key)) {
+        this.mismatchLogged.add(key);
+        log.warn(`mesh: ignoring ${id}@${address} (token mismatch)`);
+      }
+      return false;
+    }
+    if (id === this.opts.selfId) return false;
+    const url = `http://${address}:${port}`;
+    const prev = this.byId.get(id);
+    const entry = { id, url, version: typeof version === "string" ? version : "", lastSeen: this.now() };
+    this.byId.set(id, entry);
+    if (!prev) {
+      log.info(`mesh: found ${id} at ${url}`);
+      this.opts.onJoin?.(entry);
+    } else if (prev.url !== url) {
+      log.info(`mesh: ${id} moved ${prev.url} -> ${url}`);
+      this.opts.onDrop?.(prev.url);
+      this.opts.onJoin?.(entry);
+    }
+    return true;
+  }
+  /**
+   * Drop entries not vouched for within `expireMs` whose last sync did not succeed (`linkUp`): a link that
+   * still syncs stays even when UDP is lost. Returns the removed entries.
+   */
+  sweep(linkUp) {
+    const gone = [];
+    const t = this.now();
+    for (const e of this.byId.values()) {
+      if (t - e.lastSeen <= this.opts.expireMs || linkUp(e.url)) continue;
+      this.byId.delete(e.id);
+      gone.push(e);
+      log.info(`mesh: ${e.url} left`);
+      this.opts.onDrop?.(e.url);
+    }
+    return gone;
+  }
+}
+
 function createBrokerApp(opts) {
   const routes = opts.handlers.routes();
+  const protocolRoutes = opts.handlers.protocolRoutes();
   const router = createRouter();
   router.get(HEALTH_ROUTE, defineEventHandler(() => ({
     status: "ok",
@@ -559,7 +959,8 @@ function createBrokerApp(opts) {
     id: opts.id,
     port: opts.port(),
     peers: opts.handlers.alivePeerCount(),
-    ...opts.fallback ? { fallback: true } : {}
+    ...opts.fallback ? { fallback: true } : {},
+    ...opts.mesh ? { mesh: true } : {}
   })));
   const post = (route, run) => router.post(route, defineEventHandler(async (event) => {
     if (!authorized(event, opts.token)) return unauthorized(event);
@@ -572,6 +973,7 @@ function createBrokerApp(opts) {
   }));
   for (const route of BROKER_POST_ROUTES) post(route, (body) => routes[route](body));
   post(RELAY_ROUTE, (body) => opts.handlers.relayMessages(body));
+  for (const route of PROTOCOL_ROUTES) post(route, (body) => protocolRoutes[route](body));
   if (opts.mesh) post(MESH_SYNC_ROUTE, (body) => opts.handlers.meshSync(body));
   const app = createApp();
   app.use(router);
@@ -602,12 +1004,16 @@ function startDiscoveryResponder(opts) {
   const disco = createSocket({ type: "udp4", reuseAddr: true });
   disco.on("error", (e) => log.warn(`discovery responder error: ${e.message}`));
   disco.on("message", (msg, rinfo) => {
+    let m;
     try {
-      if (JSON.parse(msg.toString())[DISCOVERY_KEY] !== DISCOVERY_PROBE_VALUE) return;
+      m = JSON.parse(msg.toString());
     } catch {
       return;
     }
-    const reply = Buffer.from(JSON.stringify(opts.reply()));
+    if (m[DISCOVERY_KEY] === DISCOVERY_ANNOUNCE_VALUE) return opts.onAnnounce?.(m, rinfo);
+    if (m[DISCOVERY_KEY] !== DISCOVERY_PROBE_VALUE) return;
+    const nonce = typeof m.n === "string" && m.n.length > 0 && m.n.length <= 128 ? m.n : void 0;
+    const reply = Buffer.from(JSON.stringify(opts.reply(nonce)));
     disco.send(reply, rinfo.port, rinfo.address, () => {
     });
   });
@@ -624,6 +1030,48 @@ function startDiscoveryResponder(opts) {
     });
   });
 }
+function parseDiscoveryTargets(list) {
+  const out = [];
+  for (const s of list) {
+    const i = s.lastIndexOf(":");
+    const port = Number(s.slice(i + 1));
+    if (i <= 0 || !Number.isInteger(port) || port < 1 || port > 65535) {
+      log.warn(`discovery: ignoring invalid target "${s}" (want host:port)`);
+      continue;
+    }
+    out.push({ host: s.slice(0, i), port });
+  }
+  return out;
+}
+function sendTargets(opts) {
+  const explicit = parseDiscoveryTargets(opts.targets ?? []);
+  if (explicit.length) return explicit;
+  return probeTargets(opts.addr).map((host) => ({ host, port: opts.port }));
+}
+function buildAnnounce(a) {
+  return {
+    [DISCOVERY_KEY]: DISCOVERY_ANNOUNCE_VALUE,
+    id: a.id,
+    port: a.port,
+    version: a.version,
+    mesh: true,
+    ts: a.ts,
+    mac: meshMac(a.token, String(a.ts), a.id, a.port)
+  };
+}
+function sendAnnounce(sock, packet, targets) {
+  const buf = Buffer.from(JSON.stringify(packet));
+  for (const t of targets) {
+    try {
+      sock.send(buf, t.port, t.host, () => {
+      });
+    } catch {
+    }
+  }
+}
+function newNonce() {
+  return randomBytes(16).toString("hex");
+}
 function probeTargets(addr) {
   if (addr) return [addr];
   const targets = /* @__PURE__ */ new Set(["255.255.255.255"]);
@@ -667,7 +1115,16 @@ function probeBrokers(opts) {
         if (m[DISCOVERY_KEY] !== DISCOVERY_REPLY_VALUE || !m.port) return;
         const url = `http://${rinfo.address}:${m.port}`;
         if (!found.has(url)) {
-          found.set(url, { url, host: rinfo.address, port: m.port, id: m.id ?? rinfo.address, version: m.version ?? "", fallback: m.fallback === true });
+          found.set(url, {
+            url,
+            host: rinfo.address,
+            port: m.port,
+            id: m.id ?? rinfo.address,
+            version: m.version ?? "",
+            fallback: m.fallback === true,
+            mesh: m.mesh === true,
+            ...typeof m.mac === "string" ? { mac: m.mac } : {}
+          });
         }
       } catch {
       }
@@ -677,8 +1134,8 @@ function probeBrokers(opts) {
         sock.setBroadcast(true);
       } catch {
       }
-      const probe = Buffer.from(JSON.stringify({ [DISCOVERY_KEY]: DISCOVERY_PROBE_VALUE }));
-      for (const t of probeTargets(opts.addr)) sock.send(probe, opts.port, t, () => {
+      const probe = Buffer.from(JSON.stringify({ [DISCOVERY_KEY]: DISCOVERY_PROBE_VALUE, ...opts.nonce ? { n: opts.nonce } : {} }));
+      for (const t of sendTargets(opts)) sock.send(probe, t.port, t.host, () => {
       });
     });
   });
@@ -707,7 +1164,8 @@ async function relayUndelivered(state, url, token) {
       to_hostname: peer.hostname,
       text: m.text,
       mode: m.mode ?? "pull",
-      sent_at: m.sent_at
+      sent_at: m.sent_at,
+      ...m.meta ? { meta: m.meta } : {}
     });
   }
   let sent = 0;
@@ -719,7 +1177,7 @@ async function relayUndelivered(state, url, token) {
       dropped += r.dropped;
     } else if (res.status === 404) {
       for (const it of items) {
-        const r = await post(url, "/send-message", token, { to: it.to_name, from_id: it.from_id, from_name: it.from_name, text: it.text, mode: it.mode });
+        const r = await post(url, "/send-message", token, { to: it.to_name, from_id: it.from_id, from_name: it.from_name, text: it.text, mode: it.mode, meta: it.meta });
         if (r.ok && (await r.json()).ok) sent++;
         else dropped++;
       }
@@ -733,7 +1191,7 @@ async function relayUndelivered(state, url, token) {
   return { sent, dropped };
 }
 
-const version = "0.9.0";
+const version = "0.11.0";
 const pkg = {
 	version: version};
 
@@ -779,21 +1237,61 @@ async function startBroker(options = {}) {
     throw e;
   }
   port = listener.address.port;
-  const reply = () => ({ [DISCOVERY_KEY]: DISCOVERY_REPLY_VALUE, id: cfg.id, port, version: VERSION, ...cfg.fallback ? { fallback: true } : {} });
+  const reply = (nonce) => ({
+    [DISCOVERY_KEY]: DISCOVERY_REPLY_VALUE,
+    id: cfg.id,
+    port,
+    version: VERSION,
+    ...cfg.fallback ? { fallback: true } : {},
+    ...cfg.mesh ? { mesh: true, ...nonce ? { mac: meshMac(cfg.token, nonce, cfg.id, port) } : {} } : {}
+  });
+  const fixed = cfg.meshBrokers.map(normalizeBrokerUrl);
+  const peerTable = cfg.mesh ? new MeshPeerTable({
+    selfId: cfg.id,
+    token: cfg.token,
+    expireMs: meshExpireMs(cfg.meshAnnounceMs),
+    onDrop: (url) => mesh?.forget(url),
+    onJoin: () => mesh?.kick()
+  }) : null;
   let disco = null;
   if (cfg.discovery) {
-    disco = await startDiscoveryResponder({ port: cfg.discoveryPort, addr: cfg.discoveryAddr, reply });
+    disco = await startDiscoveryResponder({
+      port: cfg.discoveryPort,
+      addr: cfg.discoveryAddr,
+      reply,
+      ...peerTable ? { onAnnounce: (m, rinfo) => void peerTable.handleAnnounce(m, rinfo.address) } : {}
+    });
   }
+  let announceTimer = null;
   if (cfg.mesh) {
-    const fixed = cfg.meshBrokers.map(normalizeBrokerUrl);
     mesh = new Mesh({
       id: cfg.id,
       token: cfg.token,
       handlers,
-      urls: () => fixed.length ? fixed : readMeshBrokers(cfg.configFile),
+      urls: () => fixed.length ? fixed : peerTable.urls(),
       intervalMs: cfg.meshIntervalMs
     });
     mesh.start();
+    if (!cfg.discovery && !fixed.length) {
+      log.warn("mesh: AGENT_MESSENGER_MESH=on but AGENT_MESSENGER_DISCOVERY=off; no other mesh broker can be found");
+    }
+    if (cfg.discovery && disco && !fixed.length) {
+      const sock = disco;
+      const targets = sendTargets({ port: cfg.discoveryPort, addr: cfg.discoveryAddr, targets: cfg.discoveryTargets });
+      const announceAndSweep = () => {
+        sendAnnounce(sock, buildAnnounce({ token: cfg.token, id: cfg.id, port, version: VERSION, ts: Date.now() }), targets);
+        peerTable.sweep((url) => mesh?.linkUp(url) ?? false);
+      };
+      announceAndSweep();
+      announceTimer = setInterval(announceAndSweep, cfg.meshAnnounceMs);
+      announceTimer.unref();
+      const nonce = newNonce();
+      void probeBrokers({ port: cfg.discoveryPort, addr: cfg.discoveryAddr, targets: cfg.discoveryTargets, nonce, timeoutMs: 1e3 }).then((found) => {
+        for (const b of found) {
+          peerTable.handleReply({ [DISCOVERY_KEY]: DISCOVERY_REPLY_VALUE, id: b.id, port: b.port, version: b.version, mesh: b.mesh, mac: b.mac }, b.host, nonce);
+        }
+      });
+    }
   }
   log.info(`v${VERSION} id=${cfg.id} listening on ${cfg.bind}:${port} (state: ${cfg.stateFile})`);
   if (cfg.fallback) log.info(`FALLBACK mode: looking for another broker every ${cfg.fallbackIntervalMs} ms (discovery ${cfg.discovery ? "on" : "off"})`);
@@ -805,6 +1303,7 @@ async function startBroker(options = {}) {
     closed = true;
     clearInterval(cleaner);
     if (fallbackTimer) clearInterval(fallbackTimer);
+    if (announceTimer) clearInterval(announceTimer);
     mesh?.stop();
     if (disco) {
       await new Promise((resolve) => disco.close(() => resolve()));
@@ -819,7 +1318,7 @@ async function startBroker(options = {}) {
       if (busy || closed) return;
       busy = true;
       try {
-        const found = await probeBrokers({ port: cfg.discoveryPort, addr: cfg.discoveryAddr, timeoutMs: 1e3 });
+        const found = await probeBrokers({ port: cfg.discoveryPort, addr: cfg.discoveryAddr, targets: cfg.discoveryTargets, timeoutMs: 1e3 });
         const other = found.find((b) => !b.fallback && !(b.port === port && mine.has(b.host)));
         if (!other || closed) return;
         log.info(`fallback: found broker ${other.id} at ${other.url} \u2014 relaying messages and exiting`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unagents/messenger-broker",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "agent-messenger broker: HTTP daemon that tracks peers and routes messages between Claude Code sessions.",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@unagents/messenger-protocol": "0.9.0",
+    "@unagents/messenger-protocol": "0.11.0",
     "consola": "^3.4.2",
     "defu": "^6.1.7",
     "h3": "^1.15.11",