wazap-mcp 0.14.0 → 0.16.0

package/AGENT.md

@@ -4,15 +4,17 @@ You are setting up WhatsApp access for the person you are working with. Use the
 
 wazap keeps stdout for the MCP protocol and writes every human-readable line to stderr, so read stderr as well: run each command with `2>&1`.
 
-1. Run `npx wazap-mcp status --json`. If `linked` is true, skip to step 5.
+1. Run `npx wazap-mcp status --json`. `linked` is true when any configured account is linked; `accounts[]` lists each account's own credentials. If `linked` is true, skip to step 5. If it is false but `accounts[]` shows an account other than the default, link that account instead: pass `--account <id>` to `login` in step 3, or `account_id` to `link_account`.
 2. Ask the person for their WhatsApp number in international format (e.g. +15550100) and whether the agent may send messages (default: no).
 3. If you already have the `whatsapp` tools (the Claude Desktop bundle, or any client wazap is connected to), call `link_account` with the number. It returns the code within ~10 s and needs no terminal. Otherwise start the link IN THE BACKGROUND and keep reading its output:
    `npx wazap-mcp login --phone <number> --no-writes --yes 2>&1` (or `--writes`).
    Within ~10 s the output contains a line `pairing code: XXXX-XXXX`.
 4. Show the person exactly: "On your phone: WhatsApp → Settings → Linked devices → Link a device → Link with phone number instead → enter XXXX-XXXX". After `link_account`, call `get_status` every 10 seconds until it says `connected` (up to 3 minutes); after the command, keep reading the output until `Linked as …` and then `Synced N chats …` appear. If the code expired, run step 3 again.
-5. If step 1 reported `install.kind: "npx"`, run `npm i -g wazap-mcp` first: Claude Desktop and the background service cannot launch from the npx cache, which npm clears. Register wazap with the client you are running in: `npx wazap-mcp connect <client>` where <client> is claude-code, claude-desktop, cursor, codex, vscode or gemini. Tell the person what the command printed as `Next`. Then, for claude-code, codex, cursor and opencode, run `npx wazap-mcp skills install <client>`, which copies the five workflow skills where that client reads them. The other clients need no such step, because the server hands them the same five workflows as MCP prompts.
+5. If step 1 reported `install.kind: "npx"`, run `npm i -g wazap-mcp` first: Claude Desktop and the background service cannot launch from the npx cache, which npm clears. Register wazap with the client you are running in: `npx wazap-mcp connect <client>` where <client> is claude-code, claude-desktop, cursor, codex, vscode, gemini, windsurf or opencode. Tell the person what the command printed as `Next`. Then, for claude-code, codex, cursor and opencode, run `npx wazap-mcp skills install <client>`, which copies the five workflow skills where that client reads them. The other clients need no such step, because the server hands them the same five workflows as MCP prompts.
 6. Verify: `npx wazap-mcp status --json` must show `linked: true` and no failing check. If the client needs a restart, say so; otherwise call the `get_status` tool and then `learn`.
 7. Done when `get_status` returns `connected`. Then offer: "what did I miss on WhatsApp today?"
 8. Ask whether wazap should keep running after this client closes, and whether cloud agents should reach it. For the first, run `npx wazap-mcp service install`, which writes a launchd agent or a systemd user unit and starts it. For the second, also run `npx wazap-mcp expose`. It opens a tunnel, prints an https URL and a consent password, and restarts the service. Give an agent the URL only. The password is for the person, on their consent page; never paste it into a chat, a config file or a message.
 
-Errors: every wazap error prints `✗ message` and `→ fix`; do what the fix says, do not retry blindly. One process owns the session, so while the `login` of step 3 runs, no server and no other wazap command may touch the same data dir; two servers on one data dir refuse to start. Stop the other one first.
+More than one WhatsApp account: `npx wazap-mcp account add <id>` creates a slot, then link it with `login --account <id>` or `link_account(account_id)`. `account list` shows them; `account default <id>` picks the one tools use when a call does not say otherwise. A running server learns a new account only on restart — `account add`/`enable`/`disable`/`default` say so when they change the registry. When several accounts could own a chat, write tools return AMBIGUOUS_ACCOUNT; pass `account_id`. `list_accounts` is the read tool that shows them all.
+
+Errors: every wazap error prints `✗ message` and `→ fix`; do what the fix says, do not retry blindly. One process owns the session, so while the `login` of step 3 runs, no server and no other wazap command may touch the same data dir; two servers on one data dir refuse to start. Stop the other one first — `wazap service stop` when the holder is the background service.

package/README.md

@@ -502,31 +502,57 @@ trace, so an agent can decide whether to retry, ask the user, or stop.
 ## Data directory
 
 Everything lives in `~/.wazap` (override with `--data-dir` or `WAZAP_DATA_DIR`),
-created `0700` with credentials written `0600`:
+created `0700` with credentials written `0600`. A data dir from before several
+accounts moves into `accounts/default/` the first time a wazap command runs.
 
 ```
 ~/.wazap/
-  auth/         WhatsApp credentials — treat this like a password
-  media/        downloads from download_media
-  history/      per-chat message history, so a restart is not amnesia
-  previews/     one small JPEG per photo or video already previewed
-  notes.json    notes on contacts and "handled" marks; never sent anywhere
-  models/       whisper.cpp models, when transcription runs locally
-  store.json    chat-list snapshot
-  server.lock   pid of the running server
-  daemon.json   loopback endpoint a second wazap bridges to
-  oauth.json    registered agents and hashed OAuth grants, when OAuth is on
-  .env          optional settings, see .env.example
+  accounts.json     which accounts exist, and which is default
+  accounts/<id>/
+    auth/           WhatsApp credentials — treat this like a password
+    media/          downloads from download_media
+    history/        per-chat message history, so a restart is not amnesia
+    previews/       one small JPEG per photo or video already previewed
+    notes.json      notes on contacts and "handled" marks; never sent anywhere
+    store.json      chat-list snapshot
+    qr.png          last QR, when login showed one
+  models/           whisper.cpp models, when transcription runs locally
+  server.lock       pid of the running server
+  daemon.json       loopback endpoint a second wazap bridges to
+  oauth.json        registered agents and hashed OAuth grants, when OAuth is on
+  .env              optional settings, see .env.example
+  migration.json    written once when a flat dir moved into accounts/default
 ```
 
 Credential writes go to a temp file and are renamed into place, so killing the
 process mid-write cannot leave you re-linking your phone.
 
+## Several accounts
+
+One `wazap serve` holds every enabled account in the data dir. Each account is
+its own Baileys socket and its own folder under `accounts/<id>/`. The first
+account is `default`. Add another with `wazap account add work --name Work`,
+then `wazap login --account work`.
+
+`--account` picks one on `login`, `logout`, `status`, `config writes` and
+`webhook test`. MCP tools take an optional `account_id`. Call `list_accounts`
+first when more than one is linked. A chat only one account knows selects that
+account. A send to a chat no account knows, with two or more accounts, fails
+`AMBIGUOUS_ACCOUNT` instead of falling back to default.
+
+Reads without a chat and without `account_id` use the default account; the
+response still carries `account_id`. `link_account` needs an account that
+already exists. Five accounts is advice, not a cap. One phone number is one
+account.
+
+An account can override the global webhook URL and secret in `accounts.json`
+(`webhook_url`, `webhook_secret`). `wazap webhook test --account work` posts
+with that account's id and name.
+
 ## Several clients at once
 
-Claude Desktop, Claude Code and Cursor each launch their own `wazap`. WhatsApp
-allows one socket per linked device, so they share one session instead of
-fighting over it. The first `wazap` on a data directory owns the session and
+Claude Desktop, Claude Code and Cursor each launch their own `wazap`. The first
+one on a data directory owns every enabled account, each on its own socket, and
 opens an MCP endpoint on `127.0.0.1`; every later one bridges to it over that
 endpoint. There is nothing to configure, and no client can tell the difference.
 The owner publishes `<data-dir>/daemon.json` (`0600`) with its pid, its port
@@ -684,15 +710,17 @@ is not posted. The only event is `message_received`.
 ```bash
 npx wazap-mcp config webhook on    # asks for URL + secret (secret is not echoed)
 npx wazap-mcp webhook test         # POST a probe event
+npx wazap-mcp webhook test --account work
 npx wazap-mcp config webhook off
 ```
 
 On without a URL or secret fails `wazap status`, doctor and setup. A failed
 delivery retries twice (200 ms, then 500 ms), then sets `webhook.last_error`
-and leaves WhatsApp and MCP running.
+and leaves WhatsApp and MCP running. An account may set `webhook_url` and
+`webhook_secret` in `accounts.json`; those win over the global URL and secret.
 
 HMAC: `X-Wazap-Signature` is `sha256=<hex>`, HMAC-SHA256 of the exact raw
-JSON body with `WAZAP_WEBHOOK_SECRET`. Verify that raw body, not a
+JSON body with the secret that signed it. Verify that raw body, not a
 re-serialized object. HTTPS only, except `http://` on loopback.
 
 ```json
@@ -702,7 +730,9 @@ re-serialized object. HTTPS only, except `http://` on loopback.
   "chat_id": "15550100@s.whatsapp.net",
   "ts": "2026-09-08T14:00:00+00:00",
   "text": "hello, or a short preview",
-  "message_id": "false_15550100@s.whatsapp.net_3EB0…"
+  "message_id": "false_15550100@s.whatsapp.net_3EB0…",
+  "account_id": "default",
+  "account_name": "default"
 }
 ```
 
@@ -730,8 +760,8 @@ re-serialized object. HTTPS only, except `http://` on loopback.
 | `WAZAP_TRANSCRIBE_URL` | `https://api.openai.com/v1` | OpenAI-compatible base URL. |
 | `WAZAP_TRANSCRIBE_MODEL` | `gpt-4o-mini-transcribe` | Model at that URL. |
 | `WAZAP_WEBHOOK` | `off` | `on` posts live inbound messages to the webhook URL. |
-| `WAZAP_WEBHOOK_URL` | unset | HTTPS endpoint. `http://` only on loopback. |
-| `WAZAP_WEBHOOK_SECRET` | unset | Shared secret for `X-Wazap-Signature`. Never a flag. |
+| `WAZAP_WEBHOOK_URL` | unset | HTTPS endpoint. `http://` only on loopback. An account `webhook_url` wins. |
+| `WAZAP_WEBHOOK_SECRET` | unset | Shared secret for `X-Wazap-Signature`. Never a flag. An account `webhook_secret` wins. |
 
 Flags beat environment variables, which beat `<data-dir>/.env`.
 

package/dist/account-cli.js

@@ -1,11 +1,12 @@
-import { AccountRegistry } from "./accounts.js";
+import { AccountRegistry, ownerNumber } from "./accounts.js";
 import { readLinkedAccount } from "./auth-state.js";
-import { ask, leftoverFix } from "./cli.js";
+import { ask, leftoverFix, warnIfServerRunning } from "./cli.js";
 import { ACCOUNT_USAGE, MIGRATE_USAGE, accountPaths, paths } from "./config.js";
 import { WazapError } from "./errors.js";
 import { lockHolder } from "./lock.js";
 import { say } from "./logger.js";
 import { rollbackMigration } from "./migrate.js";
+import { serviceHolding } from "./service.js";
 import { brand, info, maskNumber, ok } from "./ui.js";
 function parseAccountVerb(verb) {
     switch (verb) {
@@ -14,6 +15,7 @@ function parseAccountVerb(verb) {
         case "remove":
         case "enable":
         case "disable":
+        case "default":
             return verb;
         default:
             throw new WazapError("INVALID_ID", `Unknown account command "${verb ?? ""}".`, ACCOUNT_USAGE);
@@ -26,7 +28,11 @@ export function describeAccount(account) {
 }
 export function describeStatusAccount(row) {
     const flag = row.enabled ? "enabled" : "disabled";
-    const who = row.account === null ? "not linked" : describeAccount(row.account);
+    const who = row.account !== null
+        ? describeAccount(row.account)
+        : row.owner !== null
+            ? `was ${maskNumber(ownerNumber(row.owner))}`
+            : "not linked";
     return `${row.id}  ${flag}  ${who}`;
 }
 export function accountRows(config) {
@@ -45,6 +51,7 @@ export function accountRows(config) {
             enabled: record.enabled,
             default: record.id === registry.defaultId(),
             account: linked,
+            owner: record.owner ?? null,
         };
     });
 }
@@ -77,6 +84,11 @@ export async function runAccount(config) {
                 throw new WazapError("INVALID_ID", "Missing account id.", ACCOUNT_USAGE);
             enableAccount(config, id, false);
             return;
+        case "default":
+            if (id === undefined)
+                throw new WazapError("INVALID_ID", "Missing account id.", ACCOUNT_USAGE);
+            defaultAccount(config, id);
+            return;
         default: {
             const _exhaustive = verb;
             return _exhaustive;
@@ -91,15 +103,18 @@ function listAccounts(config) {
 function addAccount(config, id) {
     const record = AccountRegistry.load(config.dataDir).add(id, config.accountName);
     say(ok(`Account "${record.id}" added.`));
+    warnIfServerRunning(config);
 }
 async function removeAccount(config, id) {
     const registry = AccountRegistry.load(config.dataDir);
     if (registry.get(id) === undefined) {
         throw new WazapError("INVALID_ID", `No account "${id}".`, "Run `wazap account list`");
     }
+    // Removing an account under a live hub would orphan its socket; even the
+    // service must be stopped by hand, so the fix names whichever holder it is.
     const running = lockHolder(paths(config.dataDir).lockFile);
     if (running !== null) {
-        throw new WazapError("INVALID_ID", `wazap is running (pid ${running}).`, leftoverFix(running));
+        throw new WazapError("INVALID_ID", `wazap is running (pid ${running}).`, leftoverFix(running, serviceHolding(config.dataDir, running) !== null));
     }
     if (!config.assumeYes) {
         if (process.stdin.isTTY !== true) {
@@ -121,6 +136,12 @@ function enableAccount(config, id, enabled) {
     else
         registry.disable(id);
     say(ok(`Account "${id}" ${enabled ? "enabled" : "disabled"}.`));
+    warnIfServerRunning(config);
+}
+function defaultAccount(config, id) {
+    AccountRegistry.load(config.dataDir).setDefault(id);
+    say(ok(`Default account: "${id}".`));
+    warnIfServerRunning(config);
 }
 export function runMigrate(config) {
     const [verb] = config.args;

package/dist/account-hub.js

@@ -3,6 +3,7 @@
  * a live service for each enabled one, with its own reconnect loop and write
  * bucket. MCP tools resolve a service per call.
  */
+import { AccountRegistry } from "./accounts.js";
 import { accountPaths } from "./config.js";
 import { WazapError } from "./errors.js";
 import { logError } from "./logger.js";
@@ -48,6 +49,9 @@ export function singletonSource(wa) {
         findByDraft: (did) => (typeof wa.hasDraft === "function" && wa.hasDraft(did) ? [binding] : []),
         record: (requested) => (requested === id ? self() : undefined),
         records: () => [self()],
+        // The stub has no disk: what it knows is all there is.
+        recordOnDisk: (requested) => (requested === id ? self() : undefined),
+        noteOwner: () => { },
     };
 }
 export class AccountHub {
@@ -56,9 +60,11 @@ export class AccountHub {
     givenUp = new Set();
     primary;
     primaryId;
+    dataDir;
     /** Process exit hook. Fires only after every enabled account has given up. */
     onGiveUp = null;
     constructor(config, registry) {
+        this.dataDir = config.dataDir;
         for (const account of registry.all()) {
             this.known.set(account.id, { ...account });
         }
@@ -69,6 +75,7 @@ export class AccountHub {
         for (const account of enabled) {
             const wa = new WhatsAppService(config, account, accountPaths(config.dataDir, account.id));
             wa.onGiveUp = () => this.noteGiveUp(account.id);
+            wa.onLinked = (linked) => this.noteOwner(account.id, linked.id);
             this.services.set(account.id, wa);
         }
         const firstId = enabled[0].id;
@@ -119,6 +126,30 @@ export class AccountHub {
     records() {
         return [...this.known.values()].map((account) => ({ ...account }));
     }
+    /**
+     * The registry re-read from disk, so a tool can tell "account added after
+     * this server started" apart from "no such account" and ask for a restart.
+     */
+    recordOnDisk(id) {
+        try {
+            return AccountRegistry.load(this.dataDir).get(id);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    noteOwner(id, owner) {
+        try {
+            AccountRegistry.load(this.dataDir).setOwner(id, owner);
+            const record = this.known.get(id);
+            if (record !== undefined)
+                record.owner = owner;
+        }
+        catch (err) {
+            // A linked session still works; the display field is what is lost.
+            logError(`owner persist ${id}`, err);
+        }
+    }
     noteGiveUp(id) {
         if (this.givenUp.has(id))
             return;

package/dist/account-resolve.js

@@ -2,6 +2,7 @@
  * Per-call account resolution and the list/status overlays that need the hub.
  * Tool handlers stay in tools.ts.
  */
+import { ownerNumber } from "./accounts.js";
 import { WazapError } from "./errors.js";
 import { maskNumber } from "./ui.js";
 const FIX_ADD_ACCOUNT = "Run `wazap account add`";
@@ -38,6 +39,14 @@ function resolveGivenId(hub, requested, toolName) {
         throw new WazapError("ACCOUNT_DISABLED", `Account "${requested}" is disabled.`, `Run \`wazap account enable ${requested}\` and restart the server`);
     }
     if (live === undefined) {
+        // The registry may have grown since this server started; `record` reads a
+        // snapshot, so check disk before calling the id unknown.
+        const onDisk = hub.recordOnDisk(requested);
+        if (onDisk !== undefined) {
+            throw new WazapError("ACCOUNT_NOT_FOUND", `Account "${requested}" was added after this server started.`, onDisk.enabled
+                ? "Restart the server so it picks up the account (`wazap service restart`, or restart your client)"
+                : `Run \`wazap account enable ${requested}\`, then restart the server`);
+        }
         const fix = toolName === "link_account" ? FIX_ADD_ACCOUNT : `${FIX_ADD_ACCOUNT}, or call list_accounts`;
         throw new WazapError("ACCOUNT_NOT_FOUND", `No account "${requested}".`, fix);
     }
@@ -79,7 +88,7 @@ function listedFromRecord(record) {
         id: record.id,
         name: record.name,
         status: record.enabled ? "disconnected" : "disabled",
-        phone_masked: null,
+        phone_masked: record.owner === null ? null : maskNumber(ownerNumber(record.owner)),
         owner_name: null,
         write_tools: false,
         enabled: record.enabled,
@@ -87,7 +96,9 @@ function listedFromRecord(record) {
 }
 function renderAccountLines(rows) {
     return rows.map((row) => {
-        const who = row.owner_name ? `${row.owner_name}${row.phone_masked ? ` (${row.phone_masked})` : ""}` : "not linked";
+        const who = row.owner_name
+            ? `${row.owner_name}${row.phone_masked ? ` (${row.phone_masked})` : ""}`
+            : (row.phone_masked ?? "not linked");
         const writes = row.write_tools ? "writes on" : "writes off";
         const flag = row.enabled ? row.status : "disabled";
         return `- **${row.id}** (${row.name}) · ${flag} · ${who} · ${writes}`;

package/dist/accounts.js

@@ -1,5 +1,6 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { readLinkedAccount } from "./auth-state.js";
 import { accountPaths, paths } from "./config.js";
 import { WazapError } from "./errors.js";
 export const DEFAULT_ACCOUNT_ID = "default";
@@ -71,7 +72,24 @@ function parseAccountRecord(value, file) {
         }
         record.rate_limit = value.rate_limit;
     }
-    return record;
+    return { ...record, ...webhookFields(value.id, value.webhook_url, value.webhook_secret, ` in ${file}`) };
+}
+/** Shared by load and `setWebhook` so a writer cannot persist what load refuses. */
+function webhookFields(id, url, secret, where = "", fix = "Fix or remove accounts.json") {
+    const fields = {};
+    if (url !== undefined) {
+        if (typeof url !== "string" || url.trim() === "") {
+            throw new WazapError("INVALID_ID", `Account "${id}"${where} has a bad webhook_url.`, fix);
+        }
+        fields.webhook_url = url.trim().replace(/\/+$/, "");
+    }
+    if (secret !== undefined) {
+        if (typeof secret !== "string" || secret === "") {
+            throw new WazapError("INVALID_ID", `Account "${id}"${where} has a bad webhook_secret.`, fix);
+        }
+        fields.webhook_secret = secret;
+    }
+    return fields;
 }
 function parseAccountsFile(value, file) {
     if (!isRecord(value) || value.v !== 2 || typeof value.default !== "string" || !Array.isArray(value.accounts)) {
@@ -179,6 +197,28 @@ export class AccountRegistry {
     setWrites(id, writes) {
         this.commit(this.withAccount(id, (account) => ({ ...account, writes })));
     }
+    setWebhook(id, webhook) {
+        this.commit(this.withAccount(id, (account) => ({
+            ...account,
+            ...webhookFields(id, webhook.url, webhook.secret, "", "Set a non-empty webhook URL or secret"),
+        })));
+    }
+    /** Drop the per-account override so the account follows the global webhook again. */
+    clearWebhook(id) {
+        this.commit(this.withAccount(id, (account) => {
+            const next = { ...account };
+            delete next.webhook_url;
+            delete next.webhook_secret;
+            return next;
+        }));
+    }
+    setDefault(id) {
+        const slug = parseAccountId(id);
+        if (!this.file.accounts.some((account) => account.id === slug)) {
+            throw new WazapError("INVALID_ID", `No account "${slug}".`, FIX_LIST);
+        }
+        this.commit({ ...this.file, default: slug });
+    }
     commit(next) {
         writeJsonFile(paths(this.dataDir).accountsFile, next);
         this.file = next;
@@ -215,3 +255,21 @@ export function ensureAccountsFile(dataDir) {
         registry.save();
     return registry;
 }
+/** The digits of an owner jid like `40734…:75@s.whatsapp.net`, for display. */
+export function ownerNumber(owner) {
+    return owner.split(/[:@]/)[0] ?? "";
+}
+/**
+ * Whether any configured account has linked credentials on disk. `status` and
+ * the doctor checks answer for the data dir, not only the selected account.
+ */
+export function anyAccountLinked(dataDir, registry = AccountRegistry.load(dataDir)) {
+    return registry.all().some((account) => {
+        try {
+            return readLinkedAccount(accountPaths(dataDir, account.id).authDir) !== null;
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/cli.js

@@ -68,16 +68,20 @@ export async function runStatus(config) {
     const serverPid = lockHolder(p.lockFile);
     const daemon = readDaemon(p.daemonFile);
     const sharing = daemon !== null && daemon.pid === serverPid ? { pid: daemon.pid, port: daemon.port } : null;
+    const rows = accountRows(config);
     const report = {
         data_dir: config.dataDir,
-        linked: account !== null,
+        // The dir is linked when any account is; `account` still describes the
+        // selected one, and `accounts` carries each row's own credentials.
+        linked: account !== null || rows.some((row) => row.account !== null),
         credentials_readable: !unreadable,
         account,
-        accounts: accountRows(config),
+        accounts: rows,
         wazap_version: WAZAP_VERSION,
         baileys_version: BAILEYS_VERSION,
         install: whereInstalled(),
         server_pid: serverPid,
+        server_is_service: serverPid !== null && serviceHolding(config.dataDir, serverPid) !== null,
         daemon: sharing,
         checks: await runChecks(config),
     };
@@ -102,15 +106,10 @@ export async function runStatus(config) {
 /** Today's phrasing, kept verbatim so pipes and log captures keep parsing. */
 function plainStatus(report) {
     const lines = [`data dir: ${report.data_dir}`];
-    if (!report.credentials_readable) {
-        lines.push("linked: no (credentials unreadable — run `wazap logout` then `wazap login`)");
-    }
-    else if (report.account) {
-        lines.push("linked: yes", `account: ${describeAccount(report.account)}`);
-    }
-    else {
-        lines.push("linked: no");
-    }
+    const credsNote = report.credentials_readable ? "" : " (credentials unreadable — run `wazap logout` then `wazap login`)";
+    lines.push(`linked: ${report.linked ? "yes" : "no"}${credsNote}`);
+    if (report.account)
+        lines.push(`account: ${describeAccount(report.account)}`);
     if (report.accounts.length > 1) {
         lines.push("accounts:");
         for (const row of report.accounts) {
@@ -360,9 +359,19 @@ async function testTranscribe(settings, file) {
     say(ok(facts.filter((fact) => fact !== undefined).join(" · ")));
     say(`"${transcript.text}"`);
 }
-/** The one line that names the leftover pid, so greet, login and logout cannot drift. */
-export function leftoverFix(pid) {
-    return `stop it first: kill ${pid}`;
+/**
+ * The one line that names the leftover pid, so greet, login and logout cannot
+ * drift. `kill` on a service-held pid just gets it restarted by the supervisor,
+ * so that case names the service verb instead.
+ */
+export function leftoverFix(pid, heldByService = false) {
+    return heldByService ? "stop it first: `wazap service stop`" : `stop it first: kill ${pid}`;
+}
+/** A mutation the running server cannot see asks for a restart, on the spot. */
+export function warnIfServerRunning(config) {
+    const running = lockHolder(paths(config.dataDir).lockFile);
+    if (running !== null)
+        say(warn(`A server is running (pid ${running}); restart it for this to apply.`));
 }
 /**
  * A client-launched wazap holding the session, or null if the lock is free or
@@ -382,7 +391,7 @@ export function greetNext(report) {
     if (report.server_pid !== null) {
         lines.push(info(`A server is already running (pid ${report.server_pid}).`));
         if (!report.linked || !report.credentials_readable) {
-            lines.push(fix(leftoverFix(report.server_pid)));
+            lines.push(fix(leftoverFix(report.server_pid, report.server_is_service === true)));
         }
     }
     if (!report.credentials_readable) {
@@ -717,7 +726,7 @@ const SERVICE_STOP_MS = 10_000;
  * quit; the background service is ours to stop, which is why the returned
  * function starts it again. What `~/.wazap/link.sh` did by hand.
  */
-export async function yieldSession(config, lockFile) {
+export async function yieldSession(config, lockFile, why = "pairing") {
     const running = takeSessionLock(lockFile);
     if (running === null)
         return () => { };
@@ -725,7 +734,7 @@ export async function yieldSession(config, lockFile) {
     if (held === null) {
         throw leftoverRefusal(config) ?? new WazapError("WHATSAPP_ERROR", `wazap is running (pid ${running}).`, leftoverFix(running));
     }
-    say(info("Stopping the wazap service for pairing"));
+    say(info(`Stopping the wazap service for ${why}`));
     held.supervisor.stop(held.record);
     let resumed = false;
     const resume = () => {
@@ -841,44 +850,45 @@ class Countdown {
 export async function runLogout(config) {
     const p = paths(config.dataDir);
     const selected = resolveAccount(config.dataDir, config.accountId);
-    const running = lockHolder(p.lockFile);
-    if (running !== null) {
-        say(fail(`wazap is running (pid ${running}).`));
-        say(fix(leftoverFix(running)));
-        process.exit(1);
-    }
-    let linked = null;
-    let unreadable = false;
+    const resumeService = await yieldSession(config, p.lockFile, "logout");
     try {
-        linked = readLinkedAccount(selected.paths.authDir);
-    }
-    catch {
-        // Unreadable creds are exactly what logout exists to clear, so keep going.
-        unreadable = true;
-    }
-    if (!linked && !unreadable) {
-        say(info("Not linked."));
-        return;
-    }
-    if (linked) {
-        const deadline = Date.now() + LOGOUT_TIMEOUT_MS;
+        let linked = null;
+        let unreadable = false;
         try {
-            const sock = await linkSession(selected.paths.authDir, { deadline });
-            await withDeadline(sock.logout(), deadline, "WhatsApp did not confirm the unlink in time.");
+            linked = readLinkedAccount(selected.paths.authDir);
         }
-        catch (err) {
-            if (alreadyUnlinked(err)) {
-                say(info("WhatsApp had already unlinked this device."));
+        catch {
+            // Unreadable creds are exactly what logout exists to clear, so keep going.
+            unreadable = true;
+        }
+        if (!linked && !unreadable) {
+            say(info("Not linked."));
+            return;
+        }
+        if (linked) {
+            const deadline = Date.now() + LOGOUT_TIMEOUT_MS;
+            try {
+                const sock = await linkSession(selected.paths.authDir, { deadline });
+                await withDeadline(sock.logout(), deadline, "WhatsApp did not confirm the unlink in time.");
             }
-            else {
-                logError("unlink from WhatsApp", err);
-                say(warn("Could not tell WhatsApp to unlink; remove this device from your phone if it is still listed."));
+            catch (err) {
+                if (alreadyUnlinked(err)) {
+                    say(info("WhatsApp had already unlinked this device."));
+                }
+                else {
+                    logError("unlink from WhatsApp", err);
+                    say(warn("Could not tell WhatsApp to unlink; remove this device from your phone if it is still listed."));
+                }
             }
         }
+        clearSession(selected.paths);
+        selected.registry.setOwner(selected.account.id, null);
+        say(ok("Logged out. Local credentials deleted."));
+    }
+    finally {
+        releaseLock(p.lockFile);
+        resumeService();
     }
-    clearSession(selected.paths);
-    selected.registry.setOwner(selected.account.id, null);
-    say(ok("Logged out. Local credentials deleted."));
     process.exit(0);
 }
 /**

package/dist/config.js

@@ -56,7 +56,7 @@ const COMMAND_ARGS = {
     migrate: [1],
 };
 const COMMANDS = Object.keys(COMMAND_ARGS);
-export const ACCOUNT_USAGE = "Run `wazap account add <id> [--name <name>]`, `wazap account remove|enable|disable <id>`, or `wazap account list`";
+export const ACCOUNT_USAGE = "Run `wazap account add <id> [--name <name>]`, `wazap account remove|enable|disable|default <id>`, or `wazap account list`";
 export const MIGRATE_USAGE = "Run `wazap migrate rollback`";
 /**
  * What to type instead of `--help` when the arity is wrong. Literals, not

package/dist/doctor.js

@@ -1,7 +1,7 @@
 import { accessSync, constants, statSync } from "node:fs";
-import { accountPolicy, resolveAccount } from "./accounts.js";
+import { AccountRegistry, accountPolicy, anyAccountLinked, resolveAccount } from "./accounts.js";
 import { readLinkedAccount } from "./auth-state.js";
-import { WAZAP_VERSION, WRITES_ENABLE_FIX, WRITE_TOKEN_NOTE, isRemoteHttp, paths } from "./config.js";
+import { WAZAP_VERSION, WRITES_ENABLE_FIX, WRITE_TOKEN_NOTE, accountPaths, isRemoteHttp, paths } from "./config.js";
 import { asWazapError } from "./errors.js";
 import { lockHolder, lockPid } from "./lock.js";
 import { oauthProblem, readGrants } from "./oauth.js";
@@ -36,7 +36,7 @@ export async function runChecks(config) {
         checks.push(...[await check(config)].flat());
     let linked = false;
     try {
-        linked = readLinkedAccount(resolveAccount(config.dataDir, config.accountId).paths.authDir) !== null;
+        linked = anyAccountLinked(config.dataDir);
     }
     catch {
         linked = false;
@@ -122,7 +122,7 @@ function checkService(config) {
     if (pid === null) {
         return { name: "service", state: "fail", detail: "installed but not running", fix: "run `wazap service start`" };
     }
-    if (record.installedVersion !== WAZAP_VERSION) {
+    if (isNewer(WAZAP_VERSION, record.installedVersion)) {
         return {
             name: "service",
             state: "info",
@@ -130,21 +130,42 @@ function checkService(config) {
             fix: "run `wazap service restart`",
         };
     }
+    if (isNewer(record.installedVersion, WAZAP_VERSION)) {
+        return {
+            name: "service",
+            state: "info",
+            detail: `runs ${record.installedVersion}, but only ${WAZAP_VERSION} is installed`,
+            fix: "run `wazap update` — restarting keeps the newer build",
+        };
+    }
     return { name: "service", state: "ok", detail: `running (pid ${pid}, ${supervisor.name})` };
 }
 function checkCredentials(config) {
-    const authDir = resolveAccount(config.dataDir, config.accountId).paths.authDir;
+    // The data dir is linked when any account is; every corrupt record fails,
+    // naming its account.
+    let records;
     try {
-        const account = readLinkedAccount(authDir);
-        // The number is deliberately absent: status is the thing people screenshot.
-        return account === null
-            ? { name: "credentials", state: "info", detail: "no account linked yet" }
-            : { name: "credentials", state: "ok", detail: "readable" };
+        records = AccountRegistry.load(config.dataDir).all();
     }
     catch (err) {
         const wazap = err;
         return { name: "credentials", state: "fail", detail: wazap.message, fix: wazap.fix };
     }
+    const linkedIds = [];
+    for (const record of records) {
+        try {
+            if (readLinkedAccount(accountPaths(config.dataDir, record.id).authDir) !== null)
+                linkedIds.push(record.id);
+        }
+        catch (err) {
+            const wazap = err;
+            return { name: "credentials", state: "fail", detail: `${record.id}: ${wazap.message}`, fix: wazap.fix };
+        }
+    }
+    if (linkedIds.length === 0)
+        return { name: "credentials", state: "info", detail: "no account linked yet" };
+    // The number is deliberately absent: status is the thing people screenshot.
+    return { name: "credentials", state: "ok", detail: records.length > 1 ? `readable (${linkedIds.join(", ")})` : "readable" };
 }
 function checkWrites(config) {
     const selected = resolveAccount(config.dataDir, config.accountId);

package/dist/index.js

@@ -26,7 +26,7 @@ Usage:
   wazap expose [tailscale|cloudflare|off]                  Give the running service a public https URL cloud agents can reach
   wazap config [writes on|off] [transcribe local|openai|off] [webhook on|off]
                                                            Show the effective settings, or change one
-  wazap webhook test                                       POST a test message_received to the configured webhook
+  wazap webhook test [--account <id>]                      POST a test message_received to the configured webhook
   wazap transcribe download [--model <alias>]              Fetch the whisper.cpp model into the data dir
   wazap transcribe test <audio file>                       Transcribe a local file with the configured provider
   wazap contacts resync                                    Fetch the phone's address book from WhatsApp again
@@ -34,7 +34,7 @@ Usage:
   wazap status [--live] [--json] [--account <id>]          Check the install, the session and the server
   wazap logout [--account <id>]                            Unlink and delete local credentials
   wazap account add <id> [--name <name>]                   Add an account slot
-  wazap account remove|enable|disable <id>                 Change an account, or delete its local data
+  wazap account remove|enable|disable|default <id>         Change an account, or delete its local data
   wazap account list                                       List accounts in this data dir
   wazap migrate rollback                                   Undo a flat-layout move into accounts/
 
@@ -44,7 +44,8 @@ Tunnel providers for wazap expose: ${PROVIDER_NAMES}.
 
 Options:
   --data-dir <path>   Where wazap keeps its data (default ~/.wazap, or $WAZAP_DATA_DIR)
-  --account <id>      With login, logout, status, contacts, config writes: pick this account
+  --account <id>      With login, logout, status, contacts, config writes|webhook, webhook test:
+                      pick this account. account add|enable|disable|default apply on server restart
   --name <name>       With account add: a display name
   --read-only         Refuse every write; the write tools are not registered at all
   --http              Serve Streamable HTTP instead of stdio
@@ -89,8 +90,11 @@ async function main() {
     }
     const { config } = invocation;
     // Rollback is the inverse of this move. Running it first would re-apply a
-    // half-finished migrate and then fail to undo it.
-    if (config.command !== "migrate")
+    // half-finished migrate and then fail to undo it. The other exempt commands
+    // never open account state, and `service stop` is how a lock that blocks the
+    // migration is released.
+    const MIGRATE_EXEMPT = new Set(["migrate", "service", "connect", "skills", "expose", "update", "transcribe"]);
+    if (!MIGRATE_EXEMPT.has(config.command))
         migrateLayout(config.dataDir);
     switch (config.command) {
         case "serve":

package/dist/migrate.js

@@ -2,8 +2,9 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmdirSync,
 import { join } from "node:path";
 import { AccountRegistry, DEFAULT_ACCOUNT_ID, ensureAccountsFile, isRecord, writeJsonFile } from "./accounts.js";
 import { readLinkedAccount } from "./auth-state.js";
-import { accountPaths } from "./config.js";
+import { accountPaths, paths } from "./config.js";
 import { WazapError } from "./errors.js";
+import { lockHolder } from "./lock.js";
 /** Flat-layout names that move into accounts/default/. qr.png is leftover login art. */
 export const LAYOUT_ENTRIES = ["auth", "store.json", "history", "media", "previews", "notes.json", "qr.png"];
 function isDir(path) {
@@ -37,6 +38,17 @@ function leftoverEntries(dataDir) {
 function rollbackFix(dataDir) {
     return `Run \`wazap migrate rollback --data-dir ${dataDir}\``;
 }
+/**
+ * Moving `auth/` out from under a live process breaks it, and whatever it
+ * recreates at the root then blocks both migrate and rollback. The holder can
+ * only be a pre-migration build: every newer one migrated at its own start.
+ */
+function refuseWhileRunning(dataDir) {
+    const running = lockHolder(paths(dataDir).lockFile);
+    if (running === null)
+        return;
+    throw new WazapError("WHATSAPP_ERROR", `wazap is running (pid ${running}) on the old data layout.`, `stop it first (\`wazap service stop\` if it is the background service, otherwise \`kill ${running}\`), then run this again`);
+}
 function migrateFail(dataDir, message) {
     return new WazapError("WHATSAPP_ERROR", message, rollbackFix(dataDir));
 }
@@ -165,6 +177,7 @@ export function migrateLayout(dataDir) {
     const manifest = readManifest(manifestFile, dataDir);
     const defaultRoot = accountPaths(dataDir, DEFAULT_ACCOUNT_ID).root;
     if (leftover.length > 0) {
+        refuseWhileRunning(dataDir);
         applyMigration(dataDir, manifestFile, manifest);
         return;
     }
@@ -176,6 +189,7 @@ export function migrateLayout(dataDir) {
  * later add cannot be smashed back into a flat v0 dir.
  */
 export function rollbackMigration(dataDir) {
+    refuseWhileRunning(dataDir);
     const manifestFile = join(dataDir, "migration.json");
     const manifest = readManifest(manifestFile, dataDir);
     if (manifest === null) {

package/dist/settings.js

@@ -1,14 +1,14 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { AccountRegistry, accountPolicy, resolveAccount } from "./accounts.js";
-import { ask, askSecret } from "./cli.js";
+import { ask, askSecret, warnIfServerRunning } from "./cli.js";
 import { paths, writesHints } from "./config.js";
 import { WazapError, asWazapError } from "./errors.js";
 import { lockHolder } from "./lock.js";
 import { say } from "./logger.js";
 import { maskKey, readTranscribeSettings, requireSafeUrl, stripPasted, transcribeReady, } from "./transcribe/index.js";
 import { brand, dim, fix, ok, shortPath, warn } from "./ui.js";
-import { WEBHOOK_ON_FIX, WEBHOOK_TEST_FIX, WebhookSink, readWebhookSettings, requireWebhookUrl } from "./webhook.js";
+import { WEBHOOK_ON_FIX, WEBHOOK_TEST_FIX, WebhookSink, readWebhookSettings, requireWebhookUrl, } from "./webhook.js";
 /**
  * dotenv 16 treats an unquoted `#` as a comment, even with no space, and
  * trims unquoted padding. Quote so a secret like `p@ss#word` round-trips.
@@ -152,16 +152,20 @@ function transcribeRows(config) {
         rows.push(`api key: ${maskKey(settings.apiKey)}`);
     return rows;
 }
+function accountWebhook(config) {
+    const selected = resolveAccount(config.dataDir, config.accountId);
+    const override = { url: selected.account.webhook_url, secret: selected.account.webhook_secret };
+    const source = override.url !== undefined || override.secret !== undefined ? "accounts.json" : config.sources.webhook;
+    return { override, source };
+}
 function webhookRows(config) {
-    const settings = readWebhookSettings(process.env);
+    const { override, source } = accountWebhook(config);
+    const settings = readWebhookSettings(process.env, override);
     switch (settings.kind) {
         case "off":
-            return [`webhook: off (${config.sources.webhook})`];
+            return [`webhook: off (${source})`];
         case "ready":
-            return [
-                `webhook: on (${new URL(settings.url).host}) (${config.sources.webhook})`,
-                `secret: ${maskKey(settings.secret)}`,
-            ];
+            return [`webhook: on (${new URL(settings.url).host}) (${source})`, `secret: ${maskKey(settings.secret)}`];
         case "invalid":
             return [`webhook: ${settings.detail}${settings.fix === "" ? "" : ` — ${settings.fix}`}`];
         default: {
@@ -176,6 +180,16 @@ async function applyWebhook(config, value) {
         return;
     }
     if (value === "off") {
+        if (config.accountId !== undefined) {
+            // The on/off switch is global; only the endpoint is per-account. `off`
+            // scoped to an account drops its override so it follows the global again.
+            AccountRegistry.load(config.dataDir).clearWebhook(config.accountId);
+            const global = readWebhookSettings(process.env);
+            say(ok(`webhook override removed for ${config.accountId} — the global webhook applies${global.kind === "off" ? " (off)" : ""}.`));
+            say(dim(`Stored in ${shortPath(paths(config.dataDir).accountsFile)}.`));
+            warnIfServerRunning(config);
+            return;
+        }
         setWebhookFlag(config, "off");
         say(ok("webhook: off — live inbound messages are not posted anywhere. Turn it on with `wazap config webhook on`."));
         say(dim(`Stored in ${shortPath(paths(config.dataDir).envFile)}.`));
@@ -189,9 +203,12 @@ export async function runWebhook(config) {
     if (verb !== "test") {
         throw new WazapError("INVALID_ID", `Cannot run \`wazap webhook ${config.args.join(" ")}\`.`, WEBHOOK_TEST_FIX);
     }
-    await testWebhook();
+    await testWebhook(config);
 }
 async function enableWebhook(config) {
+    // An unknown --account fails before any prompt asks for a URL or a secret.
+    if (config.accountId !== undefined)
+        resolveAccount(config.dataDir, config.accountId);
     // A pipe is consumed whole by the first readline, so a script sets the URL
     // in the environment and only types the secret, the way transcribe does.
     let url;
@@ -214,6 +231,15 @@ async function enableWebhook(config) {
         throw new WazapError("INVALID_ID", "No webhook secret was typed.", "Run `wazap config webhook on` again");
     }
     const p = paths(config.dataDir);
+    if (config.accountId !== undefined) {
+        // The switch stays global; the URL and secret are this account's override.
+        AccountRegistry.load(config.dataDir).setWebhook(config.accountId, { url, secret });
+        setEnvSetting(p.envFile, "WAZAP_WEBHOOK", "on");
+        say(ok(`webhook: on for ${config.accountId} — live inbound messages POST to ${new URL(url).host} as message_received.`));
+        say(dim(`URL and secret stored in ${shortPath(p.accountsFile)}; WAZAP_WEBHOOK=on in ${shortPath(p.envFile)}.`));
+        warnIfServerRunning(config);
+        return;
+    }
     setEnvSetting(p.envFile, "WAZAP_WEBHOOK", "on");
     setEnvSetting(p.envFile, "WAZAP_WEBHOOK_URL", url);
     setEnvSetting(p.envFile, "WAZAP_WEBHOOK_SECRET", secret);
@@ -224,19 +250,15 @@ async function enableWebhook(config) {
 function setWebhookFlag(config, value) {
     setEnvSetting(paths(config.dataDir).envFile, "WAZAP_WEBHOOK", value);
 }
-async function testWebhook() {
-    const result = await new WebhookSink(process.env).sendTest();
+async function testWebhook(config) {
+    const selected = resolveAccount(config.dataDir, config.accountId);
+    const result = await new WebhookSink(process.env, { account: selected.account }).sendTest();
     if (result.ok) {
         say(ok("webhook: test delivered"));
         return;
     }
     throw new WazapError("INVALID_ID", result.error, result.fix === "" ? WEBHOOK_ON_FIX : result.fix);
 }
-function warnIfServerRunning(config) {
-    const running = lockHolder(paths(config.dataDir).lockFile);
-    if (running !== null)
-        say(warn(`A server is running (pid ${running}); restart it for this to apply.`));
-}
 const DEFAULT_URL = "https://api.openai.com/v1";
 const TRANSCRIBE_SAID = {
     local: "transcribe: local — whisper.cpp runs here, and the audio never leaves this machine.",
@@ -301,6 +323,10 @@ export function applyWrites(config, allowWrites) {
             ? `writes: on for ${config.accountId} — the agent can send from this account. Turn it off with \`wazap config writes off --account ${config.accountId}\`.`
             : `writes: off for ${config.accountId} — the agent can only read this account. Turn it on with \`wazap config writes on --account ${config.accountId}\`.`));
         say(dim(`Stored in ${shortPath(p.accountsFile)}.`));
+        // The account flag is set, but the global switch is a hard off either way.
+        if (allowWrites && config.readOnly) {
+            say(warn("Global read-only is still on, so writes stay off until `wazap config writes on` clears it."));
+        }
     }
     else {
         setEnvSetting(p.envFile, "WAZAP_READ_ONLY", allowWrites ? "0" : "1");

package/dist/webhook.js

@@ -1,6 +1,7 @@
 /**
- * W1 outbound webhook: one URL, one shared secret, one live event
- * (`message_received`). Delivery never throws into the WhatsApp or MCP path.
+ * W1 outbound webhook: one live event (`message_received`). Global URL and
+ * secret live in `.env`; an account may override either. Delivery never throws
+ * into the WhatsApp or MCP path.
  */
 import { createHmac, timingSafeEqual } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -19,7 +20,7 @@ const OFF = new Set(["", "off", "0", "no", "none", "false"]);
 const ON = new Set(["on", "1", "true", "yes"]);
 const LOOPBACK = new Set(["127.0.0.1", "::1", "localhost"]);
 /** The one place the webhook environment becomes typed. */
-export function readWebhookSettings(env = process.env) {
+export function readWebhookSettings(env = process.env, override = {}) {
     const raw = stripPasted(env.WAZAP_WEBHOOK ?? "");
     const flag = raw.toLowerCase();
     if (OFF.has(flag))
@@ -31,8 +32,10 @@ export function readWebhookSettings(env = process.env) {
             fix: "set WAZAP_WEBHOOK to on or off",
         };
     }
-    const urlRaw = stripPasted(env.WAZAP_WEBHOOK_URL ?? "").replace(/\/+$/, "");
-    const secret = stripPasted(env.WAZAP_WEBHOOK_SECRET ?? "");
+    const overrideUrl = stripPasted(override.url ?? "");
+    const overrideSecret = stripPasted(override.secret ?? "");
+    const urlRaw = (overrideUrl || stripPasted(env.WAZAP_WEBHOOK_URL ?? "")).replace(/\/+$/, "");
+    const secret = overrideSecret || stripPasted(env.WAZAP_WEBHOOK_SECRET ?? "");
     const missingUrl = urlRaw === "";
     const missingSecret = secret === "";
     if (missingUrl && missingSecret) {
@@ -84,7 +87,7 @@ export function previewText(text) {
         return text;
     return `${text.slice(0, WEBHOOK_TEXT_MAX - 1)}…`;
 }
-export function asWebhookPayload(view) {
+export function asWebhookPayload(view, account) {
     return {
         event: WEBHOOK_EVENT,
         from: view.sender.phone ?? view.sender.id,
@@ -92,6 +95,8 @@ export function asWebhookPayload(view) {
         ts: view.timestamp,
         text: previewText(view.text),
         message_id: view.message_id,
+        account_id: account.id,
+        account_name: account.name,
     };
 }
 export function webhookInfo(settings, lastError) {
@@ -111,16 +116,21 @@ export function webhookInfo(settings, lastError) {
 /** Posts `message_received` when the webhook is on and valid. Never throws. */
 export class WebhookSink {
     env;
+    lastError = null;
     post;
     retryDelays;
-    lastError = null;
-    constructor(env = process.env, post = fetch, retryDelays = WEBHOOK_RETRY_DELAYS_MS) {
+    account;
+    constructor(env = process.env, opts = {}) {
         this.env = env;
-        this.post = post;
-        this.retryDelays = retryDelays;
+        this.post = opts.post ?? fetch;
+        this.retryDelays = opts.retryDelays ?? WEBHOOK_RETRY_DELAYS_MS;
+        this.account = opts.account;
     }
     settings() {
-        return readWebhookSettings(this.env);
+        return readWebhookSettings(this.env, {
+            url: this.account?.webhook_url,
+            secret: this.account?.webhook_secret,
+        });
     }
     info() {
         return webhookInfo(this.settings(), this.lastError);
@@ -147,7 +157,7 @@ export class WebhookSink {
             case "invalid":
                 return { ok: false, error: settings.detail, fix: settings.fix };
             case "ready":
-                return this.postEvent(testPayload(), settings);
+                return this.postEvent(testPayload(this.account), settings);
             default: {
                 const _exhaustive = settings;
                 return _exhaustive;
@@ -198,7 +208,7 @@ export class WebhookSink {
         }
     }
 }
-function testPayload() {
+function testPayload(account) {
     return {
         event: WEBHOOK_EVENT,
         from: "wazap",
@@ -206,6 +216,8 @@ function testPayload() {
         ts: new Date().toISOString(),
         text: "wazap webhook test",
         message_id: "test",
+        account_id: account?.id ?? "default",
+        account_name: account?.name ?? "default",
     };
 }
 function hostOf(url) {

package/dist/whatsapp.js

@@ -141,6 +141,8 @@ export class WhatsAppService {
      * fix. The CLI turns it into an exit code, so a supervisor gets its turn.
      */
     onGiveUp = null;
+    /** Fires when a `link` lands, so the hub can persist the owner on the record. */
+    onLinked = null;
     account = null;
     /** The pairing in flight, from the first `link` call until it settles either way. */
     linking = null;
@@ -185,13 +187,14 @@ export class WhatsAppService {
     transcribing = new Map();
     drafts = new DraftStore();
     writes;
-    webhook = new WebhookSink();
+    webhook;
     accountRecord;
     effectiveReadOnly;
     effectiveRateLimit;
     constructor(config, account, paths) {
         this.config = config;
         this.accountRecord = account;
+        this.webhook = new WebhookSink(process.env, { account });
         const policy = accountPolicy(account, config);
         this.effectiveReadOnly = policy.readOnly;
         this.effectiveRateLimit = policy.rateLimit;
@@ -319,6 +322,7 @@ export class WhatsAppService {
         this.pairing = null;
         this.account = account;
         this.lastError = null;
+        this.onLinked?.(account);
         await this.start();
     }
     abandonLink(err) {
@@ -2033,7 +2037,7 @@ export class WhatsAppService {
             try {
                 const jid = this.canonical(raw.key.remoteJid ?? "");
                 const sid = messageIdFor(raw.key, jid);
-                void this.webhook.notify(asWebhookPayload(this.viewOf(sid, jid))).catch((err) => {
+                void this.webhook.notify(asWebhookPayload(this.viewOf(sid, jid), this.accountRecord)).catch((err) => {
                     logError("webhook", err);
                 });
             }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "wazap-mcp",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "mcpName": "io.github.razvangirgiz/wazap",
-  "description": "WhatsApp for your AI agent. MCP server over Baileys: pairing-code login, 32 tools, stdio or HTTP with bearer tokens and OAuth.",
+  "description": "WhatsApp for your AI agent. MCP server over Baileys: pairing-code login, several accounts, 33 tools, stdio or HTTP.",
   "license": "MIT",
   "author": "Răzvan Girgiz",
   "repository": {