bloby-bot 0.46.1 → 0.46.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.46.1",
+  "version": "0.46.3",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",
@@ -58,7 +58,7 @@
     "@streamdown/code": "^1.1.1",
     "@tailwindcss/vite": "^4.2.0",
     "@vitejs/plugin-react": "^6.0.1",
-    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "@whiskeysockets/baileys": "^7.0.0-rc11",
     "better-sqlite3": "^12.6.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",

package/scripts/postinstall.js

@@ -77,6 +77,22 @@ try {
   console.error('Warning: failed to install dependencies in ~/.bloby/ — run "cd ~/.bloby && npm install" manually');
 }
 
+// ── Prune wrong-libc claude-agent-sdk native package ──
+// The SDK's binary resolver tries the musl variant before glibc on Linux. If
+// both optionalDependencies install (npm does that for arm64), a glibc system
+// like Raspberry Pi OS picks the musl binary and fails to spawn it.
+if (process.platform === 'linux') {
+  const muslLoader = `/lib/ld-musl-${process.arch === 'arm64' ? 'aarch64' : process.arch === 'x64' ? 'x86_64' : process.arch}.so.1`;
+  const systemIsMusl = fs.existsSync(muslLoader);
+  const unwanted = systemIsMusl
+    ? `claude-agent-sdk-linux-${process.arch}`
+    : `claude-agent-sdk-linux-${process.arch}-musl`;
+  const unwantedPath = path.join(BLOBY_HOME, 'node_modules', '@anthropic-ai', unwanted);
+  if (fs.existsSync(unwantedPath)) {
+    fs.rmSync(unwantedPath, { recursive: true, force: true });
+  }
+}
+
 // ── Install workspace dependencies (isolated from system deps) ──
 // Native modules (better-sqlite3) must be built for the target platform —
 // failures here cause backend crash loops, so surface them.

package/supervisor/channels/manager.ts

@@ -25,9 +25,10 @@ import { WORKSPACE_DIR } from '../../shared/paths.js';
 import { log } from '../../shared/logger.js';
 import { startBlobyAgentQuery, startConversation, pushMessage, hasConversation, type RecentMessage } from '../bloby-agent.js';
 import { WhatsAppChannel } from './whatsapp.js';
-import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, InboundMessageAttachment, SenderRole } from './types.js';
+import type { ChannelConfig, ChannelProvider, ChannelStatus, ChannelType, InboundMessage, InboundMessageAttachment, RoutingTarget, SenderRole } from './types.js';
 import type { AgentAttachment } from '../bloby-agent.js';
 import { saveAttachment, type SavedFile } from '../file-saver.js';
+import type { WAMessageKey } from '@whiskeysockets/baileys';
 
 const MAX_CONCURRENT_AGENTS = 5;
 const MAX_BUFFER_MESSAGES = 30;
@@ -74,6 +75,8 @@ interface DebounceEntry {
   isSelfChat: boolean;
   chatJid: string;
   isGroup: boolean;
+  /** Latest inbound message key in the batch (used for reactions/quotes on the freshest message). */
+  inboundKey?: WAMessageKey;
 }
 
 /** Per-conversation accumulator for streaming bot text → WhatsApp. */
@@ -91,8 +94,13 @@ export class ChannelManager {
   private customerBuffers = new Map<string, BufferedMessage[]>();
   /** Debounce buffers per sender (keyed by "channel:sender") */
   private debounceBuffers = new Map<string, DebounceEntry>();
-  /** FIFO queue of reply targets — one per pushMessage, consumed on each bot:response */
-  private waReplyQueue: { channel: ChannelType; rawSender: string; assistantBufferKey?: string }[] = [];
+  /**
+   * Per-conversation FIFO of routing targets. One entry pushed for every user message,
+   * one consumed for every `bot:response`. This is the supervisor-enforced anti-bleed
+   * mechanism — the agent's reply is pinned to whatever surface triggered it, regardless
+   * of any mid-turn inbound from another channel.
+   */
+  private routingQueues = new Map<string, RoutingTarget[]>();
 
   constructor(opts: ChannelManagerOpts) {
     this.opts = opts;
@@ -110,9 +118,9 @@ export class ChannelManager {
 
     log.info('[channels] Initializing WhatsApp channel...');
     const whatsapp = new WhatsAppChannel(
-      (sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, images) => {
+      (sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, images, inboundKey) => {
         const attachments = images?.map((img) => ({ type: 'image' as const, mediaType: img.mediaType, data: img.data }));
-        this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, attachments);
+        this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, attachments, inboundKey);
       },
       (status) => this.handleStatusChange(status),
       (audioBase64) => this.transcribeAudio(audioBase64),
@@ -134,9 +142,9 @@ export class ChannelManager {
     let provider = this.providers.get('whatsapp');
     if (!provider) {
       const whatsapp = new WhatsAppChannel(
-        (sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, images) => {
+        (sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, images, inboundKey) => {
           const attachments = images?.map((img) => ({ type: 'image' as const, mediaType: img.mediaType, data: img.data }));
-          this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, attachments);
+          this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, attachments, inboundKey);
         },
         (status) => this.handleStatusChange(status),
         (audioBase64) => this.transcribeAudio(audioBase64),
@@ -338,65 +346,119 @@ export class ChannelManager {
     return { chunkBuf: '' };
   }
 
+  /** Push a user message into a live conversation and pin where the assistant's reply must go.
+   *
+   *  THIS IS THE SINGLE SOURCE OF TRUTH for routing — every caller (chat-WS, channel inbound
+   *  handlers, scheduler, etc.) MUST push via this method, never via the raw harness pushMessage.
+   *
+   *  Each call enqueues exactly one routing target onto a per-conversation FIFO. Each
+   *  `bot:response` consumes exactly one entry. Concurrent inbounds from different surfaces
+   *  during the same turn cannot bleed into each other's replies — the SDK queues inputs in
+   *  order, and the FIFO mirrors that ordering. Turns that end without a response (error /
+   *  empty turn / aborted) drain the head entry in `routeWaStreamEvent` so the queue stays
+   *  in sync. */
+  pushWithRouting(
+    convId: string,
+    target: RoutingTarget,
+    content: string,
+    attachments?: AgentAttachment[],
+    savedFiles?: SavedFile[],
+  ): void {
+    let q = this.routingQueues.get(convId);
+    if (!q) {
+      q = [];
+      this.routingQueues.set(convId, q);
+    }
+    q.push(target);
+    pushMessage(convId, content, attachments, savedFiles);
+  }
+
+  /** Peek the head of the routing queue without consuming. Used during intermediate streaming
+   *  flushes (bot:tool) so chunks land on the correct surface before the final response. */
+  private peekRoute(convId: string): RoutingTarget | undefined {
+    return this.routingQueues.get(convId)?.[0];
+  }
+
+  /** Consume one entry from the routing queue. Called on `bot:response`, and as a safety net
+   *  on `bot:turn-complete`/`bot:error` if no response fired (so the head doesn't bleed into
+   *  the next turn). */
+  private consumeRoute(convId: string): RoutingTarget | undefined {
+    const q = this.routingQueues.get(convId);
+    if (!q || q.length === 0) return undefined;
+    const target = q.shift();
+    if (q.length === 0) this.routingQueues.delete(convId);
+    return target;
+  }
+
+  /** Drop all pending routes for a conversation — used when the live conversation ends.
+   *  Accepts undefined for ergonomics in callers that hold a possibly-undefined convId. */
+  clearRoutes(convId: string | undefined): void {
+    if (!convId) return;
+    const q = this.routingQueues.get(convId);
+    if (q && q.length > 0) {
+      log.warn(`[channels] Discarding ${q.length} pending route(s) for ended conversation ${convId}`);
+    }
+    this.routingQueues.delete(convId);
+  }
+
+  /** Send a reaction emoji on the inbound message that triggered a turn. Used to acknowledge
+   *  long-running work without spamming text. Pass `''` to remove a previous reaction. */
+  async reactToInbound(target: RoutingTarget, emoji: string): Promise<void> {
+    if (!target.inboundKey || !target.waSendTo) return;
+    const provider = this.providers.get('whatsapp');
+    if (provider instanceof WhatsAppChannel) {
+      await provider.sendReaction(target.waSendTo, target.inboundKey as WAMessageKey, emoji);
+    }
+  }
+
+  /** Direct reaction API (for the /api/channels/whatsapp/react endpoint). */
+  async reactToMessage(channel: ChannelType, chatJid: string, key: WAMessageKey, emoji: string): Promise<void> {
+    const provider = this.providers.get(channel);
+    if (!(provider instanceof WhatsAppChannel)) {
+      throw new Error(`Channel ${channel} does not support reactions`);
+    }
+    await provider.sendReaction(chatJid, key, emoji);
+  }
+
   /** Centralized WhatsApp routing for streaming agent events.
    *
-   * Decision rule:
-   *   - If the manager has a queued reply target (set by `handleAdminMessage` when
-   *     a WhatsApp inbound was the trigger) → send to that target.
-   *   - Else if `fallbackMirrorJid` is provided (chat-UI initiated) → mirror to that JID
-   *     (typically the user's own number for self-chat mirroring).
-   *   - Else → don't send anything to WhatsApp.
+   * Every event passes through here exactly once (only one onMessage callback is registered
+   * per live conversation, regardless of who started it). The routing decision is pure: it
+   * consults the per-conversation FIFO populated by `pushWithRouting`. No fallback, no
+   * implicit channel inference — the trigger surface owns the reply.
    *
-   * This method also updates the assistant context buffer when applicable.
-   * Call from any callback registered via startConversation. Safe to call from
-   * either the orchestrator or the manager's own callback — they will not
-   * double-send because only one callback is registered per live conversation.
+   * Also keeps assistant-mode context buffers up to date.
    */
   routeWaStreamEvent(
     state: WaStreamState,
     type: string,
     eventData: any,
-    fallbackMirrorJid: string | null,
     botName: string,
   ): void {
+    const convId = eventData?.conversationId as string | undefined;
+
     if (type === 'bot:token' && eventData?.token) {
       state.chunkBuf += eventData.token;
       return;
     }
 
-    const fireSend = (jid: string, text: string, prefix: boolean) => {
-      const body = prefix ? this.formatBotReply(text, botName) : text;
-      this.sendMessage('whatsapp', jid, body).catch((err) => {
-        log.warn(`[channels] WA send failed (${jid}): ${err.message}`);
-      });
-    };
-
-    if (type === 'bot:tool' && state.chunkBuf.trim()) {
-      // Agent paused for a tool call — flush whatever text was streamed so the user
-      // sees progress before the tool result lands.
-      const target = this.waReplyQueue[0]; // peek; consume on bot:response
-      if (target) {
-        fireSend(target.rawSender, state.chunkBuf.trim(), true);
-      } else if (fallbackMirrorJid) {
-        fireSend(`${fallbackMirrorJid}@s.whatsapp.net`, state.chunkBuf.trim(), false);
-      }
+    if (type === 'bot:tool' && state.chunkBuf.trim() && convId) {
+      // Agent paused for a tool call — flush streamed text so the user sees progress
+      // before the tool result lands. Peek (don't consume) — the final bot:response
+      // is what closes out the turn.
+      this.sendStreamChunk(this.peekRoute(convId), state.chunkBuf.trim(), botName);
       state.chunkBuf = '';
       return;
     }
 
-    if (type === 'bot:response' && eventData?.content) {
-      const target = this.waReplyQueue.shift(); // consume the reply target for this turn
+    if (type === 'bot:response' && eventData?.content && convId) {
+      const target = this.consumeRoute(convId);
       const remaining = state.chunkBuf.trim();
-
-      if (target) {
-        if (remaining) fireSend(target.rawSender, remaining, true);
-      } else if (remaining && fallbackMirrorJid) {
-        fireSend(`${fallbackMirrorJid}@s.whatsapp.net`, remaining, false);
-      }
+      if (remaining) this.sendStreamChunk(target, remaining, botName);
       state.chunkBuf = '';
 
-      // Append the assistant's reply into the per-chat context buffer so subsequent
-      // triggers in that chat see it as conversation history.
+      // Append the assistant's reply into the per-chat context buffer so the next
+      // trigger in that chat sees it as conversation history.
       if (target?.assistantBufferKey) {
         const buf = this.customerBuffers.get(target.assistantBufferKey);
         if (buf) {
@@ -404,9 +466,34 @@ export class ChannelManager {
           if (buf.length > MAX_BUFFER_MESSAGES) buf.splice(0, buf.length - MAX_BUFFER_MESSAGES);
         }
       }
+      return;
+    }
+
+    // Turn ended (or errored) without a bot:response — drain the head entry so it
+    // doesn't bleed into the next turn's reply. The SDK guarantees one response per
+    // pushed input; this safety net covers aborts, empty turns, and provider errors.
+    if ((type === 'bot:turn-complete' || type === 'bot:error') && convId) {
+      if (this.peekRoute(convId)) {
+        const dropped = this.consumeRoute(convId);
+        log.warn(`[channels] ${type} without bot:response — dropping pending route (surface=${dropped?.surface}, to=${dropped?.waSendTo || 'none'})`);
+      }
+      state.chunkBuf = '';
     }
   }
 
+  /** Deliver a streamed chunk to the WhatsApp side of a routing target.
+   *  No-op when the target has no `waSendTo` (e.g., chat-UI turn with WA disconnected). */
+  private sendStreamChunk(target: RoutingTarget | undefined, text: string, botName: string): void {
+    if (!target?.waSendTo) return;
+    // Prefix only when the trigger came from WhatsApp AND it isn't the user's own self-chat —
+    // the user doesn't need to see "🤖 Bot:" before their own bot's reply in their own chat.
+    const usePrefix = target.surface === 'whatsapp' && !target.isSelfChat;
+    const body = usePrefix ? this.formatBotReply(text, botName) : text;
+    this.sendMessage('whatsapp', target.waSendTo, body).catch((err) =>
+      log.warn(`[channels] WA send failed (${target.waSendTo}): ${err.message}`),
+    );
+  }
+
   private handleStatusChange(status: ChannelStatus) {
     for (const listener of this.statusListeners) {
       listener(status);
@@ -434,6 +521,7 @@ export class ChannelManager {
     chatJid: string,
     isGroup: boolean,
     attachments?: InboundMessageAttachment[],
+    inboundKey?: WAMessageKey,
   ) {
     const channelConfig = this.getChannelConfig(channel);
     if (!channelConfig) return;
@@ -482,6 +570,7 @@ export class ChannelManager {
       existing.messages.push(text);
       if (attachments?.length) existing.attachments.push(...attachments);
       existing.senderName = senderName || existing.senderName;
+      if (inboundKey) existing.inboundKey = inboundKey; // track the freshest message for reactions
       existing.timer = setTimeout(() => this.flushDebounce(debounceKey), DEBOUNCE_MS);
       log.info(`[channels] Debounce: buffered message ${existing.messages.length} from ${sender} in ${chatJid}`);
       return;
@@ -498,6 +587,7 @@ export class ChannelManager {
       isSelfChat,
       chatJid,
       isGroup,
+      inboundKey,
       timer: setTimeout(() => this.flushDebounce(debounceKey), DEBOUNCE_MS),
     };
     this.debounceBuffers.set(debounceKey, entry);
@@ -509,7 +599,7 @@ export class ChannelManager {
     if (!entry) return;
     this.debounceBuffers.delete(key);
 
-    const { channel, sender, senderName, fromMe, isSelfChat, chatJid, isGroup, messages, attachments } = entry;
+    const { channel, sender, senderName, fromMe, isSelfChat, chatJid, isGroup, messages, attachments, inboundKey } = entry;
     const combinedText = messages.join('\n');
 
     const channelConfig = this.getChannelConfig(channel);
@@ -531,6 +621,8 @@ export class ChannelManager {
         text: combinedText,
         rawSender: chatJid,
         attachments: attachments.length > 0 ? attachments : undefined,
+        inboundKey,
+        isGroup,
       };
 
       const modeLabel = mode === 'channel' ? 'Channel mode | self-chat'
@@ -589,6 +681,8 @@ export class ChannelManager {
         displayText: cleanText,
         rawSender: chatJid,
         attachments: attachments.length > 0 ? attachments : undefined,
+        inboundKey,
+        isGroup,
       };
 
       log.info(`[channels] Assistant mode | triggered in ${isGroup ? 'group ' : 'chat with '}${chatId} | buffer=${buffer.length} msgs | "${cleanText.slice(0, 60)}"`);
@@ -607,6 +701,8 @@ export class ChannelManager {
       text: combinedText,
       rawSender: chatJid,
       attachments: attachments.length > 0 ? attachments : undefined,
+      inboundKey,
+      isGroup,
     };
 
     log.info(`[channels] Business mode | ${message.sender} | role=${role} | "${combinedText.slice(0, 60)}"`);
@@ -723,9 +819,10 @@ export class ChannelManager {
       log.info(`[channels] Starting live conversation for admin: ${convId}`);
 
       await startConversation(convId, model, (type, eventData) => {
-        // WhatsApp routing — uses the manager's queue. No fallback mirror jid here:
-        // when no chat UI is open, we should only send to the chat that triggered us.
-        this.routeWaStreamEvent(waState, type, eventData, null, botName);
+        // WhatsApp routing — purely queue-driven, no fallback mirror jid. The
+        // routing target carries the destination; whatever surface triggered the
+        // turn owns the reply.
+        this.routeWaStreamEvent(waState, type, eventData, botName);
 
         // Persist the assistant's reply to the conversation's DB
         if (type === 'bot:response' && eventData.content) {
@@ -747,24 +844,32 @@ export class ChannelManager {
           return;
         }
 
-        // Don't forward internal events to chat clients
-        if (type === 'bot:conversation-ended') return;
+        // Live conversation ended — drop any pending routes so a future
+        // conversation under the same convId starts clean.
+        if (type === 'bot:conversation-ended') {
+          this.clearRoutes(convId);
+          return;
+        }
 
         // Mirror streaming + task events to chat clients
         broadcastBloby(type, eventData);
       }, { botName, humanName }, recentMessages);
     }
 
-    // Enqueue reply target BEFORE pushing — callback consumes in FIFO order
-    this.waReplyQueue.push({
-      channel: msg.channel,
-      rawSender: msg.rawSender,
-      assistantBufferKey: msg.role === 'assistant' ? `${msg.channel}:${msg.sender}` : undefined,
-    });
-
-    // Push the message into the live conversation
+    // Push into the live conversation with a pinned WhatsApp routing target.
+    // The agent's reply for THIS specific input will go to msg.rawSender — no other
+    // surface can hijack it via the FIFO ordering of the shared conversation.
     const channelContent = channelContext + msg.text;
-    pushMessage(convId, channelContent, agentAttachments, savedFiles);
+    const target: RoutingTarget = {
+      surface: 'whatsapp',
+      waSendTo: msg.rawSender,
+      isGroup: msg.isGroup,
+      // Self-chat in 1:1: don't prefix "🤖 Bot:" — it's the user's own chat with themselves.
+      isSelfChat: msg.role === 'admin' && !msg.isGroup,
+      assistantBufferKey: msg.role === 'assistant' ? `${msg.channel}:${msg.sender}` : undefined,
+      inboundKey: msg.inboundKey,
+    };
+    this.pushWithRouting(convId, target, channelContent, agentAttachments, savedFiles);
   }
 
   /** Handle message from a customer — runs support agent in parallel with conversation context */

package/supervisor/channels/types.ts

@@ -39,6 +39,10 @@ export interface InboundMessage {
   rawSender: string;
   /** Image attachments */
   attachments?: InboundMessageAttachment[];
+  /** Original channel-native message key (Baileys WAMessageKey for WhatsApp). Opaque here. */
+  inboundKey?: unknown;
+  /** True when the chat is a group (for assistant-mode group routing). */
+  isGroup?: boolean;
 }
 
 export interface OutboundMessage {
@@ -54,6 +58,34 @@ export interface ChannelStatus {
   info?: Record<string, any>;
 }
 
+/**
+ * Per-turn routing target.
+ *
+ * Every user message pushed into a live conversation carries one of these so the
+ * agent's response goes back to the surface that triggered it — no FIFO ambiguity,
+ * no channel-bleed across concurrent turns.
+ *
+ * Created by the surface that pushes the user message (chat-WS or channel handler),
+ * consumed by the manager when the corresponding `bot:response` fires, discarded if
+ * the turn ends without a response (error / empty turn).
+ */
+export interface RoutingTarget {
+  /** Which surface triggered this turn. Drives whether the WA reply carries a "🤖 Bot:" prefix. */
+  surface: 'chat' | 'whatsapp';
+  /** WhatsApp JID to deliver the reply to.
+   *  - 'whatsapp' surface → the originating chat JID (group or peer).
+   *  - 'chat' surface     → optionally the user's own number (self-chat mirror), or undefined.
+   *  When undefined, no WhatsApp send happens — the reply only reaches the dashboard via broadcast.
+   */
+  waSendTo?: string;
+  isGroup?: boolean;
+  isSelfChat?: boolean;
+  /** When set, the assistant's reply is appended to this customer buffer (assistant-mode context). */
+  assistantBufferKey?: string;
+  /** Original inbound WA message key — kept opaque here, used by the channel to react/quote. */
+  inboundKey?: unknown;
+}
+
 export interface ChannelProvider {
   readonly type: ChannelType;
   /** Start the channel connection (may trigger QR flow) */

package/supervisor/channels/whatsapp.ts

@@ -12,6 +12,7 @@ import makeWASocket, {
   Browsers,
   type WASocket,
   type BaileysEventMap,
+  type WAMessageKey,
 } from '@whiskeysockets/baileys';
 import fs from 'fs';
 import path from 'path';
@@ -33,6 +34,7 @@ export interface WhatsAppImageAttachment {
  * - sender: who sent it (phone JID, translated from LID where possible)
  * - chatJid: the conversation identifier (group JID for groups, peer JID for 1:1) — reply to this
  * - isGroup: true when the chat is a WhatsApp group (@g.us)
+ * - inboundKey: original Baileys message key — used to react/quote/ack the user's message
  */
 export type OnWhatsAppMessage = (
   sender: string,
@@ -43,6 +45,7 @@ export type OnWhatsAppMessage = (
   chatJid: string,
   isGroup: boolean,
   images?: WhatsAppImageAttachment[],
+  inboundKey?: WAMessageKey,
 ) => void;
 
 /** Callback to transcribe audio via whisper */
@@ -181,6 +184,25 @@ export class WhatsAppChannel implements ChannelProvider {
     log.info(`[whatsapp] Sent video to ${jid} (id=${result?.key?.id || 'unknown'})`);
   }
 
+  /** Send an emoji reaction onto an existing message.
+   *  Pass an empty string to remove a previously-sent reaction (Baileys convention). */
+  async sendReaction(chatJid: string, key: WAMessageKey, emoji: string): Promise<void> {
+    if (!this.sock || !this.connected) {
+      log.warn('[whatsapp] Cannot react — not connected');
+      return;
+    }
+    if (!key || !key.id) {
+      log.warn('[whatsapp] Cannot react — missing message key');
+      return;
+    }
+    try {
+      await this.sock.sendMessage(chatJid, { react: { text: emoji, key } });
+      log.info(`[whatsapp] Reacted "${emoji}" to ${key.id} in ${chatJid}`);
+    } catch (err: any) {
+      log.warn(`[whatsapp] Reaction failed: ${err.message}`);
+    }
+  }
+
   /** Send a document (PDF, zip, etc.) via WhatsApp */
   async sendDocument(to: string, document: Buffer, fileName: string, mimetype?: string, caption?: string): Promise<void> {
     if (!this.sock || !this.connected) {
@@ -286,15 +308,28 @@ export class WhatsAppChannel implements ChannelProvider {
 
   // ── Internal ──
 
-  /** Translate a JID from LID format to phone format if possible */
-  private translateJid(jid: string): string {
+  /** Translate a JID from LID format to phone format if possible.
+   *  Falls back to the supplied `alt` (Baileys 7+ `key.participantAlt`/`remoteJidAlt`) which
+   *  carries the phone form when the primary identifier is a LID. */
+  private translateJid(jid: string, alt?: string | null): string {
     // If it's already a phone JID, return as-is
     if (jid.endsWith('@s.whatsapp.net')) return jid;
 
-    // Check LID map (only contains our own LID, mapped during connection)
+    // Check learned LID map first (covers our own LID + any pairs we've seen)
     const mapped = this.lidToPhoneMap.get(jid);
     if (mapped) return mapped;
 
+    // Baileys 7 ships the alternate identifier on the message key. If the primary
+    // is a LID, the alt is the phone-number form — adopt it and learn the mapping
+    // for future messages on this conversation.
+    if (alt && alt.endsWith('@s.whatsapp.net')) {
+      this.lidToPhoneMap.set(jid, alt);
+      // Also map the bare LID number → phone, so different LID encodings collapse
+      const lidNum = jid.split(':')[0].split('@')[0];
+      if (lidNum) this.lidToPhoneMap.set(`${lidNum}@lid`, alt);
+      return alt;
+    }
+
     // Unknown LID — don't guess. Return as-is so isSelfChat stays false.
     return jid;
   }
@@ -499,8 +534,16 @@ export class WhatsAppChannel implements ChannelProvider {
         const participant = msg.key.participant || '';
         const isGroup = rawSender.endsWith('@g.us');
 
+        // Baileys 7 exposes the alternate identifier on the key — when the primary is a LID,
+        // the alt is the phone-number form (and vice versa). Use these to translate cleanly.
+        const remoteJidAlt = (msg.key as any).remoteJidAlt as string | undefined;
+        const participantAlt = (msg.key as any).participantAlt as string | undefined;
+
         // chatJid: where to reply (group JID for groups, peer JID otherwise).
-        const chatJid = rawSender;
+        // For peer chats, prefer the phone-form JID so reactions/replies hit the canonical chat.
+        const chatJid = isGroup
+          ? rawSender
+          : this.translateJid(rawSender, remoteJidAlt);
 
         // The actual sender JID:
         //   - groups: always `participant` (remoteJid is the group)
@@ -508,17 +551,34 @@ export class WhatsAppChannel implements ChannelProvider {
         const actualSender = isGroup
           ? participant || rawSender
           : (participant || rawSender);
+        const senderAlt = isGroup ? participantAlt : (participantAlt || remoteJidAlt);
 
-        // Translate LID JIDs to phone JIDs (only handles our own LID)
-        const sender = this.translateJid(actualSender);
+        // Translate LID → phone via the learned map + the message's `*Alt` fallback.
+        const sender = this.translateJid(actualSender, senderAlt);
         const pushName = msg.pushName || undefined;
 
-        // Self-chat: only meaningful for 1:1 — remoteJid is our own number AND no participant.
-        const isSelfChat = !isGroup && !participant && this.ownPhoneJid !== null && this.translateJid(rawSender) === this.ownPhoneJid;
+        // Self-chat: only meaningful for 1:1. True when the (translated) chat JID is our own number
+        // AND no group participant. Both `participant` and `participantAlt` must be absent — Baileys
+        // sets `participant` on newer 1:1 messages too, so we additionally accept when the participant
+        // (or its alt) resolves to our own phone.
+        const participantResolved = participant ? this.translateJid(participant, senderAlt) : '';
+        const ownsChat = this.ownPhoneJid !== null && chatJid === this.ownPhoneJid;
+        const ownsParticipant = !participant || participantResolved === this.ownPhoneJid;
+        const isSelfChat = !isGroup && ownsChat && ownsParticipant;
 
         log.info(`[whatsapp] Message from ${sender} (chat=${chatJid}, group=${isGroup}, fromMe=${fromMe}, selfChat=${isSelfChat}, images=${images.length}): ${text.slice(0, 80)}`);
 
-        this.onMessage(sender, pushName, text, fromMe, isSelfChat, chatJid, isGroup, images.length > 0 ? images : undefined);
+        this.onMessage(
+          sender,
+          pushName,
+          text,
+          fromMe,
+          isSelfChat,
+          chatJid,
+          isGroup,
+          images.length > 0 ? images : undefined,
+          msg.key,
+        );
       }
     });
   }

package/supervisor/chat/src/hooks/useBlobyChat.ts

@@ -81,14 +81,14 @@ export function useBlobyChat(ws: WsClient | null, triggerReload?: number, enable
     };
   }, []);
 
-  // Load current conversation from DB (last 20 messages)
+  // Load current conversation from DB (last 200 messages — pagination kicks in beyond that)
   const loadFromDb = useCallback(async () => {
     try {
       const ctx = await authFetch('/api/context/current').then((r) => r.json());
       if (!ctx.conversationId) return;
       setConversationId(ctx.conversationId);
 
-      const limit = 20;
+      const limit = 200;
       const res = await authFetch(`/api/conversations/${ctx.conversationId}/messages?limit=${limit}`);
       if (!res.ok) return;
       const data = await res.json();
@@ -100,14 +100,14 @@ export function useBlobyChat(ws: WsClient | null, triggerReload?: number, enable
     } catch { /* worker not ready yet */ }
   }, [parseMessage]);
 
-  // Load older messages (cursor-based pagination)
+  // Load older messages (cursor-based pagination — cursor is the rowid-equivalent on the server)
   const loadOlder = useCallback(async () => {
     if (loadingOlder.current || !conversationIdRef.current) return;
     loadingOlder.current = true;
     try {
       const oldestId = messages[0]?.id;
       if (!oldestId) return;
-      const limit = 20;
+      const limit = 100;
       const res = await authFetch(`/api/conversations/${conversationIdRef.current}/messages?before=${oldestId}&limit=${limit}`);
       if (!res.ok) return;
       const data = await res.json();

package/supervisor/index.ts

@@ -15,7 +15,7 @@ import { spawnBackend, stopBackend, getBackendPort, isBackendAlive, isBackendSto
 import { handleAgentQuery, type AgentQueryRequest } from './agent-api.js';
 import { updateTunnelUrl, startHeartbeat, stopHeartbeat, disconnect } from '../shared/relay.js';
 import {
-  startConversation, pushMessage, hasConversation, endConversation, endAllConversations,
+  startConversation, hasConversation, endConversation, endAllConversations,
   isConversationBusy, stopSubAgentTask,
   startBlobyAgentQuery, stopBlobyAgentQuery,
   warmUpForLiveConversation,
@@ -365,6 +365,7 @@ export async function startSupervisor() {
     'POST /api/channels/whatsapp/logout',
     'POST /api/channels/whatsapp/configure',
     'POST /api/channels/whatsapp/pairing-code',
+    'POST /api/channels/whatsapp/react',
     'POST /api/channels/send',
   ];
 
@@ -735,6 +736,37 @@ ${!connected ? `<script>
         return;
       }
 
+      // POST /api/channels/whatsapp/react — send (or remove) an emoji reaction on a WhatsApp message
+      if (req.method === 'POST' && channelPath === '/api/channels/whatsapp/react') {
+        let body = '';
+        req.on('data', (chunk: Buffer) => { body += chunk.toString(); });
+        req.on('end', async () => {
+          try {
+            const { chatJid, messageId, fromMe, participant, emoji } = JSON.parse(body) as {
+              chatJid?: string;
+              messageId?: string;
+              fromMe?: boolean;
+              participant?: string;
+              emoji?: string;
+            };
+            if (!chatJid || !messageId) {
+              res.writeHead(400);
+              res.end(JSON.stringify({ error: 'chatJid and messageId are required' }));
+              return;
+            }
+            // emoji='' is intentionally supported — it removes a previous reaction (Baileys convention).
+            const key = { remoteJid: chatJid, id: messageId, fromMe: !!fromMe, participant } as any;
+            await channelManager.reactToMessage('whatsapp', chatJid, key, emoji ?? '👍');
+            res.writeHead(200);
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err: any) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: err.message }));
+          }
+        });
+        return;
+      }
+
       // POST /api/channels/send — send a message (and/or media) via any channel
       if (req.method === 'POST' && channelPath === '/api/channels/send') {
         let body = '';
@@ -1295,7 +1327,11 @@ ${!connected ? `<script>
         const data = msg.data || {};
         const content = data.content;
         if (!content) return;
-        if (data.conversationId) convId = data.conversationId;
+        // Note: we intentionally ignore data.conversationId from the client.
+        // The server is the authority on which DB conversation this WS belongs to —
+        // honoring a client-supplied id let stale browser state drive messages into
+        // an orphan conv whose row had been deleted, causing FK failures on every
+        // INSERT. Server resolution below (clientConvs → context.current → create).
 
         // Re-read config on each message so post-onboard changes are picked up
         const freshConfig = loadConfig();
@@ -1364,6 +1400,10 @@ ${!connected ? `<script>
               });
             } catch (err: any) {
               log.warn(`[bloby] DB persist error: ${err.message}`);
+              // Surface to all clients so they can flag the missing user bubble
+              // instead of pretending it's saved. addMessage() in worker/db.ts is
+              // self-healing for orphan convIds, so this should now be rare.
+              broadcastBloby('chat:persist-error', { conversationId: convId, role: 'user', error: err.message });
             }
 
             // Fetch agent/user names and recent messages in parallel
@@ -1406,7 +1446,7 @@ ${!connected ? `<script>
               // the self-chat mirror (the user's own number).
               const waState = channelManager.createWaStreamState();
 
-              await startConversation(convId, freshConfig.ai.model, (type, eventData) => {
+              await startConversation(convId, freshConfig.ai.model, async (type, eventData) => {
                 // Track stream buffer for reconnecting clients
                 if (type === 'bot:typing') {
                   currentStreamConvId = convId;
@@ -1418,11 +1458,10 @@ ${!connected ? `<script>
                   currentStreamBuffer += eventData.token;
                 }
 
-                // Route streaming text to WhatsApp (if connected). Re-read mirror state
-                // each time so reconnections / disconnects are picked up.
-                const waStatus = channelManager.getStatus('whatsapp');
-                const waMirrorJid = waStatus?.connected ? (waStatus.info?.phoneNumber as string | undefined) : undefined;
-                channelManager.routeWaStreamEvent(waState, type, eventData, waMirrorJid ?? null, botName);
+                // Route streaming text via the manager's per-conversation routing FIFO.
+                // The destination was decided at pushWithRouting time — this is purely a
+                // dispatcher and cannot bleed events to the wrong surface.
+                channelManager.routeWaStreamEvent(waState, type, eventData, botName);
 
                 // Agent finished a turn — handle backend restart + notify client
                 if (type === 'bot:turn-complete') {
@@ -1458,22 +1497,27 @@ ${!connected ? `<script>
                   agentQueryActive = false;
                   currentStreamConvId = null;
                   currentStreamBuffer = '';
+                  channelManager.clearRoutes(convId);
                   return;
                 }
 
-                // Save assistant response to DB
+                // Save assistant response to DB BEFORE broadcasting so a refresh
+                // immediately after the bubble appears can't race the INSERT and lose
+                // the message. addMessage() in worker/db.ts is self-healing —
+                // it INSERT OR IGNOREs the parent conversation row first, so even an
+                // orphan convId persists cleanly.
                 if (type === 'bot:response') {
                   currentStreamBuffer = '';
-
-                  (async () => {
-                    try {
-                      await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
-                        role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
-                      });
-                    } catch (err: any) {
-                      log.warn(`[bloby] DB persist bot response error: ${err.message}`);
-                    }
-                  })();
+                  try {
+                    await workerApi(`/api/conversations/${convId}/messages`, 'POST', {
+                      role: 'assistant', content: eventData.content, meta: { model: freshConfig.ai.model },
+                    });
+                  } catch (err: any) {
+                    log.warn(`[bloby] DB persist bot response error: ${err.message}`);
+                    // Tell clients the bubble they're about to see is not durable —
+                    // they can flag/retry rather than silently losing it on refresh.
+                    broadcastBloby('chat:persist-error', { conversationId: convId, role: 'assistant', error: err.message });
+                  }
                 }
 
                 // Stream all events to every connected client
@@ -1481,9 +1525,21 @@ ${!connected ? `<script>
               }, { botName, humanName }, recentMessages);
             }
 
-            // Push the user message into the live conversation
-            log.info(`[orchestrator] Pushing message into live conversation`);
-            pushMessage(convId, content, data.attachments, savedFiles);
+            // Push the user message into the live conversation with a pinned routing
+            // target. Chat-bubble responses are broadcast to all WS clients regardless;
+            // the WhatsApp self-chat mirror (if connected) is the optional secondary
+            // destination, baked in at push time so it cannot drift to a different chat.
+            const waStatus = channelManager.getStatus('whatsapp');
+            const ownPhone = waStatus?.connected ? (waStatus.info?.phoneNumber as string | undefined) : undefined;
+            const waMirrorTo = ownPhone ? `${ownPhone}@s.whatsapp.net` : undefined;
+            log.info(`[orchestrator] Pushing message into live conversation (waMirror=${waMirrorTo || 'none'})`);
+            channelManager.pushWithRouting(
+              convId,
+              { surface: 'chat', waSendTo: waMirrorTo, isSelfChat: true },
+              content,
+              data.attachments,
+              savedFiles,
+            );
           })();
           return;
         }

package/worker/db.ts

@@ -93,10 +93,18 @@ export function deleteConversation(id: string) {
 
 // Messages
 export function addMessage(convId: string, role: string, content: string, meta?: { tokens_in?: number; tokens_out?: number; model?: string; audio_data?: string; attachments?: string }) {
-  const msg = db.prepare('INSERT INTO messages (conversation_id, role, content, tokens_in, tokens_out, model, audio_data, attachments) VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *')
-    .get(convId, role, content, meta?.tokens_in ?? null, meta?.tokens_out ?? null, meta?.model ?? null, meta?.audio_data ?? null, meta?.attachments ?? null);
-  db.prepare('UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(convId);
-  return msg as any;
+  // Self-heal: if the conversation row is missing (orphan live convId, harness session
+  // drift, deleted parent, etc.), create it so the FK constraint never fires.
+  // Use the first user message as title; assistant-first stays NULL (filled by UI).
+  const tx = db.transaction(() => {
+    db.prepare('INSERT OR IGNORE INTO conversations (id, title, model) VALUES (?, ?, ?)')
+      .run(convId, role === 'user' ? content.slice(0, 80) : null, meta?.model ?? null);
+    const msg = db.prepare('INSERT INTO messages (conversation_id, role, content, tokens_in, tokens_out, model, audio_data, attachments) VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING *')
+      .get(convId, role, content, meta?.tokens_in ?? null, meta?.tokens_out ?? null, meta?.model ?? null, meta?.audio_data ?? null, meta?.attachments ?? null);
+    db.prepare('UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(convId);
+    return msg;
+  });
+  return tx() as any;
 }
 export function getMessages(convId: string) {
   return db.prepare('SELECT * FROM messages WHERE conversation_id = ? ORDER BY created_at ASC').all(convId);
@@ -177,22 +185,29 @@ export function deleteAllTrustedDevices() {
   db.prepare('DELETE FROM trusted_devices').run();
 }
 
-// Recent messages (for context injection)
+// Recent messages (for context injection).
+// Order by rowid (monotonic insertion order) — created_at has 1-second resolution
+// so rapid-fire messages can collide. rowid never does.
+// rowid is a hidden column, so `SELECT *` omits it — we must alias it explicitly
+// in the inner query for the outer ORDER BY to reach it.
 export function getRecentMessages(convId: string, limit = 20) {
   return db.prepare(`
     SELECT * FROM (
-      SELECT * FROM messages WHERE conversation_id = ? ORDER BY created_at DESC LIMIT ?
-    ) sub ORDER BY created_at ASC
+      SELECT messages.*, messages.rowid AS _rid FROM messages
+      WHERE conversation_id = ? ORDER BY messages.rowid DESC LIMIT ?
+    ) sub ORDER BY _rid ASC
   `).all(convId, limit);
 }
 
-// Cursor-based pagination: messages before a given ID
+// Cursor-based pagination: messages before a given message id.
+// Use rowid for comparison — message.id is random hex so `id < ?` is meaningless.
 export function getMessagesBefore(convId: string, beforeId: string, limit = 20) {
   return db.prepare(`
     SELECT * FROM (
-      SELECT * FROM messages
-      WHERE conversation_id = ? AND id < ?
-      ORDER BY id DESC LIMIT ?
-    ) sub ORDER BY id ASC
+      SELECT messages.*, messages.rowid AS _rid FROM messages
+      WHERE conversation_id = ?
+        AND messages.rowid < (SELECT rowid FROM messages WHERE id = ?)
+      ORDER BY messages.rowid DESC LIMIT ?
+    ) sub ORDER BY _rid ASC
   `).all(convId, beforeId, limit);
 }

package/worker/index.ts

@@ -133,12 +133,12 @@ app.post('/api/conversations/:id/messages', (req, res) => {
 });
 app.get('/api/conversations/:id/messages/recent', (req, res) => {
   const limit = parseInt(req.query.limit as string) || 20;
-  const msgs = getRecentMessages(req.params.id, Math.min(limit, 100));
+  const msgs = getRecentMessages(req.params.id, Math.min(limit, 1000));
   res.json(msgs);
 });
 app.get('/api/conversations/:id/messages', (req, res) => {
   const before = req.query.before as string;
-  const limit = Math.min(parseInt(req.query.limit as string) || 20, 100);
+  const limit = Math.min(parseInt(req.query.limit as string) || 20, 1000);
   if (before) {
     res.json(getMessagesBefore(req.params.id, before, limit));
   } else {

package/worker/prompts/bloby-system-prompt.txt

@@ -278,6 +278,8 @@ If your human asks you to update a skill's behavior, edit the files INSIDE `skil
 
 You can communicate through messaging channels beyond the chat bubble. Channel support is provided by **skills** — if your human wants to use WhatsApp, Telegram, Discord, or any other channel, check the Bloby Marketplace for the corresponding skill. They install it, the skill teaches you everything you need to know about that channel.
 
+**Channel discipline.** Every incoming message is tagged with a surface (e.g. `[WhatsApp | ... | role | name]`) — that tag is the truth about who you're talking to and where your reply will go. The supervisor pins each turn's reply to the surface that triggered it; concurrent inbounds from another channel cannot redirect this turn. **Don't infer the channel from prior messages, conversation drift, or what feels right** — read the tag on the current turn and respond accordingly. Chat-bubble content does not belong in a WhatsApp reply, and WhatsApp-specific context (group dynamics, customer back-and-forth, etc.) does not belong in a chat-bubble reply. If a tag isn't present, you're on the chat bubble. If you ever feel the urge to mention a different channel's content in your reply, stop and re-check the tag.
+
 ## Marketplace — Getting New Skills
 
 Before building a skill from scratch, **always check the Bloby Marketplace first**:

package/workspace/skills/whatsapp/SKILL.md

@@ -18,6 +18,12 @@ None.
 
 **Adjust your style for WhatsApp:** Keep messages shorter and more conversational than chat. No markdown headers, no code blocks unless asked. Think texting, not email.
 
+### Routing is supervisor-enforced — you can't accidentally cross channels
+
+Each incoming user message is tagged with a routing target at the moment it enters your conversation. The supervisor pins the agent's reply to whatever surface triggered it — chat-bubble messages land in chat, WhatsApp messages reply to the originating WhatsApp chat (group or 1:1). Concurrent inbounds from different surfaces during the same turn cannot leak into each other's replies. **You don't need to remember which channel you're talking on — the channel context tag (`[WhatsApp | ... | role | name]`) is the truth, and the supervisor handles delivery.**
+
+If you ever see content in your context that doesn't match the surface you think you're on, trust the tag, not your assumption. Reply to what the tag says.
+
 ---
 
 ## How Messages Arrive
@@ -200,6 +206,26 @@ Up to 5 customer conversations can run in parallel. Additional messages queue au
 
 ---
 
+## Reactions (emoji ack)
+
+Use a reaction when you want to acknowledge a message without sending a full text reply — perfect for "I saw this, working on it" or quick approvals/disapprovals. Reactions are first-class in WhatsApp and don't clutter the chat.
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/react \
+  -H "Content-Type: application/json" \
+  -d '{"chatJid":"5511999888777@s.whatsapp.net","messageId":"3EB0...","fromMe":false,"emoji":"👀"}'
+```
+
+- `chatJid` — the WhatsApp JID where the message lives (group JID for groups, peer JID for 1:1). Include the suffix (`@s.whatsapp.net` or `@g.us`).
+- `messageId` — the Baileys message id (the supervisor logs this on every inbound: look for `id=...` in the channel logs).
+- `fromMe` — true if the message you're reacting to was sent by your number, false otherwise. Defaults to false.
+- `participant` — optional; for group messages where you need to reference the original sender's JID.
+- `emoji` — any single emoji. Pass `""` (empty string) to remove a previous reaction.
+
+**When to react vs reply:** react for quick "saw it / on it / done" signals during long-running work; reply with text when there's something meaningful to say. Don't react AND reply with the same content — pick one.
+
+---
+
 ## Account Management
 
 **Disconnect** (keep credentials for later):
@@ -237,6 +263,7 @@ curl -s -X POST http://localhost:7400/api/channels/whatsapp/logout
 | `/api/channels/whatsapp/logout` | POST | Disconnect + delete credentials |
 | `/api/channels/whatsapp/configure` | POST | Set mode + admins + skill |
 | `/api/channels/whatsapp/pairing-code` | POST | Get 8-char pairing code (mobile linking) |
+| `/api/channels/whatsapp/react` | POST | Send/remove an emoji reaction on a message |
 | `/api/channels/send` | POST | Send proactive message via channel |
 
 All endpoints use `http://localhost:7400` for internal API calls (curl from your terminal). For URLs shown to your human, use relative paths (e.g. `/api/channels/whatsapp/qr-page`) — their browser is already on the correct domain.