@prototypevip/baileys 0.0.8 → 0.0.9

package/lib/AntiBan/banRecoveryOrchestrator.js

@@ -0,0 +1,284 @@
+/**
+ * BanRecoveryOrchestrator — Structured recovery after ban/restriction events
+ *
+ * When WhatsApp restricts your account, the worst thing to do is immediately
+ * resume normal activity. This module provides a evidence-based recovery protocol:
+ *
+ * - Timelocked (reachout_restricted): 24h pause, resume at 10% rate, ramp 15%/week
+ * - Rate-overlimit (429): 4h pause, resume at 25% rate, ramp 25%/week
+ * - Soft-ban (repeated disconnects): 48h pause, resume at 5% rate, ramp 10%/week
+ * - Hard-ban (loggedOut): account is dead, signal for replacement
+ *
+ * Based on observed recovery times from community reports. Not guaranteed —
+ * WA's enforcement is non-deterministic. Treat as best-effort guidance.
+ */
+const DEFAULT_PLANS = {
+    timelock: {
+        eventType: 'timelock',
+        pauseDurationMs: 24 * 60 * 60 * 1000, // 24 hours
+        resumeRateMultiplier: 0.10, // 10% of normal
+        weeklyRampPercent: 15, // +15% per week
+        estimatedRecoveryDays: 14,
+        description: 'WA reachout timelock — 24h pause then slow ramp',
+    },
+    rate_overlimit: {
+        eventType: 'rate_overlimit',
+        pauseDurationMs: 4 * 60 * 60 * 1000, // 4 hours
+        resumeRateMultiplier: 0.25, // 25% of normal
+        weeklyRampPercent: 25, // +25% per week
+        estimatedRecoveryDays: 7,
+        description: 'Rate limit hit — 4h pause then moderate ramp',
+    },
+    soft_ban: {
+        eventType: 'soft_ban',
+        pauseDurationMs: 48 * 60 * 60 * 1000, // 48 hours
+        resumeRateMultiplier: 0.05, // 5% of normal
+        weeklyRampPercent: 10, // +10% per week
+        estimatedRecoveryDays: 21,
+        description: 'Soft ban detected — 48h pause then very slow ramp',
+    },
+    hard_ban: {
+        eventType: 'hard_ban',
+        pauseDurationMs: Infinity,
+        resumeRateMultiplier: 0,
+        weeklyRampPercent: 0,
+        estimatedRecoveryDays: Infinity,
+        description: 'Hard ban — number is dead, replace SIM',
+    },
+};
+export class BanRecoveryOrchestrator {
+    config;
+    state;
+    plans;
+    constructor(config = {}) {
+        this.config = {
+            plans: config.plans || {},
+            onPhaseChange: config.onPhaseChange || (() => { }),
+            onHardBan: config.onHardBan || (() => { }),
+            maxRecoveryWeeks: config.maxRecoveryWeeks ?? 8,
+        };
+        // Merge custom plans with defaults
+        this.plans = { ...DEFAULT_PLANS };
+        if (config.plans) {
+            for (const eventType in config.plans) {
+                const customPlan = config.plans[eventType];
+                if (customPlan) {
+                    this.plans[eventType] = {
+                        ...this.plans[eventType],
+                        ...customPlan,
+                    };
+                }
+            }
+        }
+        this.state = {
+            active: false,
+            phase: 'graduated',
+            currentRateMultiplier: 1.0,
+            weeksSinceResume: 0,
+            banCount30d: 0,
+        };
+    }
+    /**
+     * Record a ban event and start recovery protocol
+     */
+    recordBanEvent(eventType) {
+        const now = Date.now();
+        const plan = this.plans[eventType];
+        // Update ban count (reset if >30 days since last ban)
+        if (this.state.lastBanAt) {
+            const daysSinceLastBan = (now - this.state.lastBanAt) / (86400000);
+            if (daysSinceLastBan > 30) {
+                this.state.banCount30d = 0;
+            }
+        }
+        this.state.banCount30d++;
+        this.state.lastBanAt = now;
+        // Upgrade to hard_ban if 3+ bans in 30 days (unless already hard_ban)
+        if (this.state.banCount30d >= 3 && eventType !== 'hard_ban') {
+            eventType = 'hard_ban';
+        }
+        this.state.active = true;
+        this.state.eventType = eventType;
+        this.state.banDetectedAt = now;
+        this.state.pauseUntil = plan.pauseDurationMs === Infinity ? Infinity : now + plan.pauseDurationMs;
+        this.state.currentRateMultiplier = plan.resumeRateMultiplier;
+        this.state.weeksSinceResume = 0;
+        this.state.phase = eventType === 'hard_ban' ? 'dead' : 'paused';
+        this.config.onPhaseChange(this.state.phase, plan);
+        if (eventType === 'hard_ban') {
+            this.config.onHardBan();
+        }
+        return this.getStatus();
+    }
+    /**
+     * Get current recovery status (call before sending to check rate)
+     */
+    getStatus() {
+        if (!this.state.active || !this.state.eventType) {
+            return {
+                phase: 'graduated',
+                rateMultiplier: 1.0,
+                recommendation: 'No active recovery — operating normally',
+                shouldReplaceNumber: false,
+            };
+        }
+        const now = Date.now();
+        const plan = this.plans[this.state.eventType];
+        // Check if pause period has ended
+        if (this.state.phase === 'paused' && this.state.pauseUntil !== undefined && this.state.pauseUntil !== Infinity && now >= this.state.pauseUntil) {
+            this.state.phase = 'recovering';
+            this.config.onPhaseChange(this.state.phase, plan);
+        }
+        // Check if we've exceeded max recovery weeks (give up)
+        if (this.state.phase === 'recovering' || this.state.phase === 'ramping') {
+            if (this.state.weeksSinceResume >= this.config.maxRecoveryWeeks) {
+                this.state.phase = 'dead';
+                this.config.onPhaseChange(this.state.phase, plan);
+                this.config.onHardBan();
+            }
+        }
+        const shouldReplaceNumber = this.state.phase === 'dead' || this.state.banCount30d >= 3;
+        let recommendation;
+        switch (this.state.phase) {
+            case 'dead':
+                recommendation = 'Account is permanently restricted. Replace number and start fresh.';
+                break;
+            case 'paused':
+                if (this.state.pauseUntil === Infinity) {
+                    recommendation = 'Account is dead. Do not attempt to send messages.';
+                }
+                else {
+                    const remainingMs = this.state.pauseUntil - now;
+                    const remainingHours = Math.ceil(remainingMs / 3600000);
+                    recommendation = `Pause period active. Wait ${remainingHours}h before resuming. ${plan.description}`;
+                }
+                break;
+            case 'recovering':
+                recommendation = `Recovery phase. Operating at ${Math.round(this.state.currentRateMultiplier * 100)}% capacity. Ramp: ${plan.weeklyRampPercent}%/week.`;
+                break;
+            case 'ramping':
+                recommendation = `Ramping phase. Operating at ${Math.round(this.state.currentRateMultiplier * 100)}% capacity. Ramp: ${plan.weeklyRampPercent}%/week.`;
+                break;
+            case 'graduated':
+                recommendation = 'Recovery complete. Operating at full capacity.';
+                break;
+        }
+        const pauseRemainingMs = this.state.pauseUntil !== undefined && this.state.pauseUntil !== Infinity && now < this.state.pauseUntil
+            ? this.state.pauseUntil - now
+            : undefined;
+        let estimatedFullRecoveryDate;
+        if (this.state.phase === 'recovering' || this.state.phase === 'ramping') {
+            const rateToGain = 1.0 - this.state.currentRateMultiplier;
+            const weeksNeeded = Math.ceil((rateToGain / (plan.weeklyRampPercent / 100)) * (1 / this.state.currentRateMultiplier));
+            estimatedFullRecoveryDate = now + weeksNeeded * 7 * 86400000;
+        }
+        return {
+            phase: this.state.phase,
+            rateMultiplier: this.state.currentRateMultiplier,
+            pauseRemainingMs,
+            estimatedFullRecoveryDate,
+            recommendation,
+            shouldReplaceNumber,
+        };
+    }
+    /**
+     * Current rate multiplier — multiply your normal limits by this
+     */
+    getRateMultiplier() {
+        return this.state.currentRateMultiplier;
+    }
+    /**
+     * Should be called daily/weekly to advance the ramp
+     */
+    tick() {
+        if (!this.state.active || !this.state.eventType) {
+            return;
+        }
+        const now = Date.now();
+        const plan = this.plans[this.state.eventType];
+        // Transition from paused to recovering
+        if (this.state.phase === 'paused' && this.state.pauseUntil !== undefined && this.state.pauseUntil !== Infinity && now >= this.state.pauseUntil) {
+            this.state.phase = 'recovering';
+            this.config.onPhaseChange(this.state.phase, plan);
+        }
+        // Advance the ramp if in recovering/ramping phase
+        if (this.state.phase === 'recovering' || this.state.phase === 'ramping') {
+            this.state.weeksSinceResume++;
+            // Check if exceeded max recovery weeks
+            if (this.state.weeksSinceResume >= this.config.maxRecoveryWeeks) {
+                this.state.phase = 'dead';
+                this.state.currentRateMultiplier = 0;
+                this.config.onPhaseChange(this.state.phase, plan);
+                this.config.onHardBan();
+                return;
+            }
+            // Apply weekly ramp
+            const rampMultiplier = 1 + (plan.weeklyRampPercent / 100);
+            const newMultiplier = this.state.currentRateMultiplier * rampMultiplier;
+            if (newMultiplier >= 1.0) {
+                // Graduated
+                this.state.currentRateMultiplier = 1.0;
+                this.state.phase = 'graduated';
+                this.state.active = false;
+                this.config.onPhaseChange(this.state.phase, plan);
+            }
+            else {
+                // Still ramping
+                this.state.currentRateMultiplier = newMultiplier;
+                this.state.phase = 'ramping';
+            }
+        }
+    }
+    /**
+     * Classify a raw error into a BanEventType
+     */
+    static classifyError(err) {
+        if (!err)
+            return null;
+        const errorStr = String(err).toLowerCase();
+        const errorMsg = err.message?.toLowerCase() || '';
+        const errorCode = err.code || '';
+        // Timelock patterns
+        if (errorStr.includes('reachout') ||
+            errorStr.includes('account_reachout_restricted') ||
+            errorMsg.includes('reachout') ||
+            errorCode === 463 ||
+            errorCode === '463') {
+            return 'timelock';
+        }
+        // Rate overlimit patterns
+        if (errorStr.includes('rate-overlimit') ||
+            errorStr.includes('rate_overlimit') ||
+            errorStr.includes('429') ||
+            errorCode === 429 ||
+            errorCode === '429') {
+            return 'rate_overlimit';
+        }
+        // Hard ban patterns
+        if (errorStr.includes('loggedout') ||
+            errorStr.includes('logged_out') ||
+            errorStr.includes('logged out') ||
+            errorMsg.includes('loggedout') ||
+            errorCode === 401 ||
+            errorCode === '401') {
+            return 'hard_ban';
+        }
+        // Note: soft_ban detection requires context (multiple disconnects)
+        // and should be determined by the caller using HealthMonitor
+        return null;
+    }
+    /**
+     * Serializable state for persistence
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Restore from persisted state
+     */
+    static fromState(state, config) {
+        const orchestrator = new BanRecoveryOrchestrator(config);
+        orchestrator.state = { ...state };
+        return orchestrator;
+    }
+}

package/lib/AntiBan/cli.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * baileys-antiban CLI
+ * Usage: npx baileys-antiban <command> [options]
+ */
+import * as fs from 'fs';
+import { StateManager } from './persist.js';
+import { resolveConfig } from './presets.js';
+import { applyPatch, unpatchFile } from './patch.js';
+const args = process.argv.slice(2);
+const command = args[0];
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) {
+                result[key] = next;
+                i++;
+            }
+            else {
+                result[key] = true;
+            }
+        }
+    }
+    return result;
+}
+function cmdStatus(opts) {
+    const statePath = opts['state'];
+    let warmupInfo = 'No state file (in-memory mode)';
+    let savedAt = 'N/A';
+    if (statePath) {
+        const mgr = new StateManager(statePath);
+        const state = mgr.load();
+        if (state) {
+            const now = Date.now();
+            const dayMs = 86400000;
+            const currentDay = Math.floor((now - state.warmup.startedAt) / dayMs);
+            warmupInfo = state.warmup.graduated
+                ? 'Graduated (warmup complete)'
+                : `Day ${currentDay + 1}, sent today: ${state.warmup.dailyCounts[currentDay] || 0}`;
+            savedAt = new Date(state.savedAt).toISOString();
+        }
+        else {
+            warmupInfo = 'State file missing or corrupt';
+        }
+    }
+    const output = {
+        warmup: warmupInfo,
+        savedAt,
+        statePath: statePath || null,
+    };
+    if (opts['json']) {
+        console.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        console.log('═══ baileys-antiban status ═══');
+        console.log(`Warmup:   ${output.warmup}`);
+        console.log(`Saved:    ${output.savedAt}`);
+        console.log(`State:    ${output.statePath || 'none'}`);
+    }
+}
+function cmdReset(opts) {
+    const statePath = opts['state'];
+    if (!statePath) {
+        console.error('Error: --state <path> required for reset');
+        process.exit(1);
+    }
+    if (!fs.existsSync(statePath)) {
+        console.log('State file does not exist — nothing to reset');
+        return;
+    }
+    fs.unlinkSync(statePath);
+    console.log(`✅ State file deleted: ${statePath}`);
+}
+function cmdWarmupSimulate(opts) {
+    const days = parseInt(opts['simulate'] || '7', 10);
+    const presetName = opts['preset'] || 'conservative';
+    const cfg = resolveConfig(presetName);
+    console.log(`\nWarmup simulation — preset: ${presetName}, days: ${days}`);
+    console.log('─'.repeat(50));
+    const startDate = new Date();
+    for (let day = 0; day < days; day++) {
+        const date = new Date(startDate);
+        date.setDate(date.getDate() + day);
+        const dayName = date.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' });
+        const limit = Math.round(cfg.day1Limit * Math.pow(cfg.growthFactor, day));
+        const bar = '█'.repeat(Math.min(30, Math.round(limit / 10)));
+        console.log(`Day ${String(day + 1).padStart(2)} ${dayName.padEnd(15)} ${String(limit).padStart(5)} msgs/day  ${bar}`);
+    }
+    console.log('─'.repeat(50));
+    console.log(`Day ${days + 1}+: graduated (unlimited by warmup)\n`);
+}
+function cmdPatch(opts) {
+    const searchPaths = opts['path'] ? [opts['path']] : undefined;
+    const preset = opts['preset'] || 'conservative';
+    const minDelay = opts['min-delay'] ? parseInt(opts['min-delay']) : 1500;
+    const maxDelay = opts['max-delay'] ? parseInt(opts['max-delay']) : 4000;
+    const typingIndicator = opts['no-typing'] ? false : true;
+    const dryRun = !!opts['dry-run'];
+    const force = !!opts['force'];
+    const result = applyPatch({
+        baileysPaths: searchPaths,
+        preset,
+        minDelay,
+        maxDelay,
+        typingIndicator,
+        dryRun,
+    });
+    if (result.alreadyPatched && !force) {
+        console.log(result.message);
+        process.exit(0);
+    }
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
+function cmdUnpatch(opts) {
+    const targetFile = opts['file'];
+    if (!targetFile) {
+        console.error('Usage: npx baileys-antiban unpatch --file <path-to-patched-file>');
+        process.exit(1);
+    }
+    const result = unpatchFile(targetFile);
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
+// Main
+const opts = parseArgs(args);
+switch (command) {
+    case 'status':
+        cmdStatus(opts);
+        break;
+    case 'reset':
+        cmdReset(opts);
+        break;
+    case 'warmup':
+        if (opts['simulate']) {
+            cmdWarmupSimulate(opts);
+        }
+        else {
+            console.error('Usage: npx baileys-antiban warmup --simulate <days> [--preset conservative|moderate|aggressive]');
+            process.exit(1);
+        }
+        break;
+    case 'patch':
+        cmdPatch(opts);
+        break;
+    case 'unpatch':
+        cmdUnpatch(opts);
+        break;
+    default:
+        console.log('baileys-antiban v3.0');
+        console.log('');
+        console.log('Commands:');
+        console.log('  status [--state <path>] [--json]     Show warmup and health status');
+        console.log('  reset --state <path>                  Delete state file');
+        console.log('  warmup --simulate <days> [--preset]  Show warmup schedule');
+        console.log('  patch [--path <baileys-dir>] [--preset] [--min-delay] [--max-delay] [--no-typing] [--dry-run]');
+        console.log('  unpatch --file <patched-file>         Restore file from backup');
+        console.log('');
+        console.log('Examples:');
+        console.log('  npx baileys-antiban status --state ./antiban-state.json');
+        console.log('  npx baileys-antiban warmup --simulate 7 --preset moderate');
+        console.log('  npx baileys-antiban reset --state ./antiban-state.json');
+        console.log('  npx baileys-antiban patch');
+        console.log('  npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys');
+        console.log('  npx baileys-antiban patch --preset moderate --min-delay 1000 --max-delay 3000');
+        console.log('  npx baileys-antiban unpatch --file ./node_modules/baileys/lib/socket/index.js');
+}

package/lib/AntiBan/contactGraph.js

@@ -0,0 +1,236 @@
+/**
+ * Contact Graph Warmer — Requires 1:1 handshake before group/bulk sends
+ *
+ * WhatsApp's ML models weight "social graph distance" heavily. Accounts that
+ * message strangers (contacts who never replied) have higher ban risk.
+ *
+ * This module:
+ * - Tracks contact state: stranger → handshake_sent → handshake_complete → known
+ * - Blocks sends to strangers unless handshake completed
+ * - Enforces group lurk period (don't send immediately after joining)
+ * - Caps daily new-contact messaging (prevent spray-and-pray patterns)
+ * - Auto-registers inbound senders as "known contacts"
+ *
+ * Research: 2025 ban waves correlated with accounts joining groups + spamming
+ * instantly. 12-24h lurk period significantly reduced bans.
+ */
+const DEFAULT_CONFIG = {
+    enabled: false,
+    requireHandshakeBeforeGroupSend: true,
+    handshakeMinDelayMs: 3600000, // 1 hour
+    groupLurkPeriodMs: 43200000, // 12 hours
+    maxStrangerMessagesPerDay: 5,
+    autoRegisterOnIncoming: true,
+};
+export class ContactGraphWarmer {
+    config;
+    contacts = new Map();
+    groups = new Map();
+    strangerMessagesToday = 0;
+    lastStrangerResetDay = this.getCurrentDay();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Check if message can be sent to this contact/group.
+     * Returns { allowed: false, needsHandshake: true } if handshake required.
+     */
+    canMessage(jid) {
+        if (!this.config.enabled) {
+            return { allowed: true };
+        }
+        // Reset daily stranger counter at UTC midnight
+        const currentDay = this.getCurrentDay();
+        if (currentDay !== this.lastStrangerResetDay) {
+            this.strangerMessagesToday = 0;
+            this.lastStrangerResetDay = currentDay;
+        }
+        // Handle groups
+        if (this.isGroup(jid)) {
+            return this.checkGroupMessage(jid);
+        }
+        // Handle individual contacts
+        return this.checkIndividualMessage(jid);
+    }
+    /**
+     * Mark handshake as sent to this contact.
+     */
+    markHandshakeSent(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        const record = this.contacts.get(jid) || { state: 'stranger' };
+        record.state = 'handshake_sent';
+        record.handshakeSentAt = Date.now();
+        this.contacts.set(jid, record);
+    }
+    /**
+     * Mark handshake as complete with this contact.
+     */
+    markHandshakeComplete(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        const record = this.contacts.get(jid) || { state: 'stranger' };
+        record.state = 'handshake_complete';
+        this.contacts.set(jid, record);
+    }
+    /**
+     * Register a contact as known (skip handshake requirement).
+     */
+    registerKnownContact(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        const record = this.contacts.get(jid) || { state: 'stranger' };
+        record.state = 'known';
+        this.contacts.set(jid, record);
+    }
+    /**
+     * Register a group join event.
+     */
+    registerGroupJoin(groupJid) {
+        if (!this.config.enabled)
+            return;
+        if (!this.isGroup(groupJid))
+            return;
+        this.groups.set(groupJid, { joinedAt: Date.now() });
+    }
+    /**
+     * Get contact state.
+     */
+    getContactState(jid) {
+        if (this.isGroup(jid))
+            return 'known'; // Groups don't have handshake states
+        return this.contacts.get(jid)?.state || 'stranger';
+    }
+    /**
+     * Handle incoming message — auto-register if enabled.
+     */
+    onIncomingMessage(jid) {
+        if (!this.config.enabled)
+            return;
+        if (this.isGroup(jid))
+            return;
+        if (this.config.autoRegisterOnIncoming) {
+            this.registerKnownContact(jid);
+        }
+    }
+    /**
+     * Get statistics.
+     */
+    getStats() {
+        const knownContacts = Array.from(this.contacts.values()).filter(c => c.state === 'known').length;
+        const pendingHandshakes = Array.from(this.contacts.values()).filter(c => c.state === 'handshake_sent').length;
+        const groupsJoined = Array.from(this.groups.entries()).map(([groupJid, record]) => ({
+            groupJid,
+            joinedAt: record.joinedAt,
+            firstSendUnlocksAt: record.joinedAt + this.config.groupLurkPeriodMs,
+        }));
+        return {
+            knownContacts,
+            pendingHandshakes,
+            strangersToday: this.strangerMessagesToday,
+            groupsJoined,
+        };
+    }
+    /**
+     * Reset all state.
+     */
+    reset() {
+        this.contacts.clear();
+        this.groups.clear();
+        this.strangerMessagesToday = 0;
+        this.lastStrangerResetDay = this.getCurrentDay();
+    }
+    /**
+     * Export state for persistence.
+     */
+    exportState() {
+        return {
+            contacts: Array.from(this.contacts.entries()),
+            groups: Array.from(this.groups.entries()),
+            strangerMessagesToday: this.strangerMessagesToday,
+            lastStrangerResetDay: this.lastStrangerResetDay,
+        };
+    }
+    /**
+     * Restore state from persistence.
+     */
+    restoreState(state) {
+        if (state?.contacts && Array.isArray(state.contacts)) {
+            this.contacts = new Map(state.contacts);
+        }
+        if (state?.groups && Array.isArray(state.groups)) {
+            this.groups = new Map(state.groups);
+        }
+        if (typeof state?.strangerMessagesToday === 'number') {
+            this.strangerMessagesToday = state.strangerMessagesToday;
+        }
+        if (typeof state?.lastStrangerResetDay === 'number') {
+            this.lastStrangerResetDay = state.lastStrangerResetDay;
+        }
+    }
+    // Private helpers
+    isGroup(jid) {
+        return jid.endsWith('@g.us');
+    }
+    getCurrentDay() {
+        return Math.floor(Date.now() / 86400000);
+    }
+    checkGroupMessage(groupJid) {
+        const record = this.groups.get(groupJid);
+        if (!record) {
+            // Group not registered — allow (assume old membership)
+            return { allowed: true };
+        }
+        const lurkEndsAt = record.joinedAt + this.config.groupLurkPeriodMs;
+        if (Date.now() < lurkEndsAt) {
+            const minutesLeft = Math.ceil((lurkEndsAt - Date.now()) / 60000);
+            return {
+                allowed: false,
+                reason: `Group lurk period not elapsed — wait ${minutesLeft} minutes`,
+            };
+        }
+        return { allowed: true };
+    }
+    checkIndividualMessage(jid) {
+        const record = this.contacts.get(jid);
+        // Unknown contact (stranger)
+        if (!record || record.state === 'stranger') {
+            if (this.config.requireHandshakeBeforeGroupSend) {
+                // Check daily stranger quota
+                if (this.strangerMessagesToday >= this.config.maxStrangerMessagesPerDay) {
+                    return {
+                        allowed: false,
+                        reason: `Daily new-contact limit reached (${this.config.maxStrangerMessagesPerDay})`,
+                        needsHandshake: true,
+                    };
+                }
+                // Allow but increment counter
+                this.strangerMessagesToday++;
+            }
+            return { allowed: true, needsHandshake: true };
+        }
+        // Handshake sent — check delay
+        if (record.state === 'handshake_sent') {
+            if (!record.handshakeSentAt) {
+                // No timestamp — shouldn't happen, but allow
+                return { allowed: true };
+            }
+            const elapsed = Date.now() - record.handshakeSentAt;
+            if (elapsed < this.config.handshakeMinDelayMs) {
+                const minutesLeft = Math.ceil((this.config.handshakeMinDelayMs - elapsed) / 60000);
+                return {
+                    allowed: false,
+                    reason: `Handshake too recent — wait ${minutesLeft} minutes`,
+                };
+            }
+        }
+        // handshake_complete or known — allow
+        return { allowed: true };
+    }
+}