@rubytech/create-sitedesk-code 0.1.521 → 0.1.523

package/payload/server/{chunk-AZLT4LVO.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";
@@ -332,32 +344,32 @@ function ledgerFilePath(account) {
   }
   return join(root, `${account}.jsonl`);
 }
-function appendStanza(entry) {
+function appendStanza(entry2) {
   try {
     const row = {
-      msgId: entry.msgId,
-      from: entry.from,
-      type: entry.type,
+      msgId: entry2.msgId,
+      from: entry2.from,
+      type: entry2.type,
       ts: (/* @__PURE__ */ new Date()).toISOString()
     };
-    appendFileSync(ledgerFilePath(entry.account), JSON.stringify(row) + "\n");
+    appendFileSync(ledgerFilePath(entry2.account), JSON.stringify(row) + "\n");
   } catch (err) {
     console.error(
-      `${TAG3} FAIL op=append msgId=${entry.msgId} err=${err instanceof Error ? err.message : String(err)}`
+      `${TAG3} FAIL op=append msgId=${entry2.msgId} err=${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
-function markDeclined(entry) {
+function markDeclined(entry2) {
   try {
     const row = {
-      declined: entry.msgId,
-      reason: entry.reason,
+      declined: entry2.msgId,
+      reason: entry2.reason,
       ts: (/* @__PURE__ */ new Date()).toISOString()
     };
-    appendFileSync(ledgerFilePath(entry.account), JSON.stringify(row) + "\n");
+    appendFileSync(ledgerFilePath(entry2.account), JSON.stringify(row) + "\n");
   } catch (err) {
     console.error(
-      `${TAG3} FAIL op=decline msgId=${entry.msgId} err=${err instanceof Error ? err.message : String(err)}`
+      `${TAG3} FAIL op=decline msgId=${entry2.msgId} err=${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
@@ -375,36 +387,36 @@ function readDeclined(account) {
   }
   return out;
 }
-function appendNotifyEligible(entry) {
+function appendNotifyEligible(entry2) {
   try {
     const row = {
-      notifyEligible: entry.msgId,
-      upsertType: entry.upsertType,
-      fromMe: entry.fromMe,
-      allowed: entry.allowed,
-      reason: entry.reason,
-      passive: entry.passive,
-      persistAccount: entry.persistAccount,
+      notifyEligible: entry2.msgId,
+      upsertType: entry2.upsertType,
+      fromMe: entry2.fromMe,
+      allowed: entry2.allowed,
+      reason: entry2.reason,
+      passive: entry2.passive,
+      persistAccount: entry2.persistAccount,
       ts: (/* @__PURE__ */ new Date()).toISOString()
     };
-    appendFileSync(ledgerFilePath(entry.account), JSON.stringify(row) + "\n");
+    appendFileSync(ledgerFilePath(entry2.account), JSON.stringify(row) + "\n");
   } catch (err) {
     console.error(
-      `${TAG3} FAIL op=append-notify-eligible msgId=${entry.msgId} err=${err instanceof Error ? err.message : String(err)}`
+      `${TAG3} FAIL op=append-notify-eligible msgId=${entry2.msgId} err=${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
-function appendNotifyPublished(entry) {
+function appendNotifyPublished(entry2) {
   try {
     const row = {
-      notifyPublished: entry.msgId,
-      subscribers: entry.subscribers,
+      notifyPublished: entry2.msgId,
+      subscribers: entry2.subscribers,
       ts: (/* @__PURE__ */ new Date()).toISOString()
     };
-    appendFileSync(ledgerFilePath(entry.account), JSON.stringify(row) + "\n");
+    appendFileSync(ledgerFilePath(entry2.account), JSON.stringify(row) + "\n");
   } catch (err) {
     console.error(
-      `${TAG3} FAIL op=append-notify-published msgId=${entry.msgId} err=${err instanceof Error ? err.message : String(err)}`
+      `${TAG3} FAIL op=append-notify-published msgId=${entry2.msgId} err=${err instanceof Error ? err.message : String(err)}`
     );
   }
 }
@@ -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;
 }
@@ -1218,16 +1359,16 @@ function toMillis(v) {
   if (typeof v.low === "number") return (v.low >>> 0) + (v.high ?? 0) * 4294967296;
   return null;
 }
-function readReactionEntry(entry) {
-  const targetMsgKeyId = entry.key?.id ?? void 0;
+function readReactionEntry(entry2) {
+  const targetMsgKeyId = entry2.key?.id ?? void 0;
   if (!targetMsgKeyId) return null;
-  const chatJid = entry.key?.remoteJid ?? entry.reaction?.key?.remoteJid ?? void 0;
+  const chatJid = entry2.key?.remoteJid ?? entry2.reaction?.key?.remoteJid ?? void 0;
   if (!chatJid) return null;
   const isGroup = isGroupJid(chatJid);
-  const reactorKey = entry.reaction?.key;
+  const reactorKey = entry2.reaction?.key;
   const reactorJid = isGroup ? reactorKey?.participant ?? void 0 : reactorKey?.remoteJid ?? chatJid;
   if (!reactorJid) return null;
-  const emoji = entry.reaction?.text ?? "";
+  const emoji = entry2.reaction?.text ?? "";
   return {
     targetMsgKeyId,
     chatJid,
@@ -1236,7 +1377,7 @@ function readReactionEntry(entry) {
     emoji,
     removed: !emoji,
     fromMe: !!reactorKey?.fromMe,
-    timestampMs: toMillis(entry.reaction?.senderTimestampMs)
+    timestampMs: toMillis(entry2.reaction?.senderTimestampMs)
   };
 }
 
@@ -1381,7 +1522,7 @@ function summariseRecords(records) {
   return {
     first: sorted[0],
     last: sorted[sorted.length - 1],
-    firstNamedSender: sorted.find((r) => r.senderName)?.senderName ?? null
+    firstNamedSender: sorted.find((r) => !r.fromMe && r.senderName)?.senderName ?? null
   };
 }
 function readConversationSummaries(platformAccountId) {
@@ -1393,10 +1534,10 @@ function readConversationSummaries(platformAccountId) {
   let bytesRead = 0;
   try {
     if (!existsSync3(dir)) return out;
-    for (const entry of readdirSync2(dir)) {
-      if (!entry.endsWith(".jsonl")) continue;
-      const remoteJid = entry.slice(0, -".jsonl".length);
-      const file = join2(dir, entry);
+    for (const entry2 of readdirSync2(dir)) {
+      if (!entry2.endsWith(".jsonl")) continue;
+      const remoteJid = entry2.slice(0, -".jsonl".length);
+      const file = join2(dir, entry2);
       seen.add(file);
       let size;
       let mtimeMs;
@@ -1445,9 +1586,9 @@ function readAllConversations(platformAccountId) {
   const out = /* @__PURE__ */ new Map();
   try {
     if (!existsSync3(dir)) return out;
-    for (const entry of readdirSync2(dir)) {
-      if (!entry.endsWith(".jsonl")) continue;
-      const remoteJid = entry.slice(0, -".jsonl".length);
+    for (const entry2 of readdirSync2(dir)) {
+      if (!entry2.endsWith(".jsonl")) continue;
+      const remoteJid = entry2.slice(0, -".jsonl".length);
       out.set(remoteJid, readConversation(platformAccountId, remoteJid));
     }
   } catch (err) {
@@ -1468,16 +1609,16 @@ function normalizeEntry(v) {
   return typeof v === "string" ? { account: v, mode: "active" } : { account: v.managesAccount, mode: v.mode ?? "active" };
 }
 function managedAccountFor(accountManagers, phone) {
-  for (const [managerPhone, entry] of Object.entries(accountManagers)) {
-    const { account, mode } = normalizeEntry(entry);
+  for (const [managerPhone, entry2] of Object.entries(accountManagers)) {
+    const { account, mode } = normalizeEntry(entry2);
     if (account && phonesMatch(managerPhone, phone)) return { account, mode };
   }
   return null;
 }
 function managerPhonesForAccount(accountManagers, subAccountId) {
   const phones = [];
-  for (const [managerPhone, entry] of Object.entries(accountManagers)) {
-    const { account } = normalizeEntry(entry);
+  for (const [managerPhone, entry2] of Object.entries(accountManagers)) {
+    const { account } = normalizeEntry(entry2);
     if (account && account === subAccountId) phones.push(managerPhone);
   }
   return phones;
@@ -1498,7 +1639,7 @@ function resolveAccountConfig(config, accountConfig) {
 function isAdminPhone(phone, adminPhones) {
   const normalized = normalizeE164(phone);
   if (!normalized) return false;
-  return adminPhones.some((entry) => phonesMatch(entry, normalized));
+  return adminPhones.some((entry2) => phonesMatch(entry2, normalized));
 }
 function checkDmAccess(params) {
   const { senderPhone, selfPhone, accountId } = params;
@@ -1520,9 +1661,9 @@ function checkDmAccess(params) {
     case "open":
       return { allowed: true, reason: "dm-policy-open", agentType: "public", effectiveAccountId: accountId };
     case "allowlist": {
-      const inList = cfg.allowFrom.some((entry) => {
-        if (entry === "*") return true;
-        return phonesMatch(entry, senderPhone);
+      const inList = cfg.allowFrom.some((entry2) => {
+        if (entry2 === "*") return true;
+        return phonesMatch(entry2, senderPhone);
       });
       if (inList) {
         return { allowed: true, reason: "allowlist-match", agentType: "public", effectiveAccountId: accountId };
@@ -1597,8 +1738,8 @@ var NOTIFY_MAX = 5e3;
 var notifyCache = /* @__PURE__ */ new Map();
 function isNotifyDuplicate(msgKeyId) {
   const now = Date.now();
-  const entry = notifyCache.get(msgKeyId);
-  if (entry && now - entry.ts <= NOTIFY_TTL_MS) return true;
+  const entry2 = notifyCache.get(msgKeyId);
+  if (entry2 && now - entry2.ts <= NOTIFY_TTL_MS) return true;
   for (const [key, e] of notifyCache) {
     if (now - e.ts > NOTIFY_TTL_MS) notifyCache.delete(key);
   }
@@ -1675,15 +1816,15 @@ var ACCESS_LOCKOUT_MS = 15 * 60 * 1e3;
 var ACCESS_WINDOW_MS = 15 * 60 * 1e3;
 function checkAccessRateLimit(ip, agentSlug) {
   const key = `${ip}:${agentSlug}`;
-  const entry = rateLimitMap.get(key);
-  if (!entry) return null;
+  const entry2 = rateLimitMap.get(key);
+  if (!entry2) return null;
   const now = Date.now();
-  if (entry.lockedUntil && now < entry.lockedUntil) {
-    const remainingMs = entry.lockedUntil - now;
+  if (entry2.lockedUntil && now < entry2.lockedUntil) {
+    const remainingMs = entry2.lockedUntil - now;
     const remainingS = Math.ceil(remainingMs / 1e3);
     return `Too many attempts. Try again in ${remainingS}s`;
   }
-  if (now - entry.firstAttempt > ACCESS_WINDOW_MS) {
+  if (now - entry2.firstAttempt > ACCESS_WINDOW_MS) {
     rateLimitMap.delete(key);
     return null;
   }
@@ -1692,14 +1833,14 @@ function checkAccessRateLimit(ip, agentSlug) {
 function recordAccessFailedAttempt(ip, agentSlug) {
   const key = `${ip}:${agentSlug}`;
   const now = Date.now();
-  const entry = rateLimitMap.get(key);
-  if (!entry || now - entry.firstAttempt > ACCESS_WINDOW_MS) {
+  const entry2 = rateLimitMap.get(key);
+  if (!entry2 || now - entry2.firstAttempt > ACCESS_WINDOW_MS) {
     rateLimitMap.set(key, { attempts: 1, firstAttempt: now });
     return;
   }
-  entry.attempts++;
-  if (entry.attempts >= ACCESS_MAX_ATTEMPTS) {
-    entry.lockedUntil = now + ACCESS_LOCKOUT_MS;
+  entry2.attempts++;
+  if (entry2.attempts >= ACCESS_MAX_ATTEMPTS) {
+    entry2.lockedUntil = now + ACCESS_LOCKOUT_MS;
   }
 }
 function clearAccessRateLimit(ip, agentSlug) {
@@ -1709,15 +1850,15 @@ var contactRateMap = /* @__PURE__ */ new Map();
 var REQUEST_LINK_MAX = 3;
 var REQUEST_LINK_WINDOW_MS = 60 * 60 * 1e3;
 function checkRequestLinkRateLimit(contactValue) {
-  const entry = contactRateMap.get(contactValue);
-  if (!entry) return null;
+  const entry2 = contactRateMap.get(contactValue);
+  if (!entry2) return null;
   const now = Date.now();
-  if (now - entry.windowStart > REQUEST_LINK_WINDOW_MS) {
+  if (now - entry2.windowStart > REQUEST_LINK_WINDOW_MS) {
     contactRateMap.delete(contactValue);
     return null;
   }
-  if (entry.count >= REQUEST_LINK_MAX) {
-    const remainingMs = REQUEST_LINK_WINDOW_MS - (now - entry.windowStart);
+  if (entry2.count >= REQUEST_LINK_MAX) {
+    const remainingMs = REQUEST_LINK_WINDOW_MS - (now - entry2.windowStart);
     const remainingM = Math.ceil(remainingMs / 6e4);
     return `Too many requests. Try again in ${remainingM} minute(s)`;
   }
@@ -1725,12 +1866,12 @@ function checkRequestLinkRateLimit(contactValue) {
 }
 function recordRequestLinkAttempt(contactValue) {
   const now = Date.now();
-  const entry = contactRateMap.get(contactValue);
-  if (!entry || now - entry.windowStart > REQUEST_LINK_WINDOW_MS) {
+  const entry2 = contactRateMap.get(contactValue);
+  if (!entry2 || now - entry2.windowStart > REQUEST_LINK_WINDOW_MS) {
     contactRateMap.set(contactValue, { count: 1, windowStart: now });
     return;
   }
-  entry.count++;
+  entry2.count++;
 }
 function maskContact(value) {
   if (value.includes("@")) {
@@ -1919,8 +2060,8 @@ var agentSentCache = /* @__PURE__ */ new Map();
 var inboundCache = /* @__PURE__ */ new Map();
 function pruneCache(cache3, ttl, max) {
   const now = Date.now();
-  for (const [key, entry] of cache3) {
-    if (now - entry.ts > ttl) cache3.delete(key);
+  for (const [key, entry2] of cache3) {
+    if (now - entry2.ts > ttl) cache3.delete(key);
   }
   if (cache3.size > max) {
     const excess = cache3.size - max;
@@ -1937,22 +2078,22 @@ function trackAgentSentMessage(messageId) {
   agentSentCache.set(messageId, { ts: Date.now() });
 }
 function isAgentSentMessage(messageId) {
-  const entry = agentSentCache.get(messageId);
-  if (!entry) return false;
-  if (Date.now() - entry.ts > AGENT_SENT_TTL_MS) {
+  const entry2 = agentSentCache.get(messageId);
+  if (!entry2) return false;
+  if (Date.now() - entry2.ts > AGENT_SENT_TTL_MS) {
     agentSentCache.delete(messageId);
     return false;
   }
   return true;
 }
 function isDuplicateInbound(key) {
-  const entry = inboundCache.get(key);
-  if (!entry) {
+  const entry2 = inboundCache.get(key);
+  if (!entry2) {
     pruneCache(inboundCache, INBOUND_TTL_MS, INBOUND_MAX);
     inboundCache.set(key, { ts: Date.now() });
     return false;
   }
-  if (Date.now() - entry.ts > INBOUND_TTL_MS) {
+  if (Date.now() - entry2.ts > INBOUND_TTL_MS) {
     inboundCache.delete(key);
     inboundCache.set(key, { ts: Date.now() });
     return false;
@@ -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 = [];
@@ -2013,7 +2154,7 @@ function recordActivity(event) {
     }
     acct[direction]++;
     acct.lastEventAt = now;
-    const entry = {
+    const entry2 = {
       channel: "whatsapp",
       accountId,
       direction,
@@ -2021,15 +2162,15 @@ function recordActivity(event) {
       timestamp: now,
       messageType
     };
-    recentEvents.push(entry);
+    recentEvents.push(entry2);
     if (recentEvents.length > RECENT_EVENTS_MAX) {
       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 {
@@ -2295,8 +2436,218 @@ function sanitizeReason(err) {
   return `${err.name}:${msg}`;
 }
 
+// app/lib/whatsapp/chat-metadata-store.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync, statSync as statSync2 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+
+// app/lib/data-path.ts
+import { realpathSync } from "fs";
+import { resolve as resolve2, normalize, sep, relative, basename, join as join3 } from "path";
+var PLATFORM_ROOT2 = process.env.MAXY_PLATFORM_ROOT ?? resolve2(process.cwd(), "../platform");
+var DATA_ROOT = resolve2(PLATFORM_ROOT2, "..", "data");
+var CLAUDE_UPLOADS_ROOT = process.env.CLAUDE_CONFIG_DIR ? resolve2(process.env.CLAUDE_CONFIG_DIR, "uploads") : null;
+var ACCOUNT_PARTITION_DIRS = /* @__PURE__ */ new Set(["accounts"]);
+var ACCOUNT_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function crossesForeignAccountPartition(relPath, accountId) {
+  const segs = relPath.split("/").filter(Boolean);
+  if (segs.length < 2) return false;
+  if (!ACCOUNT_PARTITION_DIRS.has(segs[0])) return false;
+  const owner = segs[1];
+  if (!ACCOUNT_UUID_RE.test(owner)) return false;
+  return owner !== accountId;
+}
+function isWithinOwnAccountPartition(relPath, accountId) {
+  const segs = relPath.split("/").filter(Boolean);
+  return segs.length >= 2 && segs[0] === "accounts" && segs[1] === accountId;
+}
+function resolveUnderRoot(raw, rootAbs, rootLabel) {
+  const cleaned = normalize("/" + (raw ?? "").replace(/\\/g, "/")).replace(/^\/+/, "");
+  const absolute = resolve2(rootAbs, cleaned);
+  let rootReal;
+  try {
+    rootReal = realpathSync(rootAbs);
+  } catch (err) {
+    return {
+      ok: false,
+      status: 500,
+      error: `${rootLabel} not accessible: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  let resolvedReal;
+  try {
+    resolvedReal = realpathSync(absolute);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      if (absolute !== rootReal && !absolute.startsWith(rootReal + sep)) {
+        return { ok: false, status: 403, error: `Path escapes ${rootLabel}`, resolved: absolute };
+      }
+      return { ok: false, status: 404, error: "Not found" };
+    }
+    return {
+      ok: false,
+      status: 500,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  if (resolvedReal !== rootReal && !resolvedReal.startsWith(rootReal + sep)) {
+    return { ok: false, status: 403, error: `Path escapes ${rootLabel}`, resolved: resolvedReal };
+  }
+  const relPath = relative(rootReal, resolvedReal) || ".";
+  return { ok: true, absolute: resolvedReal, dataRootReal: rootReal, relative: relPath };
+}
+function resolveDataPath(raw) {
+  return resolveUnderRoot(raw, DATA_ROOT, "DATA_ROOT");
+}
+function resolveClaudeUploadsPath(raw) {
+  if (!CLAUDE_UPLOADS_ROOT) {
+    return { ok: false, status: 404, error: "Not found" };
+  }
+  return resolveUnderRoot(raw, CLAUDE_UPLOADS_ROOT, "CLAUDE_UPLOADS_ROOT");
+}
+function scratchpadTmpBase() {
+  return process.env.MAXY_SCRATCHPAD_BASE ?? "/tmp";
+}
+function sessionScratchpadRoot(projectDir, sessionId) {
+  const uid = typeof process.geteuid === "function" ? process.geteuid() : 0;
+  return join3(scratchpadTmpBase(), `claude-${uid}`, basename(projectDir), sessionId, "scratchpad");
+}
+function resolveScratchpadPath(raw, scratchpadRootAbs) {
+  return resolveUnderRoot(raw, scratchpadRootAbs, "scratchpad");
+}
+
+// app/lib/whatsapp/chat-metadata-store.ts
+var SOURCE_RANK = { contact: 3, group: 2, chat: 1 };
+function isSource(v) {
+  return v === "contact" || v === "group" || v === "chat";
+}
+function preferEntry(existing, incoming) {
+  if (existing === void 0) return incoming;
+  const a = SOURCE_RANK[existing.source];
+  const b = SOURCE_RANK[incoming.source];
+  if (b > a) return incoming;
+  if (b < a) return existing;
+  return incoming.updatedAt > existing.updatedAt ? incoming : existing;
+}
+function parseChatMetadata(raw) {
+  const out = /* @__PURE__ */ new Map();
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return out;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return out;
+  for (const [jid, value] of Object.entries(parsed)) {
+    if (value === null || typeof value !== "object") continue;
+    const v = value;
+    if (typeof v.name !== "string" || v.name.length === 0) continue;
+    if (!isSource(v.source)) continue;
+    if (typeof v.updatedAt !== "string") continue;
+    out.set(jid, {
+      jid,
+      name: v.name,
+      source: v.source,
+      isGroup: v.isGroup === true,
+      updatedAt: v.updatedAt
+    });
+  }
+  return out;
+}
+function serializeChatMetadata(map) {
+  const obj = {};
+  for (const [jid, entry2] of map) obj[jid] = entry2;
+  return JSON.stringify(obj);
+}
+function chatMetadataPath(accountId) {
+  return join4(DATA_ROOT, "accounts", accountId, "chat-metadata.json");
+}
+var readCache = /* @__PURE__ */ new Map();
+function readChatMetadata(accountId) {
+  const path3 = chatMetadataPath(accountId);
+  try {
+    if (!existsSync4(path3)) return /* @__PURE__ */ new Map();
+    const st = statSync2(path3);
+    const cached = readCache.get(path3);
+    if (cached && cached.size === st.size && cached.mtimeMs === st.mtimeMs) return cached.map;
+    const map = parseChatMetadata(readFileSync5(path3, "utf8"));
+    readCache.set(path3, { size: st.size, mtimeMs: st.mtimeMs, map });
+    return map;
+  } catch (err) {
+    console.error(
+      `[wa-chatmeta] op=read outcome=fail account=${accountId.slice(0, 8)} reason=${(err instanceof Error ? err.message : String(err)).slice(0, 100)}`
+    );
+    return /* @__PURE__ */ new Map();
+  }
+}
+function writeChatMetadataMerged(accountId, updates) {
+  if (updates.length === 0) return -1;
+  const path3 = chatMetadataPath(accountId);
+  try {
+    mkdirSync3(dirname2(path3), { recursive: true });
+    let merged = /* @__PURE__ */ new Map();
+    if (existsSync4(path3)) merged = parseChatMetadata(readFileSync5(path3, "utf8"));
+    for (const entry2 of updates) merged.set(entry2.jid, preferEntry(merged.get(entry2.jid), entry2));
+    const tmp = `${path3}.tmp`;
+    writeFileSync3(tmp, serializeChatMetadata(merged), "utf8");
+    renameSync(tmp, path3);
+    return parseChatMetadata(readFileSync5(path3, "utf8")).size;
+  } catch (err) {
+    console.error(
+      `[wa-chatmeta] op=persist outcome=fail account=${accountId.slice(0, 8)} reason=${(err instanceof Error ? err.message : String(err)).slice(0, 100)}`
+    );
+    return -1;
+  }
+}
+
+// app/lib/whatsapp/chat-metadata-events.ts
+var NON_CHAT_JIDS = /* @__PURE__ */ new Set(["status@broadcast"]);
+function isGroupJid2(jid) {
+  return jid.endsWith("@g.us");
+}
+function entry(jid, name, source, nowIso) {
+  return { jid, name, source, isGroup: isGroupJid2(jid), updatedAt: nowIso };
+}
+function conversationKey(jid, phoneNumber) {
+  if (!jid.endsWith("@lid")) return jid;
+  if (typeof phoneNumber !== "string") return jid;
+  const trimmed = phoneNumber.trim();
+  return trimmed.endsWith("@s.whatsapp.net") ? trimmed : jid;
+}
+function usable(jid, name, phoneNumber) {
+  if (typeof jid !== "string" || jid.length === 0) return null;
+  if (NON_CHAT_JIDS.has(jid)) return null;
+  const trimmed = typeof name === "string" ? name.trim() : "";
+  if (trimmed.length === 0) return null;
+  return { jid: conversationKey(jid, phoneNumber), name: trimmed };
+}
+function chatEntriesFromChats(chats, nowIso) {
+  const out = [];
+  for (const c of chats) {
+    const ok = usable(c.id, c.name, c.phoneNumber);
+    if (ok) out.push(entry(ok.jid, ok.name, "chat", nowIso));
+  }
+  return out;
+}
+function chatEntriesFromContacts(contacts, nowIso) {
+  const out = [];
+  for (const c of contacts) {
+    const ok = usable(c.id, c.name, c.phoneNumber);
+    if (ok) out.push(entry(ok.jid, ok.name, isGroupJid2(ok.jid) ? "chat" : "contact", nowIso));
+  }
+  return out;
+}
+function groupEntriesFromUpdates(updates, nowIso) {
+  const out = [];
+  for (const g of updates) {
+    const ok = usable(g.id, g.subject);
+    if (ok) out.push(entry(ok.jid, ok.name, "group", nowIso));
+  }
+  return out;
+}
+
 // app/lib/whatsapp/ensure-conversation.ts
-var TAG10 = "[whatsapp-persist]";
+var TAG11 = "[whatsapp-persist]";
 async function ensureWhatsAppConversation(input) {
   const t0 = Date.now();
   try {
@@ -2308,27 +2659,27 @@ 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;
   }
 }
 
 // ../lib/account-enumeration/src/index.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve3 } from "path";
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var cache2 = /* @__PURE__ */ new Map();
 function enumerateValidAccountIds(accountsDir) {
@@ -2347,9 +2698,9 @@ function enumerateValidAccountIds(accountsDir) {
   const valid = [];
   for (const name of names) {
     if (!UUID_RE.test(name)) continue;
-    const configPath = resolve2(accountsDir, name, "account.json");
+    const configPath = resolve3(accountsDir, name, "account.json");
     try {
-      JSON.parse(readFileSync5(configPath, "utf-8"));
+      JSON.parse(readFileSync6(configPath, "utf-8"));
       valid.push(name);
     } catch (err) {
       const code = err.code;
@@ -2363,9 +2714,9 @@ function resolveHouseOrSoleAccountId(accountsDir) {
   const valid = enumerateValidAccountIds(accountsDir);
   const houses = [];
   for (const id of valid) {
-    const configPath = resolve2(accountsDir, id, "account.json");
+    const configPath = resolve3(accountsDir, id, "account.json");
     try {
-      const cfg = JSON.parse(readFileSync5(configPath, "utf-8"));
+      const cfg = JSON.parse(readFileSync6(configPath, "utf-8"));
       if (cfg.role === "house") houses.push(id);
     } catch {
     }
@@ -2383,7 +2734,7 @@ function getAccountsDirFromEnv() {
       "[graph-write] MAXY_PLATFORM_ROOT not set \u2014 cannot enforce accountId gate. Set MAXY_PLATFORM_ROOT in the spawning process or pass `accountsDir` explicitly."
     );
   }
-  return resolve2(root, "..", "data/accounts");
+  return resolve3(root, "..", "data/accounts");
 }
 function validateAccountIdEnv(envValue, diskIds) {
   if (!envValue) {
@@ -2399,8 +2750,8 @@ function validateAccountIdEnv(envValue, diskIds) {
 }
 
 // app/lib/whatsapp/platform-account-id.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve4 } from "path";
 var cachedHouseId = null;
 var cachedHouseAccountsDir = null;
 function resolveHouseId(accountsDir) {
@@ -2411,10 +2762,10 @@ function resolveHouseId(accountsDir) {
   return cachedHouseId;
 }
 function readChannelRoutingOverride(accountsDir, houseId) {
-  const configPath = resolve3(accountsDir, houseId, "account.json");
+  const configPath = resolve4(accountsDir, houseId, "account.json");
   let raw;
   try {
-    raw = readFileSync6(configPath, "utf-8");
+    raw = readFileSync7(configPath, "utf-8");
   } catch {
     return null;
   }
@@ -2455,8 +2806,8 @@ function warnNonUuidAccount(caller, accountId) {
 }
 
 // app/lib/managed-service.ts
-import { join as join3 } from "path";
-import { readFileSync as readFileSync7 } from "fs";
+import { join as join5 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
 function isHouseManagedService(accountsDir = ACCOUNTS_DIR) {
   let houseId;
   try {
@@ -2466,7 +2817,7 @@ function isHouseManagedService(accountsDir = ACCOUNTS_DIR) {
   }
   try {
     const cfg = JSON.parse(
-      readFileSync7(join3(accountsDir, houseId, "account.json"), "utf-8")
+      readFileSync8(join5(accountsDir, houseId, "account.json"), "utf-8")
     );
     return cfg.managedService === true;
   } catch {
@@ -2480,7 +2831,7 @@ function isCustomerTurnSuppressed(role, managedService) {
 // app/lib/whatsapp/inbound/media.ts
 import { randomUUID as randomUUID4, createHash } from "crypto";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import {
   downloadMediaMessage,
   downloadContentFromMessage,
@@ -2490,85 +2841,9 @@ import {
 // app/lib/attachments.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir, writeFile } from "fs/promises";
-import { realpathSync as realpathSync2, existsSync as existsSync4, readFileSync as readFileSync8, readdirSync as readdirSync4 } from "fs";
+import { realpathSync as realpathSync2, existsSync as existsSync5, readFileSync as readFileSync9, readdirSync as readdirSync4 } from "fs";
 import { resolve as resolve5, extname } from "path";
 
-// app/lib/data-path.ts
-import { realpathSync } from "fs";
-import { resolve as resolve4, normalize, sep, relative, basename, join as join4 } from "path";
-var PLATFORM_ROOT2 = process.env.MAXY_PLATFORM_ROOT ?? resolve4(process.cwd(), "../platform");
-var DATA_ROOT = resolve4(PLATFORM_ROOT2, "..", "data");
-var CLAUDE_UPLOADS_ROOT = process.env.CLAUDE_CONFIG_DIR ? resolve4(process.env.CLAUDE_CONFIG_DIR, "uploads") : null;
-var ACCOUNT_PARTITION_DIRS = /* @__PURE__ */ new Set(["accounts"]);
-var ACCOUNT_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function crossesForeignAccountPartition(relPath, accountId) {
-  const segs = relPath.split("/").filter(Boolean);
-  if (segs.length < 2) return false;
-  if (!ACCOUNT_PARTITION_DIRS.has(segs[0])) return false;
-  const owner = segs[1];
-  if (!ACCOUNT_UUID_RE.test(owner)) return false;
-  return owner !== accountId;
-}
-function isWithinOwnAccountPartition(relPath, accountId) {
-  const segs = relPath.split("/").filter(Boolean);
-  return segs.length >= 2 && segs[0] === "accounts" && segs[1] === accountId;
-}
-function resolveUnderRoot(raw, rootAbs, rootLabel) {
-  const cleaned = normalize("/" + (raw ?? "").replace(/\\/g, "/")).replace(/^\/+/, "");
-  const absolute = resolve4(rootAbs, cleaned);
-  let rootReal;
-  try {
-    rootReal = realpathSync(rootAbs);
-  } catch (err) {
-    return {
-      ok: false,
-      status: 500,
-      error: `${rootLabel} not accessible: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-  let resolvedReal;
-  try {
-    resolvedReal = realpathSync(absolute);
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") {
-      if (absolute !== rootReal && !absolute.startsWith(rootReal + sep)) {
-        return { ok: false, status: 403, error: `Path escapes ${rootLabel}`, resolved: absolute };
-      }
-      return { ok: false, status: 404, error: "Not found" };
-    }
-    return {
-      ok: false,
-      status: 500,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-  if (resolvedReal !== rootReal && !resolvedReal.startsWith(rootReal + sep)) {
-    return { ok: false, status: 403, error: `Path escapes ${rootLabel}`, resolved: resolvedReal };
-  }
-  const relPath = relative(rootReal, resolvedReal) || ".";
-  return { ok: true, absolute: resolvedReal, dataRootReal: rootReal, relative: relPath };
-}
-function resolveDataPath(raw) {
-  return resolveUnderRoot(raw, DATA_ROOT, "DATA_ROOT");
-}
-function resolveClaudeUploadsPath(raw) {
-  if (!CLAUDE_UPLOADS_ROOT) {
-    return { ok: false, status: 404, error: "Not found" };
-  }
-  return resolveUnderRoot(raw, CLAUDE_UPLOADS_ROOT, "CLAUDE_UPLOADS_ROOT");
-}
-function scratchpadTmpBase() {
-  return process.env.MAXY_SCRATCHPAD_BASE ?? "/tmp";
-}
-function sessionScratchpadRoot(projectDir, sessionId) {
-  const uid = typeof process.geteuid === "function" ? process.geteuid() : 0;
-  return join4(scratchpadTmpBase(), `claude-${uid}`, basename(projectDir), sessionId, "scratchpad");
-}
-function resolveScratchpadPath(raw, scratchpadRootAbs) {
-  return resolveUnderRoot(raw, scratchpadRootAbs, "scratchpad");
-}
-
 // app/lib/doc-to-text.ts
 import { unzipSync, strFromU8 } from "fflate";
 var DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
@@ -2589,10 +2864,10 @@ function bareMime(mimeType) {
 function unescapeXml(s) {
   return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 }
-function unzipEntry(buffer, entry) {
+function unzipEntry(buffer, entry2) {
   const files = unzipSync(new Uint8Array(buffer));
-  const bytes = files[entry];
-  if (!bytes) throw new Error(`zip entry not found: ${entry}`);
+  const bytes = files[entry2];
+  if (!bytes) throw new Error(`zip entry not found: ${entry2}`);
   return strFromU8(bytes);
 }
 function docxToText(buffer) {
@@ -2814,14 +3089,14 @@ async function storeMediaBuffer(accountId, attachmentId, filename, mimeType, buf
   return writeAttachment(accountId, "", filename, mimeType, buffer.byteLength, buffer, attachmentId);
 }
 function attachmentExists(accountId, attachmentId) {
-  return existsSync4(resolve5(uploadsDirFor(accountId, "", attachmentId), `${attachmentId}.meta.json`));
+  return existsSync5(resolve5(uploadsDirFor(accountId, "", attachmentId), `${attachmentId}.meta.json`));
 }
 function resolveStoredAttachment(accountId, attachmentId) {
   if (!ATTACHMENT_ID_RE.test(attachmentId)) return null;
   const dir = uploadsDirFor(accountId, "", attachmentId);
   let meta;
   try {
-    meta = JSON.parse(readFileSync8(resolve5(dir, `${attachmentId}.meta.json`), "utf8"));
+    meta = JSON.parse(readFileSync9(resolve5(dir, `${attachmentId}.meta.json`), "utf8"));
   } catch {
     return null;
   }
@@ -2969,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() {
@@ -2999,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;
 }
@@ -3030,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;
@@ -3124,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 {
@@ -3156,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?.();
@@ -3171,10 +3446,10 @@ async function downloadInboundMedia(msg, sock, opts) {
   if (!res) return void 0;
   await mkdir2(MEDIA_DIR, { recursive: true });
   const ext = mimeToExt(res.mimetype);
-  const filePath = join5(MEDIA_DIR, `${randomUUID4()}.${ext}`);
+  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) {
@@ -3183,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;
   }
 }
@@ -3239,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;
@@ -3270,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);
@@ -3350,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);
@@ -3368,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) => ({
@@ -3377,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) {
@@ -3387,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,
@@ -3400,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,
@@ -3414,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,
@@ -3428,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)" };
   }
@@ -3474,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;
@@ -3493,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 {
@@ -3516,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 {
@@ -3532,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(() => {
@@ -3564,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;
@@ -3607,17 +3883,17 @@ var messageStore = /* @__PURE__ */ new Map();
 function messageStoreKey(accountId, remoteJid) {
   return `${accountId}:${remoteJid}`;
 }
-function storeMessage(storeKey, entry) {
+function storeMessage(storeKey, entry2) {
   let entries = messageStore.get(storeKey);
   if (!entries) {
     entries = [];
     messageStore.set(storeKey, entries);
   }
-  entries.push(entry);
+  entries.push(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) {
@@ -3661,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;
@@ -3671,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)}`);
     });
   }
 }
@@ -3693,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;
@@ -3724,6 +4000,7 @@ async function startConnection(accountId) {
     selfJid: null,
     selfLid: null,
     reconnectAttempts: 0,
+    rearmAttempts: 0,
     abortController: new AbortController(),
     debouncer: null,
     lidMapping: null
@@ -3747,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) => ({
@@ -3862,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,
@@ -3870,11 +4148,12 @@ async function registerLoginSocket(accountId, sock, authDir) {
   applySelfIdentity(conn, sock, "register");
   connections.set(accountId, conn);
   monitorInbound(conn);
+  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,
@@ -3885,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;
@@ -3944,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 {
@@ -3955,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;
@@ -3991,7 +4283,8 @@ async function connectWithReconnect(conn) {
       conn.sock = sock;
       applySelfIdentity(conn, sock, "pre-listener");
       monitorInbound(conn);
-      console.error(`${TAG16} socket created account=${conn.accountId} \u2014 waiting for connection`);
+      monitorChatMetadata(conn);
+      console.error(`${TAG17} socket created account=${conn.accountId} \u2014 waiting for connection`);
       await waitForConnection(sock);
       connectedAt = Date.now();
       conn.connected = true;
@@ -3999,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,
@@ -4027,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,
@@ -4041,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);
@@ -4096,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)}`);
       });
     }
   });
@@ -4122,26 +4445,115 @@ function applySelfIdentity(conn, sock, phase) {
     );
   }
 }
+function monitorChatMetadata(conn) {
+  if (!conn.sock) return;
+  const sock = conn.sock;
+  const account = conn.platformAccountId;
+  const canonicalise = async (entries) => {
+    const out = [];
+    for (const e of entries) {
+      if (!e.jid.endsWith("@lid")) {
+        out.push(e);
+        continue;
+      }
+      const { canonical, resolved } = await resolveCanonicalConversationJid(e.jid, conn.lidMapping);
+      if (resolved === "lid2pn") {
+        console.error(`${TAG17} [wa-chatmeta] op=canonical raw=${e.jid} canonical=${canonical}`);
+        out.push({ ...e, jid: canonical });
+      } else {
+        out.push(e);
+      }
+    }
+    return out;
+  };
+  const persist = (kind, entries, perJid) => {
+    if (entries.length === 0) return;
+    if (perJid) {
+      for (const e of entries) {
+        console.error(
+          `${TAG17} [wa-chatmeta] op=event kind=${kind} jid=${e.jid} name=${e.name.length} source=${e.source}`
+        );
+      }
+    }
+    const total = writeChatMetadataMerged(account, entries);
+    console.error(
+      `${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 }) => {
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const chatEntries = chatEntriesFromChats(chats ?? [], nowIso);
+    const contactEntries = chatEntriesFromContacts(contacts ?? [], nowIso);
+    console.error(
+      `${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));
+  });
+  sock.ev.on("chats.upsert", (chats) => {
+    void canonicalise(chatEntriesFromChats(chats ?? [], (/* @__PURE__ */ new Date()).toISOString())).then((e) => persist("chats.upsert", e, true));
+  });
+  sock.ev.on("chats.update", (chats) => {
+    void canonicalise(chatEntriesFromChats(chats ?? [], (/* @__PURE__ */ new Date()).toISOString())).then((e) => persist("chats.update", e, true));
+  });
+  sock.ev.on("contacts.upsert", (contacts) => {
+    void canonicalise(chatEntriesFromContacts(contacts ?? [], (/* @__PURE__ */ new Date()).toISOString())).then((e) => persist("contacts.upsert", e, true));
+  });
+  sock.ev.on("contacts.update", (contacts) => {
+    void canonicalise(chatEntriesFromContacts(contacts ?? [], (/* @__PURE__ */ new Date()).toISOString())).then((e) => persist("contacts.update", e, true));
+  });
+  sock.ev.on("groups.update", (updates) => {
+    persist("groups.update", groupEntriesFromUpdates(updates ?? [], (/* @__PURE__ */ new Date()).toISOString()), true);
+  });
+  const groupFetchAttempted = /* @__PURE__ */ new Set();
+  sock.ev.on("messages.upsert", async (upsert) => {
+    for (const msg of upsert.messages ?? []) {
+      const jid = msg.key?.remoteJid;
+      if (!jid || !jid.endsWith("@g.us")) continue;
+      if (groupFetchAttempted.has(jid)) continue;
+      if (readChatMetadata(account).get(jid)?.source === "group") continue;
+      groupFetchAttempted.add(jid);
+      const startedAt = Date.now();
+      try {
+        const meta = await sock.groupMetadata(jid);
+        console.error(
+          `${TAG17} [wa-chatmeta] op=group-fetch jid=${jid} ms=${Date.now() - startedAt} outcome=ok`
+        );
+        persist(
+          "group-fetch",
+          groupEntriesFromUpdates([{ id: jid, subject: meta.subject }], (/* @__PURE__ */ new Date()).toISOString()),
+          true
+        );
+      } catch (err) {
+        console.error(
+          `${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)}`
+        );
+      }
+    }
+  });
+}
+function listConnections() {
+  return [...connections.values()];
+}
 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) => {
-      const conversationKey = payload.isGroup ? payload.groupJid : payload.senderPhone;
-      return `${payload.accountId}:${conversationKey ?? payload.senderPhone}:${payload.senderPhone}`;
+      const conversationKey2 = payload.isGroup ? payload.groupJid : payload.senderPhone;
+      return `${payload.accountId}:${conversationKey2 ?? payload.senderPhone}:${payload.senderPhone}`;
     },
     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) => {
@@ -4254,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,
@@ -4308,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}`;
@@ -4391,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,
@@ -4468,21 +4880,21 @@ 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)}`);
       }
     }
   });
   console.error(`[whatsapp-reaction] op=subscribed account=${conn.platformAccountId}`);
   sock.ev.on("messages.reaction", async (reactions) => {
-    for (const entry of reactions) {
+    for (const entry2 of reactions) {
       try {
-        const sig = readReactionEntry(entry);
+        const sig = readReactionEntry(entry2);
         if (!sig) continue;
         if (sig.fromMe) continue;
         const reactorTelephone = await resolveJidToE164(sig.reactorJid, conn.lidMapping) ?? sig.reactorJid;
@@ -4530,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");
@@ -4588,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);
@@ -4612,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(
@@ -4649,12 +5061,12 @@ 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) {
-    const conversationKey = isGroup ? remoteJid : senderPhone;
-    const debounceKey = `${conn.accountId}:${conversationKey}:${senderPhone}`;
+    const conversationKey2 = isGroup ? remoteJid : senderPhone;
+    const debounceKey = `${conn.accountId}:${conversationKey2}:${senderPhone}`;
     let resolvePending;
     const sttPending = new Promise((resolve6) => {
       resolvePending = resolve6;
@@ -4671,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;
@@ -4718,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)}`
           );
         }
       }
@@ -4775,6 +5187,7 @@ export {
   getAuthAgeMs,
   clearAuth,
   discardAuthDirSync,
+  startVersionDriftCensus,
   drainCredsSaveQueue,
   createWaSocket,
   waitForConnection,
@@ -4782,6 +5195,8 @@ export {
   formatError,
   closeKind,
   classifyDisconnect,
+  LINK_CENSUS_INTERVAL_MS,
+  runLinkCensus,
   normalizeE164,
   toWhatsappJid,
   jidToE164,
@@ -4795,6 +5210,7 @@ export {
   managerPhonesForAccount,
   isAdminPhone,
   shouldDispatchInbound,
+  formatSenderPhone,
   checkAccessRateLimit,
   recordAccessFailedAttempt,
   clearAccessRateLimit,
@@ -4813,10 +5229,6 @@ export {
   sendComposing,
   sendPaused,
   sendMediaMessage,
-  resolvePlatformAccountId,
-  warnNonUuidAccount,
-  isHouseManagedService,
-  isCustomerTurnSuppressed,
   DATA_ROOT,
   crossesForeignAccountPartition,
   isWithinOwnAccountPartition,
@@ -4824,6 +5236,13 @@ export {
   resolveClaudeUploadsPath,
   sessionScratchpadRoot,
   resolveScratchpadPath,
+  readChatMetadata,
+  writeChatMetadataMerged,
+  groupEntriesFromUpdates,
+  resolvePlatformAccountId,
+  warnNonUuidAccount,
+  isHouseManagedService,
+  isCustomerTurnSuppressed,
   SUPPORTED_MIME_TYPES,
   MAX_FILE_SIZE_BYTES,
   MAX_FILES_PER_MESSAGE,
@@ -4866,5 +5285,6 @@ export {
   getMessages,
   listConversationJids,
   listStoreAccountKeys,
-  shutdown
+  shutdown,
+  listConnections
 };