agor-live 0.21.2 → 0.22.0

package/dist/daemon/services/gateway.js

@@ -1,4 +1,5 @@
 // src/services/gateway.ts
+import { PublicBaseUrlNotConfiguredError, requirePublicBaseUrl } from "@agor/core/config";
 import {
   GatewayChannelRepository,
   MCPServerRepository,
@@ -9,7 +10,9 @@ import {
 } from "@agor/core/db";
 import {
   formatGatewayContext,
-  formatGatewaySystemMessage,
+  formatGatewayFollowUpRoutingMessage,
+  formatGatewaySessionCreatedMessage,
+  formatGatewaySystemPayload,
   getConnector,
   hasConnector,
   normalizeOutbound,
@@ -17,6 +20,7 @@ import {
 } from "@agor/core/gateway";
 import { resolveSessionDefaults } from "@agor/core/sessions";
 import { SessionStatus } from "@agor/core/types";
+import { getSessionUrl } from "@agor/core/utils/url";
 function hasListeningConfig(channel) {
   const config = channel.config;
   switch (channel.channel_type) {
@@ -24,10 +28,15 @@ function hasListeningConfig(channel) {
       return !!config.app_token;
     case "github":
       return !!(config.app_id && config.private_key && config.installation_id && config.watch_repos?.length);
+    case "teams":
+      return !!(config.app_id && config.app_password);
     default:
       return false;
   }
 }
+function isSlackThinkingPlaceholder(text) {
+  return /^thinking\s*\.{3}$/i.test(text.trim());
+}
 function buildGitHubInitialPrompt(threadId, text, metadata) {
   try {
     const { owner, repo, number } = parseGitHubThreadId(threadId);
@@ -102,6 +111,26 @@ function buildGatewayContext(channel, data) {
         extras
       };
     }
+    case "teams": {
+      const conversationType = meta.teams_conversation_type;
+      const isPersonal = conversationType === "personal";
+      let channelKind;
+      if (isPersonal) {
+        channelKind = "DM";
+      } else if (conversationType === "channel") {
+        channelKind = "Channel";
+      } else if (conversationType === "groupChat") {
+        channelKind = "Group Chat";
+      }
+      const channelName = isPersonal ? void 0 : meta.teams_channel_name ?? meta.teams_team_name ?? void 0;
+      return {
+        platform: "teams",
+        channelName,
+        channelKind,
+        userName: meta.teams_user_name ?? void 0,
+        userEmail: meta.teams_user_email ?? void 0
+      };
+    }
     default:
       return {
         platform: channel.channel_type,
@@ -109,7 +138,7 @@ function buildGatewayContext(channel, data) {
       };
   }
 }
-var GatewayService = class {
+var GatewayService = class _GatewayService {
   channelRepo;
   threadMapRepo;
   usersRepo;
@@ -133,6 +162,21 @@ var GatewayService = class {
    * previous one — only the final message matters.
    */
   githubMessageBuffer = /* @__PURE__ */ new Map();
+  /**
+   * Slack status updates are serialized and lightly throttled so concurrent
+   * tool/message hooks do not race while deleting/reposting the transient row.
+   * Terminal states always bypass this throttle.
+   */
+  slackProgressLastUpdate = /* @__PURE__ */ new Map();
+  slackProgressQueues = /* @__PURE__ */ new Map();
+  slackStreamsByTask = /* @__PURE__ */ new Map();
+  slackStreamStatusRefreshLast = /* @__PURE__ */ new Map();
+  slackStreamedMessageIds = /* @__PURE__ */ new Set();
+  slackStreamedTaskIds = /* @__PURE__ */ new Set();
+  slackStreamTaskByMessage = /* @__PURE__ */ new Map();
+  static SLACK_PROGRESS_MIN_UPDATE_MS = 2500;
+  static SLACK_STREAM_STATUS_REFRESH_MS = 300;
+  static SLACK_STREAMED_MESSAGE_CACHE_MAX = 500;
   constructor(db, app) {
     this.channelRepo = new GatewayChannelRepository(db);
     this.threadMapRepo = new ThreadSessionMapRepository(db);
@@ -153,21 +197,479 @@ var GatewayService = class {
     );
   }
   /**
-   * Send a debug/system message to the platform thread (fire-and-forget).
+   * Send a system message to the platform thread (fire-and-forget).
    * Useful for giving the user visibility into what's happening.
    */
-  sendDebugMessage(channel, threadId, text) {
+  sendSystemMessage(channel, threadId, text, opts) {
     if (channel.channel_type === "github") return;
+    if (channel.channel_type === "slack" && opts?.suppressSlack) return;
     if (!hasConnector(channel.channel_type)) return;
     try {
-      const connector = getConnector(channel.channel_type, channel.config);
+      const connector = this.activeListeners.get(channel.id) ?? getConnector(channel.channel_type, channel.config);
       connector.sendMessage({
         threadId,
-        text: formatGatewaySystemMessage(channel.channel_type, text)
+        ...formatGatewaySystemPayload(channel.channel_type, text)
       }).catch((err) => console.warn("[gateway] Debug message failed:", err));
     } catch {
     }
   }
+  truncateSlackInline(value, maxChars = 70) {
+    const singleLine = value.replace(/\s+/g, " ").trim();
+    if (singleLine.length <= maxChars) return singleLine;
+    return `${singleLine.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+  }
+  formatSlackLoadingMessage(text) {
+    return this.truncateSlackInline(text, 50);
+  }
+  makeSlackThreadIdForMessage(rootThreadId, messageTs) {
+    const lastHyphen = rootThreadId.lastIndexOf("-");
+    if (lastHyphen === -1) return null;
+    const channelId = rootThreadId.slice(0, lastHyphen);
+    if (!channelId || !messageTs) return null;
+    return `${channelId}-${messageTs}`;
+  }
+  async addSlackThreadAlias(mapping, messageTs, reason) {
+    const aliasThreadId = this.makeSlackThreadIdForMessage(mapping.thread_id, messageTs);
+    if (!aliasThreadId || aliasThreadId === mapping.thread_id) return;
+    const freshMapping = await this.threadMapRepo.findById(mapping.id);
+    const metadata = (freshMapping ?? mapping).metadata ?? {};
+    const aliases = Array.isArray(metadata.slack_thread_aliases) ? metadata.slack_thread_aliases.filter((alias) => typeof alias === "string") : [];
+    if (aliases.includes(aliasThreadId)) return;
+    await this.threadMapRepo.updateMetadata(mapping.id, {
+      ...metadata,
+      slack_thread_aliases: [...aliases, aliasThreadId].slice(-50),
+      slack_thread_alias_last_reason: reason
+    });
+  }
+  getActiveSlackThreadId(mapping) {
+    const metadata = mapping.metadata ?? {};
+    return typeof metadata.slack_active_thread_id === "string" ? metadata.slack_active_thread_id : mapping.thread_id;
+  }
+  pickSlackRoutingMetadata(metadata) {
+    return {
+      ...typeof metadata.slack_active_thread_id === "string" ? { slack_active_thread_id: metadata.slack_active_thread_id } : {},
+      ...Array.isArray(metadata.slack_thread_aliases) ? { slack_thread_aliases: metadata.slack_thread_aliases } : {},
+      ...typeof metadata.slack_thread_alias_last_reason === "string" ? { slack_thread_alias_last_reason: metadata.slack_thread_alias_last_reason } : {}
+    };
+  }
+  async findSlackThreadAliasMapping(channelId, threadId) {
+    const mappings = channelId ? await this.threadMapRepo.findByChannel(channelId, "active") : (await this.threadMapRepo.findAll()).filter((mapping) => mapping.status === "active");
+    return mappings.find((mapping) => {
+      const metadata = mapping.metadata ?? {};
+      return Array.isArray(metadata.slack_thread_aliases) && metadata.slack_thread_aliases.includes(threadId);
+    }) ?? null;
+  }
+  parseGatewayTodos(raw) {
+    const candidate = typeof raw === "string" ? (() => {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    })() : raw;
+    if (!Array.isArray(candidate)) return [];
+    return candidate.map((item) => {
+      if (!item || typeof item !== "object") return null;
+      const record = item;
+      const content = typeof record.content === "string" ? record.content : typeof record.activeForm === "string" ? record.activeForm : null;
+      if (!content) return null;
+      const status = record.status;
+      if (status !== "pending" && status !== "in_progress" && status !== "completed" && status !== "stopped" && status !== "unknown") {
+        return { content, status: "pending" };
+      }
+      return {
+        content,
+        ...typeof record.activeForm === "string" ? { activeForm: record.activeForm } : {},
+        status
+      };
+    }).filter((item) => item !== null);
+  }
+  formatSlackToolSummary(toolName, input) {
+    if (!toolName) return "Waiting for the agent...";
+    const str = (value) => typeof value === "string" && value.trim().length > 0 ? value : void 0;
+    const preview = (value, maxChars = 70) => {
+      const text = str(value);
+      return text ? this.truncateSlackInline(text, maxChars) : void 0;
+    };
+    const withPreview = (value) => value ? `\`${toolName}\` ${value}` : `\`${toolName}\``;
+    if (toolName === "TodoWrite") {
+      const todos = this.parseGatewayTodos(input?.todos);
+      if (todos.length > 0) {
+        const completed = todos.filter((todo) => todo.status === "completed").length;
+        const inProgress = todos.filter((todo) => todo.status === "in_progress").length;
+        const parts = [`${completed}/${todos.length} done`];
+        if (inProgress > 0) parts.push(`${inProgress} in progress`);
+        return withPreview(parts.join(", "));
+      }
+    }
+    switch (toolName) {
+      case "Read":
+      case "Write":
+      case "Edit":
+      case "NotebookEdit":
+        return withPreview(preview(input?.file_path));
+      case "Bash":
+      case "exec_command":
+        return withPreview(preview(input?.description) ?? preview(input?.command));
+      case "Grep":
+      case "Glob":
+        return withPreview(preview(input?.pattern));
+      case "ToolSearch":
+      case "WebSearch":
+      case "web_search":
+        return withPreview(preview(input?.query));
+      case "WebFetch":
+        return withPreview(preview(input?.url));
+      case "Agent":
+        return withPreview(preview(input?.description));
+      case "Skill":
+      case "SlashCommand":
+        return withPreview(preview(input?.skill) ?? preview(input?.name));
+      case "Task":
+        return withPreview(preview(str(input?.prompt)?.split("\n")[0], 100));
+      case "edit_files": {
+        const changes = input?.changes;
+        if (Array.isArray(changes) && changes.length > 0) {
+          if (changes.length === 1) {
+            const change = changes[0];
+            const kind = str(change.kind) ?? "update";
+            const path = str(change.path) ?? "";
+            return withPreview(this.truncateSlackInline(`${kind} ${path}`.trim(), 70));
+          }
+          return withPreview(`${changes.length} files`);
+        }
+        break;
+      }
+    }
+    return `\`${toolName}\``;
+  }
+  buildSlackAssistantStatus(data, existingMetadata) {
+    if (data.state === "done") return "";
+    if (data.state === "failed") return "ran into an error.";
+    if (data.state === "queued") {
+      const position = typeof data.queue_position === "number" ? ` at position ${data.queue_position}` : "";
+      return `is queued${position}.`;
+    }
+    const latestToolName = data.tool_name ?? (typeof existingMetadata.slack_status_tool_name === "string" ? existingMetadata.slack_status_tool_name : void 0);
+    return latestToolName ? `is using ${this.truncateSlackInline(latestToolName, 40)}.` : "is working on your request.";
+  }
+  buildSlackAssistantLoadingMessage(data, existingMetadata) {
+    if (data.state === "done") return void 0;
+    if (data.state === "failed") return this.formatSlackLoadingMessage("Agor ran into an error.");
+    if (data.state === "queued") return this.formatSlackLoadingMessage("Queued in Agor\u2026");
+    const latestToolSummary = data.tool_name || data.tool_input ? this.formatSlackToolSummary(data.tool_name, data.tool_input) : typeof existingMetadata.slack_status_tool_summary === "string" ? existingMetadata.slack_status_tool_summary : void 0;
+    if (latestToolSummary) {
+      return this.formatSlackLoadingMessage(`Using ${latestToolSummary.replace(/`/g, "")}\u2026`);
+    }
+    const latestToolName = data.tool_name ?? (typeof existingMetadata.slack_status_tool_name === "string" ? existingMetadata.slack_status_tool_name : void 0);
+    if (latestToolName) {
+      return this.formatSlackLoadingMessage(`Using ${latestToolName}\u2026`);
+    }
+    return this.formatSlackLoadingMessage("Working in Agor\u2026");
+  }
+  stripSlackProgressMetadata(metadata) {
+    const {
+      slack_status_message_ts: _statusTs,
+      slack_status_started_at: _startedAt,
+      slack_status_tool_name: _toolName,
+      slack_status_tool_summary: _toolSummary,
+      slack_status_todos: _todos,
+      slack_status_state: _state,
+      slack_status_task_id: _taskId,
+      ...rest
+    } = metadata;
+    return rest;
+  }
+  stripSlackProgressMessageMetadata(metadata) {
+    const { slack_status_message_ts: _statusTs, ...rest } = metadata;
+    return rest;
+  }
+  async refreshSlackAssistantStatusAfterStreamStart(threadId, connector, sessionId, taskId, metadata) {
+    if (!connector.setThreadStatus) return;
+    const progress = {
+      session_id: sessionId,
+      state: "working",
+      ...taskId ? { task_id: taskId } : {}
+    };
+    const loadingMessage = this.buildSlackAssistantLoadingMessage(progress, metadata) ?? this.formatSlackLoadingMessage("Writing response\u2026");
+    await connector.setThreadStatus({
+      threadId,
+      status: this.buildSlackAssistantStatus(progress, metadata),
+      loadingMessages: [loadingMessage],
+      iconEmoji: ":hourglass_flowing_sand:"
+    });
+    if (taskId) {
+      this.slackStreamStatusRefreshLast.set(taskId, Date.now());
+    }
+  }
+  async refreshSlackAssistantStatusAfterStreamAppend(threadId, connector, sessionId, taskId, metadata) {
+    if (!taskId) return;
+    const now = Date.now();
+    const lastRefresh = this.slackStreamStatusRefreshLast.get(taskId) ?? 0;
+    if (now - lastRefresh < _GatewayService.SLACK_STREAM_STATUS_REFRESH_MS) return;
+    this.slackStreamStatusRefreshLast.set(taskId, now);
+    await this.refreshSlackAssistantStatusAfterStreamStart(
+      threadId,
+      connector,
+      sessionId,
+      taskId,
+      metadata
+    );
+  }
+  /**
+   * Update Slack's native assistant status/stream chrome for a gateway thread.
+   *
+   * We expose a short, Slack-safe tool summary and TodoWrite plan state, never
+   * raw JSON args/results. Raw tool inputs are already persisted in Agor's
+   * transcript; Slack receives only a compact truncated preview.
+   */
+  async updateProgress(data) {
+    const previous = this.slackProgressQueues.get(data.session_id) ?? Promise.resolve();
+    const next = previous.catch(() => void 0).then(() => this.updateProgressNow(data));
+    this.slackProgressQueues.set(data.session_id, next);
+    try {
+      await next;
+    } finally {
+      if (this.slackProgressQueues.get(data.session_id) === next) {
+        this.slackProgressQueues.delete(data.session_id);
+      }
+    }
+  }
+  wasMessageStreamedToSlack(messageId) {
+    return this.slackStreamedMessageIds.has(messageId);
+  }
+  wasTaskStreamedToSlack(taskId) {
+    return !!taskId && this.slackStreamedTaskIds.has(taskId);
+  }
+  markMessageStreamedToSlack(messageId) {
+    this.slackStreamedMessageIds.add(messageId);
+    if (this.slackStreamedMessageIds.size > _GatewayService.SLACK_STREAMED_MESSAGE_CACHE_MAX) {
+      const oldest = this.slackStreamedMessageIds.values().next().value;
+      if (oldest) this.slackStreamedMessageIds.delete(oldest);
+    }
+  }
+  markTaskStreamedToSlack(taskId) {
+    if (!taskId) return;
+    this.slackStreamedTaskIds.add(taskId);
+    if (this.slackStreamedTaskIds.size > _GatewayService.SLACK_STREAMED_MESSAGE_CACHE_MAX) {
+      const oldest = this.slackStreamedTaskIds.values().next().value;
+      if (oldest) this.slackStreamedTaskIds.delete(oldest);
+    }
+  }
+  async stopSlackTaskStream(taskId, connector) {
+    if (!taskId) return;
+    const stream = this.slackStreamsByTask.get(taskId);
+    if (!stream) return;
+    if (!stream.hasContent && connector.deleteMessage) {
+      await connector.deleteMessage({
+        threadId: stream.threadId,
+        messageId: stream.ts
+      });
+      this.slackStreamsByTask.delete(taskId);
+      this.slackStreamStatusRefreshLast.delete(taskId);
+      return;
+    }
+    const streamConnector = connector;
+    if (!streamConnector.stopStream) return;
+    await streamConnector.stopStream({
+      threadId: stream.threadId,
+      ts: stream.ts
+    });
+    this.slackStreamsByTask.delete(taskId);
+    this.slackStreamStatusRefreshLast.delete(taskId);
+  }
+  async updateProgressNow(data) {
+    if (!this.hasActiveChannels) return;
+    const mapping = await this.threadMapRepo.findBySession(data.session_id);
+    if (!mapping) return;
+    const channel = await this.channelRepo.findById(mapping.channel_id);
+    if (!channel?.enabled || channel.channel_type !== "slack") return;
+    const now = Date.now();
+    const isTerminal = data.state === "done" || data.state === "failed";
+    const metadata = mapping.metadata ?? {};
+    const isNewTask = typeof data.task_id === "string" && data.task_id !== metadata.slack_status_task_id;
+    const isRestartingAfterTerminal = (data.state === "queued" || data.state === "working") && (metadata.slack_status_state === "done" || metadata.slack_status_state === "failed");
+    const lastUpdate = this.slackProgressLastUpdate.get(data.session_id) ?? 0;
+    if (!isTerminal && !data.tool_name && !isNewTask && !isRestartingAfterTerminal && now - lastUpdate < _GatewayService.SLACK_PROGRESS_MIN_UPDATE_MS) {
+      return;
+    }
+    this.slackProgressLastUpdate.set(data.session_id, now);
+    const statusStartedAt = isNewTask || isRestartingAfterTerminal ? new Date(now).toISOString() : typeof metadata.slack_status_started_at === "string" ? metadata.slack_status_started_at : new Date(now).toISOString();
+    const toolTodos = data.tool_name === "TodoWrite" ? this.parseGatewayTodos(data.tool_input?.todos) : [];
+    const toolSummary = data.tool_name || data.tool_input ? this.formatSlackToolSummary(data.tool_name, data.tool_input) : void 0;
+    const baseMetadata = isNewTask || isRestartingAfterTerminal ? this.stripSlackProgressMetadata(metadata) : metadata;
+    const metadataWithStart = {
+      ...baseMetadata,
+      slack_status_started_at: statusStartedAt,
+      slack_status_state: data.state,
+      ...data.task_id ? { slack_status_task_id: data.task_id } : {},
+      ...data.tool_name ? { slack_status_tool_name: data.tool_name } : {},
+      ...toolSummary ? { slack_status_tool_summary: toolSummary } : {},
+      ...toolTodos.length > 0 ? { slack_status_todos: toolTodos } : {}
+    };
+    const connector = this.activeListeners.get(channel.id) ?? getConnector(channel.channel_type, channel.config);
+    const activeTaskId = typeof metadata.slack_status_task_id === "string" ? metadata.slack_status_task_id : void 0;
+    try {
+      if (isTerminal) {
+        try {
+          await this.stopSlackTaskStream(activeTaskId, connector);
+        } catch (error) {
+          console.warn("[gateway] Failed to stop Slack task stream:", error);
+        }
+      }
+      const freshMapping = await this.threadMapRepo.findById(mapping.id);
+      const freshMetadata = freshMapping?.metadata ?? {};
+      const metadataForWrite = {
+        ...isTerminal ? this.stripSlackProgressMetadata(metadataWithStart) : this.stripSlackProgressMessageMetadata(metadataWithStart),
+        ...this.pickSlackRoutingMetadata(freshMetadata)
+      };
+      const slackThreadId = typeof metadataForWrite.slack_active_thread_id === "string" ? metadataForWrite.slack_active_thread_id : mapping.thread_id;
+      await this.threadMapRepo.updateMetadata(mapping.id, metadataForWrite);
+      if (!connector.setThreadStatus) return;
+      try {
+        const loadingMessage = this.buildSlackAssistantLoadingMessage(data, metadataWithStart);
+        await connector.setThreadStatus({
+          threadId: slackThreadId,
+          status: this.buildSlackAssistantStatus(data, metadataWithStart),
+          loadingMessages: loadingMessage ? [loadingMessage] : void 0,
+          iconEmoji: ":hourglass_flowing_sand:"
+        });
+      } catch (error) {
+        console.warn("[gateway] Failed to set Slack assistant status:", error);
+      }
+    } catch (error) {
+      console.warn("[gateway] Failed to update Slack progress status:", error);
+    }
+  }
+  async handleMessageStreamingEvent(event, data) {
+    if (!this.hasActiveChannels) return;
+    const sessionId = typeof data.session_id === "string" ? data.session_id : void 0;
+    const messageId = typeof data.message_id === "string" ? data.message_id : void 0;
+    const taskId = typeof data.task_id === "string" ? data.task_id : void 0;
+    if (!sessionId || !messageId) return;
+    if (event === "streaming:start") {
+      if (taskId) {
+        this.slackStreamTaskByMessage.set(messageId, taskId);
+      }
+      return;
+    }
+    const taskKey = taskId ?? this.slackStreamTaskByMessage.get(messageId) ?? messageId;
+    const mapping = await this.threadMapRepo.findBySession(sessionId);
+    if (!mapping) return;
+    const channel = await this.channelRepo.findById(mapping.channel_id);
+    if (!channel?.enabled || channel.channel_type !== "slack") return;
+    const connector = this.activeListeners.get(channel.id) ?? getConnector(channel.channel_type, channel.config);
+    const streamConnector = connector;
+    if (!streamConnector.startStream || !streamConnector.appendStream) {
+      return;
+    }
+    try {
+      const metadata = mapping.metadata ?? {};
+      const slackThreadId = this.getActiveSlackThreadId(mapping);
+      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") {
+        const chunk = typeof data.chunk === "string" ? data.chunk : "";
+        if (!chunk) return;
+        if (isSlackThinkingPlaceholder(chunk)) {
+          return;
+        }
+        const existing = this.slackStreamsByTask.get(taskKey);
+        if (!existing) {
+          const ts = await streamConnector.startStream({
+            threadId: slackThreadId,
+            text: chunk,
+            recipientUserId,
+            recipientTeamId
+          });
+          this.slackStreamsByTask.set(taskKey, {
+            threadId: slackThreadId,
+            ts,
+            hasContent: true,
+            taskId: taskKey,
+            lastMessageId: messageId
+          });
+          await this.addSlackThreadAlias(mapping, ts, "stream");
+          try {
+            await this.refreshSlackAssistantStatusAfterStreamStart(
+              slackThreadId,
+              connector,
+              sessionId,
+              taskKey,
+              metadata
+            );
+          } catch (error) {
+            console.warn("[gateway] Failed to refresh Slack status after stream start:", error);
+          }
+          this.markMessageStreamedToSlack(messageId);
+          this.markTaskStreamedToSlack(taskKey);
+          return;
+        }
+        const text = existing.hasContent && existing.lastMessageId && existing.lastMessageId !== messageId ? `
+
+${chunk}` : chunk;
+        await streamConnector.appendStream({
+          threadId: existing.threadId,
+          ts: existing.ts,
+          text
+        });
+        try {
+          await this.refreshSlackAssistantStatusAfterStreamAppend(
+            existing.threadId,
+            connector,
+            sessionId,
+            taskKey,
+            metadata
+          );
+        } catch (error) {
+          console.warn("[gateway] Failed to refresh Slack status after stream append:", error);
+        }
+        existing.hasContent = true;
+        existing.lastMessageId = messageId;
+        this.markMessageStreamedToSlack(messageId);
+        this.markTaskStreamedToSlack(taskKey);
+        return;
+      }
+      if (event === "streaming:end") {
+        const existing = this.slackStreamsByTask.get(taskKey);
+        if (existing?.hasContent) {
+          this.markMessageStreamedToSlack(messageId);
+          this.markTaskStreamedToSlack(taskKey);
+        }
+        this.slackStreamTaskByMessage.delete(messageId);
+        return;
+      }
+      if (event === "streaming:error") {
+        this.slackStreamTaskByMessage.delete(messageId);
+      }
+    } catch (error) {
+      this.slackStreamsByTask.delete(taskKey);
+      this.slackStreamTaskByMessage.delete(messageId);
+      console.warn("[gateway] Failed to mirror message stream to Slack:", error);
+    }
+  }
+  async fetchExistingSessionUrlForGatewayUser(sessionId, user) {
+    try {
+      const baseUrl = await requirePublicBaseUrl();
+      return getSessionUrl(sessionId, baseUrl);
+    } catch (error) {
+      if (!(error instanceof PublicBaseUrlNotConfiguredError)) {
+        console.warn("[gateway] Failed to build public session URL:", error);
+      }
+    }
+    try {
+      const sessionsService = this.app.service("sessions");
+      const sessionWithUrl = await sessionsService.get(sessionId, { user });
+      const sessionUrl = sessionWithUrl.url || null;
+      if (!sessionUrl) return null;
+      const hostname = new URL(sessionUrl).hostname;
+      if (hostname === "0.0.0.0") return null;
+      return sessionUrl;
+    } catch (error) {
+      console.warn("[gateway] Failed to fetch session URL:", error);
+      return null;
+    }
+  }
   /**
    * Inbound routing: platform → session
    *
@@ -182,12 +684,27 @@ var GatewayService = class {
     if (!channel.enabled) {
       throw new Error("Channel is disabled");
     }
-    const existingMapping = await this.threadMapRepo.findByChannelAndThread(
+    let existingMapping = await this.threadMapRepo.findByChannelAndThread(
       channel.id,
       data.thread_id
     );
+    if (!existingMapping && channel.channel_type === "slack") {
+      existingMapping = await this.findSlackThreadAliasMapping(channel.id, data.thread_id);
+      if (existingMapping) {
+        console.log(
+          `[gateway] Found Slack thread alias: ${data.thread_id} \u2192 ${existingMapping.thread_id}`
+        );
+      }
+    }
+    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})`
+      );
+    }
     if (!existingMapping) {
-      const otherChannelMapping = await this.threadMapRepo.findByThread(data.thread_id);
+      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;
       if (otherChannelMapping) {
         console.log(
           `[gateway] IGNORED: Thread ${data.thread_id} owned by channel ${shortId(otherChannelMapping.channel_id)}, not ours (${shortId(channel.id)}). Silently dropping.`
@@ -220,7 +737,7 @@ var GatewayService = class {
         console.error(
           `[gateway] Channel "${channel.name}" has no agor_user_id and alignment is OFF. Cannot process message.`
         );
-        this.sendDebugMessage(channel, data.thread_id, errMsg);
+        this.sendSystemMessage(channel, data.thread_id, errMsg);
         if (channel.channel_type === "github" && data.metadata?.processing_comment_id) {
           try {
             const connector = getConnector(channel.channel_type, channel.config);
@@ -244,7 +761,7 @@ var GatewayService = class {
     if (alignSlackUsers) {
       if (data.metadata?.slack_user_email && typeof data.metadata.slack_user_email === "string") {
         const email = data.metadata.slack_user_email.toLowerCase().trim();
-        const matchedUser = await this.usersRepo.findByEmail(email);
+        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})`
@@ -252,7 +769,7 @@ var GatewayService = class {
           user = await usersService.get(matchedUser.user_id);
         } else {
           console.log(`[gateway] Slack user alignment failed: no Agor user with email ${email}`);
-          this.sendDebugMessage(
+          this.sendSystemMessage(
             channel,
             data.thread_id,
             `User ${email} doesn't have an Agor account. Ask an admin to create an account with this email, or disable user alignment.`
@@ -267,7 +784,7 @@ var GatewayService = class {
         console.log(
           `[gateway] Slack user alignment failed: could not resolve email for Slack user ${data.user_name ?? "unknown"} (thread=${data.thread_id})`
         );
-        this.sendDebugMessage(
+        this.sendSystemMessage(
           channel,
           data.thread_id,
           "Couldn't resolve your Slack identity. The bot may be missing the `users:read.email` scope, or your Slack profile has no email. Ask an admin to check the bot's scopes."
@@ -285,7 +802,7 @@ var GatewayService = class {
       const userMap = channelConfig.user_map;
       const mappedEmail = githubLogin && userMap?.[githubLogin] ? userMap[githubLogin].toLowerCase().trim() : null;
       if (mappedEmail) {
-        const matchedUser = await this.usersRepo.findByEmail(mappedEmail);
+        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)}`
@@ -301,7 +818,7 @@ var GatewayService = class {
       if (!resolved) {
         const githubEmail = data.metadata?.github_user_email && typeof data.metadata.github_user_email === "string" ? data.metadata.github_user_email.toLowerCase().trim() : null;
         if (githubEmail) {
-          const matchedUser = await this.usersRepo.findByEmail(githubEmail);
+          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)}`
@@ -359,24 +876,34 @@ var GatewayService = class {
     if (existingMapping) {
       sessionId = existingMapping.session_id;
       await this.threadMapRepo.updateLastMessage(existingMapping.id);
-      if (data.metadata?.processing_comment_id) {
-        const updatedMetadata = {
-          ...existingMapping.metadata ?? {},
-          processing_comment_id: data.metadata.processing_comment_id
-        };
-        await this.threadMapRepo.updateMetadata(existingMapping.id, updatedMetadata);
+      const existingMetadata = existingMapping.metadata ?? {};
+      await this.threadMapRepo.updateMetadata(existingMapping.id, {
+        ...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 } : {},
+        ...channel.channel_type === "slack" ? { slack_active_thread_id: data.thread_id } : {}
+      });
+      if (channel.channel_type === "slack") {
+        console.log(
+          `[gateway] Slack active outbound thread for session ${shortId(sessionId)} set to ${data.thread_id}`
+        );
+      }
+      const sessionUrl = await this.fetchExistingSessionUrlForGatewayUser(sessionId, user);
+      if (sessionUrl) {
+        this.sendSystemMessage(
+          channel,
+          data.thread_id,
+          formatGatewayFollowUpRoutingMessage(sessionId, sessionUrl)
+        );
       }
-      this.sendDebugMessage(
-        channel,
-        data.thread_id,
-        `Received follow-up, routing to session ${shortId(sessionId)}...`
-      );
     } else {
       const sessionsService = this.app.service("sessions");
-      this.sendDebugMessage(
+      this.sendSystemMessage(
         channel,
         data.thread_id,
-        `Creating new ${agenticTool} session (${permissionMode} mode)...`
+        `Creating new ${agenticTool} session (${permissionMode} mode)...`,
+        { suppressSlack: true }
       );
       const gatewaySource = {
         channel_id: channel.id,
@@ -452,19 +979,16 @@ var GatewayService = class {
         session_id: session.session_id,
         branch_id: channel.target_branch_id,
         status: "active",
-        metadata: data.metadata ?? null
+        metadata: channel.channel_type === "slack" ? { ...data.metadata ?? {}, slack_active_thread_id: data.thread_id } : data.metadata ?? null
       });
-      let sessionUrl = null;
-      try {
-        const sessionsService2 = this.app.service("sessions");
-        const sessionWithUrl = await sessionsService2.get(sessionId, { user });
-        sessionUrl = sessionWithUrl.url || null;
-      } catch (error) {
-        console.warn("[gateway] Failed to fetch session URL:", error);
+      const sessionUrl = await this.fetchExistingSessionUrlForGatewayUser(sessionId, user);
+      if (sessionUrl) {
+        this.sendSystemMessage(
+          channel,
+          data.thread_id,
+          formatGatewaySessionCreatedMessage(sessionId, sessionUrl)
+        );
       }
-      const sessionIdShort = shortId(sessionId);
-      const message = sessionUrl ? `Session created: ${sessionUrl}` : `Session ${sessionIdShort} created, sending prompt to agent...`;
-      this.sendDebugMessage(channel, data.thread_id, message);
       if (channel.channel_type === "github" && data.metadata?.processing_comment_id) {
         try {
           const connector = getConnector(channel.channel_type, channel.config);
@@ -507,19 +1031,36 @@ ${promptText}`;
         console.log(
           `[gateway] Message queued for session ${shortId(sessionId)} at position ${task.queue_position}`
         );
-        this.sendDebugMessage(
+        this.sendSystemMessage(
           channel,
           data.thread_id,
-          `Session is busy, message queued at position ${task.queue_position}`
+          `Session is busy, message queued at position ${task.queue_position}`,
+          { suppressSlack: true }
         );
+        void this.updateProgress({
+          session_id: sessionId,
+          state: "queued",
+          task_id: task.task_id,
+          queue_position: task.queue_position
+        });
       } else {
         console.log(
           `[gateway] Prompt sent to session ${shortId(sessionId)} via /sessions/:id/prompt`
         );
+        void this.updateProgress({
+          session_id: sessionId,
+          state: "working",
+          task_id: task.task_id
+        });
       }
     } catch (error) {
       console.error("[gateway] Failed to send prompt to session:", error);
-      this.sendDebugMessage(channel, data.thread_id, `Error sending prompt: ${error}`);
+      this.sendSystemMessage(channel, data.thread_id, `Error sending prompt: ${error}`);
+      void this.updateProgress({
+        session_id: sessionId,
+        state: "failed",
+        error_message: error instanceof Error ? error.message : String(error)
+      });
     }
     return {
       success: true,
@@ -562,19 +1103,21 @@ ${promptText}`;
       return { routed: true, channelType: "github" };
     }
     try {
-      const connector = getConnector(channel.channel_type, channel.config);
+      const connector = this.activeListeners.get(channel.id) ?? getConnector(channel.channel_type, channel.config);
       const { text, blocks } = normalizeOutbound(
         connector.formatMessage ? connector.formatMessage(data.message) : data.message
       );
-      await connector.sendMessage({
-        threadId: mapping.thread_id,
+      const threadId = channel.channel_type === "slack" ? this.getActiveSlackThreadId(mapping) : mapping.thread_id;
+      const sentTs = await connector.sendMessage({
+        threadId,
         text,
         blocks,
         metadata: data.metadata
       });
-      console.log(
-        `[gateway] Routed message to ${channel.channel_type} thread ${mapping.thread_id}`
-      );
+      if (channel.channel_type === "slack") {
+        await this.addSlackThreadAlias(mapping, sentTs, "message");
+      }
+      console.log(`[gateway] Routed message to ${channel.channel_type} thread ${threadId}`);
     } catch (error) {
       console.error(`[gateway] Failed to route message to ${channel.channel_type}:`, error);
       return { routed: false, channelType: channel.channel_type };