bloby-bot 0.27.2 → 0.27.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.27.2",
+  "version": "0.27.3",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",

package/shared/config.ts

@@ -9,6 +9,8 @@ export interface ChannelConfig {
   admins?: string[];
   /** Active skill for customer-facing mode (folder name in workspace/skills/) */
   skill?: string;
+  /** Opt-in: process messages in group chats (default false). Channel mode ignores this. */
+  allowGroups?: boolean;
 }
 
 export interface BotConfig {

package/supervisor/channels/manager.ts

@@ -58,6 +58,13 @@ interface DebounceEntry {
   senderName?: string;
   fromMe: boolean;
   isSelfChat: boolean;
+  chatJid: string;
+  isGroup: boolean;
+}
+
+/** Per-conversation accumulator for streaming bot text → WhatsApp. */
+export interface WaStreamState {
+  chunkBuf: string;
 }
 
 export class ChannelManager {
@@ -89,9 +96,9 @@ export class ChannelManager {
 
     log.info('[channels] Initializing WhatsApp channel...');
     const whatsapp = new WhatsAppChannel(
-      (sender, senderName, text, fromMe, isSelfChat, images) => {
+      (sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, images) => {
         const attachments = images?.map((img) => ({ type: 'image' as const, mediaType: img.mediaType, data: img.data }));
-        this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat, attachments);
+        this.handleInboundMessage('whatsapp', sender, senderName, text, fromMe, isSelfChat, chatJid, isGroup, attachments);
       },
       (status) => this.handleStatusChange(status),
       (audioBase64) => this.transcribeAudio(audioBase64),
@@ -310,6 +317,82 @@ export class ChannelManager {
     return `🤖 *${botName}:*\n\n${text}`;
   }
 
+  /** Allocate per-conv state for WhatsApp text streaming. Both the orchestrator
+   * (chat UI websocket) and the manager's own admin handler create one of these
+   * and feed each agent stream event through `routeWaStreamEvent` below. */
+  createWaStreamState(): WaStreamState {
+    return { chunkBuf: '' };
+  }
+
+  /** 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.
+   *
+   * 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.
+   */
+  routeWaStreamEvent(
+    state: WaStreamState,
+    type: string,
+    eventData: any,
+    fallbackMirrorJid: string | null,
+    botName: string,
+  ): void {
+    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);
+      }
+      state.chunkBuf = '';
+      return;
+    }
+
+    if (type === 'bot:response' && eventData?.content) {
+      const target = this.waReplyQueue.shift(); // consume the reply target for this turn
+      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);
+      }
+      state.chunkBuf = '';
+
+      // Append the assistant's reply into the per-chat context buffer so subsequent
+      // triggers in that chat see it as conversation history.
+      if (target?.assistantBufferKey) {
+        const buf = this.customerBuffers.get(target.assistantBufferKey);
+        if (buf) {
+          buf.push({ role: 'assistant', content: eventData.content });
+          if (buf.length > MAX_BUFFER_MESSAGES) buf.splice(0, buf.length - MAX_BUFFER_MESSAGES);
+        }
+      }
+    }
+  }
+
   private handleStatusChange(status: ChannelStatus) {
     for (const listener of this.statusListeners) {
       listener(status);
@@ -322,7 +405,11 @@ export class ChannelManager {
     return config.channels?.[channel];
   }
 
-  /** Handle an incoming message from any channel — debounces rapid messages from the same sender */
+  /** Handle an incoming message from any channel — debounces rapid messages from the same sender.
+   *
+   * Per-mode behavior is decided here. To add a new mode: extend the gating block below
+   * (filter inbound) and the routing block in flushDebounce (route to admin/customer/assistant).
+   */
   private async handleInboundMessage(
     channel: ChannelType,
     sender: string,
@@ -330,6 +417,8 @@ export class ChannelManager {
     text: string,
     fromMe: boolean,
     isSelfChat: boolean,
+    chatJid: string,
+    isGroup: boolean,
     attachments?: InboundMessageAttachment[],
   ) {
     const channelConfig = this.getChannelConfig(channel);
@@ -337,6 +426,14 @@ export class ChannelManager {
 
     const mode = channelConfig.mode || 'channel';
 
+    // ── Group gating ──
+    // Channel mode is self-chat only — groups never apply.
+    // Other modes: opt-in via channelConfig.allowGroups (default false).
+    if (isGroup) {
+      if (mode === 'channel') return;
+      if (!channelConfig.allowGroups) return;
+    }
+
     // ── Channel mode: ONLY respond to self-chat ──
     if (mode === 'channel') {
       if (!fromMe || !isSelfChat) return;
@@ -350,8 +447,8 @@ export class ChannelManager {
     // Others' messages or my untriggered messages: store for context, don't invoke
     // My messages with @botname trigger: falls through to debounce → agent
     if (mode === 'assistant' && !(fromMe && isSelfChat)) {
-      // Store every message for context (both mine and theirs)
-      this.storeAssistantContext(channel, sender, senderName, text, fromMe);
+      // Store every message for context (both mine and theirs) — keyed by the chat (group or 1:1)
+      this.storeAssistantContext(channel, chatJid, senderName, text, fromMe);
 
       // Only continue if it's me AND the message contains the trigger
       const botName = loadConfig().username || 'bloby';
@@ -360,22 +457,23 @@ export class ChannelManager {
       // Falls through to debounce → flushDebounce → handleAssistantMessage
     }
 
-    // Debounce: accumulate rapid messages from the same sender
-    const debounceKey = `${channel}:${sender}`;
+    // Debounce: accumulate rapid messages from the same chat
+    // (key by chatJid so a group's rapid messages collapse into one turn)
+    const debounceKey = `${channel}:${chatJid}`;
     const existing = this.debounceBuffers.get(debounceKey);
 
     if (existing) {
-      // Another message from the same sender — reset timer, append text
+      // Another message in the same chat — reset timer, append text
       clearTimeout(existing.timer);
       existing.messages.push(text);
       if (attachments?.length) existing.attachments.push(...attachments);
       existing.senderName = senderName || existing.senderName;
       existing.timer = setTimeout(() => this.flushDebounce(debounceKey), DEBOUNCE_MS);
-      log.info(`[channels] Debounce: buffered message ${existing.messages.length} from ${sender}`);
+      log.info(`[channels] Debounce: buffered message ${existing.messages.length} from ${sender} in ${chatJid}`);
       return;
     }
 
-    // First message from this sender — start debounce timer
+    // First message in this chat's debounce window
     const entry: DebounceEntry = {
       messages: [text],
       attachments: attachments ? [...attachments] : [],
@@ -384,6 +482,8 @@ export class ChannelManager {
       senderName,
       fromMe,
       isSelfChat,
+      chatJid,
+      isGroup,
       timer: setTimeout(() => this.flushDebounce(debounceKey), DEBOUNCE_MS),
     };
     this.debounceBuffers.set(debounceKey, entry);
@@ -395,7 +495,7 @@ export class ChannelManager {
     if (!entry) return;
     this.debounceBuffers.delete(key);
 
-    const { channel, sender, senderName, fromMe, isSelfChat, messages, attachments } = entry;
+    const { channel, sender, senderName, fromMe, isSelfChat, chatJid, isGroup, messages, attachments } = entry;
     const combinedText = messages.join('\n');
 
     const channelConfig = this.getChannelConfig(channel);
@@ -403,16 +503,19 @@ export class ChannelManager {
 
     const mode = channelConfig.mode || 'channel';
 
+    // Reply identifier — strip JID suffix to get a stable id (phone for 1:1, group hash for groups)
+    const chatId = chatJid.replace(/@.*/, '');
+
     // Route based on mode and role
     if (mode === 'channel' || (mode === 'business' && fromMe && isSelfChat) || (mode === 'assistant' && fromMe && isSelfChat)) {
       // Admin (self-chat in any mode)
       const message: InboundMessage = {
         channel,
-        sender: sender.replace(/@.*/, ''),
+        sender: chatId,
         senderName,
         role: 'admin',
         text: combinedText,
-        rawSender: sender,
+        rawSender: chatJid,
         attachments: attachments.length > 0 ? attachments : undefined,
       };
 
@@ -424,10 +527,9 @@ export class ChannelManager {
       return;
     }
 
-    // Assistant mode — triggered message in someone else's chat → route through admin (shared brain)
+    // Assistant mode — triggered message in someone else's chat (or a group) → route through admin (shared brain)
     if (mode === 'assistant') {
-      const phone = sender.replace(/@.*/, '');
-      const bufferKey = `${channel}:${phone}`;
+      const bufferKey = `${channel}:${chatId}`;
       const buffer = this.customerBuffers.get(bufferKey) || [];
 
       // Strip trigger prefix
@@ -445,7 +547,7 @@ export class ChannelManager {
       try {
         const customerDataDir = this.getSkillCustomerDataDir(channelConfig);
         if (customerDataDir) {
-          const memoryPath = path.join(WORKSPACE_DIR, customerDataDir, `${phone}.md`);
+          const memoryPath = path.join(WORKSPACE_DIR, customerDataDir, `${chatId}.md`);
           if (fs.existsSync(memoryPath)) {
             contactMemory = fs.readFileSync(memoryPath, 'utf-8').trim();
           }
@@ -453,11 +555,12 @@ export class ChannelManager {
       } catch {}
 
       // Build enriched text: skill instructions + conversation context + command
+      const chatLabel = isGroup ? `group ${chatId}` : (senderName || chatId);
       let enrichedText = '';
       if (scriptPrompt) enrichedText += `# Assistant Skill Instructions\n${scriptPrompt}\n\n---\n`;
-      if (contactMemory) enrichedText += `# Contact Memory (${phone})\n${contactMemory}\n\n---\n`;
+      if (contactMemory) enrichedText += `# Contact Memory (${chatId})\n${contactMemory}\n\n---\n`;
       if (buffer.length > 0) {
-        enrichedText += `# Recent conversation with ${senderName || phone}\n`;
+        enrichedText += `# Recent conversation with ${chatLabel}\n`;
         enrichedText += buffer.map((m) => m.content).join('\n');
         enrichedText += '\n\n---\n';
       }
@@ -465,21 +568,21 @@ export class ChannelManager {
 
       const message: InboundMessage = {
         channel,
-        sender: phone,
+        sender: chatId,
         senderName,
         role: 'assistant',
         text: enrichedText,
         displayText: cleanText,
-        rawSender: sender,
+        rawSender: chatJid,
         attachments: attachments.length > 0 ? attachments : undefined,
       };
 
-      log.info(`[channels] Assistant mode | triggered in chat with ${phone} | buffer=${buffer.length} msgs | "${cleanText.slice(0, 60)}"`);
+      log.info(`[channels] Assistant mode | triggered in ${isGroup ? 'group ' : 'chat with '}${chatId} | buffer=${buffer.length} msgs | "${cleanText.slice(0, 60)}"`);
       await this.handleAdminMessage(message);
       return;
     }
 
-    // Business mode — incoming message
+    // Business mode — incoming message. Role is resolved against the actual sender JID (not the chat JID).
     const role = this.resolveBusinessRole(channelConfig, sender);
 
     const message: InboundMessage = {
@@ -488,7 +591,7 @@ export class ChannelManager {
       senderName,
       role,
       text: combinedText,
-      rawSender: sender,
+      rawSender: chatJid,
       attachments: attachments.length > 0 ? attachments : undefined,
     };
 
@@ -594,54 +697,20 @@ export class ChannelManager {
     // Show "typing..." in the correct chat
     this.startTyping(msg.channel, msg.rawSender);
 
-    // Track text chunks for WhatsApp — lives for the conversation lifetime
-    let waChunkBuf = '';
+    // Per-conversation streaming state for WhatsApp routing
+    const waState = this.createWaStreamState();
 
     // Start a live conversation if one doesn't exist (shared with chat UI)
     if (!hasConversation(convId)) {
       log.info(`[channels] Starting live conversation for admin: ${convId}`);
 
       await startConversation(convId, model, (type, eventData) => {
-        // Accumulate text tokens
-        if (type === 'bot:token' && eventData.token) {
-          waChunkBuf += eventData.token;
-        }
-
-        // Peek at the front of the reply queue (the target for the current response)
-        const target = this.waReplyQueue[0];
-        if (!target) return;
-
-        // Agent paused to use a tool — send accumulated text as an intermediate WhatsApp message
-        if (type === 'bot:tool' && waChunkBuf.trim()) {
-          this.sendMessage(target.channel, target.rawSender, this.formatBotReply(waChunkBuf.trim(), botName)).catch((err) => {
-            log.warn(`[channels] Failed to send WhatsApp chunk: ${err.message}`);
-          });
-          waChunkBuf = '';
-        }
+        // 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);
 
+        // Persist the assistant's reply to the conversation's DB
         if (type === 'bot:response' && eventData.content) {
-          // Consume this target from the queue — this response is for it
-          this.waReplyQueue.shift();
-
-          // Send remaining text to the correct chat
-          const remaining = waChunkBuf.trim();
-          if (remaining) {
-            this.sendMessage(target.channel, target.rawSender, this.formatBotReply(remaining, botName)).catch((err) => {
-              log.warn(`[channels] Failed to send WhatsApp reply: ${err.message}`);
-            });
-            waChunkBuf = '';
-          }
-
-          // If this was an assistant response, store in the contact's context buffer
-          if (target.assistantBufferKey) {
-            const buf = this.customerBuffers.get(target.assistantBufferKey);
-            if (buf) {
-              buf.push({ role: 'assistant', content: eventData.content });
-              if (buf.length > MAX_BUFFER_MESSAGES) buf.splice(0, buf.length - MAX_BUFFER_MESSAGES);
-            }
-          }
-
-          // Save response to DB
           workerApi(`/api/conversations/${convId}/messages`, 'POST', {
             role: 'assistant',
             content: eventData.content,
@@ -649,7 +718,7 @@ export class ChannelManager {
           }).catch(() => {});
         }
 
-        // Handle turn completion — restart backend if needed
+        // Handle turn completion — restart backend if file tools were used
         if (type === 'bot:turn-complete' && eventData.usedFileTools) {
           this.opts.restartBackend();
         }
@@ -807,23 +876,24 @@ export class ChannelManager {
     );
   }
 
-  /** Store a message in the assistant context buffer (for conversation history when triggered) */
+  /** Store a message in the assistant context buffer (for conversation history when triggered).
+   * Keyed by the chat (not the sender) so groups accumulate one shared buffer per group.
+   */
   private storeAssistantContext(
     channel: ChannelType,
-    sender: string,
+    chatJid: string,
     senderName: string | undefined,
     text: string,
     fromMe: boolean,
   ) {
-    // Normalize key to phone number (strip @lid / @s.whatsapp.net) — must match handleAssistantMessage's agentKey
-    const phone = sender.replace(/@.*/, '');
-    const bufferKey = `${channel}:${phone}`;
+    const chatId = chatJid.replace(/@.*/, '');
+    const bufferKey = `${channel}:${chatId}`;
     let buffer = this.customerBuffers.get(bufferKey);
     if (!buffer) {
       buffer = [];
       this.customerBuffers.set(bufferKey, buffer);
     }
-    const label = fromMe ? 'me' : (senderName || phone);
+    const label = fromMe ? 'me' : (senderName || chatId);
     buffer.push({ role: 'user', content: `[${label}]: ${text}` });
     if (buffer.length > MAX_BUFFER_MESSAGES) {
       buffer.splice(0, buffer.length - MAX_BUFFER_MESSAGES);

package/supervisor/channels/types.ts

@@ -13,6 +13,8 @@ export interface ChannelConfig {
   admins?: string[];
   /** Active skill for customer-facing mode (folder name in workspace/skills/) */
   skill?: string;
+  /** Opt-in: process messages in group chats (default false). Channel mode ignores this. */
+  allowGroups?: boolean;
 }
 
 export interface InboundMessageAttachment {

package/supervisor/channels/whatsapp.ts

@@ -29,8 +29,21 @@ export interface WhatsAppImageAttachment {
   data: string; // base64
 }
 
-/** Callback when a new message arrives */
-export type OnWhatsAppMessage = (sender: string, senderName: string | undefined, text: string, fromMe: boolean, isSelfChat: boolean, images?: WhatsAppImageAttachment[]) => void;
+/** Callback when a new message arrives.
+ * - 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)
+ */
+export type OnWhatsAppMessage = (
+  sender: string,
+  senderName: string | undefined,
+  text: string,
+  fromMe: boolean,
+  isSelfChat: boolean,
+  chatJid: string,
+  isGroup: boolean,
+  images?: WhatsAppImageAttachment[],
+) => void;
 
 /** Callback to transcribe audio via whisper */
 export type TranscribeFn = (audioBase64: string) => Promise<string | null>;
@@ -416,9 +429,9 @@ export class WhatsAppChannel implements ChannelProvider {
       if (m.type !== 'notify') return;
 
       for (const msg of m.messages) {
-        // Skip status broadcasts, group messages, and protocol messages
+        // Skip status broadcasts and protocol-only messages.
+        // Groups are passed through — the manager filters them based on channel config (allowGroups).
         if (msg.key.remoteJid === 'status@broadcast') continue;
-        if (msg.key.remoteJid?.endsWith('@g.us')) continue; // group chats — ignore entirely
         if (msg.key.remoteJid?.endsWith('@newsletter')) continue; // channels/newsletters
         if (!msg.message) continue;
 
@@ -484,20 +497,28 @@ export class WhatsAppChannel implements ChannelProvider {
         const fromMe = msg.key.fromMe || false;
         const rawSender = msg.key.remoteJid || '';
         const participant = msg.key.participant || '';
+        const isGroup = rawSender.endsWith('@g.us');
+
+        // chatJid: where to reply (group JID for groups, peer JID otherwise).
+        const chatJid = rawSender;
 
-        // The actual sender JID — use participant if available (newer protocol), fallback to remoteJid
-        const actualSender = participant || rawSender;
+        // The actual sender JID:
+        //   - groups: always `participant` (remoteJid is the group)
+        //   - 1:1:   `participant` if Baileys provided one (newer protocol), else remoteJid
+        const actualSender = isGroup
+          ? participant || rawSender
+          : (participant || rawSender);
 
-        // Translate LID JIDs to phone JIDs
+        // Translate LID JIDs to phone JIDs (only handles our own LID)
         const sender = this.translateJid(actualSender);
         const pushName = msg.pushName || undefined;
 
-        // Detect self-chat: remoteJid matches our own phone number AND no participant field
-        const isSelfChat = !participant && this.ownPhoneJid !== null && this.translateJid(rawSender) === this.ownPhoneJid;
+        // 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;
 
-        log.info(`[whatsapp] Message from ${sender} (raw=${rawSender}, participant=${participant}, fromMe=${fromMe}, selfChat=${isSelfChat}, images=${images.length}): ${text.slice(0, 80)}`);
+        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, images.length > 0 ? images : undefined);
+        this.onMessage(sender, pushName, text, fromMe, isSelfChat, chatJid, isGroup, images.length > 0 ? images : undefined);
       }
     });
   }

package/supervisor/index.ts

@@ -723,6 +723,7 @@ ${!connected ? `<script>
             if (data.mode) cfg.channels.whatsapp.mode = data.mode;
             if (data.admins !== undefined) cfg.channels.whatsapp.admins = data.admins;
             if (data.skill !== undefined) cfg.channels.whatsapp.skill = data.skill;
+            if (data.allowGroups !== undefined) cfg.channels.whatsapp.allowGroups = !!data.allowGroups;
             saveConfig(cfg);
             res.writeHead(200);
             res.end(JSON.stringify({ ok: true, config: cfg.channels.whatsapp }));
@@ -1396,14 +1397,13 @@ ${!connected ? `<script>
             if (!hasConversation(convId)) {
               log.info(`[orchestrator] Starting new live conversation...`);
 
-              // WhatsApp mirror state — lives for the conversation lifetime
-              let waChunkBuf = '';
+              // Per-conversation WhatsApp streaming state. The manager owns the
+              // routing decision: if a WhatsApp inbound message is the trigger
+              // for this turn, it sends to that chat; otherwise it falls back to
+              // the self-chat mirror (the user's own number).
+              const waState = channelManager.createWaStreamState();
 
               await startConversation(convId, freshConfig.ai.model, (type, eventData) => {
-                // Check WA mirror on each event (connection state may change)
-                const waStatus = channelManager.getStatus('whatsapp');
-                const waMirrorJid = waStatus?.connected ? waStatus.info?.phoneNumber : null;
-
                 // Track stream buffer for reconnecting clients
                 if (type === 'bot:typing') {
                   currentStreamConvId = convId;
@@ -1413,14 +1413,13 @@ ${!connected ? `<script>
 
                 if (type === 'bot:token' && eventData.token) {
                   currentStreamBuffer += eventData.token;
-                  if (waMirrorJid) waChunkBuf += eventData.token;
                 }
 
-                // WhatsApp mirror: send intermediate chunk when agent pauses for tool use
-                if (type === 'bot:tool' && waMirrorJid && waChunkBuf.trim()) {
-                  channelManager.sendMessage('whatsapp', `${waMirrorJid}@s.whatsapp.net`, waChunkBuf.trim()).catch(() => {});
-                  waChunkBuf = '';
-                }
+                // 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);
 
                 // Agent finished a turn — handle backend restart + notify client
                 if (type === 'bot:turn-complete') {
@@ -1463,12 +1462,6 @@ ${!connected ? `<script>
                 if (type === 'bot:response') {
                   currentStreamBuffer = '';
 
-                  // WhatsApp mirror: send remaining chunk
-                  if (waMirrorJid && waChunkBuf.trim()) {
-                    channelManager.sendMessage('whatsapp', `${waMirrorJid}@s.whatsapp.net`, waChunkBuf.trim()).catch(() => {});
-                    waChunkBuf = '';
-                  }
-
                   (async () => {
                     try {
                       await workerApi(`/api/conversations/${convId}/messages`, 'POST', {

package/workspace/skills/whatsapp/SKILL.md

@@ -45,12 +45,34 @@ Your channel configuration is injected into your context (if any channels are co
 
 ## Modes
 
-**Channel Mode** (default): Your human's own WhatsApp number. Only self-chat (messages your human sends to themselves) triggers you — messages from other people are completely ignored. This is "just talk to me" mode.
+The mode determines the routing/security policy for inbound messages. The core (supervisor) enforces it — your skill is what decides which mode is active. Switch via `/api/channels/whatsapp/configure`.
+
+**Channel Mode** (default): Your human's own WhatsApp number. Only self-chat (messages your human sends to themselves) triggers you — messages from other people are completely ignored. This is "just talk to me" mode. Group chats are always ignored in channel mode regardless of `allowGroups`.
 
 **Business Mode**: Bloby has its own dedicated WhatsApp number. Numbers in the `admins` array get admin access (main system prompt). Everyone else is a customer and gets the support prompt from the active skill's SCRIPT.md.
 
 **Assistant Mode**: Your personal assistant inside your own conversations. Self-chat works as a normal admin channel. When other people message you, their messages are silently stored for context. When YOU type `@botname:` followed by a command in someone's chat, the agent activates with full conversation context and responds in that chat. The trigger uses the bot's configured name (from `config.json` `username` field) and is case-insensitive. Nobody else can trigger the agent — only you (the account owner). Uses the active skill's SCRIPT.md for the system prompt and `customer_data/` for per-contact memory.
 
+### Group chats (`allowGroups`)
+
+Group chats are **off by default**. Enable per-channel with the `allowGroups` flag on `/configure`. When enabled:
+
+- **Assistant mode**: messages in groups your human is part of are stored as conversation context (per-group, shared buffer). Your human can `@botname:` inside a group and you'll respond in that group with the full group context.
+- **Business mode**: messages from group members are routed by `admins` (admin vs customer) like any other inbound. The group itself becomes the reply target.
+- **Channel mode**: groups are always ignored — channel mode is self-chat only.
+
+Reply target: in groups your reply goes to the group (everyone sees it), not to the individual sender. Per-group memory under `customer_data/` is keyed by the group's WhatsApp ID (not a phone number).
+
+Toggle with:
+
+```bash
+curl -s -X POST http://localhost:7400/api/channels/whatsapp/configure \
+  -H "Content-Type: application/json" \
+  -d '{"allowGroups":true}'
+```
+
+Disable again with `{"allowGroups":false}`. Default is false — leave it off unless your human asks for it.
+
 ---
 
 ## Setup
@@ -105,6 +127,8 @@ curl -s -X POST http://localhost:7400/api/channels/whatsapp/configure \
 
 The trigger uses the bot's name from `config.json` `username` field (e.g. if username is "bloby", trigger is `@bloby:`). Only the account owner can trigger — other people's messages are context only.
 
+To also let assistant mode operate in group chats your human is in, add `"allowGroups":true` to the configure call (see "Group chats" above).
+
 ### 3. Verify
 
 ```bash