@c4t4/heyamigo 0.10.1 → 0.10.3

package/dist/gateway/incoming.js

@@ -1,23 +1,10 @@
-import { unlink } from 'fs/promises';
 import { getContentType, isJidGroup, jidDecode, jidNormalizedUser, } from 'baileys';
-import { getProvider } from '../ai/providers.js';
-import { getSession } from '../ai/sessions.js';
-import { formatAddress, jidToAddress } from '../db/address.js';
-import { personIdForAddress } from '../db/identity-sync.js';
 import { config } from '../config.js';
-import { estimate as estimateJob } from '../estimates/index.js';
+import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
-import { buildMemoryPreamble } from '../memory/preamble.js';
-import { enqueueInbound } from '../queue/inbound.js';
-import { enqueueOutbound } from '../queue/outbound.js';
-import { detectMediaType, downloadAndSave, getMediaSize, mediaPromptTag, } from '../store/media.js';
-import { append } from '../store/messages.js';
-import { getDailyTokens } from '../store/usage.js';
-import { sendText } from '../wa/sender.js';
-import { checkAccess, discoverGroupIfNew, getLimitsForUser, getRoleForContext, } from '../wa/whitelist.js';
-import { buildInitPayload, buildRecentContext } from './bootstrap.js';
-import { tryCommand } from './commands.js';
-import { checkTrigger } from './triggers.js';
+import { detectMediaType, downloadAndSave, getMediaSize, } from '../store/media.js';
+import { discoverGroupIfNew } from '../wa/whitelist.js';
+import { processIncomingMessage } from './ingest.js';
 export function attachIncoming(sock) {
     const ownerJid = sock.user?.id
         ? jidNormalizedUser(sock.user.id)
@@ -26,7 +13,7 @@ export function attachIncoming(sock) {
     // Process ones within the age window through the normal pipeline.
     sock.ev.on('messaging-history.set', ({ messages: historyMsgs }) => {
         logger.info({ count: historyMsgs.length }, 'history sync received');
-        void processMessages(historyMsgs, sock, ownerJid);
+        void processMessages(historyMsgs, sock, ownerJid, true);
     });
     sock.ev.on('messages.upsert', async ({ messages, type }) => {
         if (type !== 'notify' && type !== 'append')
@@ -37,230 +24,12 @@ export function attachIncoming(sock) {
 async function processMessages(messages, sock, ownerJid, isHistorySync = false) {
     for (const msg of messages) {
         try {
-            const stored = await toStored(msg, ownerJid, sock);
-            if (!stored)
-                continue;
-            // Age gate: skip messages older than maxMessageAgeMs
-            const ageMs = Date.now() - stored.timestamp * 1000;
-            if (ageMs > config.reply.maxMessageAgeMs) {
-                if (isHistorySync)
-                    continue; // don't store ancient history
-                await append(stored);
-                logger.debug({ jid: stored.jid, ageMs: Math.floor(ageMs) }, 'message too old, stored silently');
-                continue;
-            }
-            const isGroup = stored.jid.endsWith('@g.us');
-            if (isGroup)
-                await discoverGroupIfNew(sock, stored.jid);
-            const decision = checkAccess({
-                jid: stored.jid,
-                isGroup,
-                senderNumber: stored.senderNumber,
-                fromMe: stored.fromMe,
-            });
-            const logCtx = {
-                jid: stored.jid,
-                from: stored.senderNumber || '(owner)',
-                fromMe: stored.fromMe,
-                type: stored.messageType,
-                text: stored.text.slice(0, 80),
-                decision: decision.reason,
-            };
-            if (!decision.store) {
-                logger.debug(logCtx, 'message dropped');
-                continue;
-            }
-            // File-size gate: refuse oversized media BEFORE downloading. Per-role
-            // cap; owner is always unlimited. If a file is too big we store the
-            // message (text/caption preserved for history), tell the user, and
-            // skip the Claude call — Claude would have no useful payload anyway.
-            const limits = getLimitsForUser(stored.senderNumber, isGroup);
-            const incomingMediaType = detectMediaType(msg);
-            if (incomingMediaType &&
-                limits.maxFileBytes !== null &&
-                decision.respond) {
-                const size = getMediaSize(msg);
-                if (size !== null && size > limits.maxFileBytes) {
-                    await append(stored);
-                    const quoted = isGroup && config.reply.quoteInGroups ? msg : undefined;
-                    await sendText(sock, stored.jid, 'Could not process that, please try a smaller file.', quoted).catch((err) => logger.error({ err, jid: stored.jid }, 'failed to send oversized-file notice'));
-                    logger.info({ ...logCtx, size, cap: limits.maxFileBytes }, 'oversized media rejected');
-                    continue;
-                }
-            }
-            // Download media if present (image, video, audio, document)
-            const media = await downloadAndSave(msg, stored.jid);
-            // Post-download safety net: re-check against the real buffer size.
-            // Catches cases the pre-download gate missed — protobuf fileLength
-            // missing, nested in documentWithCaptionMessage, stickers, etc.
-            // Only enforced when we'd otherwise respond; silent groups keep the
-            // archive intact regardless of size.
-            if (media &&
-                limits.maxFileBytes !== null &&
-                decision.respond &&
-                media.bytes > limits.maxFileBytes) {
-                await unlink(media.mediaPath).catch(() => undefined);
-                await append(stored);
-                const quoted = isGroup && config.reply.quoteInGroups ? msg : undefined;
-                await sendText(sock, stored.jid, 'Could not process that, please try a smaller file.', quoted).catch((err) => logger.error({ err, jid: stored.jid }, 'failed to send oversized-file notice'));
-                logger.info({ ...logCtx, bytes: media.bytes, cap: limits.maxFileBytes }, 'oversized media rejected (post-download)');
-                continue;
-            }
-            if (media) {
-                stored.mediaType = media.mediaType;
-                stored.mediaPath = media.mediaPath;
-                stored.mediaMime = media.mediaMime;
-            }
-            await append(stored);
-            if (!decision.respond) {
-                logger.info(logCtx, 'message captured, silent');
+            const incoming = await toIncoming(msg, ownerJid, sock);
+            if (!incoming)
                 continue;
-            }
-            // Need either text or media to respond
-            if (!stored.text.trim() && !media) {
-                logger.debug(logCtx, 'message captured, respond skipped (empty)');
-                continue;
-            }
-            // Commands short-circuit the AI pipeline (always, regardless of trigger mode)
-            const isCommand = await tryCommand({
-                sock,
-                jid: stored.jid,
-                text: stored.text,
-                senderNumber: stored.senderNumber,
-                quoted: isGroup && config.reply.quoteInGroups ? msg : undefined,
-            });
-            if (isCommand) {
-                logger.info(logCtx, 'command handled');
-                continue;
-            }
-            // Self-chat: owner messaging themselves — always trigger
-            const isSelfChat = stored.fromMe && !isGroup &&
-                jidDecode(stored.jid)?.user === config.owner.number;
-            // Trigger gate: alias / @mention / reply-to-bot depending on mode
-            let triggerReason = isSelfChat ? 'self-chat' : '';
-            if (!isSelfChat) {
-                const trigger = checkTrigger({
-                    isGroup,
-                    text: stored.text,
-                    msg,
-                    sock,
-                });
-                if (!trigger.triggered) {
-                    logger.info({ ...logCtx, trigger: trigger.reason }, 'message captured, no trigger');
-                    continue;
-                }
-                triggerReason = trigger.reason;
-            }
-            // Daily token cap: silent drop once the user has burned their budget
-            // for the day. Owner is exempt (limits.dailyTokenLimit is null).
-            if (limits.dailyTokenLimit !== null) {
-                const used = getDailyTokens(stored.senderNumber);
-                if (used >= limits.dailyTokenLimit) {
-                    logger.info({
-                        ...logCtx,
-                        used,
-                        cap: limits.dailyTokenLimit,
-                        trigger: triggerReason,
-                    }, 'daily token quota exhausted, silent drop');
-                    continue;
-                }
-            }
-            const { role } = getRoleForContext(stored.senderNumber, isGroup);
-            const existingSession = getSession(stored.jid, getProvider().name);
-            let userContent = stored.text;
-            if (media) {
-                const tag = mediaPromptTag(media, stored.text);
-                userContent = tag;
-            }
-            const recentText = stored.text;
-            const memoryPreamble = buildMemoryPreamble({
-                jid: stored.jid,
-                senderNumber: stored.senderNumber,
-                isGroup,
-                recentText,
-            });
-            let core;
-            if (existingSession) {
-                const recent = await buildRecentContext(stored.jid, config.bootstrap.recentContextDepth);
-                const current = `[Current message]\n${stored.senderNumber}: ${userContent}`;
-                core = recent ? `${recent}\n${current}` : userContent;
-            }
-            else {
-                core = await buildInitPayload({
-                    jid: stored.jid,
-                    sock,
-                    userText: userContent,
-                    userNumber: stored.senderNumber,
-                });
-            }
-            const input = `${memoryPreamble}\n\n---\n\n${core}`;
-            logger.info({ ...logCtx, resume: !!existingSession, trigger: triggerReason }, 'message captured, enqueuing');
-            const job = {
-                jid: stored.jid,
-                text: stored.text,
-                input,
-                sessionId: existingSession,
-                senderNumber: stored.senderNumber,
-                fromMe: stored.fromMe,
-                allowedTools: role.tools,
-                allowedTags: role.tags,
-            };
-            // Enqueue into the inbound table; chat worker pool drains and
-            // calls processJob + handleReply asynchronously. Typing indicator
-            // is temporarily dropped (was tied to the old synchronous flow);
-            // re-add via ChannelAdapter.sendTyping() in a follow-up commit.
-            const chatAddress = formatAddress(jidToAddress(stored.jid));
-            const senderAddress = stored.senderNumber
-                ? formatAddress(jidToAddress(`${stored.senderNumber}@s.whatsapp.net`))
-                : null;
-            const personId = personIdForAddress(chatAddress);
-            const actorPersonId = senderAddress
-                ? personIdForAddress(senderAddress)
-                : null;
-            // Estimator: classify this message and, when a kind matches,
-            // (a) tag the inbound row so future estimates of the same kind
-            // get a fresh sample, and (b) send the estimate text as an
-            // immediate ack so the user sees a timeline before the agent
-            // even starts.
-            const est = estimateJob({
-                description: stored.text,
-                attachments: media ? [{ kind: media.mediaType }] : undefined,
-                senderPersonId: actorPersonId ?? undefined,
-            });
-            const jobKind = est?.kind ?? null;
-            if (est) {
-                enqueueOutbound({
-                    address: chatAddress,
-                    kind: 'text',
-                    text: est.text,
-                    idempotencyKey: `estimate-${msg.key.id}`,
-                });
-            }
-            else if (media && config.reply.ackOnMedia !== false) {
-                // Fallback media-ack when no estimator matched — keeps the
-                // pre-estimator behavior so image messages still get the
-                // "looking…" hint. A future MediaIncomingEstimator can replace
-                // this with a real average.
-                enqueueOutbound({
-                    address: chatAddress,
-                    kind: 'text',
-                    text: config.reply.mediaAckText,
-                    idempotencyKey: `media-ack-${msg.key.id}`,
-                });
-            }
-            enqueueInbound({
-                address: chatAddress,
-                actorAddress: senderAddress,
-                personId,
-                actorPersonId,
-                externalMsgId: msg.key.id ?? null,
-                text: stored.text,
-                pushName: stored.pushName ?? null,
-                triggerReason,
-                kind: jobKind,
-                receivedAt: stored.timestamp,
-                payload: job,
-            });
+            if (incoming.isGroup)
+                await discoverGroupIfNew(sock, incoming.accessKey);
+            await processIncomingMessage(incoming, { isHistorySync });
         }
         catch (err) {
             logger.error({ err, msgId: msg.key.id }, 'failed to process incoming message');
@@ -278,7 +47,7 @@ async function resolveToPn(sock, jid) {
         return jid;
     }
 }
-async function toStored(msg, ownerJid, sock) {
+async function toIncoming(msg, ownerJid, sock) {
     const rawJid = msg.key.remoteJid;
     if (!rawJid)
         return null;
@@ -288,8 +57,8 @@ async function toStored(msg, ownerJid, sock) {
         return null;
     const fromMe = !!msg.key.fromMe;
     const isGroup = isJidGroup(rawJid) === true;
-    // canonicalize chat jid: groups stay as @g.us, DMs preferred as @s.whatsapp.net,
-    // drop device suffix (e.g. ":19") so chats from different devices merge
+    // Canonicalize chat jid: groups stay as @g.us, DMs preferred as
+    // @s.whatsapp.net, drop device suffixes so devices merge.
     const jid = isGroup
         ? jidNormalizedUser(rawJid)
         : jidNormalizedUser(await resolveToPn(sock, rawJid));
@@ -307,19 +76,103 @@ async function toStored(msg, ownerJid, sock) {
     const senderNumber = jidDecode(sender)?.user ?? '';
     const messageType = getContentType(msg.message) ?? 'unknown';
     const text = extractText(msg.message);
+    const timestamp = typeof msg.messageTimestamp === 'number'
+        ? msg.messageTimestamp
+        : Number(msg.messageTimestamp ?? 0);
+    const msgId = msg.key.id ?? `${jid}-${timestamp}`;
+    const mediaType = detectMediaType(msg);
     return {
-        id: msg.key.id ?? '',
-        jid,
-        direction: fromMe ? 'out' : 'in',
-        fromMe,
-        sender,
-        senderNumber,
-        pushName: msg.pushName ?? undefined,
-        timestamp: typeof msg.messageTimestamp === 'number'
-            ? msg.messageTimestamp
-            : Number(msg.messageTimestamp ?? 0),
+        id: msgId,
+        externalMsgId: `wa:${msgId}`,
+        channel: 'wa',
+        address: formatAddress(jidToAddress(jid)),
+        chatKey: jid,
+        accessKey: jid,
+        actorAddress: senderNumber
+            ? formatAddress(jidToAddress(`${senderNumber}@s.whatsapp.net`))
+            : null,
+        senderKey: senderNumber,
+        senderLabel: msg.pushName ?? undefined,
+        timestamp,
         text,
+        fromMe,
+        isGroup,
         messageType,
+        mediaType,
+        mediaBytes: mediaType ? getMediaSize(msg) : null,
+        downloadMedia: mediaType ? () => downloadAndSave(msg, jid) : undefined,
+        quoteMsgId: msg.key.id ?? null,
+        triggerHints: waTriggerHints(msg, sock),
+        selfChat: fromMe &&
+            !isGroup &&
+            jidDecode(jid)?.user === config.owner.number,
+        loadChatMetadata: () => loadWaChatMetadata(sock, jid, isGroup),
+    };
+}
+function contextInfo(message) {
+    return (message.extendedTextMessage?.contextInfo ??
+        message.imageMessage?.contextInfo ??
+        message.videoMessage?.contextInfo ??
+        message.audioMessage?.contextInfo ??
+        message.documentMessage?.contextInfo ??
+        message.documentWithCaptionMessage?.message?.documentMessage?.contextInfo ??
+        message.stickerMessage?.contextInfo);
+}
+function ownerNumbers(sock) {
+    const out = new Set();
+    if (config.owner.number)
+        out.add(config.owner.number);
+    const pn = sock.user?.id ? jidDecode(sock.user.id)?.user : undefined;
+    if (pn)
+        out.add(pn);
+    const lid = sock.user?.lid ? jidDecode(sock.user.lid)?.user : undefined;
+    if (lid)
+        out.add(lid);
+    return out;
+}
+function waTriggerHints(msg, sock) {
+    const ci = msg.message ? contextInfo(msg.message) : undefined;
+    if (!ci)
+        return {};
+    const owners = ownerNumbers(sock);
+    let mentionedBot = false;
+    for (const m of ci.mentionedJid ?? []) {
+        const user = jidDecode(m)?.user;
+        if (user && owners.has(user)) {
+            mentionedBot = true;
+            break;
+        }
+    }
+    let replyToBot = false;
+    const quotedParticipant = ci.participant;
+    if (quotedParticipant) {
+        const user = jidDecode(quotedParticipant)?.user;
+        replyToBot = !!user && owners.has(user);
+    }
+    return { mentionedBot, replyToBot };
+}
+async function loadWaChatMetadata(sock, jid, isGroup) {
+    if (!isGroup) {
+        return { platform: 'WhatsApp', isGroup, externalId: jid };
+    }
+    let chatName = 'unknown';
+    let memberSummary = '';
+    try {
+        const meta = await sock.groupMetadata(jid);
+        chatName = meta.subject || chatName;
+        if (meta.participants?.length) {
+            memberSummary = `${meta.participants.length} participants`;
+        }
+    }
+    catch (err) {
+        logger.warn({ err, jid }, 'group metadata fetch failed in bootstrap');
+    }
+    return {
+        platform: 'WhatsApp',
+        isGroup,
+        chatName,
+        memberSummary,
+        externalId: jid,
     };
 }
 function extractText(message) {

package/dist/gateway/ingest.js

@@ -0,0 +1,240 @@
+import { unlink } from 'fs/promises';
+import { getProvider } from '../ai/providers.js';
+import { getSession } from '../ai/sessions.js';
+import { config } from '../config.js';
+import { personIdForAddress } from '../db/identity-sync.js';
+import { estimate as estimateJob } from '../estimates/index.js';
+import { logger } from '../logger.js';
+import { buildMemoryPreamble } from '../memory/preamble.js';
+import { enqueueInbound } from '../queue/inbound.js';
+import { enqueueOutbound } from '../queue/outbound.js';
+import { mediaPromptTag } from '../store/media.js';
+import { append } from '../store/messages.js';
+import { getDailyTokens } from '../store/usage.js';
+import { checkAccess, discoverAddressGroupIfNew, getLimitsForUser, getRoleForContext, } from '../wa/whitelist.js';
+import { buildInitPayload, buildRecentContext } from './bootstrap.js';
+import { tryCommand } from './commands.js';
+import { checkTrigger } from './triggers.js';
+function toStored(incoming) {
+    return {
+        id: incoming.id,
+        jid: incoming.chatKey,
+        direction: incoming.fromMe ? 'out' : 'in',
+        fromMe: incoming.fromMe,
+        sender: incoming.actorAddress ?? incoming.senderKey,
+        senderNumber: incoming.senderKey,
+        pushName: incoming.senderLabel,
+        timestamp: incoming.timestamp,
+        text: incoming.text,
+        messageType: incoming.messageType,
+    };
+}
+function enqueueTextReply(incoming, text, idempotencyKey) {
+    enqueueOutbound({
+        address: incoming.address,
+        kind: 'text',
+        text,
+        quoteMsgId: incoming.isGroup && config.reply.quoteInGroups
+            ? incoming.quoteMsgId ?? undefined
+            : undefined,
+        idempotencyKey,
+    });
+}
+export async function processIncomingMessage(incoming, opts = {}) {
+    const stored = toStored(incoming);
+    const ageMs = Date.now() - stored.timestamp * 1000;
+    if (ageMs > config.reply.maxMessageAgeMs) {
+        if (opts.isHistorySync)
+            return;
+        await append(stored);
+        logger.debug({ jid: stored.jid, address: incoming.address, ageMs: Math.floor(ageMs) }, 'message too old, stored silently');
+        return;
+    }
+    if (incoming.isGroup && incoming.channel !== 'wa') {
+        await discoverAddressGroupIfNew({
+            address: incoming.address,
+            name: incoming.chat?.chatName,
+            ownerSender: stored.senderNumber || config.owner.number || undefined,
+        });
+    }
+    const decision = checkAccess({
+        jid: incoming.accessKey,
+        address: incoming.address,
+        isGroup: incoming.isGroup,
+        senderNumber: stored.senderNumber,
+        fromMe: stored.fromMe,
+    });
+    const logCtx = {
+        jid: stored.jid,
+        address: incoming.address,
+        from: stored.senderNumber || '(owner)',
+        fromMe: stored.fromMe,
+        type: stored.messageType,
+        text: stored.text.slice(0, 80),
+        decision: decision.reason,
+    };
+    if (!decision.store) {
+        logger.debug(logCtx, 'message dropped');
+        return;
+    }
+    const limits = getLimitsForUser(stored.senderNumber, incoming.isGroup);
+    if (incoming.mediaType &&
+        limits.maxFileBytes !== null &&
+        decision.respond &&
+        incoming.mediaBytes !== null &&
+        incoming.mediaBytes !== undefined &&
+        incoming.mediaBytes > limits.maxFileBytes) {
+        await append(stored);
+        enqueueTextReply(incoming, 'Could not process that, please try a smaller file.', `oversized-${incoming.externalMsgId}`);
+        logger.info({ ...logCtx, size: incoming.mediaBytes, cap: limits.maxFileBytes }, 'oversized media rejected');
+        return;
+    }
+    let media = null;
+    if (incoming.mediaType && incoming.downloadMedia) {
+        media = await incoming.downloadMedia();
+    }
+    if (media &&
+        limits.maxFileBytes !== null &&
+        decision.respond &&
+        media.bytes > limits.maxFileBytes) {
+        await unlink(media.mediaPath).catch(() => undefined);
+        await append(stored);
+        enqueueTextReply(incoming, 'Could not process that, please try a smaller file.', `oversized-downloaded-${incoming.externalMsgId}`);
+        logger.info({ ...logCtx, bytes: media.bytes, cap: limits.maxFileBytes }, 'oversized media rejected (post-download)');
+        return;
+    }
+    if (media) {
+        stored.mediaType = media.mediaType;
+        stored.mediaPath = media.mediaPath;
+        stored.mediaMime = media.mediaMime;
+    }
+    await append(stored);
+    if (!decision.respond) {
+        logger.info(logCtx, 'message captured, silent');
+        return;
+    }
+    if (!stored.text.trim() && !media) {
+        logger.debug(logCtx, 'message captured, respond skipped (empty)');
+        return;
+    }
+    const isCommand = await tryCommand({
+        jid: stored.jid,
+        address: incoming.address,
+        text: stored.text,
+        senderNumber: stored.senderNumber,
+        reply: async (text) => enqueueTextReply(incoming, text, `command-${incoming.externalMsgId}`),
+    });
+    if (isCommand) {
+        logger.info(logCtx, 'command handled');
+        return;
+    }
+    let triggerReason = incoming.selfChat ? 'self-chat' : '';
+    if (!incoming.selfChat) {
+        const trigger = checkTrigger({
+            isGroup: incoming.isGroup,
+            text: stored.text,
+            mentionedBot: incoming.triggerHints?.mentionedBot,
+            replyToBot: incoming.triggerHints?.replyToBot,
+        });
+        if (!trigger.triggered) {
+            logger.info({ ...logCtx, trigger: trigger.reason }, 'message captured, no trigger');
+            return;
+        }
+        triggerReason = trigger.reason;
+    }
+    if (limits.dailyTokenLimit !== null) {
+        const used = getDailyTokens(stored.senderNumber);
+        if (used >= limits.dailyTokenLimit) {
+            logger.info({
+                ...logCtx,
+                used,
+                cap: limits.dailyTokenLimit,
+                trigger: triggerReason,
+            }, 'daily token quota exhausted, silent drop');
+            return;
+        }
+    }
+    const { role } = getRoleForContext(stored.senderNumber, incoming.isGroup);
+    const existingSession = getSession(stored.jid, getProvider().name);
+    let userContent = stored.text;
+    if (media) {
+        userContent = mediaPromptTag(media, stored.text);
+    }
+    const memoryPreamble = buildMemoryPreamble({
+        jid: stored.jid,
+        senderNumber: stored.senderNumber,
+        isGroup: incoming.isGroup,
+        recentText: stored.text,
+    });
+    let core;
+    if (existingSession) {
+        const recent = await buildRecentContext(stored.jid, config.bootstrap.recentContextDepth);
+        const current = `[Current message]\n${stored.senderNumber}: ${userContent}`;
+        core = recent ? `${recent}\n${current}` : userContent;
+    }
+    else {
+        const chat = incoming.chat ?? await incoming.loadChatMetadata?.();
+        core = await buildInitPayload({
+            jid: stored.jid,
+            userText: userContent,
+            userNumber: stored.senderNumber,
+            chat,
+        });
+    }
+    const input = `${memoryPreamble}\n\n---\n\n${core}`;
+    logger.info({ ...logCtx, resume: !!existingSession, trigger: triggerReason }, 'message captured, enqueuing');
+    const job = {
+        jid: stored.jid,
+        address: incoming.address,
+        actorAddress: incoming.actorAddress,
+        text: stored.text,
+        input,
+        sessionId: existingSession,
+        senderNumber: stored.senderNumber,
+        fromMe: stored.fromMe,
+        allowedTools: role.tools,
+        allowedTags: role.tags,
+    };
+    const personId = personIdForAddress(incoming.address);
+    const actorPersonId = incoming.actorAddress
+        ? personIdForAddress(incoming.actorAddress)
+        : null;
+    const est = estimateJob({
+        description: stored.text,
+        attachments: media ? [{ kind: media.mediaType }] : undefined,
+        senderPersonId: actorPersonId ?? undefined,
+    });
+    const jobKind = est?.kind ?? null;
+    if (est) {
+        enqueueOutbound({
+            address: incoming.address,
+            kind: 'text',
+            text: est.text,
+            idempotencyKey: `estimate-${incoming.externalMsgId}`,
+        });
+    }
+    else if (media && config.reply.ackOnMedia !== false) {
+        enqueueOutbound({
+            address: incoming.address,
+            kind: 'text',
+            text: config.reply.mediaAckText,
+            idempotencyKey: `media-ack-${incoming.externalMsgId}`,
+        });
+    }
+    enqueueInbound({
+        address: incoming.address,
+        actorAddress: incoming.actorAddress,
+        personId,
+        actorPersonId,
+        externalMsgId: incoming.externalMsgId,
+        text: stored.text,
+        mediaPath: media?.mediaPath ?? null,
+        mediaMime: media?.mediaMime ?? null,
+        mediaBytes: media?.bytes ?? null,
+        pushName: stored.pushName ?? null,
+        triggerReason,
+        kind: jobKind,
+        receivedAt: stored.timestamp,
+        payload: job,
+    });
+}

package/dist/gateway/outgoing.js

@@ -1,9 +1,9 @@
 import { existsSync, statSync } from 'fs';
 import { extname } from 'path';
-import { isJidGroup } from 'baileys';
 import { config } from '../config.js';
 import { formatAddress, jidToAddress } from '../db/address.js';
 import { logger } from '../logger.js';
+import { addressForJob } from '../queue/job-address.js';
 import { enqueueOutbound } from '../queue/outbound.js';
 import { detectMediaType } from '../wa/sender.js';
 // Matches [FILE: path], [IMAGE: path], [VIDEO: path], [AUDIO: path], [DOCUMENT: path]
@@ -60,9 +60,7 @@ export async function handleReply(job, result, _originalMsg) {
     if (!raw)
         return;
     const { text, files } = extractFiles(raw);
-    const isGroup = isJidGroup(job.jid) === true;
-    void isGroup; // quoting deferred; see comment above
-    const address = formatAddress(jidToAddress(job.jid));
+    const address = addressForJob(job);
     // Surface media tags in the footer too. Files already parsed above
     // — just map each to its kind so the footer reads e.g. "+2 image".
     const mediaKinds = files.map(kindForFile);
@@ -142,7 +140,7 @@ export async function initiate(params) {
     const { text, files } = extractFiles(raw);
     if (!text && files.length === 0)
         return false;
-    const address = formatAddress(jidToAddress(params.jid));
+    const address = params.address ?? formatAddress(jidToAddress(params.jid));
     let pieceIdx = 0;
     const baseKey = `initiate-${params.jid}-${Date.now()}`;
     const enqueuePiece = (input) => {