create-walle 0.9.13 → 0.9.15

package/template/wall-e/skills/_bundled/slack-mentions/run.js

@@ -2,9 +2,16 @@
 'use strict';
 const path = require('path');
 const fs = require('fs');
+const crypto = require('crypto');
 
 const brain = require(path.resolve(__dirname, '..', '..', '..', 'brain'));
 const slackMcp = require(path.resolve(__dirname, '..', '..', '..', 'tools', 'slack-mcp'));
+const { ReplyDispatcher } = require(path.resolve(__dirname, '..', '..', '..', 'channels', 'reply-dispatcher'));
+const {
+  SILENT_REPLY_TOKEN,
+  isSilentReply,
+  stripSilentReply,
+} = require(path.resolve(__dirname, '..', '..', '..', 'loops', 'silent-reply-tokens'));
 
 const WATERMARK_FILE = path.join(__dirname, '.watermark.json');
 const OWNER_HANDLE = process.env.SLACK_OWNER_HANDLE || '';
@@ -39,6 +46,14 @@ function discoverHomeChannels() {
 }
 let HOME_CHANNELS = [];
 
+const slackReplyDispatcher = new ReplyDispatcher({
+  send: async (reply) => slackMcp.callSlackMcp('slack_send_message', {
+    channel_id: reply.target,
+    thread_ts: reply.threadTs,
+    message: reply.message,
+  }),
+});
+
 // ── Watermark helpers ──
 
 function loadWatermark() {
@@ -71,6 +86,170 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function cleanWalleAddress(text) {
+  return (text || '')
+    .replace(/<@[A-Z0-9]+>/g, '@walle')
+    .replace(/@wall-?e/gi, '')
+    .trim();
+}
+
+function actorLabel(msg) {
+  return msg.fromName || msg.fromUserId || getConfiguredOwnerName() || 'A Slack user';
+}
+
+function compactSlackTs(ts) {
+  return String(ts || '').replace('.', '');
+}
+
+function safeSlackIdPart(value) {
+  return String(value || 'unknown').replace(/[^A-Za-z0-9_-]/g, '_');
+}
+
+function buildSlackThreadSessionId(channelId, threadTs) {
+  return `slack-thread-${safeSlackIdPart(channelId)}-${compactSlackTs(threadTs || 'unknown')}`;
+}
+
+function buildSlackDeliveryId(kind, channelId, threadTs, messageTs) {
+  return `slack:${kind}:${channelId || 'unknown'}:${threadTs || 'unknown'}:${messageTs || 'unknown'}`;
+}
+
+function hashPayload(value) {
+  return crypto.createHash('sha1').update(String(value || '')).digest('hex');
+}
+
+function claimSlackMessage(msg, source = 'poll') {
+  if (!msg?.channelId || !msg?.ts || typeof brain.claimSlackInboundEvent !== 'function') {
+    return { claimed: true, id: null };
+  }
+  try {
+    return brain.claimSlackInboundEvent({
+      channelId: msg.channelId,
+      messageTs: msg.ts,
+      threadTs: msg.threadTs || msg.ts,
+      source,
+      payloadHash: hashPayload(msg.content || ''),
+    });
+  } catch (err) {
+    console.warn(`[slack-mentions] Could not claim Slack inbound event ${msg.channelId}:${msg.ts}: ${err.message}`);
+    return { claimed: true, id: null };
+  }
+}
+
+function completeSlackMessage(claim, status = 'completed', error = null) {
+  if (!claim?.id || typeof brain.completeSlackInboundEvent !== 'function') return;
+  try {
+    brain.completeSlackInboundEvent(claim.id, { status, error });
+  } catch (err) {
+    console.warn(`[slack-mentions] Could not complete Slack inbound event ${claim.id}: ${err.message}`);
+  }
+}
+
+function sourceRefMatchesMessage(sourceRef, msg) {
+  if (!sourceRef || !msg) return false;
+  const ref = String(sourceRef).split('?')[0];
+  const permalink = msg.permalink ? String(msg.permalink).split('?')[0] : '';
+  if (permalink && ref === permalink) return true;
+  if (msg.channelId && msg.ts && ref === `${msg.channelId}:${msg.ts}`) return true;
+  if (msg.channelId && msg.ts && ref.includes(`/archives/${msg.channelId}/p${compactSlackTs(msg.ts)}`)) return true;
+  return false;
+}
+
+function compareSlackTs(a, b) {
+  const an = Number(a);
+  const bn = Number(b);
+  if (Number.isFinite(an) && Number.isFinite(bn)) return an - bn;
+  return String(a || '').localeCompare(String(b || ''));
+}
+
+function slackTsAfter(a, b) {
+  if (!a) return false;
+  if (!b) return true;
+  return compareSlackTs(a, b) > 0;
+}
+
+function getConfiguredOwnerName() {
+  if (OWNER_NAME) return OWNER_NAME;
+  try {
+    return brain.getOwnerName ? (brain.getOwnerName() || '') : '';
+  } catch {
+    return '';
+  }
+}
+
+function isOwnerName(name, ownerHandle = OWNER_HANDLE, ownerName) {
+  const normalizedName = String(name || '').toLowerCase().trim();
+  if (!normalizedName) return false;
+
+  const normalizedHandle = String(ownerHandle || '').toLowerCase().trim().replace(/^@/, '');
+  if (normalizedHandle && normalizedName.includes(normalizedHandle)) return true;
+
+  const effectiveOwnerName = ownerName === undefined ? getConfiguredOwnerName() : ownerName;
+  const normalizedOwner = String(effectiveOwnerName || '').toLowerCase().trim();
+  if (normalizedOwner && normalizedName.includes(normalizedOwner)) return true;
+
+  const firstName = normalizedOwner.split(/\s+/)[0];
+  return Boolean(firstName && firstName.length >= 2 && normalizedName.includes(firstName));
+}
+
+function isOwnerReply(reply, opts = {}) {
+  return Boolean(reply?.ts) && isOwnerName(reply.from, opts.ownerHandle, opts.ownerName);
+}
+
+function isMessageDraftRequest(text) {
+  const t = String(text || '').toLowerCase();
+  return /\b(write|draft|compose|wordsmith|rewrite)\b/.test(t)
+    && /\b(message|note|reply|response|email|slack|dm)\b/.test(t);
+}
+
+function slackResponseInstruction(text) {
+  const noReply = `If you cannot produce a useful final answer from the available context, reply with ONLY: ${SILENT_REPLY_TOKEN}. Do not ask the Slack user for more context and do not narrate searches or attempts.`;
+  if (isMessageDraftRequest(text)) {
+    return [
+      'The user wants a message draft.',
+      'Use the full Slack thread context and memories to infer the situation.',
+      'Return exactly one ready-to-copy draft in first person for the user to review and send.',
+      'Do not include analysis, tool narration, caveats, or follow-up questions.',
+      'Do not claim you actually sent anything or that you are the user.',
+      'If context is incomplete but enough signal exists, write the safest concise draft from the available context.',
+      noReply,
+    ].join(' ');
+  }
+  return `Give a concise, helpful answer (2-6 sentences). Do NOT mention any tool failures, search steps, or technical issues in your response. ${noReply}`;
+}
+
+function looksLikeSlackToolError(answer) {
+  const text = String(answer || '');
+  return /\b(authentication failed|auth.?required|tool.?fail|error.*MCP|MCP.*error|OAuth.*expired)\b/i.test(text)
+    || /\b(I encountered|I was unable|I couldn't)\b.*\b(authenticate|connect|access|reach|call the tool)\b/i.test(text);
+}
+
+function validateSlackAnswer(answer) {
+  const raw = String(answer || '').trim();
+  if (isSilentReply(raw)) return { ok: false, reason: 'silent_reply' };
+  const stripped = stripSilentReply(raw);
+  if (stripped.hadToken && !stripped.text.trim()) return { ok: false, reason: 'silent_reply' };
+  const text = stripped.text.trim();
+  if (text.length < 5) return { ok: false, reason: 'empty' };
+  if (looksLikeSlackToolError(text)) return { ok: false, reason: 'tool_error' };
+  return { ok: true, text };
+}
+
+function selectThreadMessagesToProcess(replies, thread, opts = {}) {
+  const lastSeenTs = thread?.last_seen_ts || thread?.thread_ts || null;
+  const ownerReplies = (replies || []).filter(reply => isOwnerReply(reply, opts));
+  if (ownerReplies.length === 0) {
+    return { messages: [], latestTs: lastSeenTs, reason: 'no_owner_replies' };
+  }
+
+  const newReplies = ownerReplies.filter(reply => slackTsAfter(reply.ts, lastSeenTs));
+  if (newReplies.length === 0) {
+    return { messages: [], latestTs: lastSeenTs, reason: 'no_new_owner_replies' };
+  }
+
+  const latestTs = newReplies[newReplies.length - 1].ts;
+  return { messages: newReplies, latestTs, reason: 'new_owner_replies' };
+}
+
 /**
  * Generate an answer using chat and send it directly to Slack.
  * Returns the reply text on success, or null on failure.
@@ -79,26 +258,48 @@ function sleep(ms) {
  * (for live data like Google Calendar). We send the reply ourselves via
  * callSlackMcp rather than relying on the model to call slack_send_message.
  */
-async function generateAndSendReply(msg, threadTs, contextBlock, kind) {
+async function deliverSlackReply({ channelId, threadTs, message, deliveryId }) {
+  if (!channelId) return { ok: true, status: 'no_channel' };
+  const status = await slackReplyDispatcher.dispatch({
+    channel: 'slack',
+    target: channelId,
+    threadTs,
+    message,
+    deliveryId,
+  });
+  if (status.status === 'sent') {
+    console.log(`[slack-mentions] Reply sent to Slack thread ${threadTs}`);
+    return { ok: true, status: status.status };
+  }
+  if (status.status === 'skipped' && status.reason === 'duplicate') {
+    console.log(`[slack-mentions] Duplicate Slack delivery skipped: ${deliveryId}`);
+    return { ok: false, status: status.status, reason: status.reason };
+  }
+  console.error(`[slack-mentions] Failed to send reply to Slack: ${status.reason || 'unknown error'}`);
+  return { ok: false, status: status.status, reason: status.reason };
+}
+
+async function generateAndSendReply(msg, threadTs, contextBlock, kind, opts = {}) {
   const chatModule = require(path.resolve(__dirname, '..', '..', '..', 'chat'));
-  const question = (msg.content || '').replace(/@wall-?e/gi, '').trim();
+  const question = cleanWalleAddress(msg.content);
 
   // Step 1: Generate the answer with limited tools
   const isGreeting = /\b(welcome|hello|hi|hey|greet|introduce|join|new member|new hire)\b/i.test(question);
   let answer;
   try {
     const today = new Date().toISOString().split('T')[0];
+    const instruction = slackResponseInstruction(question);
     // Build a context-aware prompt: greetings/welcomes get a warmer, more proactive prompt
     let prompt;
     if (isGreeting) {
-      prompt = `[SLACK GREETING] ${OWNER_NAME} said in Slack:\n\n"${question}"${contextBlock}\n\nToday is ${today}. This appears to be a greeting or welcome message. Search your memories (e.g. lookup_person) to learn about the people mentioned. Respond warmly — welcome them, share any relevant context you know about them, and proactively offer to help. Be genuine and concise (2-4 sentences). Do NOT mention any tool failures or technical issues in your response.`;
+      prompt = `[SLACK GREETING] ${actorLabel(msg)} said in Slack:\n\n"${question}"${contextBlock}\n\nToday is ${today}. This appears to be a greeting or welcome message. Search your memories (e.g. lookup_person) to learn about the people mentioned. Respond warmly — welcome them, share any relevant context you know about them, and proactively offer to help. Be genuine and concise (2-4 sentences). Do NOT mention any tool failures or technical issues in your response.`;
     } else {
-      prompt = `[SLACK ${kind.toUpperCase()}] ${OWNER_NAME} asked in Slack:\n\n${question}${contextBlock}\n\nToday is ${today}. Search your memories for relevant info. For schedule/calendar questions, search with the specific date (e.g. "calendar 2026-04-13") since calendar events are stored as memories with source=calendar. Use mcp_call only if memories don't have what you need. Give a concise, helpful answer (2-6 sentences). Do NOT mention any tool failures or technical issues in your response — just answer naturally.`;
+      prompt = `[SLACK ${kind.toUpperCase()}] ${actorLabel(msg)} asked in Slack:\n\n${question}${contextBlock}\n\nToday is ${today}. Search your memories for relevant info. For schedule/calendar questions, search with the specific date (e.g. "calendar 2026-04-13") since calendar events are stored as memories with source=calendar. Use mcp_call only if memories don't have what you need. ${instruction}`;
     }
 
     const result = await chatModule.chat(prompt, {
       channel: 'task',
-      session_id: `slack-reply-${msg.ts || Date.now()}`,
+      session_id: opts.sessionId || buildSlackThreadSessionId(msg.channelId, threadTs),
       allowedTools: ['search_memories', 'think', 'lookup_person', 'mcp_call', 'calendar_events', 'mail_messages', 'mail_read', 'mail_search'],
       maxToolCalls: 6,
       timeoutMs: 90000, // 90s to allow MCP calls (e.g. Google Calendar)
@@ -112,36 +313,29 @@ async function generateAndSendReply(msg, threadTs, contextBlock, kind) {
   }
 
   // Step 2: Send the reply directly via Slack MCP
-  // Guard: never send error/failure text to Slack — fall back to a graceful message
-  const looksLikeError = answer && (
-    /\b(authentication failed|auth.?required|tool.?fail|error.*MCP|MCP.*error|OAuth.*expired)\b/i.test(answer)
-    || /\b(I encountered|I was unable|I couldn't)\b.*\b(authenticate|connect|access|reach|call the tool)\b/i.test(answer)
-  );
-  if (!answer || answer.length < 5 || looksLikeError) {
-    if (looksLikeError) console.warn(`[slack-mentions] Suppressed error-like answer: ${answer.slice(0, 200)}`);
+  // Guard: never send error/progress/uncertainty text to Slack.
+  const validation = validateSlackAnswer(answer);
+  if (!validation.ok) {
+    if (answer) console.warn(`[slack-mentions] Suppressed ${validation.reason} answer: ${answer.slice(0, 200)}`);
+    if (!isGreeting) return null;
     answer = isGreeting
       ? `Welcome! Great to have you here. Let me know if there's anything I can help with!`
-      : `I'm not sure about that — let me look into it and get back to you.`;
+      : null;
+  } else {
+    answer = validation.text;
   }
+  if (!answer) return null;
 
   // Truncate for Slack (4000 char limit)
   if (answer.length > 3500) answer = answer.slice(0, 3500) + '...';
 
-  if (msg.channelId) {
-    try {
-      await slackMcp.callSlackMcp('slack_send_message', {
-        channel_id: msg.channelId,
-        thread_ts: threadTs,
-        message: answer,
-      });
-      console.log(`[slack-mentions] Reply sent to Slack thread ${threadTs}`);
-      return answer;
-    } catch (sendErr) {
-      console.error(`[slack-mentions] Failed to send reply to Slack: ${sendErr.message}`);
-      return null;
-    }
-  }
-  return answer;
+  const delivery = await deliverSlackReply({
+    channelId: msg.channelId,
+    threadTs,
+    message: answer,
+    deliveryId: opts.deliveryId || buildSlackDeliveryId('reply', msg.channelId, threadTs, msg.ts),
+  });
+  return delivery.ok ? answer : null;
 }
 
 /**
@@ -149,17 +343,19 @@ async function generateAndSendReply(msg, threadTs, contextBlock, kind) {
  * Mirrors generateAndSendReply: we control the chat call and send the reply
  * ourselves, rather than letting the model call slack_send_message directly.
  */
-async function generateAndSendFollowUp(combinedMessage, thread) {
+async function generateAndSendFollowUp(combinedMessage, thread, threadContext, opts = {}) {
   const chatModule = require(path.resolve(__dirname, '..', '..', '..', 'chat'));
 
   let answer;
   try {
     const today = new Date().toISOString().split('T')[0];
-    const prompt = `[SLACK FOLLOW-UP] ${OWNER_NAME} replied in a Slack thread:\n\n${combinedMessage}\n\nToday is ${today}. Search your memories for relevant info. Give a concise, helpful answer (2-6 sentences). Do NOT mention any tool failures or technical issues in your response — just answer naturally.`;
+    const contextBlock = threadContext ? `\n\nFull Slack thread context:\n${threadContext}` : '';
+    const instruction = slackResponseInstruction(combinedMessage);
+    const prompt = `[SLACK FOLLOW-UP] ${getConfiguredOwnerName() || 'The owner'} replied in a Slack thread:\n\n${combinedMessage}${contextBlock}\n\nToday is ${today}. Search your memories for relevant info. ${instruction}`;
 
     const result = await chatModule.chat(prompt, {
       channel: 'task',
-      session_id: thread.session_id,
+      session_id: thread.session_id || buildSlackThreadSessionId(thread.channel_id, thread.thread_ts),
       allowedTools: ['search_memories', 'think', 'lookup_person', 'mcp_call', 'calendar_events', 'mail_messages', 'mail_read', 'mail_search'],
       maxToolCalls: 6,
       timeoutMs: 90000,
@@ -171,35 +367,28 @@ async function generateAndSendFollowUp(combinedMessage, thread) {
     return null;
   }
 
-  // Guard: never send error/failure text to Slack
-  const looksLikeError = answer && (
-    /\b(authentication failed|auth.?required|tool.?fail|error.*MCP|MCP.*error|OAuth.*expired)\b/i.test(answer)
-    || /\b(I encountered|I was unable|I couldn't)\b.*\b(authenticate|connect|access|reach|call the tool)\b/i.test(answer)
-  );
-  if (!answer || answer.length < 5 || looksLikeError) {
-    if (looksLikeError) console.warn(`[slack-mentions] Suppressed error-like follow-up: ${answer.slice(0, 200)}`);
-    answer = `I'm not sure about that — let me look into it and get back to you.`;
+  // Guard: never send error/progress/uncertainty text to Slack.
+  const validation = validateSlackAnswer(answer);
+  if (!validation.ok) {
+    if (answer) console.warn(`[slack-mentions] Suppressed ${validation.reason} follow-up: ${answer.slice(0, 200)}`);
+    return null;
   }
+  answer = validation.text;
 
   if (answer.length > 3500) answer = answer.slice(0, 3500) + '...';
 
-  try {
-    await slackMcp.callSlackMcp('slack_send_message', {
-      channel_id: thread.channel_id,
-      thread_ts: thread.thread_ts,
-      message: answer,
-    });
-    console.log(`[slack-mentions] Follow-up sent to Slack thread ${thread.thread_ts}`);
-    return answer;
-  } catch (sendErr) {
-    console.error(`[slack-mentions] Failed to send follow-up to Slack: ${sendErr.message}`);
-    return null;
-  }
+  const delivery = await deliverSlackReply({
+    channelId: thread.channel_id,
+    threadTs: thread.thread_ts,
+    message: answer,
+    deliveryId: opts.deliveryId || buildSlackDeliveryId('followup', thread.channel_id, thread.thread_ts, opts.messageTs),
+  });
+  return delivery.ok ? answer : null;
 }
 
 function classifyMention(text) {
   const trimmed = (text || '').trim();
-  const cleaned = trimmed.replace(/@wall-?e/gi, '').trim();
+  const cleaned = cleanWalleAddress(trimmed);
   if (/\?\s*$/.test(cleaned)) return 'question';
   if (/^(what|who|where|when|why|how|is|are|do|does|did|can|could|would|should|will)\b/i.test(cleaned)) return 'question';
 
@@ -212,7 +401,7 @@ function classifyMention(text) {
 }
 
 function extractTaskTitle(text) {
-  const cleaned = (text || '').replace(/@wall-?e/gi, '').trim();
+  const cleaned = cleanWalleAddress(text);
   if (cleaned.length <= 120) return cleaned;
   return cleaned.slice(0, 120).replace(/\s+\S*$/, '') + '...';
 }
@@ -332,61 +521,72 @@ async function pollWatchedThreads() {
       const replies = parseThreadReplies(rawThread);
       if (replies.length === 0) continue;
 
-      const lastSeenTs = thread.last_seen_ts || thread.thread_ts;
-
-      // Find the last non-bot reply from the owner
-      const ownerReplies = replies.filter(r => {
-        if (!r.ts) return false;
-        const name = (r.from || '').toLowerCase();
-        return name.includes(OWNER_HANDLE.toLowerCase()) ||
-          name.includes(OWNER_NAME.split(' ')[0].toLowerCase());
-      });
-
-      if (ownerReplies.length === 0) continue;
-
-      const lastOwnerReply = ownerReplies[ownerReplies.length - 1];
-      const lastReplyInThread = replies[replies.length - 1];
+      const selection = selectThreadMessagesToProcess(replies, thread);
+      const messagesToProcess = selection.messages;
+      if (messagesToProcess.length === 0) {
+        continue;
+      }
 
-      // Skip if we already replied after the owner's last message (last reply is bot)
-      const lastReplyIsBot = lastReplyInThread && lastReplyInThread.ts > lastOwnerReply.ts;
-      if (lastReplyIsBot) continue;
+      console.log(`[slack-mentions] ${messagesToProcess.length} message(s) to process in watched thread ${thread.id}`);
 
-      // Collect unseen messages (new since last_seen_ts)
-      const newReplies = ownerReplies.filter(r => r.ts > lastSeenTs);
+      const latestTs = selection.latestTs || messagesToProcess[messagesToProcess.length - 1].ts;
+      const claimed = [];
+      for (const reply of messagesToProcess) {
+        const claim = claimSlackMessage({
+          channelId: thread.channel_id,
+          threadTs: thread.thread_ts,
+          ts: reply.ts,
+          content: reply.content,
+        }, 'thread_poll');
+        if (!claim.claimed) {
+          console.log(`[slack-mentions] Skipping already-claimed thread reply ${thread.channel_id}:${reply.ts}`);
+          continue;
+        }
+        claimed.push({ reply, claim });
+      }
 
-      // If no strictly-new messages but the last thread message is from the owner,
-      // it means our previous reply attempt failed — retry the last seen message
-      let messagesToProcess;
-      if (newReplies.length > 0) {
-        messagesToProcess = newReplies;
-      } else if (lastOwnerReply.ts >= lastSeenTs) {
-        console.log(`[slack-mentions] Retrying unanswered message in thread ${thread.id} (ts=${lastOwnerReply.ts})`);
-        messagesToProcess = [lastOwnerReply];
-      } else {
+      if (claimed.length === 0) {
+        brain.updateSlackThread(thread.id, {
+          last_seen_ts: latestTs || thread.last_seen_ts,
+          last_activity: new Date().toISOString(),
+        });
         continue;
       }
 
-      console.log(`[slack-mentions] ${messagesToProcess.length} message(s) to process in watched thread ${thread.id}`);
-
-      const combinedMessage = messagesToProcess.map(r => r.content).join('\n\n');
-      const latestTs = messagesToProcess[messagesToProcess.length - 1].ts;
+      const combinedMessage = claimed.map(item => item.reply.content).join('\n\n');
+      const deliveryMessageTs = claimed[claimed.length - 1]?.reply?.ts || latestTs;
 
       let replySucceeded = false;
+      let claimStatus = 'completed';
+      let claimError = null;
       try {
-        const reply = await generateAndSendFollowUp(combinedMessage, thread);
+        const reply = await generateAndSendFollowUp(combinedMessage, thread, rawThread, {
+          messageTs: deliveryMessageTs,
+          deliveryId: buildSlackDeliveryId('followup', thread.channel_id, thread.thread_ts, deliveryMessageTs),
+        });
         replySucceeded = !!reply;
         if (reply) {
           console.log(`[slack-mentions] Follow-up reply sent for thread ${thread.id}: ${reply.slice(0, 100)}`);
+        } else {
+          claimStatus = 'no_reply';
         }
       } catch (chatErr) {
         console.error(`[slack-mentions] Failed to process follow-up: ${chatErr.message}`);
+        claimStatus = 'failed';
+        claimError = chatErr.message;
+      } finally {
+        for (const item of claimed) completeSlackMessage(item.claim, claimStatus, claimError);
       }
 
-      // Only advance last_seen_ts if the reply succeeded
+      // Advance even when the reply is suppressed or sending fails. Retrying the
+      // same Slack message every 10s is worse than missing one transient reply.
       brain.updateSlackThread(thread.id, {
-        last_seen_ts: replySucceeded ? latestTs : thread.last_seen_ts,
+        last_seen_ts: latestTs || thread.last_seen_ts,
         last_activity: new Date().toISOString(),
       });
+      if (!replySucceeded) {
+        console.warn(`[slack-mentions] Marked thread ${thread.id} seen without sending a follow-up`);
+      }
 
       await sleep(PAUSE_MS);
     } catch (err) {
@@ -461,12 +661,10 @@ async function pollHomeChannels(lastTs, seenTs, stats) {
         if (lastTs && msg.ts && msg.ts <= lastTs) continue;
 
         // Check sender is owner
-        const senderName = (msg.fromName || '').toLowerCase();
-        const isFromOwner = senderName.includes(OWNER_HANDLE.toLowerCase()) ||
-          senderName.includes(OWNER_NAME.split(' ')[0].toLowerCase());
+        const isFromOwner = isOwnerName(msg.fromName);
         if (!isFromOwner) continue;
 
-        await _processMention(msg, seenTs, stats);
+        await _processMention(msg, seenTs, stats, { source: 'home_poll' });
       }
 
       await sleep(PAUSE_MS);
@@ -478,119 +676,186 @@ async function pollHomeChannels(lastTs, seenTs, stats) {
 
 // ── New mention processing ──
 
-// Shared per-message processor — creates tasks/questions from a mention
-async function _processMention(msg, seenTs, stats) {
-  const dedupeKey = msg.ts || msg.permalink || msg.content;
+// Shared per-message processor - creates tasks/questions from a mention.
+async function _processMention(msg, seenTs, stats, opts = {}) {
+  const dedupeKey = msg.channelId && msg.ts ? `${msg.channelId}:${msg.ts}` : (msg.ts || msg.permalink || msg.content);
   if (seenTs.has(dedupeKey)) return;
   seenTs.add(dedupeKey);
 
   const now = new Date();
+  const effectiveTs = msg.ts || msg.isoTimestamp || now.toISOString();
+  const threadTs = msg.threadTs || msg.ts;
+  const sessionId = buildSlackThreadSessionId(msg.channelId, threadTs);
   const sourceRef = (msg.permalink || (msg.channelId ? `${msg.channelId}:${msg.ts || 'unknown'}` : `unknown:${msg.ts}`)).split('?')[0];
-  const existing = brain.listTasks({ source: 'slack' }).find(t => t.source_ref && t.source_ref.split('?')[0] === sourceRef);
-  if (existing) {
-    console.log(`[slack-mentions] Skipping already-processed mention: ${sourceRef}`);
+  const claim = claimSlackMessage({ ...msg, threadTs }, opts.source || 'mention_poll');
+
+  if (effectiveTs > (stats.maxTs || '')) stats.maxTs = effectiveTs;
+  if (!claim.claimed) {
+    console.log(`[slack-mentions] Skipping already-claimed mention: ${sourceRef}`);
     return;
   }
 
-  stats.newMentions++;
-  const kind = classifyMention(msg.content);
-  const effectiveTs = msg.ts || msg.isoTimestamp || now.toISOString();
-  const threadTs = msg.threadTs || msg.ts;
+  let claimStatus = 'completed';
+  let claimError = null;
 
-  // Fetch full thread context
-  let threadContext = null;
-  if (msg.channelId && threadTs) {
-    threadContext = await fetchThreadContext(msg.channelId, threadTs);
-    await sleep(PAUSE_MS);
-  }
-  const contextBlock = threadContext ? `\n\nFull thread context:\n${threadContext}` : '';
+  try {
+    const existing = brain.listTasks({ source: 'slack' }).find(t => sourceRefMatchesMessage(t.source_ref, msg));
+    if (existing) {
+      console.log(`[slack-mentions] Skipping already-processed mention: ${sourceRef}`);
+      claimStatus = 'skipped_existing_task';
+      return;
+    }
 
-  if (kind === 'coding') {
-    const title = extractTaskTitle(msg.content);
-    try {
-      const { id } = brain.insertTask({
-        title: title.slice(0, 100),
-        description: `Coding request from Slack:\n\n${msg.content}`,
-        priority: 'normal',
-        type: 'once',
-        execution: 'skill',
-        skill: 'coding-agent',
-        skill_config: JSON.stringify({
-          request: msg.content.replace(/@wall-?e/gi, '').trim(),
-          cwd: process.env.HOME || '/tmp',
-          options: { delivery: 'commit' },
-        }),
-        source: 'slack',
-        source_ref: sourceRef,
-      });
-      stats.tasksCreated++;
-      console.log(`[slack-mentions] Coding task created: ${id} — ${title}`);
+    stats.newMentions++;
+    const kind = classifyMention(msg.content);
+
+    // Fetch full thread context
+    let threadContext = null;
+    if (msg.channelId && threadTs) {
+      threadContext = await fetchThreadContext(msg.channelId, threadTs);
+      await sleep(PAUSE_MS);
+    }
+    const contextBlock = threadContext ? `\n\nFull thread context:\n${threadContext}` : '';
+
+    if (kind === 'coding') {
+      const title = extractTaskTitle(msg.content);
+      try {
+        const { id } = brain.insertTask({
+          title: title.slice(0, 100),
+          description: `Coding request from Slack:\n\n${msg.content}`,
+          priority: 'normal',
+          type: 'once',
+          execution: 'skill',
+          skill: 'coding-agent',
+          skill_config: JSON.stringify({
+            request: cleanWalleAddress(msg.content),
+            cwd: process.env.HOME || '/tmp',
+            options: { delivery: 'commit' },
+          }),
+          source: 'slack',
+          source_ref: sourceRef,
+        });
+        stats.tasksCreated++;
+        console.log(`[slack-mentions] Coding task created: ${id} - ${title}`);
 
-      if (msg.channelId) {
         try {
-          await slackMcp.callSlackMcp('slack_send_message', {
-            channel_id: msg.channelId,
-            message: `On it — planning the implementation now. I'll update this thread when done.`,
-            thread_ts: threadTs,
+          const threadId = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId });
+          if (msg.ts) brain.updateSlackThread(threadId, { last_seen_ts: msg.ts, last_activity: new Date().toISOString() });
+        } catch (upsertErr) {
+          console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message}`);
+        }
+
+        if (msg.channelId) {
+          const delivery = await deliverSlackReply({
+            channelId: msg.channelId,
+            threadTs,
+            message: `On it - planning the implementation now. I'll update this thread when done.`,
+            deliveryId: buildSlackDeliveryId('coding-ack', msg.channelId, threadTs, msg.ts),
           });
-        } catch (replyErr) {
-          console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
+          if (!delivery.ok) claimStatus = 'ack_failed';
+          await sleep(PAUSE_MS);
         }
-        await sleep(PAUSE_MS);
+      } catch (taskErr) {
+        claimStatus = 'failed';
+        claimError = taskErr.message;
+        console.error(`[slack-mentions] Failed to create coding task: ${taskErr.message}`);
       }
-    } catch (taskErr) {
-      console.error(`[slack-mentions] Failed to create coding task: ${taskErr.message}`);
+      return;
     }
-    return;
-  }
 
-  if (kind === 'task' || kind === 'question') {
-    stats.questionsFound += kind === 'question' ? 1 : 0;
-    stats.tasksCreated += kind === 'task' ? 1 : 0;
-    const title = extractTaskTitle(msg.content);
-    console.log(`[slack-mentions] ${kind} detected: ${title.slice(0, 80)}`);
+    if (kind === 'task' || kind === 'question') {
+      stats.questionsFound += kind === 'question' ? 1 : 0;
+      stats.tasksCreated += kind === 'task' ? 1 : 0;
+      const title = extractTaskTitle(msg.content);
+      console.log(`[slack-mentions] ${kind} detected: ${title.slice(0, 80)}`);
 
-    // Phase 1: Generate answer directly and send it — no task intermediary.
-    // This is the most reliable approach: we control the chat call and send the
-    // reply ourselves, instead of hoping the task's chat engine will do it.
-    const reply = await generateAndSendReply(msg, threadTs, contextBlock, kind);
-
-    // Track as a completed task for history/dedup
-    try {
-      const { id } = brain.insertTask({
-        title: kind === 'question' ? `Answer Slack question: ${title}` : title,
-        description: `${kind === 'question' ? 'Question' : 'Task'} from ${OWNER_NAME} in Slack:\n\n${msg.content}${contextBlock}`,
-        priority: kind === 'question' ? 'high' : 'normal',
-        type: 'once',
-        execution: 'chat',
-        source: 'slack',
-        source_ref: sourceRef,
-      });
-      // Mark completed/failed immediately since we handled it inline
-      brain.updateTask(id, {
-        status: reply ? 'completed' : 'failed',
-        result: (reply || 'Failed to generate or send reply').slice(0, 10000),
-        completed_at: new Date().toISOString(),
-        run_count: 1,
+      // Generate the response and route delivery through the channel dispatcher.
+      const reply = await generateAndSendReply(msg, threadTs, contextBlock, kind, {
+        sessionId,
+        deliveryId: buildSlackDeliveryId('reply', msg.channelId, threadTs, msg.ts),
       });
+      if (!reply) claimStatus = 'no_reply';
+
+      // Track as a completed task for history/dedup.
       try {
-        const threadId = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
-        // Set last_seen_ts so pollWatchedThreads knows we already replied to this message.
-        // Without this, the next poll cycle sees the owner's message as "unanswered" and sends a duplicate reply.
-        if (reply && msg.ts) {
-          brain.updateSlackThread(threadId, { last_seen_ts: msg.ts, last_activity: new Date().toISOString() });
+        const { id } = brain.insertTask({
+          title: kind === 'question' ? `Answer Slack question: ${title}` : title,
+          description: `${kind === 'question' ? 'Question' : 'Task'} from ${getConfiguredOwnerName() || 'Slack'} in Slack:\n\n${msg.content}${contextBlock}`,
+          priority: kind === 'question' ? 'high' : 'normal',
+          type: 'once',
+          execution: 'chat',
+          source: 'slack',
+          source_ref: sourceRef,
+        });
+        brain.updateTask(id, {
+          status: reply ? 'completed' : 'failed',
+          result: (reply || 'No Slack reply sent').slice(0, 10000),
+          completed_at: new Date().toISOString(),
+          run_count: 1,
+        });
+        try {
+          const threadId = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId });
+          if (msg.ts) {
+            brain.updateSlackThread(threadId, { last_seen_ts: msg.ts, last_activity: new Date().toISOString() });
+          }
+        } catch (upsertErr) {
+          console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message}`);
         }
-      } catch (upsertErr) {
-        console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message}`);
+      } catch (taskErr) {
+        claimStatus = 'failed';
+        claimError = taskErr.message;
+        console.error(`[slack-mentions] Failed to create task record: ${taskErr.message}`);
       }
-    } catch (taskErr) {
-      console.error(`[slack-mentions] Failed to create task record: ${taskErr.message}`);
     }
+  } catch (err) {
+    claimStatus = 'failed';
+    claimError = err.message;
+    console.error(`[slack-mentions] Failed to process mention ${sourceRef}: ${err.message}`);
+  } finally {
+    completeSlackMessage(claim, claimStatus, claimError);
+  }
+}
+
+function normalizeEventText(event) {
+  if (!event || typeof event.text !== 'string') return '';
+  if (event.type === 'app_mention') return event.text.replace(/<@[A-Z0-9]+>/g, '@walle');
+  return event.text;
+}
+
+function shouldAcceptSocketEvent(event) {
+  if (!event || !event.type) return false;
+  if (event.bot_id || event.subtype) return false;
+  if (event.type === 'app_mention') return true;
+  if (event.type === 'message') {
+    return event.channel_type === 'im' || event.channel_type === 'mpim';
   }
+  return false;
+}
 
-  if (effectiveTs > (stats.maxTs || '')) {
-    stats.maxTs = effectiveTs;
+async function processIncomingSlackEvent(event, opts = {}) {
+  if (!shouldAcceptSocketEvent(event)) {
+    return { processed: false, reason: 'ignored_event_type' };
   }
+  brain.initDb();
+  const stats = { newMentions: 0, tasksCreated: 0, questionsFound: 0, maxTs: null };
+  const seenTs = new Set();
+  const threadTs = event.thread_ts || event.ts;
+  const msg = {
+    ts: event.ts,
+    threadTs,
+    channelId: event.channel,
+    fromUserId: event.user,
+    fromName: opts.fromName || event.user,
+    permalink: opts.permalink || null,
+    content: normalizeEventText(event),
+    isoTimestamp: event.event_ts || event.ts || new Date().toISOString(),
+  };
+  await _processMention(msg, seenTs, stats, { source: 'socket' });
+  return {
+    processed: stats.newMentions > 0,
+    tasksCreated: stats.tasksCreated,
+    questionsFound: stats.questionsFound,
+  };
 }
 
 async function processNewMentions() {
@@ -640,15 +905,13 @@ async function processNewMentions() {
         if (lastTs && msg.ts && msg.ts <= lastTs) continue;
         if (lastTs && msg.isoTimestamp && msg.isoTimestamp <= lastTs) continue;
 
-        const senderName = (msg.fromName || '').toLowerCase();
-        const isFromOwner = senderName.includes(OWNER_HANDLE.toLowerCase()) ||
-          senderName.includes(OWNER_NAME.split(' ')[0].toLowerCase());
+        const isFromOwner = isOwnerName(msg.fromName);
         if (!isFromOwner) {
           console.log(`[slack-mentions] Skipping non-owner mention from: ${msg.fromName || 'unknown'}`);
           continue;
         }
 
-        await _processMention(msg, seenTs, stats);
+        await _processMention(msg, seenTs, stats, { source: 'search' });
       }
     } catch (err) {
       if (err.message.includes('401') || err.message.includes('expired') ||
@@ -666,7 +929,7 @@ async function processNewMentions() {
   // Phase 2b: DM channel polling — catches thread replies that search misses
   try {
     await pollDmChannels(lastTs, seenTs, async (msg, seen) => {
-      await _processMention(msg, seen, stats);
+      await _processMention(msg, seen, stats, { source: 'dm_poll' });
     });
   } catch (err) {
     console.warn(`[slack-mentions] DM polling error: ${err.message}`);
@@ -767,9 +1030,7 @@ async function pollDmChannels(lastTs, seenTs, processMsg) {
         if (seenTs.has(msg.ts)) continue;
 
         // Check sender is owner
-        const senderName = (msg.fromName || '').toLowerCase();
-        const isFromOwner = senderName.includes(OWNER_HANDLE.toLowerCase()) ||
-          senderName.includes(OWNER_NAME.split(' ')[0].toLowerCase());
+        const isFromOwner = isOwnerName(msg.fromName);
         if (!isFromOwner) continue;
 
         msg.channelId = channelId;
@@ -805,6 +1066,14 @@ function setNextRunInterval() {
 
 async function main() {
   brain.initDb();
+  if (typeof brain.pruneSlackInboundEvents === 'function') {
+    try {
+      const pruned = brain.pruneSlackInboundEvents(7 * 24 * 60 * 60 * 1000);
+      if (pruned > 0) console.log(`[slack-mentions] Pruned ${pruned} old inbound event(s)`);
+    } catch (err) {
+      console.warn(`[slack-mentions] Could not prune inbound event ledger: ${err.message}`);
+    }
+  }
   HOME_CHANNELS = discoverHomeChannels();
 
   if (!(await slackMcp.isAuthenticated())) {
@@ -824,7 +1093,21 @@ async function main() {
 }
 
 // Export for skill-planner; also run directly when invoked as CLI script
-module.exports = { run: main };
+module.exports = {
+  run: main,
+  processIncomingSlackEvent,
+  shouldAcceptSocketEvent,
+  cleanWalleAddress,
+  sourceRefMatchesMessage,
+  isOwnerName,
+  isMessageDraftRequest,
+  slackResponseInstruction,
+  buildSlackThreadSessionId,
+  buildSlackDeliveryId,
+  validateSlackAnswer,
+  parseThreadReplies,
+  selectThreadMessagesToProcess,
+};
 
 if (require.main === module) {
   main().catch(err => {