tesseract-agent 0.11.0 → 0.11.2

package/dist-bundle/cli.js

@@ -79502,7 +79502,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join68(separator = "") {
+function join67(separator = "") {
   astr("join", separator);
   return {
     encode: (from) => {
@@ -79707,7 +79707,7 @@ var init_esm = __esm({
       convertRadix2,
       radix,
       radix2,
-      join: join68,
+      join: join67,
       padding
     };
   }
@@ -81254,7 +81254,7 @@ var mesh_ca_exports = {};
 __export(mesh_ca_exports, {
   netCaCommand: () => netCaCommand
 });
-import { chmodSync as chmodSync8, existsSync as existsSync48, mkdirSync as mkdirSync45, readFileSync as readFileSync53, writeFileSync as writeFileSync46 } from "node:fs";
+import { chmodSync as chmodSync8, existsSync as existsSync49, mkdirSync as mkdirSync45, readFileSync as readFileSync54, writeFileSync as writeFileSync46 } from "node:fs";
 import { join as join87, resolve as resolve13 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 function die(msg) {
@@ -81302,12 +81302,12 @@ function ensureDir(p) {
 async function openCa(dir2) {
   const gPath = join87(dir2, "genesis.bin");
   const sPath = join87(dir2, "ca.sealed");
-  if (!existsSync48(gPath) || !existsSync48(sPath)) {
+  if (!existsSync49(gPath) || !existsSync49(sPath)) {
     die(`No mesh CA in ${dir2}. Run: tesseract-agent net init --org NAME --ca-dir ${dir2}`);
   }
-  const genesisBytes = new Uint8Array(readFileSync53(gPath));
+  const genesisBytes = new Uint8Array(readFileSync54(gPath));
   const genesis = decodeGenesis(genesisBytes);
-  const sealed = decodeRecoveryBundle(new Uint8Array(readFileSync53(sPath)));
+  const sealed = decodeRecoveryBundle(new Uint8Array(readFileSync54(sPath)));
   const pass = await readPassphrase("CA passphrase: ");
   let seed;
   try {
@@ -81323,7 +81323,7 @@ async function netCaCommand(rest, flags) {
   if (sub === "init") {
     const org = typeof flags.org === "string" ? flags.org.trim() : "";
     if (!org) die("Usage: tesseract-agent net init --org NAME [--ca-dir DIR]");
-    if (existsSync48(join87(caDir, "ca.sealed"))) {
+    if (existsSync49(join87(caDir, "ca.sealed"))) {
       die(`A mesh CA already exists in ${caDir}. Refusing to overwrite it.`);
     }
     const pass = await readPassphrase("New CA passphrase: ");
@@ -81481,7 +81481,7 @@ var init_mesh_ca = __esm({
 
 // src/cli.ts
 init_base_paths();
-import { existsSync as existsSync49, mkdtempSync as mkdtempSync4, readFileSync as readFileSync55, rmSync as rmSync13 } from "node:fs";
+import { existsSync as existsSync50, mkdtempSync as mkdtempSync4, readFileSync as readFileSync56, rmSync as rmSync13 } from "node:fs";
 import { createHash as createHash9 } from "node:crypto";
 import { execFileSync as execFileSync6, spawn as spawn14 } from "node:child_process";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
@@ -109557,7 +109557,7 @@ async function startLocalServer(opts) {
 
 // ../../packages/host-core/dist/daemon-runtime.js
 init_base_paths();
-import { readFileSync as readFileSync49, writeFileSync as writeFileSync40, existsSync as existsSync38, mkdirSync as mkdirSync41, unlinkSync as unlinkSync6, chmodSync as chmodSync7, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync49, writeFileSync as writeFileSync40, existsSync as existsSync39, mkdirSync as mkdirSync41, unlinkSync as unlinkSync6, chmodSync as chmodSync7, statSync as statSync14 } from "node:fs";
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { join as join77 } from "node:path";
 import { randomBytes as randomBytes10 } from "node:crypto";
@@ -109819,16 +109819,455 @@ async function getPeerIdentityPub(opts) {
 // ../../packages/host-core/dist/mesh/node.js
 import { createSocket as createSocket2 } from "node:dgram";
 import { createRequire as createRequire4 } from "node:module";
+init_credentials();
+
+// ../../packages/host-core/dist/mesh/bundle-gossip.js
+var BundleOfferLedger = class {
+  #offered = /* @__PURE__ */ new Set();
+  /**
+   * Should we offer epoch `mine` to this peer, and record that we did?
+   *
+   * Returns false when we are not ahead (including equal — an offer would tell them
+   * nothing), and false for a peer already offered THIS epoch. Keyed by epoch as well as
+   * peer, so a newer bundle is offered afresh to someone we have already talked to.
+   */
+  claim(peerHex, peerEpoch, mine) {
+    if (!(mine > peerEpoch))
+      return false;
+    const key2 = `${peerHex}:${mine}`;
+    if (this.#offered.has(key2))
+      return false;
+    this.#offered.add(key2);
+    return true;
+  }
+  /**
+   * Forget everything, because we just adopted a newer bundle and are now the node that is
+   * ahead. Without this the ledger would still be keyed to the epoch we no longer hold —
+   * harmless for correctness (the key carries the epoch) but it would grow without bound on
+   * a long-lived node, one entry per peer per epoch forever.
+   */
+  reset() {
+    this.#offered.clear();
+  }
+};
+
+// ../../packages/host-core/dist/mesh/netd-engine.js
+init_dist6();
+
+// ../../packages/host-core/dist/mesh/netd-client.js
+import { connect as connect2 } from "node:net";
+import { platform as platform3 } from "node:process";
+var NETD_WIRE_VERSION = 2;
+var MAX_LINE = 1024 * 1024;
+var TIMEOUT_MS3 = 15e3;
+function netdEndpoint() {
+  if (platform3 === "win32")
+    return "\\\\.\\pipe\\tesseract-netd";
+  if (platform3 === "darwin")
+    return "/var/run/tesseract-netd.sock";
+  return "/run/tesseract-netd.sock";
+}
+function endpointOverride() {
+  return process.env.CCB_NETD_SOCKET ?? null;
+}
+function fail2(code, detail) {
+  return { ok: false, code, detail };
+}
+async function call(line) {
+  const endpoint2 = endpointOverride() ?? netdEndpoint();
+  return new Promise((resolve16) => {
+    let settled = false;
+    const done = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        sock.destroy();
+      } catch {
+      }
+      resolve16(r);
+    };
+    let sock;
+    try {
+      sock = connect2(endpoint2);
+    } catch (e) {
+      return resolve16(fail2("not-installed", e instanceof Error ? e.message : String(e)));
+    }
+    const timer2 = setTimeout(() => {
+      done(fail2("timeout", `no answer from the network helper in ${TIMEOUT_MS3}ms`));
+    }, TIMEOUT_MS3);
+    timer2.unref?.();
+    sock.setTimeout(TIMEOUT_MS3);
+    sock.on("timeout", () => {
+      clearTimeout(timer2);
+      done(fail2("timeout", "socket idle"));
+    });
+    sock.on("error", (e) => {
+      clearTimeout(timer2);
+      const absent = e.code === "ENOENT" || e.code === "ECONNREFUSED";
+      done(fail2(absent ? "not-installed" : "io", e.message));
+    });
+    let buf = "";
+    sock.on("data", (chunk) => {
+      buf += chunk.toString("utf8");
+      if (buf.length > MAX_LINE) {
+        clearTimeout(timer2);
+        done(fail2("protocol", "the helper sent an oversized line"));
+        return;
+      }
+      const nl = buf.indexOf("\n");
+      if (nl === -1)
+        return;
+      clearTimeout(timer2);
+      done({ ok: true, line: buf.slice(0, nl) });
+    });
+    sock.on("close", () => {
+      clearTimeout(timer2);
+      done(fail2("protocol", "the helper closed the connection without answering"));
+    });
+    sock.on("connect", () => {
+      sock.write(`${line}
+`);
+    });
+  });
+}
+function parse3(line) {
+  let body;
+  try {
+    body = JSON.parse(line);
+  } catch {
+    return fail2("protocol", "the helper sent something that is not JSON");
+  }
+  if (typeof body !== "object" || body === null) {
+    return fail2("protocol", "the helper sent something that is not an object");
+  }
+  const o = body;
+  if (o.ok === false) {
+    const code = typeof o.code === "string" ? o.code : "refused";
+    const detail = typeof o.detail === "string" ? o.detail : "the helper refused";
+    return fail2(code, detail);
+  }
+  if (o.ok !== true)
+    return fail2("protocol", "the helper did not say whether it succeeded");
+  return { ok: true, body: o };
+}
+async function request(line) {
+  const r = await call(line);
+  return r.ok ? parse3(r.line) : r;
+}
+function hex4(b) {
+  return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+}
+async function netdHello() {
+  const r = await request(JSON.stringify({ op: "hello", wireVersion: NETD_WIRE_VERSION }));
+  if (!r.ok)
+    return r;
+  const v = r.body.wireVersion;
+  if (typeof v !== "number")
+    return fail2("protocol", "the helper did not report a wire version");
+  if (v !== NETD_WIRE_VERSION) {
+    return fail2("wire-version", `the helper speaks ${v}, this build speaks ${NETD_WIRE_VERSION}`);
+  }
+  return { ok: true, wireVersion: v };
+}
+async function netdStatus() {
+  const r = await request(JSON.stringify({ op: "status" }));
+  if (!r.ok)
+    return r;
+  const meshes = Array.isArray(r.body.meshes) ? r.body.meshes.filter((m) => typeof m === "string") : [];
+  const iface = typeof r.body.interface === "string" ? r.body.interface : null;
+  return { ok: true, meshes, interface: iface };
+}
+async function netdUp(args) {
+  const r = await request(JSON.stringify({
+    op: "up",
+    meshId: args.meshId,
+    genesis: hex4(args.genesis),
+    cert: hex4(args.cert),
+    fullTunnel: args.fullTunnel === true,
+    ...args.staticPrivate ? { staticPrivate: hex4(args.staticPrivate) } : {},
+    ...args.bundle ? { bundle: hex4(args.bundle) } : {}
+  }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdHint(args) {
+  const r = await request(JSON.stringify({
+    op: "hint",
+    meshId: args.meshId,
+    staticPub: hex4(args.staticPub),
+    endpoints: args.endpoints,
+    relayed: args.relayed === true
+  }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdBundle(meshId, bundle) {
+  const r = await request(JSON.stringify({ op: "bundle", meshId, bundle: hex4(bundle) }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdSetExitNode(meshId, staticPub) {
+  const r = await request(JSON.stringify({
+    op: "setExitNode",
+    meshId,
+    staticPub: staticPub ? hex4(staticPub) : null
+  }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdNodeStatus(meshId) {
+  const r = await request(JSON.stringify({ op: "nodeStatus", meshId }));
+  if (!r.ok)
+    return r;
+  const b = r.body;
+  const num2 = (k) => typeof b[k] === "number" ? b[k] : 0;
+  const strs = (k) => Array.isArray(b[k]) ? b[k].filter((x) => typeof x === "string") : [];
+  if (b.node !== true)
+    return fail2("protocol", "the helper did not answer with a node status");
+  const pubHex = typeof b.localStaticPub === "string" ? b.localStaticPub : "";
+  return {
+    ok: true,
+    node: {
+      running: b.running === true,
+      port: num2("port"),
+      peers: num2("peers"),
+      established: strs("established"),
+      relayed: strs("relayed"),
+      policyEpoch: num2("policyEpoch"),
+      revoked: b.revoked === true,
+      lastError: typeof b.lastError === "string" ? b.lastError : null,
+      localStaticPub: Uint8Array.from(Buffer.from(pubHex, "hex")),
+      meter: {
+        txDirectBytes: num2("txDirectBytes"),
+        txDirectPackets: num2("txDirectPackets"),
+        txRelayedBytes: num2("txRelayedBytes"),
+        txRelayedPackets: num2("txRelayedPackets"),
+        rxDirectBytes: num2("rxDirectBytes"),
+        rxDirectPackets: num2("rxDirectPackets"),
+        rxRelayedBytes: num2("rxRelayedBytes"),
+        rxRelayedPackets: num2("rxRelayedPackets"),
+        forwardedBytes: num2("forwardedBytes"),
+        forwardedPackets: num2("forwardedPackets")
+      }
+    }
+  };
+}
+async function netdDown(meshId) {
+  const r = await request(JSON.stringify({ op: "down", meshId }));
+  return r.ok ? { ok: true } : r;
+}
+async function netdAvailable() {
+  return (await netdHello()).ok;
+}
+
+// ../../packages/host-core/dist/mesh/netd-engine.js
+var NETD_POLL_MS = 1e3;
+var NetdEngine = class {
+  #meshDir;
+  #meshId;
+  #localStaticPub;
+  #hooks;
+  #snapshot = null;
+  #pendingEndpoints = /* @__PURE__ */ new Map();
+  #events = [];
+  #seenEstablished = /* @__PURE__ */ new Set();
+  #seenRelayed = /* @__PURE__ */ new Set();
+  #timer = null;
+  #announced = false;
+  #lastError = null;
+  #stopped = false;
+  constructor(meshDir2, cert, hooks2) {
+    this.#meshDir = meshDir2;
+    this.#hooks = hooks2;
+    const d = decodeCert(cert).details;
+    this.#meshId = hex3(d.genesisFp);
+    this.#localStaticPub = Buffer.from(d.staticPub);
+    this.#timer = setInterval(() => void this.#poll(), NETD_POLL_MS);
+    this.#timer.unref?.();
+    void this.#poll();
+  }
+  /** Read netd's view now rather than waiting for the timer. Exposed for tests and for
+   *  the moment right after `up` so status does not lag a full interval. */
+  async refresh() {
+    await this.#poll();
+  }
+  async #poll() {
+    if (this.#stopped)
+      return;
+    const r = await netdNodeStatus(this.#meshDir);
+    if (!r.ok) {
+      if (r.code !== "not-running" && r.code !== "not-installed") {
+        this.#lastError = `netd: ${r.detail}`;
+      }
+      return;
+    }
+    const s = r.node;
+    const prev = this.#snapshot;
+    this.#snapshot = s;
+    if (s.lastError)
+      this.#lastError = s.lastError;
+    for (const k of s.established) {
+      if (!this.#seenEstablished.has(k)) {
+        this.#seenEstablished.add(k);
+        this.#events.push({ kind: "peerEstablished", staticPub: Buffer.from(k, "hex") });
+      }
+    }
+    const relayedNow = new Set(s.relayed);
+    for (const k of relayedNow) {
+      if (!this.#seenRelayed.has(k)) {
+        this.#seenRelayed.add(k);
+        this.#events.push({ kind: "pathChanged", staticPub: Buffer.from(k, "hex"), detail: "relay" });
+      }
+    }
+    for (const k of [...this.#seenRelayed]) {
+      if (!relayedNow.has(k)) {
+        this.#seenRelayed.delete(k);
+        this.#events.push({ kind: "pathChanged", staticPub: Buffer.from(k, "hex"), detail: "direct" });
+      }
+    }
+    if (s.running && s.port > 0 && !this.#announced) {
+      this.#announced = true;
+      this.#hooks.log?.(`mesh: node running in the network helper on UDP port ${s.port}`);
+      this.#hooks.onUp(s.port);
+    }
+    void prev;
+  }
+  // ── MeshEngineNative ────────────────────────────────────────────────────────────
+  setBundle(b, _nowMs) {
+    void netdBundle(this.#meshDir, b).then((r) => {
+      if (!r.ok)
+        this.#lastError = `bundle: ${r.detail}`;
+    });
+  }
+  addPeer(staticPub, _overlayV4, _overlayV6) {
+    const k = staticPub.toString("hex");
+    if (!this.#pendingEndpoints.has(k))
+      this.#pendingEndpoints.set(k, { endpoints: [], relayed: false });
+  }
+  addPath(staticPub, endpoint2, relayed) {
+    const k = staticPub.toString("hex");
+    const p = this.#pendingEndpoints.get(k) ?? { endpoints: [], relayed: false };
+    if (!p.endpoints.includes(endpoint2))
+      p.endpoints.push(endpoint2);
+    p.relayed = p.relayed || relayed;
+    this.#pendingEndpoints.set(k, p);
+  }
+  startHandshake(staticPub, _nowMs) {
+    const k = staticPub.toString("hex");
+    const p = this.#pendingEndpoints.get(k) ?? { endpoints: [], relayed: false };
+    this.#pendingEndpoints.delete(k);
+    void netdHint({ meshId: this.#meshDir, staticPub, endpoints: p.endpoints, relayed: p.relayed }).then((r) => {
+      if (!r.ok)
+        this.#lastError = `hint: ${r.detail}`;
+    });
+  }
+  /** No UDP here — netd owns the socket. Never called in practice; kept for the interface. */
+  injectUdp(_pkt, _from, _nowMs) {
+  }
+  tick(_nowMs) {
+  }
+  pollSend() {
+    return null;
+  }
+  pollEvent() {
+    return this.#events.shift() ?? null;
+  }
+  meter() {
+    const m = this.#snapshot?.meter;
+    const tx = (m?.txDirectBytes ?? 0) + (m?.txRelayedBytes ?? 0);
+    return {
+      txDirectBytes: m?.txDirectBytes ?? 0,
+      txRelayedBytes: m?.txRelayedBytes ?? 0,
+      rxDirectBytes: m?.rxDirectBytes ?? 0,
+      rxRelayedBytes: m?.rxRelayedBytes ?? 0,
+      forwardedBytes: m?.forwardedBytes ?? 0,
+      forwardedPackets: m?.forwardedPackets ?? 0,
+      relayedTxFraction: tx === 0 ? 0 : (m?.txRelayedBytes ?? 0) / tx
+    };
+  }
+  localStaticPub() {
+    return this.#localStaticPub;
+  }
+  meshId() {
+    return this.#meshId;
+  }
+  policyEpoch() {
+    return this.#snapshot?.policyEpoch ?? 0;
+  }
+  selfRevoked() {
+    return this.#snapshot?.revoked === true;
+  }
+  peerCount() {
+    return this.#snapshot?.peers ?? 0;
+  }
+  setExitNode(staticPub) {
+    void netdSetExitNode(this.#meshDir, staticPub).then((r) => {
+      if (!r.ok)
+        this.#lastError = `exit node: ${r.detail}`;
+    });
+  }
+  /** Is netd running the node right now, and on which port? */
+  get running() {
+    return this.#snapshot?.running === true;
+  }
+  get port() {
+    return this.#snapshot && this.#snapshot.port > 0 ? this.#snapshot.port : null;
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = null;
+    }
+  }
+};
+
+// ../../packages/host-core/dist/mesh/node.js
+import { existsSync as existsSync34 } from "node:fs";
+
+// ../../packages/host-core/dist/mesh/bundle-refresh.js
+init_dist6();
+var CONTEXT = "tsr-bundle-fetch-v1";
+var REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
+async function fetchBundle(args) {
+  const none = { bundle: null, epoch: null };
+  try {
+    const ts = Date.now();
+    const { privateKey } = await signingKeyFromSeed(args.sigPrivate);
+    const message = new TextEncoder().encode(`${CONTEXT}
+${args.genesisFp.toLowerCase()}
+${args.staticPub.toLowerCase()}
+${ts}`);
+    const sig = await sign2(privateKey, message);
+    const doFetch = args.fetchImpl ?? fetch;
+    const res = await doFetch(`${args.origin.replace(/\/$/, "")}/api/core/tesseract/mesh/meshes/by-genesis/${encodeURIComponent(args.genesisFp.toLowerCase())}/bundle`, {
+      method: "GET",
+      headers: {
+        "x-tsr-node": args.staticPub.toLowerCase(),
+        "x-tsr-ts": String(ts),
+        "x-tsr-sig": Buffer.from(sig).toString("base64")
+      }
+    });
+    if (!res.ok)
+      return none;
+    const body = await res.json();
+    if (!body.bundle)
+      return none;
+    return { bundle: Uint8Array.from(Buffer.from(body.bundle, "hex")), epoch: body.epoch ?? null };
+  } catch {
+    return none;
+  }
+}
 
 // ../../packages/host-core/dist/mesh/config.js
 init_credentials();
 import { chmodSync as chmodSync5, existsSync as existsSync33, mkdirSync as mkdirSync36, readdirSync as readdirSync12, readFileSync as readFileSync47, renameSync as renameSync11, rmSync as rmSync7, writeFileSync as writeFileSync35 } from "node:fs";
-import { dirname as dirname31, join as join67 } from "node:path";
+import { dirname as dirname31, join as join68 } from "node:path";
 function meshDir() {
-  return join67(daemonDir2(), "mesh");
+  return join68(daemonDir2(), "mesh");
 }
 function meshesDir() {
-  return join67(meshDir(), "meshes");
+  return join68(meshDir(), "meshes");
 }
 var MESH_DIR_NAME_BYTES = 8;
 function meshDirName(genesisFp) {
@@ -109846,7 +110285,7 @@ function oneMeshDir(meshId) {
   if (!isMeshId(meshId)) {
     throw new Error(`not a mesh id: ${JSON.stringify(meshId.slice(0, 64))}`);
   }
-  return join67(meshesDir(), meshId);
+  return join68(meshesDir(), meshId);
 }
 var LEGACY_MESH_ID = "legacy";
 var CERT_GENESIS_FP_OFFSET = 19;
@@ -109864,7 +110303,7 @@ var FILES = {
   local: "local.json"
 };
 function readIfPresent(name, dir2 = meshDir()) {
-  const p = join67(dir2, name);
+  const p = join68(dir2, name);
   try {
     return existsSync33(p) ? new Uint8Array(readFileSync47(p)) : void 0;
   } catch {
@@ -109872,7 +110311,7 @@ function readIfPresent(name, dir2 = meshDir()) {
   }
 }
 function migrateSingleMesh() {
-  const legacyGenesis = join67(meshDir(), FILES.genesis);
+  const legacyGenesis = join68(meshDir(), FILES.genesis);
   if (!existsSync33(legacyGenesis))
     return null;
   const id = meshIdFromCert(readIfPresent(FILES.cert)) ?? LEGACY_MESH_ID;
@@ -109881,11 +110320,11 @@ function migrateSingleMesh() {
     mkdirSync36(dest, { recursive: true, mode: 448 });
     chmodSync5(dest, 448);
     for (const f of Object.values(FILES)) {
-      const from = join67(meshDir(), f);
+      const from = join68(meshDir(), f);
       if (existsSync33(from))
-        renameSync11(from, join67(dest, f));
+        renameSync11(from, join68(dest, f));
     }
-    const key2 = join67(dest, FILES.key);
+    const key2 = join68(dest, FILES.key);
     if (existsSync33(key2))
       chmodSync5(key2, 384);
   } catch {
@@ -109909,7 +110348,7 @@ function listMeshIds() {
 }
 function readLocal(meshId) {
   try {
-    return JSON.parse(readFileSync47(join67(oneMeshDir(meshId), FILES.local), "utf8"));
+    return JSON.parse(readFileSync47(join68(oneMeshDir(meshId), FILES.local), "utf8"));
   } catch {
     return null;
   }
@@ -109917,7 +110356,7 @@ function readLocal(meshId) {
 function writeLocal(meshId, state3) {
   try {
     mkdirSync36(oneMeshDir(meshId), { recursive: true, mode: 448 });
-    writeFileSync35(join67(oneMeshDir(meshId), FILES.local), JSON.stringify(state3, null, 2), { mode: 384 });
+    writeFileSync35(join68(oneMeshDir(meshId), FILES.local), JSON.stringify(state3, null, 2), { mode: 384 });
   } catch {
   }
 }
@@ -109950,7 +110389,7 @@ function loadMeshIdentity() {
   return first === void 0 ? null : loadMesh(first);
 }
 function writeSecret(name, bytes2, dir2 = meshDir()) {
-  const p = join67(dir2, name);
+  const p = join68(dir2, name);
   writeFileSync35(p, bytes2, { mode: 384 });
   try {
     chmodSync5(p, 384);
@@ -109968,11 +110407,11 @@ function saveMeshIdentity(id) {
     chmodSync5(meshDir(), 448);
   } catch {
   }
-  writeFileSync35(join67(meshDir(), FILES.genesis), id.genesis);
-  writeFileSync35(join67(meshDir(), FILES.cert), id.cert);
+  writeFileSync35(join68(meshDir(), FILES.genesis), id.genesis);
+  writeFileSync35(join68(meshDir(), FILES.cert), id.cert);
   writeSecret(FILES.key, id.staticPrivate);
   if (id.bundle)
-    writeFileSync35(join67(meshDir(), FILES.bundle), id.bundle);
+    writeFileSync35(join68(meshDir(), FILES.bundle), id.bundle);
 }
 function saveMesh(meshId, id) {
   const dir2 = oneMeshDir(meshId);
@@ -109989,13 +110428,13 @@ function saveMesh(meshId, id) {
     chmodSync5(dir2, 448);
   } catch {
   }
-  writeFileSync35(join67(dir2, FILES.genesis), id.genesis);
-  writeFileSync35(join67(dir2, FILES.cert), id.cert);
+  writeFileSync35(join68(dir2, FILES.genesis), id.genesis);
+  writeFileSync35(join68(dir2, FILES.cert), id.cert);
   writeSecret(FILES.key, id.staticPrivate, dir2);
   if (id.sigPrivate)
     writeSecret(FILES.sigKey, id.sigPrivate, dir2);
   if (id.bundle)
-    writeFileSync35(join67(dir2, FILES.bundle), id.bundle);
+    writeFileSync35(join68(dir2, FILES.bundle), id.bundle);
   if (readLocal(meshId) === null)
     writeLocal(meshId, { joinedAt: Date.now() });
 }
@@ -110005,7 +110444,7 @@ function removeMesh(meshId) {
 var STATUS_REFRESH_MS = 5e3;
 var STATUS_STALE_MS = 2e4;
 function statusPath(meshId) {
-  return meshId === void 0 ? join67(meshDir(), "status.json") : join67(oneMeshDir(meshId), "status.json");
+  return meshId === void 0 ? join68(meshDir(), "status.json") : join68(oneMeshDir(meshId), "status.json");
 }
 function writeStatus(status2, meshId) {
   try {
@@ -110036,7 +110475,7 @@ function cacheBundle(bundle, meshId) {
     const id = meshId ?? listMeshIds()[0];
     const dir2 = id === void 0 ? meshDir() : oneMeshDir(id);
     mkdirSync36(dir2, { recursive: true, mode: 448 });
-    writeFileSync35(join67(dir2, FILES.bundle), bundle);
+    writeFileSync35(join68(dir2, FILES.bundle), bundle);
   } catch {
   }
 }
@@ -110192,6 +110631,9 @@ function loadMeshCore() {
 }
 var meshCore = loadMeshCore();
 function meshEngineStatus() {
+  if (process.env.CCB_MESH_IN_DAEMON !== "1" && existsSync34(netdEndpoint())) {
+    return { available: true, reason: null };
+  }
   return { available: meshCore.available === true, reason: meshCore.loadError ?? null };
 }
 var TICK_MS2 = 1e3;
@@ -110287,8 +110729,16 @@ var MeshNode = class {
   #engine = null;
   #sock = null;
   #timer = null;
+  /** The policy refresh poll. See `bundle-refresh.ts` — this is what makes eviction real. */
+  #refreshTimer = null;
   #unsubscribe = null;
   #identity = null;
+  /** The policy bundle we hold, as bytes, so we can OFFER it to a peer that is behind.
+   *  Kept beside the engine because the engine exposes an epoch but not the bytes. */
+  #bundle = null;
+  /** Who has already been offered which epoch — see `bundle-gossip.ts` for why a ledger
+   *  is needed at all (the relay broadcasts to the whole mesh, not to one peer). */
+  #bundleOffered = new BundleOfferLedger();
   #port = null;
   #lastError = null;
   /**
@@ -110353,8 +110803,11 @@ var MeshNode = class {
   }
   status() {
     return {
-      available: meshCore.available,
-      loadError: meshCore.loadError,
+      // In netd mode the engine is the helper's, and whether THIS process could load a
+      // prebuilt is beside the point — a CLI install whose native fetch failed still has a
+      // working network when the helper runs it, and must not say "engine unavailable".
+      available: this.#engine instanceof NetdEngine ? true : meshCore.available,
+      loadError: this.#engine instanceof NetdEngine ? null : meshCore.loadError,
       enrolled: this.#identity !== null || this.#loadIdentity() !== null,
       running: this.#engine !== null,
       port: this.#port,
@@ -110371,7 +110824,22 @@ var MeshNode = class {
         this.#established.has(hex6) ? this.#relayed.has(hex6) ? "relay" : "direct" : "none"
       ])),
       meter: this.#engine?.meter() ?? null,
-      lastError: this.#lastError,
+      // THE POLICY EPOCH this node is actually running on.
+      //
+      // Read from the ENGINE, never from `bundle.bin`: the engine installs a bundle the
+      // moment it verifies one, and a bundle pulled from a peer over the Noise session
+      // never touches that file. Judging freshness by the file — which is what there was
+      // to judge by — therefore reports a node as stale when it is current, and is how a
+      // machine came to look a dozen epochs behind while carrying the right policy.
+      //
+      // It is the one number that answers "why is nothing passing": a node whose policy
+      // predates a peer has no roster entry for it and drops every packet, correctly, with
+      // nothing anywhere saying so.
+      policyEpoch: this.#engine?.policyEpoch() ?? null,
+      lastError: this.#lastError ?? (this.#engine instanceof NetdEngine ? this.#engine.lastError : null),
+      // In netd mode "running" means netd runs it: an adapter with no node behind it yet
+      // (routes not synced, helper just installed) is not a running node.
+      ...this.#engine instanceof NetdEngine && !this.#engine.running ? { running: false } : {},
       // Surfaced so `net status` can say "removed" rather than "not running". Those look
       // identical from outside and have completely different remedies.
       removed: this.#revoked
@@ -110393,7 +110861,8 @@ var MeshNode = class {
         reason: "this machine was removed from the network \u2014 ask an admin for a new invitation"
       };
     }
-    if (!meshCore.available) {
+    const inNetd = process.env.CCB_MESH_IN_DAEMON !== "1" && existsSync34(netdEndpoint());
+    if (!inNetd && !meshCore.available) {
       return { ok: false, reason: `mesh engine unavailable: ${meshCore.loadError ?? "no prebuilt"}` };
     }
     const id = this.#loadIdentity();
@@ -110403,18 +110872,46 @@ var MeshNode = class {
         reason: this.#wantMeshId === null ? "this machine is not enrolled in a mesh" : `this machine is not enrolled in mesh ${this.#wantMeshId}`
       };
     }
-    try {
-      this.#engine = new meshCore.MeshEngine(Buffer.from(id.genesis), Buffer.from(id.staticPrivate), Buffer.from(id.cert), 0, Buffer.alloc(16));
-      if (id.bundle)
-        this.#engine.setBundle(Buffer.from(id.bundle), Date.now());
-    } catch (e) {
-      this.#engine = null;
-      this.#lastError = e instanceof Error ? e.message : String(e);
-      return { ok: false, reason: this.#lastError };
+    if (inNetd) {
+      const meshDir2 = this.#wantMeshId ?? listMeshIds()[0] ?? null;
+      if (!meshDir2)
+        return { ok: false, reason: "this machine is not enrolled in a mesh" };
+      try {
+        this.#engine = new NetdEngine(meshDir2, id.cert, {
+          // netd reports the node up: now this side has a port to advertise, and can
+          // publish itself to the relay and the LAN. Before that there is nothing to say.
+          onUp: (port) => {
+            this.#port = port;
+            this.#join();
+            this.#startLan();
+            this.#publishStatus();
+          }
+        });
+        if (id.bundle)
+          this.#bundle = id.bundle;
+      } catch (e) {
+        this.#engine = null;
+        this.#lastError = e instanceof Error ? e.message : String(e);
+        return { ok: false, reason: this.#lastError };
+      }
+    } else {
+      try {
+        this.#engine = new meshCore.MeshEngine(Buffer.from(id.genesis), Buffer.from(id.staticPrivate), Buffer.from(id.cert), 0, Buffer.alloc(16));
+        if (id.bundle) {
+          this.#engine.setBundle(Buffer.from(id.bundle), Date.now());
+          this.#bundle = id.bundle;
+        }
+      } catch (e) {
+        this.#engine = null;
+        this.#lastError = e instanceof Error ? e.message : String(e);
+        return { ok: false, reason: this.#lastError };
+      }
     }
     this.#identity = id;
-    this.#openSocket();
-    this.#startLan();
+    if (!inNetd) {
+      this.#openSocket();
+      this.#startLan();
+    }
     this.#offRejoin = onMeshRejoin(() => this.#join());
     this.#publishStatus();
     this.#statusTimer = setInterval(() => this.#publishStatus(), STATUS_REFRESH_MS);
@@ -110422,6 +110919,9 @@ var MeshNode = class {
     this.#subscribe();
     this.#timer = setInterval(() => this.#tick(), TICK_MS2);
     this.#timer.unref?.();
+    void this.#refreshBundle();
+    this.#refreshTimer = setInterval(() => void this.#refreshBundle(), REFRESH_INTERVAL_MS);
+    this.#refreshTimer.unref?.();
     return { ok: true };
   }
   /** Tear down. Idempotent, and safe to call from a signal handler. */
@@ -110430,6 +110930,16 @@ var MeshNode = class {
       clearInterval(this.#timer);
       this.#timer = null;
     }
+    if (this.#refreshTimer) {
+      clearInterval(this.#refreshTimer);
+      this.#refreshTimer = null;
+    }
+    if (this.#engine instanceof NetdEngine) {
+      try {
+        this.#engine.stop();
+      } catch {
+      }
+    }
     this.#unsubscribe?.();
     this.#unsubscribe = null;
     this.#offRejoin?.();
@@ -110529,19 +111039,27 @@ var MeshNode = class {
         staticPub: engine.localStaticPub(),
         port: () => this.#port,
         epoch: () => engine.policyEpoch(),
-        onPeer: (staticPub, address, port) => this.#learnLanPeer(staticPub, address, port)
+        onPeer: (staticPub, address, port, epoch2) => this.#learnLanPeer(staticPub, address, port, epoch2)
       });
       this.#lan.start();
     } catch {
       this.#lan = null;
     }
   }
-  /** A beacon arrived. Treated exactly like a relay hint — a candidate, not a fact. */
-  #learnLanPeer(staticPub, address, port) {
+  /** A beacon arrived. Treated exactly like a relay hint — a candidate, not a fact.
+   *
+   *  Including its EPOCH. The beacon has always carried one (`lan.ts`: "port(2) | epoch(8)")
+   *  for the same reason the relay hint does — so a peer that is behind can be brought up
+   *  to date — and, like the relay hint's, it was thrown away here. Two laptops on one
+   *  Wi-Fi with the internet down are the demonstration that the overlay is not
+   *  relay-dependent; without this they would find each other and then never agree on who
+   *  else exists. */
+  #learnLanPeer(staticPub, address, port, epoch2 = 0) {
     const engine = this.#engine;
     if (!engine)
       return;
     const hex6 = staticPub.toString("hex");
+    this.#offerBundleTo(hex6, epoch2);
     try {
       if (!this.#peers.has(hex6)) {
         engine.addPeer(staticPub, 0, Buffer.alloc(16));
@@ -110653,6 +111171,8 @@ var MeshNode = class {
           engine.setBundle(bytes2, Date.now());
           this.#stopIfRevoked(engine);
           cacheBundle(new Uint8Array(bytes2), meshDirNameFromWireId(engine.meshId()) ?? void 0);
+          this.#bundle = new Uint8Array(bytes2);
+          this.#bundleOffered.reset();
           break;
         }
       }
@@ -110661,6 +111181,89 @@ var MeshNode = class {
       this.#lastError = e instanceof Error ? e.message : String(e);
     }
   }
+  /**
+   * Ask the server for current policy, and adopt it if it is newer.
+   *
+   * The one path that can deliver an EVICTION. Gossip only ever moves a network to the
+   * newest bundle some connected node already holds, and after an eviction no node holds
+   * the new one — so without this, "remove that laptop" changed a database row and nothing
+   * else until somebody happened to join.
+   *
+   * Applied through exactly the same steps as a gossiped bundle, deliberately: the engine
+   * verifies it against genesis (so a hostile server cannot widen policy any more than a
+   * hostile relay can), `#stopIfRevoked` reads our own serial out of it, it is cached to
+   * disk, and the offer ledger resets so our peers hear about it too. That last part is
+   * what makes one node's poll benefit the whole network.
+   */
+  async #refreshBundle() {
+    const engine = this.#engine;
+    const id = this.#identity;
+    if (!engine || !id?.sigPrivate)
+      return;
+    const meshDir2 = meshDirNameFromWireId(engine.meshId());
+    const origin = (meshDir2 ? readLocal(meshDir2)?.origin : void 0) ?? readCredentials()?.apiOrigin;
+    if (!origin)
+      return;
+    const got = await fetchBundle({
+      origin,
+      genesisFp: engine.meshId(),
+      staticPub: Buffer.from(engine.localStaticPub()).toString("hex"),
+      sigPrivate: id.sigPrivate
+    });
+    if (!got.bundle)
+      return;
+    try {
+      engine.setBundle(Buffer.from(got.bundle), Date.now());
+    } catch {
+      return;
+    }
+    this.#stopIfRevoked(engine);
+    cacheBundle(got.bundle, meshDir2 ?? void 0);
+    this.#bundle = got.bundle;
+    this.#bundleOffered.reset();
+  }
+  /**
+   * Offer our policy bundle to a peer whose epoch is older than ours.
+   *
+   * ## The half of gossip that was never written
+   *
+   * `MeshPeerHint.epoch` is documented in the protocol as "the epoch the node advertises,
+   * SO A LAGGING PEER KNOWS TO PULL", and the relay has always carried it. Nothing read
+   * it, and — the part that made this total — nothing in the product ever SENT a
+   * `mesh:bundle`. The broker forwarded a message with no sender anywhere.
+   *
+   * So a node's roster was frozen at the instant it joined. `joinWithToken` caches the
+   * bundle the server returns, which is why a machine works at all; but every machine that
+   * joins LATER is invisible to it forever, because the only thing that would have told it
+   * is the gossip that never happened. On a four-machine network built in join order, the
+   * first machine knew nobody, the last knew everyone, and every one of them reported
+   * itself healthy. That is what this fixes.
+   *
+   * PUSH, not pull, because push needs no new message type and the protocol already hands
+   * us exactly the fact we need — the peer's epoch. For any pair, whoever is ahead offers,
+   * so the direction takes care of itself and a new joiner (who always has the newest
+   * bundle, straight from the server) feeds it to everyone already there.
+   *
+   * Safe by construction: the bundle is CA-signed, so `setBundle` on the receiving side
+   * verifies it against genesis and refuses anything that does not chain. Offering is
+   * therefore never a policy change — the worst a wrong offer costs a peer is a parse.
+   */
+  #offerBundleTo(peerHex, peerEpoch) {
+    const engine = this.#engine;
+    const bundle = this.#bundle;
+    if (!engine || !bundle)
+      return;
+    if (!this.#bundleOffered.claim(peerHex, peerEpoch, engine.policyEpoch()))
+      return;
+    try {
+      sendMesh({
+        type: "mesh:bundle",
+        meshId: engine.meshId(),
+        bundle: Buffer.from(bundle).toString("base64")
+      });
+    } catch {
+    }
+  }
   #learnPeer(p) {
     const engine = this.#engine;
     if (!engine)
@@ -110669,6 +111272,7 @@ var MeshNode = class {
     if (pk.length !== 32)
       return;
     const hex6 = pk.toString("hex");
+    this.#offerBundleTo(hex6, p.epoch ?? 0);
     if (p.cert) {
       try {
         const bytes2 = Buffer.from(p.cert, "base64");
@@ -110712,10 +111316,12 @@ var MeshNode = class {
   /** Flush everything the engine wants to send, and absorb its events. */
   #drain() {
     const engine = this.#engine;
-    const sock = this.#sock;
-    if (!engine || !sock)
+    if (!engine)
       return;
+    const sock = this.#sock;
     for (; ; ) {
+      if (!sock)
+        break;
       const item = engine.pollSend();
       if (!item)
         break;
@@ -110863,148 +111469,6 @@ function meshManager() {
   return singleton3;
 }
 
-// ../../packages/host-core/dist/mesh/netd-client.js
-import { connect as connect2 } from "node:net";
-import { platform as platform3 } from "node:process";
-var NETD_WIRE_VERSION = 1;
-var MAX_LINE = 1024 * 1024;
-var TIMEOUT_MS3 = 15e3;
-function netdEndpoint() {
-  if (platform3 === "win32")
-    return "\\\\.\\pipe\\tesseract-netd";
-  if (platform3 === "darwin")
-    return "/var/run/tesseract-netd.sock";
-  return "/run/tesseract-netd.sock";
-}
-function endpointOverride() {
-  return process.env.CCB_NETD_SOCKET ?? null;
-}
-function fail2(code, detail) {
-  return { ok: false, code, detail };
-}
-async function call(line) {
-  const endpoint2 = endpointOverride() ?? netdEndpoint();
-  return new Promise((resolve16) => {
-    let settled = false;
-    const done = (r) => {
-      if (settled)
-        return;
-      settled = true;
-      try {
-        sock.destroy();
-      } catch {
-      }
-      resolve16(r);
-    };
-    let sock;
-    try {
-      sock = connect2(endpoint2);
-    } catch (e) {
-      return resolve16(fail2("not-installed", e instanceof Error ? e.message : String(e)));
-    }
-    const timer2 = setTimeout(() => {
-      done(fail2("timeout", `no answer from the network helper in ${TIMEOUT_MS3}ms`));
-    }, TIMEOUT_MS3);
-    timer2.unref?.();
-    sock.setTimeout(TIMEOUT_MS3);
-    sock.on("timeout", () => {
-      clearTimeout(timer2);
-      done(fail2("timeout", "socket idle"));
-    });
-    sock.on("error", (e) => {
-      clearTimeout(timer2);
-      const absent = e.code === "ENOENT" || e.code === "ECONNREFUSED";
-      done(fail2(absent ? "not-installed" : "io", e.message));
-    });
-    let buf = "";
-    sock.on("data", (chunk) => {
-      buf += chunk.toString("utf8");
-      if (buf.length > MAX_LINE) {
-        clearTimeout(timer2);
-        done(fail2("protocol", "the helper sent an oversized line"));
-        return;
-      }
-      const nl = buf.indexOf("\n");
-      if (nl === -1)
-        return;
-      clearTimeout(timer2);
-      done({ ok: true, line: buf.slice(0, nl) });
-    });
-    sock.on("close", () => {
-      clearTimeout(timer2);
-      done(fail2("protocol", "the helper closed the connection without answering"));
-    });
-    sock.on("connect", () => {
-      sock.write(`${line}
-`);
-    });
-  });
-}
-function parse3(line) {
-  let body;
-  try {
-    body = JSON.parse(line);
-  } catch {
-    return fail2("protocol", "the helper sent something that is not JSON");
-  }
-  if (typeof body !== "object" || body === null) {
-    return fail2("protocol", "the helper sent something that is not an object");
-  }
-  const o = body;
-  if (o.ok === false) {
-    const code = typeof o.code === "string" ? o.code : "refused";
-    const detail = typeof o.detail === "string" ? o.detail : "the helper refused";
-    return fail2(code, detail);
-  }
-  if (o.ok !== true)
-    return fail2("protocol", "the helper did not say whether it succeeded");
-  return { ok: true, body: o };
-}
-async function request(line) {
-  const r = await call(line);
-  return r.ok ? parse3(r.line) : r;
-}
-function hex4(b) {
-  return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
-}
-async function netdHello() {
-  const r = await request(JSON.stringify({ op: "hello", wireVersion: NETD_WIRE_VERSION }));
-  if (!r.ok)
-    return r;
-  const v = r.body.wireVersion;
-  if (typeof v !== "number")
-    return fail2("protocol", "the helper did not report a wire version");
-  if (v !== NETD_WIRE_VERSION) {
-    return fail2("wire-version", `the helper speaks ${v}, this build speaks ${NETD_WIRE_VERSION}`);
-  }
-  return { ok: true, wireVersion: v };
-}
-async function netdStatus() {
-  const r = await request(JSON.stringify({ op: "status" }));
-  if (!r.ok)
-    return r;
-  const meshes = Array.isArray(r.body.meshes) ? r.body.meshes.filter((m) => typeof m === "string") : [];
-  const iface = typeof r.body.interface === "string" ? r.body.interface : null;
-  return { ok: true, meshes, interface: iface };
-}
-async function netdUp(args) {
-  const r = await request(JSON.stringify({
-    op: "up",
-    meshId: args.meshId,
-    genesis: hex4(args.genesis),
-    cert: hex4(args.cert),
-    fullTunnel: args.fullTunnel === true
-  }));
-  return r.ok ? { ok: true } : r;
-}
-async function netdDown(meshId) {
-  const r = await request(JSON.stringify({ op: "down", meshId }));
-  return r.ok ? { ok: true } : r;
-}
-async function netdAvailable() {
-  return (await netdHello()).ok;
-}
-
 // ../../packages/host-core/dist/mesh/route-sync.js
 async function syncRoutes(running2, log9 = () => {
 }) {
@@ -111033,7 +111497,14 @@ async function syncRoutes(running2, log9 = () => {
       // The per-machine choice, and `=== true` rather than a truthiness check: an absent or
       // malformed field must read as NO. netd unions this across meshes itself — any mesh
       // asking for a full tunnel makes it one for the machine — so this stays per mesh here.
-      fullTunnel: readLocal(meshId)?.fullTunnel === true
+      fullTunnel: readLocal(meshId)?.fullTunnel === true,
+      // THE KEY, and the bundle. With these netd runs the node — the data plane — rather
+      // than only pointing routes at a device nothing reads. The crate's own doc always
+      // described the enrolment as "a genesis block, a certificate and a key"; this is the
+      // first caller to send the third. Over the helper's authenticated socket, to the one
+      // process on the machine that already holds the device the traffic goes into.
+      staticPrivate: identity.staticPrivate,
+      ...identity.bundle ? { bundle: identity.bundle } : {}
     });
     if (r.ok) {
       out.up.push(meshId);
@@ -111059,22 +111530,63 @@ async function syncRoutes(running2, log9 = () => {
 }
 
 // ../../packages/host-core/dist/mesh/start-meshes.js
-function startMeshes(log9) {
+var ROUTE_RETRY_MS = 6e4;
+function startMeshes(log9, opts = {}) {
   const running2 = startNodes(log9);
-  void syncRoutes(running2, log9).then((r) => {
+  const retryMs = opts.retryMs ?? ROUTE_RETRY_MS;
+  let timer2 = null;
+  let stopped2 = false;
+  let lastSummary = "";
+  const attempt = async () => {
+    let r;
+    try {
+      r = await syncRoutes(running2, log9);
+    } catch (e) {
+      log9(`routes: sync threw \u2014 ${e instanceof Error ? e.message : String(e)}`);
+      return false;
+    }
     if (r.helperAbsent) {
-      log9("routes: the network helper is not installed \u2014 the overlay carries no traffic yet");
-      return;
+      const msg = "routes: the network helper is not installed \u2014 the overlay carries no traffic yet";
+      if (msg !== lastSummary)
+        log9(msg);
+      lastSummary = msg;
+      return false;
     }
     if (r.up.length)
       log9(`routes: installed for ${r.up.join(", ")}`);
     if (r.down.length)
       log9(`routes: removed for ${r.down.join(", ")}`);
-    for (const f of r.failed)
-      log9(`routes: ${f.meshId} refused \u2014 ${f.reason}`);
-  }).catch((e) => {
-    log9(`routes: sync threw \u2014 ${e instanceof Error ? e.message : String(e)}`);
+    const failures2 = r.failed.map((f) => `routes: ${f.meshId} refused \u2014 ${f.reason}`).join("\n");
+    if (failures2 && failures2 !== lastSummary)
+      log9(failures2);
+    lastSummary = failures2;
+    return r.failed.length === 0;
+  };
+  const schedule = () => {
+    if (stopped2 || running2.length === 0)
+      return;
+    timer2 = setTimeout(() => {
+      timer2 = null;
+      void attempt().then((done) => {
+        if (!done)
+          schedule();
+      });
+    }, retryMs);
+    timer2.unref?.();
+  };
+  void attempt().then((done) => {
+    if (!done)
+      schedule();
   });
+  return {
+    stop() {
+      stopped2 = true;
+      if (timer2) {
+        clearTimeout(timer2);
+        timer2 = null;
+      }
+    }
+  };
 }
 function startNodes(log9) {
   const ids = listMeshIds();
@@ -112404,7 +112916,7 @@ function appendRdeskAudit(e) {
 
 // ../../packages/host-core/dist/fileprovider-bridge.js
 init_managed_spawn();
-import { writeFileSync as writeFileSync36, mkdirSync as mkdirSync37, rmSync as rmSync8, existsSync as existsSync34 } from "node:fs";
+import { writeFileSync as writeFileSync36, mkdirSync as mkdirSync37, rmSync as rmSync8, existsSync as existsSync35 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { join as join73 } from "node:path";
 init_safe_kill();
@@ -112575,7 +113087,7 @@ function stopFileProviderBridge() {
 
 // ../../packages/host-core/dist/vault/autofill-bridge.js
 import { randomBytes as randomBytes9 } from "node:crypto";
-import { existsSync as existsSync35, mkdirSync as mkdirSync38, writeFileSync as writeFileSync37, rmSync as rmSync9 } from "node:fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync38, writeFileSync as writeFileSync37, rmSync as rmSync9 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { join as join74 } from "node:path";
 
@@ -112650,7 +113162,7 @@ function writeBridgeInfo(port, token3, log9) {
     return;
   const containerData = appexContainerData();
   try {
-    if (!existsSync35(containerData)) {
+    if (!existsSync36(containerData)) {
       if (!infoLoggedOnce) {
         infoLoggedOnce = true;
         log9("autofill bridge-info SKIP: no appex container yet at", containerData);
@@ -112899,7 +113411,7 @@ function createNodePowerController() {
 
 // ../../packages/host-core/dist/native-host.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { chmodSync as chmodSync6, existsSync as existsSync36, mkdirSync as mkdirSync39, writeFileSync as writeFileSync38 } from "node:fs";
+import { chmodSync as chmodSync6, existsSync as existsSync37, mkdirSync as mkdirSync39, writeFileSync as writeFileSync38 } from "node:fs";
 import { homedir as homedir12, platform as platform5 } from "node:os";
 import { dirname as dirname34, join as join75, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
@@ -112930,7 +113442,7 @@ function resolveBridge(log9) {
   } catch {
   }
   for (const c of candidates)
-    if (c && existsSync36(c))
+    if (c && existsSync37(c))
       return c;
   log9("companion native-host: bridge not found; skipping registration (looked in", candidates.filter(Boolean).join(" , "), ")");
   return null;
@@ -112972,7 +113484,7 @@ function registerNativeHost(opts) {
       return registerWindows(opts.daemonDir, manifestJson, log9);
     let wrote = 0;
     for (const profile of browserProfileDirs()) {
-      if (!existsSync36(profile))
+      if (!existsSync37(profile))
         continue;
       try {
         const dir2 = join75(profile, "NativeMessagingHosts");
@@ -113008,7 +113520,7 @@ init_daemon_settings();
 
 // ../../packages/host-core/dist/activity/activity-tracker.js
 init_credentials();
-import { promises as fsp, writeFileSync as writeFileSync39, mkdirSync as mkdirSync40, existsSync as existsSync37 } from "node:fs";
+import { promises as fsp, writeFileSync as writeFileSync39, mkdirSync as mkdirSync40, existsSync as existsSync38 } from "node:fs";
 import { join as join76 } from "node:path";
 function activityProfilePath() {
   return join76(daemonDir2(), "activity-profile.json");
@@ -113086,7 +113598,7 @@ function createActivityTracker(opts = {}) {
         return;
       const key2 = front.bundleId || front.name;
       await ensureLoaded();
-      if (profile && Object.keys(profile.apps).length && !existsSync37(activityProfilePath())) {
+      if (profile && Object.keys(profile.apps).length && !existsSync38(activityProfilePath())) {
         log9("activity profile cleared externally \u2014 resetting in-memory");
         profile = { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), apps: {} };
       }
@@ -113319,7 +113831,7 @@ function backoff2() {
 
 // ../../packages/host-core/dist/daemon-runtime.js
 var daemonClipboardSync = null;
-var REFRESH_INTERVAL_MS = 12 * 60 * 60 * 1e3;
+var REFRESH_INTERVAL_MS2 = 12 * 60 * 60 * 1e3;
 async function runDaemon(opts = {}) {
   const VERSION3 = opts.version ?? process.env.CCB_DAEMON_VERSION ?? "dev";
   const TAG = opts.tag ?? "host-daemon";
@@ -113360,7 +113872,7 @@ async function runDaemon(opts = {}) {
   function acquireLock2() {
     const f = pidfile();
     try {
-      if (!existsSync38(daemonDir2()))
+      if (!existsSync39(daemonDir2()))
         mkdirSync41(daemonDir2(), { recursive: true, mode: 448 });
     } catch {
     }
@@ -113386,7 +113898,7 @@ async function runDaemon(opts = {}) {
   function releaseLock() {
     try {
       const f = pidfile();
-      if (existsSync38(f) && Number(readFileSync49(f, "utf-8").trim()) === process.pid)
+      if (existsSync39(f) && Number(readFileSync49(f, "utf-8").trim()) === process.pid)
         unlinkSync6(f);
     } catch {
     }
@@ -113428,6 +113940,7 @@ async function runDaemon(opts = {}) {
     }
   }
   let stopGatewayKeyRefresh = null;
+  let meshRoutes = null;
   let timer2 = null;
   let identityWatch = null;
   let refreshRetry = null;
@@ -113522,6 +114035,10 @@ async function runDaemon(opts = {}) {
       stopGatewayKeyRefresh();
       stopGatewayKeyRefresh = null;
     }
+    if (meshRoutes) {
+      meshRoutes.stop();
+      meshRoutes = null;
+    }
     try {
       offRecovery?.();
       offRecovery = null;
@@ -114213,7 +114730,7 @@ async function runDaemon(opts = {}) {
     } catch {
     }
     try {
-      startMeshes(log9);
+      meshRoutes = startMeshes(log9);
     } catch {
     }
     writeStatus2({ deviceId: c.deviceId, connected: true });
@@ -114492,7 +115009,7 @@ async function runDaemon(opts = {}) {
     const daemonLogFile = join77(daemonDir2(), "daemon.log");
     const capTimer = setInterval(() => {
       try {
-        if (existsSync38(daemonLogFile) && statSync14(daemonLogFile).size > DAEMON_LOG_CAP) {
+        if (existsSync39(daemonLogFile) && statSync14(daemonLogFile).size > DAEMON_LOG_CAP) {
           const buf = readFileSync49(daemonLogFile, "utf-8");
           const kept = `\u2026[daemon.log capped at ${(/* @__PURE__ */ new Date()).toISOString()}]\u2026
 ` + buf.slice(-DAEMON_LOG_CAP / 2);
@@ -114509,7 +115026,7 @@ async function runDaemon(opts = {}) {
     startAutofillBridge(log9);
   }
   if (ownsMachine)
-    startMeshes(log9);
+    meshRoutes = startMeshes(log9);
   if (ownsMachine) {
     try {
       stopGatewayKeyRefresh = startGatewayKeyRefresh();
@@ -114521,7 +115038,7 @@ async function runDaemon(opts = {}) {
   await refresh();
   timer2 = setInterval(() => {
     void refresh();
-  }, REFRESH_INTERVAL_MS);
+  }, REFRESH_INTERVAL_MS2);
 }
 
 // ../../packages/host-core/dist/host-daemon-entry.js
@@ -114631,7 +115148,7 @@ async function evictNode(args) {
   const r = await call2(`/meshes/${encodeURIComponent(args.meshId)}/nodes/${encodeURIComponent(args.nodeId)}`, { method: "DELETE", body: {} });
   return r.ok ? { ok: true, epoch: r.data.epoch } : r;
 }
-async function enrolWith(requested, post) {
+async function enrolWith(requested, post, origin) {
   const name = normaliseNodeName(requested);
   if (!name) {
     return fail3("bad-name", `"${requested}" cannot be a machine name \u2014 names are DNS labels, so letters, digits and hyphens only`);
@@ -114655,7 +115172,7 @@ async function enrolWith(requested, post) {
   }
   try {
     saveMesh(meshId, { genesis, cert, staticPrivate, sigPrivate });
-    writeLocal(meshId, { joinedAt: Date.now(), enabled: true });
+    writeLocal(meshId, { joinedAt: Date.now(), enabled: true, ...origin ? { origin } : {} });
     if (r.data.bundle) {
       try {
         cacheBundle(fromHexOrB64(r.data.bundle), meshId);
@@ -114677,16 +115194,24 @@ async function enrolWith(requested, post) {
   };
 }
 async function enrol(args) {
-  return enrolWith(args.name, (staticPub, sigPub, name) => call2(`/meshes/${encodeURIComponent(args.meshId)}/nodes`, {
-    method: "POST",
-    body: { name, staticPub, sigPub, ...args.exitNode === true ? { exitNode: true } : {} }
-  }));
+  return enrolWith(
+    args.name,
+    (staticPub, sigPub, name) => call2(`/meshes/${encodeURIComponent(args.meshId)}/nodes`, {
+      method: "POST",
+      body: { name, staticPub, sigPub, ...args.exitNode === true ? { exitNode: true } : {} }
+    }),
+    // This path is authenticated, so the origin is necessarily the signed-in one.
+    resolveOrigin(void 0)
+  );
 }
 async function joinWithToken(args) {
-  return enrolWith(args.name, async (staticPub, sigPub, name) => postJoin(args.origin, { token: args.token, name, staticPub, sigPub }));
+  return enrolWith(args.name, async (staticPub, sigPub, name) => postJoin(args.origin, { token: args.token, name, staticPub, sigPub }), resolveOrigin(args.origin));
+}
+function resolveOrigin(origin) {
+  return origin ?? readCredentials()?.apiOrigin ?? void 0;
 }
 async function postJoin(origin, body) {
-  const base = origin ?? readCredentials()?.apiOrigin;
+  const base = resolveOrigin(origin);
   if (!base) {
     return fail3("not-signed-in", "this machine has never signed in \u2014 pass --origin https://\u2026 so it knows which server to ask");
   }
@@ -114714,7 +115239,7 @@ async function postJoin(origin, body) {
   return { ok: true, data: JSON.parse(text12) };
 }
 async function enrolWithCode(args) {
-  return enrolWith(args.name, async (staticPub, sigPub, name) => postJoin(args.origin, { code: args.code, name, staticPub, sigPub }));
+  return enrolWith(args.name, async (staticPub, sigPub, name) => postJoin(args.origin, { code: args.code, name, staticPub, sigPub }), resolveOrigin(args.origin));
 }
 async function rawPrivate(key2) {
   const pkcs8 = new Uint8Array(await crypto.subtle.exportKey("pkcs8", key2));
@@ -114798,13 +115323,13 @@ init_credentials();
 
 // ../../packages/host-core/dist/net-service/ensure-installed.js
 import { execFile as execFile14 } from "node:child_process";
-import { existsSync as existsSync42 } from "node:fs";
+import { existsSync as existsSync43 } from "node:fs";
 import { dirname as dirname36, join as join81 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 
 // ../../packages/host-core/dist/net-service/launchd-system.js
 import { spawn as spawn9 } from "node:child_process";
-import { existsSync as existsSync39, mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync41, rmSync as rmSync10, readFileSync as readFileSync50 } from "node:fs";
+import { existsSync as existsSync40, mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync41, rmSync as rmSync10, readFileSync as readFileSync50 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
 import { join as join78 } from "node:path";
 
@@ -114975,7 +115500,7 @@ ${plist}TESSERACT_PLIST_EOF`,
       };
     },
     async state() {
-      if (!existsSync39(PLIST))
+      if (!existsSync40(PLIST))
         return { installed: false, running: false };
       const owner = parseOwnerUid(readFileSync50(PLIST, "utf8"));
       const running2 = await netdAvailable();
@@ -114995,7 +115520,7 @@ ${plist}TESSERACT_PLIST_EOF`,
 
 // ../../packages/host-core/dist/net-service/systemd-system.js
 import { spawn as spawn11 } from "node:child_process";
-import { existsSync as existsSync40, readFileSync as readFileSync51 } from "node:fs";
+import { existsSync as existsSync41, readFileSync as readFileSync51 } from "node:fs";
 
 // ../../packages/host-core/dist/service/exec.js
 import { execFile as execFile11, spawn as spawn10 } from "node:child_process";
@@ -115138,7 +115663,7 @@ function makeSystemdSystem() {
       return code === 0 ? { ok: true } : { ok: false, detail: `removing the helper failed (exit ${code})` };
     },
     async state() {
-      if (!existsSync40(UNIT_PATH))
+      if (!existsSync41(UNIT_PATH))
         return { installed: false, running: false };
       const owner = parseOwnerUid(readFileSync51(UNIT_PATH, "utf8"));
       const active = await tryRun("systemctl", ["is-active", UNIT]);
@@ -115401,7 +115926,7 @@ function makeNetService() {
 }
 
 // ../../packages/host-core/dist/net-service/netd-binary.js
-import { existsSync as existsSync41 } from "node:fs";
+import { existsSync as existsSync42 } from "node:fs";
 import { dirname as dirname35, join as join80 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function netdBinaryName() {
@@ -115409,7 +115934,7 @@ function netdBinaryName() {
 }
 function override2() {
   const p = process.env.CCB_NETD_BIN;
-  return p && existsSync41(p) ? p : null;
+  return p && existsSync42(p) ? p : null;
 }
 function netdBinaryPath() {
   const fromEnv = override2();
@@ -115436,7 +115961,7 @@ function netdBinaryPath() {
   candidates.push(join80(process.cwd(), "crates", "target", "release", name));
   for (const c of candidates) {
     try {
-      if (existsSync41(c))
+      if (existsSync42(c))
         return c;
     } catch {
     }
@@ -115478,7 +116003,7 @@ async function ensureNetHelperInstalled() {
   if (st.installed && !mismatched)
     return { ok: true, already: true };
   const exec2 = netdBinaryPath();
-  if (exec2 && process.platform === "win32" && !existsSync42(join81(dirname36(exec2), "wintun.dll"))) {
+  if (exec2 && process.platform === "win32" && !existsSync43(join81(dirname36(exec2), "wintun.dll"))) {
     return {
       ok: false,
       reason: "no-binary",
@@ -115530,7 +116055,7 @@ import { platform as platform6 } from "node:os";
 
 // ../../packages/host-core/dist/service/launchd.js
 init_credentials();
-import { writeFileSync as writeFileSync43, existsSync as existsSync43, mkdirSync as mkdirSync42, unlinkSync as unlinkSync7 } from "node:fs";
+import { writeFileSync as writeFileSync43, existsSync as existsSync44, mkdirSync as mkdirSync42, unlinkSync as unlinkSync7 } from "node:fs";
 import { dirname as dirname37, join as join82 } from "node:path";
 import { homedir as homedir13, userInfo as userInfo2 } from "node:os";
 function xml2(s) {
@@ -115585,6 +116110,36 @@ ${env}
 </plist>
 `;
   }
+  const loaded = async () => {
+    try {
+      await run5("launchctl", ["print", serviceTarget()]);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const untilGone = async () => {
+    for (let i = 0; i < 25; i++) {
+      if (!await loaded())
+        return;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+  };
+  const bootstrapWithRetry = async () => {
+    let last;
+    for (let i = 0; i < 5; i++) {
+      try {
+        await run5("launchctl", ["bootstrap", domainTarget(), plistPath()]);
+        return;
+      } catch (e) {
+        last = e;
+        if (await loaded())
+          return;
+        await new Promise((r) => setTimeout(r, 300 * (i + 1)));
+      }
+    }
+    throw last instanceof Error ? last : new Error(String(last));
+  };
   return {
     async install(spec) {
       mkdirSync42(workDirOf(spec), { recursive: true });
@@ -115593,16 +116148,20 @@ ${env}
       writeFileSync43(plistPath(), buildPlist2(spec));
       await run5("launchctl", ["bootout", serviceTarget()]).catch(() => {
       });
-      await run5("launchctl", ["bootstrap", domainTarget(), plistPath()]);
+      await untilGone();
+      await bootstrapWithRetry();
       await run5("launchctl", ["enable", serviceTarget()]).catch(() => {
       });
       await run5("launchctl", ["kickstart", "-k", serviceTarget()]).catch(() => {
       });
+      if (!await loaded()) {
+        throw new Error(`the service ${label} is not loaded after install \u2014 check \`launchctl print ${serviceTarget()}\``);
+      }
     },
     async uninstall() {
       await run5("launchctl", ["bootout", serviceTarget()]).catch(() => {
       });
-      if (existsSync43(plistPath())) {
+      if (existsSync44(plistPath())) {
         try {
           unlinkSync7(plistPath());
         } catch {
@@ -115613,7 +116172,7 @@ ${env}
       await this.install(spec);
     },
     async isInstalled() {
-      return existsSync43(plistPath());
+      return existsSync44(plistPath());
     },
     async start() {
       await run5("launchctl", ["bootstrap", domainTarget(), plistPath()]).catch(() => {
@@ -115630,7 +116189,7 @@ ${env}
     },
     async logs(follow) {
       const f = logFile();
-      if (!existsSync43(f)) {
+      if (!existsSync44(f)) {
         console.log(`No log yet at ${f} \u2014 has the service started?`);
         return;
       }
@@ -115641,7 +116200,7 @@ ${env}
 
 // ../../packages/host-core/dist/service/systemd.js
 init_credentials();
-import { writeFileSync as writeFileSync44, existsSync as existsSync44, mkdirSync as mkdirSync43, unlinkSync as unlinkSync8 } from "node:fs";
+import { writeFileSync as writeFileSync44, existsSync as existsSync45, mkdirSync as mkdirSync43, unlinkSync as unlinkSync8 } from "node:fs";
 import { dirname as dirname38, join as join83 } from "node:path";
 import { homedir as homedir14, userInfo as userInfo3 } from "node:os";
 function unitVal2(v) {
@@ -115697,7 +116256,7 @@ WantedBy=default.target
     async uninstall() {
       await run5("systemctl", ["--user", "disable", "--now", unit]).catch(() => {
       });
-      if (existsSync44(unitPath())) {
+      if (existsSync45(unitPath())) {
         try {
           unlinkSync8(unitPath());
         } catch {
@@ -115710,7 +116269,7 @@ WantedBy=default.target
       await this.install(spec);
     },
     async isInstalled() {
-      return existsSync44(unitPath());
+      return existsSync45(unitPath());
     },
     async start() {
       await run5("systemctl", ["--user", "start", unit]);
@@ -115723,7 +116282,7 @@ WantedBy=default.target
     },
     async logs(follow) {
       const f = join83(daemonDir2(), "daemon.log");
-      if (existsSync44(f)) {
+      if (existsSync45(f)) {
         await runInherit("tail", follow ? ["-f", f] : ["-n", "200", f]);
         return;
       }
@@ -115735,8 +116294,20 @@ WantedBy=default.target
 
 // ../../packages/host-core/dist/service/windows.js
 init_credentials();
-import { writeFileSync as writeFileSync45, existsSync as existsSync45, mkdirSync as mkdirSync44, unlinkSync as unlinkSync9 } from "node:fs";
+import { writeFileSync as writeFileSync45, existsSync as existsSync46, mkdirSync as mkdirSync44, unlinkSync as unlinkSync9, readFileSync as readFileSync52 } from "node:fs";
 import { dirname as dirname39, join as join84 } from "node:path";
+function publishedDaemonPid(dir2) {
+  for (const f of ["status.json", "daemon.lock"]) {
+    try {
+      const raw = readFileSync52(join84(dir2, f), "utf-8");
+      const pid = f === "status.json" ? Number(JSON.parse(raw).pid) : Number(raw.trim());
+      if (Number.isInteger(pid) && pid > 0)
+        return pid;
+    } catch {
+    }
+  }
+  return null;
+}
 function makeWindowsTask(instanceId) {
   const suffix = instanceSuffix(instanceId);
   const task = `Fineguide\\TesseractHost${suffix ? `-${suffix}` : ""}`;
@@ -115768,14 +116339,20 @@ start "" /b ${cmd} >> "${oneLine2(spec.logPath).replace(/"/g, "")}" 2>&1\r
     async uninstall() {
       await run5("schtasks", ["/Delete", "/TN", task, "/F"]).catch(() => {
       });
-      if (existsSync45(wrapperPath())) {
+      if (existsSync46(wrapperPath())) {
         try {
           unlinkSync9(wrapperPath());
         } catch {
         }
       }
     },
+    // STOP FIRST. `install` alone re-creates the task and runs it, which on Windows spawns a
+    // SECOND daemon beside the one that is still running (see stop()); the newcomer finds the
+    // pid lock held and stands down, so "restart" restarted nothing — the old process kept
+    // running the old code. That is how a machine upgraded to a fixed CLI kept exhibiting the
+    // bug the upgrade fixed, and how `tesseract-agent restart` reported success while doing it.
     async restart(spec) {
+      await this.stop();
       await this.install(spec);
     },
     async isInstalled() {
@@ -115789,16 +116366,54 @@ start "" /b ${cmd} >> "${oneLine2(spec.logPath).replace(/"/g, "")}" 2>&1\r
     async start() {
       await run5("schtasks", ["/Run", "/TN", task]);
     },
+    /**
+     * Stop the daemon. Not the task — the daemon.
+     *
+     * `schtasks /End` ends the TASK's process, and the task's process is the .cmd wrapper, which
+     * exited the instant it ran `start "" /b` to detach the daemon. So /End ended a task that had
+     * already finished, reported success, and the daemon ran on. Every `stop`, `restart` and
+     * self-update on Windows has been a no-op against a running daemon since the wrapper was
+     * written; observed directly as two node processes surviving stop, restart, and the task's
+     * own /End, with start times from the original launch.
+     *
+     * The daemon publishes its own pid (status.json / daemon.lock), and that is what gets ended.
+     * Its PARENT is ended instead when the parent is the CLI supervisor (`cli.js run`), because
+     * killing only the worker makes the supervisor respawn it; `/T` takes the whole tree either
+     * way. The parent is checked by command line before being touched: the lock can be held by a
+     * process that is not ours to kill — the desktop app owning the machine — and a supervisor
+     * that is not `cli.js` is left alone, worker only.
+     *
+     * Best-effort throughout, like the other controllers' stop: a daemon that is already gone
+     * is the desired state, not an error.
+     */
     async stop() {
       await run5("schtasks", ["/End", "/TN", task]).catch(() => {
       });
+      const pid = publishedDaemonPid(daemonDir2());
+      if (pid === null)
+        return;
+      let target = pid;
+      try {
+        const { stdout } = await run5("powershell", [
+          "-NoProfile",
+          "-Command",
+          `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($p) { $pp = Get-CimInstance Win32_Process -Filter "ProcessId = $($p.ParentProcessId)"; if ($pp) { "$($pp.ProcessId)|$($pp.CommandLine)" } }`
+        ]);
+        const [ppidRaw, cmd = ""] = String(stdout).trim().split("|");
+        const ppid = Number(ppidRaw);
+        if (Number.isInteger(ppid) && ppid > 0 && /cli\.js["']?\s+run\b/.test(cmd))
+          target = ppid;
+      } catch {
+      }
+      await run5("taskkill", ["/pid", String(target), "/T", "/F"]).catch(() => {
+      });
     },
     async status() {
       await runInherit("schtasks", ["/Query", "/TN", task, "/V", "/FO", "LIST"]);
     },
     async logs(follow) {
       const f = logFile();
-      if (!existsSync45(f)) {
+      if (!existsSync46(f)) {
         console.log(`No log yet at ${f} \u2014 has the task run?`);
         return;
       }
@@ -115830,7 +116445,7 @@ init_safe_kill();
 // src/auth.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
 import { randomUUID as randomUUID30 } from "node:crypto";
-import { existsSync as existsSync46, rmSync as rmSync12 } from "node:fs";
+import { existsSync as existsSync47, rmSync as rmSync12 } from "node:fs";
 import { join as join85 } from "node:path";
 
 // src/config.ts
@@ -116033,7 +116648,7 @@ async function logout() {
   for (const f of ["credentials.json", "status.json", "daemon.lock"]) {
     try {
       const p = join85(daemonDir2(), f);
-      if (existsSync46(p)) rmSync12(p);
+      if (existsSync47(p)) rmSync12(p);
     } catch {
     }
   }
@@ -116193,7 +116808,7 @@ function startSelfUpdater(current) {
 // src/service.ts
 import { join as join86 } from "node:path";
 import { platform as platform7 } from "node:os";
-import { existsSync as existsSync47, readFileSync as readFileSync52 } from "node:fs";
+import { existsSync as existsSync48, readFileSync as readFileSync53 } from "node:fs";
 function controller(instanceId) {
   const c = getServiceController(instanceId);
   if (!c) {
@@ -116220,8 +116835,8 @@ var isAlive = (pid) => {
 function runningDaemonInfo() {
   const lock = join86(daemonDir2(), "daemon.lock");
   try {
-    if (!existsSync47(lock)) return null;
-    const pid = Number(readFileSync52(lock, "utf-8").trim());
+    if (!existsSync48(lock)) return null;
+    const pid = Number(readFileSync53(lock, "utf-8").trim());
     if (!pid || !isAlive(pid)) return null;
     return { pid, device: readCredentials()?.deviceId };
   } catch {
@@ -116255,7 +116870,7 @@ async function logs(instanceId, follow) {
 }
 
 // src/net.ts
-import { readFileSync as readFileSync54 } from "node:fs";
+import { readFileSync as readFileSync55 } from "node:fs";
 import { randomBytes as randomBytes11 } from "node:crypto";
 import { hostname as hostname7 } from "node:os";
 import { resolve as resolve14 } from "node:path";
@@ -116320,7 +116935,7 @@ function readOrDie(label, p) {
     process.exit(1);
   }
   try {
-    return new Uint8Array(readFileSync54(resolve14(p)));
+    return new Uint8Array(readFileSync55(resolve14(p)));
   } catch (e) {
     console.error(`net enroll: could not read --${label} ${p}: ${e instanceof Error ? e.message : e}`);
     process.exit(1);
@@ -116392,6 +117007,9 @@ async function netCommand(rest, flags) {
     const established = s.established ?? [];
     const relayed = s.relayed ?? [];
     console.log(`peers:        ${s.peers ?? 0} known, ${established.length} with a live session`);
+    if (typeof s.policyEpoch === "number") {
+      console.log(`policy:       epoch ${s.policyEpoch}${s.policyEpoch === 0 ? "  \u2014 no policy yet, so NO traffic will pass" : ""}`);
+    }
     if (relayed.length) {
       console.log(`relayed:      ${relayed.length} (${relayed.join(", ")}) \u2014 these are NOT direct`);
     } else if (established.length) {
@@ -116871,7 +117489,7 @@ async function netCommand(rest, flags) {
 function pkgVersion() {
   try {
     const p = join88(dirname40(fileURLToPath8(import.meta.url)), "..", "package.json");
-    return JSON.parse(readFileSync55(p, "utf8")).version ?? "0.0.0";
+    return JSON.parse(readFileSync56(p, "utf8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";
   }
@@ -117117,7 +117735,7 @@ async function captureClaudeSubscription(flags) {
     });
     if (code !== 0) throw new Error(`Claude sign-in did not complete (exit ${code}).`);
     const file2 = join88(home, ".credentials.json");
-    if (existsSync49(file2)) return readFileSync55(file2, "utf8");
+    if (existsSync50(file2)) return readFileSync56(file2, "utf8");
     if (process.platform === "darwin") {
       const value = execFileSync6("security", [
         "find-generic-password",
@@ -117199,7 +117817,7 @@ async function runnerCommand(rest, flags) {
       process.exit(1);
     }
     const oauthFilePath = typeof flags["oauth-file"] === "string" ? resolve15(flags["oauth-file"]) : void 0;
-    const oauthAuthFile = oauthFilePath ? readFileSync55(oauthFilePath, "utf8") : void 0;
+    const oauthAuthFile = oauthFilePath ? readFileSync56(oauthFilePath, "utf8") : void 0;
     if (oauthAuthFile) {
       try {
         JSON.parse(oauthAuthFile);