wazap-mcp 0.16.0 → 0.18.0

package/README.md

@@ -545,9 +545,9 @@ 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.
+An account can override the global webhook URL, secret and event list in
+`accounts.json` (`webhook_url`, `webhook_secret`, `webhook_events`).
+`wazap webhook test --account work` posts with that account's id and name.
 
 ## Several clients at once
 
@@ -704,38 +704,119 @@ What to know before exposing it:
 
 ## Outbound webhook
 
-A live inbound message can POST to one URL. Off by default. History sync
-is not posted. The only event is `message_received`.
+Live events POST to one URL. Off by default. History sync is not posted.
+Only `message_received` is posted unless you ask for more, because a consumer
+that answers every POST without reading `event` would otherwise answer the
+messages its own owner typed on the phone.
+
+The `event` field names one of three. `message_received` is a message another
+person sent. `message_sent` is a message this account sent itself, typed on
+the phone or on another linked device; a message wazap sent through its own
+tools is not announced, so a consumer can never be made to answer itself.
+`connection` says the link came up, went down or expired.
+
+Ask for the other two in `WAZAP_WEBHOOK_EVENTS`, comma-separated
+(`message_received,connection`), or say `all` for the three of them. Case
+does not matter and the spaces around a name are ignored. An unknown name
+fails `wazap status`, doctor and setup. An account carries its own list as
+`webhook_events` in `accounts.json`.
 
 ```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 --event connection   # needs connection enabled
 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. An account may set `webhook_url` and
-`webhook_secret` in `accounts.json`; those win over the global URL and secret.
+and leaves WhatsApp and MCP running. An account may set `webhook_url`,
+`webhook_secret` and `webhook_events` in `accounts.json`; those win over the
+global URL, secret and event list, and `config webhook off --account work`
+clears all three.
+
+`webhook test --event <name>` posts nothing and exits non-zero when that
+event is not enabled, and says what to enable it with. While the webhook is
+on, `wazap config` prints the events it posts on an `events:` line.
 
 HMAC: `X-Wazap-Signature` is `sha256=<hex>`, HMAC-SHA256 of the exact raw
 JSON body with the secret that signed it. Verify that raw body, not a
 re-serialized object. HTTPS only, except `http://` on loopback.
 
+`text` is a preview, cut at 2000 characters and ending in a single `…`.
+`truncated` is true when it was cut. For `kind: "audio"`, `text` is the
+transcription when wazap auto-transcribed the note itself, which it does for
+incoming notes only; the event waits up to 60 seconds for those words. In
+every other case `text` is the `[voice message · 0:42]` placeholder: a note
+you recorded yourself, a note longer than 600 seconds, a note WhatsApp stated
+no duration for, and a transcription that failed. `ts` is the original local
+time with a numeric offset, kept for consumers already reading it, and
+`timestamp` is the same instant in UTC.
+
+Events are not guaranteed to arrive in the order they happened. A message held
+for its transcript is overtaken by the messages behind it, so order by
+`timestamp` and not by arrival. Connection events are the exception: they are
+delivered in the order the link moved in.
+
+A message another person sent:
+
 ```json
 {
   "event": "message_received",
-  "from": "+15550100",
+  "from": "15550100",
   "chat_id": "15550100@s.whatsapp.net",
-  "ts": "2026-09-08T14:00:00+00:00",
-  "text": "hello, or a short preview",
+  "ts": "2026-09-08T17:00:00+03:00",
+  "timestamp": "2026-09-08T14:00:00.000Z",
+  "text": "hello, or a preview of something longer",
+  "truncated": false,
+  "kind": "text",
+  "from_me": false,
+  "is_self_chat": false,
   "message_id": "false_15550100@s.whatsapp.net_3EB0…",
   "account_id": "default",
   "account_name": "default"
 }
 ```
 
+A message sent from the phone, here in the "Message yourself" chat:
+
+```json
+{
+  "event": "message_sent",
+  "from": "15551234",
+  "chat_id": "15551234@s.whatsapp.net",
+  "ts": "2026-09-08T17:04:12+03:00",
+  "timestamp": "2026-09-08T14:04:12.000Z",
+  "text": "call the notary at 14:00 on Wednesday",
+  "truncated": false,
+  "kind": "text",
+  "from_me": true,
+  "is_self_chat": true,
+  "message_id": "true_15551234@s.whatsapp.net_3EB0…",
+  "account_id": "default",
+  "account_name": "default"
+}
+```
+
+A connection change. `status` is `linked`, `disconnected` or `expired`;
+`not_linked`, `linking` and `connecting` post nothing, and two changes that
+mean the same status post once.
+
+```json
+{
+  "event": "connection",
+  "status": "expired",
+  "timestamp": "2026-09-08T14:10:00.000Z",
+  "account_id": "default",
+  "account_name": "default"
+}
+```
+
+`connection` reports what the socket does while wazap is running. A clean
+shutdown posts nothing, and a crash posts nothing either, so silence does not
+mean the link is up. Poll `get_status` when you need to know that.
+
 ## Settings
 
 | Variable | Default | Meaning |
@@ -759,9 +840,10 @@ re-serialized object. HTTPS only, except `http://` on loopback.
 | `WAZAP_TRANSCRIBE_API_KEY` | unset | API key; `OPENAI_API_KEY` is the fallback. Never a flag. |
 | `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` | `off` | `on` posts the enabled events to the webhook URL. |
 | `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. |
+| `WAZAP_WEBHOOK_EVENTS` | unset (`message_received`) | Which events to post, comma-separated, or `all`. An account `webhook_events` wins. |
 
 Flags beat environment variables, which beat `<data-dir>/.env`.
 

package/dist/account-cli.js

@@ -38,7 +38,7 @@ export function describeStatusAccount(row) {
 export function accountRows(config) {
     const registry = AccountRegistry.load(config.dataDir);
     return registry.all().map((record) => {
-        let linked = null;
+        let linked;
         try {
             linked = readLinkedAccount(accountPaths(config.dataDir, record.id).authDir);
         }

package/dist/account-resolve.js

@@ -136,7 +136,9 @@ export function renderGetStatus(s, writeTools, hub) {
         `- **contacts named**: ${s.contacts_named}`,
         `- **data dir**: ${s.data_dir} · **read-only**: ${s.read_only} · **write tools**: ${writeLine} · **rate limit**: ${s.rate_limit}/min`,
         `- **versions**: wazap ${s.wazap_version}, baileys ${s.baileys_version}`,
-        s.pairing ? `- **pairing code**: ${s.pairing.code} for ${s.pairing.phone_masked}, until ${s.pairing.expires_at}` : null,
+        s.pairing
+            ? `- **pairing code**: ${s.pairing.code} for ${s.pairing.phone_masked}, until ${s.pairing.expires_at}`
+            : null,
         webhookStatusLine(s.webhook),
         s.last_error ? `- **last error**: ${s.last_error}` : null,
         s.hint ? `- **hint**: ${s.hint}` : null,

package/dist/accounts.js

@@ -2,7 +2,8 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, wri
 import { dirname } from "node:path";
 import { readLinkedAccount } from "./auth-state.js";
 import { accountPaths, paths } from "./config.js";
-import { WazapError } from "./errors.js";
+import { WazapError, asWazapError } from "./errors.js";
+import { parseWebhookEvents } from "./webhook.js";
 export const DEFAULT_ACCOUNT_ID = "default";
 export const ACCOUNT_ID_RE = /^[a-z0-9][a-z0-9-]{0,31}$/;
 const FIX_LIST = "Run `wazap account list`";
@@ -72,10 +73,13 @@ function parseAccountRecord(value, file) {
         }
         record.rate_limit = value.rate_limit;
     }
-    return { ...record, ...webhookFields(value.id, value.webhook_url, value.webhook_secret, ` in ${file}`) };
+    return {
+        ...record,
+        ...webhookFields(value.id, value.webhook_url, value.webhook_secret, value.webhook_events, ` 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") {
+function webhookFields(id, url, secret, events, where = "", fix = "Fix or remove accounts.json") {
     const fields = {};
     if (url !== undefined) {
         if (typeof url !== "string" || url.trim() === "") {
@@ -89,6 +93,19 @@ function webhookFields(id, url, secret, where = "", fix = "Fix or remove account
         }
         fields.webhook_secret = secret;
     }
+    if (events !== undefined) {
+        if (typeof events !== "string" || events.trim() === "") {
+            throw new WazapError("INVALID_ID", `Account "${id}"${where} has a bad webhook_events.`, fix);
+        }
+        const trimmed = events.trim();
+        try {
+            parseWebhookEvents(trimmed);
+        }
+        catch (err) {
+            throw new WazapError("INVALID_ID", `Account "${id}"${where} has a bad webhook_events: ${asWazapError(err).message}`, fix);
+        }
+        fields.webhook_events = trimmed;
+    }
     return fields;
 }
 function parseAccountsFile(value, file) {
@@ -200,7 +217,7 @@ export class AccountRegistry {
     setWebhook(id, webhook) {
         this.commit(this.withAccount(id, (account) => ({
             ...account,
-            ...webhookFields(id, webhook.url, webhook.secret, "", "Set a non-empty webhook URL or secret"),
+            ...webhookFields(id, webhook.url, webhook.secret, undefined, "", "Set a non-empty webhook URL or secret"),
         })));
     }
     /** Drop the per-account override so the account follows the global webhook again. */
@@ -209,6 +226,7 @@ export class AccountRegistry {
             const next = { ...account };
             delete next.webhook_url;
             delete next.webhook_secret;
+            delete next.webhook_events;
             return next;
         }));
     }

package/dist/cli.js

@@ -23,13 +23,14 @@ import { lockHolder, releaseLock, writeLock } from "./lock.js";
 import { log, logError, say } from "./logger.js";
 import { clockLabel, formatAge } from "./messages.js";
 import { oauthProblem } from "./oauth.js";
+import { downloadEmbed, embedModelSpec, readRecallSettings, } from "./recall/index.js";
 import { PAIRING_TIMEOUT_MS, linkSession, prettyCode, settledAccount, startPairing } from "./pairing.js";
 import { runHttp, runStdio, startLoopbackEndpoint } from "./server.js";
 import { fetchHealth, serviceHolding } from "./service.js";
 import { applyWrites } from "./settings.js";
 import { MODELS, downloadModel, maskKey, modelSpec, readTranscribeSettings, stripPasted, transcribeFile, transcribeReady, } from "./transcribe/index.js";
 import { bold, box, brand, humanLayout, dim, fail, fix, info, maskNumber, next, ok, openScreen, qrSavedLine, shortPath, spinner, tilde, warn, } from "./ui.js";
-import { loginWizardSteps, maybeWizard, wizDim, wizFail, wizInfo, wizOk, wizWarn, } from "./wizard.js";
+import { loginWizardSteps, maybeWizard, wizDim, wizFail, wizInfo, wizOk, wizWarn } from "./wizard.js";
 import { WhatsAppService } from "./whatsapp.js";
 /** How long a probe waits for the socket to settle; tests shorten it through the environment. */
 const LIVE_TIMEOUT_MS = Number.parseInt(process.env.WAZAP_LIVE_TIMEOUT_MS ?? "", 10) || 15_000;
@@ -106,7 +107,9 @@ 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}`];
-    const credsNote = report.credentials_readable ? "" : " (credentials unreadable — run `wazap logout` then `wazap login`)";
+    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)}`);
@@ -326,6 +329,32 @@ export async function downloadTranscribeModel(settings, spec) {
         throw err;
     }
 }
+/** `wazap embed download`. */
+export async function runEmbed(config) {
+    const [verb] = config.args;
+    if (verb !== "download") {
+        throw new WazapError("INVALID_ID", `Cannot run \`wazap embed ${config.args.join(" ")}\`.`, "Run `wazap embed download`");
+    }
+    await ensureDeps([DEPS.llama], config);
+    const settings = readRecallSettings(process.env, config.dataDir);
+    await downloadEmbedModel(settings, config.modelName);
+}
+/** The same check-then-fetch dance downloadTranscribeModel does, for the embed table. */
+export async function downloadEmbedModel(settings, modelName) {
+    const spec = embedModelSpec(modelName ?? settings.model);
+    const spin = spinner(`Checking ${spec.file}…`);
+    try {
+        const result = await downloadEmbed(settings.modelsDir, spec, (progress) => {
+            const percent = Math.floor((progress.received / progress.total) * 100);
+            spin.update(`Downloading ${spec.file} — ${mib(progress.received)} / ${mib(progress.total)} MiB (${percent}%)`);
+        });
+        spin.stop(ok(`${spec.file} (${mib(spec.bytes)} MiB) ${result.alreadyPresent ? "already present" : "verified"}`));
+    }
+    catch (err) {
+        spin.stop();
+        throw err;
+    }
+}
 /** What identifies each provider on screen. Keyed like PROVIDERS, never branched on. */
 const PROVIDER_ROWS = {
     local: (settings) => [
@@ -617,7 +646,10 @@ export async function linkAndSync(config, announce = () => { }, w = null) {
             announce("Link your phone");
         let account;
         try {
-            account = phone === null ? await linkByQr(selected.paths, waiting, w) : await linkByCode(selected.paths.authDir, phone, waiting, w);
+            account =
+                phone === null
+                    ? await linkByQr(selected.paths, waiting, w)
+                    : await linkByCode(selected.paths.authDir, phone, waiting, w);
         }
         catch (err) {
             waiting.stop();
@@ -732,7 +764,8 @@ export async function yieldSession(config, lockFile, why = "pairing") {
         return () => { };
     const held = serviceHolding(config.dataDir, running);
     if (held === null) {
-        throw leftoverRefusal(config) ?? new WazapError("WHATSAPP_ERROR", `wazap is running (pid ${running}).`, leftoverFix(running));
+        throw (leftoverRefusal(config) ??
+            new WazapError("WHATSAPP_ERROR", `wazap is running (pid ${running}).`, leftoverFix(running)));
     }
     say(info(`Stopping the wazap service for ${why}`));
     held.supervisor.stop(held.record);

package/dist/compact.js

@@ -30,7 +30,13 @@ export function compactConversations(conversations) {
                 last.message_ids.push(m.message_id);
                 continue;
             }
-            lines.push({ timestamp: m.timestamp, sender: m.sender.id, from_me: m.from_me, text: m.text, message_ids: [m.message_id] });
+            lines.push({
+                timestamp: m.timestamp,
+                sender: m.sender.id,
+                from_me: m.from_me,
+                text: m.text,
+                message_ids: [m.message_id],
+            });
             // The name rides on the line, once, for the renderer.
             lines[lines.length - 1].name = m.from_me
                 ? "me"
@@ -40,7 +46,14 @@ export function compactConversations(conversations) {
         }
         if (lines.length === 0 && dropped.media === 0 && dropped.wordless === 0)
             continue;
-        out.push({ chat_id: c.chat_id, chat_name: c.chat_name, type: c.type, ...(c.note ? { note: c.note } : {}), lines, dropped });
+        out.push({
+            chat_id: c.chat_id,
+            chat_name: c.chat_name,
+            type: c.type,
+            ...(c.note ? { note: c.note } : {}),
+            lines,
+            dropped,
+        });
     }
     return out;
 }

package/dist/config.js

@@ -50,6 +50,7 @@ const COMMAND_ARGS = {
     // No positional means the first available provider; `off` takes the tunnel down.
     expose: [0, 1],
     transcribe: [1, 2],
+    embed: [1],
     update: [0],
     webhook: [1],
     account: [1, 2],
@@ -67,8 +68,9 @@ const COMMAND_USAGE = {
     skills: "Run `wazap skills install [<harness>]`",
     service: "Run `wazap service install|status|start|stop|restart|logs|uninstall`",
     transcribe: "Run `wazap transcribe download` or `wazap transcribe test <audio file>`",
+    embed: "Run `wazap embed download`",
     contacts: "Run `wazap contacts resync`",
-    config: "Run `wazap config`, `wazap config writes on|off`, `wazap config transcribe local|openai|off`, or `wazap config webhook on|off`",
+    config: "Run `wazap config`, `wazap config writes on|off`, `wazap config transcribe local|openai|off`, `wazap config recall local|off`, or `wazap config webhook on|off`",
     webhook: "Run `wazap webhook test`",
     account: ACCOUNT_USAGE,
     migrate: MIGRATE_USAGE,
@@ -163,6 +165,7 @@ export function parseCli(argv = process.argv.slice(2)) {
                 service: { type: "boolean" },
                 expose: { type: "boolean" },
                 yes: { type: "boolean", short: "y" },
+                event: { type: "string" },
                 account: { type: "string" },
                 name: { type: "string" },
                 help: { type: "boolean", short: "h" },
@@ -224,6 +227,7 @@ export function parseCli(argv = process.argv.slice(2)) {
                 rateLimit: sourceOf("WAZAP_RATE_LIMIT", false),
                 transcribe: sourceOf("WAZAP_TRANSCRIBE", false),
                 webhook: sourceOf("WAZAP_WEBHOOK", false),
+                recall: sourceOf("WAZAP_RECALL", false),
             },
             command,
             explicitCommand: first !== undefined,
@@ -245,6 +249,7 @@ export function parseCli(argv = process.argv.slice(2)) {
             keepRunning: values.expose === true ? "expose" : values.service === true ? "service" : null,
             accountId: values.account,
             accountName: values.name,
+            webhookEvent: values.event,
         },
     };
 }

package/dist/connect.js

@@ -135,8 +135,18 @@ export function whereInstalled(binPath = process.argv[1] ?? "", pathEnv = proces
     const script = binPath === "" ? "" : resolve(binPath);
     if (isNpxPath(binPath))
         return { kind: "npx", script };
-    if (commandOnPath("wazap", pathEnv, exists))
-        return { kind: "global", script };
+    const onPath = commandPath("wazap", pathEnv, exists);
+    if (onPath) {
+        try {
+            if (realpathSync(onPath) === realpathSync(script))
+                return { kind: "global", script };
+        }
+        catch {
+            // A package path or a direct launcher can still be classified when inspecting another host.
+            if (/[/\\]node_modules[/\\]wazap(?:-mcp)?[/\\]/.test(script) || resolve(onPath) === script)
+                return { kind: "global", script };
+        }
+    }
     return { kind: "checkout", script };
 }
 const GLOBAL_FIX = "run `npm i -g wazap-mcp` yourself (sudo on some Linux installs), then `wazap setup` again";
@@ -145,7 +155,12 @@ export function installGlobally(version = WAZAP_VERSION, npm = "npm") {
     const result = spawnSync(npm, ["install", "-g", `wazap-mcp@${version}`], { stdio: "inherit" });
     if (result.error !== undefined || result.status !== 0) {
         const detail = result.error === undefined ? `exit ${result.status ?? -1}` : result.error.message;
-        return { name: "install", state: "fail", detail: `npm install -g wazap-mcp@${version} failed (${detail})`, fix: GLOBAL_FIX };
+        return {
+            name: "install",
+            state: "fail",
+            detail: `npm install -g wazap-mcp@${version} failed (${detail})`,
+            fix: GLOBAL_FIX,
+        };
     }
     return { name: "install", state: "ok", detail: `wazap-mcp@${version} installed globally` };
 }
@@ -224,8 +239,9 @@ export const GUI_PATH = "/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin";
 export function mcpEntry(config, spec, install = whereInstalled()) {
     const entry = entryFor(install);
     // The global `wazap` bin is a symlink into the package, and launchd's PATH has
-    // neither it nor npx, so a GUI client gets this Node and the script behind it.
-    if (spec.gui && entry.command === "wazap") {
+    // neither it, nor npx, nor the bare `node` a checkout entry would name, so a
+    // GUI client gets this Node and the script behind it.
+    if (spec.gui && (entry.command === "wazap" || install.kind === "checkout")) {
         entry.command = process.execPath;
         entry.args = [realpathSync(install.script)];
     }
@@ -244,7 +260,11 @@ export function launchCheck(spec, entry, pathEnv = GUI_PATH, exists, platform =
     if (platform !== "darwin")
         return { name: "launch", state: "info", detail: "not checked on this platform" };
     if (isAbsolute(entry.command) || commandOnPath(entry.command, pathEnv, exists)) {
-        return { name: "launch", state: "ok", detail: `${spec.describe} can start \`${entry.command}\` without your shell PATH` };
+        return {
+            name: "launch",
+            state: "ok",
+            detail: `${spec.describe} can start \`${entry.command}\` without your shell PATH`,
+        };
     }
     return {
         name: "launch",

package/dist/deps.js

@@ -12,6 +12,7 @@ import { brand, info } from "./ui.js";
 export const DEPS = {
     whisper: { binary: "whisper-cli", brew: "whisper-cpp", why: "transcribes voice messages locally" },
     ffmpeg: { binary: "ffmpeg", brew: "ffmpeg", why: "converts voice notes for whisper" },
+    llama: { binary: "llama-server", brew: "llama.cpp", why: "embeds messages for local semantic recall" },
     tailscale: { binary: "tailscale", brew: "tailscale", why: "gives wazap a public https URL" },
     cloudflared: { binary: "cloudflared", brew: "cloudflared", why: "gives wazap a public https URL" },
 };

package/dist/doctor.js

@@ -1,10 +1,11 @@
 import { accessSync, constants, statSync } from "node:fs";
 import { AccountRegistry, accountPolicy, anyAccountLinked, resolveAccount } from "./accounts.js";
 import { readLinkedAccount } from "./auth-state.js";
-import { WAZAP_VERSION, WRITES_ENABLE_FIX, WRITE_TOKEN_NOTE, accountPaths, 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";
+import { EMBED_MODELS, embedModelPath, embedReady, readRecallSettings } from "./recall/index.js";
 import { installedService } from "./service.js";
 import { detectedTargets, skillState } from "./skills.js";
 import { MODELS, findWhisper, localProvider, maskKey, modelPath, readTranscribeSettings, which, } from "./transcribe/index.js";
@@ -25,6 +26,7 @@ const CHECKS = [
     checkSkills,
     checkOAuth,
     checkTranscribe,
+    checkRecall,
     checkWebhook,
     checkUpdate,
 ];
@@ -34,7 +36,7 @@ export async function runChecks(config) {
     const checks = [];
     for (const check of CHECKS)
         checks.push(...[await check(config)].flat());
-    let linked = false;
+    let linked;
     try {
         linked = anyAccountLinked(config.dataDir);
     }
@@ -81,7 +83,12 @@ function checkDataDir(config) {
         return { name: "data dir", state: "info", detail: `${dir} does not exist yet (login creates it)` };
     }
     if (!stat.isDirectory()) {
-        return { name: "data dir", state: "fail", detail: `${dir} is not a directory`, fix: "move it aside or use --data-dir" };
+        return {
+            name: "data dir",
+            state: "fail",
+            detail: `${dir} is not a directory`,
+            fix: "move it aside or use --data-dir",
+        };
     }
     const mode = stat.mode & 0o777;
     if (process.platform !== "win32" && mode !== 0o700) {
@@ -96,7 +103,12 @@ function checkDataDir(config) {
         accessSync(dir, constants.W_OK);
     }
     catch {
-        return { name: "data dir", state: "fail", detail: `${dir} is not writable`, fix: "fix its ownership or permissions" };
+        return {
+            name: "data dir",
+            state: "fail",
+            detail: `${dir} is not writable`,
+            fix: "fix its ownership or permissions",
+        };
     }
     return { name: "data dir", state: "ok", detail: `${dir} (0700, writable)` };
 }
@@ -165,7 +177,11 @@ function checkCredentials(config) {
     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" };
+    return {
+        name: "credentials",
+        state: "ok",
+        detail: records.length > 1 ? `readable (${linkedIds.join(", ")})` : "readable",
+    };
 }
 function checkWrites(config) {
     const selected = resolveAccount(config.dataDir, config.accountId);
@@ -278,6 +294,35 @@ async function localChecks(settings) {
             : { name: "model", state: "ok", detail: `${spec.file} (${Math.round(size / MIB)} MiB)` },
     ];
 }
+const RECALL_OFF_FIX = "run `wazap config recall local` to search messages by meaning";
+/**
+ * Off is quiet; on reports the sidecar binary and the model file, the two
+ * things `embed download` plus an install can repair.
+ */
+async function checkRecall(config) {
+    let settings;
+    try {
+        settings = readRecallSettings(process.env, config.dataDir);
+    }
+    catch (err) {
+        const failure = asWazapError(err);
+        return [{ name: "recall", state: "fail", detail: failure.message, fix: failure.fix }];
+    }
+    if (!settings.enabled)
+        return [{ name: "recall", state: "info", detail: "off", fix: RECALL_OFF_FIX }];
+    const spec = EMBED_MODELS[settings.model];
+    const size = fileSize(embedModelPath(settings.modelsDir, spec));
+    const readiness = await embedReady(settings, spec);
+    return [
+        { name: "recall", state: "ok", detail: `local (${settings.model})` },
+        readiness.ok
+            ? { name: "llama-server", state: "ok", detail: settings.embedUrl ?? "found" }
+            : { name: "llama-server", state: "fail", detail: readiness.detail, fix: readiness.fix },
+        size === null && settings.embedUrl === null
+            ? { name: "embed model", state: "fail", detail: `${spec.file} is not downloaded`, fix: "run `wazap embed download`" }
+            : { name: "embed model", state: "ok", detail: `${spec.file} (${Math.round((size ?? 0) / MIB)} MiB)` },
+    ];
+}
 /** W1 webhook: off is quiet; on without a URL or secret is a visible fail. */
 export function webhookCheck(env = process.env) {
     const settings = readWebhookSettings(env);
@@ -341,6 +386,11 @@ async function checkUpdate() {
     if (latest === null)
         return { name: "update", state: "info", detail: "update check skipped (no answer)" };
     return isNewer(latest, WAZAP_VERSION)
-        ? { name: "update", state: "info", detail: `${latest} is out (running ${WAZAP_VERSION})`, fix: "run `wazap update`" }
+        ? {
+            name: "update",
+            state: "info",
+            detail: `${latest} is out (running ${WAZAP_VERSION})`,
+            fix: "run `wazap update`",
+        }
         : { name: "update", state: "ok", detail: `${WAZAP_VERSION} is current` };
 }

package/dist/drafts.js

@@ -142,6 +142,9 @@ function formatNumber(digits) {
     const raw = digits.startsWith("+") ? digits.slice(1) : digits;
     if (!/^\d+$/.test(raw) || raw.length < 4)
         return digits.startsWith("+") ? digits : `+${digits}`;
-    const rest = raw.slice(2).match(/.{1,3}/g)?.join(" ") ?? raw.slice(2);
+    const rest = raw
+        .slice(2)
+        .match(/.{1,3}/g)
+        ?.join(" ") ?? raw.slice(2);
     return `+${raw.slice(0, 2)} ${rest}`;
 }

package/dist/errors.js

@@ -29,6 +29,7 @@ export const ERROR_GUIDE = {
     NOT_ADMIN: "The linked account is not an admin of that group, so this action is refused. Do not retry.",
     GROUP_ANNOUNCEMENT_ONLY: "Only admins may post in that group. Do not retry.",
     MEDIA_UNAVAILABLE: "The media expired on WhatsApp's servers or was never synced. Do not retry; ask the sender to resend.",
+    MEDIA_ACCESS_DENIED: "The URL is not a public http(s) address, or resolves to a private or internal one. Pass a public URL or download the file and use file_path.",
     FILE_NOT_FOUND: "The local path does not exist on the machine running wazap. Check the path with the user.",
     FILE_TOO_LARGE: "The file is too large. Chat media may be 100 MB; a profile picture may be 10 MB. Send a smaller file.",
     INVALID_IMAGE: "The file is not a JPEG, PNG or WebP. Pass a photo via file_path or url; GIF, video and documents are refused.",
@@ -41,6 +42,8 @@ export const ERROR_GUIDE = {
     RATE_LIMITED: "Too many writes too fast. Wait the number of seconds in the fix, then retry once.",
     TRANSCRIBE_UNAVAILABLE: "Transcription is off, or its binaries or model are missing. Tell the user to run the command in the fix; do not retry.",
     TRANSCRIBE_FAILED: "The transcription provider ran and failed. Read the message; retry once at most.",
+    RECALL_UNAVAILABLE: "Semantic recall is off, or llama.cpp or the embedding model is missing. Tell the user to run the command in the fix; do not retry.",
+    RECALL_FAILED: "The embedding backend ran and failed. Read the message; retry once at most.",
     TIMEOUT: "WhatsApp did not answer in time. Retry once; if it fails again, call get_status.",
     SERVICE_ERROR: "wazap's own background service could not be managed. This is a machine problem, not a WhatsApp one: read the fix and tell the user.",
     DRAFT_NOT_FOUND: "That draft_id is unknown or was already sent. Call the send tool again to draft, show the new preview, then confirm_send.",

package/dist/gif.js

@@ -25,11 +25,18 @@ export async function gifToMp4(gif) {
         const output = join(dir, "out.mp4");
         await writeFile(input, gif);
         const args = [
-            "-nostdin", "-loglevel", "error", "-y",
-            "-i", input,
-            "-movflags", "faststart",
-            "-pix_fmt", "yuv420p",
-            "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+            "-nostdin",
+            "-loglevel",
+            "error",
+            "-y",
+            "-i",
+            input,
+            "-movflags",
+            "faststart",
+            "-pix_fmt",
+            "yuv420p",
+            "-vf",
+            "scale=trunc(iw/2)*2:trunc(ih/2)*2",
             "-an",
             output,
         ];

package/dist/ids.js

@@ -2,7 +2,10 @@ import { WazapError } from "./errors.js";
 const PHONE_EXAMPLE = "Use international format, e.g. +15550100";
 /** Digits of a phone number in international format, or INVALID_PHONE. */
 export function normalizePhone(input) {
-    const digits = input.trim().replace(/^\+/, "").replace(/[\s\-().]/g, "");
+    const digits = input
+        .trim()
+        .replace(/^\+/, "")
+        .replace(/[\s\-().]/g, "");
     if (!/^\d+$/.test(digits) || digits.startsWith("0") || digits.length < 8 || digits.length > 15) {
         throw new WazapError("INVALID_PHONE", `"${input.trim()}" is not a phone number in international format.`, PHONE_EXAMPLE);
     }