@cohortapp/agent-sdk 2.3.0

package/scripts/poller/slack-poller.mjs

@@ -0,0 +1,854 @@
+// 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,
+  AGENT_REPO_DIR,
+  extractSlackAttachments,
+  downloadSlackAttachment,
+} from "./utils.mjs";
+
+import {
+  isVoiceTranscript,
+  parseVoiceTranscript,
+  toInboxItems,
+} from "../parse-voice-transcript.mjs";
+
+const ACTIVE_THREADS_FILE = join(
+  AGENT_REPO_DIR,
+  "state",
+  "slack-active-threads.json",
+);
+const MAX_THREADS_PER_CHANNEL = 10;
+
+const SLACK_TOKEN = process.env.SLACK_USER_TOKEN || process.env.SLACK_TOKEN;
+
+// Load agent identity from canonical SOT for self-filtering + display names.
+let _agent = null;
+function loadAgent() {
+  if (_agent) return _agent;
+  try {
+    _agent = JSON.parse(readFileSync(join(AGENT_REPO_DIR, "config/agent.json"), "utf-8"));
+  } catch {
+    _agent = { firstName: "Agent", fullName: "Agent", slackMemberId: "" };
+  }
+  return _agent;
+}
+
+// Priority overrides for known channels — everything else defaults to "normal"
+const CHANNEL_PRIORITY_OVERRIDES = {
+  "ceo-office": "critical",
+  "engineering": "high",
+  "all-company": "high",
+  "engineering-platform": "high",
+  "regulatory-remediation": "high",
+  "strategic-initiative": "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 the agent 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 AGENT_USER_ID = "U099N1JFPRQ";
+
+// Rate-limit-aware delay with random jitter to reduce Slack API rate limiting.
+// Base delay 400ms + random 0-600ms jitter = 400-1000ms between requests.
+// With broader-fetch elimination and DM/thread rotation, total calls per cycle
+// are ~20-30 (down from 90+), so this timing keeps us well under both the
+// Slack Tier 3 limit (~50 req/min) and the 50s cycle budget.
+// Previous: fixed 1500ms with redundant broader fetches caused 25-30 min cycles.
+const INTER_REQUEST_BASE_MS = 400;
+const INTER_REQUEST_JITTER_MS = 600;
+const MAX_RETRIES = 3;
+
+// Cycle time budget — abort non-critical work if approaching this limit.
+// Launchd fires every 60s; we must finish well before the next invocation.
+const CYCLE_TIME_BUDGET_MS = 55_000;
+let cycleStartTime = 0;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+let lastRequestTime = 0;
+
+/**
+ * Check whether the cycle time budget has been exceeded.
+ * Returns true if we should skip non-critical work to finish on time.
+ */
+function isCycleBudgetExceeded() {
+  return cycleStartTime > 0 && (Date.now() - cycleStartTime) > CYCLE_TIME_BUDGET_MS;
+}
+
+async function slackApi(method, params = {}) {
+  // Enforce minimum spacing between requests with random jitter
+  const now = Date.now();
+  const jitteredDelay = INTER_REQUEST_BASE_MS + Math.floor(Math.random() * INTER_REQUEST_JITTER_MS);
+  const elapsed = now - lastRequestTime;
+  if (elapsed < jitteredDelay) {
+    await sleep(jitteredDelay - 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
+// Jordan?" 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 the agent'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 === AGENT_USER_ID ? (loadAgent().firstName || "Agent") : 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 === AGENT_USER_ID ? (loadAgent().firstName || "Agent") : 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() {
+  cycleStartTime = Date.now();
+
+  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 = {};
+  }
+
+  // ── CEO DM pre-pass ──────────────────────────────────────────────────
+  // Alex's DMs are the single most time-sensitive signal. The channel
+  // loop below routinely eats the entire 55s cycle budget on a busy
+  // workspace and skips DMs entirely. Poll the CEO DMs FIRST (with a
+  // small dedicated budget) so they always get fresh data regardless of
+  // how the broader cycle plays out. The downstream DM section will
+  // re-iterate but the items dedup on raw_ref so duplicates are dropped.
+  const ceoDmItemsSeen = new Set(); // raw_refs we already pushed in the pre-pass
+  try {
+    const convos = await slackApi("conversations.list", { types: "im", limit: 50 });
+    if (convos.ok) {
+      const ceoDMs = (convos.channels || []).filter((im) => im.user === CEO_USER_ID);
+      for (const im of ceoDMs) {
+        const history = await slackApi("conversations.history", {
+          channel: im.id,
+          oldest,
+          limit: 10,
+        });
+        if (!history.ok) continue;
+        for (const msg of history.messages || []) {
+          if (msg.bot_id || msg.user === AGENT_USER_ID) continue;
+          if (isVoiceTranscript(msg.text || "")) continue; // handled in main DM loop
+          const rawRef = `slack:${im.id}:${msg.ts}`;
+          ceoDmItemsSeen.add(rawRef);
+          items.push({
+            id: msg.ts.replace(".", "-"),
+            service: "slack",
+            channel: `dm/${resolveName(msg.user)}`,
+            sender: resolveName(msg.user),
+            sender_privilege: resolvePrivilege(msg.user),
+            timestamp: new Date(parseFloat(msg.ts) * 1000).toISOString(),
+            subject: `DM from ${resolveName(msg.user)}`,
+            content: msg.text || "",
+            thread_id: msg.thread_ts && msg.thread_ts !== msg.ts ? msg.thread_ts : "",
+            is_reply: false,
+            is_voice_transcript: false,
+            priority_signals: {
+              from_ceo: true,
+              tagged_urgent:
+                /\b(urgent|emergency|asap|blocker|critical)\b/i.test(msg.text || ""),
+              contains_deadline: false,
+              mentions_agent: true,
+            },
+            raw_ref: rawRef,
+            channel_id: im.id,
+          });
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(`CEO DM pre-pass: ${err.message}`);
+  }
+
+  for (const channel of channelsThisCycle) {
+    // Check cycle time budget — skip remaining channels if running long
+    if (isCycleBudgetExceeded()) {
+      errors.push("Cycle time budget exceeded — skipping remaining channels");
+      break;
+    }
+
+    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.
+      // Thread discovery relies on persisted activeThreads state (which survives
+      // across cycles) plus any threaded messages found in the current history
+      // response. The previous "broader" second fetch (without oldest filter)
+      // has been removed — it doubled API calls per channel and was the primary
+      // cause of rate-limiting. Active threads with old parent messages are
+      // already tracked in activeThreads from prior cycles.
+      const channelThreads = new Set(activeThreads[channel.id] || []);
+
+      for (const msg of result.messages || []) {
+        // Register any message with replies as an active thread (even the agent's)
+        if (msg.reply_count > 0 && msg.ts) {
+          channelThreads.add(msg.ts);
+        }
+
+        if (msg.bot_id || msg.user === AGENT_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 agentNameLower = (loadAgent().firstName || "").toLowerCase();
+        const mentionsAgent = !!agentNameLower && msgText.toLowerCase().includes(agentNameLower);
+        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_agent: mentionsAgent,
+          },
+          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 — with rotation.
+  // CEO DMs are polled every cycle (critical). Other DMs rotate in halves
+  // to reduce API calls. DM thread discovery uses persisted activeThreads
+  // state instead of a redundant broader fetch (same fix as channels above).
+  // Cache CEO DM channel IDs for thread scanning priority later.
+  const ceoDMChannelIds = new Set();
+  try {
+    const convos = await slackApi("conversations.list", {
+      types: "im",
+      limit: 50,
+    });
+    if (convos.ok) {
+      const allDMs = convos.channels || [];
+      // Separate CEO DMs (always poll) from other DMs (rotate in halves).
+      // We still track ceoDMChannelIds for the downstream thread-scan
+      // priority pass, but skip CEO DMs in the per-channel polling loop
+      // below because the CEO DM pre-pass at the top of the cycle has
+      // already fetched + pushed their messages with fresh budget.
+      const ceoDMs = allDMs.filter((im) => im.user === CEO_USER_ID);
+      for (const dm of ceoDMs) ceoDMChannelIds.add(dm.id);
+      const otherDMs = allDMs.filter((im) => im.user !== CEO_USER_ID);
+      const rotatedOtherDMs = otherDMs.filter((_, i) => i % 2 === pollCycleCount % 2);
+      const dmsThisCycle = rotatedOtherDMs;
+
+      for (const im of dmsThisCycle) {
+        // Check cycle time budget — skip remaining DMs if running long
+        if (isCycleBudgetExceeded()) {
+          errors.push("Cycle time budget exceeded — skipping remaining DMs");
+          break;
+        }
+
+        const history = await slackApi("conversations.history", {
+          channel: im.id,
+          oldest,
+          limit: 10,
+        });
+        if (!history.ok) continue;
+
+        // Track threads discovered from DM history — uses persisted state
+        // from prior cycles instead of a redundant broader API call.
+        const channelThreads = new Set(activeThreads[im.id] || []);
+
+        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 === AGENT_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_agent: 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.
+  //
+  // Thread scanning rotation: threads in high-priority channels (CEO DMs,
+  // critical/high channels) are scanned every cycle. Threads in normal
+  // channels rotate in halves to reduce API calls. If the cycle time
+  // budget is exceeded, remaining thread scans are skipped.
+  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(AGENT_REPO_DIR, "state", "inbox", "slack");
+  let existingInboxFiles = [];
+  try {
+    existingInboxFiles = readdirSync(SLACK_INBOX);
+  } catch { /* inbox dir may not exist yet */ }
+
+  // Determine which channels are high-priority for thread scanning.
+  // ceoDMChannelIds was populated during DM polling above — no extra API call needed.
+  const highPriorityChannelIds = new Set(
+    allChannels
+      .filter((c) => c.priority === "critical" || c.priority === "high")
+      .map((c) => c.id),
+  );
+
+  const threadEntries = Object.entries(activeThreads);
+  // Sort: high-priority channels first, then rotate others
+  const priorityThreadEntries = threadEntries.filter(
+    ([chId]) => highPriorityChannelIds.has(chId) || ceoDMChannelIds.has(chId),
+  );
+  const normalThreadEntries = threadEntries.filter(
+    ([chId]) => !highPriorityChannelIds.has(chId) && !ceoDMChannelIds.has(chId),
+  );
+  // Rotate normal thread entries in halves
+  const rotatedNormalThreadEntries = normalThreadEntries.filter(
+    (_, i) => i % 2 === pollCycleCount % 2,
+  );
+  const threadEntriesToScan = [...priorityThreadEntries, ...rotatedNormalThreadEntries];
+
+  for (const [channelId, threadTsList] of threadEntriesToScan) {
+    if (!threadTsList || threadTsList.length === 0) continue;
+
+    // Check cycle time budget before scanning this channel's threads
+    if (isCycleBudgetExceeded()) {
+      errors.push("Cycle time budget exceeded — skipping remaining thread scans");
+      break;
+    }
+
+    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 the agent 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 agentRepliedRecently = replies.some(
+          (r) =>
+            r.user === AGENT_USER_ID &&
+            parseFloat(r.ts) > cooldownTs,
+        );
+        if (agentRepliedRecently) 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 the agent's own messages
+          if (reply.bot_id || reply.user === AGENT_USER_ID) continue;
+          // Only process replies within our lookback window
+          if (parseFloat(reply.ts) <= threadOldestTs) continue;
+
+          // Skip messages that the agent already replied to in this thread.
+          // If the agent posted a message AFTER this human message, a prior
+          // session already handled it — don't re-ingest and duplicate.
+          const agentRepliedAfter = replies.some(
+            (r) => r.user === AGENT_USER_ID && parseFloat(r.ts) > parseFloat(reply.ts)
+          );
+          if (agentRepliedAfter) 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 === AGENT_USER_ID ? (loadAgent().firstName || "Agent") : 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_agent: isDmThread || (loadAgent().firstName && new RegExp(loadAgent().firstName, "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(AGENT_REPO_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
+        // Events-server JSON uses `slack_event` key; also check `event` for compatibility
+        const evtPre = data.slack_event || data.event || {};
+        const eventTs = data.ts || data.event_ts || data.received_at || evtPre.ts || "";
+        const evtChannel = data.channel_id || data.channel || evtPre.channel || "";
+        const eventRef = data.raw_ref || `slack:${evtChannel}:${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
+        // Events-server JSON uses `slack_event` key; also check `event` for compatibility
+        const evt = data.slack_event || data.event || {};
+        const sender = data.sender || resolveName(data.user || data.user_id || evt.user || "unknown");
+
+        // Skip the agent'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 || evt.user || "";
+        const myFullSlug = (loadAgent().fullName || "").toLowerCase().replace(/\s+/g, "-");
+        if (userId === AGENT_USER_ID || (myFullSlug && sender === myFullSlug)) {
+          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 || evt.text || "";
+        const channelId = data.channel_id || data.channel || evt.channel || "";
+        const threadTs = data.thread_id || data.thread_ts || evt.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);
+        }
+
+        // Extract and download attachments from events-server items
+        const evtFiles = evt.files || data.files || [];
+        const evtAttachments = extractSlackAttachments(evtFiles);
+        for (const att of evtAttachments) {
+          const fileObj = evtFiles.find((f) => f.id === att.id);
+          const localPath = await downloadSlackAttachment(fileObj, SLACK_TOKEN);
+          if (localPath) att.local_path = localPath;
+        }
+
+        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),
+          attachments: evtAttachments.length > 0 ? evtAttachments : undefined,
+          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_agent: loadAgent().firstName ? new RegExp(loadAgent().firstName, "i").test(content) : false,
+          },
+          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());
+
+  const cycleDurationMs = Date.now() - cycleStartTime;
+  const cycleDurationSec = (cycleDurationMs / 1000).toFixed(1);
+  console.log(
+    `[slack-poller] Cycle ${pollCycleCount} completed in ${cycleDurationSec}s ` +
+    `(${channelsThisCycle.length} channels, ${items.length} items, ${errors.length} errors)`,
+  );
+
+  return { items, errors };
+}