agor-live 0.21.2 → 0.23.1

package/dist/core/gateway/index.js

@@ -341,12 +341,16 @@ var TABLE_MAX_ROWS = 100;
 var TABLE_MAX_COLS = 20;
 var TABLE_MAX_CELL_CHARS = 3e3;
 var SECTION_MAX_CHARS = 3e3;
+var MARKDOWN_BLOCK_MAX_CHARS = 12e3;
 var MAX_TABLES_PER_MESSAGE = 1;
 var MAX_BLOCKS_PER_MESSAGE = 50;
 var BLOCK_PAYLOAD_ERRORS = /* @__PURE__ */ new Set([
   "invalid_blocks",
   "invalid_blocks_format",
-  "message_blocks_too_long"
+  "invalid_block_type",
+  "message_blocks_too_long",
+  "unknown_block_type",
+  "unsupported_block_type"
 ]);
 var FENCE_LINE_RE = /^(`{3,}|~{3,})/;
 var PIPE_LINE_RE = /^\s*\|/;
@@ -373,6 +377,11 @@ function hasActiveMention2(text, mentionPattern) {
   mentionPattern.lastIndex = 0;
   return mentionPattern.test(stripped);
 }
+function slackTsToIso(ts) {
+  const seconds = Number(ts.split(".")[0]);
+  if (!Number.isFinite(seconds)) return (/* @__PURE__ */ new Date()).toISOString();
+  return new Date(seconds * 1e3).toISOString();
+}
 function segmentMarkdown(md) {
   const lines = md.split(/\r?\n/);
   const segments = [];
@@ -519,12 +528,35 @@ ${tableLines.join("\n")}
     text: { type: "mrkdwn", text: wrapped }
   };
 }
+function buildMarkdownBlock(markdown) {
+  const trimmed = markdown.trim();
+  if (trimmed.length === 0 || trimmed.length > MARKDOWN_BLOCK_MAX_CHARS) return null;
+  return { type: "markdown", text: markdown };
+}
+function tableHasRichMarkdown(tableLines) {
+  return tableLines.some(
+    (line) => /(\*\*|__|~~|`|\[[^\]]+\]\([^)]*\)|<br\s*\/?\s*>|_[^_|]+_|(^|\|)\s*[-*+]\s+)/i.test(line)
+  );
+}
+function shouldUseNativeMarkdownBlock(markdown, segments) {
+  if (!buildMarkdownBlock(markdown)) return false;
+  const tableSegments = segments.filter((segment) => segment.kind === "table");
+  if (tableSegments.length > 1) return true;
+  return tableSegments.some((segment) => tableHasRichMarkdown(segment.lines));
+}
 function markdownToSlackPayload(markdown) {
   const text = markdownToMrkdwn(markdown);
   const segments = segmentMarkdown(markdown);
-  if (!segments.some((s) => s.kind === "table")) {
+  const hasTable = segments.some((s) => s.kind === "table");
+  if (!hasTable) {
     return { text };
   }
+  if (shouldUseNativeMarkdownBlock(markdown, segments)) {
+    const markdownBlock = buildMarkdownBlock(markdown);
+    if (markdownBlock) {
+      return { text, blocks: [markdownBlock] };
+    }
+  }
   const blocks = [];
   let tablesEmitted = 0;
   for (const seg of segments) {
@@ -554,6 +586,64 @@ function extractSlackErrorCode(resultOrError) {
   const candidate = resultOrError;
   return candidate.data?.error ?? candidate.error;
 }
+function extractSlackErrorDetail(resultOrError) {
+  if (typeof resultOrError !== "object" || resultOrError === null) return {};
+  const candidate = resultOrError;
+  return {
+    code: candidate.data?.error ?? candidate.error ?? candidate.code,
+    needed: candidate.data?.needed ?? candidate.needed,
+    provided: candidate.data?.provided ?? candidate.provided,
+    retryAfter: candidate.retryAfter
+  };
+}
+var BOT_TOKEN_ERROR_REASONS = {
+  invalid_auth: "The bot token is invalid.",
+  account_inactive: "The bot token belongs to a deleted or deactivated account or workspace.",
+  token_revoked: "The bot token has been revoked.",
+  token_expired: "The bot token has expired.",
+  not_authed: "No bot token was provided.",
+  no_permission: "The bot token lacks permission to call auth.test."
+};
+var CHANNEL_ACCESS_ERROR_REASONS = {
+  not_in_channel: "The bot is not a member of this channel; invite it so it can read messages.",
+  channel_not_found: "The channel ID was not found, or the bot cannot see it.",
+  is_archived: "The channel is archived."
+};
+function buildTestFailure(capability, detail, reasons) {
+  const { code, needed, provided, retryAfter } = detail;
+  let reason;
+  if (code === "missing_scope") {
+    reason = needed ? `Slack reports a missing OAuth scope; add "${needed}".` : "Slack reports a missing OAuth scope.";
+  } else if (code === "ratelimited" || retryAfter != null) {
+    reason = retryAfter != null ? `Slack rate-limited the probe; retry after ${retryAfter}s. The probe did not retry.` : "Slack rate-limited the probe. The probe did not retry.";
+  } else if (code && reasons[code]) {
+    reason = reasons[code];
+  } else if (code) {
+    reason = `Slack returned error "${code}".`;
+  } else {
+    reason = "A network or unexpected error occurred while contacting Slack.";
+  }
+  const failure = { capability, reason };
+  if (code) failure.slackError = code;
+  if (needed) failure.needed = needed;
+  if (provided) failure.provided = provided;
+  return failure;
+}
+function normalizeAllowedChannelIds(raw) {
+  if (Array.isArray(raw)) return raw.filter((id) => typeof id === "string");
+  if (typeof raw === "string" && raw) return [raw];
+  return [];
+}
+var SLACK_NOT_VERIFIABLE = [
+  "Whether the bot token and app-level token belong to the same Slack app.",
+  "Whether the required Slack event subscriptions are installed and delivering events.",
+  "Whether the full set of required OAuth scopes is granted \u2014 only scopes exercised by the probed API calls are checked."
+];
+function isChannelAllowedByWhitelist(channelType, channelId, allowedChannelIds) {
+  if (channelType === "im") return true;
+  if (!allowedChannelIds || allowedChannelIds.length === 0) return true;
+  return !!channelId && allowedChannelIds.includes(channelId);
+}
 var SlackConnector = class _SlackConnector {
   channelType = "slack";
   web;
@@ -562,12 +652,15 @@ var SlackConnector = class _SlackConnector {
   botUserId = null;
   /** Cache: Slack user ID → profile (email + display name, or null if unavailable). */
   userProfileCache = /* @__PURE__ */ new Map();
+  inboundEventDedup = /* @__PURE__ */ new Map();
   /** Cache: Slack channel ID → channel name */
   channelNameCache = /* @__PURE__ */ new Map();
   static USER_CACHE_TTL_MS = 15 * 60 * 1e3;
   // 15 min for successful lookups
   static USER_CACHE_ERROR_TTL_MS = 60 * 1e3;
   // 1 min for errors (transient recovery)
+  static INBOUND_EVENT_DEDUP_TTL_MS = 5 * 60 * 1e3;
+  // Slack may send message + app_mention for one user action
   /**
    * Cache: Slack channel ID → channel type string (channel/group/mpim/im).
    *
@@ -590,6 +683,122 @@ var SlackConnector = class _SlackConnector {
     }
     this.web = new WebClient(this.config.bot_token);
   }
+  /**
+   * Build a Slack WebClient for an arbitrary token. Isolated so connection
+   * probes can construct a client for the app-level (`xapp-`) token, and so
+   * tests can stub the app-token client independently of `this.web`.
+   */
+  createWebClient(token) {
+    return new WebClient(token);
+  }
+  /**
+   * Best-effort probe of the configured Slack credentials and reachability.
+   *
+   * Probes capabilities directly rather than diffing scope-header strings:
+   *   - `auth.test()` with the bot token → team + bot identity.
+   *   - `apps.connections.open()` with the app-level token → Socket Mode /
+   *     `connections:write` validity.
+   *   - `conversations.info` on the first whitelisted channel (when any) →
+   *     channel reachability.
+   *
+   * Slack's `missing_scope` needed/provided detail and rate-limit `Retry-After`
+   * are surfaced verbatim. Never logs or returns token values.
+   */
+  async testConnection() {
+    const failures = [];
+    const notVerifiable = [...SLACK_NOT_VERIFIABLE];
+    let team;
+    let bot;
+    let botTokenValid = false;
+    try {
+      const authTest = await this.web.auth.test();
+      if (authTest.ok) {
+        botTokenValid = true;
+        team = { id: authTest.team_id ?? "", name: authTest.team ?? "" };
+        bot = { userId: authTest.user_id ?? "", name: authTest.user ?? "" };
+      } else {
+        failures.push(
+          buildTestFailure("bot_token", extractSlackErrorDetail(authTest), BOT_TOKEN_ERROR_REASONS)
+        );
+      }
+    } catch (error) {
+      failures.push(
+        buildTestFailure("bot_token", extractSlackErrorDetail(error), BOT_TOKEN_ERROR_REASONS)
+      );
+    }
+    let appTokenValid;
+    const appToken = this.config.app_token;
+    if (!appToken) {
+      appTokenValid = false;
+      failures.push({
+        capability: "app_token",
+        reason: "No app-level token is configured; Socket Mode cannot connect to receive messages."
+      });
+    } else {
+      try {
+        const appClient = this.createWebClient(appToken);
+        const res = await appClient.apps.connections.open();
+        if (res.ok) {
+          appTokenValid = true;
+        } else {
+          appTokenValid = false;
+          failures.push(buildTestFailure("app_token", extractSlackErrorDetail(res), {}));
+        }
+      } catch (error) {
+        appTokenValid = false;
+        failures.push(buildTestFailure("app_token", extractSlackErrorDetail(error), {}));
+      }
+    }
+    let channelAccess;
+    const allowedChannelIds = normalizeAllowedChannelIds(this.config.allowed_channel_ids);
+    if (allowedChannelIds.length > 0) {
+      const channelId = allowedChannelIds[0];
+      let channelOk = false;
+      try {
+        const info = await this.web.conversations.info({ channel: channelId });
+        if (info.ok) {
+          channelOk = true;
+        } else {
+          failures.push(
+            buildTestFailure(
+              "channel_access",
+              extractSlackErrorDetail(info),
+              CHANNEL_ACCESS_ERROR_REASONS
+            )
+          );
+        }
+      } catch (error) {
+        failures.push(
+          buildTestFailure(
+            "channel_access",
+            extractSlackErrorDetail(error),
+            CHANNEL_ACCESS_ERROR_REASONS
+          )
+        );
+      }
+      channelAccess = [{ channelId, ok: channelOk }];
+      if (allowedChannelIds.length > 1) {
+        notVerifiable.push(
+          `Only the first of ${allowedChannelIds.length} configured channels was probed; the rest were not checked.`
+        );
+      }
+    } else {
+      notVerifiable.push(
+        "No channel whitelist is configured, so no specific channel reachability was verified."
+      );
+    }
+    const channelsOk = !channelAccess || channelAccess.some((c) => c.ok);
+    const ok = botTokenValid && appTokenValid && channelsOk && failures.length === 0;
+    return {
+      ok,
+      ...team ? { team } : {},
+      ...bot ? { bot } : {},
+      appTokenValid,
+      ...channelAccess ? { channelAccess } : {},
+      failures,
+      notVerifiable
+    };
+  }
   /**
    * Look up a Slack user's email address by their user ID.
    *
@@ -626,11 +835,7 @@ var SlackConnector = class _SlackConnector {
         displayName,
         expiresAt: now + _SlackConnector.USER_CACHE_TTL_MS
       });
-      if (email) {
-        console.log(
-          `[slack] Resolved user ${slackUserId} \u2192 ${displayName ?? "(no name)"} <${email}>`
-        );
-      } else {
+      if (!email) {
         console.log(
           `[slack] User ${slackUserId} has no email (missing users:read.email scope or restricted account)`
         );
@@ -646,6 +851,33 @@ var SlackConnector = class _SlackConnector {
       return { email: null, displayName: null };
     }
   }
+  /**
+   * Look up a Slack user by email and return display metadata including a
+   * high-resolution avatar URL. Used by Agor's admin-triggered user avatar
+   * sync. Prefer image_512 for crisp large/retina rendering, falling back to
+   * smaller Slack-provided variants.
+   */
+  async lookupUserAvatarByEmail(email) {
+    const normalized = email.trim().toLowerCase();
+    if (!normalized) throw new Error("Slack user email is required");
+    const result = await this.web.users.lookupByEmail({ email: normalized }).catch((error) => {
+      if (extractSlackErrorCode(error) === "users_not_found") {
+        return null;
+      }
+      throw error;
+    });
+    if (!result?.ok || !result.user?.id) {
+      return null;
+    }
+    const profile = result.user.profile;
+    const avatarUrl = profile?.image_512 || profile?.image_original || profile?.image_1024 || profile?.image_192 || profile?.image_72 || profile?.image_48 || null;
+    return {
+      slackUserId: result.user.id,
+      email: profile?.email ?? normalized,
+      displayName: profile?.display_name || profile?.real_name || result.user.real_name || result.user.name || null,
+      avatarUrl
+    };
+  }
   /**
    * Look up a Slack channel's name by its ID.
    *
@@ -679,6 +911,47 @@ var SlackConnector = class _SlackConnector {
       return null;
     }
   }
+  async lookupLatestThreadReply(event) {
+    const channel = typeof event.channel === "string" ? event.channel : void 0;
+    const message = typeof event.message === "object" && event.message !== null ? event.message : void 0;
+    const threadTs = (typeof message?.thread_ts === "string" ? message.thread_ts : void 0) ?? (typeof message?.ts === "string" ? message.ts : void 0) ?? (typeof event.thread_ts === "string" ? event.thread_ts : void 0);
+    const replies = Array.isArray(message?.replies) ? message.replies.filter((reply) => {
+      return typeof reply === "object" && reply !== null;
+    }) : [];
+    const latestReplyTs = (typeof message?.latest_reply === "string" ? message.latest_reply : void 0) ?? (typeof event.latest_reply === "string" ? event.latest_reply : void 0) ?? [...replies].reverse().map((reply) => typeof reply.ts === "string" ? reply.ts : void 0).find(Boolean);
+    if (!channel || !threadTs || !latestReplyTs) return null;
+    try {
+      const result = await this.web.conversations.replies({
+        channel,
+        ts: threadTs,
+        oldest: latestReplyTs,
+        inclusive: true,
+        limit: 1
+      });
+      const reply = result.messages?.find((candidate) => candidate.ts === latestReplyTs) ?? result.messages?.[0] ?? null;
+      if (!reply) return null;
+      return {
+        ...reply,
+        channel,
+        thread_ts: typeof reply.thread_ts === "string" ? reply.thread_ts : threadTs,
+        team: event.team
+      };
+    } catch (error) {
+      console.warn("[slack] Failed to fetch latest thread reply for message_replied event:", error);
+      return null;
+    }
+  }
+  shouldProcessInboundEventOnce(channel, ts) {
+    if (!channel || !ts) return true;
+    const now = Date.now();
+    for (const [key2, expiresAt] of this.inboundEventDedup) {
+      if (expiresAt <= now) this.inboundEventDedup.delete(key2);
+    }
+    const key = `${channel}:${ts}`;
+    if (this.inboundEventDedup.has(key)) return false;
+    this.inboundEventDedup.set(key, now + _SlackConnector.INBOUND_EVENT_DEDUP_TTL_MS);
+    return true;
+  }
   /**
    * Cache a known channel type from a trusted source (e.g. `message` event with explicit `channel_type`).
    */
@@ -724,7 +997,6 @@ var SlackConnector = class _SlackConnector {
         } else {
           resolvedType = "channel";
         }
-        console.log(`[slack] conversations.info resolved channel ${channelId} \u2192 ${resolvedType}`);
         this.cacheChannelType(channelId, resolvedType);
         if (ch.name) {
           this.channelNameCache.set(channelId, {
@@ -770,22 +1042,34 @@ var SlackConnector = class _SlackConnector {
   async sendMessage(req) {
     const { channel, thread_ts } = parseThreadId2(req.threadId);
     const blocks = req.blocks && req.blocks.length > 0 ? req.blocks : void 0;
-    const post = (withBlocks) => this.web.chat.postMessage({
-      channel,
-      thread_ts,
-      text: req.text,
-      ...withBlocks && blocks ? { blocks } : {},
-      unfurl_links: false,
-      unfurl_media: false
-    });
+    const updateTs = typeof req.metadata?.slack_update_ts === "string" ? req.metadata.slack_update_ts : void 0;
+    const send = (withBlocks) => {
+      const base = {
+        channel,
+        text: req.text,
+        ...withBlocks && blocks ? { blocks } : {},
+        unfurl_links: false,
+        unfurl_media: false
+      };
+      if (updateTs) {
+        return this.web.chat.update({
+          ...base,
+          ts: updateTs
+        });
+      }
+      return this.web.chat.postMessage({
+        ...base,
+        thread_ts
+      });
+    };
     let result;
     try {
-      result = await post(true);
+      result = await send(true);
     } catch (err) {
       const code = extractSlackErrorCode(err);
       if (blocks && code && BLOCK_PAYLOAD_ERRORS.has(code)) {
         console.warn(`[slack] Block payload rejected (${code}); retrying as text-only`);
-        result = await post(false);
+        result = await send(false);
       } else {
         throw err;
       }
@@ -794,7 +1078,7 @@ var SlackConnector = class _SlackConnector {
       const code = extractSlackErrorCode(result);
       if (blocks && code && BLOCK_PAYLOAD_ERRORS.has(code)) {
         console.warn(`[slack] Block payload rejected (${code}); retrying as text-only`);
-        const retry = await post(false);
+        const retry = await send(false);
         if (!retry.ok || !retry.ts) {
           throw new Error(`Slack API error: ${retry.error ?? "unknown error"}`);
         }
@@ -805,6 +1089,234 @@ var SlackConnector = class _SlackConnector {
     }
     return result.ts;
   }
+  /**
+   * Send directly to a Slack channel or thread. Used for proactive outbound
+   * emits where no gateway thread_session_map exists yet.
+   */
+  async sendSlackMessage(req) {
+    const blocks = req.blocks && req.blocks.length > 0 ? req.blocks : void 0;
+    const send = (withBlocks) => this.web.chat.postMessage({
+      channel: req.channel,
+      text: req.text,
+      ...withBlocks && blocks ? { blocks } : {},
+      ...req.thread_ts ? { thread_ts: req.thread_ts } : {},
+      unfurl_links: false,
+      unfurl_media: false
+    });
+    let result;
+    try {
+      result = await send(true);
+    } catch (err) {
+      const code = extractSlackErrorCode(err);
+      if (blocks && code && BLOCK_PAYLOAD_ERRORS.has(code)) {
+        console.warn(`[slack] Block payload rejected (${code}); retrying direct send as text-only`);
+        result = await send(false);
+      } else {
+        throw err;
+      }
+    }
+    if (!result.ok || !result.ts) {
+      const code = extractSlackErrorCode(result);
+      if (blocks && code && BLOCK_PAYLOAD_ERRORS.has(code)) {
+        const retry = await send(false);
+        if (!retry.ok || !retry.ts) {
+          throw new Error(`Slack API error: ${retry.error ?? "unknown error"}`);
+        }
+        result = retry;
+      } else {
+        throw new Error(`Slack API error: ${result.error ?? "unknown error"}`);
+      }
+    }
+    const sentTs = result.ts;
+    if (!sentTs) {
+      throw new Error("Slack API error: missing message timestamp");
+    }
+    let permalink = null;
+    try {
+      const link = await this.web.chat.getPermalink({ channel: req.channel, message_ts: sentTs });
+      permalink = link.ok ? link.permalink ?? null : null;
+    } catch {
+      permalink = null;
+    }
+    return {
+      ts: sentTs,
+      channel: req.channel,
+      thread_ts: req.thread_ts ?? sentTs,
+      permalink
+    };
+  }
+  /** Resolve a Slack channel by its human name (with or without #). */
+  async resolveChannelByName(name) {
+    const normalized = name.replace(/^#/, "").trim().toLowerCase();
+    if (!normalized) throw new Error("Slack channel name is required");
+    let cursor;
+    do {
+      const result = await this.web.conversations.list({
+        types: "public_channel,private_channel",
+        limit: 1e3,
+        ...cursor ? { cursor } : {}
+      });
+      if (!result.ok) {
+        throw new Error(`Slack API error: ${result.error ?? "unknown error"}`);
+      }
+      const channels = result.channels ?? [];
+      const match = channels.find((channel) => {
+        if (channel.is_archived) return false;
+        return (channel.name_normalized ?? channel.name ?? "").toLowerCase() === normalized;
+      });
+      if (match?.id) {
+        return { channel: match.id, name: match.name ?? normalized };
+      }
+      cursor = result.response_metadata?.next_cursor || void 0;
+    } while (cursor);
+    throw new Error(`Slack channel not found: #${normalized}`);
+  }
+  /** Resolve a Slack user email to a DM channel with that user. */
+  async openDmByEmail(email) {
+    const normalized = email.trim().toLowerCase();
+    if (!normalized) throw new Error("Slack user email is required");
+    const userResult = await this.web.users.lookupByEmail({ email: normalized });
+    if (!userResult.ok || !userResult.user?.id) {
+      throw new Error(`Slack user lookup failed: ${userResult.error ?? "user_not_found"}`);
+    }
+    const dmResult = await this.web.conversations.open({ users: userResult.user.id });
+    if (!dmResult.ok || !dmResult.channel?.id) {
+      throw new Error(`Slack DM open failed: ${dmResult.error ?? "unknown error"}`);
+    }
+    return { channel: dmResult.channel.id, user_id: userResult.user.id };
+  }
+  async fetchThreadHistory(req) {
+    const { channel, thread_ts } = parseThreadId2(req.threadId);
+    const requestedLimit = Math.min(Math.max(req.limit ?? 50, 1), 200);
+    const messages = [];
+    let cursor;
+    let hasMore = false;
+    do {
+      const rawLimit = req.includeBotMessages ? requestedLimit : Math.min(Math.max(requestedLimit * 4, requestedLimit), 200);
+      const result = await this.web.conversations.replies({
+        channel,
+        ts: thread_ts,
+        limit: rawLimit,
+        ...cursor ? { cursor } : {},
+        ...req.oldestTs ? { oldest: req.oldestTs } : {},
+        ...req.latestTs ? { latest: req.latestTs } : {},
+        ...req.inclusive !== void 0 ? { inclusive: req.inclusive } : {}
+      });
+      if (!result.ok) {
+        throw new Error(`Slack thread history error: ${result.error ?? "unknown error"}`);
+      }
+      const rawMessages = result.messages ?? [];
+      let stoppedAtRequestedLimitWithMoreRaw = false;
+      for (let i = 0; i < rawMessages.length; i++) {
+        const raw = rawMessages[i];
+        if (!raw) continue;
+        const ts = typeof raw.ts === "string" ? raw.ts : void 0;
+        if (!ts) continue;
+        const botId = typeof raw.bot_id === "string" ? raw.bot_id : void 0;
+        const subtype = typeof raw.subtype === "string" ? raw.subtype : void 0;
+        const isBot = !!botId || subtype === "bot_message";
+        if (isBot && !req.includeBotMessages) continue;
+        const userId = typeof raw.user === "string" ? raw.user : void 0;
+        let userName;
+        if (userId) {
+          const profile = await this.lookupUserProfile(userId);
+          userName = profile.displayName ?? void 0;
+        }
+        const botProfile = raw.bot_profile;
+        const botName = typeof botProfile?.name === "string" ? botProfile.name : typeof raw.username === "string" ? raw.username : void 0;
+        const actorLabel = userName ?? botName ?? userId ?? botId ?? "unknown";
+        const text = typeof raw.text === "string" ? raw.text : "";
+        messages.push({
+          ts,
+          iso_time: slackTsToIso(ts),
+          ...userId ? { user_id: userId } : {},
+          ...userName ? { user_name: userName } : {},
+          actor_label: actorLabel,
+          text,
+          is_bot: isBot,
+          is_trigger: req.triggerTs === ts,
+          is_mention: this.botUserId ? text.includes(`<@${this.botUserId}>`) : false
+        });
+        if (messages.length >= requestedLimit) {
+          stoppedAtRequestedLimitWithMoreRaw = i < rawMessages.length - 1;
+          break;
+        }
+      }
+      cursor = result.response_metadata?.next_cursor || void 0;
+      hasMore = result.has_more === true || !!cursor || stoppedAtRequestedLimitWithMoreRaw;
+    } while (!req.includeBotMessages && messages.length < requestedLimit && cursor);
+    return {
+      threadId: req.threadId,
+      channel,
+      thread_ts,
+      messages: messages.slice(0, requestedLimit),
+      has_more: hasMore
+    };
+  }
+  async startStream(req) {
+    const { channel, thread_ts } = parseThreadId2(req.threadId);
+    const chat = this.web.chat;
+    const result = await chat.startStream({
+      channel,
+      thread_ts,
+      markdown_text: req.text?.trim() ? req.text : " ",
+      ...req.recipientUserId ? { recipient_user_id: req.recipientUserId } : {},
+      ...req.recipientTeamId ? { recipient_team_id: req.recipientTeamId } : {}
+    });
+    if (!result.ok || !result.ts) {
+      throw new Error(`Slack stream start error: ${result.error ?? "unknown error"}`);
+    }
+    return result.ts;
+  }
+  async appendStream(req) {
+    const { channel } = parseThreadId2(req.threadId);
+    const chat = this.web.chat;
+    const result = await chat.appendStream({
+      channel,
+      ts: req.ts,
+      markdown_text: req.text
+    });
+    if (!result.ok) {
+      throw new Error(`Slack stream append error: ${result.error ?? "unknown error"}`);
+    }
+  }
+  async stopStream(req) {
+    const { channel } = parseThreadId2(req.threadId);
+    const chat = this.web.chat;
+    const result = await chat.stopStream({
+      channel,
+      ts: req.ts,
+      ...req.text ? { markdown_text: req.text } : {}
+    });
+    if (!result.ok) {
+      throw new Error(`Slack stream stop error: ${result.error ?? "unknown error"}`);
+    }
+  }
+  async deleteMessage(req) {
+    const { channel } = parseThreadId2(req.threadId);
+    const result = await this.web.chat.delete({
+      channel,
+      ts: req.messageId
+    });
+    if (!result.ok) {
+      throw new Error(`Slack delete error: ${result.error ?? "unknown error"}`);
+    }
+  }
+  async setThreadStatus(req) {
+    const { channel, thread_ts } = parseThreadId2(req.threadId);
+    const web = this.web;
+    const args = {
+      channel_id: channel,
+      thread_ts,
+      status: req.status,
+      ...req.loadingMessages?.length ? { loading_messages: req.loadingMessages } : {},
+      ...req.iconEmoji ? { icon_emoji: req.iconEmoji } : {}
+    };
+    const result = web.assistant?.threads?.setStatus ? await web.assistant.threads.setStatus(args) : await web.apiCall?.("assistant.threads.setStatus", args);
+    if (!result?.ok) {
+      throw new Error(`Slack assistant status error: ${result?.error ?? "unknown error"}`);
+    }
+  }
   /**
    * Start listening for inbound messages via Socket Mode
    *
@@ -813,31 +1325,24 @@ var SlackConnector = class _SlackConnector {
    * - Public channels (if enable_channels = true)
    * - Private channels (if enable_groups = true)
    * - Group DMs (if enable_mpim = true)
-   * - Mention requirement (if require_mention = true)
+   * - Explicit mention requirement for channel-like conversations
    * - Channel whitelist (if allowed_channel_ids is set)
    */
   async startListening(callback) {
-    console.log("[slack] startListening called");
     if (!this.config.app_token) {
       console.error("[slack] ERROR: app_token is missing from config");
       throw new Error("Slack Socket Mode requires app_token in config");
     }
-    console.log("[slack] Creating SocketModeClient...");
     this.socketMode = new SocketModeClient({
       appToken: this.config.app_token
     });
     let botMentionPattern = null;
     let botMentionReplacePattern = null;
     try {
-      console.log("[slack] Testing bot token with auth.test()...");
       const authTest = await this.web.auth.test();
       this.botUserId = authTest.user_id;
       botMentionPattern = new RegExp(`<@${this.botUserId}>`);
       botMentionReplacePattern = new RegExp(`<@${this.botUserId}>\\s*`, "g");
-      console.log(`[slack] Bot user ID: ${this.botUserId}`);
-      console.log(
-        `[slack] Bot auth test successful - team: ${authTest.team}, user: ${authTest.user}`
-      );
     } catch (error) {
       console.error("[slack] Failed to fetch bot user ID:", error);
       console.error("[slack] This usually means the bot_token is invalid or expired");
@@ -846,8 +1351,7 @@ var SlackConnector = class _SlackConnector {
     const enableChannels = this.config.enable_channels ?? false;
     const enableGroups = this.config.enable_groups ?? false;
     const enableMpim = this.config.enable_mpim ?? false;
-    const requireMention = this.config.require_mention ?? true;
-    const allowThreadRepliesWithoutMention = this.config.allow_thread_replies_without_mention ?? true;
+    const requireMention = true;
     let allowedChannelIds;
     if (this.config.allowed_channel_ids) {
       if (Array.isArray(this.config.allowed_channel_ids)) {
@@ -863,13 +1367,6 @@ var SlackConnector = class _SlackConnector {
         allowedChannelIds = void 0;
       }
     }
-    console.log("[slack] Message source config:", {
-      enableChannels,
-      enableGroups,
-      enableMpim,
-      requireMention,
-      allowedChannelIds: allowedChannelIds?.length || 0
-    });
     this.socketMode.on("slack_event", async ({ type, body, ack }) => {
       if (type !== "events_api") {
         await ack();
@@ -881,44 +1378,69 @@ var SlackConnector = class _SlackConnector {
         return;
       }
       await ack();
-      const event = body.event;
+      let event = body.event;
+      const slackTeamId = typeof event.team === "string" ? event.team : typeof body.team_id === "string" ? body.team_id : Array.isArray(body.authorizations) && typeof body.authorizations[0]?.team_id === "string" ? body.authorizations[0].team_id : void 0;
       console.log(
         `[slack] Processing ${eventType} event - channel: ${event.channel}, channel_type: ${event.channel_type}`
       );
       if (event.bot_id || event.subtype === "bot_message") {
-        console.log("[slack] Skipping bot message");
         return;
       }
       if (eventType === "message" && event.subtype) {
+        if (event.subtype === "message_replied") {
+          const replyEvent = await this.lookupLatestThreadReply(event);
+          if (!replyEvent) {
+            console.log(
+              `[slack] Skipping message_replied event without fetchable latest reply channel=${event.channel ?? "(none)"} ts=${event.ts ?? "(none)"}`
+            );
+            return;
+          }
+          event = {
+            ...replyEvent,
+            type: "message",
+            channel_type: event.channel_type
+          };
+          console.log(
+            `[slack] Resolved message_replied event to latest reply thread_ts=${event.thread_ts ?? "(none)"} ts=${event.ts ?? "(none)"}`
+          );
+        } else {
+          console.debug(
+            `[slack] Skipping message subtype=${event.subtype} user=${event.user ?? "(none)"} thread_ts=${event.thread_ts ?? "(none)"} ts=${event.ts ?? "(none)"}`
+          );
+          return;
+        }
+      }
+      if (event.bot_id || event.subtype === "bot_message") {
+        console.debug(
+          `[slack] Skipping resolved bot message subtype=${event.subtype ?? "(none)"} thread_ts=${event.thread_ts ?? "(none)"} ts=${event.ts ?? "(none)"}`
+        );
         return;
       }
       const channelType = event.channel ? await this.resolveChannelType(event.channel, event.channel_type) : void 0;
       const isThreadReply = !!event.thread_ts;
-      const isChannelMessage = channelType === "channel" || channelType === "group";
-      if (isChannelMessage && !botMentionPattern) {
+      const isChannelLikeMessage = channelType === "channel" || channelType === "group" || channelType === "mpim";
+      if (isChannelLikeMessage && eventType !== "app_mention") {
+        console.debug(
+          `[slack] Skipping non-app_mention event in channel-like conversation type=${eventType} channel=${event.channel} ts=${event.ts}`
+        );
+        return;
+      }
+      if (isChannelLikeMessage && !botMentionPattern) {
         if (eventType === "message" && requireMention) {
-          console.warn(
-            "[slack] Bot ID unavailable, require_mention=true - skipping message event (will use app_mention)"
-          );
-          return;
-        }
-        if (eventType === "app_mention" && !requireMention) {
-          console.warn(
-            "[slack] Bot ID unavailable, require_mention=false - skipping app_mention (will use message)"
-          );
           return;
         }
       }
-      if (isChannelMessage && botMentionPattern) {
+      if (isChannelLikeMessage && botMentionPattern) {
         const mentionOutsideCodeBlock = hasActiveMention2(event.text ?? "", botMentionPattern);
-        if (eventType === "message" && mentionOutsideCodeBlock) {
-          return;
-        }
         if (eventType === "app_mention" && !mentionOutsideCodeBlock) {
           return;
         }
       }
-      if (!channelType || channelType === "im") {
+      if (!channelType) {
+        console.warn(`[slack] Cannot determine channel_type for channel=${event.channel}`);
+        return;
+      }
+      if (channelType === "im") {
       } else if (channelType === "channel" && !enableChannels) {
         return;
       } else if (channelType === "group" && !enableGroups) {
@@ -929,15 +1451,14 @@ var SlackConnector = class _SlackConnector {
         console.warn(`[slack] Unknown channel_type="${channelType}"`);
         return;
       }
-      if (allowedChannelIds && allowedChannelIds.length > 0) {
-        if (!allowedChannelIds.includes(event.channel)) {
-          return;
-        }
+      if (!isChannelAllowedByWhitelist(channelType, event.channel, allowedChannelIds)) {
+        return;
       }
       let messageText = event.text ?? "";
       let hasMention = false;
-      let allowedViaThreadReplyException = false;
-      if (requireMention) {
+      const allowedViaThreadReplyException = false;
+      const requiresExplicitMention = channelType !== "im";
+      if (requireMention && requiresExplicitMention) {
         if (!botMentionPattern || !botMentionReplacePattern) {
           if (eventType === "app_mention") {
             hasMention = true;
@@ -950,20 +1471,25 @@ var SlackConnector = class _SlackConnector {
         } else {
           hasMention = hasActiveMention2(messageText, botMentionPattern);
           if (!hasMention) {
-            if (isThreadReply && allowThreadRepliesWithoutMention) {
-              allowedViaThreadReplyException = true;
-            } else {
-              return;
-            }
-          }
-          if (hasMention) {
-            messageText = messageText.replace(botMentionReplacePattern, "").trim();
+            return;
           }
+          messageText = messageText.replace(botMentionReplacePattern, "").trim();
+        }
+      } else if (botMentionPattern && botMentionReplacePattern) {
+        hasMention = hasActiveMention2(messageText, botMentionPattern);
+        if (hasMention) {
+          messageText = messageText.replace(botMentionReplacePattern, "").trim();
         }
       }
+      if (!this.shouldProcessInboundEventOnce(event.channel, event.ts)) {
+        console.log(
+          `[slack] Skipping duplicate inbound event type=${eventType} channel=${event.channel} ts=${event.ts}`
+        );
+        return;
+      }
       const threadId = event.thread_ts ? `${event.channel}-${event.thread_ts}` : `${event.channel}-${event.ts}`;
       console.log(
-        `[slack] Inbound message: thread=${threadId} channel_type=${channelType} user=${event.user}`
+        `[slack] Accepted inbound message: thread=${threadId} channel_type=${channelType} user=${event.user}`
       );
       let slackUserEmail = null;
       let slackUserDisplayName = null;
@@ -984,7 +1510,15 @@ var SlackConnector = class _SlackConnector {
         metadata: {
           channel: event.channel,
           channel_type: channelType,
+          ...event.user ? { slack_user_id: event.user } : {},
+          ...slackTeamId ? { slack_team_id: slackTeamId } : {},
           requires_mapping_verification: allowedViaThreadReplyException,
+          ...this.botUserId ? { slack_bot_user_id: this.botUserId } : {},
+          ...typeof event.ts === "string" ? { slack_message_ts: event.ts } : {},
+          ...typeof event.thread_ts === "string" ? { slack_thread_ts: event.thread_ts } : typeof event.ts === "string" ? { slack_thread_ts: event.ts } : {},
+          slack_is_thread_reply: isThreadReply,
+          slack_has_mention: hasMention,
+          slack_event_type: eventType,
           ...slackUserEmail ? { slack_user_email: slackUserEmail } : {},
           ...slackUserDisplayName ? { slack_user_name: slackUserDisplayName } : {},
           ...slackChannelName ? { slack_channel_name: slackChannelName } : {},
@@ -995,9 +1529,7 @@ var SlackConnector = class _SlackConnector {
         }
       });
     });
-    console.log("[slack] Starting Socket Mode client...");
     await this.socketMode.start();
-    console.log("[slack] Socket Mode client connected successfully!");
   }
   /**
    * Stop Socket Mode listener
@@ -1013,18 +1545,310 @@ var SlackConnector = class _SlackConnector {
    *
    * Returns `{ text, blocks? }`. `text` is the mrkdwn fallback used for
    * notifications and clients that don't render Block Kit; `blocks` is set
-   * when the message contains a GFM table that we can emit as a native
-   * Block Kit `table` block (or a monospace section fallback alongside one).
+   * when the message contains tables that can benefit from Slack's native
+   * markdown/table blocks.
    */
   formatMessage(markdown) {
     return markdownToSlackPayload(markdown);
   }
 };
 
+// src/gateway/connectors/teams.ts
+import { createServer } from "http";
+import { BotFrameworkAdapter, TurnContext } from "botbuilder";
+function parseThreadId3(threadId) {
+  const lastPipe = threadId.lastIndexOf("|");
+  if (lastPipe === -1) {
+    throw new Error(
+      `Invalid Teams thread ID format: "${threadId}" (expected "{conversationId}|{activityId}")`
+    );
+  }
+  const conversationId = threadId.substring(0, lastPipe);
+  const activityId = threadId.substring(lastPipe + 1);
+  if (!conversationId || !activityId) {
+    throw new Error(
+      `Invalid Teams thread ID format: "${threadId}" (expected "{conversationId}|{activityId}")`
+    );
+  }
+  return { conversationId, activityId };
+}
+function stripMention2(text, botName) {
+  const escaped = botName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<at>${escaped}</at>\\s*`, "gi");
+  return text.replace(pattern, "").trim();
+}
+function hasActiveMention3(text, botName) {
+  const stripped = text.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "");
+  const escaped = botName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<at>${escaped}</at>`, "i");
+  return pattern.test(stripped);
+}
+function stripHtmlTags(text) {
+  return text.replace(/<[^>]+>/g, "");
+}
+function extractQuotedReplyText(attachments) {
+  if (!attachments) return null;
+  for (const attachment of attachments) {
+    if (attachment.contentType !== "text/html" || !attachment.content) continue;
+    if (!attachment.content.includes("schema.skype.com/Reply")) continue;
+    const afterQuote = attachment.content.split("</blockquote>").pop();
+    if (!afterQuote) continue;
+    const text = stripHtmlTags(afterQuote).trim();
+    if (text) return text;
+  }
+  return null;
+}
+function wrapResponse(res) {
+  const wrapped = res;
+  wrapped.status = (code) => {
+    res.statusCode = code;
+    return res;
+  };
+  wrapped.send = (body) => {
+    if (body !== void 0 && body !== null) {
+      const bodyStr = typeof body === "string" ? body : JSON.stringify(body);
+      res.setHeader("Content-Type", "application/json");
+      res.end(bodyStr);
+    } else {
+      res.end();
+    }
+  };
+  return wrapped;
+}
+var TeamsConnector = class {
+  channelType = "teams";
+  adapter;
+  config;
+  server = null;
+  /** Stored ConversationReferences for proactive messaging, keyed by threadId */
+  conversationRefs = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+    if (!this.config.app_id) {
+      throw new Error("Teams connector requires app_id in config");
+    }
+    if (!this.config.app_password) {
+      throw new Error("Teams connector requires app_password in config");
+    }
+    this.adapter = new BotFrameworkAdapter({
+      appId: this.config.app_id,
+      appPassword: this.config.app_password,
+      ...this.config.tenant_id ? { channelAuthTenant: this.config.tenant_id } : {}
+    });
+  }
+  /**
+   * Send a message to a Teams thread using a stored ConversationReference.
+   *
+   * Uses the proactive messaging pattern: look up the stored reference
+   * from the inbound turn, then use adapter.continueConversation() to
+   * send a message outside of a turn.
+   */
+  async sendMessage(req) {
+    const ref = this.conversationRefs.get(req.threadId);
+    if (!ref) {
+      throw new Error(
+        `No ConversationReference stored for thread ${req.threadId}. Cannot send proactive message before receiving an inbound message.`
+      );
+    }
+    let sentActivityId = "";
+    await this.adapter.continueConversation(ref, async (turnContext) => {
+      const response = await turnContext.sendActivity(req.text);
+      sentActivityId = response?.id ?? "";
+    });
+    return sentActivityId;
+  }
+  /**
+   * Start listening for inbound messages via an HTTP webhook.
+   *
+   * Creates a lightweight HTTP server that receives Bot Framework activities
+   * from Azure Bot Service, processes them, and calls the gateway callback.
+   */
+  async startListening(callback) {
+    const port = this.config.webhook_port ?? 3978;
+    const path = this.config.webhook_path ?? "/api/messages";
+    const requireMention = this.config.require_mention ?? true;
+    const allowThreadRepliesWithoutMention = this.config.allow_thread_replies_without_mention ?? true;
+    let botName = null;
+    this.server = createServer((req, res) => {
+      if (req.method !== "POST" || req.url !== path) {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      const bodyChunks = [];
+      req.on("data", (chunk) => bodyChunks.push(chunk));
+      req.on("end", () => {
+        const bodyStr = Buffer.concat(bodyChunks).toString("utf-8");
+        let body;
+        try {
+          body = JSON.parse(bodyStr);
+        } catch {
+          res.statusCode = 400;
+          res.end("Invalid JSON");
+          return;
+        }
+        req.body = body;
+        this.adapter.processActivity(
+          req,
+          wrapResponse(res),
+          async (turnContext) => {
+            const activity = turnContext.activity;
+            if (activity.type !== "message") {
+              return;
+            }
+            if (activity.from?.id === this.config.app_id) {
+              return;
+            }
+            const ref = TurnContext.getConversationReference(activity);
+            if (!botName && activity.recipient?.name) {
+              botName = activity.recipient.name;
+              console.log(`[teams] Bot name resolved: "${botName}"`);
+            }
+            const conversationType = activity.conversation?.conversationType;
+            const isPersonal = conversationType === "personal";
+            const isThreadReply = !isPersonal && !!activity.replyToId;
+            const rawConversationId = activity.conversation?.id ?? "";
+            const replyToId = activity.replyToId;
+            let threadId;
+            if (isPersonal) {
+              threadId = rawConversationId;
+            } else {
+              let baseConversationId = rawConversationId;
+              let messageIdFromConv;
+              const msgIdIdx = rawConversationId.indexOf(";messageid=");
+              if (msgIdIdx !== -1) {
+                baseConversationId = rawConversationId.substring(0, msgIdIdx);
+                messageIdFromConv = rawConversationId.substring(msgIdIdx + ";messageid=".length);
+              }
+              const rootId = messageIdFromConv ?? replyToId ?? activity.id ?? "";
+              threadId = `${baseConversationId}|${rootId}`;
+            }
+            this.conversationRefs.set(threadId, ref);
+            const quotedReplyText = extractQuotedReplyText(
+              activity.attachments
+            );
+            let messageText = quotedReplyText ?? activity.text ?? "";
+            let hasMention = false;
+            if (activity.entities) {
+              for (const entity of activity.entities) {
+                if (entity.type !== "mention") continue;
+                const mentioned = entity.mentioned;
+                const mentionedId = mentioned?.id ?? "";
+                const isBotMention = mentionedId === this.config.app_id || mentionedId.includes(this.config.app_id);
+                if (!isBotMention) continue;
+                hasMention = true;
+                const mentionText = entity.text;
+                if (mentionText && messageText.includes(mentionText)) {
+                  messageText = messageText.replace(mentionText, "").trim();
+                }
+              }
+            }
+            if (!hasMention) {
+              const allBotNames = /* @__PURE__ */ new Set();
+              if (botName) allBotNames.add(botName);
+              if (activity.recipient?.name) allBotNames.add(activity.recipient.name);
+              for (const name of allBotNames) {
+                if (hasActiveMention3(messageText, name)) {
+                  hasMention = true;
+                  messageText = stripMention2(messageText, name);
+                }
+              }
+            }
+            messageText = stripHtmlTags(messageText).trim();
+            if (!messageText) {
+              return;
+            }
+            if (!isPersonal && requireMention) {
+              if (!hasMention) {
+                if (isThreadReply && allowThreadRepliesWithoutMention) {
+                } else {
+                  return;
+                }
+              }
+            }
+            const userName = activity.from?.name;
+            const userAadObjectId = activity.from?.aadObjectId;
+            const channelData = activity.channelData;
+            const teamName = channelData?.team?.name;
+            const channelName = channelData?.channel?.name;
+            const tenantId = channelData?.tenant?.id;
+            callback({
+              threadId,
+              text: messageText,
+              userId: activity.from?.id ?? "unknown",
+              timestamp: activity.timestamp?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
+              metadata: {
+                teams_conversation_type: conversationType,
+                teams_channel_name: channelName,
+                teams_team_name: teamName,
+                teams_user_name: userName,
+                teams_user_aad_id: userAadObjectId,
+                teams_tenant_id: tenantId,
+                requires_mapping_verification: !hasMention && isThreadReply
+              }
+            });
+          }
+        );
+      });
+    });
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        reject(new Error("Server not created"));
+        return;
+      }
+      this.server.on("error", (err) => {
+        console.error(`[teams] HTTP server error:`, err);
+        reject(err);
+      });
+      this.server.listen(port, () => {
+        console.log(`[teams] Webhook server listening on port ${port} at ${path}`);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Stop the HTTP webhook server
+   */
+  async stopListening() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server?.close(() => {
+          console.log("[teams] Webhook server stopped");
+          this.server = null;
+          resolve();
+        });
+      });
+    }
+  }
+  /**
+   * Convert markdown to Teams-compatible format.
+   *
+   * Teams natively supports most markdown (bold, italic, code blocks, links, lists).
+   * Main adjustments:
+   * - Collapse <details>/<summary> blocks (not supported in Teams)
+   * - Strip unsupported HTML tags
+   */
+  formatMessage(markdown) {
+    let text = markdown;
+    text = text.replace(
+      /<details>\s*<summary>([\s\S]*?)<\/summary>\s*([\s\S]*?)<\/details>/gi,
+      (_match, summary, content) => {
+        const summaryText = summary.trim();
+        const contentText = content.trim();
+        return `**${summaryText}**
+${contentText}`;
+      }
+    );
+    text = stripHtmlTags(text);
+    return text.trim();
+  }
+};
+
 // src/gateway/connector-registry.ts
 var connectors = /* @__PURE__ */ new Map();
 connectors.set("slack", (config) => new SlackConnector(config));
 connectors.set("github", (config) => new GitHubConnector(config));
+connectors.set("teams", (config) => new TeamsConnector(config));
 function getConnector(channelType, config) {
   const factory = connectors.get(channelType);
   if (!factory) {
@@ -1039,13 +1863,91 @@ function hasConnector(channelType) {
   return connectors.has(channelType);
 }
 
+// src/gateway/connectors/slack-manifest.ts
+function hasChannelLikeSurface(opts) {
+  return opts.publicChannels || opts.privateChannels || opts.groupDms;
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+function requiredBotScopes(opts) {
+  const scopes = ["chat:write", "im:history", "im:read", "users:read"];
+  if (hasChannelLikeSurface(opts)) {
+    scopes.push("app_mentions:read");
+  }
+  if (opts.publicChannels) {
+    scopes.push("channels:history", "channels:read");
+  }
+  if (opts.privateChannels) {
+    scopes.push("groups:history", "groups:read");
+  }
+  if (opts.groupDms) {
+    scopes.push("mpim:history", "mpim:read");
+  }
+  if (opts.alignUsers) {
+    scopes.push("users:read.email");
+  }
+  if (opts.outbound) {
+    scopes.push(
+      "chat:write.public",
+      "channels:read",
+      "groups:read",
+      "im:write",
+      "users:read.email"
+    );
+  }
+  return sortedUnique(scopes);
+}
+function requiredBotEvents(opts) {
+  const events = ["message.im"];
+  if (hasChannelLikeSurface(opts)) {
+    events.push("app_mention");
+  }
+  return sortedUnique(events);
+}
+function buildSlackManifest(opts) {
+  return {
+    display_information: {
+      name: opts.appName
+    },
+    features: {
+      bot_user: {
+        display_name: opts.botDisplayName ?? opts.appName,
+        always_online: true
+      },
+      app_home: {
+        messages_tab_enabled: true,
+        messages_tab_read_only_enabled: false,
+        home_tab_enabled: false
+      }
+    },
+    oauth_config: {
+      scopes: {
+        bot: requiredBotScopes(opts)
+      }
+    },
+    settings: {
+      event_subscriptions: {
+        bot_events: requiredBotEvents(opts)
+      },
+      interactivity: {
+        is_enabled: false
+      },
+      org_deploy_enabled: false,
+      socket_mode_enabled: true,
+      token_rotation_enabled: false
+    }
+  };
+}
+
 // src/gateway/context.ts
 var PLATFORM_LABELS = {
   slack: "Slack",
   discord: "Discord",
   github: "GitHub",
   whatsapp: "WhatsApp",
-  telegram: "Telegram"
+  telegram: "Telegram",
+  teams: "Microsoft Teams"
 };
 function formatGatewayContext(ctx) {
   const label = PLATFORM_LABELS[ctx.platform] ?? ctx.platform;
@@ -1082,23 +1984,75 @@ function formatGatewayContext(ctx) {
 `;
 }
 
+// src/types/id.ts
+var SHORT_ID_LENGTH = 24;
+function toShortId(id, length = SHORT_ID_LENGTH) {
+  return id.replace(/-/g, "").slice(0, Math.min(length, 32));
+}
+function shortId(id) {
+  return toShortId(id, SHORT_ID_LENGTH);
+}
+
 // src/gateway/system-message.ts
+var GATEWAY_SYSTEM_PREFIX = "Agor:";
+function formatGatewayMarkdownSessionReference(sessionId, sessionUrl) {
+  return sessionUrl ? `[session](${sessionUrl})` : `session ${shortId(sessionId)}`;
+}
+function formatGatewaySessionCreatedMessage(sessionId, sessionUrl) {
+  return sessionUrl ? `Session created: ${sessionUrl}` : `Session ${shortId(sessionId)} created, sending prompt to agent.`;
+}
+function formatGatewayFollowUpRoutingMessage(sessionId, sessionUrl) {
+  return `Mention received \u2014 routing to ${formatGatewayMarkdownSessionReference(sessionId, sessionUrl)}.`;
+}
 function formatGatewaySystemMessage(channelType, text) {
   const sessionCreatedMatch = text.match(/^Session created: (https?:\/\/\S+)$/);
+  const slackMentionGuidance = "Mention me again to follow up.";
   if (channelType === "slack") {
-    const markdown = sessionCreatedMatch ? `[system] Session created: [View session](${sessionCreatedMatch[1]})` : `[system] ${text}`;
+    const markdown = sessionCreatedMatch ? `${GATEWAY_SYSTEM_PREFIX} Session created: [View session](${sessionCreatedMatch[1]}). ${slackMentionGuidance}` : text.startsWith("Session ") && text.includes(" created, sending prompt to agent.") ? `${GATEWAY_SYSTEM_PREFIX} ${text} ${slackMentionGuidance}` : text.startsWith("Mention received") ? `${GATEWAY_SYSTEM_PREFIX} ${text} ${slackMentionGuidance}` : `${GATEWAY_SYSTEM_PREFIX} ${text}`;
     return markdownToMrkdwn(markdown);
   }
-  return `[system] ${text}`;
+  return `${GATEWAY_SYSTEM_PREFIX} ${text}`;
+}
+function formatGatewaySystemPayload(channelType, text) {
+  const formatted = formatGatewaySystemMessage(channelType, text);
+  if (channelType !== "slack") {
+    return { text: formatted };
+  }
+  return {
+    text: formatted,
+    blocks: [
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: formatted
+          }
+        ]
+      }
+    ]
+  };
 }
 export {
   GitHubConnector,
   SlackConnector,
+  TeamsConnector,
+  buildSlackManifest,
+  extractQuotedReplyText,
   formatGatewayContext,
+  formatGatewayFollowUpRoutingMessage,
+  formatGatewayMarkdownSessionReference,
+  formatGatewaySessionCreatedMessage,
   formatGatewaySystemMessage,
+  formatGatewaySystemPayload,
   getConnector,
   hasConnector,
+  isChannelAllowedByWhitelist,
+  markdownToMrkdwn,
   normalizeOutbound,
   parseThreadId as parseGitHubThreadId,
-  registerConnector
+  parseThreadId3 as parseTeamsThreadId,
+  registerConnector,
+  requiredBotEvents,
+  requiredBotScopes
 };