agor-live 0.22.0 → 0.23.1

package/dist/core/gateway/index.js

@@ -377,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 = [];
@@ -581,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;
@@ -620,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.
    *
@@ -672,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.
    *
@@ -883,6 +1089,170 @@ 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;
@@ -955,7 +1325,7 @@ 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) {
@@ -981,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)) {
@@ -1049,22 +1418,29 @@ var SlackConnector = class _SlackConnector {
       }
       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) {
           return;
         }
-        if (eventType === "app_mention" && !requireMention) {
-          return;
-        }
       }
-      if (isChannelMessage && botMentionPattern) {
+      if (isChannelLikeMessage && botMentionPattern) {
         const mentionOutsideCodeBlock = hasActiveMention2(event.text ?? "", botMentionPattern);
         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) {
@@ -1075,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;
@@ -1096,15 +1471,14 @@ 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)) {
@@ -1139,6 +1513,12 @@ var SlackConnector = class _SlackConnector {
           ...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 } : {},
@@ -1483,6 +1863,83 @@ 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",
@@ -1542,15 +1999,16 @@ 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...`;
+  return sessionUrl ? `Session created: ${sessionUrl}` : `Session ${shortId(sessionId)} created, sending prompt to agent.`;
 }
 function formatGatewayFollowUpRoutingMessage(sessionId, sessionUrl) {
-  return `Follow-up received \u2014 routing to ${formatGatewayMarkdownSessionReference(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 ? `${GATEWAY_SYSTEM_PREFIX} Session created: [View session](${sessionCreatedMatch[1]})` : `${GATEWAY_SYSTEM_PREFIX} ${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 `${GATEWAY_SYSTEM_PREFIX} ${text}`;
@@ -1579,6 +2037,7 @@ export {
   GitHubConnector,
   SlackConnector,
   TeamsConnector,
+  buildSlackManifest,
   extractQuotedReplyText,
   formatGatewayContext,
   formatGatewayFollowUpRoutingMessage,
@@ -1588,9 +2047,12 @@ export {
   formatGatewaySystemPayload,
   getConnector,
   hasConnector,
+  isChannelAllowedByWhitelist,
   markdownToMrkdwn,
   normalizeOutbound,
   parseThreadId as parseGitHubThreadId,
   parseThreadId3 as parseTeamsThreadId,
-  registerConnector
+  registerConnector,
+  requiredBotEvents,
+  requiredBotScopes
 };

package/dist/core/gateway/system-message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-message.d.ts","sourceRoot":"","sources":["../../src/gateway/system-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKnD;;;;;;;GAOG;AACH,wBAAgB,qCAAqC,CACnD,SAAS,EAAE,SAAS,GAAG,MAAM,EAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,MAAM,CAER;AAED,wBAAgB,kCAAkC,CAChD,SAAS,EAAE,SAAS,GAAG,MAAM,EAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,MAAM,CAIR;AAED,wBAAgB,mCAAmC,CACjD,SAAS,EAAE,SAAS,GAAG,MAAM,EAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,MAAM,CAER;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAYzF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,GACX,eAAe,CAqBjB"}
+{"version":3,"file":"system-message.d.ts","sourceRoot":"","sources":["../../src/gateway/system-message.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAKnD;;;;;;;GAOG;AACH,wBAAgB,qCAAqC,CACnD,SAAS,EAAE,SAAS,GAAG,MAAM,EAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,MAAM,CAER;AAED,wBAAgB,kCAAkC,CAChD,SAAS,EAAE,SAAS,GAAG,MAAM,EAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,MAAM,CAIR;AAED,wBAAgB,mCAAmC,CACjD,SAAS,EAAE,SAAS,GAAG,MAAM,EAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,MAAM,CAER;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAiBzF;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,GACX,eAAe,CAqBjB"}

package/dist/core/git/exec.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/git/exec.ts
+var exec_exports = {};
+module.exports = __toCommonJS(exec_exports);
+__reExport(exec_exports, require("@agor/git"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("@agor/git")
+});

package/dist/core/git/exec.d.ts

@@ -1,7 +1,9 @@
 /**
- * Git helpers that may spawn git or touch managed repo/worktree directories.
- * Daemon code should not import this module for managed-dir operations; route
- * those through packages/executor instead.
+ * Compatibility export for daemon-local operational git helpers.
+ *
+ * The implementation lives in @agor/git so daemon and executor callers do not
+ * drift on ref validation, credential scrubbing, safe-directory handling, or
+ * clone/worktree behavior.
  */
-export * from './index';
+export * from '@agor/git';
 //# sourceMappingURL=exec.d.ts.map

package/dist/core/git/exec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/git/exec.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,cAAc,SAAS,CAAC"}
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/git/exec.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,WAAW,CAAC"}