@adaptic/maestro 1.0.0

package/scripts/poller/slack-poller.mjs

@@ -0,0 +1,716 @@
+// Slack Poller — checks Slack API for new messages every 60 seconds
+// Requires SLACK_USER_TOKEN or SLACK_TOKEN environment variable
+
+import { readFileSync, writeFileSync, readdirSync, renameSync, existsSync } from "fs";
+import { join } from "path";
+import {
+  writeInboxItem,
+  readCursor,
+  writeCursor,
+  resolvePrivilege,
+  resolveName,
+  SOPHIE_AI_DIR,
+  extractSlackAttachments,
+  downloadSlackAttachment,
+} from "./utils.mjs";
+
+import {
+  isVoiceTranscript,
+  parseVoiceTranscript,
+  toInboxItems,
+} from "../parse-voice-transcript.mjs";
+
+const ACTIVE_THREADS_FILE = join(
+  SOPHIE_AI_DIR,
+  "state",
+  "slack-active-threads.json",
+);
+const MAX_THREADS_PER_CHANNEL = 10;
+
+const SLACK_TOKEN = process.env.SLACK_USER_TOKEN || process.env.SLACK_TOKEN;
+
+// Priority overrides for known channels — everything else defaults to "normal"
+const CHANNEL_PRIORITY_OVERRIDES = {
+  "ceo-office": "critical",
+  "engineering": "high",
+  "all-adaptic": "high",
+  "adaptic-engine": "high",
+  "dfsa-remediation": "high",
+  "rollup-strategy": "high",
+  "legal-compliance": "high",
+};
+
+// Dynamic channel list — fetched once per daemon lifecycle, refreshed every 10 min
+let cachedChannels = null;
+let channelsCachedAt = 0;
+const CHANNEL_CACHE_TTL = 10 * 60 * 1000; // 10 min
+
+/**
+ * Fetch all channels Sophie is a member of.
+ * Replaces the static MONITORED_CHANNELS list so new channels are auto-discovered.
+ * Per CEO standing instruction si-001: "Monitor ALL Slack channels."
+ */
+async function getMonitoredChannels() {
+  if (cachedChannels && (Date.now() - channelsCachedAt) < CHANNEL_CACHE_TTL) {
+    return cachedChannels;
+  }
+  try {
+    const result = await slackApi("conversations.list", {
+      types: "public_channel,private_channel",
+      limit: 200,
+      exclude_archived: true,
+    });
+    if (!result.ok) {
+      console.error(`[slack-poller] conversations.list failed: ${result.error}`);
+      return cachedChannels || [];
+    }
+    cachedChannels = (result.channels || [])
+      .filter((c) => c.is_member)
+      .map((c) => ({
+        id: c.id,
+        name: c.name || c.id,
+        priority: CHANNEL_PRIORITY_OVERRIDES[c.name] || "normal",
+      }));
+    channelsCachedAt = Date.now();
+    return cachedChannels;
+  } catch (err) {
+    console.error(`[slack-poller] Channel discovery failed: ${err.message}`);
+    return cachedChannels || [];
+  }
+}
+
+const CEO_USER_ID = "U097N5R0M7U";
+const SOPHIE_USER_ID = "U099N1JFPRQ";
+
+// Rate-limit-aware delay: space requests ~1500ms apart to stay under Slack Tier 3 limits
+// (~50 req/min for conversations.history). With ~25 calls per cycle (half channels
+// rotated), 1500ms spacing = ~38s total, well within the 60s poll interval.
+// Previous: 800ms caused persistent rate limiting with 11 channels + threads.
+const INTER_REQUEST_DELAY_MS = 1500;
+const MAX_RETRIES = 3;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+let lastRequestTime = 0;
+
+async function slackApi(method, params = {}) {
+  // Enforce minimum spacing between requests
+  const now = Date.now();
+  const elapsed = now - lastRequestTime;
+  if (elapsed < INTER_REQUEST_DELAY_MS) {
+    await sleep(INTER_REQUEST_DELAY_MS - elapsed);
+  }
+  lastRequestTime = Date.now();
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const url = new URL(`https://slack.com/api/${method}`);
+    Object.entries(params).forEach(([k, v]) =>
+      url.searchParams.set(k, String(v)),
+    );
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${SLACK_TOKEN}` },
+    });
+
+    // Handle HTTP 429 rate limiting
+    if (res.status === 429) {
+      const retryAfter = parseInt(res.headers.get("Retry-After") || "5", 10);
+      if (attempt < MAX_RETRIES) {
+        await sleep(retryAfter * 1000);
+        lastRequestTime = Date.now();
+        continue;
+      }
+      // Exhausted retries — return the rate-limited response
+      return { ok: false, error: "ratelimited" };
+    }
+
+    const body = await res.json();
+
+    // Handle in-body rate limit errors (Slack sometimes returns 200 with error)
+    if (!body.ok && body.error === "ratelimited" && attempt < MAX_RETRIES) {
+      const retryAfter = parseInt(res.headers.get("Retry-After") || "3", 10);
+      await sleep(retryAfter * 1000);
+      lastRequestTime = Date.now();
+      continue;
+    }
+
+    return body;
+  }
+}
+
+// ── Context fetching ────────────────────────────────────────────────────
+// Fetch surrounding conversation context for a message so the session
+// knows what was said before. This is the fix for "are you referring to
+// Nima?" when the conversation was clearly about Graham.
+
+const CONTEXT_MESSAGES_LIMIT = 8; // Last 8 messages from the conversation
+
+/**
+ * Fetch recent conversation context for a DM message.
+ * Returns the last N messages (including Sophie's) formatted as readable text.
+ * This gives the session awareness of the conversation flow.
+ */
+async function fetchDMContext(channelId, beforeTs) {
+  try {
+    const result = await slackApi("conversations.history", {
+      channel: channelId,
+      latest: beforeTs,
+      limit: CONTEXT_MESSAGES_LIMIT,
+      inclusive: false,
+    });
+    if (!result.ok || !result.messages || result.messages.length === 0) return null;
+
+    // Messages come newest-first from Slack, reverse for chronological order
+    const msgs = result.messages.reverse();
+    const lines = msgs.map((m) => {
+      const who = m.user === SOPHIE_USER_ID ? "Sophie" : resolveName(m.user);
+      const text = (m.text || "").substring(0, 500);
+      return `${who}: ${text}`;
+    });
+    return lines.join("\n");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fetch thread context (parent message + preceding replies) for a thread reply.
+ * Returns formatted text with the full thread conversation up to this point.
+ */
+async function fetchThreadContext(channelId, threadTs, beforeTs) {
+  try {
+    const result = await slackApi("conversations.replies", {
+      channel: channelId,
+      ts: threadTs,
+      limit: CONTEXT_MESSAGES_LIMIT,
+    });
+    if (!result.ok || !result.messages || result.messages.length === 0) return null;
+
+    // Only include messages before the current one
+    const preceding = result.messages.filter(
+      (m) => parseFloat(m.ts) < parseFloat(beforeTs)
+    );
+    if (preceding.length === 0) return null;
+
+    const lines = preceding.map((m) => {
+      const who = m.user === SOPHIE_USER_ID ? "Sophie" : resolveName(m.user);
+      const text = (m.text || "").substring(0, 500);
+      return `${who}: ${text}`;
+    });
+    return lines.join("\n");
+  } catch {
+    return null;
+  }
+}
+
+// ── Channel rotation ────────────────────────────────────────────────────
+// With dynamic discovery (potentially 30+ channels), rotation is essential.
+// Critical/high channels polled every cycle; normal channels rotate in thirds.
+let pollCycleCount = 0;
+
+function getChannelsForCycle(allChannels) {
+  pollCycleCount++;
+  const critical = allChannels.filter((c) => c.priority === "critical" || c.priority === "high");
+  const normal = allChannels.filter((c) => c.priority === "normal" || c.priority === "low");
+  // Always poll critical/high; rotate normal channels in thirds
+  const normalSubset = normal.filter((_, i) => i % 3 === pollCycleCount % 3);
+  return [...critical, ...normalSubset];
+}
+
+export async function pollSlack() {
+  if (!SLACK_TOKEN) {
+    return { items: [], errors: ["SLACK_TOKEN not set"] };
+  }
+
+  const lastChecked = readCursor("slack");
+  const oldest = lastChecked
+    ? String(new Date(lastChecked).getTime() / 1000)
+    : String((Date.now() - 5 * 60 * 1000) / 1000);
+  const items = [];
+  const errors = [];
+  const allChannels = await getMonitoredChannels();
+  const channelsThisCycle = getChannelsForCycle(allChannels);
+
+  // Load active threads state (used for both channel and DM thread scanning)
+  let activeThreads = {};
+  try {
+    if (existsSync(ACTIVE_THREADS_FILE)) {
+      activeThreads = JSON.parse(readFileSync(ACTIVE_THREADS_FILE, "utf-8"));
+    }
+  } catch {
+    activeThreads = {};
+  }
+
+  for (const channel of channelsThisCycle) {
+    try {
+      const result = await slackApi("conversations.history", {
+        channel: channel.id,
+        oldest,
+        limit: 20,
+      });
+
+      if (!result.ok) {
+        errors.push(`Channel ${channel.name}: ${result.error}`);
+        continue;
+      }
+
+      // Track channel threads with replies so the thread scanner picks them up.
+      // IMPORTANT: conversations.history only returns messages newer than `oldest`,
+      // but threads with old parent messages can have NEW replies. We must also
+      // check slightly older messages to discover threads with recent activity.
+      const channelThreads = new Set(activeThreads[channel.id] || []);
+
+      // Second pass: fetch recent messages WITHOUT oldest filter to find threads
+      // with new replies. Parent messages older than cursor are invisible to the
+      // first pass, but their threads can have new replies we need to scan.
+      // Always run this — it's the only way to discover active threads in channels.
+      try {
+        const broader = await slackApi("conversations.history", {
+          channel: channel.id,
+          limit: 15,
+        });
+        if (broader.ok) {
+          for (const m of broader.messages || []) {
+            if (m.reply_count > 0 && m.ts) {
+              // Track ALL threads with replies — the thread scanner will
+              // filter by cursor timestamp when fetching individual replies
+              channelThreads.add(m.ts);
+            }
+          }
+        }
+      } catch { /* non-critical — thread discovery is best-effort */ }
+
+      for (const msg of result.messages || []) {
+        // Register any message with replies as an active thread (even Sophie's)
+        if (msg.reply_count > 0 && msg.ts) {
+          channelThreads.add(msg.ts);
+        }
+
+        if (msg.bot_id || msg.user === SOPHIE_USER_ID) continue;
+
+        const msgText = msg.text || "";
+        const isCeo = msg.user === CEO_USER_ID;
+
+        // Check if this is a voice call transcript posted by post-call routing
+        if (isVoiceTranscript(msgText)) {
+          const parsed = parseVoiceTranscript(msgText, {
+            ts: msg.ts,
+            channel: channel.id,
+          });
+          const voiceItems = toInboxItems(parsed);
+          for (const vi of voiceItems) {
+            items.push(vi);
+          }
+          continue;
+        }
+
+        const mentionsSophie = msgText.toLowerCase().includes("sophie");
+        const isUrgent = /\b(urgent|emergency|asap|blocker|critical)\b/i.test(
+          msgText,
+        );
+
+        // Fetch thread context for channel thread replies
+        let channelThreadContext = null;
+        if (msg.thread_ts && msg.thread_ts !== msg.ts) {
+          channelThreadContext = await fetchThreadContext(channel.id, msg.thread_ts, msg.ts);
+        }
+
+        // Extract and download attachments
+        const attachments = extractSlackAttachments(msg.files);
+        for (const att of attachments) {
+          const file = (msg.files || []).find((f) => f.id === att.id);
+          const localPath = await downloadSlackAttachment(file, SLACK_TOKEN);
+          if (localPath) att.local_path = localPath;
+        }
+
+        items.push({
+          id: msg.ts.replace(".", "-"),
+          service: "slack",
+          channel: channel.name,
+          channel_id: channel.id,
+          sender: resolveName(msg.user),
+          sender_privilege: resolvePrivilege(msg.user),
+          timestamp: new Date(parseFloat(msg.ts) * 1000).toISOString(),
+          subject: `#${channel.name}`,
+          content: msgText,
+          thread_id: msg.thread_ts || "",
+          thread_context: channelThreadContext,
+          is_reply: !!msg.thread_ts,
+          attachments: attachments.length > 0 ? attachments : undefined,
+          priority_signals: {
+            from_ceo: isCeo,
+            tagged_urgent: isUrgent,
+            contains_deadline: false,
+            mentions_sophie: mentionsSophie,
+          },
+          raw_ref: `slack:${channel.id}:${msg.ts}`,
+        });
+      }
+
+      // Persist channel thread tracking (bounded)
+      activeThreads[channel.id] = [...channelThreads]
+        .sort((a, b) => parseFloat(b) - parseFloat(a))
+        .slice(0, MAX_THREADS_PER_CHANNEL);
+    } catch (err) {
+      errors.push(`Channel ${channel.name}: ${err.message}`);
+    }
+  }
+
+  // Also check DMs
+  try {
+    const convos = await slackApi("conversations.list", {
+      types: "im",
+      limit: 50,
+    });
+    if (convos.ok) {
+      for (const im of convos.channels || []) {
+        const history = await slackApi("conversations.history", {
+          channel: im.id,
+          oldest,
+          limit: 10,
+        });
+        if (!history.ok) continue;
+
+        // Track threads discovered from DM history messages with replies
+        const channelThreads = new Set(activeThreads[im.id] || []);
+
+        // Broader thread discovery for DMs — same pattern as channels.
+        // Fetch recent messages WITHOUT oldest filter to find DM threads
+        // whose parent message predates the cursor but have new replies.
+        try {
+          const broader = await slackApi("conversations.history", {
+            channel: im.id,
+            limit: 10,
+          });
+          if (broader.ok) {
+            for (const m of broader.messages || []) {
+              if (m.reply_count > 0 && m.ts) {
+                channelThreads.add(m.ts);
+              }
+            }
+          }
+        } catch { /* non-critical — DM thread discovery is best-effort */ }
+
+        for (const msg of history.messages || []) {
+          // Register any message with replies as an active thread
+          if (msg.reply_count > 0 && msg.ts) {
+            channelThreads.add(msg.ts);
+          }
+
+          if (msg.bot_id || msg.user === SOPHIE_USER_ID) continue;
+
+          const msgText = msg.text || "";
+          const isCeo = msg.user === CEO_USER_ID;
+
+          // Check if this is a voice call transcript posted by post-call routing
+          if (isVoiceTranscript(msgText)) {
+            const parsed = parseVoiceTranscript(msgText, {
+              ts: msg.ts,
+              channel: im.id,
+            });
+            const voiceItems = toInboxItems(parsed);
+            for (const vi of voiceItems) {
+              items.push(vi);
+            }
+            continue;
+          }
+
+          // Fetch conversation context — thread context for thread replies,
+          // recent DM history for standalone messages
+          let threadContext = null;
+          if (msg.thread_ts && msg.thread_ts !== msg.ts) {
+            // Thread reply — fetch parent + preceding replies
+            threadContext = await fetchThreadContext(im.id, msg.thread_ts, msg.ts);
+          } else {
+            // Standalone DM — fetch recent conversation history
+            threadContext = await fetchDMContext(im.id, msg.ts);
+          }
+
+          // Extract and download attachments
+          const dmAttachments = extractSlackAttachments(msg.files);
+          for (const att of dmAttachments) {
+            const file = (msg.files || []).find((f) => f.id === att.id);
+            const localPath = await downloadSlackAttachment(file, SLACK_TOKEN);
+            if (localPath) att.local_path = localPath;
+          }
+
+          items.push({
+            id: msg.ts.replace(".", "-"),
+            service: "slack",
+            channel: `dm/${resolveName(msg.user)}`,
+            channel_id: im.id,
+            sender: resolveName(msg.user),
+            sender_privilege: resolvePrivilege(msg.user),
+            timestamp: new Date(parseFloat(msg.ts) * 1000).toISOString(),
+            subject: `DM from ${resolveName(msg.user)}`,
+            content: msgText,
+            thread_id: msg.thread_ts || "",
+            thread_context: threadContext,
+            is_reply: !!msg.thread_ts,
+            attachments: dmAttachments.length > 0 ? dmAttachments : undefined,
+            priority_signals: {
+              from_ceo: isCeo,
+              tagged_urgent:
+                /\b(urgent|emergency|asap|blocker|critical)\b/i.test(msgText),
+              contains_deadline: false,
+              mentions_sophie: true,
+            },
+            raw_ref: `slack:${im.id}:${msg.ts}`,
+          });
+        }
+
+        // Update active threads for this channel (bounded to MAX_THREADS_PER_CHANNEL, most recent first)
+        activeThreads[im.id] = [...channelThreads]
+          .sort((a, b) => parseFloat(b) - parseFloat(a))
+          .slice(0, MAX_THREADS_PER_CHANNEL);
+      }
+    }
+  } catch (err) {
+    errors.push(`DM polling: ${err.message}`);
+  }
+
+  // ── Scan active threads (DMs AND channels) for new replies ──
+  // This catches thread replies that conversations.history misses.
+  // Use a 30-minute lookback window instead of the exact cursor to avoid
+  // missing replies that arrived between poll cycles or during processing.
+  const THREAD_LOOKBACK_MS = 30 * 60 * 1000;
+  const threadOldest = String((Date.now() - THREAD_LOOKBACK_MS) / 1000);
+  const threadOldestTs = parseFloat(threadOldest);
+  const threadItems = [];
+
+  // Pre-load the list of existing inbox files once for fast dedup lookups.
+  // The 30-min lookback re-fetches replies that were already processed in
+  // previous poll cycles; without this check the daemon re-classifies and
+  // re-dispatches the same thread reply every 60 seconds until the reply
+  // ages past the lookback window (the original "thread scanning bug").
+  const SLACK_INBOX = join(SOPHIE_AI_DIR, "state", "inbox", "slack");
+  let existingInboxFiles = [];
+  try {
+    existingInboxFiles = readdirSync(SLACK_INBOX);
+  } catch { /* inbox dir may not exist yet */ }
+
+  for (const [channelId, threadTsList] of Object.entries(activeThreads)) {
+    if (!threadTsList || threadTsList.length === 0) continue;
+
+    for (const threadTs of threadTsList) {
+      try {
+        const repliesResult = await slackApi("conversations.replies", {
+          channel: channelId,
+          ts: threadTs,
+          oldest: threadOldest,
+          limit: 20,
+        });
+
+        if (!repliesResult.ok) continue;
+
+        const replies = repliesResult.messages || [];
+
+        // ── Thread-level cooldown ──────────────────────────────────
+        // If Sophie posted ANY reply in this thread within the last
+        // THREAD_COOLDOWN_MS, skip the entire thread. This prevents
+        // re-ingesting human messages that a running session is already
+        // handling, which previously caused cascading holding notes.
+        const THREAD_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
+        const cooldownTs = (Date.now() - THREAD_COOLDOWN_MS) / 1000;
+        const sophieRepliedRecently = replies.some(
+          (r) =>
+            r.user === SOPHIE_USER_ID &&
+            parseFloat(r.ts) > cooldownTs,
+        );
+        if (sophieRepliedRecently) continue; // skip entire thread
+
+        for (const reply of replies) {
+          // Skip the parent message itself (ts === thread_ts)
+          if (reply.ts === threadTs) continue;
+          // Skip bot messages and Sophie's own messages
+          if (reply.bot_id || reply.user === SOPHIE_USER_ID) continue;
+          // Only process replies within our lookback window
+          if (parseFloat(reply.ts) <= threadOldestTs) continue;
+
+          // Skip messages that Sophie already replied to in this thread.
+          // If Sophie posted a message AFTER this human message, a prior
+          // session already handled it — don't re-ingest and duplicate.
+          const sophieRepliedAfter = replies.some(
+            (r) => r.user === SOPHIE_USER_ID && parseFloat(r.ts) > parseFloat(reply.ts)
+          );
+          if (sophieRepliedAfter) continue;
+
+          const replyText = reply.text || "";
+          const isCeo = reply.user === CEO_USER_ID;
+          const replyId = `${reply.ts.replace(".", "-")}-thread_reply`;
+
+          // Dedup 1: check if this reply is already in the current cycle's items array
+          const alreadyQueued = items.some(
+            (i) => i.raw_ref === `slack:${channelId}:${reply.ts}`,
+          );
+          if (alreadyQueued) continue;
+
+          // Dedup 2: check if an inbox file already exists (active or processed)
+          // from a previous poll cycle. The 30-min lookback window exceeds the
+          // 15-min lock TTL, so without this the daemon's acquireLock() would
+          // re-acquire an expired lock and re-process the same reply.
+          const replyIdFragment = replyId;
+          const alreadyInInbox = existingInboxFiles.some(
+            (f) => f.includes(replyIdFragment),
+          );
+          if (alreadyInInbox) continue;
+
+          // Build thread context from the replies we already fetched
+          const precedingInThread = replies
+            .filter((m) => parseFloat(m.ts) < parseFloat(reply.ts))
+            .map((m) => {
+              const who = m.user === SOPHIE_USER_ID ? "Sophie" : resolveName(m.user);
+              return `${who}: ${(m.text || "").substring(0, 500)}`;
+            })
+            .join("\n");
+
+          // Extract and download attachments for thread replies
+          const replyAttachments = extractSlackAttachments(reply.files);
+          for (const att of replyAttachments) {
+            const file = (reply.files || []).find((f) => f.id === att.id);
+            const localPath = await downloadSlackAttachment(file, SLACK_TOKEN);
+            if (localPath) att.local_path = localPath;
+          }
+
+          // Determine if this is a DM thread or a channel thread
+          const isDmThread = channelId.startsWith("D");
+          const chanInfo = !isDmThread
+            ? allChannels.find((c) => c.id === channelId)
+            : null;
+          const channelLabel = isDmThread
+            ? `dm/${resolveName(reply.user)}`
+            : chanInfo ? chanInfo.name : channelId;
+          const subjectLabel = isDmThread
+            ? `DM thread reply from ${resolveName(reply.user)}`
+            : `#${channelLabel} thread reply from ${resolveName(reply.user)}`;
+
+          threadItems.push({
+            id: replyId,
+            service: "slack",
+            channel: channelLabel,
+            channel_id: channelId,
+            sender: resolveName(reply.user),
+            sender_privilege: resolvePrivilege(reply.user),
+            timestamp: new Date(parseFloat(reply.ts) * 1000).toISOString(),
+            subject: subjectLabel,
+            content: replyText,
+            thread_id: threadTs,
+            thread_context: precedingInThread || null,
+            is_reply: true,
+            event_type: "thread_reply",
+            attachments: replyAttachments.length > 0 ? replyAttachments : undefined,
+            priority_signals: {
+              from_ceo: isCeo,
+              tagged_urgent:
+                /\b(urgent|emergency|asap|blocker|critical)\b/i.test(replyText),
+              contains_deadline: false,
+              mentions_sophie: isDmThread || /sophie/i.test(replyText),
+            },
+            raw_ref: `slack:${channelId}:${reply.ts}`,
+          });
+        }
+      } catch (err) {
+        errors.push(`Thread replies ${channelId}/${threadTs}: ${err.message}`);
+      }
+    }
+  }
+
+  // Merge thread reply items
+  items.push(...threadItems);
+
+  // Persist updated active threads
+  try {
+    writeFileSync(ACTIVE_THREADS_FILE, JSON.stringify(activeThreads));
+  } catch (err) {
+    errors.push(`Writing active threads: ${err.message}`);
+  }
+
+  // ── Pick up events-server items ──────────────────────────────────────
+  // The comms-monitor.sh + Slack Events API write .json files to inbox.
+  // These include @mentions, channel thread replies, and reactions that
+  // the conversations.history API doesn't return. Scan for unprocessed
+  // .json files and convert them into items for the daemon pipeline.
+  const SLACK_INBOX_DIR = join(SOPHIE_AI_DIR, "state", "inbox", "slack");
+  try {
+    const inboxFiles = readdirSync(SLACK_INBOX_DIR)
+      .filter((f) => f.endsWith(".json") && !f.endsWith(".processed"))
+      .slice(0, 10); // Process up to 10 per cycle
+
+    for (const file of inboxFiles) {
+      try {
+        const raw = readFileSync(join(SLACK_INBOX_DIR, file), "utf-8");
+        const data = JSON.parse(raw);
+
+        // Dedup: skip if we already have this item from API polling
+        const eventTs = data.ts || data.event_ts || "";
+        const eventRef = data.raw_ref || `slack:${data.channel || ""}:${eventTs}`;
+        const alreadyHave = items.some((i) => i.raw_ref === eventRef);
+        if (alreadyHave) {
+          // Mark as processed since the API poll already got it
+          try { renameSync(join(SLACK_INBOX_DIR, file), join(SLACK_INBOX_DIR, file + ".processed")); } catch {}
+          continue;
+        }
+
+        // Convert events-server JSON to daemon item format
+        const sender = data.sender || resolveName(data.user || data.user_id || "unknown");
+
+        // Skip Sophie's own messages — the events server should filter these,
+        // but if any slip through (e.g. message_changed edge cases), catch here
+        const userId = data.user || data.user_id || "";
+        if (userId === SOPHIE_USER_ID || sender === "sophie-nguyen") {
+          try { renameSync(join(SLACK_INBOX_DIR, file), join(SLACK_INBOX_DIR, file + ".processed")); } catch {}
+          continue;
+        }
+
+        const privilege = data.sender_privilege || resolvePrivilege(userId);
+        const content = data.content || data.text || data.event?.text || "";
+        const channelId = data.channel_id || data.channel || data.event?.channel || "";
+        const threadTs = data.thread_id || data.thread_ts || data.event?.thread_ts || "";
+
+        // Fetch thread context if this is a thread reply
+        let threadContext = data.thread_context || null;
+        if (!threadContext && threadTs && eventTs && threadTs !== eventTs && channelId) {
+          threadContext = await fetchThreadContext(channelId, threadTs, eventTs);
+        }
+
+        items.push({
+          id: data.id || eventTs.replace(".", "-") || file.replace(".json", ""),
+          service: "slack",
+          channel: data.channel || channelId,
+          channel_id: channelId,
+          sender,
+          sender_privilege: privilege,
+          timestamp: data.timestamp || new Date().toISOString(),
+          subject: data.subject || `Slack event`,
+          content,
+          thread_id: threadTs,
+          thread_context: threadContext,
+          is_reply: data.is_reply || (!!threadTs && threadTs !== eventTs),
+          priority_signals: data.priority_signals || {
+            from_ceo: privilege === "ceo",
+            tagged_urgent: /\b(urgent|emergency|asap|blocker|critical)\b/i.test(content),
+            contains_deadline: false,
+            mentions_sophie: /sophie/i.test(content),
+          },
+          raw_ref: eventRef,
+          _inbox_file: file,
+        });
+
+        // Mark as processed
+        try { renameSync(join(SLACK_INBOX_DIR, file), join(SLACK_INBOX_DIR, file + ".processed")); } catch {}
+      } catch (err) {
+        errors.push(`Inbox file ${file}: ${err.message}`);
+      }
+    }
+  } catch {
+    // Inbox dir doesn't exist — fine
+  }
+
+  for (const item of items) {
+    writeInboxItem("slack", item);
+  }
+
+  writeCursor("slack", new Date().toISOString());
+  return { items, errors };
+}