@manybot/manybot 5.5.3 → 5.6.0

package/dist/kernel/contactAutoSave.js

@@ -0,0 +1,200 @@
+/**
+ * contactAutoSave.ts
+ *
+ * Gradually saves incoming senders as real contacts (using their pushName)
+ * once they've shown they're likely to keep talking, and periodically
+ * refreshes stale pushNames. Purely additive to sendGuard's
+ * anti-detection posture — a saved contact scores as "known" rather than
+ * "stranger" on WhatsApp's contact-graph-distance signal, and mobile
+ * clients resolve @mentions to a name instead of raw digits.
+ *
+ * Rules:
+ *  - DMs: every message from the sender counts toward the DM threshold.
+ *  - Groups: only messages that actually invoke the bot (hasPrefix) count
+ *    toward the group threshold, so silent group members are never
+ *    auto-added.
+ *  - DM and group progress are tracked as two SEPARATE counters per
+ *    sender, each with its own randomized target — a person who first
+ *    messages in a group and later DMs the bot doesn't get to skip the
+ *    (deliberately higher) group threshold via their DM count, or vice
+ *    versa. Saving happens as soon as EITHER counter reaches its target.
+ *  - The thresholds are randomized per sender (not fixed), so the save
+ *    timing doesn't look scripted.
+ *  - Saves happen one at a time, paced naturally by how often people
+ *    actually talk to the bot — never a bulk import.
+ *  - If the actual contact-save call fails (e.g. transient error), the
+ *    sender is NOT marked as saved — the next qualifying message retries
+ *    automatically, rather than waiting for the 30-day refresh cycle.
+ *  - Refresh: occasionally, a small random sample of long-saved contacts
+ *    get removed and are transparently re-added on their next message,
+ *    picking up pushName changes instead of keeping a stale name forever.
+ *
+ * Storage: each sender is its own key (not one shared blob) so that a
+ * slow contact-save call for one sender can never cause a concurrent
+ * update for a different sender to be silently lost — see setSenderState.
+ */
+import { buildSettingsApi } from "#kernel/settingsDb.js";
+import { toWireJid } from "#drivers/jid.js";
+import { logger } from "#logger";
+const DM_THRESHOLD_RANGE = { min: 3, max: 6 };
+const GROUP_THRESHOLD_RANGE = { min: 5, max: 9 }; // groups need extra calm
+const REFRESH_MIN_AGE_MS = 30 * 24 * 60 * 60 * 1000; // re-check after 30 days
+const REFRESH_SWEEP_SAMPLE = 2; // stale contacts touched per sweep, not all at once
+// Reserved plugin namespace — not chat-scoped, since a saved contact is a
+// bot-wide fact, not a per-chat one. Each sender gets its own key
+// ("sender:<jid>") rather than one shared JSON blob, so concurrent
+// updates for different senders (normal — different chats run
+// concurrently) never clobber each other.
+const store = buildSettingsApi("__contactAutoSave__", "_global").global;
+const SENDER_KEY_PREFIX = "sender:";
+function senderKey(jid) {
+    return `${SENDER_KEY_PREFIX}${jid}`;
+}
+function getSenderState(jid) {
+    return store.get(senderKey(jid));
+}
+function setSenderState(jid, s) {
+    store.set(senderKey(jid), s);
+}
+function getAllSenderStates() {
+    const all = store.getAll();
+    const result = {};
+    for (const [key, value] of Object.entries(all)) {
+        if (key.startsWith(SENDER_KEY_PREFIX)) {
+            result[key.slice(SENDER_KEY_PREFIX.length)] = value;
+        }
+    }
+    return result;
+}
+function randomInt(min, max) {
+    return Math.floor(min + Math.random() * (max - min + 1));
+}
+/**
+ * @returns whether the contact was actually saved. Callers must not mark
+ * a sender as "saved" unless this returns true — otherwise a transient
+ * failure would be mistaken for a real save and never retried.
+ */
+async function addContact(contract, jid, name) {
+    // `jid` here is this framework's internal "@c.us" form (see
+    // getMsgSender()/normalizeJid()) — Baileys needs the real wire JID or
+    // it silently no-ops instead of throwing, which is exactly how this
+    // went unnoticed before.
+    const wireJid = toWireJid(jid);
+    try {
+        await contract.addOrEditContact(wireJid, {
+            fullName: name,
+            firstName: name,
+            saveOnPrimaryAddressbook: true,
+        });
+        logger.debug(`[contactAutoSave] saved contact ${wireJid} as "${name}"`);
+        return true;
+    }
+    catch (e) {
+        logger.debug(`[contactAutoSave] failed to save contact ${wireJid}: ${e.message}`);
+        return false;
+    }
+}
+/**
+ * Call on every incoming message that has a resolvable sender. Handles
+ * both the gradual first-save flow and completing a pending refresh.
+ * Best-effort — never throws.
+ *
+ * @param {WaContract}   contract
+ * @param {BotMessage}   msg         — driver-neutral incoming message envelope
+ * @param {string}       senderJid   — normalized sender JID (never a group JID)
+ * @param {boolean}      isGroup     — whether this message came from a group chat
+ * @param {boolean}      triggeredBot — true if this message invoked the bot
+ *                                     (command prefix). Ignored outside groups.
+ */
+export async function trackIncomingForContactSave(contract, msg, senderJid, isGroup, triggeredBot) {
+    try {
+        const pushName = msg.pushName?.trim();
+        if (!pushName || senderJid.endsWith("@g.us"))
+            return;
+        let s = getSenderState(senderJid);
+        // Completing a refresh takes priority over new-save logic, but in
+        // groups it still only fires on messages that invoke the bot — same
+        // rule as the initial save, so a refresh never re-adds someone based
+        // on a silent group message.
+        if (s?.pendingRefresh && (!isGroup || triggeredBot)) {
+            const ok = await addContact(contract, senderJid, pushName);
+            if (ok) {
+                // Re-read rather than reuse `s` — another concurrent message from
+                // this same sender may have updated the record while we awaited.
+                const latest = getSenderState(senderJid) ?? s;
+                latest.pendingRefresh = false;
+                latest.savedAt = Date.now();
+                setSenderState(senderJid, latest);
+            }
+            return;
+        }
+        if (s?.saved)
+            return; // already saved, not due for refresh
+        if (isGroup && !triggeredBot)
+            return; // groups: only count messages that invoke the bot
+        if (!s) {
+            s = {
+                dmTarget: randomInt(DM_THRESHOLD_RANGE.min, DM_THRESHOLD_RANGE.max),
+                groupTarget: randomInt(GROUP_THRESHOLD_RANGE.min, GROUP_THRESHOLD_RANGE.max),
+                dmCount: 0,
+                groupCount: 0,
+                saved: false,
+                savedAt: 0,
+                pendingRefresh: false,
+            };
+        }
+        if (isGroup)
+            s.groupCount += 1;
+        else
+            s.dmCount += 1;
+        // Persist the increment right away, with no await in between — so a
+        // slow addContact() call below never leaves this sender's counter
+        // based on stale data for longer than necessary.
+        setSenderState(senderJid, s);
+        const reachedTarget = s.dmCount >= s.dmTarget || s.groupCount >= s.groupTarget;
+        if (reachedTarget) {
+            const ok = await addContact(contract, senderJid, pushName);
+            if (ok) {
+                const latest = getSenderState(senderJid) ?? s;
+                latest.saved = true;
+                latest.savedAt = Date.now();
+                setSenderState(senderJid, latest);
+            }
+            // If it failed, `saved` stays false — the next qualifying message
+            // will see the target already reached and retry automatically.
+        }
+    }
+    catch (e) {
+        logger.debug(`[contactAutoSave] tracking failed (non-fatal): ${e.message}`);
+    }
+}
+/**
+ * Periodic maintenance: picks a small random sample of contacts saved
+ * more than REFRESH_MIN_AGE_MS ago and starts their refresh cycle
+ * (remove now, transparently re-added on their next message via
+ * trackIncomingForContactSave) so a changed pushName doesn't linger.
+ *
+ * Call this occasionally (e.g. every few hours) from the driver.
+ * @param {WaContract} contract
+ */
+export async function runContactRefreshSweep(contract) {
+    const now = Date.now();
+    const all = getAllSenderStates();
+    const due = Object.entries(all)
+        .filter(([, s]) => s.saved && !s.pendingRefresh && now - s.savedAt > REFRESH_MIN_AGE_MS)
+        .sort(() => Math.random() - 0.5)
+        .slice(0, REFRESH_SWEEP_SAMPLE);
+    if (due.length === 0)
+        return;
+    for (const [jid, s] of due) {
+        try {
+            await contract.removeContact(toWireJid(jid));
+            s.pendingRefresh = true;
+            setSenderState(jid, s);
+            logger.debug(`[contactAutoSave] queued refresh for ${jid}`);
+        }
+        catch (e) {
+            logger.debug(`[contactAutoSave] failed to remove contact ${jid} for refresh: ${e.message}`);
+        }
+    }
+}

package/dist/kernel/driverManager.js

@@ -0,0 +1,117 @@
+/**
+ * driverManager.ts
+ *
+ * Registry for the active WhatsApp driver and any fallback drivers
+ * registered alongside it. Centralizes the answer to "which driver do
+ * I send through right now?" so sendFallbackGuard can pick the primary,
+ * notice when it's degraded, and reach for the secondary without
+ * scattering that decision across the codebase.
+ *
+ * Singleton access via getDriverManager() — same pattern as the
+ * globalSock in pluginLoader.ts. Only main.ts is expected to call
+ * register(); everywhere else reads through active() / get() / isDegraded.
+ *
+ * Shutdown order in shutdown() is reverse-registration, so a driver
+ * that was added later (e.g. whatsmeow) is disconnected before the
+ * primary one (typically Baileys). Re-registering the same name
+ * overwrites the previous instance — the old driver is NOT disconnected
+ * automatically, callers must disconnect it first if they want it torn
+ * down.
+ *
+ * See the interface and cooldown semantics.
+ */
+import { logger } from "#logger";
+class DriverManager {
+    drivers = new Map();
+    activeName = "";
+    /** Insertion order — used by shutdown() to disconnect in reverse. */
+    order = [];
+    degradedUntil = new Map();
+    /**
+     * Register a driver. The first call with isPrimary=true (or the first
+     * call overall if none sets it) becomes the active driver. Subsequent
+     * calls with isPrimary=false are stored as fallbacks.
+     */
+    register(driver, opts = {}) {
+        const name = driver.name;
+        if (this.drivers.has(name)) {
+            logger.warn(`[driverManager] re-registering driver "${name}" — old instance NOT disconnected`);
+        }
+        else {
+            this.order.push(name);
+        }
+        this.drivers.set(name, driver);
+        if (opts.isPrimary || !this.activeName) {
+            this.activeName = name;
+        }
+    }
+    active() {
+        const d = this.drivers.get(this.activeName);
+        if (!d) {
+            throw new Error(`[driverManager] no active driver registered (activeName="${this.activeName}")`);
+        }
+        return d;
+    }
+    get(name) {
+        return this.drivers.get(name);
+    }
+    activeName_() {
+        return this.activeName;
+    }
+    /** True if `name` is registered AND its connect() has resolved with state="open". */
+    isReady(name) {
+        return this.drivers.get(name)?.isReady() ?? false;
+    }
+    isDegraded(name) {
+        const until = this.degradedUntil.get(name);
+        return !!until && Date.now() < until;
+    }
+    markDegraded(name, durationMs) {
+        this.degradedUntil.set(name, Date.now() + durationMs);
+    }
+    /**
+     * Promote a different driver to active. Used by tests / hot-swap;
+     * the production sendFallbackGuard never calls this — fallback uses
+     * the secondary by direct call, leaving activeName untouched so the
+     * primary gets retried after the cooldown.
+     */
+    switchTo(name) {
+        if (!this.drivers.has(name)) {
+            throw new Error(`[driverManager] cannot switch to unregistered driver "${name}"`);
+        }
+        this.activeName = name;
+    }
+    /**
+     * Disconnect every registered driver in reverse-registration order.
+     * Errors are logged, not thrown, so a stubborn secondary can't block
+     * the primary's shutdown (or vice versa).
+     */
+    async shutdown() {
+        for (let i = this.order.length - 1; i >= 0; i--) {
+            const name = this.order[i];
+            const d = this.drivers.get(name);
+            if (!d)
+                continue;
+            try {
+                await d.disconnect();
+            }
+            catch (e) {
+                logger.warn(`[driverManager] error disconnecting "${name}": ${e.message}`);
+            }
+        }
+        this.drivers.clear();
+        this.order.length = 0;
+        this.degradedUntil.clear();
+        this.activeName = "";
+    }
+}
+let instance = null;
+export function getDriverManager() {
+    if (!instance)
+        instance = new DriverManager();
+    return instance;
+}
+/** Test-only — reset the singleton so unit tests start clean. */
+export function _resetDriverManagerForTests() {
+    instance = null;
+}

package/dist/kernel/pluginApi.js

@@ -1,11 +1,29 @@
 /**
- * kernel/pluginApi.ts (DEPRECATED)
+ * kernel/pluginApi.ts — explicit `PluginContext` contract.
  *
- * This file is now a re-export from the WhatsApp driver.
- * Plugins should continue to work without any changes.
+ * This file declares the typed surface that the
+ * plugin runtime passes to `plugin.default(ctx)` and `plugin.setup(ctx)`.
+ * Plugins depend ONLY on `PluginContext` (and the driver-neutral types
+ * it references — `WaContract`, `BotMessage`, …). The
+ * implementation lives in `drivers/baileys/api/index.ts`; this file is
+ * the source of truth that the implementation must satisfy via
+ * `tsc --noEmit`.
  *
- * All logic is now in: drivers/whatsapp/api/
- * This file exists for backward compatibility.
+ * History:
+ *   - Originally this file was a re-export shim from the WhatsApp
+ *     driver; now that the driver has been split into `drivers/baileys/`,
+ *     the contract is promoted here and the implementation annotates
+ *     `(): PluginContext`.
+ *   - WAMessageContext / WAMessageSender / WAHistoryArray / PollHandle
+ *     stay in `drivers/baileys/api/index.ts` because their internal field
+ *     shapes still mirror Baileys-proto (e.g. `msg.key.id`). whatsapp-
+ *     platform-neutrality is a per-property evolution; the contract
+ *     exposes them at the boundary (`ctx.msg`) so future swaps only touch
+ *     the implementation, never plugins.
  */
-// Re-export everything from the WhatsApp driver's plugin API
-export * from "#drivers/whatsapp/api/index.js";
+// Re-export the implementation module so existing callers that
+// `import { buildSetupApi, cleanupPluginEvents } from "#manyapi"`
+// keep working. The contract types below are the new source of truth;
+// the implementation in drivers/baileys/api/index.ts is annotated
+// to satisfy them.
+export { buildApi, buildSetupApi, buildMessageContext, buildChatFromMsg, buildStorageApi, cleanupPluginEvents, } from "#drivers/baileys/api/index.js";

package/dist/kernel/pluginLoader.js

@@ -17,7 +17,7 @@ import { PATHS } from "#config";
 import { buildSetupApi, cleanupPluginEvents } from "#manyapi";
 const PLUGINS_DIR = path.join(PATHS.HOME, "plugins");
 export const pluginRegistry = new Map();
-let globalSock = null;
+let globalContract = null;
 let globalStore = null;
 const pluginWatchers = new Map();
 // fs.watch's `recursive: true` emulates recursion on Linux by opening one
@@ -77,14 +77,14 @@ export async function loadPlugins(activePlugins) {
  * Call setup(api) on all plugins that export it.
  * Executed once after bot connects.
  */
-export async function setupPlugins(sock, store) {
-    globalSock = sock;
+export async function setupPlugins(contract, store) {
+    globalContract = contract;
     globalStore = store;
     for (const plugin of pluginRegistry.values()) {
         if (plugin.status !== "active" || !plugin.setup)
             continue;
         try {
-            const api = buildSetupApi(sock, store, pluginRegistry, plugin.name);
+            const api = buildSetupApi(contract, store, pluginRegistry, plugin.name);
             await plugin.setup(api);
         }
         catch (e) {
@@ -197,14 +197,14 @@ export async function reloadPlugin(name) {
     const plugin = pluginRegistry.get(name);
     if (!plugin)
         return;
-    if (globalSock) {
-        cleanupPluginEvents(name, globalSock);
+    if (globalContract) {
+        cleanupPluginEvents(name, globalContract);
     }
     await loadPlugin(name, true);
     const updatedPlugin = pluginRegistry.get(name);
-    if (updatedPlugin && updatedPlugin.status === "active" && updatedPlugin.setup && globalSock && globalStore) {
+    if (updatedPlugin && updatedPlugin.status === "active" && updatedPlugin.setup && globalContract && globalStore) {
         try {
-            const api = buildSetupApi(globalSock, globalStore, pluginRegistry, name);
+            const api = buildSetupApi(globalContract, globalStore, pluginRegistry, name);
             await updatedPlugin.setup(api);
         }
         catch (e) {
@@ -240,8 +240,8 @@ export async function syncPlugins() {
             logger.info(`[pluginLoader] Disabling plugin "${name}"`);
             const plugin = pluginRegistry.get(name);
             if (plugin) {
-                if (globalSock) {
-                    cleanupPluginEvents(name, globalSock);
+                if (globalContract) {
+                    cleanupPluginEvents(name, globalContract);
                 }
                 plugin.status = "disabled";
                 unwatchPlugin(name);
@@ -254,9 +254,9 @@ export async function syncPlugins() {
             logger.info(`[pluginLoader] Enabling plugin "${name}"`);
             await loadPlugin(name);
             const plugin = pluginRegistry.get(name);
-            if (plugin && plugin.status === "active" && plugin.setup && globalSock && globalStore) {
+            if (plugin && plugin.status === "active" && plugin.setup && globalContract && globalStore) {
                 try {
-                    const api = buildSetupApi(globalSock, globalStore, pluginRegistry, name);
+                    const api = buildSetupApi(globalContract, globalStore, pluginRegistry, name);
                     await plugin.setup(api);
                 }
                 catch (e) {

package/dist/kernel/sendFallbackGuard.js

@@ -0,0 +1,173 @@
+/**
+ * sendFallbackGuard.ts
+ *
+ * The only place in the codebase that knows more than one WhatsApp
+ * driver exists. Every outbound text send from a plugin flows through
+ * sendWithFallback(): try the primary, verify the message actually
+ * appeared in the driver's history, and if it didn't, swap to the
+ * secondary and try again. See "flow", "verification",
+ * and cooldown).
+ *
+ * Why a guard instead of inlining the logic in the sender: every
+ * downstream caller (makeSender, buildSendApi, buildSetupSendApi) gets
+ * the same fallback behavior for free, and a future change in policy
+ * (e.g. "after N consecutive fallbacks, drop to system queue") touches
+ * one file.
+ *
+ * The guard is intentionally text-only in this phase. sendMedia and
+ * react go straight to the active driver — media fallback is
+ * marked as out of scope until the path is designed.
+ */
+import { CONFIG } from "#config";
+import { logger } from "#logger";
+import { waitForSendSlot } from "./sendGuard.js";
+import { getDriverManager } from "./driverManager.js";
+import { fireAlert } from "./alerts.js";
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+/**
+ * Thrown by sendWithFallback when the message could not be delivered
+ * through any available driver. `reason` distinguishes between
+ * "primary failed and no secondary was available" vs "both failed".
+ */
+export class SendFailedError extends Error {
+    jid;
+    driver;
+    reason;
+    constructor(jid, driver, reason) {
+        super(`send failed: ${reason} (jid=${jid}, lastDriver=${driver})`);
+        this.name = "SendFailedError";
+        this.jid = jid;
+        this.driver = driver;
+        this.reason = reason;
+    }
+}
+/**
+ * Try the active driver, then the other one if the active one failed to
+ * confirm the send. Honors `drivers.fallbackCooldownMs` (skip the active
+ * if it's currently degraded) and uses `drivers.verifyWindowMs` to decide
+ * how long to wait for confirmation before giving up on a given attempt.
+ *
+ * Resolves with the SentMessageRef of the driver that actually delivered
+ * the message. Rejects with SendFailedError if neither driver confirmed
+ * the send (or if the only driver that could have been tried was the
+ * active one and it wasn't ready).
+ */
+export async function sendWithFallback(jid, text, opts = {}) {
+    const dm = getDriverManager();
+    const drivers = CONFIG.drivers;
+    const primary = dm.active();
+    const primaryKey = primary.name;
+    // if the primary is in cooldown, skip straight to the secondary
+    // (don't repeat the same failing call message after message). Same
+    // try/catch as the normal path so a failing secondary here also fires
+    // send_failed_both_drivers — observability stays consistent across
+    // the degraded and fresh-primary paths.
+    if (dm.isDegraded(primaryKey)) {
+        const secondary = pickSecondary(dm, primaryKey);
+        if (secondary && secondary.isReady()) {
+            try {
+                return await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ false);
+            }
+            catch (err) {
+                fireAlert("send_failed_both_drivers", { jid, primary: primaryKey, secondary: secondary.name, error: String(err) });
+                throw err;
+            }
+        }
+        logger.warn({ jid, primary: primaryKey }, "send skipped primary (degraded) and no fallback ready");
+        fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
+        throw new SendFailedError(jid, primaryKey, "no_fallback");
+    }
+    // Normal path: try primary, verify, fall back if verification fails.
+    // waitForSendSlot is the same throttle the rest of the senders use
+    // (fallback must respect rate-limit too).
+    await waitForSendSlot(jid, { cooldown: true, jitter: true });
+    const ref = await primary.sendText(jid, text, opts);
+    if (await verifyDelivery(primary, jid, ref, drivers.verifyWindowMs)) {
+        return ref;
+    }
+    logger.warn({ driver: primaryKey, jid, messageId: ref.id }, "send not confirmed by primary");
+    dm.markDegraded(primaryKey, drivers.fallbackCooldownMs);
+    const secondary = pickSecondary(dm, primaryKey);
+    if (!secondary || !secondary.isReady()) {
+        fireAlert("send_failed_no_fallback", { jid, primary: primaryKey });
+        throw new SendFailedError(jid, primaryKey, "no_fallback");
+    }
+    try {
+        const fallbackRef = await sendVia(secondary, jid, text, opts, drivers.verifyWindowMs, /*skipGuard=*/ true);
+        logger.info({ driver: secondary.name, jid, messageId: fallbackRef.id, reason: "primary verification failed" }, "message sent via fallback");
+        return fallbackRef;
+    }
+    catch (err) {
+        fireAlert("send_failed_both_drivers", { jid, primary: primaryKey, secondary: secondary.name, error: String(err) });
+        throw err;
+    }
+}
+/**
+ * Send through a specific driver and verify the result. Throws if the
+ * driver itself rejects (network error, rate-limit, etc.) or if no
+ * verification window matched. `skipGuard=true` skips waitForSendSlot —
+ * used by the secondary path, where the primary already consumed the
+ * slot and the secondary is best-effort.
+ */
+async function sendVia(driver, jid, text, opts, windows, skipGuard) {
+    if (!skipGuard)
+        await waitForSendSlot(jid, { cooldown: true, jitter: true });
+    const ref = await driver.sendText(jid, text, opts);
+    if (await verifyDelivery(driver, jid, ref, windows))
+        return ref;
+    throw new SendFailedError(jid, driver.name, "both_failed");
+}
+/**
+ * Pull recent history from the driver and look for `ref.id` among the
+ * fromMe messages. Returns true on the first hit; false if every check
+ * came up empty (including the final window, which acts as the overall
+ * timeout).
+ *
+ * The first check happens IMMEDIATELY (no sleep). For Baileys this is
+ * the common case: `sock.sendMessage` resolves after the message is
+ * already in the in-memory store (the `messages.upsert` listener runs
+ * synchronously off the same ack), so a 0ms lookup hits and the send
+ * completes with no extra latency. Only if that immediate lookup
+ * misses (driver lag, history sync delay, ...) do we start the
+ * time-windowed rechecks — `windows` are interpreted as delays
+ * BETWEEN successive checks, last one being the final timeout.
+ *
+ * id is the primary signal. We match against ALL
+ * fromMe messages in the slice, not just the newest — the secondary
+ * path skips `waitForSendSlot` (skipGuard=true) so two concurrent
+ * sends to the same jid can both be in flight at once, and "newest
+ * only" would let the second one mask the first.
+ *
+ * If the driver doesn't implement `getHistory?` (pure fire-and-forget
+ * transports), verification can't happen — return false and let the
+ * caller fall through. Both real drivers in scope today (Baileys,
+ * whatsmeow) implement it, so this is just defensive.
+ */
+async function verifyDelivery(driver, jid, ref, windows) {
+    if (!driver.getHistory)
+        return false;
+    // Check at t=0 first; only enter the window loop if that misses.
+    if (await historyContains(driver, jid, ref))
+        return true;
+    for (const delayMs of windows) {
+        await sleep(delayMs);
+        if (await historyContains(driver, jid, ref))
+            return true;
+    }
+    return false;
+}
+async function historyContains(driver, jid, ref) {
+    let history;
+    try {
+        history = await driver.getHistory(jid, { limit: 5 });
+    }
+    catch (e) {
+        logger.debug({ driver: driver.name, jid, err: String(e) }, "getHistory failed during verify (non-fatal)");
+        return false;
+    }
+    return history.some(m => m.fromMe && m.id === ref.id);
+}
+function pickSecondary(dm, primaryKey) {
+    const other = primaryKey === "baileys" ? "whatsmeow" : "baileys";
+    return dm.get(other);
+}