create-walle 0.9.0 → 0.9.3

package/template/wall-e/skills/_bundled/proactive-alerts/run.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+'use strict';
+const path = require('path');
+const brain = require(path.resolve(__dirname, '..', '..', '..', 'brain'));
+
+brain.initDb();
+const db = brain.getDb();
+
+async function main() {
+  const now = new Date();
+  const alerts = [];
+
+  // 1. Calendar events in the next 15 minutes
+  try {
+    const { getCalendarEvents } = require(path.resolve(__dirname, '..', '..', '..', 'tools', 'local-tools'));
+    const { events } = await getCalendarEvents({ days_ahead: 0 });
+    const soonMs = 15 * 60 * 1000;
+    for (const evt of events) {
+      const start = new Date(evt.start);
+      if (isNaN(start)) continue;
+      const diff = start.getTime() - now.getTime();
+      if (diff > 0 && diff <= soonMs) {
+        alerts.push({
+          type: 'calendar_soon',
+          urgency: 'critical',
+          title: `Meeting in ${Math.round(diff / 60000)}min: ${evt.title}`,
+          data: { event: evt.title, start: evt.start, attendees: evt.attendees?.slice(0, 5) },
+        });
+      }
+    }
+  } catch (err) {
+    // Calendar unavailable -- skip silently
+  }
+
+  // 2. Direct @mentions in recent Slack messages (last 30 minutes)
+  try {
+    const ownerFirst = (process.env.WALLE_OWNER_NAME || 'owner').split(' ')[0].replace(/['"*()]/g, '');
+    const hasFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories_fts'").get();
+    if (hasFts && ownerFirst.length >= 2) {
+      const cutoff = new Date(now.getTime() - 30 * 60000).toISOString();
+      const mentions = db.prepare(`
+        SELECT m.content, m.source_channel, m.participants, m.timestamp
+        FROM memories_fts f
+        JOIN memories m ON m.rowid = f.rowid
+        WHERE memories_fts MATCH ?
+          AND m.source = 'slack' AND m.direction = 'inbound'
+          AND m.timestamp > ?
+        ORDER BY m.timestamp DESC
+        LIMIT 5
+      `).all(ownerFirst, cutoff);
+
+      for (const m of mentions) {
+        alerts.push({
+          type: 'mention',
+          urgency: 'today',
+          title: `@mention from ${extractName(m.participants)} in ${m.source_channel || 'Slack'}`,
+          data: { content: (m.content || '').slice(0, 200), channel: m.source_channel, timestamp: m.timestamp },
+        });
+      }
+    }
+  } catch {}
+
+  // 3. Tasks due within 1 hour
+  try {
+    const tasks = brain.listTasks({ status: 'pending', limit: 20 });
+    const oneHourMs = 60 * 60 * 1000;
+    for (const t of tasks) {
+      if (!t.due_at) continue;
+      const due = new Date(t.due_at);
+      const diff = due.getTime() - now.getTime();
+      if (diff > 0 && diff <= oneHourMs) {
+        alerts.push({
+          type: 'deadline',
+          urgency: diff <= 15 * 60000 ? 'critical' : 'today',
+          title: `Due in ${Math.round(diff / 60000)}min: ${t.title}`,
+          data: { task_id: t.id, title: t.title, due_at: t.due_at },
+        });
+      }
+    }
+  } catch {}
+
+  // 4. Failed tasks needing attention
+  try {
+    const failed = brain.listTasks({ status: 'failed', limit: 5 });
+    for (const t of failed) {
+      alerts.push({
+        type: 'failed_task',
+        urgency: 'today',
+        title: `Failed: ${t.title} -- ${(t.error || 'unknown error').slice(0, 80)}`,
+        data: { task_id: t.id, title: t.title, error: t.error },
+      });
+    }
+  } catch {}
+
+  // 5. Urgent briefing items
+  try {
+    const urgent = db.prepare(`
+      SELECT * FROM briefing_items
+      WHERE status = 'new' AND urgency IN ('critical', 'today')
+        AND (snooze_until IS NULL OR snooze_until < datetime('now'))
+      ORDER BY urgency, created_at DESC LIMIT 5
+    `).all();
+    for (const item of urgent) {
+      alerts.push({
+        type: 'briefing_item',
+        urgency: item.urgency,
+        title: item.title,
+        data: { id: item.id, category: item.category, owner: item.owner },
+      });
+    }
+  } catch {}
+
+  // Output
+  if (alerts.length === 0) {
+    console.log('No alerts.');
+  } else {
+    console.log(`${alerts.length} alert(s) found:`);
+    for (const a of alerts) {
+      console.log(`[${a.urgency}] ${a.title}`);
+    }
+    // Structured output for the task runner
+    console.log('<!-- BRIEFING_ITEMS');
+    console.log(JSON.stringify(alerts.map(a => ({
+      title: a.title,
+      category: a.type,
+      urgency: a.urgency,
+      context: a.data,
+    })), null, 2));
+    console.log('-->');
+  }
+
+  brain.closeDb();
+}
+
+function extractName(participants) {
+  if (!participants) return 'someone';
+  const name = participants.split(',')[0].trim().replace(/^\*+|\*+$/g, '');
+  return name.split(' ')[0] || name || 'someone';
+}
+
+main().catch(err => {
+  console.error('[proactive-alerts] Error:', err.message);
+  process.exit(1);
+});

package/template/wall-e/skills/_bundled/slack-mentions/.watched-threads.json

@@ -0,0 +1,18 @@
+{
+  "D02U25VN72R:1775337680.059359": {
+    "channel_id": "D02U25VN72R",
+    "thread_ts": "1775337680.059359",
+    "task_id": "6bc67ff2-2f75-48b5-8931-effe8152833a",
+    "session_id": "task-6bc67ff2-2f75-48b5-8931-effe8152833a",
+    "last_activity": "2026-04-04T21:23:16.469Z",
+    "last_seen_ts": "1775337770.532239"
+  },
+  "D02U25VN72R:1775337821.126619": {
+    "channel_id": "D02U25VN72R",
+    "thread_ts": "1775337821.126619",
+    "task_id": "83555195-3f8d-4748-b628-2d6077bfa5a4",
+    "session_id": "task-83555195-3f8d-4748-b628-2d6077bfa5a4",
+    "last_activity": "2026-04-04T21:26:30.938Z",
+    "last_seen_ts": "1775337970.800449"
+  }
+}

package/template/wall-e/skills/_bundled/slack-mentions/.watermark.json

@@ -0,0 +1,4 @@
+{
+  "last_ts": "1775337821.126619",
+  "updated_at": "2026-04-04T21:24:42.223Z"
+}

package/template/wall-e/skills/_bundled/slack-mentions/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: slack-mentions
+description: >
+  Monitor Slack for @walle mentions from the owner and create tasks or reply
+  to questions. Searches recent messages, deduplicates via watermark, creates
+  brain tasks for assignments, and replies in-thread for questions.
+version: 1.0.0
+author: wall-e
+execution: script
+entry: run.js
+trigger:
+  type: interval
+  schedule: "every 30s"
+tags: [slack, mentions, inbox]
+permissions:
+  - slack:read
+  - slack:write
+  - brain:read
+  - brain:write
+---
+# Slack Mentions
+
+## What This Skill Does
+
+Polls Slack for messages mentioning @walle or @wall-e from the owner (Juncao).
+Classifies each mention as either a task assignment or a question, then:
+
+- **Task**: Creates a brain task with `source: 'slack'` and `source_ref` linking
+  back to the original message. Replies in-thread confirming receipt.
+- **Question**: Replies in-thread with a short acknowledgement (actual answering
+  is deferred to the Wall-E chat agent).
+
+## How It Works
+
+1. Search Slack for `@walle` and `@wall-e` mentions in the last 60 seconds
+2. Compare message timestamps against a local watermark file to skip duplicates
+3. For each new mention from the owner:
+   - Classify as task or question based on imperative/interrogative language
+   - Create a brain task or log the question
+   - Reply in the Slack thread
+4. Update the watermark to the latest processed timestamp
+
+## Watermark
+
+Stored in `.watermark.json` alongside this skill (not in the brain DB) for
+simplicity and crash-safety.
+
+## Error Handling
+
+- Slack token expiry exits with code 1 and a clear message
+- Individual message processing errors are logged and skipped
+- The watermark is only advanced past successfully processed messages

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

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+'use strict';
+const path = require('path');
+const fs = require('fs');
+
+const brain = require(path.resolve(__dirname, '..', '..', '..', 'brain'));
+const slackMcp = require(path.resolve(__dirname, '..', '..', '..', 'tools', 'slack-mcp'));
+
+const WATERMARK_FILE = path.join(__dirname, '.watermark.json');
+const OWNER_HANDLE = process.env.SLACK_OWNER_HANDLE || 'juncao';
+const OWNER_NAME = process.env.WALLE_OWNER_NAME || 'Juncao Li';
+const PAUSE_MS = 800;
+const WATCH_DURATION_MS = 2 * 60 * 60 * 1000; // 2 hours
+
+// ── Watermark helpers ──
+
+function loadWatermark() {
+  try {
+    const data = JSON.parse(fs.readFileSync(WATERMARK_FILE, 'utf8'));
+    return data.last_ts || null;
+  } catch {
+    return null;
+  }
+}
+
+function saveWatermark(ts) {
+  fs.writeFileSync(WATERMARK_FILE, JSON.stringify({ last_ts: ts, updated_at: new Date().toISOString() }, null, 2));
+}
+
+// ── Helpers ──
+
+function extractText(result) {
+  const raw = (result?.content || []).filter(c => c.type === 'text').map(c => c.text).join('\n');
+  if (raw.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed.results || parsed.messages || parsed.text || raw;
+    } catch {}
+  }
+  return raw;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function classifyMention(text) {
+  const trimmed = (text || '').trim();
+  const cleaned = trimmed.replace(/@wall-?e/gi, '').trim();
+  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';
+  return 'task';
+}
+
+function extractTaskTitle(text) {
+  const cleaned = (text || '').replace(/@wall-?e/gi, '').trim();
+  if (cleaned.length <= 120) return cleaned;
+  return cleaned.slice(0, 120).replace(/\s+\S*$/, '') + '...';
+}
+
+async function fetchThreadContext(channelId, threadTs) {
+  try {
+    const result = await slackMcp.callSlackMcp('slack_read_thread', {
+      channel_id: channelId,
+      message_ts: threadTs,
+      limit: 50,
+    });
+    return extractText(result);
+  } catch (err) {
+    console.warn(`[slack-mentions] Could not fetch thread context: ${err.message}`);
+    return null;
+  }
+}
+
+function parseSearchResults(rawText) {
+  const messages = [];
+  const blocks = rawText.split(/(?=### Result \d)/);
+
+  for (const block of blocks) {
+    if (!block.trim() || !block.includes('Result')) continue;
+
+    const channelMatch = block.match(/Channel:.*?\(ID:\s*(\w+)\)/);
+    let channelId = channelMatch ? channelMatch[1] : null;
+
+    const fromMatch = block.match(/From:\s*(.+?)\s*\(ID:\s*(\w+)\)/);
+    const fromName = fromMatch ? fromMatch[1].trim() : null;
+    const fromUserId = fromMatch ? fromMatch[2] : null;
+
+    const timeMatch = block.match(/Time:\s*(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/);
+    const isoTimestamp = timeMatch ? timeMatch[1] : null;
+
+    const msgTsMatch = block.match(/Message_ts:\s*(\d+\.\d+)/);
+    const msgTs = msgTsMatch ? msgTsMatch[1] : null;
+
+    const threadMatch = block.match(/Thread_ts:\s*(\d+\.\d+)/i);
+    const threadTs = threadMatch ? threadMatch[1] : null;
+
+    const linkMatch = block.match(/Permalink:\s*\[.*?\]\((https?:\/\/[^\s)]+)\)/);
+    // Slack MCP returns {workspace}.slack.com but enterprise workspaces use {workspace}.enterprise.slack.com
+    let permalink = linkMatch ? linkMatch[1] : null;
+    if (permalink) permalink = permalink.replace(/^(https:\/\/\w+)\.slack\.com/, '$1.enterprise.slack.com');
+
+    // Fallback: extract channel ID from permalink if Channel field didn't match (e.g. DMs)
+    if (!channelId && permalink) {
+      const archiveMatch = permalink.match(/\/archives\/([A-Z0-9]+)\//);
+      if (archiveMatch) channelId = archiveMatch[1];
+    }
+
+    const textMatch = block.match(/Text:\s*\n([\s\S]*?)(?:\n---|\n###|$)/);
+    const content = textMatch ? textMatch[1].trim() : '';
+
+    if (/@wall-?e/i.test(content) && content.length > 0) {
+      messages.push({
+        ts: msgTs, isoTimestamp, channelId, threadTs,
+        fromName, fromUserId, permalink, content, raw: block.trim(),
+      });
+    }
+  }
+
+  return messages;
+}
+
+function parseThreadReplies(rawText) {
+  let text = rawText;
+  if (text.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(text);
+      text = parsed.messages || parsed.results || parsed.text || text;
+    } catch {}
+  }
+
+  const replies = [];
+  const blocks = text.split(/(?=--- Reply \d)/);
+
+  for (const block of blocks) {
+    if (!block.trim() || !block.includes('Reply')) continue;
+
+    const fromMatch = block.match(/From:\s*(.+?)(?:\s*\(|\n)/);
+    const tsMatch = block.match(/Message TS:\s*(\d+\.\d+)/);
+    const from = fromMatch ? fromMatch[1].trim() : null;
+    const ts = tsMatch ? tsMatch[1] : null;
+
+    const lines = block.split('\n');
+    const metaEnd = lines.findIndex(l => /^Message TS:/.test(l));
+    const content = metaEnd >= 0 ? lines.slice(metaEnd + 1).join('\n').trim() : '';
+
+    // Skip bot replies (Sent using @Claude)
+    if (content.includes('Sent using') && content.includes('Claude')) continue;
+
+    if (content && ts) {
+      replies.push({ ts, from, content });
+    }
+  }
+
+  return replies;
+}
+
+// ── Watched thread polling (DB-backed) ──
+
+async function pollWatchedThreads() {
+  // Clean up expired threads
+  const expired = brain.deleteExpiredSlackThreads(WATCH_DURATION_MS);
+  if (expired > 0) console.log(`[slack-mentions] Expired ${expired} watched thread(s)`);
+
+  const activeThreads = brain.listActiveSlackThreads(WATCH_DURATION_MS);
+  if (activeThreads.length === 0) return;
+
+  for (const thread of activeThreads) {
+    try {
+      const rawThread = await fetchThreadContext(thread.channel_id, thread.thread_ts);
+      if (!rawThread) continue;
+
+      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];
+
+      // 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;
+
+      // Collect unseen messages (new since last_seen_ts)
+      const newReplies = ownerReplies.filter(r => r.ts > lastSeenTs);
+
+      // 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 {
+        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;
+
+      let replySucceeded = false;
+      try {
+        const chatModule = require(path.resolve(__dirname, '..', '..', '..', 'chat'));
+
+        const followUpPrompt = `The user replied in the Slack thread with a follow-up message:\n\n${combinedMessage}\n\n---\nRespond to their follow-up. You MUST reply in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${thread.channel_id}", "thread_ts": "${thread.thread_ts}", "message": "<your response>" }`;
+
+        const result = await chatModule.chat(followUpPrompt, {
+          channel: 'task',
+          session_id: thread.session_id,
+        });
+
+        console.log(`[slack-mentions] Follow-up reply sent for thread ${thread.id}: ${(result.reply || '').slice(0, 100)}`);
+        replySucceeded = true;
+      } catch (chatErr) {
+        console.error(`[slack-mentions] Failed to process follow-up: ${chatErr.message}`);
+      }
+
+      // Only advance last_seen_ts if the reply succeeded
+      brain.updateSlackThread(thread.id, {
+        last_seen_ts: replySucceeded ? latestTs : thread.last_seen_ts,
+        last_activity: new Date().toISOString(),
+      });
+
+      await sleep(PAUSE_MS);
+    } catch (err) {
+      console.error(`[slack-mentions] Error polling thread ${thread.id}: ${err.message}`);
+    }
+  }
+}
+
+// ── New mention processing ──
+
+async function processNewMentions() {
+  const lastTs = loadWatermark();
+  const now = new Date();
+  const yesterday = new Date(now.getTime() - 24 * 3600 * 1000);
+  const afterStr = yesterday.toISOString().split('T')[0];
+
+  console.log(`[slack-mentions] Checking for @walle mentions (watermark: ${lastTs || 'none'})`);
+
+  let newMentions = 0;
+  let tasksCreated = 0;
+  let questionsFound = 0;
+  let maxTs = lastTs;
+  const seenTs = new Set();
+
+  const queries = ['@walle', '@wall-e'];
+
+  for (const query of queries) {
+    try {
+      const result = await slackMcp.callSlackMcp('slack_search_public_and_private', {
+        query: `${query} after:${afterStr}`,
+        sort: 'timestamp',
+        sort_dir: 'desc',
+        limit: 10,
+      });
+
+      const rawText = extractText(result);
+      console.log(`[slack-mentions] Search "${query}": raw length=${rawText?.length || 0}`);
+      if (!rawText || rawText.length < 10) continue;
+
+      const messages = parseSearchResults(rawText);
+      console.log(`[slack-mentions] Parsed ${messages.length} message(s) from "${query}" search`);
+
+      for (const msg of messages) {
+        if (lastTs && msg.ts && msg.ts <= lastTs) continue;
+        if (lastTs && msg.isoTimestamp && msg.isoTimestamp <= lastTs) continue;
+
+        const dedupeKey = msg.ts || msg.permalink || msg.content;
+        if (seenTs.has(dedupeKey)) continue;
+        seenTs.add(dedupeKey);
+
+        const senderName = (msg.fromName || '').toLowerCase();
+        const isFromOwner = senderName.includes(OWNER_HANDLE.toLowerCase()) ||
+          senderName.includes(OWNER_NAME.split(' ')[0].toLowerCase());
+
+        if (!isFromOwner) {
+          console.log(`[slack-mentions] Skipping non-owner mention from: ${msg.fromName || 'unknown'}`);
+          continue;
+        }
+
+        newMentions++;
+        const kind = classifyMention(msg.content);
+        const effectiveTs = msg.ts || msg.isoTimestamp || now.toISOString();
+
+        const rawRef = msg.permalink || (msg.channelId ? `${msg.channelId}:${msg.ts || 'unknown'}` : `${kind}:${effectiveTs}`);
+        const sourceRef = rawRef.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}`);
+          continue;
+        }
+
+        // Fetch full thread context before creating the task
+        const threadTs = msg.threadTs || msg.ts;
+        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 === 'task') {
+          const title = extractTaskTitle(msg.content);
+          try {
+            const { id } = brain.insertTask({
+              title,
+              description: `Slack task from ${OWNER_NAME}:\n\n${msg.content}${contextBlock}\n\n---\n**IMPORTANT**: When done, reply with results in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your results>" }`,
+              priority: 'normal',
+              type: 'once',
+              execution: 'chat',
+              source: 'slack',
+              source_ref: sourceRef,
+            });
+            tasksCreated++;
+            console.log(`[slack-mentions] Task created: ${id} — ${title}`);
+
+            // Watch this thread for follow-ups (in DB)
+            try {
+              const threadId1 = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
+              console.log(`[slack-mentions] Upserted watched thread: ${threadId1} (task, channel=${msg.channelId})`);
+            } catch (upsertErr) {
+              console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message} (channelId=${msg.channelId}, threadTs=${threadTs})`);
+            }
+
+            if (msg.channelId) {
+              try {
+                await slackMcp.callSlackMcp('slack_send_message', {
+                  channel_id: msg.channelId,
+                  message: `Got it! I've created a task for this. I'll update you here when it's done.`,
+                  thread_ts: threadTs,
+                });
+              } catch (replyErr) {
+                console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
+              }
+              await sleep(PAUSE_MS);
+            }
+          } catch (taskErr) {
+            console.error(`[slack-mentions] Failed to create task: ${taskErr.message}`);
+          }
+        } else {
+          questionsFound++;
+          console.log(`[slack-mentions] Question detected: ${msg.content.slice(0, 80)}...`);
+
+          if (msg.channelId) {
+            try {
+              await slackMcp.callSlackMcp('slack_send_message', {
+                channel_id: msg.channelId,
+                message: `Let me look into that — I'll get back to you shortly.`,
+                thread_ts: threadTs,
+              });
+            } catch (replyErr) {
+              console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
+            }
+            await sleep(PAUSE_MS);
+          }
+
+          try {
+            const { id } = brain.insertTask({
+              title: `Answer Slack question: ${extractTaskTitle(msg.content)}`,
+              description: `Question from ${OWNER_NAME} in Slack:\n\n${msg.content}${contextBlock}\n\n---\n**IMPORTANT**: After answering, you MUST reply in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your answer>" }`,
+              priority: 'high',
+              type: 'once',
+              execution: 'chat',
+              source: 'slack',
+              source_ref: sourceRef,
+            });
+
+            // Watch this thread for follow-ups (in DB)
+            try {
+              const threadId2 = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
+              console.log(`[slack-mentions] Upserted watched thread: ${threadId2} (question, channel=${msg.channelId})`);
+            } catch (upsertErr) {
+              console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message} (channelId=${msg.channelId}, threadTs=${threadTs})`);
+            }
+          } catch (taskErr) {
+            console.error(`[slack-mentions] Failed to create question task: ${taskErr.message}`);
+          }
+        }
+
+        if (effectiveTs > (maxTs || '')) {
+          maxTs = effectiveTs;
+        }
+      }
+    } catch (err) {
+      if (err.message.includes('401') || err.message.includes('expired')) {
+        console.error('[slack-mentions] Slack token expired!');
+        brain.closeDb();
+        process.exit(1);
+      }
+      console.error(`[slack-mentions] Search error for "${query}": ${err.message}`);
+    }
+
+    await sleep(PAUSE_MS);
+  }
+
+  if (maxTs && maxTs !== lastTs) {
+    saveWatermark(maxTs);
+    console.log(`[slack-mentions] Watermark updated: ${maxTs}`);
+  }
+
+  if (newMentions === 0) {
+    console.log('[slack-mentions] No new mentions.');
+  } else {
+    console.log(`[slack-mentions] Processed ${newMentions} mention(s): ${tasksCreated} task(s), ${questionsFound} question(s).`);
+  }
+}
+
+// ── Adaptive schedule ──
+
+function setNextRunInterval() {
+  const activeThreads = brain.listActiveSlackThreads(WATCH_DURATION_MS);
+  const hasActiveThreads = activeThreads.length > 0;
+
+  const allTasks = brain.listTasks({});
+  const selfTask = allTasks.find(t => t.skill === 'slack-mentions' && t.type === 'recurring');
+  if (selfTask) {
+    const intervalMs = hasActiveThreads ? 10_000 : 30_000;
+    const nextRun = new Date(Date.now() + intervalMs).toISOString();
+    brain.updateTask(selfTask.id, { next_run_at: nextRun });
+    if (hasActiveThreads) {
+      console.log(`[slack-mentions] Active threads detected — next poll in 10s`);
+    }
+  }
+}
+
+// ── Main ──
+
+async function main() {
+  brain.initDb();
+
+  if (!slackMcp.isAuthenticated()) {
+    console.error('[slack-mentions] Slack token expired! Run: node tools/slack-mcp.js auth');
+    process.exit(1);
+  }
+
+  // Phase 1: Check watched threads for follow-up replies
+  await pollWatchedThreads();
+
+  // Phase 2: Search for new @walle mentions
+  await processNewMentions();
+
+  // Phase 3: Set next poll interval (10s if active threads, 30s otherwise)
+  setNextRunInterval();
+
+  brain.closeDb();
+}
+
+main().catch(err => {
+  console.error('[slack-mentions] Error:', err.message);
+  try { brain.closeDb(); } catch {};
+  process.exit(1);
+});