agor-live 0.22.0 → 0.23.2

package/dist/daemon/services/gateway.js

@@ -1,9 +1,16 @@
 // src/services/gateway.ts
 import { PublicBaseUrlNotConfiguredError, requirePublicBaseUrl } from "@agor/core/config";
 import {
+  BranchRepository,
   GatewayChannelRepository,
+  GatewayOutboundMessageRepository,
+  getCurrentTenantId as getCurrentTenantId2,
+  getHiddenTenantId,
   MCPServerRepository,
-  shortId,
+  runWithoutTenantDatabaseScope as runWithoutTenantDatabaseScope2,
+  runWithTenantDatabaseScope as runWithTenantDatabaseScope2,
+  SessionRepository,
+  shortId as shortId2,
   ThreadSessionMapRepository,
   UserMCPOAuthTokenRepository,
   UsersRepository
@@ -19,8 +26,87 @@ import {
   parseGitHubThreadId
 } from "@agor/core/gateway";
 import { resolveSessionDefaults } from "@agor/core/sessions";
-import { SessionStatus } from "@agor/core/types";
+import { hasMinimumRole as hasMinimumRole2, ROLES as ROLES2, SessionStatus } from "@agor/core/types";
 import { getSessionUrl } from "@agor/core/utils/url";
+
+// src/utils/branch-authorization.ts
+import { shortId } from "@agor/core/db";
+import { Forbidden, NotAuthenticated, NotFound } from "@agor/core/feathers";
+import { BRANCH_PERMISSION_LEVELS, hasMinimumRole, ROLES } from "@agor/core/types";
+function isSuperAdmin(role, allowSuperadmin = true) {
+  if (!allowSuperadmin) return false;
+  return role === ROLES.SUPERADMIN || role === "owner";
+}
+var PERMISSION_RANK = Object.fromEntries(
+  BRANCH_PERMISSION_LEVELS.map((level, i) => [level, i - 1])
+);
+function hasBranchPermission(branch, userId, isOwner, requiredLevel, userRole, allowSuperadmin = true, effectivePermission) {
+  if (isOwner) {
+    return true;
+  }
+  if (isSuperAdmin(userRole, allowSuperadmin)) {
+    return true;
+  }
+  const effectiveLevel = effectivePermission ?? branch.others_can ?? "session";
+  const effectiveRank = PERMISSION_RANK[effectiveLevel];
+  const requiredRank = PERMISSION_RANK[requiredLevel];
+  return effectiveRank >= requiredRank;
+}
+
+// src/utils/tenant-db-scope.ts
+import {
+  resolveMultiTenancyConfig,
+  resolveTenantContext,
+  TenantResolutionError
+} from "@agor/core/config";
+import {
+  enqueueTenantDatabasePostCommitCallback,
+  getCurrentTenantId,
+  runWithoutTenantDatabaseScope,
+  runWithTenantDatabaseScope
+} from "@agor/core/db";
+import { NotAuthenticated as NotAuthenticated2 } from "@agor/core/feathers";
+import jwt2 from "jsonwebtoken";
+
+// src/auth/runtime-tokens.ts
+import jwt from "jsonwebtoken";
+
+// src/utils/tenant-db-scope.ts
+function resolveTenantIdForDeferredScope(params) {
+  const scopedParams = params;
+  return scopedParams?.tenant?.tenant_id ?? getCurrentTenantId();
+}
+function deferWithTenantDatabaseScope(db, params, work, onError) {
+  const tenantId = resolveTenantIdForDeferredScope(params);
+  if (!tenantId) {
+    const error = new Error("Missing tenant context for deferred tenant-scoped work");
+    if (onError) {
+      onError(error);
+    } else {
+      console.error("[tenant-db-scope] Deferred tenant-scoped work skipped:", error);
+    }
+    return;
+  }
+  const schedule = () => {
+    runWithoutTenantDatabaseScope(() => {
+      setImmediate(() => {
+        void runWithTenantDatabaseScope(db, tenantId, work).catch((error) => {
+          if (onError) {
+            onError(error);
+            return;
+          }
+          console.error("[tenant-db-scope] Deferred tenant-scoped work failed:", error);
+        });
+      });
+    });
+  };
+  if (enqueueTenantDatabasePostCommitCallback(async () => schedule())) {
+    return;
+  }
+  schedule();
+}
+
+// src/services/gateway.ts
 function hasListeningConfig(channel) {
   const config = channel.config;
   switch (channel.channel_type) {
@@ -34,9 +120,155 @@ function hasListeningConfig(channel) {
       return false;
   }
 }
+function tenantIdFromGatewayChannel(channel) {
+  return getHiddenTenantId(channel);
+}
 function isSlackThinkingPlaceholder(text) {
   return /^thinking\s*\.{3}$/i.test(text.trim());
 }
+function parseSlackOutboundTarget(target) {
+  const trimmed = target.trim();
+  const channelMatch = /^channel:([^:\s]+)$/.exec(trimmed);
+  if (channelMatch) {
+    return { kind: "channel_id", channel: channelMatch[1] };
+  }
+  const channelNameMatch = /^channel_name:([^\s]+)$/.exec(trimmed);
+  if (channelNameMatch) {
+    return { kind: "channel_name", name: channelNameMatch[1].replace(/^#/, "") };
+  }
+  if (/^#[^\s]+$/.test(trimmed)) {
+    return { kind: "channel_name", name: trimmed.slice(1) };
+  }
+  const emailMatch = /^(?:email:|user_email:)?([^@\s]+@[^@\s]+\.[^@\s]+)$/.exec(trimmed);
+  if (emailMatch) {
+    return { kind: "email", email: emailMatch[1] };
+  }
+  throw new Error(
+    "Invalid Slack outbound target. Expected channel:C123, #channel-name, channel_name:channel-name, or user@example.com"
+  );
+}
+function redactProviderErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/xox[baprs]-[A-Za-z0-9-]+/g, "[redacted-slack-token]").replace(/xapp-[A-Za-z0-9-]+/g, "[redacted-slack-token]");
+}
+function previewText(text, maxChars = 500) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+function quoteForPrompt(text, maxChars = 2e3) {
+  const truncated = text.length <= maxChars ? text : `${text.slice(0, maxChars - 1)}\u2026`;
+  return truncated.split(/\r?\n/).map((line) => `> ${line}`).join("\n");
+}
+function getSlackMessageTs(metadata) {
+  return typeof metadata?.slack_message_ts === "string" ? metadata.slack_message_ts : void 0;
+}
+function compareSlackTs(a, b) {
+  if (!a && !b) return 0;
+  if (!a) return -1;
+  if (!b) return 1;
+  const na = Number(a);
+  const nb = Number(b);
+  if (Number.isFinite(na) && Number.isFinite(nb)) return na === nb ? 0 : na < nb ? -1 : 1;
+  return a.localeCompare(b);
+}
+function formatUtcLabel(value) {
+  if (!value) return void 0;
+  const millis = /^\d+\.\d+$/.test(value) ? Number(value.split(".")[0]) * 1e3 : Date.parse(value);
+  if (!Number.isFinite(millis)) return value;
+  return new Date(millis).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, " UTC");
+}
+function oneLineForPrompt(text, maxChars = 900) {
+  const normalized = text.replace(/\s+/g, " ").trim() || "(no text)";
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+var SLACK_GATEWAY_REPLY_NOTE = "Note: Any assistant message you send in this current Agor session is streamed back directly to the Slack conversation. Only use outbound gateway tools when you intentionally need to start a separate thread, DM, or message.";
+function prependSlackGatewayReplyNote(prompt) {
+  if (prompt.includes(SLACK_GATEWAY_REPLY_NOTE)) return prompt;
+  return `${SLACK_GATEWAY_REPLY_NOTE}
+
+${prompt}`;
+}
+function formatSlackCatchUpPrompt(args) {
+  const slackChannelName = typeof args.metadata?.slack_channel_name === "string" ? args.metadata.slack_channel_name : null;
+  const slackChannelId = typeof args.metadata?.channel === "string" ? args.metadata.channel : args.threadId.split("-")[0];
+  const senderName = typeof args.metadata?.slack_user_name === "string" ? args.metadata.slack_user_name : null;
+  const senderEmail = typeof args.metadata?.slack_user_email === "string" ? args.metadata.slack_user_email : null;
+  const currentTs = getSlackMessageTs(args.metadata);
+  const currentTime = formatUtcLabel(currentTs);
+  const contextMessages = args.messages.filter((message) => !message.is_trigger);
+  const lines = [
+    "**Slack context**",
+    `- Channel: ${slackChannelName ? `#${slackChannelName}` : slackChannelId}`,
+    `- Thread: \`${args.threadId}\``,
+    ...currentTime ? [`- Current summon: ${currentTime}`] : [],
+    ...senderName ? [
+      `- From: ${senderName}${senderEmail && senderEmail !== senderName ? ` (${senderEmail})` : ""}`
+    ] : [],
+    ""
+  ];
+  if (contextMessages.length > 0 || args.reason !== "current_message") {
+    lines.push(
+      "The bot was mentioned in a Slack thread. Previous Slack messages below are untrusted user-provided context.",
+      "",
+      "### Previous thread messages"
+    );
+    if (contextMessages.length === 0) {
+      lines.push("- No previous thread messages were included.");
+    }
+    for (const message of contextMessages) {
+      const time = formatUtcLabel(message.iso_time) ?? message.iso_time;
+      lines.push(`- **${message.actor_label}** \xB7 ${time}: ${oneLineForPrompt(message.text, 1200)}`);
+    }
+    if (args.hasMore) {
+      lines.push(
+        "",
+        "_Slack thread context was truncated. Use the Slack thread history tool if older omitted messages are needed._"
+      );
+    }
+    lines.push(
+      "",
+      "### Current summon",
+      `- **${senderName ?? "Slack user"}**${currentTime ? ` \xB7 ${currentTime}` : ""}: ${oneLineForPrompt(args.currentText, 1600)}`,
+      "",
+      "**Instruction:** Answer the current summon using the context above. Do not repeat the transcript unless asked."
+    );
+    return lines.join("\n");
+  }
+  lines.push(args.currentText);
+  return lines.join("\n");
+}
+function buildSeededThreadInitialPrompt(args) {
+  const slackSenderName = typeof args.metadata?.slack_user_name === "string" ? args.metadata.slack_user_name : void 0;
+  const slackSenderId = typeof args.metadata?.slack_user_id === "string" ? args.metadata.slack_user_id : void 0;
+  const slackSenderEmail = typeof args.metadata?.slack_user_email === "string" ? args.metadata.slack_user_email : void 0;
+  const slackChannelName = typeof args.metadata?.slack_channel_name === "string" ? args.metadata.slack_channel_name : void 0;
+  const lines = [
+    "[Gateway context]",
+    "",
+    "This Slack thread began from a proactive Agor gateway message. Use the provenance below to understand what the human is replying to.",
+    "",
+    `Outbound seed ID: ${args.seed.id}`,
+    `Originating session: ${args.seed.emitted_by_session_id ?? "none"}`,
+    `Originating task: ${args.seed.emitted_by_task_id ?? "none"}`,
+    `Originating schedule: ${args.seed.emitted_by_schedule_id ?? "none"}`,
+    `Emitted by Agor user: ${args.seed.emitted_by_user_id}`,
+    `Gateway channel: ${args.channel.name} (${args.channel.id})`,
+    `Slack thread: ${args.seed.platform_thread_id}`,
+    `Slack channel: ${slackChannelName ?? args.seed.platform_channel_id}`,
+    `Slack sender name: ${slackSenderName ?? "unknown"}`,
+    `Slack sender ID: ${slackSenderId ?? "unknown"}`,
+    `Slack sender email: ${slackSenderEmail ?? "unknown"}`,
+    "",
+    "Original proactive Agor message:",
+    quoteForPrompt(args.seed.message_text),
+    "",
+    "Human Slack reply:",
+    quoteForPrompt(args.replyText)
+  ];
+  return lines.join("\n");
+}
 function buildGitHubInitialPrompt(threadId, text, metadata) {
   try {
     const { owner, repo, number } = parseGitHubThreadId(threadId);
@@ -139,8 +371,12 @@ function buildGatewayContext(channel, data) {
   }
 }
 var GatewayService = class _GatewayService {
+  db;
   channelRepo;
   threadMapRepo;
+  outboundRepo;
+  branchRepo;
+  sessionRepo;
   usersRepo;
   mcpServerRepo;
   userTokenRepo;
@@ -178,8 +414,12 @@ var GatewayService = class _GatewayService {
   static SLACK_STREAM_STATUS_REFRESH_MS = 300;
   static SLACK_STREAMED_MESSAGE_CACHE_MAX = 500;
   constructor(db, app) {
+    this.db = db;
     this.channelRepo = new GatewayChannelRepository(db);
     this.threadMapRepo = new ThreadSessionMapRepository(db);
+    this.outboundRepo = new GatewayOutboundMessageRepository(db);
+    this.branchRepo = new BranchRepository(db);
+    this.sessionRepo = new SessionRepository(db);
     this.usersRepo = new UsersRepository(db);
     this.mcpServerRepo = new MCPServerRepository(db);
     this.userTokenRepo = new UserMCPOAuthTokenRepository(db);
@@ -228,6 +468,12 @@ var GatewayService = class _GatewayService {
     if (!channelId || !messageTs) return null;
     return `${channelId}-${messageTs}`;
   }
+  isSlackChannelLikeThreadId(threadId) {
+    const lastHyphen = threadId.lastIndexOf("-");
+    if (lastHyphen === -1) return false;
+    const channelId = threadId.slice(0, lastHyphen);
+    return !!channelId && !channelId.startsWith("D");
+  }
   async addSlackThreadAlias(mapping, messageTs, reason) {
     const aliasThreadId = this.makeSlackThreadIdForMessage(mapping.thread_id, messageTs);
     if (!aliasThreadId || aliasThreadId === mapping.thread_id) return;
@@ -435,6 +681,24 @@ var GatewayService = class _GatewayService {
       }
     }
   }
+  /**
+   * Schedule Slack assistant progress/status updates after the current
+   * tenant-scoped database work commits, then update inside a fresh tenant
+   * scope. Presence/status updates are often emitted from hooks and streaming
+   * routes whose enclosing transaction is about to close.
+   */
+  updateProgressAfterCommit(data, params) {
+    deferWithTenantDatabaseScope(
+      this.db,
+      params,
+      async () => {
+        await this.updateProgress(data);
+      },
+      (error) => {
+        console.warn("[gateway] Failed to update Slack progress after commit:", error);
+      }
+    );
+  }
   wasMessageStreamedToSlack(messageId) {
     return this.slackStreamedMessageIds.has(messageId);
   }
@@ -566,6 +830,9 @@ var GatewayService = class _GatewayService {
     try {
       const metadata = mapping.metadata ?? {};
       const slackThreadId = this.getActiveSlackThreadId(mapping);
+      if (this.isSlackChannelLikeThreadId(slackThreadId)) {
+        return;
+      }
       const recipientUserId = typeof metadata.slack_user_id === "string" ? metadata.slack_user_id : void 0;
       const recipientTeamId = typeof metadata.slack_team_id === "string" ? metadata.slack_team_id : void 0;
       if (event === "streaming:chunk") {
@@ -648,6 +915,157 @@ ${chunk}` : chunk;
       console.warn("[gateway] Failed to mirror message stream to Slack:", error);
     }
   }
+  /**
+   * Session-context emits are hard-bound to the session's branch, with no
+   * admin-role bypass — agent sessions run as admin users, so a role bypass
+   * would let any session impersonate another assistant's channel. The error
+   * deliberately never echoes the channel's target branch, so a denied emit
+   * cannot be used to enumerate which branch a foreign channel serves.
+   */
+  async ensureSessionBranchBoundToChannel(channel, sessionId) {
+    const session = await this.sessionRepo.findById(sessionId);
+    if (!session) {
+      throw new Error("Gateway outbound denied: emitting session not found");
+    }
+    if (session.branch_id !== channel.target_branch_id) {
+      throw new Error(
+        `Gateway outbound denied: session ${shortId2(sessionId)} runs on branch ${shortId2(session.branch_id)}, but this channel targets a different branch. Sessions can emit only through gateway channels whose target branch matches their own. Call agor_gateway_outbound_targets_list to see usable channels.`
+      );
+    }
+  }
+  async ensureCanEmitFromChannel(channel, userId, userRole) {
+    if (hasMinimumRole2(userRole, ROLES2.ADMIN)) return;
+    const branch = await this.branchRepo.findById(channel.target_branch_id);
+    if (!branch) {
+      throw new Error(`Branch not found for gateway channel ${shortId2(channel.id)}`);
+    }
+    const isOwner = await this.branchRepo.isOwner(branch.branch_id, userId);
+    const effectivePermission = await this.branchRepo.resolveUserPermission(branch, userId);
+    const canEmit = hasBranchPermission(
+      branch,
+      userId,
+      isOwner,
+      "all",
+      userRole,
+      true,
+      effectivePermission
+    );
+    if (!canEmit) {
+      throw new Error(
+        "Insufficient branch permission: gateway outbound emits require branch all permission or admin access"
+      );
+    }
+  }
+  async emitMessage(data) {
+    const channel = await this.channelRepo.findById(data.gatewayChannelId);
+    if (!channel) throw new Error("Gateway channel not found");
+    if (!channel.enabled) throw new Error("Gateway channel is disabled");
+    if (channel.channel_type !== "slack")
+      throw new Error("Gateway outbound v0 only supports Slack channels");
+    const config = channel.config;
+    if (config.outbound_enabled !== true) {
+      throw new Error("Gateway outbound is disabled for this channel");
+    }
+    if (data.emittedBySessionId) {
+      await this.ensureSessionBranchBoundToChannel(channel, data.emittedBySessionId);
+    }
+    await this.ensureCanEmitFromChannel(channel, data.emittedByUserId, data.userRole);
+    const target = data.target ?? (typeof config.default_outbound_target === "string" ? config.default_outbound_target : void 0);
+    if (!target) throw new Error("No usable default outbound target configured");
+    const parsedTarget = parseSlackOutboundTarget(target);
+    const connector = getConnector(
+      channel.channel_type,
+      channel.config
+    );
+    if (typeof connector.sendSlackMessage !== "function") {
+      throw new Error("Slack connector does not support direct outbound sends");
+    }
+    const { text, blocks } = normalizeOutbound(
+      connector.formatMessage ? connector.formatMessage(data.message) : data.message
+    );
+    let resolvedChannel;
+    const resolvedTargetMetadata = {
+      target,
+      target_kind: parsedTarget.kind
+    };
+    if (parsedTarget.kind === "channel_id") {
+      resolvedChannel = parsedTarget.channel;
+    } else if (parsedTarget.kind === "channel_name") {
+      if (typeof connector.resolveChannelByName !== "function") {
+        throw new Error("Slack connector does not support channel-name resolution");
+      }
+      let resolved;
+      try {
+        resolved = await connector.resolveChannelByName(parsedTarget.name);
+      } catch (error) {
+        throw new Error(`Slack API failure: ${redactProviderErrorMessage(error)}`);
+      }
+      resolvedChannel = resolved.channel;
+      resolvedTargetMetadata.resolved_channel_id = resolved.channel;
+      resolvedTargetMetadata.resolved_channel_name = resolved.name;
+    } else {
+      if (typeof connector.openDmByEmail !== "function") {
+        throw new Error("Slack connector does not support email-to-DM resolution");
+      }
+      let resolved;
+      try {
+        resolved = await connector.openDmByEmail(parsedTarget.email);
+      } catch (error) {
+        throw new Error(`Slack API failure: ${redactProviderErrorMessage(error)}`);
+      }
+      resolvedChannel = resolved.channel;
+      resolvedTargetMetadata.resolved_channel_id = resolved.channel;
+      resolvedTargetMetadata.resolved_user_id = resolved.user_id;
+    }
+    let sent;
+    try {
+      sent = await connector.sendSlackMessage({
+        channel: resolvedChannel,
+        text,
+        blocks,
+        metadata: {
+          ...data.purpose ? { purpose: data.purpose } : {},
+          ...resolvedTargetMetadata
+        }
+      });
+    } catch (error) {
+      throw new Error(`Slack API failure: ${redactProviderErrorMessage(error)}`);
+    }
+    const platformThreadId = `${sent.channel}-${sent.thread_ts || sent.ts}`;
+    const row = await this.outboundRepo.create({
+      gateway_channel_id: channel.id,
+      channel_type: "slack",
+      platform_channel_id: sent.channel,
+      platform_message_id: sent.ts,
+      platform_thread_id: platformThreadId,
+      platform_permalink: sent.permalink ?? null,
+      target_branch_id: channel.target_branch_id,
+      emitted_by_user_id: data.emittedByUserId,
+      emitted_by_session_id: data.emittedBySessionId ?? null,
+      emitted_by_task_id: data.emittedByTaskId ?? null,
+      emitted_by_schedule_id: data.emittedByScheduleId ?? null,
+      message_text: data.message,
+      message_preview: previewText(data.message),
+      metadata: {
+        target,
+        ...data.purpose ? { purpose: data.purpose } : {}
+      }
+    });
+    await this.channelRepo.updateLastMessage(channel.id);
+    console.log(
+      `[gateway] Proactive Slack outbound ${shortId2(row.id)} sent via ${shortId2(channel.id)} to ${target}`
+    );
+    return {
+      success: true,
+      gateway_outbound_message_id: row.id,
+      gateway_channel_id: channel.id,
+      channel_type: "slack",
+      platform_channel_id: sent.channel,
+      platform_message_id: sent.ts,
+      platform_thread_id: platformThreadId,
+      ...sent.permalink ? { platform_permalink: sent.permalink } : {}
+    };
+  }
   async fetchExistingSessionUrlForGatewayUser(sessionId, user) {
     try {
       const baseUrl = await requirePublicBaseUrl();
@@ -698,16 +1116,36 @@ ${chunk}` : chunk;
     }
     if (existingMapping && channel.channel_type === "slack") {
       console.log(
-        `[gateway] Slack inbound thread ${data.thread_id} \u2192 session ${shortId(existingMapping.session_id)} (root ${existingMapping.thread_id})`
+        `[gateway] Slack inbound thread ${data.thread_id} \u2192 session ${shortId2(existingMapping.session_id)} (root ${existingMapping.thread_id})`
+      );
+    }
+    const outboundSeed = !existingMapping && channel.channel_type === "slack" ? await this.outboundRepo.findUnconsumedByChannelAndThread(channel.id, data.thread_id) : null;
+    if (outboundSeed) {
+      console.log(
+        `[gateway] Slack inbound thread ${data.thread_id} is replying to outbound seed ${shortId2(outboundSeed.id)}`
       );
     }
-    if (!existingMapping) {
+    if (!existingMapping && channel.channel_type !== "slack") {
       const exactThreadMapping = await this.threadMapRepo.findByThread(data.thread_id);
-      const aliasThreadMapping = channel.channel_type === "slack" ? await this.findSlackThreadAliasMapping(void 0, data.thread_id) : null;
-      const otherChannelMapping = exactThreadMapping && exactThreadMapping.channel_id !== channel.id ? exactThreadMapping : aliasThreadMapping && aliasThreadMapping.channel_id !== channel.id ? aliasThreadMapping : null;
+      const otherChannelMapping = exactThreadMapping && exactThreadMapping.channel_id !== channel.id ? exactThreadMapping : null;
       if (otherChannelMapping) {
         console.log(
-          `[gateway] IGNORED: Thread ${data.thread_id} owned by channel ${shortId(otherChannelMapping.channel_id)}, not ours (${shortId(channel.id)}). Silently dropping.`
+          `[gateway] IGNORED: Thread ${data.thread_id} owned by channel ${shortId2(otherChannelMapping.channel_id)}, not ours (${shortId2(channel.id)}). Silently dropping.`
+        );
+        return {
+          success: false,
+          sessionId: "",
+          created: false
+        };
+      }
+    }
+    if (channel.channel_type === "slack") {
+      const slackConversationType = typeof data.metadata?.channel_type === "string" ? data.metadata.channel_type : void 0;
+      const isSlackDm = slackConversationType === "im";
+      const hasExplicitMention = data.metadata?.slack_has_mention === true;
+      if (!isSlackDm && !hasExplicitMention) {
+        console.debug(
+          `[gateway] IGNORED: Slack channel-like message without explicit mention: channel=${shortId2(channel.id)}, thread=${data.thread_id}`
         );
         return {
           success: false,
@@ -716,9 +1154,9 @@ ${chunk}` : chunk;
         };
       }
     }
-    if (!existingMapping && data.metadata?.requires_mapping_verification) {
+    if (!existingMapping && !outboundSeed && data.metadata?.requires_mapping_verification) {
       console.debug(
-        `[gateway] IGNORED: Thread reply without mention in unmapped thread: channel=${shortId(channel.id)}, thread=${data.thread_id}`
+        `[gateway] IGNORED: Thread reply without mention in unmapped thread: channel=${shortId2(channel.id)}, thread=${data.thread_id}`
       );
       return {
         success: false,
@@ -764,7 +1202,7 @@ ${chunk}` : chunk;
         const matchedUser = await this.usersRepo.findByEmailForAlignment(email);
         if (matchedUser) {
           console.log(
-            `[gateway] Slack user aligned: ${email} \u2192 Agor user ${shortId(matchedUser.user_id)} (${matchedUser.name || matchedUser.email})`
+            `[gateway] Slack user aligned: ${email} \u2192 Agor user ${shortId2(matchedUser.user_id)} (${matchedUser.name || matchedUser.email})`
           );
           user = await usersService.get(matchedUser.user_id);
         } else {
@@ -805,7 +1243,7 @@ ${chunk}` : chunk;
         const matchedUser = await this.usersRepo.findByEmailForAlignment(mappedEmail);
         if (matchedUser) {
           console.log(
-            `[gateway] GitHub user aligned via user_map: ${githubLogin} \u2192 ${mappedEmail} \u2192 Agor user ${shortId(matchedUser.user_id)}`
+            `[gateway] GitHub user aligned via user_map: ${githubLogin} \u2192 ${mappedEmail} \u2192 Agor user ${shortId2(matchedUser.user_id)}`
           );
           user = await usersService.get(matchedUser.user_id);
           resolved = true;
@@ -821,7 +1259,7 @@ ${chunk}` : chunk;
           const matchedUser = await this.usersRepo.findByEmailForAlignment(githubEmail);
           if (matchedUser) {
             console.log(
-              `[gateway] GitHub user aligned via email: ${githubLogin} (${githubEmail}) \u2192 Agor user ${shortId(matchedUser.user_id)}`
+              `[gateway] GitHub user aligned via email: ${githubLogin} (${githubEmail}) \u2192 Agor user ${shortId2(matchedUser.user_id)}`
             );
             user = await usersService.get(matchedUser.user_id);
             resolved = true;
@@ -854,6 +1292,7 @@ ${chunk}` : chunk;
     let sessionId;
     let created = false;
     let mcpAuthWarning;
+    let mappingForCursor = existingMapping ?? null;
     const agenticConfig = channel.agentic_config;
     const agenticTool = agenticConfig?.agent ?? "claude-code";
     const {
@@ -877,20 +1316,25 @@ ${chunk}` : chunk;
       sessionId = existingMapping.session_id;
       await this.threadMapRepo.updateLastMessage(existingMapping.id);
       const existingMetadata = existingMapping.metadata ?? {};
-      await this.threadMapRepo.updateMetadata(existingMapping.id, {
+      const mergedMetadata = {
         ...existingMetadata,
         ...data.metadata?.processing_comment_id ? { processing_comment_id: data.metadata.processing_comment_id } : {},
         ...typeof data.metadata?.slack_user_id === "string" ? { slack_user_id: data.metadata.slack_user_id } : {},
         ...typeof data.metadata?.slack_team_id === "string" ? { slack_team_id: data.metadata.slack_team_id } : {},
+        ...typeof data.metadata?.slack_bot_user_id === "string" ? { slack_bot_user_id: data.metadata.slack_bot_user_id } : {},
+        ...typeof data.metadata?.slack_thread_ts === "string" ? { slack_root_ts: data.metadata.slack_thread_ts } : {},
+        ...typeof data.metadata?.channel === "string" ? { slack_channel_id: data.metadata.channel } : {},
         ...channel.channel_type === "slack" ? { slack_active_thread_id: data.thread_id } : {}
-      });
+      };
+      await this.threadMapRepo.updateMetadata(existingMapping.id, mergedMetadata);
+      mappingForCursor = { ...existingMapping, metadata: mergedMetadata };
       if (channel.channel_type === "slack") {
         console.log(
-          `[gateway] Slack active outbound thread for session ${shortId(sessionId)} set to ${data.thread_id}`
+          `[gateway] Slack active outbound thread for session ${shortId2(sessionId)} set to ${data.thread_id}`
         );
       }
       const sessionUrl = await this.fetchExistingSessionUrlForGatewayUser(sessionId, user);
-      if (sessionUrl) {
+      if (sessionUrl && channel.channel_type !== "slack") {
         this.sendSystemMessage(
           channel,
           data.thread_id,
@@ -911,6 +1355,28 @@ ${chunk}` : chunk;
         channel_type: channel.channel_type,
         thread_id: data.thread_id
       };
+      if (outboundSeed) {
+        gatewaySource.outbound_seed_id = outboundSeed.id;
+        gatewaySource.outbound_seed_thread_id = outboundSeed.platform_thread_id;
+        gatewaySource.proactive_seed = true;
+      }
+      if (channel.channel_type === "slack") {
+        if (typeof data.metadata?.slack_team_id === "string") {
+          gatewaySource.slack_team_id = data.metadata.slack_team_id;
+        }
+        if (typeof data.metadata?.channel === "string") {
+          gatewaySource.slack_channel_id = data.metadata.channel;
+        }
+        if (typeof data.metadata?.slack_channel_name === "string") {
+          gatewaySource.slack_channel_name = data.metadata.slack_channel_name;
+        }
+        if (typeof data.metadata?.slack_thread_ts === "string") {
+          gatewaySource.slack_root_ts = data.metadata.slack_thread_ts;
+        }
+        if (typeof data.metadata?.slack_message_ts === "string") {
+          gatewaySource.slack_trigger_ts = data.metadata.slack_message_ts;
+        }
+      }
       if (channel.channel_type === "github") {
         try {
           const parsed = parseGitHubThreadId(data.thread_id);
@@ -973,16 +1439,29 @@ ${chunk}` : chunk;
           console.log(`[gateway] MCP auth warning for: ${unauthedMcpNames.join(", ")}`);
         }
       }
-      await this.threadMapRepo.create({
+      const initialMappingMetadata = channel.channel_type === "slack" ? {
+        ...data.metadata ?? {},
+        slack_active_thread_id: data.thread_id,
+        ...typeof data.metadata?.slack_thread_ts === "string" ? { slack_root_ts: data.metadata.slack_thread_ts } : {},
+        ...typeof data.metadata?.channel === "string" ? { slack_channel_id: data.metadata.channel } : {},
+        ...outboundSeed ? { outbound_seed_id: outboundSeed.id } : {}
+      } : data.metadata ?? null;
+      mappingForCursor = await this.threadMapRepo.create({
         channel_id: channel.id,
         thread_id: data.thread_id,
         session_id: session.session_id,
         branch_id: channel.target_branch_id,
         status: "active",
-        metadata: channel.channel_type === "slack" ? { ...data.metadata ?? {}, slack_active_thread_id: data.thread_id } : data.metadata ?? null
+        metadata: initialMappingMetadata
       });
+      if (outboundSeed) {
+        await this.outboundRepo.markConsumed(
+          outboundSeed.id,
+          session.session_id
+        );
+      }
       const sessionUrl = await this.fetchExistingSessionUrlForGatewayUser(sessionId, user);
-      if (sessionUrl) {
+      if (sessionUrl || channel.channel_type === "slack") {
         this.sendSystemMessage(
           channel,
           data.thread_id,
@@ -992,7 +1471,7 @@ ${chunk}` : chunk;
       if (channel.channel_type === "github" && data.metadata?.processing_comment_id) {
         try {
           const connector = getConnector(channel.channel_type, channel.config);
-          const processingText = sessionUrl ? `\u23F3 Processing... [View session](${sessionUrl})` : `\u23F3 Processing in session \`${shortId(sessionId)}\`...`;
+          const processingText = sessionUrl ? `\u23F3 Processing... [View session](${sessionUrl})` : `\u23F3 Processing in session \`${shortId2(sessionId)}\`...`;
           await connector.sendMessage({
             threadId: data.thread_id,
             text: processingText,
@@ -1007,10 +1486,56 @@ ${chunk}` : chunk;
     try {
       const promptService = this.app.service("/sessions/:id/prompt");
       let promptText = data.text;
-      if (created && channel.channel_type === "github") {
+      let slackCursorTsToWrite;
+      if (channel.channel_type === "slack" && !outboundSeed) {
+        const currentTs = getSlackMessageTs(data.metadata);
+        const mappingMetadata = mappingForCursor?.metadata ?? {};
+        const lastDeliveredTs = typeof mappingMetadata?.slack_last_delivered_ts === "string" ? mappingMetadata.slack_last_delivered_ts : void 0;
+        const connector = this.activeListeners.get(channel.id) ?? getConnector(channel.channel_type, channel.config);
+        const historyConnector = connector;
+        if (currentTs && typeof historyConnector.fetchThreadHistory === "function") {
+          try {
+            const slackHistoryThreadId = mappingForCursor?.thread_id ?? data.thread_id;
+            const history = await historyConnector.fetchThreadHistory({
+              threadId: slackHistoryThreadId,
+              ...created || !lastDeliveredTs ? {} : { oldestTs: lastDeliveredTs },
+              latestTs: currentTs,
+              inclusive: true,
+              limit: 200,
+              includeBotMessages: false,
+              triggerTs: currentTs
+            });
+            const filteredMessages = lastDeliveredTs ? history.messages.filter(
+              (message) => compareSlackTs(message.ts, lastDeliveredTs) > 0
+            ) : history.messages;
+            promptText = formatSlackCatchUpPrompt({
+              channel,
+              threadId: slackHistoryThreadId,
+              currentText: data.text,
+              metadata: data.metadata,
+              messages: filteredMessages.length > 0 ? filteredMessages : history.messages,
+              hasMore: history.has_more,
+              reason: created ? "initial_thread_context" : lastDeliveredTs ? "missed_since_last_mention" : "current_message"
+            });
+            slackCursorTsToWrite = currentTs;
+          } catch (error) {
+            console.warn("[gateway] Failed to fetch Slack thread catch-up context:", error);
+          }
+        } else if (currentTs) {
+          slackCursorTsToWrite = currentTs;
+        }
+      }
+      if (created && outboundSeed) {
+        promptText = buildSeededThreadInitialPrompt({
+          seed: outboundSeed,
+          channel,
+          replyText: data.text,
+          metadata: data.metadata
+        });
+      } else if (created && channel.channel_type === "github") {
         promptText = buildGitHubInitialPrompt(data.thread_id, data.text, data.metadata);
       }
-      const skipContext = created && channel.channel_type === "github";
+      const skipContext = channel.channel_type === "slack" || created && (channel.channel_type === "github" || !!outboundSeed);
       if (!skipContext) {
         const gatewayCtx = buildGatewayContext(channel, data);
         const contextPrefix = formatGatewayContext(gatewayCtx);
@@ -1018,18 +1543,38 @@ ${chunk}` : chunk;
           promptText = contextPrefix + promptText;
         }
       }
+      if (channel.channel_type === "slack") {
+        promptText = prependSlackGatewayReplyNote(promptText);
+      }
       if (created && mcpAuthWarning) {
         promptText = `${mcpAuthWarning}
 
 ${promptText}`;
       }
+      const tenantId = getCurrentTenantId2();
       const task = await promptService.create(
         { prompt: promptText, permissionMode, messageSource: "gateway" },
-        { route: { id: sessionId }, user }
+        {
+          route: { id: sessionId },
+          user,
+          ...tenantId ? { tenant: { tenant_id: tenantId, source: "explicit" } } : {}
+        }
       );
+      if (channel.channel_type === "slack" && slackCursorTsToWrite && mappingForCursor) {
+        const latestMapping = await this.threadMapRepo.findById(mappingForCursor.id);
+        const latestMetadata = latestMapping?.metadata ?? {};
+        const previousDelivered = typeof latestMetadata.slack_last_delivered_ts === "string" ? latestMetadata.slack_last_delivered_ts : void 0;
+        if (compareSlackTs(slackCursorTsToWrite, previousDelivered) >= 0) {
+          await this.threadMapRepo.updateMetadata(mappingForCursor.id, {
+            ...latestMetadata,
+            slack_last_delivered_ts: slackCursorTsToWrite,
+            slack_last_summon_ts: slackCursorTsToWrite
+          });
+        }
+      }
       if (task.status === "queued") {
         console.log(
-          `[gateway] Message queued for session ${shortId(sessionId)} at position ${task.queue_position}`
+          `[gateway] Message queued for session ${shortId2(sessionId)} at position ${task.queue_position}`
         );
         this.sendSystemMessage(
           channel,
@@ -1037,7 +1582,7 @@ ${promptText}`;
           `Session is busy, message queued at position ${task.queue_position}`,
           { suppressSlack: true }
         );
-        void this.updateProgress({
+        this.updateProgressAfterCommit({
           session_id: sessionId,
           state: "queued",
           task_id: task.task_id,
@@ -1045,9 +1590,9 @@ ${promptText}`;
         });
       } else {
         console.log(
-          `[gateway] Prompt sent to session ${shortId(sessionId)} via /sessions/:id/prompt`
+          `[gateway] Prompt sent to session ${shortId2(sessionId)} via /sessions/:id/prompt`
         );
-        void this.updateProgress({
+        this.updateProgressAfterCommit({
           session_id: sessionId,
           state: "working",
           task_id: task.task_id
@@ -1056,7 +1601,7 @@ ${promptText}`;
     } catch (error) {
       console.error("[gateway] Failed to send prompt to session:", error);
       this.sendSystemMessage(channel, data.thread_id, `Error sending prompt: ${error}`);
-      void this.updateProgress({
+      this.updateProgressAfterCommit({
         session_id: sessionId,
         state: "failed",
         error_message: error instanceof Error ? error.message : String(error)
@@ -1083,7 +1628,7 @@ ${promptText}`;
       return { routed: false };
     }
     console.log(
-      `[gateway] Found mapping: channel=${shortId(mapping.channel_id)}, thread=${mapping.thread_id}`
+      `[gateway] Found mapping: channel=${shortId2(mapping.channel_id)}, thread=${mapping.thread_id}`
     );
     const channel = await this.channelRepo.findById(mapping.channel_id);
     if (!channel?.enabled) {
@@ -1098,15 +1643,19 @@ ${promptText}`;
     if (channel.channel_type === "github") {
       this.githubMessageBuffer.set(data.session_id, data.message);
       console.log(
-        `[gateway] Buffered GitHub message for session ${shortId(data.session_id)} (${data.message.length} chars)`
+        `[gateway] Buffered GitHub message for session ${shortId2(data.session_id)} (${data.message.length} chars)`
       );
       return { routed: true, channelType: "github" };
     }
     try {
       const connector = this.activeListeners.get(channel.id) ?? getConnector(channel.channel_type, channel.config);
-      const { text, blocks } = normalizeOutbound(
+      const systemMeta = data.metadata?.system;
+      const systemPrefixMatch = /^\s*\[system\]\s*/i.exec(data.message);
+      const shouldRenderAsSystem = channel.channel_type === "slack" && (systemMeta?.render_hint === "context" || !!systemPrefixMatch);
+      const payload = shouldRenderAsSystem ? formatGatewaySystemPayload("slack", data.message.replace(/^\s*\[system\]\s*/i, "").trim()) : normalizeOutbound(
         connector.formatMessage ? connector.formatMessage(data.message) : data.message
       );
+      const { text, blocks } = payload;
       const threadId = channel.channel_type === "slack" ? this.getActiveSlackThreadId(mapping) : mapping.thread_id;
       const sentTs = await connector.sendMessage({
         threadId,
@@ -1127,6 +1676,25 @@ ${promptText}`;
       channelType: channel.channel_type
     };
   }
+  /**
+   * Schedule outbound routing after the current tenant-scoped database work
+   * commits, then route inside a fresh tenant scope. Message after-hooks fire
+   * while the newly-created row may still be transactional; routing immediately
+   * can inherit a stale transaction object or query before the session/message
+   * graph is visible on a new scoped connection.
+   */
+  routeMessageAfterCommit(data, params) {
+    deferWithTenantDatabaseScope(
+      this.db,
+      params,
+      async () => {
+        await this.routeMessage(data);
+      },
+      (error) => {
+        console.warn("[gateway] Failed to route message after commit:", error);
+      }
+    );
+  }
   /**
    * Flush the GitHub message buffer for a session.
    *
@@ -1143,7 +1711,7 @@ ${promptText}`;
     const mapping = await this.threadMapRepo.findBySession(sessionId);
     if (!mapping) {
       console.warn(
-        `[gateway] flushGitHubBuffer: no thread mapping for session ${shortId(sessionId)}`
+        `[gateway] flushGitHubBuffer: no thread mapping for session ${shortId2(sessionId)}`
       );
       return;
     }
@@ -1167,12 +1735,12 @@ ${promptText}`;
         metadata: outboundMetadata
       });
       console.log(
-        `[gateway] Flushed GitHub buffer for session ${shortId(sessionId)} \u2192 ${mapping.thread_id} (${bufferedMessage.length} chars)`
+        `[gateway] Flushed GitHub buffer for session ${shortId2(sessionId)} \u2192 ${mapping.thread_id} (${bufferedMessage.length} chars)`
       );
     } catch (error) {
       this.githubMessageBuffer.set(sessionId, bufferedMessage);
       console.error(
-        `[gateway] Failed to flush GitHub buffer for session ${shortId(sessionId)} (re-queued):`,
+        `[gateway] Failed to flush GitHub buffer for session ${shortId2(sessionId)} (re-queued):`,
         error
       );
     }
@@ -1243,7 +1811,7 @@ ${promptText}`;
       if (connector.stopListening) {
         await connector.stopListening();
       }
-      console.log(`[gateway] Listener stopped for channel ${shortId(channelId)}`);
+      console.log(`[gateway] Listener stopped for channel ${shortId2(channelId)}`);
     } catch (error) {
       console.error(
         `[gateway] Error stopping listener for ${channelId} (old socket may still be alive):`,
@@ -1258,31 +1826,42 @@ ${promptText}`;
     if (this.activeListeners.has(channel.id)) {
       return;
     }
-    try {
-      const connector = getConnector(channel.channel_type, channel.config);
-      if (!connector.startListening) {
-        return;
+    const listenerTenantId = tenantIdFromGatewayChannel(channel) ?? getCurrentTenantId2();
+    return runWithoutTenantDatabaseScope2(async () => {
+      try {
+        const connector = getConnector(channel.channel_type, channel.config);
+        if (!connector.startListening) {
+          return;
+        }
+        const callback = (msg) => {
+          this.handleListenerInboundMessage(channel, listenerTenantId, msg).catch((error) => {
+            console.error(
+              `[gateway] Failed to process inbound message for channel ${channel.name}:`,
+              error
+            );
+          });
+        };
+        await connector.startListening(callback);
+        this.activeListeners.set(channel.id, connector);
+        console.log(`[gateway] Socket Mode listener started for channel "${channel.name}"`);
+      } catch (error) {
+        console.error(`[gateway] Failed to start listener for channel "${channel.name}":`, error);
       }
-      const callback = (msg) => {
-        this.create({
-          channel_key: channel.channel_key,
-          thread_id: msg.threadId,
-          text: msg.text,
-          user_name: msg.userId,
-          metadata: msg.metadata
-        }).catch((error) => {
-          console.error(
-            `[gateway] Failed to process inbound message for channel ${channel.name}:`,
-            error
-          );
-        });
-      };
-      await connector.startListening(callback);
-      this.activeListeners.set(channel.id, connector);
-      console.log(`[gateway] Socket Mode listener started for channel "${channel.name}"`);
-    } catch (error) {
-      console.error(`[gateway] Failed to start listener for channel "${channel.name}":`, error);
+    });
+  }
+  async handleListenerInboundMessage(channel, tenantId, msg) {
+    if (!tenantId) {
+      throw new Error(`Missing tenant context for gateway listener channel ${channel.id}`);
     }
+    await runWithTenantDatabaseScope2(this.db, tenantId, async () => {
+      await this.create({
+        channel_key: channel.channel_key,
+        thread_id: msg.threadId,
+        text: msg.text,
+        user_name: msg.userId,
+        metadata: msg.metadata
+      });
+    });
   }
   /**
    * Stop all active listeners (called on shutdown)
@@ -1293,7 +1872,7 @@ ${promptText}`;
         if (connector.stopListening) {
           await connector.stopListening();
         }
-        console.log(`[gateway] Listener stopped for channel ${shortId(channelId)}`);
+        console.log(`[gateway] Listener stopped for channel ${shortId2(channelId)}`);
       } catch (error) {
         console.error(`[gateway] Error stopping listener for ${channelId}:`, error);
       }
@@ -1306,5 +1885,6 @@ function createGatewayService(db, app) {
 }
 export {
   GatewayService,
-  createGatewayService
+  createGatewayService,
+  tenantIdFromGatewayChannel
 };