wazap-mcp 0.9.3 → 0.9.5

package/README.md

@@ -8,7 +8,7 @@
 ```
 
 **WhatsApp for your AI agent.** An MCP server that puts your WhatsApp account —
-chats, messages, media, contacts, groups — behind 22 tools any MCP client can
+chats, messages, media, contacts, groups — behind 23 tools any MCP client can
 call. Pairing-code login, no browser, no phone-number reseller, ~20 MB of RAM.
 
 Built on [Baileys](https://github.com/WhiskeySockets/Baileys), which speaks the
@@ -101,13 +101,14 @@ The `skills/` folder follows the [Agent Skills](https://agentskills.io) format,
 | Tool | Kind | What it does |
 | --- | --- | --- |
 | `learn` | read | The guide to every tool, id format and error code. Call it first. |
-| `get_status` | read | Connection status, sync state, linked account, versions, data dir. |
+| `get_status` | read | Connection status, sync state, linked account, named-contact count, versions, data dir. |
 | `list_chats` | read | Conversations newest-first; filter `all`/`unread`/`groups`/`individual`/`archived`. |
 | `read_messages` | read | Messages in a chat; `before` pages further back, pulling older history from the phone. |
-| `get_recent_messages` | read | Everything from the last N hours, grouped by chat. The catch-up tool. |
+| `get_recent_messages` | read | Everything from the last N hours, grouped by chat. The catch-up tool. `include_system` adds WhatsApp's own notices. |
 | `search_messages` | read | Text search across the locally held messages. |
 | `get_message` | read | One message in full, with its quoted message and reactions. |
 | `search_contacts` | read | Find contacts by name or number. |
+| `sync_contacts` | read | Fetch the phone's address book from WhatsApp again, when names are missing. |
 | `get_contact` | read | Name, number, about text, profile picture. |
 | `get_group_info` | read | Participants, admins, announcement mode, invite link (when you are admin). |
 | `download_media` | read | Save an attachment to disk; small images also come back inline. |
@@ -307,6 +308,10 @@ Flags beat environment variables, which beat `<data-dir>/.env`.
 - **`@lid` ids.** Newer accounts are addressed by a privacy id rather than a
   phone number. wazap translates them back to phone numbers when it has learned
   the mapping, and passes the `@lid` through when it has not.
+- **Names come from the phone's address book.** WhatsApp delivers it as an app
+  state sync, and only to a connection asking for it from scratch. If contacts
+  read as phone numbers and `get_status` shows `contacts_named: 0`, ask for it
+  again with the `sync_contacts` tool or `wazap contacts resync`.
 - **Your phone must stay reachable.** A linked device stops receiving once the
   phone has been offline long enough; `get_status` says so in `hint`.
 

package/dist/auth-state.js

@@ -117,3 +117,28 @@ export function readLinkedAccount(dir) {
 export function clearAuth(dir) {
     rmSync(dir, { recursive: true, force: true });
 }
+const APP_STATE_SYNC_VERSION = "app-state-sync-version";
+/**
+ * The same auth state with the app state sync journal held at zero: reads of it
+ * find nothing and writes to it are dropped, every other key type untouched.
+ *
+ * WhatsApp delivers the phone's address book to a companion as `contactAction`
+ * mutations in the app state sync, once per stored collection version. Whichever
+ * socket saves those versions consumes that one delivery; every later connection
+ * resyncs from the version it left behind and receives nothing. The login socket
+ * has no store to put contacts in, so it must leave the journal for the service
+ * that follows.
+ */
+export function withoutAppStateSync(state) {
+    return {
+        creds: state.creds,
+        keys: {
+            get: async (type, ids) => type === APP_STATE_SYNC_VERSION ? {} : state.keys.get(type, ids),
+            set: async (data) => {
+                const rest = { ...data };
+                delete rest[APP_STATE_SYNC_VERSION];
+                await state.keys.set(rest);
+            },
+        },
+    };
+}

package/dist/cli.js

@@ -5,7 +5,7 @@ import { setTimeout as sleep } from "node:timers/promises";
 import makeWASocket, { DisconnectReason, } from "baileys";
 import qrcode from "qrcode";
 import qrcodeTerminal from "qrcode-terminal";
-import { clearAuth, readLinkedAccount, useAtomicAuthState } from "./auth-state.js";
+import { clearAuth, readLinkedAccount, useAtomicAuthState, withoutAppStateSync, } from "./auth-state.js";
 import { banner } from "./banner.js";
 import { runBridge } from "./bridge.js";
 import { BAILEYS_VERSION, WAZAP_VERSION, paths } from "./config.js";
@@ -20,7 +20,7 @@ import { formatAge } from "./messages.js";
 import { RateLimiter } from "./ratelimit.js";
 import { runHttp, runStdio, startLoopbackEndpoint } from "./server.js";
 import { applyWrites } from "./settings.js";
-import { bold, box, brand, humanLayout, dim, fail, info, maskNumber, next, ok, shortPath, spinner, step, tilde, warn, } from "./ui.js";
+import { bold, box, brand, humanLayout, dim, fail, fix, info, maskNumber, next, ok, shortPath, spinner, step, tilde, warn, } from "./ui.js";
 import { WA_BROWSER, WhatsAppService } from "./whatsapp.js";
 const LOGIN_TIMEOUT_MS = 120_000;
 const LIVE_TIMEOUT_MS = 15_000;
@@ -194,6 +194,53 @@ async function runLiveProbe(config) {
         releaseLock(p.lockFile);
     }
 }
+/**
+ * `wazap contacts resync`. One process owns the session, so this refuses while a
+ * server holds it rather than fighting for the socket: that server has the
+ * sync_contacts tool, which does the same thing.
+ */
+export async function runContacts(config) {
+    if (config.args[0] !== "resync") {
+        say(fail(`Unknown contacts command "${config.args[0]}".`));
+        say(fix("Run `wazap contacts resync`"));
+        process.exit(2);
+    }
+    const p = paths(config.dataDir);
+    const running = takeSessionLock(p.lockFile);
+    if (running !== null) {
+        say(fail(`wazap is running (pid ${running}).`));
+        say(fix("ask your agent for the sync_contacts tool, or stop the server and run this again"));
+        process.exit(1);
+    }
+    const wa = new WhatsAppService(config);
+    const spin = spinner("Asking WhatsApp for your address book…");
+    try {
+        await wa.start();
+        const deadline = Date.now() + LIVE_TIMEOUT_MS;
+        let probe = wa.getStatus();
+        while (!SETTLED_STATUSES.includes(probe.status) && Date.now() < deadline) {
+            await sleep(250);
+            probe = wa.getStatus();
+        }
+        const result = await wa.syncContacts();
+        spin.stop(result.named_after > result.named_before
+            ? ok(`${result.named_after} contacts have a name (was ${result.named_before})`)
+            : result.named_after > 0
+                ? ok(`Already up to date: ${result.named_after} contacts have a name`)
+                : warn("WhatsApp sent no names at all. The phone has no saved contacts for these people."));
+    }
+    catch (err) {
+        const failure = asWazapError(err);
+        spin.stop(fail(failure.message));
+        if (failure.fix)
+            say(fix(failure.fix));
+        process.exitCode = 1;
+    }
+    finally {
+        await wa.stop();
+        releaseLock(p.lockFile);
+    }
+}
 /** Bare `wazap` at a terminal: where you stand, and the one command to run next. */
 export async function runGreet(config) {
     say(banner());
@@ -580,10 +627,16 @@ async function linkSession(authDir, opts) {
             if (expired)
                 throw timedOut();
             const { state, saveCreds } = await useAtomicAuthState(authDir);
+            // This socket pairs and nothing else. It has no store, so anything it
+            // syncs is thrown away — and WhatsApp sends the history and the address
+            // book once. Refusing the history keeps it out of Baileys' sync state
+            // machine, which is what would otherwise bump `accountSyncCounter` and
+            // leave the service permanently past its own first sync.
             const sock = makeWASocket({
-                auth: state,
+                auth: withoutAppStateSync(state),
                 browser: WA_BROWSER,
                 markOnlineOnConnect: false,
+                shouldSyncHistoryMessage: () => false,
                 logger: SILENT_LOGGER,
             });
             current = sock;

package/dist/config.js

@@ -29,6 +29,7 @@ const COMMAND_ARGS = {
     logout: [0],
     connect: [1],
     config: [0, 2],
+    contacts: [1],
 };
 const COMMANDS = Object.keys(COMMAND_ARGS);
 export function defaultDataDir() {

package/dist/ids.js

@@ -11,6 +11,27 @@ export function normalizePhone(input) {
 export function isGroupId(jid) {
     return jid.endsWith("@g.us");
 }
+/**
+ * Jids that address nobody: the status feed, the `0@s.whatsapp.net` pseudo-chat
+ * WhatsApp files its own notices under, and anything malformed. They must never
+ * reach a chat list, a digest or the store.
+ *
+ * Stated as what to refuse rather than what to keep, so a jid kind wazap has
+ * not met yet — a broadcast list, a channel — still reaches the user instead of
+ * being silently swallowed, and a stored one is never purged.
+ */
+export function isNoiseJid(jid) {
+    const at = jid.lastIndexOf("@");
+    if (at === -1)
+        return true;
+    const user = jid.slice(0, at);
+    const domain = jid.slice(at + 1).toLowerCase();
+    if (domain === "broadcast")
+        return user.toLowerCase() === "status";
+    if (domain === "s.whatsapp.net" || domain === "c.us")
+        return /^0+$/.test(user) || !/^\d+$/.test(user);
+    return user === "";
+}
 /**
  * Canonicalize anything a caller may pass as a chat id.
  * Individuals become `<digits>@s.whatsapp.net`, groups stay `<id>@g.us`.

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { BANNER } from "./banner.js";
-import { runGreet, runLogin, runLogout, runServe, runStatus } from "./cli.js";
+import { runContacts, runGreet, runLogin, runLogout, runServe, runStatus } from "./cli.js";
 import { WAZAP_VERSION, parseCli, pickDefaultAction } from "./config.js";
 import { CLIENT_NAMES, runConnect } from "./connect.js";
 import { runSetup } from "./setup.js";
@@ -16,6 +16,7 @@ Usage:
   wazap setup [--agent] [--client <name>]                  Link, connect your client and finish, in one command
   wazap connect <client> [--dry-run]                       Register wazap with an MCP client
   wazap config [writes on|off]                             Show the effective settings, or allow/refuse writes
+  wazap contacts resync                                    Fetch the phone's address book from WhatsApp again
   wazap status [--live] [--json]                           Check the install, the session and the server
   wazap logout                                             Unlink and delete local credentials
 
@@ -75,6 +76,9 @@ async function main() {
         case "config":
             runConfig(config);
             return;
+        case "contacts":
+            await runContacts(config);
+            return;
         case "status":
             await runStatus(config);
             return;

package/dist/messages.js

@@ -14,7 +14,8 @@ export function messageTimestampMs(raw) {
     const seconds = protoNumber(raw.messageTimestamp);
     return seconds === undefined ? Date.now() : seconds * 1000;
 }
-/** Stable across restarts, and stable under lid→pn remapping of the chat. */
+/** Stable across restarts. Not stable if the chat's own jid is later remapped
+ * from a LID to a phone number, which is why wazap does not remap chat jids. */
 export function messageIdFor(key, chatId) {
     return `${key.fromMe ? "true" : "false"}_${chatId}_${key.id ?? ""}`;
 }
@@ -50,7 +51,28 @@ const PROTOCOL = {
     tag: (m) => (isRevoke(m) ? DELETED_TEXT : SYSTEM_TEXT),
 };
 const SYSTEM = { type: "system", tag: SYSTEM_TEXT };
-const UNKNOWN = { type: "unknown", tag: "[unsupported message]" };
+/** Names the payload, so a bug report says which one to add. */
+const UNKNOWN = {
+    type: "unknown",
+    tag: (m) => {
+        const key = getContentType(m) ?? Object.keys(m).find((name) => m[name] != null);
+        return key ? `[unsupported: ${key}]` : "[unsupported message]";
+    },
+};
+/** Payloads WhatsApp exchanges with its own clients; no person ever sent one. */
+const CONTROL_KEYS = ["messageContextInfo", "senderKeyDistributionMessage"];
+/**
+ * The protocol messages that report something a person did. Baileys enumerates
+ * exactly these as cross-user in Utils/process-message.js — every other type is
+ * one device talking to another. MESSAGE_EDIT is cross-user too, but wazap
+ * applies the edit to the message it edits, so its envelope is not a second
+ * message to show.
+ */
+const REPORTABLE_PROTOCOL_TYPES = new Set([
+    proto.Message.ProtocolMessage.Type.REVOKE,
+    proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+    proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE,
+]);
 /**
  * One table drives both messageType and messageText, so the reported type and
  * the placeholder can never disagree.
@@ -126,8 +148,13 @@ function ruleFor(content) {
     const rule = key ? RULES[key] : undefined;
     if (rule)
         return { rule, content };
-    if (content.messageContextInfo || content.senderKeyDistributionMessage)
+    // Only when the control keys are all there is. A payload wazap does not model
+    // yet usually carries messageContextInfo alongside it, and calling that a
+    // system message would hide someone's event, album or order behind
+    // "[system message]" and then out of the digest.
+    if (key === undefined && (content.messageContextInfo || content.senderKeyDistributionMessage)) {
         return { rule: SYSTEM, content };
+    }
     return { rule: UNKNOWN, content };
 }
 function stubKind(raw) {
@@ -141,6 +168,36 @@ function stubKind(raw) {
 function resolve(value, content) {
     return typeof value === "function" ? value(content) : value;
 }
+/**
+ * True for the machinery WhatsApp runs between devices: history-sync notices,
+ * app-state and peer-data responses, sender-key distribution, bare context
+ * info. They carry nothing a person did, so they are dropped rather than shown.
+ */
+export function isControlMessage(raw) {
+    if (isStubEvent(raw))
+        return false;
+    const content = unwrapEnvelopes(raw.message);
+    if (!content)
+        return true;
+    const key = getContentType(content);
+    if (key === "protocolMessage")
+        return !REPORTABLE_PROTOCOL_TYPES.has(content.protocolMessage?.type ?? -1);
+    if (key !== undefined)
+        return false;
+    // getContentType ignores the control keys, so reaching here means the payload
+    // is either nothing at all or nothing but control keys.
+    const present = Object.keys(content).filter((name) => content[name] != null);
+    return present.length === 0 || present.every((name) => CONTROL_KEYS.includes(name));
+}
+/**
+ * A message whose whole content is a stub type: WhatsApp's own notices about
+ * device linking, group membership and encryption. Baileys builds these with no
+ * `message` field at all, so they have to be recognised before the usual
+ * "no content, nothing to store" guard throws them away.
+ */
+export function isStubEvent(raw) {
+    return stubKind(raw) !== undefined;
+}
 export function messageType(raw) {
     const stub = stubKind(raw);
     if (stub === "deleted")
@@ -244,7 +301,7 @@ export function buildMessageView(raw, ctx) {
         from_me: Boolean(raw.key.fromMe),
         sender: {
             id: sender,
-            name: ctx.nameFor(sender) || raw.pushName || phoneOf(sender) || sender,
+            name: ctx.nameFor(sender),
             ...(phoneOf(sender) ? { phone: phoneOf(sender) } : {}),
         },
         type: messageType(raw),

package/dist/tools.js

@@ -42,7 +42,9 @@ contacts and groups. Call get_status first if anything looks wrong.
 - Catch up: get_recent_messages(hours) for everything, or list_chats(filter:"unread")
   then read_messages(chat_id).
 - Go back further: read_messages(chat_id, before: <oldest message_id you have>).
-- Find a person: search_contacts → get_contact.
+- Find a person: search_contacts → get_contact. Names come from the phone's own
+  address book; if they are missing (get_status shows contacts_named: 0), call
+  sync_contacts once.
 - Find something said: search_messages(query[, chat_id]).
 - Send: send_message / send_media / send_poll / send_location. These are REAL
   messages from the user's own account and there is no undo. Confirm the
@@ -53,6 +55,12 @@ contacts and groups. Call get_status first if anything looks wrong.
 ## Message shape
 Every message has non-empty \`text\`: media and system messages carry a
 placeholder like "[image] caption", "[voice message]", "[deleted]", "[poll] question".
+A sender whose name WhatsApp has never given us reads as their phone number, or
+as "unknown (lid …1234)" when even that is unknown — never as raw LID digits,
+which look like a phone number and are not one.
+WhatsApp's own notices (device linking, group membership, encryption) have
+\`type: "system"\` and are left out of get_recent_messages unless you pass
+include_system: true.
 \`timestamp\` is ISO 8601 with the machine's UTC offset, \`age\` is human-readable.
 
 ## Errors
@@ -76,7 +84,8 @@ code with what to do about it. Takes no arguments and never touches WhatsApp.`,
         description: `Check the session: connection status ("connected" means the tools work,
 "not_linked" means the user must run \`npx wazap-mcp login\`), whether the initial
 history sync has finished, which account is linked, when a message last arrived,
-and the versions and data directory in use.
+the versions and data directory in use, and how many contacts carry a name from
+the phone's address book (contacts_named: 0 means it never arrived).
 
 Call this whenever another tool reports NOT_CONNECTED, NOT_LINKED or
 SYNC_IN_PROGRESS, or to confirm which account you are about to send from.`,
@@ -89,6 +98,7 @@ SYNC_IN_PROGRESS, or to confirm which account you are about to send from.`,
                 `# WhatsApp: ${s.status} (sync: ${s.sync})`,
                 `- **account**: ${account}`,
                 `- **last message received**: ${s.last_message_received_at ?? "never"}`,
+                `- **contacts named**: ${s.contacts_named}`,
                 `- **data dir**: ${s.data_dir} · **read-only**: ${s.read_only} · **rate limit**: ${s.rate_limit}/min`,
                 `- **versions**: wazap ${s.wazap_version}, baileys ${s.baileys_version}`,
                 s.last_error ? `- **last error**: ${s.last_error}` : null,
@@ -143,21 +153,28 @@ older history when the local store runs out, which takes a few seconds.`,
         name: "get_recent_messages",
         title: "Get every WhatsApp conversation from the last N hours",
         description: `Everything that happened recently, grouped by chat. This is the catch-up tool:
-one call instead of list_chats plus a read_messages per chat.`,
+one call instead of list_chats plus a read_messages per chat. WhatsApp's own
+notices — device linking, group membership changes, encryption notices — are left
+out so the counts are conversation; pass include_system to see them.`,
         schema: {
             hours: z.number().int().min(1).max(168).default(24).describe("Look-back window in hours (1-168)"),
             filter: z
                 .enum(["all", "unread", "groups", "individual"])
                 .default("all")
                 .describe("Restrict to unread chats, groups, or one-to-one chats"),
+            include_system: z
+                .boolean()
+                .default(false)
+                .describe("Include WhatsApp's own system notices, which are excluded from the bodies and the counts by default"),
         },
         write: false,
-        handler: async ({ hours, filter }, wa) => {
-            const result = await wa.getRecentMessages(hours, filter);
+        handler: async ({ hours, filter, include_system }, wa) => {
+            const result = await wa.getRecentMessages(hours, filter, include_system);
             const messageCount = result.data.reduce((n, c) => n + c.messages.length, 0);
             return ok(renderConversations(result.data, hours), synced(result, {
                 hours,
                 filter,
+                include_system,
                 conversation_count: result.data.length,
                 message_count: messageCount,
                 conversations: result.data,
@@ -208,6 +225,29 @@ on the number). Returns contact_id values usable as chat_id.`,
             return ok(renderContacts(query, contacts), { query, count: contacts.length, contacts });
         },
     }),
+    tool({
+        name: "sync_contacts",
+        title: "Fetch the phone's address book again",
+        description: `Ask WhatsApp to send the linked phone's address book from scratch, and wait up
+to 15 seconds for it. Nothing on WhatsApp changes: this only refills wazap's
+own contact list.
+
+Use it when get_status reports contacts_named: 0, or when senders in a group
+read as phone numbers for people you know are saved on the phone. Returns
+named_before and named_after so you can tell whether it helped; if both are 0
+the phone has no saved contacts for these people.`,
+        schema: {},
+        write: false,
+        handler: async (_args, wa) => {
+            const result = await wa.syncContacts();
+            const text = result.named_after > result.named_before
+                ? `Address book synced: ${result.named_after} named contacts (was ${result.named_before}).`
+                : result.named_after > 0
+                    ? `Address book already current: ${result.named_after} named contacts.`
+                    : "WhatsApp sent no names at all; the phone has no saved contacts for these people.";
+            return ok(text, result);
+        },
+    }),
     tool({
         name: "get_contact",
         title: "Get WhatsApp contact details",

package/dist/whatsapp.js

@@ -7,13 +7,14 @@
 import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
-import makeWASocket, { Browsers, DisconnectReason, downloadMediaMessage, jidNormalizedUser, proto, } from "baileys";
+import { setTimeout as sleep } from "node:timers/promises";
+import makeWASocket, { ALL_WA_PATCH_NAMES, Browsers, DisconnectReason, downloadMediaMessage, jidNormalizedUser, proto, } from "baileys";
 import { readLinkedAccount, useAtomicAuthState } from "./auth-state.js";
 import { BAILEYS_VERSION, paths, WAZAP_VERSION } from "./config.js";
 import { asWazapError, RELINK_FIX, RESET_FIX, WazapError } from "./errors.js";
-import { isGroupId, resolveChatId } from "./ids.js";
+import { isGroupId, isNoiseJid, resolveChatId } from "./ids.js";
 import { log, logError } from "./logger.js";
-import { buildMessageView, isoWithOffset, mediaInfo, messageIdFor, messageText, messageTimestampMs, protoNumber, } from "./messages.js";
+import { buildMessageView, isControlMessage, isStubEvent, isoWithOffset, mediaInfo, messageIdFor, messageText, messageTimestampMs, protoNumber, } from "./messages.js";
 /** Reconnect pacing. A closed socket used to be retried instantly, which turns
  * any persistent rejection into a login storm — WhatsApp answers that by
  * throttling the account and refusing to link *any* new device to it, phone
@@ -37,6 +38,37 @@ const STORE_SAVE_DEBOUNCE_MS = 20_000;
 const HISTORY_STORE_CAP_PER_CHAT = 2_000;
 const DIR_MODE = 0o700;
 const FILE_MODE = 0o600;
+/**
+ * A contact WhatsApp will not name for us still arrives with a `name`: the
+ * masked number "+40∙∙∙∙∙∙∙98". Counting those as address-book entries would
+ * make wazap believe the address book had landed, and showing one hides the
+ * plain number the reader can actually dial. Anything made only of digits and
+ * masking is not a name.
+ */
+const NOT_A_NAME = /^[+\d\s()\-.·•∙…*]+$/u;
+/** The name a human wrote, or "" for a placeholder and for nothing at all. */
+export function realName(value) {
+    const name = value?.trim() ?? "";
+    return name === "" || NOT_A_NAME.test(name) ? "" : name;
+}
+/** A resync asks WhatsApp for the whole address book, so it is not free. */
+const CONTACT_RESYNC_COOLDOWN_MS = 7 * 24 * 3_600_000;
+/** How long past the initial sync a slow app state sync still gets to deliver. */
+const CONTACT_SETTLE_MS = 15_000;
+/**
+ * Whether this session should ask WhatsApp for the address book from scratch.
+ *
+ * Names arrive only in an app state sync that starts from version zero. With no
+ * stored version there is nothing to heal: the connection is already doing that
+ * sync. With versions stored and no names in hand, the delivery went somewhere
+ * that threw it away, and only a resync gets it back. An account whose address
+ * book is genuinely empty looks identical, which is what the cooldown is for.
+ */
+export function needsContactResync({ named, storedVersions, resyncedAt, now }) {
+    if (named > 0 || !storedVersions)
+        return false;
+    return resyncedAt === null || now - resyncedAt >= CONTACT_RESYNC_COOLDOWN_MS;
+}
 /** Baileys logs at info level to stdout by default, which corrupts the MCP
  * JSON-RPC stream on stdio. */
 const silentLogger = {
@@ -57,6 +89,14 @@ class Store {
     byChat = new Map();
     edited = new Set();
     reactions = new Map();
+    /**
+     * The name a sender publishes on their own profile, as WhatsApp attaches it
+     * to their messages. It is the only name we get for someone the user has not
+     * saved, and it never arrives through the contact list.
+     */
+    pushNames = new Map();
+    /** See `needsContactResync`: it keeps a full resync from repeating forever. */
+    contactsResyncedAt = null;
     seconds(sid) {
         const raw = this.messages.get(sid);
         return raw ? messageTimestampMs(raw) / 1000 : 0;
@@ -96,7 +136,15 @@ class Store {
         return [...map].map(([sender, emoji]) => ({ emoji, sender }));
     }
     serialize() {
-        const snapshot = { v: 1, chats: {}, contacts: {}, messages: {}, byChat: {} };
+        const snapshot = {
+            v: 1,
+            chats: {},
+            contacts: {},
+            messages: {},
+            byChat: {},
+            pushNames: Object.fromEntries(this.pushNames),
+            ...(this.contactsResyncedAt === null ? {} : { contactsResyncedAt: this.contactsResyncedAt }),
+        };
         for (const [jid, chat] of this.chats) {
             const encoded = encode(() => proto.Conversation.encode(chat).finish());
             if (encoded)
@@ -121,22 +169,30 @@ class Store {
         }
         return snapshot;
     }
+    /** A snapshot an older wazap wrote can still hold noise it used to keep. */
     hydrate(snapshot) {
         if (snapshot?.v !== 1)
             return;
         for (const [jid, b64] of Object.entries(snapshot.chats ?? {})) {
+            if (isNoiseJid(jid))
+                continue;
             const chat = decodeChat(b64);
             if (chat)
                 this.chats.set(jid, chat);
         }
         for (const [jid, contact] of Object.entries(snapshot.contacts ?? {}))
             this.contacts.set(jid, contact);
+        for (const [jid, name] of Object.entries(snapshot.pushNames ?? {}))
+            this.pushNames.set(jid, name);
+        this.contactsResyncedAt = snapshot.contactsResyncedAt ?? null;
         for (const [sid, b64] of Object.entries(snapshot.messages ?? {})) {
             const raw = decodeMessage(b64);
-            if (raw)
+            if (raw && !isControlMessage(raw))
                 this.messages.set(sid, raw);
         }
         for (const [jid, ring] of Object.entries(snapshot.byChat ?? {})) {
+            if (isNoiseJid(jid))
+                continue;
             const present = ring.filter((sid) => this.messages.has(sid));
             this.byChat.set(jid, present);
             for (const sid of present)
@@ -172,10 +228,15 @@ export class WhatsAppService {
     storeDirty = false;
     storeSaveTimer = null;
     persistedLoaded = false;
+    contactResyncTried = false;
     blocked = new Set();
     groupCache = new Map();
+    /** Groups whose metadata WhatsApp refused, so we stop asking on every read. */
+    unreadableGroups = new Set();
     /** `<user>@lid` to the phone-number jid, so ids we hand out stay canonical. */
     lidToPn = new Map();
+    /** The same, for naming only, and it holds more. See `learnLidPhone`. */
+    lidPhones = new Map();
     store = new Store();
     paths;
     constructor(config) {
@@ -236,8 +297,35 @@ export class WhatsAppService {
     hasHistory() {
         return this.historyReceived;
     }
+    /**
+     * The same full resync the self-heal runs, on demand. Nothing about the
+     * account changes: this asks WhatsApp to send the address book again.
+     */
+    syncContacts() {
+        return this.guarded(async () => {
+            const sock = this.ensureConnected();
+            const before = this.namedContacts();
+            await this.resyncContacts(sock);
+            const after = await this.waitForNames(before, Date.now() + CONTACT_SETTLE_MS);
+            return { requested: true, named_before: before, named_after: after };
+        });
+    }
     storeCounts() {
-        return { chats: this.store.chats.size, contacts: this.store.contacts.size, messages: this.store.messages.size };
+        return { chats: this.store.chats.size, contacts: this.namedContacts(), messages: this.store.messages.size };
+    }
+    /**
+     * People from the phone's address book: the only contact count worth
+     * reporting. The store also holds everyone who ever appeared in a group and
+     * every group itself, so its raw size says nothing about whether the address
+     * book ever arrived.
+     */
+    namedContacts() {
+        let named = 0;
+        for (const [jid, contact] of this.store.contacts) {
+            if (!isGroupId(jid) && realName(contact.name))
+                named++;
+        }
+        return named;
     }
     getStatus() {
         const info = {
@@ -248,6 +336,7 @@ export class WhatsAppService {
             reconnect_attempts: this.reconnectAttempts,
             wazap_version: WAZAP_VERSION,
             baileys_version: BAILEYS_VERSION,
+            contacts_named: this.namedContacts(),
             data_dir: this.config.dataDir,
             read_only: this.config.readOnly,
             rate_limit: this.config.rateLimitPerMinute,
@@ -263,11 +352,12 @@ export class WhatsAppService {
         return this.guarded(async () => {
             this.ensureConnected();
             await this.waitForSync();
-            const chats = this.knownChats()
+            const shown = this.knownChats()
                 .filter((chat) => this.matchesChatFilter(chat, filter))
                 .sort((a, b) => this.chatActivity(b) - this.chatActivity(a))
-                .slice(0, limit)
-                .map((chat) => this.chatSummary(chat));
+                .slice(0, limit);
+            await this.learnLidPhones(shown.map((chat) => this.canonical(chat.id ?? "")));
+            const chats = shown.map((chat) => this.chatSummary(chat));
             return this.synced(chats);
         });
     }
@@ -276,6 +366,8 @@ export class WhatsAppService {
             const sock = this.ensureConnected();
             const jid = this.resolveId(chatId);
             await this.waitForSync();
+            await this.learnParticipants(jid);
+            await this.learnLidPhones([jid]);
             if (before === undefined) {
                 const ring = this.store.byChat.get(jid) ?? [];
                 return this.synced(this.viewsFor(ring.slice(-limit), jid));
@@ -289,13 +381,16 @@ export class WhatsAppService {
             return this.synced(this.viewsFor(older, jid));
         });
     }
-    getRecentMessages(hours, filter) {
+    getRecentMessages(hours, filter, includeSystem = false) {
         return this.guarded(async () => {
             this.ensureConnected();
             await this.waitForSync();
             const cutoff = Date.now() - hours * 3_600_000;
             const conversations = [];
+            await this.learnLidPhones(this.store.byChat.keys());
             for (const [jid, ring] of this.store.byChat) {
+                if (isNoiseJid(jid))
+                    continue;
                 const chat = this.store.chats.get(jid);
                 if (chat && !this.matchesChatFilter(chat, filter))
                     continue;
@@ -307,13 +402,14 @@ export class WhatsAppService {
                 });
                 if (recent.length === 0)
                     continue;
-                const messages = this.viewsFor(recent, jid);
-                const last = messages[messages.length - 1];
+                const messages = this.viewsFor(recent, jid).filter((view) => includeSystem || view.type !== "system");
+                if (messages.length === 0)
+                    continue;
                 conversations.push({
                     chat_id: jid,
-                    chat_name: this.nameFor(jid),
+                    chat_name: this.displayName(jid),
                     type: isGroupId(jid) ? "group" : "individual",
-                    last_activity: last ? last.timestamp : isoWithOffset(cutoff),
+                    last_activity: messages[messages.length - 1].timestamp,
                     messages,
                 });
             }
@@ -355,12 +451,12 @@ export class WhatsAppService {
             const digits = needle.replace(/\D/g, "");
             const matches = [];
             for (const [jid, contact] of this.store.contacts) {
-                const name = (contact.name ?? "").toLowerCase();
-                const notify = (contact.notify ?? "").toLowerCase();
+                // Every name we might show, or someone the chat list calls "Carmen"
+                // would not be findable by that name here.
+                const known = [contact.name, contact.verifiedName, contact.notify, this.store.pushNames.get(jid)].map(realName);
                 const number = jid.split("@")[0] ?? "";
                 const hit = needle === "" ||
-                    name.includes(needle) ||
-                    notify.includes(needle) ||
+                    known.some((name) => name?.toLowerCase().includes(needle)) ||
                     (digits.length >= 5 && number.includes(digits));
                 if (!hit)
                     continue;
@@ -413,7 +509,7 @@ export class WhatsAppService {
                 participant_count: meta.participants.length,
                 participants: meta.participants.slice(0, MAX_GROUP_PARTICIPANTS).map((p) => {
                     const id = this.canonical(p.id);
-                    return { contact_id: id, name: this.nameFor(id), is_admin: isAdmin(p) };
+                    return { contact_id: id, name: this.displayName(id), is_admin: isAdmin(p) };
                 }),
                 announcement_only: Boolean(meta.announce),
                 i_am_admin: iAmAdmin,
@@ -588,7 +684,7 @@ export class WhatsAppService {
             const sock = this.beginWrite();
             const ids = participantIds.map((id) => this.resolveId(id));
             const meta = await sock.groupCreate(name, ids);
-            this.groupCache.set(this.canonical(meta.id), meta);
+            this.cacheGroup(this.canonical(meta.id), meta);
             const present = new Set(meta.participants.map((p) => this.canonical(p.id)));
             return {
                 chat_id: this.canonical(meta.id),
@@ -710,6 +806,7 @@ export class WhatsAppService {
                 this.adoptSocketAccount();
                 this.armSyncDeadline();
                 log("connected to WhatsApp");
+                void this.healContacts(sock, generation);
             }
             else if (connection === "close") {
                 const code = statusCodeOf(lastDisconnect?.error);
@@ -752,6 +849,8 @@ export class WhatsAppService {
                 if (!update.id)
                     continue;
                 const jid = this.canonical(update.id);
+                if (isNoiseJid(jid))
+                    continue;
                 const previous = this.store.chats.get(jid);
                 this.store.chats.set(jid, { ...(previous ?? {}), ...update, id: jid });
             }
@@ -773,6 +872,7 @@ export class WhatsAppService {
                 const previous = this.store.contacts.get(this.canonical(update.id));
                 this.ingestContact({ ...(previous ?? {}), ...update, id: update.id });
             }
+            this.markStoreDirty();
         });
         sock.ev.on("messages.upsert", ({ messages, type }) => {
             const stored = this.ingestMessages(messages);
@@ -829,7 +929,7 @@ export class WhatsAppService {
         });
         sock.ev.on("groups.upsert", (groups) => {
             for (const meta of groups)
-                this.groupCache.set(this.canonical(meta.id), meta);
+                this.cacheGroup(this.canonical(meta.id), meta);
         });
         sock.ev.on("groups.update", (updates) => {
             for (const update of updates) {
@@ -947,6 +1047,66 @@ export class WhatsAppService {
             this.syncWaiters.push(waiter);
         });
     }
+    /**
+     * The address book, once, for a session that connected without it.
+     *
+     * Names reach a companion through the app state sync, and WhatsApp sends each
+     * collection's snapshot only to a connection asking from version zero. A
+     * socket that saved those versions and dropped the contacts leaves every later
+     * connection resyncing from a version with nothing left to send, so the only
+     * way back is to forget the versions and ask again.
+     */
+    async healContacts(sock, generation) {
+        if (this.contactResyncTried)
+            return;
+        this.contactResyncTried = true;
+        try {
+            await this.waitForSync();
+            const named = await this.waitForNames(0, Date.now() + CONTACT_SETTLE_MS);
+            if (generation !== this.generation || this.stopped)
+                return;
+            const decision = {
+                named,
+                storedVersions: await this.hasAppStateVersions(sock),
+                resyncedAt: this.store.contactsResyncedAt,
+                now: Date.now(),
+            };
+            if (!needsContactResync(decision))
+                return;
+            log("address book missing; requesting a full contact sync");
+            await this.resyncContacts(sock);
+        }
+        catch (err) {
+            logError("contact sync", err);
+        }
+    }
+    /** Names still arriving mean the sync is working; only silence means it is not coming. */
+    async waitForNames(floor, deadline) {
+        for (;;) {
+            const named = this.namedContacts();
+            if (named > floor || this.stopped || Date.now() >= deadline)
+                return named;
+            await sleep(500);
+        }
+    }
+    async hasAppStateVersions(sock) {
+        const stored = await sock.authState.keys.get("app-state-sync-version", [...ALL_WA_PATCH_NAMES]);
+        return Object.values(stored).some((state) => state);
+    }
+    /**
+     * Forget every stored app state version, then resync. The order is the whole
+     * point: Baileys asks for a snapshot only when it has no version to resume
+     * from, and the snapshot is what carries the contacts. The timestamp is
+     * written before the request, so a resync interrupted halfway is not retried
+     * on every start.
+     */
+    async resyncContacts(sock) {
+        const forgotten = Object.fromEntries(ALL_WA_PATCH_NAMES.map((name) => [name, null]));
+        await sock.authState.keys.set({ "app-state-sync-version": forgotten });
+        this.store.contactsResyncedAt = Date.now();
+        this.markStoreDirty();
+        await sock.resyncAppState(ALL_WA_PATCH_NAMES, true);
+    }
     syncState() {
         return this.initialSyncDone ? "done" : "in_progress";
     }
@@ -1026,9 +1186,25 @@ export class WhatsAppService {
                 throw new WazapError("GROUP_NOT_FOUND", `WhatsApp does not know the group ${jid}.`);
             throw new WazapError("GROUP_NOT_FOUND", `Could not read ${jid}: ${describe(err)}`);
         }
-        this.groupCache.set(jid, meta);
+        this.cacheGroup(jid, meta);
         return meta;
     }
+    cacheGroup(jid, meta) {
+        this.groupCache.set(jid, meta);
+        this.learnGroup(meta);
+        this.markStoreDirty();
+    }
+    /**
+     * Reading a group for the first time costs one metadata fetch, after which its
+     * senders resolve from cache. A group we cannot read — left, deleted — is not
+     * worth failing the read over, and asking again on every read would cost a
+     * round trip per message page forever.
+     */
+    async learnParticipants(jid) {
+        if (!isGroupId(jid) || this.groupCache.has(jid) || this.unreadableGroups.has(jid))
+            return;
+        await this.groupMeta(jid).catch(() => this.unreadableGroups.add(jid));
+    }
     myParticipation(meta) {
         return meta.participants.find((p) => this.isMe(p.id) || (p.phoneNumber && this.isMe(p.phoneNumber)));
     }
@@ -1072,24 +1248,94 @@ export class WhatsAppService {
             return jid;
         }
     }
+    /**
+     * WhatsApp usually keys a contact by its phone jid and names the LID on the
+     * side, leaving `phoneNumber` empty, so the pairing has to be read off `id`.
+     * A hydrated store is full of these, which is why loading one relearns them.
+     */
+    relearnLid(contact) {
+        if (!contact.lid)
+            return;
+        if (contact.phoneNumber)
+            this.learnLid(contact.lid, contact.phoneNumber);
+        else if (contact.id?.endsWith("@s.whatsapp.net"))
+            this.learnLidPhone(contact.lid, contact.id);
+    }
+    /** A pairing WhatsApp stated in a field meant for it, so ids may follow it. */
     learnLid(lid, pn) {
         if (!lid || !pn)
             return;
-        const key = `${jidNormalizedUser(lid).split("@")[0]}@lid`;
-        this.lidToPn.set(key, pn);
+        this.lidToPn.set(lidKey(lid), jidNormalizedUser(pn));
+        this.learnLidPhone(lid, pn);
+    }
+    /**
+     * A pairing wazap inferred or looked up. It names people and never renames a
+     * chat: a chat whose history is filed under a LID would split in two the
+     * moment its id started canonicalising to the number instead, and the older
+     * half would stop being reachable by any id at all.
+     */
+    learnLidPhone(lid, pn) {
+        if (!lid || !pn)
+            return;
+        const key = lidKey(lid);
+        const phone = jidNormalizedUser(pn);
+        this.lidPhones.set(key, phone);
+        const pushed = this.store.pushNames.get(key) ?? this.store.pushNames.get(phone);
+        if (pushed) {
+            this.store.pushNames.set(key, pushed);
+            this.store.pushNames.set(phone, pushed);
+        }
+    }
+    /**
+     * Ask Baileys for the numbers behind the LIDs we are about to name. It answers
+     * from the table the account has already synced, so this is a lookup and not a
+     * fetch, and it covers LIDs no chat, contact or group ever paired.
+     */
+    async learnLidPhones(jids) {
+        const missing = [...new Set(jids)].filter((jid) => jid.endsWith("@lid") && !this.lidPhones.has(jid));
+        if (missing.length === 0)
+            return;
+        const mappings = await this.sockClient?.signalRepository.lidMapping
+            .getPNsForLIDs(missing)
+            .catch(() => null);
+        for (const { lid, pn } of mappings ?? [])
+            this.learnLidPhone(lid, pn);
     }
-    nameFor(jid) {
+    /**
+     * The one place a jid becomes a name, so a sender, a chat header, a digest
+     * title and a participant list can never disagree. The last rung is never a
+     * raw LID: a LID is fifteen digits that read as a phone number and are not
+     * one, so an unresolved one says it is unknown instead.
+     *
+     * `hint` is the pushName on the message being rendered, for a sender whose
+     * name has not been ingested yet.
+     */
+    displayName(jid, hint) {
+        if (!jid)
+            return "unknown";
         if (this.isMe(jid))
             return this.account?.name || "You";
-        const chat = this.store.chats.get(jid);
-        if (chat?.name)
-            return chat.name;
-        const contact = this.store.contacts.get(jid);
-        if (contact?.name || contact?.notify)
-            return contact.name || contact.notify || "";
-        if (isGroupId(jid))
-            return this.groupCache.get(jid)?.subject ?? jid;
-        return jid.split("@")[0] ?? jid;
+        if (isGroupId(jid)) {
+            return this.store.chats.get(jid)?.name || this.groupCache.get(jid)?.subject || jid;
+        }
+        const phoneJid = jid.endsWith("@lid") ? this.lidPhones.get(jid) : undefined;
+        for (const known of phoneJid ? [jid, phoneJid] : [jid]) {
+            const contact = this.store.contacts.get(known);
+            const name = realName(contact?.name) ||
+                realName(contact?.verifiedName) ||
+                realName(contact?.notify) ||
+                realName(this.store.pushNames.get(known)) ||
+                realName(this.store.chats.get(known)?.name);
+            if (name)
+                return name;
+        }
+        const hinted = realName(hint);
+        if (hinted)
+            return hinted;
+        const digits = (phoneJid ?? jid).split("@")[0] ?? "";
+        if ((phoneJid ?? jid).endsWith("@s.whatsapp.net"))
+            return digits;
+        return jid.endsWith("@lid") ? `unknown (lid …${digits.slice(-4)})` : jid;
     }
     messageOrThrow(messageId) {
         const raw = this.store.messages.get(messageId);
@@ -1108,7 +1354,7 @@ export class WhatsAppService {
         const raw = this.messageOrThrow(sid);
         return buildMessageView(raw, {
             canonical: (jid) => this.canonical(jid),
-            nameFor: (jid) => this.nameFor(jid),
+            nameFor: (jid) => this.displayName(jid, raw.pushName ?? undefined),
             ownId: this.ownJid(),
             chatId: chatJid,
             edited: this.store.edited.has(sid),
@@ -1152,7 +1398,7 @@ export class WhatsAppService {
     knownChats() {
         const chats = [...this.store.chats.values()];
         for (const jid of this.store.byChat.keys()) {
-            if (!this.store.chats.has(jid))
+            if (!this.store.chats.has(jid) && !isNoiseJid(jid))
                 chats.push({ id: jid });
         }
         return chats;
@@ -1186,7 +1432,7 @@ export class WhatsAppService {
         const muteEnd = protoNumber(chat.muteEndTime) ?? 0;
         const summary = {
             chat_id: jid,
-            name: chat.name || this.nameFor(jid),
+            name: this.displayName(jid),
             type: isGroupId(jid) ? "group" : "individual",
             unread_count: Math.max(0, chat.unreadCount ?? 0),
             last_message: last
@@ -1206,12 +1452,13 @@ export class WhatsAppService {
         return summary;
     }
     contactSummary(jid, contact) {
-        const number = jid.endsWith("@s.whatsapp.net") ? (jid.split("@")[0] ?? null) : null;
+        const phoneJid = jid.endsWith("@lid") ? (this.lidPhones.get(jid) ?? jid) : jid;
+        const number = phoneJid.endsWith("@s.whatsapp.net") ? (phoneJid.split("@")[0] ?? null) : null;
         return {
             contact_id: jid,
-            name: contact?.name || contact?.notify || number || jid,
+            name: this.displayName(jid),
             number,
-            is_my_contact: Boolean(contact?.name),
+            is_my_contact: realName(contact?.name) !== "",
             is_business: Boolean(contact?.verifiedName),
         };
     }
@@ -1230,14 +1477,15 @@ export class WhatsAppService {
         if (chat.lidJid && chat.pnJid)
             this.learnLid(chat.lidJid, chat.pnJid);
         const jid = this.canonical(chat.id);
+        if (isNoiseJid(jid))
+            return;
         const previous = this.store.chats.get(jid);
         this.store.chats.set(jid, { ...(previous ?? {}), ...chat, id: jid });
     }
     ingestContact(contact) {
         if (!contact.id)
             return;
-        if (contact.lid && contact.phoneNumber)
-            this.learnLid(contact.lid, contact.phoneNumber);
+        this.relearnLid(contact);
         const jid = this.canonical(contact.id);
         const previous = this.store.contacts.get(jid);
         this.store.contacts.set(jid, { ...(previous ?? {}), ...contact, id: jid });
@@ -1245,16 +1493,41 @@ export class WhatsAppService {
     ingestMessages(messages) {
         const stored = [];
         for (const raw of messages) {
-            if (!raw.message || !raw.key?.remoteJid)
+            if (!raw.key?.remoteJid || (!raw.message && !isStubEvent(raw)))
                 continue;
             const jid = this.canonical(raw.key.remoteJid);
-            if (jid === "status@broadcast")
+            if (isNoiseJid(jid) || isControlMessage(raw))
                 continue;
+            this.learnPushName(raw, jid);
             this.store.putMessage(messageIdFor(raw.key, jid), jid, raw);
             stored.push(raw);
         }
         return stored;
     }
+    learnPushName(raw, chatJid) {
+        const name = raw.pushName?.trim();
+        if (!name || raw.key.fromMe)
+            return;
+        const sender = this.canonical(raw.key.participant ?? raw.participant ?? chatJid);
+        if (sender && !this.isMe(sender))
+            this.store.pushNames.set(sender, name);
+    }
+    /**
+     * One fetch teaches every later message in that group who its participants
+     * are, which matters most for a group whose members are strangers to the
+     * address book.
+     */
+    learnGroup(meta) {
+        for (const p of meta.participants) {
+            const lid = p.lid ?? (p.id.endsWith("@lid") ? p.id : undefined);
+            const phone = p.phoneNumber ?? (p.id.endsWith("@s.whatsapp.net") ? p.id : undefined);
+            if (lid && phone)
+                this.learnLidPhone(lid, phone);
+            const name = p.name ?? p.notify ?? p.username;
+            if (name)
+                this.ingestContact({ id: phone ?? p.id, ...(lid ? { lid } : {}), notify: name });
+        }
+    }
     async loadPersisted() {
         if (!this.config.persistHistory || this.persistedLoaded)
             return;
@@ -1266,6 +1539,8 @@ export class WhatsAppService {
         try {
             const text = await readFile(this.paths.storeFile, "utf8");
             this.store.hydrate(JSON.parse(text));
+            for (const contact of this.store.contacts.values())
+                this.relearnLid(contact);
             log(`store loaded: ${this.store.chats.size} chats, ${this.store.messages.size} messages`);
         }
         catch (err) {
@@ -1344,9 +1619,12 @@ export class WhatsAppService {
         let loaded = 0;
         for (const record of kept) {
             const raw = decodeMessage(record.raw);
-            if (!raw?.message || !raw.key?.remoteJid)
+            if (!raw?.key?.remoteJid || (!raw.message && !isStubEvent(raw)))
                 continue;
-            this.store.putMessage(record.sid, this.canonical(raw.key.remoteJid), raw);
+            const jid = this.canonical(raw.key.remoteJid);
+            if (isNoiseJid(jid) || isControlMessage(raw))
+                continue;
+            this.store.putMessage(record.sid, jid, raw);
             loaded++;
         }
         return loaded;
@@ -1356,7 +1634,7 @@ export class WhatsAppService {
             return;
         const lines = new Map();
         for (const raw of messages) {
-            if (!raw.message || !raw.key?.remoteJid)
+            if (!raw.key?.remoteJid)
                 continue;
             const encoded = encode(() => proto.WebMessageInfo.encode(raw).finish());
             if (!encoded)
@@ -1396,6 +1674,9 @@ const ADMIN_ACTIONS = new Set([
 const PARTICIPANT_ACTIONS = new Set(["add", "remove", "promote", "demote"]);
 /** WhatsApp answers "cannot add, invite them instead" with these codes. */
 const INVITE_NEEDED_CODES = new Set(["403", "409"]);
+function lidKey(lid) {
+    return `${jidNormalizedUser(lid).split("@")[0]}@lid`;
+}
 function isAdmin(participant) {
     return participant.admin === "admin" || participant.admin === "superadmin";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wazap-mcp",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "WhatsApp for your AI agent. MCP server over Baileys: pairing-code login, 22 tools, stdio or token-protected HTTP.",
   "license": "MIT",
   "author": "Răzvan Girgiz",