@rubytech/create-sitedesk-code 0.1.522 → 0.1.523

package/payload/server/{chunk-K7CJGZPU.js → chunk-VUXKXOJU.js}

@@ -6,8 +6,9 @@ import {
   ensureConversation,
   getSession,
   getUserTimezone,
-  isValidAccountId
-} from "./chunk-PXNY2TAP.js";
+  isValidAccountId,
+  registerLoop
+} from "./chunk-XCR5D2G3.js";
 
 // app/lib/whatsapp/schema.ts
 import { z } from "zod";
@@ -257,7 +258,6 @@ import { inspect } from "util";
 import {
   Browsers,
   DisconnectReason,
-  fetchLatestBaileysVersion,
   makeCacheableSignalKeyStore,
   makeWASocket,
   useMultiFileAuthState
@@ -318,6 +318,18 @@ function resolveDebugWindow(authDir, nowMs = Date.now()) {
   return state;
 }
 
+// app/lib/whatsapp/companion-reg.ts
+var PRIMARY_IDENTITY_PUB = "primary_identity_pub";
+function classifyCompanionReg(node) {
+  const outer = node?.content;
+  const child = Array.isArray(outer) ? outer.find((c) => c?.tag === "link_code_companion_reg") : void 0;
+  const rawStage = child?.attrs?.stage;
+  const stage = typeof rawStage === "string" && rawStage ? rawStage : "absent";
+  const inner = child?.content;
+  const children = Array.isArray(inner) ? inner.map((c) => c?.tag).filter((t) => typeof t === "string") : [];
+  return { stage, children, parseable: children.includes(PRIMARY_IDENTITY_PUB) };
+}
+
 // app/lib/whatsapp/ingest-ledger.ts
 import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync, readdirSync } from "fs";
 import { join } from "path";
@@ -471,8 +483,102 @@ function listLedgerAccounts() {
   }
 }
 
+// app/lib/whatsapp/version-census.ts
+import { DEFAULT_CONNECTION_CONFIG, fetchLatestBaileysVersion } from "@whiskeysockets/baileys";
+var TAG4 = "[whatsapp:version]";
+var BAILEYS_VERSION_URL = "https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts";
+var VERSION_RE = /const version = \[(\d+),\s*(\d+),\s*(\d+)\]/;
+var presented = /* @__PURE__ */ new Map();
+var behindSince = null;
+function packagedVersion() {
+  return DEFAULT_CONNECTION_CONFIG.version.join(".");
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var PROBE_TIMEOUT_MS = 5e3;
+async function probeSourceAge(fetchImpl) {
+  const none = (probe) => ({ sourceAgeSec: null, edge: null, probe });
+  try {
+    const res = await fetchImpl(BAILEYS_VERSION_URL, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+    if (!res.ok) return none(`http-${res.status}`);
+    const header = res.headers.get("age") !== null ? "age" : "source-age";
+    const raw = res.headers.get(header);
+    const n = raw === null ? Number.NaN : Number.parseInt(raw, 10);
+    if (!Number.isFinite(n)) return none("no-header");
+    return { sourceAgeSec: n, edge: res.headers.get("x-served-by"), probe: header };
+  } catch (err) {
+    return none(err instanceof Error && err.name === "TimeoutError" ? "timeout" : "net-error");
+  }
+}
+async function resolveWaVersion(opts) {
+  const { account } = opts;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const fetchVersion = opts.fetchVersion ?? fetchLatestBaileysVersion;
+  const now = opts.now ?? Date.now;
+  const timed = (async () => {
+    const t0 = now();
+    const r2 = await fetchVersion();
+    return { r: r2, ms: now() - t0 };
+  })();
+  const [{ r, ms }, probe] = await Promise.all([timed, probeSourceAge(fetchImpl)]);
+  const err = r.error;
+  const origin = r.isLatest === false || err !== void 0 ? "packaged-fallback" : "fetched";
+  const versionStr = r.version.join(".");
+  const packaged = packagedVersion();
+  presented.set(account, versionStr);
+  console.error(
+    `${TAG4} op=resolve account=${account} version=${versionStr} origin=${origin} sourceAgeSec=${probe.sourceAgeSec ?? "unknown"} probe=${probe.probe} edge=${probe.edge ?? "unknown"} packaged=${packaged} matchesPackaged=${versionStr === packaged} fetchMs=${ms} error=${err === void 0 ? "none" : `"${messageOf(err)}"`}`
+  );
+  return { version: r.version };
+}
+var CENSUS_INTERVAL_MS = 15 * 60 * 1e3;
+async function runVersionDriftCensus(opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  let upstream = null;
+  let reason = "net-error";
+  try {
+    const res = await fetchImpl(BAILEYS_VERSION_URL);
+    if (!res.ok) {
+      reason = `http-${res.status}`;
+    } else {
+      const m = VERSION_RE.exec(await res.text());
+      if (m) upstream = `${m[1]}.${m[2]}.${m[3]}`;
+      else reason = "parse-failed";
+    }
+  } catch {
+    upstream = null;
+    reason = "net-error";
+  }
+  const distinct = [...new Set(presented.values())].sort();
+  const presentedStr = distinct.length === 0 ? "none" : distinct.join(",");
+  if (upstream !== null && distinct.length > 0) {
+    if (distinct.some((v) => v !== upstream)) {
+      if (behindSince === null) behindSince = now().toISOString();
+    } else {
+      behindSince = null;
+    }
+  }
+  console.error(
+    `${TAG4} op=drift-census presented=${presentedStr} upstream=${upstream ?? reason} behindSince=${behindSince ?? "none"}`
+  );
+  return `presented=${presentedStr} upstream=${upstream ?? reason}`;
+}
+function startVersionDriftCensus(intervalMs = CENSUS_INTERVAL_MS) {
+  return registerLoop({
+    name: "whatsapp-version-drift",
+    intervalMs,
+    firstRunDelayMs: 0,
+    run: () => runVersionDriftCensus()
+  });
+}
+
 // app/lib/whatsapp/session.ts
-var TAG4 = "[whatsapp:session]";
+var TAG5 = "[whatsapp:session]";
 var WIRE_TAG = "[whatsapp:wire]";
 var baileysPkgVersion = (() => {
   try {
@@ -482,7 +588,7 @@ var baileysPkgVersion = (() => {
     return "unknown";
   }
 })();
-console.error(`${TAG4} baileys package loaded version=${baileysPkgVersion}`);
+console.error(`${TAG5} baileys package loaded version=${baileysPkgVersion}`);
 var __BAILEYS_TAG = "[whatsapp:baileys]";
 var INSPECT_OPTS = {
   depth: null,
@@ -543,7 +649,7 @@ function createBaileysLogger(bindings = {}, authDir) {
 }
 var credsSaveQueue = Promise.resolve();
 async function drainCredsSaveQueue(timeoutMs = 5e3) {
-  console.error(`${TAG4} draining credential save queue\u2026`);
+  console.error(`${TAG5} draining credential save queue\u2026`);
   const timer = new Promise(
     (resolve6) => setTimeout(() => resolve6("timeout"), timeoutMs)
   );
@@ -552,9 +658,9 @@ async function drainCredsSaveQueue(timeoutMs = 5e3) {
     timer
   ]);
   if (result === "timeout") {
-    console.error(`${TAG4} credential save queue drain timed out after ${timeoutMs}ms`);
+    console.error(`${TAG5} credential save queue drain timed out after ${timeoutMs}ms`);
   } else {
-    console.error(`${TAG4} credential save queue drained`);
+    console.error(`${TAG5} credential save queue drained`);
   }
 }
 function readCredsJsonRaw2(filePath) {
@@ -577,11 +683,11 @@ async function safeSaveCreds(authDir, saveCreds) {
         JSON.parse(raw);
         fsSync2.copyFileSync(credsPath, backupPath);
       } catch (err) {
-        console.warn(`${TAG4} backup pre-copy failed (parse or write) authDir=${authDir}: ${String(err)}`);
+        console.warn(`${TAG5} backup pre-copy failed (parse or write) authDir=${authDir}: ${String(err)}`);
       }
     }
   } catch (err) {
-    console.warn(`${TAG4} backup preparation failed authDir=${authDir}: ${String(err)}`);
+    console.warn(`${TAG5} backup preparation failed authDir=${authDir}: ${String(err)}`);
   }
   try {
     await Promise.resolve(saveCreds());
@@ -589,39 +695,39 @@ async function safeSaveCreds(authDir, saveCreds) {
     try {
       const stats = await fs3.stat(credsPath);
       if (stats.size <= 1) {
-        console.error(`${TAG4} WARNING: creds file empty/truncated after save path=${credsPath} size=${stats.size}`);
+        console.error(`${TAG5} WARNING: creds file empty/truncated after save path=${credsPath} size=${stats.size}`);
       } else {
-        console.error(`${TAG4} creds saved and verified path=${credsPath} size=${stats.size}`);
+        console.error(`${TAG5} creds saved and verified path=${credsPath} size=${stats.size}`);
       }
     } catch (statErr) {
-      console.error(`${TAG4} creds NOT found on disk after save path=${credsPath}: ${String(statErr)}`);
+      console.error(`${TAG5} creds NOT found on disk after save path=${credsPath}: ${String(statErr)}`);
     }
   } catch (err) {
-    console.error(`${TAG4} failed saving creds to ${authDir}: ${String(err)}`);
+    console.error(`${TAG5} failed saving creds to ${authDir}: ${String(err)}`);
   }
 }
 function enqueueSaveCreds(authDir, saveCreds) {
   credsSaveQueue = credsSaveQueue.then(() => safeSaveCreds(authDir, saveCreds)).catch((err) => {
-    console.error(`${TAG4} creds save queue error: ${String(err)}`);
+    console.error(`${TAG5} creds save queue error: ${String(err)}`);
   });
 }
 async function createWaSocket(opts) {
-  const { authDir, onQr, onConnectionUpdate, silent, correlationId, account, getCodeIssuedTs } = opts;
+  const { authDir, onQr, onConnectionUpdate, silent, correlationId, account, getCodeIssuedTs, onCompanionReg } = opts;
   const cid = correlationId ?? "none";
   const acct = account ?? "unknown";
   await fs3.mkdir(authDir, { recursive: true });
   maybeRestoreCredsFromBackup(authDir);
   const { state, saveCreds } = await useMultiFileAuthState(authDir);
-  const { version } = await fetchLatestBaileysVersion();
+  const { version } = await resolveWaVersion({ account: acct });
   if (!silent) {
     const preCensus = credsCensus(authDir);
     console.error(
-      `${TAG4} op=creds-pre cid=${cid} account=${acct} credsPresent=${preCensus.credsPresent} registered=${preCensus.registered} hasAccount=${preCensus.hasAccountSignature}`
+      `${TAG5} op=creds-pre cid=${cid} account=${acct} credsPresent=${preCensus.credsPresent} registered=${preCensus.registered} hasAccount=${preCensus.hasAccountSignature}`
     );
   }
   const openTs = Date.now();
   console.error(
-    `${TAG4} op=socket-open cid=${cid} account=${acct} baileysVersion=${baileysPkgVersion} waProtocolVersion=${version.join(".")} openTs=${openTs}`
+    `${TAG5} op=socket-open cid=${cid} account=${acct} baileysVersion=${baileysPkgVersion} waProtocolVersion=${version.join(".")} openTs=${openTs}`
   );
   const baileysLogger = createBaileysLogger({}, authDir);
   const sock = makeWASocket({
@@ -638,7 +744,7 @@ async function createWaSocket(opts) {
     fireInitQueries: false
   });
   sock.ev.on("creds.update", () => {
-    console.error(`${TAG4} creds.update received \u2014 saving to ${authDir}`);
+    console.error(`${TAG5} creds.update received \u2014 saving to ${authDir}`);
     enqueueSaveCreds(authDir, saveCreds);
   });
   let qrSequence = 0;
@@ -658,14 +764,14 @@ async function createWaSocket(opts) {
         parts.push(`disconnectReason=${formatError(update.lastDisconnect.error)}`);
       }
       if (!silent && parts.length > 0) {
-        console.error(`${TAG4} connection.update ${parts.join(" ")}`);
+        console.error(`${TAG5} connection.update ${parts.join(" ")}`);
       }
       if (update.qr && !silent) {
         const now = Date.now();
         const sinceLastRefMs = lastQrTs ? now - lastQrTs : null;
         lastQrTs = now;
         console.error(
-          `${TAG4} op=qr cid=${cid} qr=#${qrSequence} sinceOpenMs=${now - openTs} sinceLastRefMs=${sinceLastRefMs ?? "n/a"}`
+          `${TAG5} op=qr cid=${cid} qr=#${qrSequence} sinceOpenMs=${now - openTs} sinceLastRefMs=${sinceLastRefMs ?? "n/a"}`
         );
       }
       if (update.isNewLogin === true && !pairSuccessLogged && !silent) {
@@ -674,7 +780,7 @@ async function createWaSocket(opts) {
         const sinceCodeIssuedMs = codeIssuedTs ? Date.now() - codeIssuedTs : null;
         const afterCensus = credsCensus(authDir);
         console.error(
-          `${TAG4} op=pair-success cid=${cid} account=${acct} sinceCodeIssuedMs=${sinceCodeIssuedMs ?? "n/a"} hasAccountAfter=${afterCensus.hasAccountSignature}`
+          `${TAG5} op=pair-success cid=${cid} account=${acct} sinceCodeIssuedMs=${sinceCodeIssuedMs ?? "n/a"} hasAccountAfter=${afterCensus.hasAccountSignature}`
         );
       }
       if (update.qr && onQr) {
@@ -684,25 +790,25 @@ async function createWaSocket(opts) {
         const status = getStatusCode(update.lastDisconnect?.error);
         if (!silent) {
           console.error(
-            `${TAG4} op=close cid=${cid} account=${acct} status=${status ?? "unknown"} reason="${formatError(update.lastDisconnect?.error)}" socketLifeMs=${Date.now() - openTs} kind=${closeKind(status, everOpen)}`
+            `${TAG5} op=close cid=${cid} account=${acct} status=${status ?? "unknown"} reason="${formatError(update.lastDisconnect?.error)}" socketLifeMs=${Date.now() - openTs} kind=${closeKind(status, everOpen)}`
           );
         }
         if (status === DisconnectReason.loggedOut && !silent) {
-          console.error(`${TAG4} session logged out (401) \u2014 re-link required`);
+          console.error(`${TAG5} session logged out (401) \u2014 re-link required`);
         }
       }
       if (update.connection === "open") {
         everOpen = true;
-        if (!silent) console.error(`${TAG4} connected`);
+        if (!silent) console.error(`${TAG5} connected`);
       }
       onConnectionUpdate?.(update);
     } catch (err) {
-      console.error(`${TAG4} connection.update handler error: ${String(err)}`);
+      console.error(`${TAG5} connection.update handler error: ${String(err)}`);
     }
   });
   if (sock.ws && typeof sock.ws.on === "function") {
     sock.ws.on("error", (err) => {
-      console.error(`${TAG4} WebSocket error: ${String(err)}`);
+      console.error(`${TAG5} WebSocket error: ${String(err)}`);
     });
     sock.ws.on("CB:message", (node) => {
       const attrs = node?.attrs ?? {};
@@ -718,6 +824,21 @@ async function createWaSocket(opts) {
         });
       }
     });
+    if (!silent) {
+      sock.ws.on("CB:notification,type:link_code_companion_reg", (node) => {
+        try {
+          const census = classifyCompanionReg(node);
+          console.error(
+            `${TAG5} op=companion-reg cid=${cid} account=${acct} stage=${census.stage} children=${census.children.join(",") || "none"} parseable=${census.parseable}`
+          );
+          onCompanionReg?.(census);
+        } catch (err) {
+          console.error(
+            `${TAG5} op=companion-reg-observer-error cid=${cid} account=${acct} err=${String(err)}`
+          );
+        }
+      });
+    }
   }
   return sock;
 }
@@ -826,6 +947,26 @@ function computeBackoff(attempt, config = {}) {
   return Math.round(jitter);
 }
 
+// app/lib/whatsapp/link-census.ts
+var HEALTH_TAG = "[whatsapp-health]";
+var LINK_CENSUS_INTERVAL_MS = 15 * 6e4;
+function downMsFor(row, now) {
+  if (row.connected) return "0";
+  if (row.lastConnectedAt === void 0) return "unknown";
+  return String(now - row.lastConnectedAt);
+}
+function linkCensusLines(rows, now) {
+  if (rows.length === 0) return [`${HEALTH_TAG} op=link-census accounts=0`];
+  return rows.map(
+    (row) => `${HEALTH_TAG} op=link-census account=${row.accountId} connected=${row.connected} stuck=${Boolean(row.sessionStuckReason)} downMs=${downMsFor(row, now)} lastError=${row.lastError ?? "none"}`
+  );
+}
+function runLinkCensus(read, now) {
+  const rows = read();
+  for (const line of linkCensusLines(rows, now)) console.error(line);
+  return rows.length;
+}
+
 // app/lib/whatsapp/init-queries.ts
 import { inspect as inspect2 } from "util";
 
@@ -855,7 +996,7 @@ function withTimeout(label, promise, timeoutMs) {
 }
 
 // app/lib/whatsapp/init-queries.ts
-var TAG5 = "[whatsapp:init]";
+var TAG6 = "[whatsapp:init]";
 var DEFAULT_QUERY_TIMEOUT_MS = 15e3;
 var INSPECT_OPTS2 = {
   depth: null,
@@ -883,20 +1024,20 @@ async function runInitQueries(sock, ctx) {
     elapsedMs: 0
   };
   console.error(
-    `${TAG5} runInitQueries start account=${ctx.accountId} attempt=${ctx.attempt} selfPhone=${ctx.selfPhone ?? "unknown"} authDir=${ctx.authDir} queryTimeoutMs=${queryTimeoutMs}`
+    `${TAG6} runInitQueries start account=${ctx.accountId} attempt=${ctx.attempt} selfPhone=${ctx.selfPhone ?? "unknown"} authDir=${ctx.authDir} queryTimeoutMs=${queryTimeoutMs}`
   );
   console.error(
-    `${TAG5} fetchProps SKIPPED account=${ctx.accountId} reason=no-platform-consumer`
+    `${TAG6} fetchProps SKIPPED account=${ctx.accountId} reason=no-platform-consumer`
   );
   if (ctx.signal?.aborted) {
     result.aborted = true;
     result.elapsedMs = Date.now() - startedAt;
     console.error(
-      `${TAG5} runInitQueries aborted before start account=${ctx.accountId}`
+      `${TAG6} runInitQueries aborted before start account=${ctx.accountId}`
     );
     return result;
   }
-  console.error(`${TAG5} fetchBlocklist start account=${ctx.accountId}`);
+  console.error(`${TAG6} fetchBlocklist start account=${ctx.accountId}`);
   try {
     const blocklist = await withTimeout(
       "fetchBlocklist",
@@ -906,24 +1047,24 @@ async function runInitQueries(sock, ctx) {
     const count = Array.isArray(blocklist) ? blocklist.length : 0;
     result.blocklistOk = true;
     console.error(
-      `${TAG5} fetchBlocklist ok account=${ctx.accountId} count=${count}`
+      `${TAG6} fetchBlocklist ok account=${ctx.accountId} count=${count}`
     );
   } catch (err) {
     const formatted = formatErr(err);
     result.errors.blocklist = formatted;
     console.error(
-      `${TAG5} fetchBlocklist FAILED account=${ctx.accountId}: ${formatted}`
+      `${TAG6} fetchBlocklist FAILED account=${ctx.accountId}: ${formatted}`
     );
   }
   if (ctx.signal?.aborted) {
     result.aborted = true;
     result.elapsedMs = Date.now() - startedAt;
     console.error(
-      `${TAG5} runInitQueries aborted mid-sequence account=${ctx.accountId} after=fetchBlocklist`
+      `${TAG6} runInitQueries aborted mid-sequence account=${ctx.accountId} after=fetchBlocklist`
     );
     return result;
   }
-  console.error(`${TAG5} fetchPrivacySettings start account=${ctx.accountId}`);
+  console.error(`${TAG6} fetchPrivacySettings start account=${ctx.accountId}`);
   try {
     const settings = await withTimeout(
       "fetchPrivacySettings",
@@ -933,18 +1074,18 @@ async function runInitQueries(sock, ctx) {
     );
     result.privacySettingsOk = true;
     console.error(
-      `${TAG5} fetchPrivacySettings ok account=${ctx.accountId} keys=${settings ? Object.keys(settings).join(",") : ""}`
+      `${TAG6} fetchPrivacySettings ok account=${ctx.accountId} keys=${settings ? Object.keys(settings).join(",") : ""}`
     );
   } catch (err) {
     const formatted = formatErr(err);
     result.errors.privacySettings = formatted;
     console.error(
-      `${TAG5} fetchPrivacySettings FAILED account=${ctx.accountId}: ${formatted}`
+      `${TAG6} fetchPrivacySettings FAILED account=${ctx.accountId}: ${formatted}`
     );
   }
   result.elapsedMs = Date.now() - startedAt;
   console.error(
-    `${TAG5} runInitQueries done account=${ctx.accountId} blocklistOk=${result.blocklistOk} privacySettingsOk=${result.privacySettingsOk} elapsedMs=${result.elapsedMs}`
+    `${TAG6} runInitQueries done account=${ctx.accountId} blocklistOk=${result.blocklistOk} privacySettingsOk=${result.privacySettingsOk} elapsedMs=${result.elapsedMs}`
   );
   return result;
 }
@@ -1961,7 +2102,7 @@ function isDuplicateInbound(key) {
 }
 
 // app/lib/whatsapp/inbound/self-chat.ts
-var TAG6 = "[whatsapp:self-chat]";
+var TAG7 = "[whatsapp:self-chat]";
 function normalizeJid(jid) {
   const m = jid.match(/^(\d+)(?::\d+)?@(s\.whatsapp\.net|lid)$/i);
   return m ? `${m[1]}@${m[2].toLowerCase()}` : jid;
@@ -1981,10 +2122,10 @@ function evaluateSelfChatCommand(input) {
   const connAtMs = input.lastConnectedAtMs ?? 0;
   const msgId = input.msgId ?? "?";
   console.error(
-    `${TAG6} op=seen account=${input.accountId} msgId=${msgId} tsMs=${tsMs} connAtMs=${connAtMs} fromMe=true`
+    `${TAG7} op=seen account=${input.accountId} msgId=${msgId} tsMs=${tsMs} connAtMs=${connAtMs} fromMe=true`
   );
   const skip = (reason) => {
-    console.error(`${TAG6} op=skip account=${input.accountId} msgId=${msgId} reason=${reason}`);
+    console.error(`${TAG7} op=skip account=${input.accountId} msgId=${msgId} reason=${reason}`);
     return { kind: "skip", reason };
   };
   if (input.msgId && isAgentSentMessage(input.msgId)) return skip("echo");
@@ -1992,13 +2133,13 @@ function evaluateSelfChatCommand(input) {
   if (isDuplicateInbound(`${input.accountId}:${input.remoteJid}:${input.msgId}`)) return skip("duplicate");
   if (!input.text) return skip("no-text");
   console.error(
-    `${TAG6} op=dispatch account=${input.accountId} msgId=${msgId} bytes=${Buffer.byteLength(input.text, "utf8")} agentType=admin`
+    `${TAG7} op=dispatch account=${input.accountId} msgId=${msgId} bytes=${Buffer.byteLength(input.text, "utf8")} agentType=admin`
   );
   return { kind: "dispatch", text: input.text };
 }
 
 // app/lib/whatsapp/activity.ts
-var TAG7 = "[whatsapp:activity]";
+var TAG8 = "[whatsapp:activity]";
 var RECENT_EVENTS_MAX = 200;
 var counters = /* @__PURE__ */ new Map();
 var recentEvents = [];
@@ -2026,10 +2167,10 @@ function recordActivity(event) {
       recentEvents.splice(0, recentEvents.length - RECENT_EVENTS_MAX);
     }
     console.error(
-      `${TAG7} channel-activity: direction=${direction} account=${accountId} jid=${jid}` + (messageType ? ` type=${messageType}` : "")
+      `${TAG8} channel-activity: direction=${direction} account=${accountId} jid=${jid}` + (messageType ? ` type=${messageType}` : "")
     );
   } catch (err) {
-    console.error(`${TAG7} recording failed: ${String(err)}`);
+    console.error(`${TAG8} recording failed: ${String(err)}`);
   }
 }
 function getChannelActivity(accountId) {
@@ -2050,7 +2191,7 @@ function getChannelActivity(accountId) {
 }
 
 // app/lib/whatsapp/outbound/send.ts
-var TAG8 = "[whatsapp:outbound]";
+var TAG9 = "[whatsapp:outbound]";
 function buildQuoted(q) {
   return {
     key: {
@@ -2071,14 +2212,14 @@ async function sendTextMessage(sock, to, text, opts) {
     const messageId = result?.key?.id;
     if (messageId) {
       trackAgentSentMessage(messageId);
-      console.error(`${TAG8} sent text to=${jid} id=${messageId}`);
+      console.error(`${TAG9} sent text to=${jid} id=${messageId}`);
     }
     if (opts?.accountId) {
       recordActivity({ accountId: opts.accountId, direction: "outbound", jid, messageType: "text" });
     }
     return { success: true, messageId: messageId ?? void 0 };
   } catch (err) {
-    console.error(`${TAG8} send failed to=${to}: ${String(err)}`);
+    console.error(`${TAG9} send failed to=${to}: ${String(err)}`);
     return { success: false, error: String(err) };
   }
 }
@@ -2155,20 +2296,20 @@ async function sendMediaMessage(sock, to, media, opts) {
     const messageId = result?.key?.id;
     if (messageId) {
       trackAgentSentMessage(messageId);
-      console.error(`${TAG8} sent ${media.type} to=${jid} id=${messageId}`);
+      console.error(`${TAG9} sent ${media.type} to=${jid} id=${messageId}`);
     }
     if (opts?.accountId) {
       recordActivity({ accountId: opts.accountId, direction: "outbound", jid, messageType: media.type });
     }
     return { success: true, messageId: messageId ?? void 0 };
   } catch (err) {
-    console.error(`${TAG8} send media failed to=${to}: ${String(err)}`);
+    console.error(`${TAG9} send media failed to=${to}: ${String(err)}`);
     return { success: false, error: String(err) };
   }
 }
 
 // app/lib/whatsapp/persist-message.ts
-var TAG9 = "[whatsapp-persist]";
+var TAG10 = "[whatsapp-persist]";
 var sessionWriteLocks = /* @__PURE__ */ new Map();
 async function persistWhatsAppMessage(input) {
   if (!input.body && !input.attachmentId || !input.msgKeyId) return null;
@@ -2219,14 +2360,14 @@ async function persistWhatsAppMessage(input) {
     };
     const result = await session.run(cypher, params);
     if (result.records.length === 0) {
-      console.error(`${TAG9} skip reason=conversation-not-found accountId=${input.platformAccountId} cacheKey=${input.cacheKey} messageId=${messageId}`);
+      console.error(`${TAG10} skip reason=conversation-not-found accountId=${input.platformAccountId} cacheKey=${input.cacheKey} messageId=${messageId}`);
       return null;
     }
     const rec = result.records[0];
     const senderElementId = rec.get("senderElementId");
     const senderReused = rec.get("senderReused") === true;
     console.error(
-      `${TAG9} sender-resolved telephone=${senderTelephone} nodeKind=Person elementId=${senderElementId} reused=${senderReused}`
+      `${TAG10} sender-resolved telephone=${senderTelephone} nodeKind=Person elementId=${senderElementId} reused=${senderReused}`
     );
     const diskRecord = {
       messageId,
@@ -2252,18 +2393,18 @@ async function persistWhatsAppMessage(input) {
     const { created } = appendMessage(input.platformAccountId, diskRecord, altDedupeRemoteJids);
     const ms = Date.now() - t0;
     if (!created) {
-      console.error(`${TAG9} noop reason=existing-message messageId=${messageId}`);
+      console.error(`${TAG10} noop reason=existing-message messageId=${messageId}`);
       return { messageId, created: false, senderElementId };
     }
     console.error(
-      `${TAG9} write messageId=${messageId} accountId=${input.platformAccountId} cacheKey=${input.cacheKey} fromMe=${input.fromMe} dateSent=${dateSentIso} bodyBytes=${Buffer.byteLength(input.body, "utf8")} attachment=${input.attachmentId ?? "none"} ms=${ms}`
+      `${TAG10} write messageId=${messageId} accountId=${input.platformAccountId} cacheKey=${input.cacheKey} fromMe=${input.fromMe} dateSent=${dateSentIso} bodyBytes=${Buffer.byteLength(input.body, "utf8")} attachment=${input.attachmentId ?? "none"} ms=${ms}`
     );
     return { messageId, created: true, senderElementId };
   } catch (err) {
     const ms = Date.now() - t0;
     const reason = sanitizeReason(err);
     console.error(
-      `${TAG9} FAIL accountId=${input.platformAccountId} waname=${input.accountId} remoteJid=${input.remoteJid} msgKey=${input.msgKeyId} reason=${reason} ms=${ms}`
+      `${TAG10} FAIL accountId=${input.platformAccountId} waname=${input.accountId} remoteJid=${input.remoteJid} msgKey=${input.msgKeyId} reason=${reason} ms=${ms}`
     );
     return null;
   } finally {
@@ -2506,7 +2647,7 @@ function groupEntriesFromUpdates(updates, nowIso) {
 }
 
 // app/lib/whatsapp/ensure-conversation.ts
-var TAG10 = "[whatsapp-persist]";
+var TAG11 = "[whatsapp-persist]";
 async function ensureWhatsAppConversation(input) {
   const t0 = Date.now();
   try {
@@ -2518,19 +2659,19 @@ async function ensureWhatsAppConversation(input) {
     const ms = Date.now() - t0;
     if (!result.sessionId) {
       console.error(
-        `${TAG10} conversation-merged FAIL cacheKey=${input.cacheKey} reason=null-sessionId ms=${ms}`
+        `${TAG11} conversation-merged FAIL cacheKey=${input.cacheKey} reason=null-sessionId ms=${ms}`
       );
       return null;
     }
     console.error(
-      `${TAG10} conversation-merged cacheKey=${input.cacheKey} agentType=${input.agentType} channel=whatsapp accountId=${input.platformAccountId} connectionAccountId=${input.connectionAccountId ?? input.platformAccountId} created=${result.created} ms=${ms}`
+      `${TAG11} conversation-merged cacheKey=${input.cacheKey} agentType=${input.agentType} channel=whatsapp accountId=${input.platformAccountId} connectionAccountId=${input.connectionAccountId ?? input.platformAccountId} created=${result.created} ms=${ms}`
     );
     return { sessionId: result.sessionId, created: result.created };
   } catch (err) {
     const ms = Date.now() - t0;
     const reason = err instanceof Error ? `${err.name}:${err.message.slice(0, 200)}` : String(err).slice(0, 200);
     console.error(
-      `${TAG10} conversation-merged FAIL cacheKey=${input.cacheKey} reason=${reason} ms=${ms}`
+      `${TAG11} conversation-merged FAIL cacheKey=${input.cacheKey} reason=${reason} ms=${ms}`
     );
     return null;
   }
@@ -3103,7 +3244,7 @@ async function storeComponentArtefact(accountId, attachmentId, mimeType, content
 }
 
 // app/lib/whatsapp/inbound/media-download-guard.ts
-var TAG11 = "[media-guard]";
+var TAG12 = "[media-guard]";
 var inFlight = 0;
 var containedCount = 0;
 function containedSinceBoot() {
@@ -3133,13 +3274,13 @@ function handleEscapedMediaError(err, channel) {
   if (undiciFrame && inFlight > 0) {
     containedCount += 1;
     console.error(
-      `${TAG11} op=contained channel=${channel} inFlight=${inFlight} err=${err instanceof Error ? err.message : String(err)} cause=${causeCode(err)}
+      `${TAG12} op=contained channel=${channel} inFlight=${inFlight} err=${err instanceof Error ? err.message : String(err)} cause=${causeCode(err)}
 ${stack}`
     );
     return true;
   }
   console.error(
-    `${TAG11} op=escaped channel=${channel} inFlight=${inFlight} undiciFrame=${undiciFrame} err=${err instanceof Error ? err.message : String(err)} cause=${causeCode(err)} contained=false`
+    `${TAG12} op=escaped channel=${channel} inFlight=${inFlight} undiciFrame=${undiciFrame} err=${err instanceof Error ? err.message : String(err)} cause=${causeCode(err)} contained=false`
   );
   return false;
 }
@@ -3164,11 +3305,11 @@ function installMediaDownloadGuard() {
     );
     process.exit(1);
   });
-  console.error(`${TAG11} op=installed`);
+  console.error(`${TAG12} op=installed`);
 }
 
 // app/lib/whatsapp/inbound/media.ts
-var TAG12 = "[whatsapp:media]";
+var TAG13 = "[whatsapp:media]";
 var MEDIA_DIR = "/tmp/maxy-media";
 var DOWNLOAD_TIMEOUT_MS = 45e3;
 var DETACHED_GRACE_MS = 3e5;
@@ -3258,25 +3399,25 @@ async function downloadInboundMediaBuffer(msg, sock, opts) {
           }
         );
         if (!buffer || buffer.length === 0) {
-          console.error(`${TAG12} primary download returned empty, trying direct fallback`);
+          console.error(`${TAG13} primary download returned empty, trying direct fallback`);
           const downloadable = getDownloadableContent(content);
           if (downloadable) {
             try {
               const stream = await downloadContentFromMessage(downloadable.downloadable, downloadable.mediaType);
               buffer = await streamToBuffer(stream);
             } catch (fallbackErr) {
-              console.error(`${TAG12} direct download fallback failed: ${String(fallbackErr)}`);
+              console.error(`${TAG13} direct download fallback failed: ${String(fallbackErr)}`);
             }
           }
         }
         if (!buffer || buffer.length === 0) {
-          console.error(`${TAG12} download failed: empty buffer for ${mimetype ?? "unknown"}`);
+          console.error(`${TAG13} download failed: empty buffer for ${mimetype ?? "unknown"}`);
           return void 0;
         }
         if (buffer.length > maxBytes) {
           const sizeMB = (buffer.length / (1024 * 1024)).toFixed(1);
           const limitMB = (maxBytes / (1024 * 1024)).toFixed(0);
-          console.error(`${TAG12} media too large type=${mimetype ?? "unknown"} size=${sizeMB}MB limit=${limitMB}MB`);
+          console.error(`${TAG13} media too large type=${mimetype ?? "unknown"} size=${sizeMB}MB limit=${limitMB}MB`);
           return void 0;
         }
         return {
@@ -3290,7 +3431,7 @@ async function downloadInboundMediaBuffer(msg, sock, opts) {
     endMediaDownload();
     return settled;
   } catch (err) {
-    console.error(`${TAG12} media download failed type=${mimetype ?? "unknown"} error=${String(err)}`);
+    console.error(`${TAG13} media download failed type=${mimetype ?? "unknown"} error=${String(err)}`);
     if (isTimeoutError(err)) {
       const t = setTimeout(endMediaDownload, DETACHED_GRACE_MS);
       t.unref?.();
@@ -3308,7 +3449,7 @@ async function downloadInboundMedia(msg, sock, opts) {
   const filePath = join6(MEDIA_DIR, `${randomUUID4()}.${ext}`);
   await writeFile2(filePath, res.buffer);
   const sizeKB = (res.buffer.length / 1024).toFixed(0);
-  console.error(`${TAG12} media downloaded type=${res.mimetype} size=${sizeKB}KB path=${filePath}`);
+  console.error(`${TAG13} media downloaded type=${res.mimetype} size=${sizeKB}KB path=${filePath}`);
   return { path: filePath, mimetype: res.mimetype, size: res.buffer.length };
 }
 async function storeInboundMediaServable(msg, sock, accountId, seed, opts) {
@@ -3317,15 +3458,15 @@ async function storeInboundMediaServable(msg, sock, accountId, seed, opts) {
     if (attachmentExists(accountId, attachmentId)) return attachmentId;
     const res = await downloadInboundMediaBufferCached(msg, sock, opts);
     if (!res) {
-      console.error(`${TAG12} servable-store skip reason=no-buffer id=${attachmentId}`);
+      console.error(`${TAG13} servable-store skip reason=no-buffer id=${attachmentId}`);
       return null;
     }
     const filename = res.filename ?? `${attachmentId}.${mimeToExt(res.mimetype)}`;
     await storeMediaBuffer(accountId, attachmentId, filename, res.mimetype, res.buffer);
-    console.error(`${TAG12} servable-store ok id=${attachmentId} mime=${res.mimetype} bytes=${res.buffer.length}`);
+    console.error(`${TAG13} servable-store ok id=${attachmentId} mime=${res.mimetype} bytes=${res.buffer.length}`);
     return attachmentId;
   } catch (err) {
-    console.error(`${TAG12} servable-store FAIL id=${attachmentId} reason=${String(err).slice(0, 120)}`);
+    console.error(`${TAG13} servable-store FAIL id=${attachmentId} reason=${String(err).slice(0, 120)}`);
     return null;
   }
 }
@@ -3373,7 +3514,7 @@ function createBoundedQueue(limit, opts) {
 }
 
 // app/lib/whatsapp/inbound/debounce.ts
-var TAG13 = "[whatsapp:debounce]";
+var TAG14 = "[whatsapp:debounce]";
 var STT_TAG = "[whatsapp:stt-await]";
 function createInboundDebouncer(opts) {
   const { debounceMs, buildKey, onFlush, onError } = opts;
@@ -3404,7 +3545,7 @@ function createInboundDebouncer(opts) {
     pending.delete(key);
     const batchSize = batch.entries.length;
     try {
-      console.error(`${TAG13} debounce flush key=${key} batchSize=${batchSize}`);
+      console.error(`${TAG14} debounce flush key=${key} batchSize=${batchSize}`);
       const result = onFlush(batch.entries);
       if (result && typeof result.catch === "function") {
         result.catch(onError);
@@ -3484,7 +3625,7 @@ function combineInboundBatch(entries) {
 }
 
 // app/lib/whatsapp/opening-hours.ts
-var TAG14 = "[whatsapp:hours]";
+var TAG15 = "[whatsapp:hours]";
 async function isBusinessOpen(accountId) {
   try {
     const timezone = await resolveTimezone(accountId);
@@ -3502,7 +3643,7 @@ async function isBusinessOpen(accountId) {
         { accountId, dayOfWeek, previousDayOfWeek }
       );
       if (result.records.length === 0) {
-        console.error(`${TAG14} [${accountId}] business hours check: no opening hours configured, treating as open`);
+        console.error(`${TAG15} [${accountId}] business hours check: no opening hours configured, treating as open`);
         return { open: true, reason: "no opening hours configured" };
       }
       const specs = result.records.filter((r) => r.get("opens") != null && r.get("closes") != null).map((r) => ({
@@ -3511,7 +3652,7 @@ async function isBusinessOpen(accountId) {
         closes: String(r.get("closes")).trim()
       }));
       if (specs.length === 0) {
-        console.error(`${TAG14} [${accountId}] business hours check: no opening hours configured, treating as open`);
+        console.error(`${TAG15} [${accountId}] business hours check: no opening hours configured, treating as open`);
         return { open: true, reason: "no opening hours configured" };
       }
       for (const spec of specs) {
@@ -3521,7 +3662,7 @@ async function isBusinessOpen(accountId) {
           if (spec.opens > spec.closes && currentTime < spec.closes) {
             const hoursStr = `${spec.opens}-${spec.closes} (${spec.day})`;
             console.error(
-              `${TAG14} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
+              `${TAG15} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
             );
             return {
               open: true,
@@ -3534,7 +3675,7 @@ async function isBusinessOpen(accountId) {
         } else if (isTimeInRange(currentTime, spec.opens, spec.closes)) {
           const hoursStr = `${spec.opens}-${spec.closes}`;
           console.error(
-            `${TAG14} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
+            `${TAG15} [${accountId}] business hours check: open (day=${dayOfWeek}, time=${currentTime}, hours=${hoursStr})`
           );
           return {
             open: true,
@@ -3548,7 +3689,7 @@ async function isBusinessOpen(accountId) {
       const todaySpecs = specs.filter((s) => s.day === dayOfWeek);
       const allHours = todaySpecs.map((s) => `${s.opens}-${s.closes}`).join(", ") || "none today";
       console.error(
-        `${TAG14} [${accountId}] business hours check: closed (day=${dayOfWeek}, time=${currentTime}, hours=${allHours})`
+        `${TAG15} [${accountId}] business hours check: closed (day=${dayOfWeek}, time=${currentTime}, hours=${allHours})`
       );
       return {
         open: false,
@@ -3562,7 +3703,7 @@ async function isBusinessOpen(accountId) {
     }
   } catch (err) {
     console.error(
-      `${TAG14} [${accountId}] business hours check failed, treating as open: ${err instanceof Error ? err.message : String(err)}`
+      `${TAG15} [${accountId}] business hours check failed, treating as open: ${err instanceof Error ? err.message : String(err)}`
     );
     return { open: true, reason: "hours check failed (treating as open)" };
   }
@@ -3608,7 +3749,7 @@ import { execFile } from "child_process";
 import { unlink, stat } from "fs/promises";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var TAG15 = "[stt]";
+var TAG16 = "[stt]";
 var WHISPER_BINARY = process.env.WHISPER_BINARY ?? "/opt/whisper.cpp/build/bin/whisper-cli";
 var WHISPER_MODEL = process.env.WHISPER_MODEL ?? "/opt/whisper.cpp/models/ggml-base.bin";
 var WHISPER_TIMEOUT_MS = 20 * 60 * 1e3;
@@ -3627,11 +3768,11 @@ async function transcribe(audioPath, mimetype) {
     const s = await stat(audioPath);
     audioBytes = s.size;
   } catch {
-    console.error(`${TAG15} failed: file not readable path=${audioPath}`);
+    console.error(`${TAG16} failed: file not readable path=${audioPath}`);
     return void 0;
   }
   console.error(
-    `${TAG15} start provider=whisper-local audio_bytes=${audioBytes} mimetype=${mimetype} path=${audioPath}`
+    `${TAG16} start provider=whisper-local audio_bytes=${audioBytes} mimetype=${mimetype} path=${audioPath}`
   );
   const wavPath = audioPath.replace(/\.[^.]+$/, "") + ".wav";
   try {
@@ -3650,7 +3791,7 @@ async function transcribe(audioPath, mimetype) {
     ], { timeout: 3e4 });
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG15} failed: ffmpeg conversion error=${reason}`);
+    console.error(`${TAG16} failed: ffmpeg conversion error=${reason}`);
     return void 0;
   }
   try {
@@ -3666,20 +3807,20 @@ async function transcribe(audioPath, mimetype) {
     const durationMs = Date.now() - startMs;
     const { text, count: stripped } = stripSpecialTokens(stdout.trim());
     if (!text) {
-      console.error(`${TAG15} failed: whisper returned empty output duration_ms=${durationMs}`);
+      console.error(`${TAG16} failed: whisper returned empty output duration_ms=${durationMs}`);
       return void 0;
     }
     const langMatch = stderr.match(/auto-detected language:\s*(\w+)/);
     const language = langMatch?.[1] ?? "unknown";
     const words = text.split(/\s+/).filter(Boolean).length;
     console.error(
-      `${TAG15} done provider=whisper-local duration_ms=${durationMs} words=${words} stripped=${stripped} lang=${language}`
+      `${TAG16} done provider=whisper-local duration_ms=${durationMs} words=${words} stripped=${stripped} lang=${language}`
     );
     return { text, language, durationMs };
   } catch (err) {
     const durationMs = Date.now() - startMs;
     const reason = err instanceof Error ? err.message : String(err);
-    console.error(`${TAG15} failed provider=whisper-local duration_ms=${durationMs} error=${reason}`);
+    console.error(`${TAG16} failed provider=whisper-local duration_ms=${durationMs} error=${reason}`);
     return void 0;
   } finally {
     unlink(wavPath).catch(() => {
@@ -3698,8 +3839,9 @@ var WaReplyError = class extends Error {
 };
 
 // app/lib/whatsapp/manager.ts
-var TAG16 = "[whatsapp:manager]";
+var TAG17 = "[whatsapp:manager]";
 var MAX_RECONNECT_ATTEMPTS = 10;
+var REARM_INTERVAL_MS = 15 * 6e4;
 var MESSAGE_STORE_MAX = 500;
 var APPEND_MEDIA_CONCURRENCY = 3;
 var APPEND_MEDIA_MAX_PENDING = 24;
@@ -3751,7 +3893,7 @@ function storeMessage(storeKey, entry2) {
   if (entries.length > MESSAGE_STORE_MAX) {
     const trimmed = entries.length - MESSAGE_STORE_MAX;
     entries.splice(0, trimmed);
-    console.error(`${TAG16} message store trimmed for ${storeKey}: ${trimmed} oldest messages removed`);
+    console.error(`${TAG17} message store trimmed for ${storeKey}: ${trimmed} oldest messages removed`);
   }
 }
 function deriveCacheKey(input) {
@@ -3795,7 +3937,7 @@ function buildSelfChatDispatch(input) {
 }
 async function init(opts) {
   if (initialized) {
-    console.error(`${TAG16} already initialized`);
+    console.error(`${TAG17} already initialized`);
     return;
   }
   configDir = opts.configDir;
@@ -3805,20 +3947,20 @@ async function init(opts) {
   loadConfig(opts.accountConfig);
   const accountIds = listCredentialAccountIds(configDir);
   if (accountIds.length === 0) {
-    console.error(`${TAG16} init: no stored WhatsApp credentials found`);
+    console.error(`${TAG17} init: no stored WhatsApp credentials found`);
     initialized = true;
     return;
   }
-  console.error(`${TAG16} init: found ${accountIds.length} credentialed account(s): ${accountIds.join(", ")}`);
+  console.error(`${TAG17} init: found ${accountIds.length} credentialed account(s): ${accountIds.join(", ")}`);
   initialized = true;
   for (const accountId of accountIds) {
     const accountCfg = whatsAppConfig.accounts?.[accountId];
     if (accountCfg?.enabled === false) {
-      console.error(`${TAG16} skipping disabled account=${accountId}`);
+      console.error(`${TAG17} skipping disabled account=${accountId}`);
       continue;
     }
     startConnection(accountId).catch((err) => {
-      console.error(`${TAG16} failed to auto-start account=${accountId}: ${formatError(err)}`);
+      console.error(`${TAG17} failed to auto-start account=${accountId}: ${formatError(err)}`);
     });
   }
 }
@@ -3827,7 +3969,7 @@ async function startConnection(accountId) {
   const authDir = resolveAuthDir(configDir, accountId);
   const hasAuth = await authExists(authDir);
   if (!hasAuth) {
-    console.error(`${TAG16} no credentials for account=${accountId}`);
+    console.error(`${TAG17} no credentials for account=${accountId}`);
     return;
   }
   let platformAccountId;
@@ -3858,6 +4000,7 @@ async function startConnection(accountId) {
     selfJid: null,
     selfLid: null,
     reconnectAttempts: 0,
+    rearmAttempts: 0,
     abortController: new AbortController(),
     debouncer: null,
     lidMapping: null
@@ -3881,11 +4024,11 @@ async function stopConnection(accountId) {
       conn.sock.ev.removeAllListeners("creds.update");
       conn.sock.ws?.close?.();
     } catch (err) {
-      console.warn(`${TAG16} socket cleanup error during stop account=${accountId}: ${String(err)}`);
+      console.warn(`${TAG17} socket cleanup error during stop account=${accountId}: ${String(err)}`);
     }
   }
   connections.delete(accountId);
-  console.error(`${TAG16} stopped account=${accountId}`);
+  console.error(`${TAG17} stopped account=${accountId}`);
 }
 function getStatus() {
   return Array.from(connections.values()).map((conn) => ({
@@ -3996,6 +4139,7 @@ async function registerLoginSocket(accountId, sock, authDir) {
     selfJid: null,
     selfLid: null,
     reconnectAttempts: 0,
+    rearmAttempts: 0,
     lastConnectedAt: Date.now(),
     abortController: new AbortController(),
     debouncer: null,
@@ -4007,9 +4151,9 @@ async function registerLoginSocket(accountId, sock, authDir) {
   monitorChatMetadata(conn);
   try {
     await sock.sendPresenceUpdate("available");
-    console.error(`${TAG16} presence set to available account=${accountId}`);
+    console.error(`${TAG17} presence set to available account=${accountId}`);
   } catch (err) {
-    console.error(`${TAG16} presence update failed account=${accountId}: ${String(err)}`);
+    console.error(`${TAG17} presence update failed account=${accountId}: ${String(err)}`);
   }
   await runInitQueries(sock, {
     accountId,
@@ -4020,7 +4164,7 @@ async function registerLoginSocket(accountId, sock, authDir) {
   });
   watchForDisconnect(conn);
   attachSelfIdRefreshOnCredsUpdate(conn);
-  console.error(`${TAG16} registered login socket for account=${accountId} phone=${conn.selfPhone ?? "unknown"}`);
+  console.error(`${TAG17} registered login socket for account=${accountId} phone=${conn.selfPhone ?? "unknown"}`);
 }
 function attachSelfIdRefreshOnCredsUpdate(conn) {
   if (!conn.sock) return;
@@ -4079,7 +4223,7 @@ async function shutdown() {
   const ids = Array.from(connections.keys());
   await Promise.all(ids.map((id) => stopConnection(id)));
   initialized = false;
-  console.error(`${TAG16} shutdown complete`);
+  console.error(`${TAG17} shutdown complete`);
 }
 function loadConfig(accountConfig) {
   try {
@@ -4090,30 +4234,43 @@ function loadConfig(accountConfig) {
       if (result.ok) {
         whatsAppConfig = result.data;
         if (result.droppedKeys.length > 0) {
-          console.error(`${TAG16} config: dropped unknown keys=[${result.droppedKeys.join(",")}] preserved known config`);
+          console.error(`${TAG17} config: dropped unknown keys=[${result.droppedKeys.join(",")}] preserved known config`);
         }
       } else {
-        console.error(`${TAG16} config validation failed: ${result.error.message}`);
+        console.error(`${TAG17} config validation failed: ${result.error.message}`);
         whatsAppConfig = {};
       }
       const diskAdmin = Array.isArray(wa.adminPhones) ? wa.adminPhones : [];
       if (diskAdmin.length > 0 && (whatsAppConfig.adminPhones?.length ?? 0) === 0) {
-        console.error(`${TAG16} WARN adminPhones present on disk but empty after load`);
+        console.error(`${TAG17} WARN adminPhones present on disk but empty after load`);
       }
     }
   } catch (err) {
-    console.error(`${TAG16} config load error: ${String(err)}`);
+    console.error(`${TAG17} config load error: ${String(err)}`);
     whatsAppConfig = {};
   }
 }
+function sinceStuckMs(conn) {
+  return conn.stuckSinceMs === void 0 ? 0 : Date.now() - conn.stuckSinceMs;
+}
+function clearStuck(conn) {
+  if (!conn.sessionStuckReason) return;
+  console.error(
+    `${HEALTH_TAG} op=rearm account=${conn.accountId} attempt=${conn.rearmAttempts} sinceStuckMs=${sinceStuckMs(conn)} outcome=connected`
+  );
+  conn.sessionStuckReason = void 0;
+  conn.stuckSinceMs = void 0;
+  conn.rearmAttempts = 0;
+}
 async function connectWithReconnect(conn) {
   const maxAttempts = MAX_RECONNECT_ATTEMPTS;
   while (!conn.abortController.signal.aborted) {
     let uptimeMs = 0;
     let cycleError = null;
     let connectedAt;
+    let heldTimer;
     try {
-      console.error(`${TAG16} connecting account=${conn.accountId} attempt=${conn.reconnectAttempts}`);
+      console.error(`${TAG17} connecting account=${conn.accountId} attempt=${conn.reconnectAttempts}`);
       if (conn.debouncer) {
         await conn.debouncer.destroy();
         conn.debouncer = null;
@@ -4127,7 +4284,7 @@ async function connectWithReconnect(conn) {
       applySelfIdentity(conn, sock, "pre-listener");
       monitorInbound(conn);
       monitorChatMetadata(conn);
-      console.error(`${TAG16} socket created account=${conn.accountId} \u2014 waiting for connection`);
+      console.error(`${TAG17} socket created account=${conn.accountId} \u2014 waiting for connection`);
       await waitForConnection(sock);
       connectedAt = Date.now();
       conn.connected = true;
@@ -4135,12 +4292,19 @@ async function connectWithReconnect(conn) {
       conn.lastError = void 0;
       conn.terminalReason = void 0;
       applySelfIdentity(conn, sock, "post-connect");
-      console.error(`${TAG16} connected account=${conn.accountId} phone=${conn.selfPhone ?? "unknown"}`);
+      console.error(`${TAG17} connected account=${conn.accountId} phone=${conn.selfPhone ?? "unknown"}`);
+      if (conn.sessionStuckReason) {
+        heldTimer = setTimeout(() => {
+          if (!conn.connected || connections.get(conn.accountId) !== conn) return;
+          clearStuck(conn);
+        }, STABLE_UPTIME_MS);
+        if (typeof heldTimer.unref === "function") heldTimer.unref();
+      }
       try {
         await sock.sendPresenceUpdate("available");
-        console.error(`${TAG16} presence set to available account=${conn.accountId}`);
+        console.error(`${TAG17} presence set to available account=${conn.accountId}`);
       } catch (err) {
-        console.error(`${TAG16} presence update failed account=${conn.accountId}: ${String(err)}`);
+        console.error(`${TAG17} presence update failed account=${conn.accountId}: ${String(err)}`);
       }
       await runInitQueries(sock, {
         accountId: conn.accountId,
@@ -4163,13 +4327,20 @@ async function connectWithReconnect(conn) {
       }
       const classification = classifyDisconnect(err);
       conn.lastError = classification.message;
-      console.error(`${TAG16} disconnect account=${conn.accountId}: ${classification.kind} \u2014 ${classification.message}`);
+      console.error(`${TAG17} disconnect account=${conn.accountId}: ${classification.kind} \u2014 ${classification.message}`);
       if (!classification.shouldRetry) {
         conn.terminalReason = classification.message;
-        console.error(`${TAG16} terminal disconnect for account=${conn.accountId}, stopping reconnection`);
+        if (conn.sessionStuckReason) {
+          console.error(
+            `${HEALTH_TAG} op=rearm account=${conn.accountId} attempt=${conn.rearmAttempts} sinceStuckMs=${sinceStuckMs(conn)} outcome=skipped-terminal`
+          );
+        }
+        console.error(`${TAG17} terminal disconnect for account=${conn.accountId}, stopping reconnection`);
+        if (heldTimer !== void 0) clearTimeout(heldTimer);
         return;
       }
     }
+    if (heldTimer !== void 0) clearTimeout(heldTimer);
     const decision = computeReconnectNextState({
       reconnectAttempts: conn.reconnectAttempts,
       uptimeMs,
@@ -4177,28 +4348,44 @@ async function connectWithReconnect(conn) {
       maxAttempts
     });
     if (decision.action === "abort") {
-      const stuckReason = `GIVING UP account=${conn.accountId} attempts=${decision.finalAttempts}/${maxAttempts} uptimeMsLast=${uptimeMs} stableThresholdMs=${STABLE_UPTIME_MS} lastError=${conn.lastError ?? "(none)"}`;
+      const stuckReason = `RETRYING SLOWLY account=${conn.accountId} attempts=${decision.finalAttempts}/${maxAttempts} rearmIntervalMs=${REARM_INTERVAL_MS} uptimeMsLast=${uptimeMs} stableThresholdMs=${STABLE_UPTIME_MS} lastError=${conn.lastError ?? "(none)"}`;
+      if (conn.rearmAttempts > 0) {
+        console.error(
+          `${HEALTH_TAG} op=rearm account=${conn.accountId} attempt=${conn.rearmAttempts} sinceStuckMs=${sinceStuckMs(conn)} outcome=failed`
+        );
+      }
       console.error(
-        `${TAG16} ${stuckReason} \u2014 re-pair via QR or restart required; WhatsApp will not reconnect automatically`
+        `${TAG17} ${stuckReason} \u2014 re-arming in ${REARM_INTERVAL_MS}ms and every ${REARM_INTERVAL_MS}ms after; a re-pair via QR ends the wait sooner`
       );
       conn.sessionStuckReason = stuckReason;
       conn.lastError = stuckReason;
-      return;
+      if (conn.stuckSinceMs === void 0) conn.stuckSinceMs = Date.now();
+      await new Promise((resolve6) => {
+        const timer = setTimeout(resolve6, REARM_INTERVAL_MS);
+        conn.abortController.signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          resolve6();
+        }, { once: true });
+      });
+      if (conn.abortController.signal.aborted) return;
+      conn.rearmAttempts += 1;
+      continue;
     }
     conn.reconnectAttempts = decision.nextAttempts;
     if (decision.reason === "short-lived") {
       console.error(
-        `${TAG16} short-lived session account=${conn.accountId} uptimeMs=${uptimeMs} attempt=${decision.nextAttempts}/${maxAttempts} lastError=${conn.lastError ?? "(clean disconnect)"}`
+        `${TAG17} short-lived session account=${conn.accountId} uptimeMs=${uptimeMs} attempt=${decision.nextAttempts}/${maxAttempts} lastError=${conn.lastError ?? "(clean disconnect)"}`
       );
     } else {
+      clearStuck(conn);
       console.error(
-        `${TAG16} session stable account=${conn.accountId} uptimeMs=${uptimeMs} \u2014 reconnect counter reset`
+        `${TAG17} session stable account=${conn.accountId} uptimeMs=${uptimeMs} \u2014 reconnect counter reset`
       );
     }
     if (decision.reason === "short-lived" || cycleError) {
       const delay = computeBackoff(Math.max(1, decision.nextAttempts));
       console.error(
-        `${TAG16} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
+        `${TAG17} reconnecting account=${conn.accountId} in ${delay}ms (attempt ${decision.nextAttempts}/${maxAttempts})`
       );
       await new Promise((resolve6) => {
         const timer = setTimeout(resolve6, delay);
@@ -4232,11 +4419,11 @@ function watchForDisconnect(conn) {
   conn.sock.ev.on("connection.update", (update) => {
     if (update.connection === "close") {
       if (connections.get(conn.accountId) !== conn) return;
-      console.error(`${TAG16} socket disconnected for account=${conn.accountId}`);
+      console.error(`${TAG17} socket disconnected for account=${conn.accountId}`);
       conn.connected = false;
       conn.sock = null;
       connectWithReconnect(conn).catch((err) => {
-        console.error(`${TAG16} reconnection failed for account=${conn.accountId}: ${formatError(err)}`);
+        console.error(`${TAG17} reconnection failed for account=${conn.accountId}: ${formatError(err)}`);
       });
     }
   });
@@ -4271,7 +4458,7 @@ function monitorChatMetadata(conn) {
       }
       const { canonical, resolved } = await resolveCanonicalConversationJid(e.jid, conn.lidMapping);
       if (resolved === "lid2pn") {
-        console.error(`${TAG16} [wa-chatmeta] op=canonical raw=${e.jid} canonical=${canonical}`);
+        console.error(`${TAG17} [wa-chatmeta] op=canonical raw=${e.jid} canonical=${canonical}`);
         out.push({ ...e, jid: canonical });
       } else {
         out.push(e);
@@ -4284,13 +4471,13 @@ function monitorChatMetadata(conn) {
     if (perJid) {
       for (const e of entries) {
         console.error(
-          `${TAG16} [wa-chatmeta] op=event kind=${kind} jid=${e.jid} name=${e.name.length} source=${e.source}`
+          `${TAG17} [wa-chatmeta] op=event kind=${kind} jid=${e.jid} name=${e.name.length} source=${e.source}`
         );
       }
     }
     const total = writeChatMetadataMerged(account, entries);
     console.error(
-      `${TAG16} [wa-chatmeta] op=persist kind=${kind} account=${account.slice(0, 8)} updates=${entries.length} outcome=${total < 0 ? "fail" : "ok"} entries=${total}`
+      `${TAG17} [wa-chatmeta] op=persist kind=${kind} account=${account.slice(0, 8)} updates=${entries.length} outcome=${total < 0 ? "fail" : "ok"} entries=${total}`
     );
   };
   sock.ev.on("messaging-history.set", ({ chats, contacts }) => {
@@ -4298,7 +4485,7 @@ function monitorChatMetadata(conn) {
     const chatEntries = chatEntriesFromChats(chats ?? [], nowIso);
     const contactEntries = chatEntriesFromContacts(contacts ?? [], nowIso);
     console.error(
-      `${TAG16} [wa-chatmeta] op=history-set account=${account.slice(0, 8)} chats=${chats?.length ?? 0} contacts=${contacts?.length ?? 0} groups=${chatEntries.filter((e) => e.isGroup).length} named=${chatEntries.length + contactEntries.length}`
+      `${TAG17} [wa-chatmeta] op=history-set account=${account.slice(0, 8)} chats=${chats?.length ?? 0} contacts=${contacts?.length ?? 0} groups=${chatEntries.filter((e) => e.isGroup).length} named=${chatEntries.length + contactEntries.length}`
     );
     void canonicalise([...chatEntries, ...contactEntries]).then((e) => persist("history-set", e, false));
   });
@@ -4329,7 +4516,7 @@ function monitorChatMetadata(conn) {
       try {
         const meta = await sock.groupMetadata(jid);
         console.error(
-          `${TAG16} [wa-chatmeta] op=group-fetch jid=${jid} ms=${Date.now() - startedAt} outcome=ok`
+          `${TAG17} [wa-chatmeta] op=group-fetch jid=${jid} ms=${Date.now() - startedAt} outcome=ok`
         );
         persist(
           "group-fetch",
@@ -4338,7 +4525,7 @@ function monitorChatMetadata(conn) {
         );
       } catch (err) {
         console.error(
-          `${TAG16} [wa-chatmeta] op=group-fetch jid=${jid} ms=${Date.now() - startedAt} outcome=fail reason=${(err instanceof Error ? err.message : String(err)).slice(0, 100)}`
+          `${TAG17} [wa-chatmeta] op=group-fetch jid=${jid} ms=${Date.now() - startedAt} outcome=fail reason=${(err instanceof Error ? err.message : String(err)).slice(0, 100)}`
         );
       }
     }
@@ -4351,7 +4538,7 @@ function monitorInbound(conn) {
   if (!conn.sock || !onInboundMessage) return;
   const sock = conn.sock;
   const debounceMs = whatsAppConfig.accounts?.[conn.accountId]?.debounceMs ?? whatsAppConfig.debounceMs ?? 0;
-  console.error(`${TAG16} monitorInbound started account=${conn.accountId} debounceMs=${debounceMs}`);
+  console.error(`${TAG17} monitorInbound started account=${conn.accountId} debounceMs=${debounceMs}`);
   conn.debouncer = createInboundDebouncer({
     debounceMs,
     buildKey: (payload) => {
@@ -4361,12 +4548,12 @@ function monitorInbound(conn) {
     onFlush: (entries) => {
       if (!onInboundMessage) return;
       if (entries.length > 1) {
-        console.error(`${TAG16} debounce: combining ${entries.length} messages account=${conn.accountId} from=${entries[0].senderPhone}`);
+        console.error(`${TAG17} debounce: combining ${entries.length} messages account=${conn.accountId} from=${entries[0].senderPhone}`);
       }
       dispatchInboundPayload(conn, combineInboundBatch(entries));
     },
     onError: (err) => {
-      console.error(`${TAG16} debounce flush error account=${conn.accountId}: ${String(err)}`);
+      console.error(`${TAG17} debounce flush error account=${conn.accountId}: ${String(err)}`);
     }
   });
   sock.ev.on("messages.upsert", async (upsert) => {
@@ -4479,7 +4666,7 @@ function monitorInbound(conn) {
           }
           const entries = messageStore.get(storeKey);
           console.error(
-            `${TAG16} stored message ${msg.key.id ?? "?"} for ${remoteJid} (type: ${upsert.type}, store size: ${entries?.length ?? 0}/${MESSAGE_STORE_MAX}) storeAccount=${persistAccountId} socketOwner=${conn.platformAccountId}`
+            `${TAG17} stored message ${msg.key.id ?? "?"} for ${remoteJid} (type: ${upsert.type}, store size: ${entries?.length ?? 0}/${MESSAGE_STORE_MAX}) storeAccount=${persistAccountId} socketOwner=${conn.platformAccountId}`
           );
           recordActivity({
             accountId: conn.accountId,
@@ -4533,7 +4720,7 @@ function monitorInbound(conn) {
               const wantsServableMedia = mediaServable && !!conn.sock && (!fromMe || !alreadyRecorded);
               if (fromMe && mediaServable && !!conn.sock) {
                 console.error(
-                  `${TAG16} fromMe-media-echo msgKey=${msg.key.id} decision=${alreadyRecorded ? "skip" : "store"} reason=${alreadyRecorded ? "already-recorded" : "no-prior-record"}`
+                  `${TAG17} fromMe-media-echo msgKey=${msg.key.id} decision=${alreadyRecorded ? "skip" : "store"} reason=${alreadyRecorded ? "already-recorded" : "no-prior-record"}`
                 );
               }
               const mediaSeed = `whatsapp-live:${conn.accountId}:${canonicalRemoteJid}:${msg.key.id}`;
@@ -4616,7 +4803,7 @@ function monitorInbound(conn) {
                 receiptDeferredToWorker = true;
                 if (!accepted) {
                   console.error(
-                    `${TAG16} append-media overflow account=${conn.platformAccountId} msgKey=${msgKeyId ?? "?"} \u2014 pending cap ${APPEND_MEDIA_MAX_PENDING} reached, text-fallback persist, inline media shed`
+                    `${TAG17} append-media overflow account=${conn.platformAccountId} msgKey=${msgKeyId ?? "?"} \u2014 pending cap ${APPEND_MEDIA_MAX_PENDING} reached, text-fallback persist, inline media shed`
                   );
                   const persisted = await persistWhatsAppMessage({
                     ...basePersist,
@@ -4693,13 +4880,13 @@ function monitorInbound(conn) {
           const skippedSenderJid = isGroupJid(remoteJid) ? msg.key.participant ?? remoteJid : remoteJid;
           const skippedSenderPhone = await resolveJidToE164(skippedSenderJid, conn.lidMapping) ?? skippedSenderJid;
           console.error(
-            `${TAG16} append-type message ${msg.key.id ?? "?"} dispatch skipped from=${skippedSenderPhone}${msg.pushName ? ` name=${msg.pushName}` : ""} account=${conn.accountId} (persistence not confirmed here)`
+            `${TAG17} append-type message ${msg.key.id ?? "?"} dispatch skipped from=${skippedSenderPhone}${msg.pushName ? ` name=${msg.pushName}` : ""} account=${conn.accountId} (persistence not confirmed here)`
           );
           continue;
         }
         await handleInboundMessage(conn, msg);
       } catch (err) {
-        console.error(`${TAG16} inbound handler error account=${conn.accountId}: ${String(err)}`);
+        console.error(`${TAG17} inbound handler error account=${conn.accountId}: ${String(err)}`);
       }
     }
   });
@@ -4755,31 +4942,31 @@ async function handleInboundMessage(conn, msg) {
   const remoteJid = msg.key.remoteJid;
   if (!remoteJid) return;
   if (remoteJid === "status@broadcast") {
-    console.error(`${TAG16} drop: status broadcast account=${conn.accountId}`);
+    console.error(`${TAG17} drop: status broadcast account=${conn.accountId}`);
     return;
   }
   if (!msg.message) {
-    console.error(`${TAG16} drop: empty message account=${conn.accountId} from=${remoteJid}`);
+    console.error(`${TAG17} drop: empty message account=${conn.accountId} from=${remoteJid}`);
     return;
   }
   const dedupKey = `${conn.accountId}:${remoteJid}:${msg.key.id}`;
   if (isDuplicateInbound(dedupKey)) {
-    console.error(`${TAG16} drop: duplicate account=${conn.accountId} key=${dedupKey}`);
+    console.error(`${TAG17} drop: duplicate account=${conn.accountId} key=${dedupKey}`);
     return;
   }
   if (msg.key.fromMe) {
     if (msg.key.id && isAgentSentMessage(msg.key.id)) {
-      console.error(`${TAG16} drop: echo suppression account=${conn.accountId} msgId=${msg.key.id}`);
+      console.error(`${TAG17} drop: echo suppression account=${conn.accountId} msgId=${msg.key.id}`);
       return;
     }
     const extracted2 = extractMessage(msg);
     if (!extracted2.text) {
-      console.error(`${TAG16} owner reply skipped \u2014 no text content account=${conn.accountId}`);
+      console.error(`${TAG17} owner reply skipped \u2014 no text content account=${conn.accountId}`);
       return;
     }
     const isGroup2 = isGroupJid(remoteJid);
     const senderPhone2 = conn.selfPhone ?? "owner";
-    console.error(`${TAG16} owner reply mirrored to session from=${senderPhone2} account=${conn.accountId}`);
+    console.error(`${TAG17} owner reply mirrored to session from=${senderPhone2} account=${conn.accountId}`);
     const reply2 = async (text) => {
       const currentSock = conn.sock;
       if (!currentSock) throw new Error("WhatsApp disconnected \u2014 cannot reply");
@@ -4813,7 +5000,7 @@ async function handleInboundMessage(conn, msg) {
   }
   const extracted = extractMessage(msg);
   if (!extracted.text && !extracted.mediaType) {
-    console.error(`${TAG16} drop: no text or media account=${conn.accountId} from=${remoteJid}`);
+    console.error(`${TAG17} drop: no text or media account=${conn.accountId} from=${remoteJid}`);
     return;
   }
   const isGroup = isGroupJid(remoteJid);
@@ -4837,7 +5024,7 @@ async function handleInboundMessage(conn, msg) {
     });
   }
   console.error(
-    `${TAG16} inbound account=${conn.accountId} from=${senderPhone} group=${isGroup} access=${accessResult.allowed ? "allowed" : "blocked"}(${accessResult.reason}) agent=${accessResult.agentType}` + (extracted.mediaType ? ` media=${extracted.mediaType}` : "") + (extracted.quotedMessage ? ` replyTo=${extracted.quotedMessage.id}` : "")
+    `${TAG17} inbound account=${conn.accountId} from=${senderPhone} group=${isGroup} access=${accessResult.allowed ? "allowed" : "blocked"}(${accessResult.reason}) agent=${accessResult.agentType}` + (extracted.mediaType ? ` media=${extracted.mediaType}` : "") + (extracted.quotedMessage ? ` replyTo=${extracted.quotedMessage.id}` : "")
   );
   if (!accessResult.allowed && accessResult.reason === "account-manager-unresolved") {
     console.error(
@@ -4874,7 +5061,7 @@ async function handleInboundMessage(conn, msg) {
       maxBytes: maxMb * 1024 * 1024
     });
     if (!mediaResult) {
-      console.error(`${TAG16} media download returned undefined account=${conn.accountId} type=${extracted.mediaType} from=${remoteJid}`);
+      console.error(`${TAG17} media download returned undefined account=${conn.accountId} type=${extracted.mediaType} from=${remoteJid}`);
     }
   }
   if (extracted.mediaType === "audio" && mediaResult?.path) {
@@ -4896,7 +5083,7 @@ async function handleInboundMessage(conn, msg) {
   }
   const reply = async (text) => {
     if (isGroupJid(remoteJid)) {
-      console.error(`${TAG16} op=group-reply-blocked jid=${remoteJid}`);
+      console.error(`${TAG17} op=group-reply-blocked jid=${remoteJid}`);
       throw new WaReplyError("group reply blocked \u2014 observe-only", false);
     }
     const currentSock = conn.sock;
@@ -4943,15 +5130,15 @@ async function handleInboundMessage(conn, msg) {
   if (accessResult.agentType === "public") {
     const hoursResult = await isBusinessOpen(conn.accountId);
     if (!hoursResult.open) {
-      console.error(`${TAG16} [${conn.accountId}] dispatch skipped: business closed`);
+      console.error(`${TAG17} [${conn.accountId}] dispatch skipped: business closed`);
       const afterHoursMessage = whatsAppConfig.accounts?.[conn.accountId]?.afterHoursMessage ?? whatsAppConfig.afterHoursMessage;
       if (afterHoursMessage) {
         try {
           await reply(afterHoursMessage);
-          console.error(`${TAG16} [${conn.accountId}] after-hours auto-reply sent to ${remoteJid}`);
+          console.error(`${TAG17} [${conn.accountId}] after-hours auto-reply sent to ${remoteJid}`);
         } catch (err) {
           console.error(
-            `${TAG16} [${conn.accountId}] after-hours auto-reply failed: ${err instanceof Error ? err.message : String(err)}`
+            `${TAG17} [${conn.accountId}] after-hours auto-reply failed: ${err instanceof Error ? err.message : String(err)}`
           );
         }
       }
@@ -5000,6 +5187,7 @@ export {
   getAuthAgeMs,
   clearAuth,
   discardAuthDirSync,
+  startVersionDriftCensus,
   drainCredsSaveQueue,
   createWaSocket,
   waitForConnection,
@@ -5007,6 +5195,8 @@ export {
   formatError,
   closeKind,
   classifyDisconnect,
+  LINK_CENSUS_INTERVAL_MS,
+  runLinkCensus,
   normalizeE164,
   toWhatsappJid,
   jidToE164,