bloby-bot 0.46.0 → 0.46.2

package/bin/cli.js

@@ -5,7 +5,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import readline from 'readline';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -2010,6 +2010,40 @@ async function passwordReset() {
 // body to stdout (and the Payment-Receipt / X-PAYMENT-RESPONSE header to
 // stderr) so it composes with shell pipelines like curl.
 
+// x402-fetch pulls in ~520 MB of browser-wallet SDKs (WalletConnect, MetaMask,
+// Coinbase, Reown, Solana, etc.) that we never use. Installing it as a regular
+// dep OOMs t4g.small (2 GB) during npm install. So we lazy-install on first
+// `bloby x402` use into an isolated tools dir.
+async function ensureX402Module() {
+  // Already installed in the main tree? (dev convenience)
+  try { return await import('x402-fetch'); } catch {}
+
+  const toolsDir = path.join(DATA_DIR, '.x402-tools');
+  const installed = path.join(toolsDir, 'node_modules', 'x402-fetch', 'dist', 'esm', 'index.mjs');
+
+  if (!fs.existsSync(installed)) {
+    console.log(`  ${c.dim}Installing x402-fetch (one-time, ~30s)…${c.reset}`);
+    fs.mkdirSync(toolsDir, { recursive: true });
+    const toolsPkg = path.join(toolsDir, 'package.json');
+    if (!fs.existsSync(toolsPkg)) {
+      fs.writeFileSync(toolsPkg, JSON.stringify({
+        name: 'bloby-x402-tools', private: true, version: '0.0.0',
+      }, null, 2));
+    }
+    try {
+      execSync(
+        'npm install --omit=dev --no-audit --no-fund --no-progress --prefer-offline --loglevel=error x402-fetch@^1.2.0',
+        { cwd: toolsDir, stdio: 'inherit' },
+      );
+    } catch {
+      console.error(`  ${c.red}✗${c.reset}  Failed to install x402-fetch. Check network and retry.`);
+      process.exit(1);
+    }
+  }
+
+  return import(pathToFileURL(installed).href);
+}
+
 async function x402Pay(rest) {
   if (!rest.length || rest.includes('-h') || rest.includes('--help')) {
     console.log(`
@@ -2026,6 +2060,8 @@ async function x402Pay(rest) {
   Example:
     bloby x402 https://bloby.bot/api/marketplace/buy-base/<id> \\
       -X POST -H "X-Bloby-Token: $RELAY_TOKEN"
+
+  First-call note: installs x402-fetch on demand (~30s, one-time).
 `);
     process.exit(rest.length ? 0 : 1);
   }
@@ -2059,7 +2095,7 @@ async function x402Pay(rest) {
   const { createWalletClient, http } = await import('viem');
   const { privateKeyToAccount } = await import('viem/accounts');
   const { base } = await import('viem/chains');
-  const { wrapFetchWithPayment, decodeXPaymentResponse } = await import('x402-fetch');
+  const { wrapFetchWithPayment, decodeXPaymentResponse } = await ensureX402Module();
 
   const pk = cfg.wallet.privateKey.startsWith('0x') ? cfg.wallet.privateKey : `0x${cfg.wallet.privateKey}`;
   const account = privateKeyToAccount(pk);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.46.0",
+  "version": "0.46.2",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",
@@ -52,13 +52,13 @@
     "dev:docs": "cd ./docs && npx fumapress"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.112",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.138",
     "@clack/prompts": "^1.1.0",
-    "@openai/codex": "^0.128.0",
+    "@openai/codex": "^0.130.0",
     "@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",
@@ -87,7 +87,6 @@
     "vite": "^8.0.3",
     "web-push": "^3.6.7",
     "ws": "^8.19.0",
-    "x402-fetch": "^1.2.0",
     "zustand": "^5.0.11"
   },
   "devDependencies": {

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/harnesses/claude.ts

@@ -422,10 +422,11 @@ export async function startConversation(
                 summary: sysMsg.summary,
                 usage: sysMsg.usage,
               });
-              // Sub-agent completion may have written files
-              if (sysMsg.status === 'completed') {
-                onMessage('bot:turn-complete', { conversationId, usedFileTools: true });
-              }
+              // Don't emit bot:turn-complete here. Sub-agent completion is a progress
+              // signal, not a turn boundary — the parent agent will continue, and its
+              // real `result` event (above) is the only true turn end. The parent's
+              // `usedTools` Set already captures sub-agent tool_use blocks, so file
+              // edits made inside a sub-agent are still reflected in usedFileTools.
             }
             break;
           }

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 = '';
@@ -1418,11 +1450,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,6 +1489,7 @@ ${!connected ? `<script>
                   agentQueryActive = false;
                   currentStreamConvId = null;
                   currentStreamBuffer = '';
+                  channelManager.clearRoutes(convId);
                   return;
                 }
 
@@ -1481,9 +1513,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/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/client/index.html

@@ -46,29 +46,17 @@
     </script>
     <script type="module" src="/src/main.tsx"></script>
     <script>
+    // Register the SW but DO NOT auto-reload on controllerchange.
+    // The old pattern (skipWaiting + claim + controllerchange → location.reload)
+    // caused surprise reloads on mobile PWAs: iOS aggressively re-checks sw.js
+    // and any byte-level variation in the response (esp. via Vite dev) trips a
+    // new SW activation → controllerchange → unwanted reload. The new SW
+    // silently takes over for future fetches; the user gets the new build on
+    // their next natural refresh.
     if('serviceWorker' in navigator && location.port !== '5173'){
-      var swRefreshing=false;
-      navigator.serviceWorker.addEventListener('controllerchange',function(){
-        if(swRefreshing)return;
-        swRefreshing=true;
-        var s=document.getElementById('splash');
-        if(s){s.style.transition='none';s.style.display='block';s.style.opacity='1'}
-        location.reload();
+      navigator.serviceWorker.register('/sw.js').catch(function(err){
+        console.error('[sw-reg] registration failed:', err);
       });
-      navigator.serviceWorker.register('/sw.js').then(function(r){
-        r.update();
-        if(r.waiting){
-          r.waiting.postMessage({type:'SKIP_WAITING'});
-        }
-        r.addEventListener('updatefound',function(){
-          var w=r.installing;
-          if(w)w.addEventListener('statechange',function(){
-            if(w.state==='installed'&&navigator.serviceWorker.controller){
-              w.postMessage({type:'SKIP_WAITING'});
-            }
-          });
-        });
-      }).catch(function(err){ console.error('[sw-reg] registration failed:', err); });
     }
     </script>
     <script src="/bloby/widget.js"></script>

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.