dorkos 0.16.0 → 0.17.0

package/dist/server/index.js

@@ -71060,7 +71060,7 @@ var SERVER_VERSION = resolveVersion();
 var IS_DEV_BUILD = checkDevBuild(SERVER_VERSION);
 function resolveVersion() {
   if (env.DORKOS_VERSION_OVERRIDE) return env.DORKOS_VERSION_OVERRIDE;
-  if (true) return "0.16.0";
+  if (true) return "0.17.0";
   const pkgPath = path4.join(path4.dirname(fileURLToPath2(import.meta.url)), "../../package.json");
   return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
 }
@@ -72143,7 +72143,8 @@ var ResponseContextSchema = z9.object({
   platform: z9.string(),
   maxLength: z9.number().int().optional(),
   supportedFormats: z9.array(z9.string()).optional(),
-  instructions: z9.string().optional()
+  instructions: z9.string().optional(),
+  formattingInstructions: z9.string().optional()
 }).openapi("ResponseContext");
 var StandardPayloadSchema = z9.object({
   content: z9.string(),
@@ -74473,6 +74474,20 @@ var TranscriptReader = class {
     const slug = this.getProjectSlug(vaultRoot2);
     return path14.join(os3.homedir(), ".claude", "projects", slug);
   }
+  /**
+   * Check whether a JSONL transcript file exists for the given session ID.
+   * Lightweight stat-only check (no parsing). Skips boundary validation
+   * since the caller is expected to have already validated.
+   */
+  async hasTranscript(vaultRoot2, sessionId) {
+    const filePath = path14.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    try {
+      await fs8.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   /**
    * List all sessions by scanning SDK JSONL transcript files.
    * Extracts metadata (title, timestamps, preview) from file content and stats.
@@ -75474,9 +75489,9 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname7 = sysPath.dirname(file);
+    const dirname8 = sysPath.dirname(file);
     const basename4 = sysPath.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname7);
+    const parent = this.fsw._getWatchedDir(dirname8);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
@@ -75503,7 +75518,7 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname7, basename4);
+          this.fsw._remove(dirname8, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -77884,6 +77899,11 @@ ${messageOpts.systemPromptAppend}` : baseAppend;
   };
   if (session.hasStarted) {
     sdkOptions.resume = session.sdkSessionId;
+    if (session.sdkSessionId === sessionId) {
+      logger.debug("[sendMessage] resuming with sdkSessionId === sessionId (expected after server restart)", {
+        session: sessionId
+      });
+    }
   }
   const cwdSource = messageOpts?.cwd ? "opts.cwd" : opts.sessionCwd ? "session.cwd" : "default";
   logger.debug("[sendMessage]", {
@@ -78214,8 +78234,9 @@ var ClaudeCodeRuntime = class _ClaudeCodeRuntime {
     if (!session) {
       this.ensureSession(sessionId, {
         permissionMode: opts.permissionMode ?? "default",
-        hasStarted: true
+        hasStarted: false
       });
+      this.sessions.get(sessionId).needsTranscriptCheck = true;
       session = this.sessions.get(sessionId);
     }
     if (opts.permissionMode) {
@@ -78241,11 +78262,31 @@ var ClaudeCodeRuntime = class _ClaudeCodeRuntime {
   // ---------------------------------------------------------------------------
   async *sendMessage(sessionId, content3, opts) {
     if (!this.sessions.has(sessionId)) {
+      const effectiveCwd = opts?.cwd ?? this.cwd;
+      const hasTranscript = await this.transcriptReader.hasTranscript(effectiveCwd, sessionId);
+      logger.debug("[sendMessage] auto-creating session", {
+        session: sessionId,
+        hasTranscript,
+        cwd: effectiveCwd
+      });
       this.ensureSession(sessionId, {
         permissionMode: opts?.permissionMode ?? "default",
         cwd: opts?.cwd,
-        hasStarted: true
+        hasStarted: hasTranscript
       });
+    } else {
+      const existingSession = this.sessions.get(sessionId);
+      if (existingSession.needsTranscriptCheck) {
+        existingSession.needsTranscriptCheck = false;
+        const effectiveCwd = opts?.cwd || existingSession.cwd || this.cwd;
+        const hasTranscript = await this.transcriptReader.hasTranscript(effectiveCwd, sessionId);
+        if (hasTranscript) {
+          logger.debug("[sendMessage] upgrading hasStarted for existing transcript", {
+            session: sessionId
+          });
+          existingSession.hasStarted = true;
+        }
+      }
     }
     const session = this.sessions.get(sessionId);
     yield* executeSdkQuery(sessionId, content3, session, {
@@ -84670,6 +84711,7 @@ var relayIndex = sqliteTable("relay_index", {
   }).notNull().default("pending"),
   expiresAt: text("expires_at"),
   // was: ttl INTEGER (Unix ms)
+  sender: text("sender"),
   payload: text("payload"),
   metadata: text("metadata"),
   createdAt: text("created_at").notNull()
@@ -86876,7 +86918,8 @@ var SqliteIndex = class {
       endpointHash: message.endpointHash,
       status: message.status,
       createdAt: message.createdAt,
-      expiresAt: message.expiresAt
+      expiresAt: message.expiresAt,
+      sender: message.sender ?? null
     }).onConflictDoUpdate({
       target: relayIndex.id,
       set: {
@@ -86884,7 +86927,8 @@ var SqliteIndex = class {
         endpointHash: message.endpointHash,
         status: message.status,
         createdAt: message.createdAt,
-        expiresAt: message.expiresAt
+        expiresAt: message.expiresAt,
+        sender: message.sender ?? null
       }
     }).run();
   }
@@ -86931,16 +86975,15 @@ var SqliteIndex = class {
     return rows.map(mapRow);
   }
   /**
-   * Count messages sent within a time window by filtering on createdAt.
-   * Used by the rate limiter for sliding window log checks.
+   * Count messages from a specific sender within a time window.
+   * Used by the rate limiter for per-sender sliding window log checks.
    *
-   * @param sender - Unused (retained for API compatibility). Rate limiting
-   *        is now done at the RelayCore level before indexing.
+   * @param sender - The sender identity to filter by (e.g. `relay.human.slack.bot`).
    * @param windowStartIso - ISO 8601 timestamp marking the start of the window.
-   * @returns The number of messages after the window start.
+   * @returns The number of messages from this sender after the window start.
    */
-  countSenderInWindow(_sender, windowStartIso) {
-    const rows = this.db.select({ cnt: count() }).from(relayIndex).where(sql`${relayIndex.createdAt} > ${windowStartIso}`).all();
+  countSenderInWindow(sender, windowStartIso) {
+    const rows = this.db.select({ cnt: count() }).from(relayIndex).where(and(sql`${relayIndex.createdAt} > ${windowStartIso}`, eq(relayIndex.sender, sender))).all();
     return rows[0]?.cnt ?? 0;
   }
   /**
@@ -86958,7 +87001,7 @@ var SqliteIndex = class {
   /**
    * Query messages with optional filters and cursor-based pagination.
    *
-   * Supports filtering by subject, status, sender (no-op), and endpoint hash.
+   * Supports filtering by subject, status, sender, and endpoint hash.
    * Uses ULID cursor for pagination (messages are sorted by id DESC).
    *
    * @param filters - Optional query filters
@@ -86972,6 +87015,9 @@ var SqliteIndex = class {
     if (filters?.status) {
       conditions.push(eq(relayIndex.status, filters.status));
     }
+    if (filters?.sender) {
+      conditions.push(eq(relayIndex.sender, filters.sender));
+    }
     if (filters?.endpointHash) {
       conditions.push(eq(relayIndex.endpointHash, filters.endpointHash));
     }
@@ -87042,7 +87088,8 @@ var SqliteIndex = class {
             endpointHash: hash,
             status: statusMap[subdir],
             createdAt: envelope.createdAt,
-            expiresAt: envelope.budget.ttl ? new Date(envelope.budget.ttl).toISOString() : null
+            expiresAt: envelope.budget.ttl ? new Date(envelope.budget.ttl).toISOString() : null,
+            sender: envelope.from
           });
           rebuildCount++;
         }
@@ -87110,7 +87157,8 @@ function mapRow(row) {
     endpointHash: row.endpointHash,
     status: row.status,
     createdAt: row.createdAt,
-    expiresAt: row.expiresAt
+    expiresAt: row.expiresAt,
+    sender: row.sender
   };
 }
 async function listMessageIds(store, hash, subdir) {
@@ -88239,6 +88287,7 @@ var RelayPublishPipeline = class {
       const countInWindow = this.deps.sqliteIndex.countSenderInWindow(options.from, windowStartIso);
       const rateLimitResult = checkRateLimit(options.from, countInWindow, this.rateLimitConfig);
       if (!rateLimitResult.allowed) {
+        this.deps.logger?.warn?.(`publish rate-limited: sender=${options.from}, count=${rateLimitResult.currentCount}/${rateLimitResult.limit} in ${this.rateLimitConfig.windowSecs}s window, subject=${subject}`);
         return {
           messageId: "",
           deliveredTo: 0,
@@ -88262,6 +88311,16 @@ var RelayPublishPipeline = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       payload
     };
+    this.deps.sqliteIndex.insertMessage({
+      id: messageId,
+      subject,
+      endpointHash: "*",
+      // placeholder — not a Maildir endpoint
+      status: "delivered",
+      createdAt: envelope.createdAt,
+      expiresAt: envelope.budget.ttl ? new Date(envelope.budget.ttl).toISOString() : null,
+      sender: options.from
+    });
     return this.deliverAndFinalize(envelope, subject, options, messageId);
   }
   /**
@@ -88505,7 +88564,8 @@ var RelayCore = class {
       deliveryPipeline: this.deliveryPipeline,
       adapterDelivery,
       adapterRegistry: options?.adapterRegistry,
-      traceStore: options?.traceStore
+      traceStore: options?.traceStore,
+      logger: options?.logger
     }, {
       maxHops: options?.maxHops ?? DEFAULT_MAX_HOPS2,
       defaultTtlMs: options?.defaultTtlMs ?? DEFAULT_TTL_MS2,
@@ -88877,6 +88937,32 @@ var BaseRelayAdapter = class {
       return;
     this._status = { ...this._status, state: "connected" };
   }
+  /**
+   * Build a callbacks object for inbound message handling sub-modules.
+   *
+   * Returns bound wrappers around `trackInbound()` and `recordError()` so
+   * sub-modules can update adapter status without holding a reference to the
+   * adapter itself.
+   */
+  makeInboundCallbacks() {
+    return {
+      trackInbound: () => this.trackInbound(),
+      recordError: (err) => this.recordError(err)
+    };
+  }
+  /**
+   * Build a callbacks object for outbound message delivery sub-modules.
+   *
+   * Returns bound wrappers around `trackOutbound()` and `recordError()` so
+   * sub-modules can update adapter status without holding a reference to the
+   * adapter itself.
+   */
+  makeOutboundCallbacks() {
+    return {
+      trackOutbound: () => this.trackOutbound(),
+      recordError: (err) => this.recordError(err)
+    };
+  }
   /** Whether the adapter has been stopped or is stopping. */
   get isStopped() {
     return this._status.state === "disconnected" || this._status.state === "stopping";
@@ -89016,6 +89102,14 @@ var GROUP_SEGMENT = "group";
 var MAX_MESSAGE_LENGTH = 4096;
 var UNKNOWN_SENDER = "unknown";
 var MAX_CONTENT_LENGTH = 32768;
+var TELEGRAM_FORMATTING_RULES = [
+  "FORMATTING RULES (you MUST follow these):",
+  "- Do NOT use Markdown tables. Telegram cannot render them.",
+  "- For structured data: use bullet points or bold key-value pairs.",
+  "- Use **bold**, _italic_, `code`, ```code blocks```, and [links](url).",
+  "- Telegram supports HTML subset: headings are not supported, use bold instead.",
+  `- Keep responses concise. Messages over ${MAX_MESSAGE_LENGTH} characters are split.`
+].join("\n");
 function buildSubject(chatId, isGroup) {
   if (isGroup) {
     return `${SUBJECT_PREFIX}.${GROUP_SEGMENT}.${chatId}`;
@@ -89077,7 +89171,8 @@ async function handleInboundMessage(ctx, relay, callbacks, logger3 = noopLogger)
       platform: "telegram",
       maxLength: MAX_MESSAGE_LENGTH,
       supportedFormats: ["text", "markdown"],
-      instructions: `Reply to subject ${subject} to respond to this Telegram message.`
+      instructions: `Reply to subject ${subject} to respond to this Telegram message.`,
+      formattingInstructions: TELEGRAM_FORMATTING_RULES
     },
     platformData: {
       chatId: chat.id,
@@ -89088,10 +89183,16 @@ async function handleInboundMessage(ctx, relay, callbacks, logger3 = noopLogger)
     }
   };
   try {
-    await relay.publish(subject, payload, {
+    const result2 = await relay.publish(subject, payload, {
       from: `${SUBJECT_PREFIX}.bot`,
       replyTo: subject
     });
+    if (result2.deliveredTo === 0 && result2.rejected?.length) {
+      const reason = result2.rejected[0]?.reason ?? "unknown";
+      callbacks.recordError(new Error(`Publish rejected: ${reason}`));
+      logger3.warn(`inbound publish rejected for chat ${chat.id}: ${reason}`);
+      return;
+    }
     callbacks.trackInbound();
     logger3.debug(`inbound from ${senderName} in chat ${chat.id}: "${text6.slice(0, 80)}${text6.length > 80 ? "\u2026" : ""}" (${text6.length} chars) \u2192 ${subject}`);
   } catch (err) {
@@ -89502,9 +89603,9 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set dirname(dirname7) {
+  set dirname(dirname8) {
     assertPath(this.basename, "dirname");
-    this.path = default2.join(dirname7 || "", this.basename);
+    this.path = default2.join(dirname8 || "", this.basename);
   }
   /**
    * Get the extname (including dot) (example: `'.js'`).
@@ -101527,37 +101628,82 @@ function formatToolDescription(toolName, input) {
   }
   return `wants to use tool \`${toolName}\``;
 }
+function extractAgentIdFromEnvelope(envelope) {
+  const payload = envelope.payload;
+  if (payload && typeof payload === "object" && "data" in payload) {
+    const data = payload.data;
+    if (data && typeof data === "object" && "agentId" in data) {
+      return data.agentId;
+    }
+  }
+  return void 0;
+}
+function extractSessionIdFromEnvelope(envelope) {
+  const payload = envelope.payload;
+  if (payload && typeof payload === "object" && "data" in payload) {
+    const data = payload.data;
+    if (data && typeof data === "object" && "ccaSessionKey" in data) {
+      return data.ccaSessionKey;
+    }
+  }
+  return void 0;
+}
+function markdownToTelegramHtml(md) {
+  let html2 = md;
+  html2 = html2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  html2 = html2.replace(/```(\w*)\n([\s\S]*?)```/g, (_m, lang, code3) => {
+    const cls = lang ? ` class="language-${lang}"` : "";
+    return `<pre><code${cls}>${code3.trimEnd()}</code></pre>`;
+  });
+  html2 = html2.replace(/`([^`]+)`/g, "<code>$1</code>");
+  html2 = html2.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  html2 = html2.replace(/\*(.+?)\*/g, "<i>$1</i>");
+  html2 = html2.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  html2 = html2.replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2">$1</a>');
+  html2 = html2.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+  return html2;
+}
 function formatForPlatform(content3, platform2) {
   switch (platform2) {
     case "slack":
       return slackifyMarkdown(content3);
     case "telegram":
-      return content3;
+      return markdownToTelegramHtml(content3);
     case "plain":
       return content3.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/_(.+?)_/g, "$1").replace(/~~(.+?)~~/g, "$1").replace(/`{3}[\s\S]*?`{3}/g, (m3) => m3.replace(/`{3}\w*\n?/g, "").trim()).replace(/`(.+?)`/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/^[*-]\s+/gm, "- ").replace(/^>\s+/gm, "").replace(/\[(.+?)\]\(.+?\)/g, "$1");
   }
 }
 
+// ../relay/dist/adapters/telegram/stream-api.js
+async function sendMessageDraft(bot, chatId, text6) {
+  await bot.api.sendMessageDraft(chatId, text6);
+}
+
 // ../relay/dist/adapters/telegram/outbound.js
 var TELEGRAM_TYPING_ACTION = "typing";
-var typingIntervals = /* @__PURE__ */ new Map();
 var TYPING_REFRESH_MS = 4e3;
 var DRAFT_UPDATE_INTERVAL_MS = 200;
 var BUFFER_TTL_MS = 5 * 60 * 1e3;
-var lastDraftUpdate = /* @__PURE__ */ new Map();
-var callbackIdMap = /* @__PURE__ */ new Map();
 var CALLBACK_ID_TTL_MS = 15 * 60 * 1e3;
-var pendingApprovalTimeouts = /* @__PURE__ */ new Map();
-function clearApprovalTimeout(shortKey) {
-  const timer = pendingApprovalTimeouts.get(shortKey);
+function createTelegramOutboundState() {
+  return {
+    typingIntervals: /* @__PURE__ */ new Map(),
+    lastDraftUpdate: /* @__PURE__ */ new Map(),
+    callbackIdMap: /* @__PURE__ */ new Map(),
+    pendingApprovalTimeouts: /* @__PURE__ */ new Map()
+  };
+}
+function clearApprovalTimeout(state, shortKey) {
+  const timer = state.pendingApprovalTimeouts.get(shortKey);
   if (timer) {
     clearTimeout(timer);
-    pendingApprovalTimeouts.delete(shortKey);
+    state.pendingApprovalTimeouts.delete(shortKey);
   }
 }
 async function sendAndTrack(bot, chatId, text6, startTime, callbacks) {
   try {
-    await bot.api.sendMessage(chatId, text6);
+    const html2 = formatForPlatform(text6, "telegram");
+    await bot.api.sendMessage(chatId, html2, { parse_mode: "HTML" });
     callbacks.trackOutbound();
     return { success: true, durationMs: Date.now() - startTime };
   } catch (err) {
@@ -101570,7 +101716,7 @@ async function sendAndTrack(bot, chatId, text6, startTime, callbacks) {
   }
 }
 async function deliverMessage(opts) {
-  const { adapterId, subject, envelope, bot, responseBuffers, callbacks, streaming, logger: logger3 = noopLogger } = opts;
+  const { adapterId, subject, envelope, bot, responseBuffers, state, callbacks, streaming, logger: logger3 = noopLogger } = opts;
   const startTime = Date.now();
   if (envelope.from.startsWith(SUBJECT_PREFIX)) {
     logger3.debug("deliver: echo prevention \u2014 skipping self-originated message");
@@ -101595,7 +101741,7 @@ async function deliverMessage(opts) {
   for (const [id, buf] of responseBuffers) {
     if (now - buf.startedAt > BUFFER_TTL_MS) {
       responseBuffers.delete(id);
-      lastDraftUpdate.delete(id);
+      state.lastDraftUpdate.delete(id);
       logger3.warn(`buffer: reaped stale buffer for chat ${id} (age: ${Math.round((now - buf.startedAt) / 1e3)}s)`);
     }
   }
@@ -101610,12 +101756,12 @@ async function deliverMessage(opts) {
         startedAt: existing?.startedAt ?? Date.now()
       });
       if (streaming && chatId > 0) {
-        const lastUpdate = lastDraftUpdate.get(chatId) ?? 0;
+        const lastUpdate = state.lastDraftUpdate.get(chatId) ?? 0;
         if (Date.now() - lastUpdate >= DRAFT_UPDATE_INTERVAL_MS) {
-          lastDraftUpdate.set(chatId, Date.now());
+          state.lastDraftUpdate.set(chatId, Date.now());
           logger3.debug(`stream: sendMessageDraft to chat ${chatId} (${responseBuffers.get(chatId).text.length} chars)`);
           try {
-            await bot.api.sendMessageDraft(chatId, responseBuffers.get(chatId).text);
+            await sendMessageDraft(bot, chatId, responseBuffers.get(chatId).text);
           } catch {
           }
         }
@@ -101627,7 +101773,7 @@ async function deliverMessage(opts) {
       logger3.debug(`deliver: error to chat ${chatId}: "${errorMsg.slice(0, 100)}"`);
       const buffered = responseBuffers.get(chatId)?.text ?? "";
       responseBuffers.delete(chatId);
-      lastDraftUpdate.delete(chatId);
+      state.lastDraftUpdate.delete(chatId);
       const text7 = buffered ? truncateText(`${buffered}
 
 [Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH) : truncateText(`[Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH);
@@ -101637,7 +101783,7 @@ async function deliverMessage(opts) {
       const buffered = responseBuffers.get(chatId);
       logger3.debug(`deliver: done for chat ${chatId} (buffered: ${buffered ? `${buffered.text.length} chars` : "empty"})`);
       responseBuffers.delete(chatId);
-      lastDraftUpdate.delete(chatId);
+      state.lastDraftUpdate.delete(chatId);
       if (buffered) {
         return sendAndTrack(bot, chatId, truncateText(buffered.text, MAX_MESSAGE_LENGTH), startTime, callbacks);
       }
@@ -101650,10 +101796,10 @@ async function deliverMessage(opts) {
         const buffered = responseBuffers.get(chatId);
         if (buffered?.text) {
           responseBuffers.delete(chatId);
-          lastDraftUpdate.delete(chatId);
+          state.lastDraftUpdate.delete(chatId);
           await sendAndTrack(bot, chatId, truncateText(buffered.text, MAX_MESSAGE_LENGTH), startTime, callbacks);
         }
-        return handleApprovalRequired(bot, chatId, data, envelope, callbacks, startTime);
+        return handleApprovalRequired(bot, chatId, data, envelope, state, callbacks, startTime);
       }
     }
     logger3.debug(`deliver: dropping stream event '${eventType}' (whitelist)`);
@@ -101664,14 +101810,14 @@ async function deliverMessage(opts) {
   logger3.debug(`deliver: standard payload to chat ${chatId} (${text6.length} chars)`);
   return sendAndTrack(bot, chatId, text6, startTime, callbacks);
 }
-async function handleTypingSignal(bot, subject, state) {
+async function handleTypingSignal(bot, subject, outboundState, signalState) {
   if (!bot)
     return;
   const chatId = extractChatId(subject);
   if (chatId === null)
     return;
-  if (state === "active") {
-    clearTypingInterval(chatId);
+  if (signalState === "active") {
+    clearTypingInterval(outboundState, chatId);
     try {
       await bot.api.sendChatAction(chatId, TELEGRAM_TYPING_ACTION);
     } catch {
@@ -101680,43 +101826,33 @@ async function handleTypingSignal(bot, subject, state) {
       try {
         await bot.api.sendChatAction(chatId, TELEGRAM_TYPING_ACTION);
       } catch {
-        clearTypingInterval(chatId);
+        clearTypingInterval(outboundState, chatId);
       }
     }, TYPING_REFRESH_MS);
-    typingIntervals.set(chatId, intervalId);
+    outboundState.typingIntervals.set(chatId, intervalId);
   } else {
-    clearTypingInterval(chatId);
+    clearTypingInterval(outboundState, chatId);
   }
 }
-function clearTypingInterval(chatId) {
-  const existing = typingIntervals.get(chatId);
+function clearTypingInterval(state, chatId) {
+  const existing = state.typingIntervals.get(chatId);
   if (existing !== void 0) {
     clearInterval(existing);
-    typingIntervals.delete(chatId);
+    state.typingIntervals.delete(chatId);
   }
 }
-function clearAllTypingIntervals() {
-  for (const interval of typingIntervals.values())
+function clearAllTypingIntervals(state) {
+  for (const interval of state.typingIntervals.values())
     clearInterval(interval);
-  typingIntervals.clear();
-  lastDraftUpdate.clear();
+  state.typingIntervals.clear();
+  state.lastDraftUpdate.clear();
 }
-function extractAgentIdFromEnvelope(envelope) {
-  const payload = envelope.payload;
-  const data = payload?.data;
-  return data?.agentId ?? "unknown";
-}
-function extractSessionIdFromEnvelope(envelope) {
-  const payload = envelope.payload;
-  const data = payload?.data;
-  return data?.ccaSessionKey ?? "unknown";
-}
-async function handleApprovalRequired(bot, chatId, data, envelope, callbacks, startTime) {
-  const agentId = extractAgentIdFromEnvelope(envelope);
-  const sessionId = extractSessionIdFromEnvelope(envelope);
+async function handleApprovalRequired(bot, chatId, data, envelope, state, callbacks, startTime) {
+  const agentId = extractAgentIdFromEnvelope(envelope) ?? "unknown";
+  const sessionId = extractSessionIdFromEnvelope(envelope) ?? "unknown";
   const shortKey = randomBytes(6).toString("hex");
-  callbackIdMap.set(shortKey, { toolCallId: data.toolCallId, sessionId, agentId });
-  setTimeout(() => callbackIdMap.delete(shortKey), CALLBACK_ID_TTL_MS);
+  state.callbackIdMap.set(shortKey, { toolCallId: data.toolCallId, sessionId, agentId });
+  setTimeout(() => state.callbackIdMap.delete(shortKey), CALLBACK_ID_TTL_MS);
   const toolDescription = formatToolDescription(data.toolName, data.input);
   const inputPreview = truncateText(data.input, 400);
   const messageText = `*Tool Approval Required*
@@ -101739,15 +101875,15 @@ ${inputPreview}
     });
     if (data.timeoutMs && data.timeoutMs > 0) {
       const timer = setTimeout(async () => {
-        pendingApprovalTimeouts.delete(shortKey);
-        callbackIdMap.delete(shortKey);
+        state.pendingApprovalTimeouts.delete(shortKey);
+        state.callbackIdMap.delete(shortKey);
         try {
           await bot.api.editMessageText(chatId, sent.message_id, `\u23F0 *Tool Approval Timed Out*
 ~~\`${data.toolName}\`~~ ${toolDescription}`, { parse_mode: "Markdown" });
         } catch {
         }
       }, data.timeoutMs);
-      pendingApprovalTimeouts.set(shortKey, timer);
+      state.pendingApprovalTimeouts.set(shortKey, timer);
     }
     callbacks.trackOutbound();
     return { success: true, durationMs: Date.now() - startTime };
@@ -101913,6 +102049,8 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
   reconnectAttempts = 0;
   reconnectTimer = null;
   responseBuffers = /* @__PURE__ */ new Map();
+  /** Instance-scoped outbound state — prevents cross-adapter leakage when multiInstance: true. */
+  outboundState = createTelegramOutboundState();
   constructor(id, config, displayName = "Telegram") {
     super(id, SUBJECT_PREFIX, displayName);
     this.config = config;
@@ -101935,14 +102073,14 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
     bot.on("callback_query:data", async (ctx) => {
       try {
         const data = JSON.parse(ctx.callbackQuery.data);
-        const entry = callbackIdMap.get(data.k);
+        const entry = this.outboundState.callbackIdMap.get(data.k);
         if (!entry) {
           await ctx.answerCallbackQuery({ text: "This approval has expired." });
           return;
         }
         const approved = data.a === 1;
-        callbackIdMap.delete(data.k);
-        clearApprovalTimeout(data.k);
+        this.outboundState.callbackIdMap.delete(data.k);
+        clearApprovalTimeout(this.outboundState, data.k);
         const opts = { from: `telegram:${ctx.from.id}` };
         await relay.publish(`relay.system.approval.${entry.agentId}`, {
           type: "approval_response",
@@ -101968,7 +102106,7 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
     this.bot = bot;
     this.signalUnsub = relay.onSignal(`${SUBJECT_PREFIX}.>`, (subject, signal) => {
       if (signal.type === "typing")
-        void handleTypingSignal(this.bot, subject, signal.state);
+        void handleTypingSignal(this.bot, subject, this.outboundState, signal.state);
     });
     if (this.config.mode === "webhook") {
       this.webhookServer = await startWebhookMode(bot, this.id, this.config.webhookUrl, this.config.webhookPort, this.config.webhookSecret);
@@ -101986,7 +102124,11 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
       this.signalUnsub();
       this.signalUnsub = null;
     }
-    clearAllTypingIntervals();
+    clearAllTypingIntervals(this.outboundState);
+    for (const timer of this.outboundState.pendingApprovalTimeouts.values())
+      clearTimeout(timer);
+    this.outboundState.pendingApprovalTimeouts.clear();
+    this.outboundState.callbackIdMap.clear();
     if (this.bot) {
       if (this.config.mode === "webhook") {
         try {
@@ -102015,26 +102157,13 @@ var TelegramAdapter = class _TelegramAdapter extends BaseRelayAdapter {
       envelope,
       bot: this.bot,
       responseBuffers: this.responseBuffers,
+      state: this.outboundState,
       callbacks: this.makeOutboundCallbacks(),
       streaming: this.config.streaming ?? true,
       logger: this.logger
     });
   }
   // --- Private helpers ---
-  /** Build callbacks for inbound message handling. */
-  makeInboundCallbacks() {
-    return {
-      trackInbound: () => this.trackInbound(),
-      recordError: (err) => this.recordError(err)
-    };
-  }
-  /** Build callbacks for outbound message delivery. */
-  makeOutboundCallbacks() {
-    return {
-      trackOutbound: () => this.trackOutbound(),
-      recordError: (err) => this.recordError(err)
-    };
-  }
   /** Start grammy bot in long-polling mode with eager token validation. */
   async startPollingMode(bot) {
     await bot.init();
@@ -102153,20 +102282,11 @@ Leave empty if no custom headers are needed.`
     }
   ]
 };
-var WebhookAdapter = class {
-  id;
-  subjectPrefix;
-  displayName;
+var WebhookAdapter = class extends BaseRelayAdapter {
   config;
-  relay = null;
   /** Tracks nonces to prevent replay attacks. Maps `{adapterId}:{nonce}` -> expiresAt timestamp. */
   nonceMap = /* @__PURE__ */ new Map();
   nonceInterval = null;
-  status = {
-    state: "disconnected",
-    messageCount: { inbound: 0, outbound: 0 },
-    errorCount: 0
-  };
   /**
    * Create a new WebhookAdapter instance.
    *
@@ -102175,50 +102295,33 @@ var WebhookAdapter = class {
    * @param displayName - Human-readable name (defaults to `Webhook ({id})`)
    */
   constructor(id, config, displayName) {
-    this.id = id;
+    super(id, config.inbound.subject, displayName ?? `Webhook (${id})`);
     this.config = config;
-    this.subjectPrefix = config.inbound.subject;
-    this.displayName = displayName ?? `Webhook (${id})`;
   }
   /**
-   * Start the adapter — store the relay publisher and begin nonce pruning.
+   * Connect hook — begin nonce pruning interval.
    *
    * This adapter has no external connection to establish; it relies on the
    * Express route calling `handleInbound()` for inbound messages. The nonce
    * pruning interval is started here to prevent unbounded memory growth.
+   * The relay publisher reference is stored by {@link BaseRelayAdapter.start}.
    *
-   * Idempotent: safe to call multiple times.
-   *
-   * @param relay - The RelayPublisher to publish inbound messages to
+   * @param _relay - The RelayPublisher (stored by base class; unused here)
    */
-  async start(relay) {
-    if (this.status.state === "connected")
-      return;
-    this.relay = relay;
-    this.status = {
-      ...this.status,
-      state: "connected",
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
+  async _start(_relay) {
     this.nonceInterval = setInterval(() => {
       this.pruneExpiredNonces();
     }, NONCE_PRUNE_INTERVAL_MS);
   }
   /**
-   * Stop the adapter — clear nonce state and pruning interval.
-   *
-   * Idempotent: safe to call multiple times.
+   * Disconnect hook — clear nonce state and pruning interval.
    */
-  async stop() {
-    if (this.status.state === "disconnected")
-      return;
+  async _stop() {
     if (this.nonceInterval !== null) {
       clearInterval(this.nonceInterval);
       this.nonceInterval = null;
     }
     this.nonceMap.clear();
-    this.relay = null;
-    this.status = { ...this.status, state: "disconnected" };
   }
   /**
    * Handle an inbound webhook HTTP POST request.
@@ -102261,24 +102364,18 @@ var WebhookAdapter = class {
         metadata: { platform: "webhook", adapterId: this.id, nonce },
         responseContext: { platform: "webhook" }
       };
-      await this.relay.publish(this.config.inbound.subject, payload, {
+      const result2 = await this.relay.publish(this.config.inbound.subject, payload, {
         from: `relay.webhook.${this.id}`
       });
-      this.status = {
-        ...this.status,
-        messageCount: {
-          ...this.status.messageCount,
-          inbound: this.status.messageCount.inbound + 1
-        }
-      };
+      if (result2.deliveredTo === 0 && result2.rejected?.length) {
+        const reason = result2.rejected[0]?.reason ?? "unknown";
+        this.recordError(new Error(`Publish rejected: ${reason}`));
+        return { ok: false, error: `Publish rejected: ${reason}` };
+      }
+      this.trackInbound();
       return { ok: true };
     } catch (err) {
-      this.status = {
-        ...this.status,
-        errorCount: this.status.errorCount + 1,
-        lastError: err instanceof Error ? err.message : String(err),
-        lastErrorAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      this.recordError(err);
       return { ok: false, error: "Publish failed" };
     }
   }
@@ -102313,41 +102410,17 @@ var WebhookAdapter = class {
       });
       if (!response.ok) {
         const error = `Outbound delivery failed: HTTP ${response.status}`;
-        this.status = {
-          ...this.status,
-          errorCount: this.status.errorCount + 1,
-          lastError: error,
-          lastErrorAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
+        this.recordError(error);
         return { success: false, error, durationMs: Date.now() - startTime };
       }
-      this.status = {
-        ...this.status,
-        messageCount: {
-          ...this.status.messageCount,
-          outbound: this.status.messageCount.outbound + 1
-        }
-      };
+      this.trackOutbound();
       return { success: true, durationMs: Date.now() - startTime };
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
-      this.status = {
-        ...this.status,
-        errorCount: this.status.errorCount + 1,
-        lastError: error,
-        lastErrorAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      this.recordError(err);
       return { success: false, error, durationMs: Date.now() - startTime };
     }
   }
-  /**
-   * Get the current adapter status.
-   *
-   * Returns a shallow copy to prevent external mutation of internal state.
-   */
-  getStatus() {
-    return { ...this.status };
-  }
   /** Remove expired nonces from the in-memory map. */
   pruneExpiredNonces() {
     const now = Date.now();
@@ -102391,6 +102464,15 @@ var SUBJECT_PREFIX2 = "relay.human.slack";
 var GROUP_SEGMENT2 = "group";
 var MAX_MESSAGE_LENGTH2 = 4e3;
 var MAX_CONTENT_LENGTH2 = 32768;
+var SLACK_FORMATTING_RULES = [
+  "FORMATTING RULES (you MUST follow these):",
+  "- Do NOT use Markdown tables (| col | col |). Slack cannot render them.",
+  "- For structured data: use bullet points, numbered lists, or bold key-value pairs.",
+  '- Example: instead of a table, write "*Name*: Alice\\n*Role*: Engineer"',
+  "- Use *bold* (single asterisk), _italic_ (underscore), `code`, ```code blocks```.",
+  "- Do NOT use ## headings \u2014 Slack ignores them. Use *bold text* for section titles.",
+  `- Keep responses concise. Slack messages over ${MAX_MESSAGE_LENGTH2} characters are truncated.`
+].join("\n");
 var SKIP_SUBTYPES = /* @__PURE__ */ new Set([
   "channel_join",
   "channel_leave",
@@ -102483,7 +102565,7 @@ function clearCaches() {
   userNameCache.clear();
   channelNameCache.clear();
 }
-async function handleInboundMessage2(event, client, relay, botUserId, callbacks, logger3 = noopLogger) {
+async function handleInboundMessage2(event, client, relay, botUserId, callbacks, logger3 = noopLogger, typingIndicator = "none", pendingReactions) {
   if (event.user === botUserId) {
     logger3.debug(`inbound skipped: echo (own user ${botUserId})`);
     return;
@@ -102514,7 +102596,8 @@ async function handleInboundMessage2(event, client, relay, botUserId, callbacks,
       platform: "slack",
       maxLength: MAX_MESSAGE_LENGTH2,
       supportedFormats: ["text", "mrkdwn"],
-      instructions: `Reply to subject ${subject} to respond to this Slack message.`
+      instructions: `Reply to subject ${subject} to respond to this Slack message.`,
+      formattingInstructions: SLACK_FORMATTING_RULES
     },
     platformData: {
       channelId: event.channel,
@@ -102525,47 +102608,67 @@ async function handleInboundMessage2(event, client, relay, botUserId, callbacks,
     }
   };
   try {
-    await relay.publish(subject, payload, {
+    const result2 = await relay.publish(subject, payload, {
       from: `${SUBJECT_PREFIX2}.bot`,
       replyTo: subject
     });
+    if (result2.deliveredTo === 0 && result2.rejected?.length) {
+      const reason = result2.rejected[0]?.reason ?? "unknown";
+      callbacks.recordError(new Error(`Publish rejected: ${reason}`));
+      logger3.warn(`inbound publish rejected for ${event.channel}: ${reason}`);
+      return;
+    }
     callbacks.trackInbound();
     logger3.debug(`inbound from ${senderName} in ${event.channel}: "${content3.slice(0, 80)}${content3.length > 80 ? "\u2026" : ""}" (${content3.length} chars) \u2192 ${subject}`);
+    if (typingIndicator === "reaction") {
+      if (pendingReactions) {
+        const queue2 = pendingReactions.get(event.channel) ?? [];
+        queue2.push(event.ts);
+        pendingReactions.set(event.channel, queue2);
+      }
+      client.reactions.add({ channel: event.channel, name: "hourglass_flowing_sand", timestamp: event.ts }).then(() => {
+        logger3.debug(`inbound: added typing reaction to ${event.channel}:${event.ts}`);
+      }).catch((err) => {
+        if (pendingReactions) {
+          const queue2 = pendingReactions.get(event.channel);
+          if (queue2) {
+            const idx = queue2.indexOf(event.ts);
+            if (idx !== -1)
+              queue2.splice(idx, 1);
+            if (queue2.length === 0)
+              pendingReactions.delete(event.channel);
+          }
+        }
+        logger3.warn(`inbound: failed to add typing reaction to ${event.channel}:${event.ts}: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    }
   } catch (err) {
     callbacks.recordError(err);
     logger3.warn(`inbound publish failed for ${event.channel}:`, err instanceof Error ? err.message : String(err));
   }
 }
 
-// ../relay/dist/adapters/slack/outbound.js
+// ../relay/dist/adapters/slack/stream.js
 import { randomUUID as randomUUID4 } from "node:crypto";
-var STREAM_UPDATE_INTERVAL_MS = 1e3;
-var STREAM_TTL_MS = 5 * 60 * 1e3;
-var pendingApprovalTimeouts2 = /* @__PURE__ */ new Map();
-function clearApprovalTimeout2(toolCallId) {
-  const entry = pendingApprovalTimeouts2.get(toolCallId);
-  if (entry) {
-    clearTimeout(entry.timer);
-    pendingApprovalTimeouts2.delete(toolCallId);
-  }
+
+// ../relay/dist/adapters/slack/stream-api.js
+function asStreamClient(client) {
+  return client;
 }
-function streamKey(channelId, threadTs) {
-  return threadTs ? `${channelId}:${threadTs}` : channelId;
+async function startStream(client, channel, threadTs) {
+  const result2 = await asStreamClient(client).chat.startStream({ channel, thread_ts: threadTs });
+  return result2.stream_id ?? "";
 }
-function resolveThreadTs(envelope) {
-  const payload = envelope.payload;
-  if (payload === null || typeof payload !== "object")
-    return void 0;
-  const obj = payload;
-  const pd = obj.platformData;
-  if (!pd)
-    return void 0;
-  if (typeof pd.threadTs === "string" && pd.threadTs)
-    return pd.threadTs;
-  if (typeof pd.ts === "string" && pd.ts)
-    return pd.ts;
-  return void 0;
+async function appendStream(client, streamId, text6) {
+  await asStreamClient(client).chat.appendStream({ stream_id: streamId, text: text6 });
 }
+async function stopStream(client, streamId) {
+  await asStreamClient(client).chat.stopStream({ stream_id: streamId });
+}
+
+// ../relay/dist/adapters/slack/stream.js
+var STREAM_UPDATE_INTERVAL_MS = 1e3;
+var STREAM_TTL_MS = 5 * 60 * 1e3;
 async function wrapSlackCall(fn, callbacks, startTime, trackDelivery = false) {
   try {
     await fn();
@@ -102581,28 +102684,50 @@ async function wrapSlackCall(fn, callbacks, startTime, trackDelivery = false) {
     };
   }
 }
-function addTypingReaction(client, channelId, threadTs, typingIndicator) {
+function buildStreamKey(channelId, streamKeyTs) {
+  return streamKeyTs ? `${channelId}:${streamKeyTs}` : channelId;
+}
+function addTypingReaction(client, channelId, threadTs, typingIndicator, logger3) {
   if (typingIndicator !== "reaction" || !threadTs)
     return;
-  void client.reactions.add({
-    channel: channelId,
-    name: "hourglass_flowing_sand",
-    timestamp: threadTs
-  }).catch(() => {
+  void client.reactions.add({ channel: channelId, name: "hourglass_flowing_sand", timestamp: threadTs }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.includes("already_reacted")) {
+      logger3?.warn(`stream: failed to add typing reaction to ${channelId}:${threadTs}: ${msg}`);
+    }
   });
 }
-function removeTypingReaction(client, channelId, threadTs, typingIndicator) {
+function removeTypingReaction(client, channelId, threadTs, typingIndicator, logger3) {
   if (typingIndicator !== "reaction" || !threadTs)
     return;
-  void client.reactions.remove({
-    channel: channelId,
-    name: "hourglass_flowing_sand",
-    timestamp: threadTs
-  }).catch(() => {
+  void client.reactions.remove({ channel: channelId, name: "hourglass_flowing_sand", timestamp: threadTs }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.includes("no_reaction")) {
+      logger3?.warn(`stream: failed to remove typing reaction from ${channelId}:${threadTs}: ${msg}`);
+    }
+  });
+}
+function removePendingReaction(client, channelId, typingIndicator, pendingReactions, logger3) {
+  if (typingIndicator !== "reaction")
+    return;
+  const queue2 = pendingReactions.get(channelId);
+  if (!queue2 || queue2.length === 0)
+    return;
+  const messageTs = queue2.shift();
+  if (queue2.length === 0)
+    pendingReactions.delete(channelId);
+  void client.reactions.remove({ channel: channelId, name: "hourglass_flowing_sand", timestamp: messageTs }).then(() => {
+    logger3?.debug?.(`stream: removed pending typing reaction from ${channelId}:${messageTs}`);
+  }).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.includes("no_reaction")) {
+      logger3?.warn(`stream: failed to remove pending typing reaction from ${channelId}:${messageTs}: ${msg}`);
+    }
   });
 }
-async function handleTextDelta(channelId, textChunk, threadTs, client, streamState, callbacks, startTime, streaming, nativeStreaming, typingIndicator, streamKeyTs) {
-  const key = streamKey(channelId, streamKeyTs);
+async function handleTextDelta(textChunk, streaming, nativeStreaming, ctx) {
+  const { channelId, threadTs, client, streamState, callbacks, startTime, typingIndicator, streamKeyTs, logger: logger3 } = ctx;
+  const key = buildStreamKey(channelId, streamKeyTs);
   const existing = streamState.get(key);
   if (!streaming) {
     if (existing) {
@@ -102612,23 +102737,19 @@ async function handleTextDelta(channelId, textChunk, threadTs, client, streamSta
         channelId,
         threadTs: threadTs ?? "",
         messageTs: "",
-        // No message posted yet
         accumulatedText: textChunk,
         lastUpdateAt: 0,
         startedAt: Date.now(),
         streamId: randomUUID4()
       });
-      addTypingReaction(client, channelId, threadTs, typingIndicator);
+      addTypingReaction(client, channelId, threadTs, typingIndicator, logger3);
     }
     return { success: true, durationMs: Date.now() - startTime };
   }
   if (existing) {
     existing.accumulatedText += textChunk;
     if (existing.nativeStreamId) {
-      return wrapSlackCall(() => client.chat.appendStream({
-        stream_id: existing.nativeStreamId,
-        text: formatForPlatform(textChunk, "slack")
-      }), callbacks, startTime);
+      return wrapSlackCall(() => appendStream(client, existing.nativeStreamId, formatForPlatform(textChunk, "slack")), callbacks, startTime);
     }
     const now = Date.now();
     if (now - existing.lastUpdateAt < STREAM_UPDATE_INTERVAL_MS) {
@@ -102636,49 +102757,38 @@ async function handleTextDelta(channelId, textChunk, threadTs, client, streamSta
     }
     existing.lastUpdateAt = now;
     const formatted = formatForPlatform(existing.accumulatedText, "slack");
-    const streamText = formatted.replace(/\n{2,}/g, "\n");
     return wrapSlackCall(() => client.chat.update({
       channel: channelId,
       ts: existing.messageTs,
-      text: truncateText(streamText, MAX_MESSAGE_LENGTH2)
+      text: truncateText(formatted.replace(/\n{2,}/g, "\n"), MAX_MESSAGE_LENGTH2)
     }), callbacks, startTime);
   }
   if (nativeStreaming && threadTs) {
     try {
-      const slackClient = client;
-      const result2 = await slackClient.chat.startStream({
-        channel: channelId,
-        thread_ts: threadTs
-      });
-      const nativeStreamId = result2.stream_id ?? "";
+      const nativeStreamId = await startStream(client, channelId, threadTs);
       const now = Date.now();
       streamState.set(key, {
         channelId,
-        threadTs: threadTs ?? "",
+        threadTs,
         messageTs: "",
-        // Not used in native streaming
         accumulatedText: textChunk,
         lastUpdateAt: now,
         startedAt: now,
         streamId: randomUUID4(),
         nativeStreamId
       });
-      await slackClient.chat.appendStream({
-        stream_id: nativeStreamId,
-        text: formatForPlatform(textChunk, "slack")
-      });
-      addTypingReaction(client, channelId, threadTs, typingIndicator);
+      await appendStream(client, nativeStreamId, formatForPlatform(textChunk, "slack"));
+      addTypingReaction(client, channelId, threadTs, typingIndicator, logger3);
       return { success: true, durationMs: Date.now() - startTime };
     } catch (err) {
       callbacks.recordError(err);
     }
   }
   try {
-    const mrkdwn = formatForPlatform(textChunk, "slack");
     const now = Date.now();
     const result2 = await client.chat.postMessage({
       channel: channelId,
-      text: truncateText(mrkdwn, MAX_MESSAGE_LENGTH2),
+      text: truncateText(formatForPlatform(textChunk, "slack"), MAX_MESSAGE_LENGTH2),
       ...threadTs ? { thread_ts: threadTs } : {}
     });
     streamState.set(key, {
@@ -102690,26 +102800,22 @@ async function handleTextDelta(channelId, textChunk, threadTs, client, streamSta
       startedAt: now,
       streamId: randomUUID4()
     });
-    addTypingReaction(client, channelId, threadTs, typingIndicator);
+    addTypingReaction(client, channelId, threadTs, typingIndicator, logger3);
     return { success: true, durationMs: now - startTime };
   } catch (err) {
     callbacks.recordError(err);
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : String(err),
-      durationMs: Date.now() - startTime
-    };
+    return { success: false, error: err instanceof Error ? err.message : String(err), durationMs: Date.now() - startTime };
   }
 }
-async function flushStreamBuffer(channelId, threadTs, client, streamState, callbacks, streamKeyTs) {
-  const key = streamKey(channelId, streamKeyTs);
+async function flushStreamBuffer(ctx) {
+  const { channelId, threadTs, client, streamState, callbacks, streamKeyTs } = ctx;
+  const key = buildStreamKey(channelId, streamKeyTs);
   const existing = streamState.get(key);
   if (!existing || !existing.accumulatedText)
     return;
   if (existing.nativeStreamId) {
-    const slackClient = client;
     try {
-      await slackClient.chat.stopStream({ stream_id: existing.nativeStreamId });
+      await stopStream(client, existing.nativeStreamId);
     } catch {
     }
     existing.nativeStreamId = void 0;
@@ -102740,19 +102846,21 @@ async function flushStreamBuffer(channelId, threadTs, client, streamState, callb
     callbacks.recordError(err);
   }
 }
-async function handleDone(channelId, threadTs, client, streamState, callbacks, startTime, typingIndicator, streamKeyTs) {
-  const key = streamKey(channelId, streamKeyTs);
+async function handleDone(ctx) {
+  const { channelId, threadTs, client, streamState, callbacks, startTime, typingIndicator, streamKeyTs, pendingReactions, logger: logger3 } = ctx;
+  const key = buildStreamKey(channelId, streamKeyTs);
   const existing = streamState.get(key);
   streamState.delete(key);
+  removePendingReaction(client, channelId, typingIndicator, pendingReactions, logger3);
   if (existing?.threadTs) {
-    removeTypingReaction(client, channelId, existing.threadTs, typingIndicator);
+    removeTypingReaction(client, channelId, existing.threadTs, typingIndicator, logger3);
   }
   if (!existing) {
+    logger3?.warn(`stream: done received for ${channelId} with no active stream (empty response \u2014 user may see no output)`);
     return { success: true, durationMs: Date.now() - startTime };
   }
   if (existing.nativeStreamId) {
-    const slackClient = client;
-    return wrapSlackCall(() => slackClient.chat.stopStream({ stream_id: existing.nativeStreamId }), callbacks, startTime, true);
+    return wrapSlackCall(() => stopStream(client, existing.nativeStreamId), callbacks, startTime, true);
   }
   if (!existing.messageTs) {
     return wrapSlackCall(() => client.chat.postMessage({
@@ -102767,27 +102875,24 @@ async function handleDone(channelId, threadTs, client, streamState, callbacks, s
     text: truncateText(formatForPlatform(existing.accumulatedText, "slack"), MAX_MESSAGE_LENGTH2)
   }), callbacks, startTime, true);
 }
-async function handleError(channelId, errorMsg, threadTs, client, streamState, callbacks, startTime, typingIndicator, streamKeyTs) {
-  const key = streamKey(channelId, streamKeyTs);
+async function handleError(errorMsg, ctx) {
+  const { channelId, threadTs, client, streamState, callbacks, startTime, typingIndicator, streamKeyTs, pendingReactions, logger: logger3 } = ctx;
+  const key = buildStreamKey(channelId, streamKeyTs);
   const existing = streamState.get(key);
   streamState.delete(key);
+  removePendingReaction(client, channelId, typingIndicator, pendingReactions, logger3);
   if (existing?.threadTs) {
-    removeTypingReaction(client, channelId, existing.threadTs, typingIndicator);
+    removeTypingReaction(client, channelId, existing.threadTs, typingIndicator, logger3);
   }
   if (existing) {
     if (existing.nativeStreamId) {
-      const slackClient = client;
-      const errorSuffix = formatForPlatform(`
-
-[Error: ${errorMsg}]`, "slack");
       try {
-        await slackClient.chat.appendStream({
-          stream_id: existing.nativeStreamId,
-          text: errorSuffix
-        });
+        await appendStream(client, existing.nativeStreamId, formatForPlatform(`
+
+[Error: ${errorMsg}]`, "slack"));
       } catch {
       }
-      return wrapSlackCall(() => slackClient.chat.stopStream({ stream_id: existing.nativeStreamId }), callbacks, startTime, true);
+      return wrapSlackCall(() => stopStream(client, existing.nativeStreamId), callbacks, startTime, true);
     }
     const finalText = truncateText(`${formatForPlatform(existing.accumulatedText, "slack")}
 
@@ -102799,101 +102904,35 @@ async function handleError(channelId, errorMsg, threadTs, client, streamState, c
         ...threadTs ? { thread_ts: threadTs } : {}
       }), callbacks, startTime, true);
     }
-    return wrapSlackCall(() => client.chat.update({
-      channel: channelId,
-      ts: existing.messageTs,
-      text: finalText
-    }), callbacks, startTime, true);
+    return wrapSlackCall(() => client.chat.update({ channel: channelId, ts: existing.messageTs, text: finalText }), callbacks, startTime, true);
   }
-  const text6 = truncateText(`[Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH2);
   return wrapSlackCall(() => client.chat.postMessage({
     channel: channelId,
-    text: text6,
+    text: truncateText(`[Error: ${errorMsg}]`, MAX_MESSAGE_LENGTH2),
     ...threadTs ? { thread_ts: threadTs } : {}
   }), callbacks, startTime, true);
 }
-async function deliverMessage2(opts) {
-  const { adapterId, subject, envelope, client, streamState, callbacks, logger: logger3 = noopLogger } = opts;
-  const startTime = Date.now();
-  for (const [key, stream] of streamState) {
-    if (startTime - stream.startedAt > STREAM_TTL_MS) {
-      streamState.delete(key);
-      logger3.warn(`stream: reaped orphaned stream for ${key} (age: ${Math.round((startTime - stream.startedAt) / 1e3)}s)`);
-    }
-  }
-  if (envelope.from.startsWith(SUBJECT_PREFIX2)) {
-    logger3.debug("deliver: echo prevention \u2014 skipping self-originated message");
-    return { success: true, durationMs: Date.now() - startTime };
-  }
-  if (!client) {
-    return {
-      success: false,
-      error: `SlackAdapter(${adapterId}): not started`,
-      durationMs: Date.now() - startTime
-    };
-  }
-  const channelId = extractChannelId(subject);
-  if (!channelId) {
-    return {
-      success: false,
-      error: `SlackAdapter(${adapterId}): cannot extract channel ID from subject '${subject}'`,
-      durationMs: Date.now() - startTime
-    };
-  }
-  const threadTs = resolveThreadTs(envelope);
-  const payloadObj = envelope.payload && typeof envelope.payload === "object" ? envelope.payload : void 0;
-  const payloadCorrelationId = payloadObj?.correlationId;
-  const streamKeyTs = threadTs ?? payloadCorrelationId ?? envelope.from;
-  const eventType = detectStreamEventType(envelope.payload);
-  if (eventType) {
-    const textChunk = extractTextDelta(envelope.payload);
-    if (textChunk) {
-      logger3.debug(`deliver: text_delta to ${channelId} (${textChunk.length} chars, streaming=${opts.streaming ? opts.nativeStreaming ? "native" : "legacy" : "buffered"})`);
-      return handleTextDelta(channelId, textChunk, threadTs, client, streamState, callbacks, startTime, opts.streaming, opts.nativeStreaming, opts.typingIndicator, streamKeyTs);
-    }
-    const errorMsg = extractErrorMessage(envelope.payload);
-    if (errorMsg) {
-      logger3.debug(`deliver: error to ${channelId}: "${errorMsg.slice(0, 100)}"`);
-      return handleError(channelId, errorMsg, threadTs, client, streamState, callbacks, startTime, opts.typingIndicator, streamKeyTs);
-    }
-    if (eventType === "done") {
-      logger3.debug(`deliver: done for ${channelId}`);
-      return handleDone(channelId, threadTs, client, streamState, callbacks, startTime, opts.typingIndicator, streamKeyTs);
-    }
-    if (eventType === "approval_required") {
-      const approvalData = extractApprovalData(envelope.payload);
-      if (approvalData) {
-        logger3.debug(`deliver: approval_required for tool '${approvalData.toolName}' to ${channelId}`);
-        await flushStreamBuffer(channelId, threadTs, client, streamState, callbacks, streamKeyTs);
-        return handleApprovalRequired2(channelId, threadTs, approvalData, envelope, client, callbacks, startTime);
-      }
-    }
-    logger3.debug(`deliver: dropping stream event '${eventType}' (whitelist)`);
-    return { success: true, durationMs: Date.now() - startTime };
-  }
-  const content3 = extractPayloadContent(envelope.payload);
-  const mrkdwn = formatForPlatform(content3, "slack");
-  const text6 = truncateText(mrkdwn, MAX_MESSAGE_LENGTH2);
-  logger3.debug(`deliver: standard payload to ${channelId} (${text6.length} chars)`);
-  return wrapSlackCall(() => client.chat.postMessage({
-    channel: channelId,
-    text: text6,
-    ...threadTs ? { thread_ts: threadTs } : {}
-  }), callbacks, startTime, true);
+
+// ../relay/dist/adapters/slack/approval.js
+function createSlackOutboundState() {
+  return { pendingApprovalTimeouts: /* @__PURE__ */ new Map() };
 }
-function extractAgentIdFromEnvelope2(envelope) {
-  const payload = envelope.payload;
-  const data = payload?.data;
-  return data?.agentId ?? "unknown";
+function clearAllApprovalTimeouts(state) {
+  for (const entry of state.pendingApprovalTimeouts.values()) {
+    clearTimeout(entry.timer);
+  }
+  state.pendingApprovalTimeouts.clear();
 }
-function extractSessionIdFromEnvelope2(envelope) {
-  const payload = envelope.payload;
-  const data = payload?.data;
-  return data?.ccaSessionKey ?? "unknown";
+function clearApprovalTimeout2(state, toolCallId) {
+  const entry = state.pendingApprovalTimeouts.get(toolCallId);
+  if (entry) {
+    clearTimeout(entry.timer);
+    state.pendingApprovalTimeouts.delete(toolCallId);
+  }
 }
-async function handleApprovalRequired2(channelId, threadTs, data, envelope, client, callbacks, startTime) {
-  const agentId = extractAgentIdFromEnvelope2(envelope);
-  const sessionId = extractSessionIdFromEnvelope2(envelope);
+async function handleApprovalRequired2(channelId, threadTs, data, envelope, client, callbacks, startTime, state) {
+  const agentId = extractAgentIdFromEnvelope(envelope) ?? "unknown";
+  const sessionId = extractSessionIdFromEnvelope(envelope) ?? "unknown";
   const inputPreview = truncateText(data.input, 500);
   const toolDescription = formatToolDescription(data.toolName, data.input);
   const buttonValue = JSON.stringify({
@@ -102952,7 +102991,7 @@ ${inputPreview}
   if (result2.success && postedTs && data.timeoutMs > 0) {
     const msgTs = postedTs;
     const timer = setTimeout(async () => {
-      pendingApprovalTimeouts2.delete(data.toolCallId);
+      state.pendingApprovalTimeouts.delete(data.toolCallId);
       try {
         await client.chat.update({
           channel: channelId,
@@ -102968,7 +103007,7 @@ ${inputPreview}
       } catch {
       }
     }, data.timeoutMs);
-    pendingApprovalTimeouts2.set(data.toolCallId, {
+    state.pendingApprovalTimeouts.set(data.toolCallId, {
       timer,
       channelId,
       messageTs: msgTs,
@@ -102978,24 +103017,107 @@ ${inputPreview}
   return result2;
 }
 
+// ../relay/dist/adapters/slack/outbound.js
+function resolveThreadTs(envelope) {
+  const payload = envelope.payload;
+  if (payload === null || typeof payload !== "object")
+    return void 0;
+  const obj = payload;
+  const pd = obj.platformData;
+  if (!pd)
+    return void 0;
+  if (typeof pd.threadTs === "string" && pd.threadTs)
+    return pd.threadTs;
+  if (typeof pd.ts === "string" && pd.ts)
+    return pd.ts;
+  return void 0;
+}
+async function deliverMessage2(opts) {
+  const { adapterId, subject, envelope, client, streamState, pendingReactions, callbacks, logger: logger3 = noopLogger } = opts;
+  const startTime = Date.now();
+  for (const [key, stream] of streamState) {
+    if (startTime - stream.startedAt > STREAM_TTL_MS) {
+      streamState.delete(key);
+      logger3.warn(`stream: reaped orphaned stream for ${key} (age: ${Math.round((startTime - stream.startedAt) / 1e3)}s)`);
+    }
+  }
+  if (envelope.from.startsWith(SUBJECT_PREFIX2)) {
+    logger3.debug("deliver: echo prevention \u2014 skipping self-originated message");
+    return { success: true, durationMs: Date.now() - startTime };
+  }
+  if (!client) {
+    return { success: false, error: `SlackAdapter(${adapterId}): not started`, durationMs: Date.now() - startTime };
+  }
+  const channelId = extractChannelId(subject);
+  if (!channelId) {
+    return {
+      success: false,
+      error: `SlackAdapter(${adapterId}): cannot extract channel ID from subject '${subject}'`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const threadTs = resolveThreadTs(envelope);
+  const payloadObj = envelope.payload && typeof envelope.payload === "object" ? envelope.payload : void 0;
+  const streamKeyTs = threadTs ?? payloadObj?.correlationId ?? envelope.from;
+  const ctx = {
+    channelId,
+    threadTs,
+    client,
+    streamState,
+    callbacks,
+    startTime,
+    typingIndicator: opts.typingIndicator,
+    streamKeyTs,
+    pendingReactions,
+    logger: logger3
+  };
+  const eventType = detectStreamEventType(envelope.payload);
+  if (eventType) {
+    const textChunk = extractTextDelta(envelope.payload);
+    if (textChunk) {
+      logger3.debug(`deliver: text_delta to ${channelId} (${textChunk.length} chars, streaming=${opts.streaming ? opts.nativeStreaming ? "native" : "legacy" : "buffered"})`);
+      return handleTextDelta(textChunk, opts.streaming, opts.nativeStreaming, ctx);
+    }
+    const errorMsg = extractErrorMessage(envelope.payload);
+    if (errorMsg) {
+      logger3.debug(`deliver: error to ${channelId}: "${errorMsg.slice(0, 100)}"`);
+      return handleError(errorMsg, ctx);
+    }
+    if (eventType === "done") {
+      logger3.debug(`deliver: done for ${channelId}`);
+      return handleDone(ctx);
+    }
+    if (eventType === "approval_required") {
+      const approvalData = extractApprovalData(envelope.payload);
+      if (approvalData) {
+        logger3.debug(`deliver: approval_required for tool '${approvalData.toolName}' to ${channelId}`);
+        await flushStreamBuffer(ctx);
+        return handleApprovalRequired2(channelId, threadTs, approvalData, envelope, client, callbacks, startTime, opts.approvalState);
+      }
+    }
+    logger3.debug(`deliver: dropping stream event '${eventType}' (whitelist)`);
+    return { success: true, durationMs: Date.now() - startTime };
+  }
+  const text6 = truncateText(formatForPlatform(extractPayloadContent(envelope.payload), "slack"), MAX_MESSAGE_LENGTH2);
+  logger3.debug(`deliver: standard payload to ${channelId} (${text6.length} chars)`);
+  return wrapSlackCall(() => client.chat.postMessage({ channel: channelId, text: text6, ...threadTs ? { thread_ts: threadTs } : {} }), callbacks, startTime, true);
+}
+
 // ../relay/dist/adapters/slack/slack-adapter.js
 var SLACK_APP_MANIFEST_YAML = `display_information:
   name: DorkOS Relay
-settings:
-  socket_mode_enabled: true
-  event_subscriptions:
-    bot_events:
-      - message.channels
-      - message.groups
-      - message.im
-      - app_mention
 features:
+  app_home:
+    home_tab_enabled: false
+    messages_tab_enabled: true
+    messages_tab_read_only_enabled: false
   bot_user:
     display_name: DorkOS Relay
     always_online: false
 oauth_config:
   scopes:
     bot:
+      - app_mentions:read
       - channels:history
       - channels:read
       - chat:write
@@ -103005,9 +103127,22 @@ oauth_config:
       - im:read
       - im:write
       - mpim:history
-      - app_mentions:read
+      - reactions:read
+      - reactions:write
       - users:read
-      - reactions:write`;
+settings:
+  event_subscriptions:
+    bot_events:
+      - app_mention
+      - message.channels
+      - message.groups
+      - message.im
+      - message.mpim
+  interactivity:
+    is_enabled: true
+  org_deploy_enabled: false
+  socket_mode_enabled: true
+  token_rotation_enabled: false`;
 var SLACK_CREATE_APP_URL = `https://api.slack.com/apps?new_app=1&manifest_yaml=${encodeURIComponent(SLACK_APP_MANIFEST_YAML)}`;
 var SLACK_MANIFEST = {
   type: "slack",
@@ -103026,7 +103161,7 @@ var SLACK_MANIFEST = {
     {
       stepId: "create-app",
       title: "Create & Configure a Slack App",
-      description: 'Go to api.slack.com/apps \u2192 Create New App \u2192 From Scratch.\n\n1. **Socket Mode** \u2014 Enable it (Settings \u2192 Socket Mode).\n2. **Event Subscriptions** \u2014 Turn on Enable Events, then subscribe to bot events: message.channels, message.groups, message.im, app_mention.\n3. **OAuth & Permissions** \u2014 Add bot token scopes: channels:history, channels:read, chat:write, groups:history, groups:read, im:history, im:read, im:write, mpim:history, app_mentions:read, users:read, reactions:write. Then install the app to your workspace.\n4. **App-Level Token** \u2014 In Basic Information \u2192 App-Level Tokens, generate a token with the connections:write scope.\n\n\u26A0\uFE0F Do NOT enable "Agents & AI Apps" \u2014 it adds user scopes that cause install failures on most workspaces.',
+      description: 'Go to api.slack.com/apps \u2192 Create New App \u2192 From Scratch.\n\n1. **Socket Mode** \u2014 Enable it (Settings \u2192 Socket Mode).\n2. **Event Subscriptions** \u2014 Turn on Enable Events, then subscribe to bot events: app_mention, message.channels, message.groups, message.im, message.mpim.\n3. **OAuth & Permissions** \u2014 Add bot token scopes: app_mentions:read, channels:history, channels:read, chat:write, groups:history, groups:read, im:history, im:read, im:write, mpim:history, reactions:read, reactions:write, users:read. Then install the app to your workspace.\n4. **App-Level Token** \u2014 In Basic Information \u2192 App-Level Tokens, generate a token with the connections:write scope.\n\n\u26A0\uFE0F Do NOT enable "Agents & AI Apps" \u2014 it adds user scopes that cause install failures on most workspaces.',
       fields: ["botToken", "appToken", "signingSecret", "streaming", "nativeStreaming", "typingIndicator"]
     }
   ],
@@ -103106,10 +103241,10 @@ var SLACK_MANIFEST = {
         { label: "Emoji reaction", value: "reaction" }
       ],
       visibleByDefault: true,
-      helpMarkdown: 'When set to "Emoji reaction", adds an :hourglass_flowing_sand: reaction to your message while the agent is processing. Requires the `reactions:write` scope.'
+      helpMarkdown: 'When set to "Emoji reaction", adds an :hourglass_flowing_sand: reaction to your message while the agent is processing. Requires the `reactions:write` and `reactions:read` scopes.'
     }
   ],
-  setupInstructions: '1. Create a Slack app at api.slack.com/apps (From Scratch, not From Manifest).\n2. Enable Socket Mode (Settings \u2192 Socket Mode).\n3. Enable Event Subscriptions and subscribe to bot events: message.channels, message.groups, message.im, app_mention.\n4. Add bot token scopes under OAuth & Permissions: channels:history, channels:read, chat:write, groups:history, groups:read, im:history, im:read, im:write, mpim:history, app_mentions:read, users:read, reactions:write.\n5. Install the app to your workspace (OAuth & Permissions \u2192 Install).\n6. Copy the Bot User OAuth Token (starts with xoxb-).\n7. Generate an App-Level Token with connections:write scope (Basic Information \u2192 App-Level Tokens).\n8. Copy the Signing Secret from Basic Information.\n\n\u26A0\uFE0F Do NOT enable "Agents & AI Apps" \u2014 it adds user-level scopes that cause invalid_scope errors on most workspace plans.'
+  setupInstructions: '1. Create a Slack app at api.slack.com/apps (From Scratch, not From Manifest).\n2. Enable Socket Mode (Settings \u2192 Socket Mode).\n3. Enable Event Subscriptions and subscribe to bot events: app_mention, message.channels, message.groups, message.im, message.mpim.\n4. Add bot token scopes under OAuth & Permissions: app_mentions:read, channels:history, channels:read, chat:write, groups:history, groups:read, im:history, im:read, im:write, mpim:history, reactions:read, reactions:write, users:read.\n5. Install the app to your workspace (OAuth & Permissions \u2192 Install).\n6. Copy the Bot User OAuth Token (starts with xoxb-).\n7. Generate an App-Level Token with connections:write scope (Basic Information \u2192 App-Level Tokens).\n8. Copy the Signing Secret from Basic Information.\n\n\u26A0\uFE0F Do NOT enable "Agents & AI Apps" \u2014 it adds user-level scopes that cause invalid_scope errors on most workspace plans.'
 };
 var SlackAdapter = class extends BaseRelayAdapter {
   config;
@@ -103117,6 +103252,9 @@ var SlackAdapter = class extends BaseRelayAdapter {
   /** Bot's own user ID — cached after auth.test for echo prevention. */
   botUserId = "";
   streamState = /* @__PURE__ */ new Map();
+  /** FIFO queue of message timestamps with pending hourglass reactions, keyed by channelId. */
+  pendingReactions = /* @__PURE__ */ new Map();
+  outboundState = createSlackOutboundState();
   constructor(id, config, displayName = "Slack") {
     super(id, SUBJECT_PREFIX2, displayName);
     this.config = config;
@@ -103149,10 +103287,10 @@ var SlackAdapter = class extends BaseRelayAdapter {
     const authResult = await app.client.auth.test();
     this.botUserId = authResult.user_id ?? "";
     app.message(async ({ event, client }) => {
-      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks(), this.logger);
+      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks(), this.logger, this.config.typingIndicator ?? "none", this.pendingReactions);
     });
     app.event("app_mention", async ({ event, client }) => {
-      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks(), this.logger);
+      await handleInboundMessage2(event, client, relay, this.botUserId, this.makeInboundCallbacks(), this.logger, this.config.typingIndicator ?? "none", this.pendingReactions);
     });
     app.action("tool_approve", async ({ ack, action, body, client }) => {
       await ack();
@@ -103179,6 +103317,8 @@ var SlackAdapter = class extends BaseRelayAdapter {
     }
     this.botUserId = "";
     this.streamState.clear();
+    this.pendingReactions.clear();
+    clearAllApprovalTimeouts(this.outboundState);
     clearCaches();
   }
   /**
@@ -103197,28 +103337,16 @@ var SlackAdapter = class extends BaseRelayAdapter {
       envelope,
       client: this.app?.client ?? null,
       streamState: this.streamState,
+      pendingReactions: this.pendingReactions,
       botUserId: this.botUserId,
       callbacks: this.makeOutboundCallbacks(),
       streaming: this.config.streaming ?? true,
       nativeStreaming: this.config.nativeStreaming ?? true,
       typingIndicator: this.config.typingIndicator ?? "none",
+      approvalState: this.outboundState,
       logger: this.logger
     });
   }
-  /** Build callbacks for inbound message handling. */
-  makeInboundCallbacks() {
-    return {
-      trackInbound: () => this.trackInbound(),
-      recordError: (err) => this.recordError(err)
-    };
-  }
-  /** Build callbacks for outbound message delivery. */
-  makeOutboundCallbacks() {
-    return {
-      trackOutbound: () => this.trackOutbound(),
-      recordError: (err) => this.recordError(err)
-    };
-  }
   /**
    * Handle a tool approval or denial action from Slack interactive buttons.
    *
@@ -103240,7 +103368,7 @@ var SlackAdapter = class extends BaseRelayAdapter {
         return;
       }
       const { toolCallId, sessionId, agentId } = JSON.parse(btnAction.value);
-      clearApprovalTimeout2(toolCallId);
+      clearApprovalTimeout2(this.outboundState, toolCallId);
       const opts = { from: `slack:${btnBody.user?.id ?? "unknown"}` };
       await relay.publish(`relay.system.approval.${agentId}`, {
         type: "approval_response",
@@ -103353,9 +103481,13 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
   if (!agentId) {
     return { success: false, error: `Could not extract agentId from subject: ${subject}`, durationMs: Date.now() - startTime };
   }
+  const log = deps.logger ?? console;
+  if (!deps.agentSessionStore) {
+    log.warn("[CCA] agentSessionStore not provided \u2014 SDK session mapping will not persist across restarts");
+  }
   const persistedSdkSessionId = deps.agentSessionStore?.get(agentId);
   const ccaSessionKey = persistedSdkSessionId ?? agentId;
-  const log = deps.logger ?? console;
+  log.debug?.(`[CCA] session lookup: agentId=${agentId}, persistedSdkSessionId=${persistedSdkSessionId ?? "(none)"}, hasStarted=${!!persistedSdkSessionId}`);
   deps.traceStore.insertSpan({
     messageId: envelope.id,
     traceId: randomUUID5(),
@@ -103372,11 +103504,15 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
     processedAt: null,
     error: null
   });
-  const payloadCwd = typeof envelope.payload === "object" && envelope.payload !== null ? envelope.payload.cwd : void 0;
+  const payloadObj = typeof envelope.payload === "object" && envelope.payload !== null ? envelope.payload : null;
+  const bindingPerms = payloadObj?.__bindingPermissions;
+  const responseContext = payloadObj?.responseContext;
+  const payloadCwd = payloadObj?.cwd;
   const effectiveCwd = payloadCwd ?? context?.agent?.directory;
-  log.debug?.(`[CCA] handleAgentMessage agentId=${agentId} ccaSessionKey=${ccaSessionKey}, payloadCwd=${payloadCwd ?? "(none)"}, context.agent.directory=${context?.agent?.directory ?? "(none)"}, resolvedCwd=${effectiveCwd ?? "(deferred to session)"}`);
+  const effectivePermissionMode = bindingPerms?.permissionMode ?? "default";
+  log.debug?.(`[CCA] handleAgentMessage agentId=${agentId} ccaSessionKey=${ccaSessionKey}, payloadCwd=${payloadCwd ?? "(none)"}, context.agent.directory=${context?.agent?.directory ?? "(none)"}, resolvedCwd=${effectiveCwd ?? "(deferred to session)"}, permissionMode=${effectivePermissionMode}`);
   deps.agentManager.ensureSession(ccaSessionKey, {
-    permissionMode: "default",
+    permissionMode: effectivePermissionMode,
     hasStarted: !!persistedSdkSessionId,
     ...effectiveCwd ? { cwd: effectiveCwd } : {}
   });
@@ -103384,7 +103520,6 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
   if (!envelope.replyTo) {
     log.warn(`ClaudeCodeAdapter: envelope ${envelope.id} has no replyTo \u2014 response events will not be published`);
   }
-  const payloadObj = typeof envelope.payload === "object" && envelope.payload !== null ? envelope.payload : null;
   if (payloadObj?.type && STREAM_EVENT_TYPES.has(payloadObj.type)) {
     log.debug?.(`[CCA] skipping sendMessage for StreamEvent payload type=${String(payloadObj.type)}`);
     deps.traceStore.updateSpan(envelope.id, { status: "processed", processedAt: Date.now() });
@@ -103392,12 +103527,15 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
   }
   const correlationId = payloadObj?.correlationId;
   const prompt2 = formatPromptWithContext(extractPayloadContent(envelope.payload), envelope, agentId, ccaSessionKey);
+  const formatBlock = buildResponseFormatBlock(responseContext);
   const ttlRemaining = envelope.budget.ttl - Date.now();
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), ttlRemaining > 0 ? ttlRemaining : config.defaultTimeoutMs);
   const isInboxReplyTo = envelope.replyTo?.startsWith("relay.inbox.");
   const eventStream = deps.agentManager.sendMessage(ccaSessionKey, prompt2, {
-    ...effectiveCwd ? { cwd: effectiveCwd } : {}
+    permissionMode: effectivePermissionMode,
+    ...effectiveCwd ? { cwd: effectiveCwd } : {},
+    ...formatBlock ? { systemPromptAppend: formatBlock } : {}
   });
   let eventCount = 0, collectedText = "", stepCounter = 0, messageBuffer = "";
   let streamedDone = false, streamError;
@@ -103455,7 +103593,7 @@ async function handleAgentMessage(subject, envelope, context, startTime, config,
     const actualSdkId = deps.agentManager.getSdkSessionId(ccaSessionKey);
     if (actualSdkId && actualSdkId !== agentId) {
       deps.agentSessionStore.set(agentId, actualSdkId);
-      log.debug?.(`[CCA] persisted session mapping: ${agentId} \u2192 ${actualSdkId}`);
+      log.info(`[CCA] persisted session mapping: ${agentId} \u2192 ${actualSdkId}`);
     } else {
       log.debug?.(`[CCA] no session mapping to persist: agentId=${agentId}, ccaSessionKey=${ccaSessionKey}, actualSdkId=${actualSdkId ?? "(none)"}`);
     }
@@ -103483,22 +103621,23 @@ function extractAgentId(subject) {
     return null;
   return segments[2] || null;
 }
-var PLATFORM_FORMATTING = {
-  slack: [
-    "Platform: Slack (mrkdwn format)",
-    "Formatting rules:",
-    "- Use *bold* (single asterisk), _italic_, ~strikethrough~, `code`",
-    "- Do NOT use Markdown tables (| col | col |) \u2014 Slack cannot render them",
-    "- For structured data, use bullet lists with bold labels instead",
-    "- Keep responses under 4000 characters"
-  ].join("\n"),
-  telegram: [
-    "Platform: Telegram",
-    "Formatting rules:",
-    "- Use standard Markdown: **bold**, _italic_, `code`",
-    "- Keep responses under 4096 characters"
-  ].join("\n")
-};
+function buildResponseFormatBlock(ctx) {
+  if (!ctx?.platform)
+    return "";
+  const lines = [
+    `Platform: ${ctx.platform}`,
+    ctx.maxLength ? `Maximum response length: ${ctx.maxLength} characters` : ""
+  ];
+  if (ctx.formattingInstructions) {
+    lines.push("", ctx.formattingInstructions);
+  } else if (ctx.supportedFormats && !ctx.supportedFormats.includes("markdown")) {
+    lines.push("", "FORMATTING RULES (you MUST follow these):");
+    lines.push("- Avoid complex Markdown formatting (tables, headings) \u2014 use plain text with bullet points.");
+  }
+  return `<response_format>
+${lines.filter(Boolean).join("\n")}
+</response_format>`;
+}
 function formatPromptWithContext(content3, envelope, agentId, sdkSessionId) {
   const lines = [
     `Agent-ID: ${agentId}`,
@@ -103516,12 +103655,6 @@ function formatPromptWithContext(content3, envelope, agentId, sdkSessionId) {
   if (envelope.replyTo) {
     lines.push("", `Reply to: ${envelope.replyTo}`, "If you cannot complete the task within the budget, summarize what you've done and stop.");
   }
-  const payloadObj = typeof envelope.payload === "object" && envelope.payload !== null ? envelope.payload : null;
-  const responseContext = payloadObj?.responseContext;
-  const platform2 = responseContext?.platform;
-  if (platform2 && PLATFORM_FORMATTING[platform2]) {
-    lines.push("", PLATFORM_FORMATTING[platform2]);
-  }
   return `<relay_context>
 ${lines.join("\n")}
 </relay_context>
@@ -104066,11 +104199,293 @@ import { z as z24 } from "zod";
 // ../../apps/server/src/services/relay/adapter-manager.ts
 import { readFile as readFile8 } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { dirname as dirname7, join as join12 } from "node:path";
+
+// ../../apps/server/src/services/relay/adapter-error.ts
+var AdapterError = class extends Error {
+  constructor(message, code3) {
+    super(message);
+    this.code = code3;
+    this.name = "AdapterError";
+  }
+};
+
+// ../../apps/server/src/services/relay/adapter-config.ts
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir4, rename as rename2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+var CONFIG_STABILITY_THRESHOLD_MS = 150;
+var CONFIG_POLL_INTERVAL_MS = 50;
+async function loadAdapterConfig(configPath) {
+  try {
+    const raw = await readFile4(configPath, "utf-8");
+    const parsed = AdaptersConfigFileSchema.safeParse(JSON.parse(raw));
+    if (parsed.success) {
+      return parsed.data.adapters;
+    } else {
+      logger.warn(
+        "[AdapterConfig] Malformed config, skipping invalid entries:",
+        parsed.error.flatten()
+      );
+      return [];
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return [];
+    } else {
+      logger.warn("[AdapterConfig] Failed to read config:", err);
+      return [];
+    }
+  }
+}
+async function saveAdapterConfig(configPath, configs) {
+  await mkdir4(dirname3(configPath), { recursive: true });
+  const tmpPath = `${configPath}.tmp`;
+  await writeFile2(
+    tmpPath,
+    JSON.stringify({ adapters: configs }, null, 2),
+    "utf-8"
+  );
+  await rename2(tmpPath, configPath);
+}
+async function ensureDefaultAdapterConfig(configPath) {
+  try {
+    await readFile4(configPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      const defaultConfig = {
+        adapters: [
+          {
+            id: "claude-code",
+            type: "claude-code",
+            builtin: true,
+            enabled: true,
+            config: {
+              maxConcurrent: 3,
+              defaultTimeoutMs: 3e5
+            }
+          }
+        ]
+      };
+      try {
+        await mkdir4(dirname3(configPath), { recursive: true });
+        await writeFile2(
+          configPath,
+          JSON.stringify(defaultConfig, null, 2),
+          "utf-8"
+        );
+        logger.info("[AdapterConfig] Generated default adapters.json with claude-code adapter");
+      } catch (writeErr) {
+        logger.warn("[AdapterConfig] Failed to write default config:", writeErr);
+      }
+    }
+  }
+}
+function watchAdapterConfig(configPath, onChange) {
+  const watcher = esm_default.watch(configPath, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: CONFIG_STABILITY_THRESHOLD_MS,
+      pollInterval: CONFIG_POLL_INTERVAL_MS
+    }
+  });
+  watcher.on("change", onChange);
+  return watcher;
+}
+function maskSensitiveFields(config, manifest) {
+  if (!manifest) return config;
+  const masked = structuredClone(config);
+  for (const field of manifest.configFields) {
+    if (field.type !== "password") continue;
+    const parts = field.key.split(".");
+    let current = masked;
+    let found = true;
+    for (let i2 = 0; i2 < parts.length - 1; i2++) {
+      if (current[parts[i2]] && typeof current[parts[i2]] === "object") {
+        current = current[parts[i2]];
+      } else {
+        found = false;
+        break;
+      }
+    }
+    const lastKey = parts.at(-1);
+    if (found && lastKey in current) {
+      current[lastKey] = "***";
+    }
+  }
+  return masked;
+}
+function mergeWithPasswordPreservation(existing, incoming, manifest) {
+  const result2 = { ...existing, ...incoming };
+  if (!manifest) return result2;
+  for (const field of manifest.configFields) {
+    if (field.type !== "password") continue;
+    const parts = field.key.split(".");
+    const incomingValue = getNestedValue(incoming, parts);
+    if (incomingValue === "" || incomingValue === "***" || incomingValue === void 0) {
+      const existingValue = getNestedValue(existing, parts);
+      if (existingValue !== void 0) {
+        setNestedValue(result2, parts, existingValue);
+      }
+    }
+  }
+  return result2;
+}
+function getNestedValue(obj, parts) {
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, parts, value) {
+  let current = obj;
+  for (let i2 = 0; i2 < parts.length - 1; i2++) {
+    if (!(parts[i2] in current) || typeof current[parts[i2]] !== "object") {
+      current[parts[i2]] = {};
+    }
+    current = current[parts[i2]];
+  }
+  current[parts.at(-1)] = value;
+}
+
+// ../../apps/server/src/services/relay/adapter-factory.ts
+import { dirname as dirname4 } from "node:path";
+function defaultAdapterStatus() {
+  return {
+    state: "disconnected",
+    messageCount: { inbound: 0, outbound: 0 },
+    errorCount: 0
+  };
+}
+async function createAdapter(config, deps, configPath, onPluginManifest) {
+  switch (config.type) {
+    case "telegram": {
+      const adapter = new TelegramAdapter(
+        config.id,
+        config.config
+      );
+      adapter.setLogger(createTaggedLogger(`telegram:${config.id}`));
+      return adapter;
+    }
+    case "webhook":
+      return new WebhookAdapter(
+        config.id,
+        config.config
+      );
+    case "slack": {
+      const adapter = new SlackAdapter(
+        config.id,
+        config.config
+      );
+      adapter.setLogger(createTaggedLogger(`slack:${config.id}`));
+      return adapter;
+    }
+    case "claude-code":
+      return new ClaudeCodeAdapter(
+        config.id,
+        config.config,
+        {
+          agentManager: deps.agentManager,
+          traceStore: deps.traceStore,
+          pulseStore: deps.pulseStore,
+          agentSessionStore: deps.agentSessionStore,
+          logger
+        }
+      );
+    case "plugin":
+      return loadPluginAdapter(config, configPath, onPluginManifest);
+    default:
+      logger.warn(`[AdapterFactory] Unknown adapter type: ${config.type}`);
+      return null;
+  }
+}
+var CONNECTION_TEST_TIMEOUT_MS = 15e3;
+async function testAdapterConnection(adapter) {
+  try {
+    if (adapter.testConnection) {
+      let timer;
+      try {
+        return await Promise.race([
+          adapter.testConnection(),
+          new Promise((_4, reject) => {
+            timer = setTimeout(
+              () => reject(new Error("Connection test timed out")),
+              CONNECTION_TEST_TIMEOUT_MS
+            );
+          })
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    const noopRelay = {
+      publish: async () => ({ messageId: "", deliveredTo: 0 }),
+      onSignal: () => () => {
+      },
+      subscribe: () => () => {
+      }
+    };
+    let fallbackTimer;
+    try {
+      await Promise.race([
+        adapter.start(noopRelay),
+        new Promise((_4, reject) => {
+          fallbackTimer = setTimeout(
+            () => reject(new Error("Connection test timed out")),
+            CONNECTION_TEST_TIMEOUT_MS
+          );
+        })
+      ]);
+    } finally {
+      clearTimeout(fallbackTimer);
+    }
+    return { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  } finally {
+    try {
+      await adapter.stop();
+    } catch {
+    }
+  }
+}
+async function loadPluginAdapter(config, configPath, onPluginManifest) {
+  if (!config.plugin) {
+    logger.warn(`[AdapterFactory] Plugin adapter '${config.id}' missing plugin source config`);
+    return null;
+  }
+  const builtinMap = /* @__PURE__ */ new Map();
+  const configDir = dirname4(configPath);
+  const results = await loadAdapters(
+    [
+      {
+        id: config.id,
+        type: config.type,
+        enabled: config.enabled,
+        plugin: config.plugin,
+        config: config.config
+      }
+    ],
+    builtinMap,
+    configDir
+  );
+  const result2 = results[0];
+  if (!result2) return null;
+  if (result2.manifest && onPluginManifest) {
+    onPluginManifest(config.type, result2.manifest);
+  }
+  return result2.adapter;
+}
+
+// ../../apps/server/src/services/relay/binding-subsystem.ts
+import { dirname as dirname6 } from "node:path";
 
 // ../../apps/server/src/services/relay/binding-store.ts
-import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir4, rename as rename2, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname3, join as pathJoin } from "node:path";
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir5, rename as rename3, stat as stat4 } from "node:fs/promises";
+import { dirname as dirname5, join as pathJoin } from "node:path";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { z as z23 } from "zod";
 var BindingsFileSchema = z23.object({
@@ -104204,7 +104619,7 @@ var BindingStore = class {
   }
   async load() {
     try {
-      const raw = await readFile4(this.filePath, "utf-8");
+      const raw = await readFile5(this.filePath, "utf-8");
       const json = JSON.parse(raw);
       const parsed = BindingsFileSchema.parse(json);
       this.bindings.clear();
@@ -104224,10 +104639,10 @@ var BindingStore = class {
   }
   async save() {
     const data = { bindings: this.getAll() };
-    await mkdir4(dirname3(this.filePath), { recursive: true });
+    await mkdir5(dirname5(this.filePath), { recursive: true });
     const tmpPath = `${this.filePath}.tmp`;
-    await writeFile2(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-    await rename2(tmpPath, this.filePath);
+    await writeFile3(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    await rename3(tmpPath, this.filePath);
     const fileStat = await stat4(this.filePath);
     this.lastWriteMtime = fileStat.mtimeMs;
   }
@@ -104257,10 +104672,12 @@ var BindingStore = class {
 
 // ../../apps/server/src/services/relay/agent-session-store.ts
 import { join as join11 } from "node:path";
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir5, rename as rename3 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir6, rename as rename4 } from "node:fs/promises";
 var AgentSessionStore = class {
   filePath;
   sessions = /* @__PURE__ */ new Map();
+  /** Serializes persist calls to prevent concurrent tmp+rename races. */
+  writeLock = Promise.resolve();
   constructor(relayDir) {
     this.filePath = join11(relayDir, "agent-sessions.json");
   }
@@ -104272,7 +104689,7 @@ var AgentSessionStore = class {
    */
   async init() {
     try {
-      const raw = await readFile5(this.filePath, "utf-8");
+      const raw = await readFile6(this.filePath, "utf-8");
       const parsed = JSON.parse(raw);
       this.sessions = new Map(Object.entries(parsed));
       logger.info(`[AgentSessionStore] Loaded ${this.sessions.size} session mapping(s)`);
@@ -104328,24 +104745,41 @@ var AgentSessionStore = class {
       logger.warn("[AgentSessionStore] Failed to persist after delete", { err });
     });
   }
-  /** Atomically write the current sessions map to disk (tmp + rename). */
-  async persist() {
+  /**
+   * Flush any pending writes to disk.
+   *
+   * Call during shutdown to ensure the last fire-and-forget persist
+   * completes before the process exits.
+   */
+  async shutdown() {
+    try {
+      await this.writeLock;
+    } catch {
+    }
+  }
+  /** Enqueue an atomic persist, serialized to prevent concurrent tmp+rename races. */
+  persist() {
+    this.writeLock = this.writeLock.then(() => this.doPersist(), () => this.doPersist());
+    return this.writeLock;
+  }
+  /** Atomic tmp+rename write. Must be serialized via writeLock. */
+  async doPersist() {
     const dir = join11(this.filePath, "..");
-    await mkdir5(dir, { recursive: true });
+    await mkdir6(dir, { recursive: true });
     const data = {};
     for (const [agentId, record2] of this.sessions) {
       data[agentId] = record2;
     }
     const json = JSON.stringify(data, null, 2);
     const tmp = `${this.filePath}.tmp`;
-    await writeFile3(tmp, json, "utf-8");
-    await rename3(tmp, this.filePath);
+    await writeFile4(tmp, json, "utf-8");
+    await rename4(tmp, this.filePath);
   }
 };
 
 // ../../apps/server/src/services/relay/binding-router.ts
 import { join as pathJoin2 } from "node:path";
-import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir6, rename as rename4 } from "node:fs/promises";
+import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir7, rename as rename5 } from "node:fs/promises";
 var BindingRouter = class _BindingRouter {
   constructor(deps) {
     this.deps = deps;
@@ -104359,6 +104793,10 @@ var BindingRouter = class _BindingRouter {
   inFlight = /* @__PURE__ */ new Map();
   sessionMapPath;
   unsubscribe;
+  /** Serializes saveSessionMap calls to prevent concurrent tmp+rename races. */
+  writeLock = Promise.resolve();
+  /** Guards against concurrent shutdown calls corrupting session data. */
+  isShutdown = false;
   /** Load persisted session map, subscribe to inbound messages. */
   async init() {
     await this.loadSessionMap();
@@ -104555,7 +104993,7 @@ var BindingRouter = class _BindingRouter {
   }
   async loadSessionMap() {
     try {
-      const raw = await readFile6(this.sessionMapPath, "utf-8");
+      const raw = await readFile7(this.sessionMapPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) {
         logger.warn("BindingRouter: sessionMap is not an array, starting fresh");
@@ -104571,19 +105009,32 @@ var BindingRouter = class _BindingRouter {
         );
       }
       this.sessionMap = new Map(valid);
-    } catch {
+    } catch (err) {
+      const code3 = err.code;
+      if (code3 === "ENOENT") {
+        logger.debug("BindingRouter: no sessions.json found, starting with empty session map");
+      } else {
+        logger.warn("BindingRouter: failed to load sessions.json, starting fresh", err);
+      }
       this.sessionMap = /* @__PURE__ */ new Map();
     }
   }
-  async saveSessionMap() {
-    await mkdir6(this.deps.relayDir, { recursive: true });
+  saveSessionMap() {
+    this.writeLock = this.writeLock.then(() => this.doSaveSessionMap(), () => this.doSaveSessionMap());
+    return this.writeLock;
+  }
+  /** Atomic tmp+rename write of the session map. Must be serialized via writeLock. */
+  async doSaveSessionMap() {
+    await mkdir7(this.deps.relayDir, { recursive: true });
     const data = JSON.stringify(Array.from(this.sessionMap.entries()));
     const tmpPath = `${this.sessionMapPath}.tmp`;
-    await writeFile4(tmpPath, data, "utf-8");
-    await rename4(tmpPath, this.sessionMapPath);
+    await writeFile5(tmpPath, data, "utf-8");
+    await rename5(tmpPath, this.sessionMapPath);
   }
-  /** Save session map, unsubscribe, and clear state. */
+  /** Save session map, unsubscribe, and clear state. Idempotent — safe to call multiple times. */
   async shutdown() {
+    if (this.isShutdown) return;
+    this.isShutdown = true;
     this.unsubscribe?.();
     try {
       await this.saveSessionMap();
@@ -104594,284 +105045,82 @@ var BindingRouter = class _BindingRouter {
   }
 };
 
-// ../../apps/server/src/services/relay/adapter-error.ts
-var AdapterError = class extends Error {
-  constructor(message, code3) {
-    super(message);
-    this.code = code3;
-    this.name = "AdapterError";
-  }
-};
-
-// ../../apps/server/src/services/relay/adapter-config.ts
-import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir7, rename as rename5 } from "node:fs/promises";
-import { dirname as dirname4 } from "node:path";
-var CONFIG_STABILITY_THRESHOLD_MS = 150;
-var CONFIG_POLL_INTERVAL_MS = 50;
-async function loadAdapterConfig(configPath) {
-  try {
-    const raw = await readFile7(configPath, "utf-8");
-    const parsed = AdaptersConfigFileSchema.safeParse(JSON.parse(raw));
-    if (parsed.success) {
-      return parsed.data.adapters;
-    } else {
-      logger.warn(
-        "[AdapterConfig] Malformed config, skipping invalid entries:",
-        parsed.error.flatten()
-      );
-      return [];
-    }
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return [];
-    } else {
-      logger.warn("[AdapterConfig] Failed to read config:", err);
-      return [];
-    }
+// ../../apps/server/src/services/relay/binding-subsystem.ts
+var BindingSubsystem = class _BindingSubsystem {
+  bindingStore;
+  agentSessionStore;
+  bindingRouter;
+  isShutdown = false;
+  constructor(bindingStore, agentSessionStore) {
+    this.bindingStore = bindingStore;
+    this.agentSessionStore = agentSessionStore;
   }
-}
-async function saveAdapterConfig(configPath, configs) {
-  await mkdir7(dirname4(configPath), { recursive: true });
-  const tmpPath = `${configPath}.tmp`;
-  await writeFile5(
-    tmpPath,
-    JSON.stringify({ adapters: configs }, null, 2),
-    "utf-8"
-  );
-  await rename5(tmpPath, configPath);
-}
-async function ensureDefaultAdapterConfig(configPath) {
-  try {
-    await readFile7(configPath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      const defaultConfig = {
-        adapters: [
-          {
-            id: "claude-code",
-            type: "claude-code",
-            builtin: true,
-            enabled: true,
-            config: {
-              maxConcurrent: 3,
-              defaultTimeoutMs: 3e5
-            }
-          }
-        ]
+  /**
+   * Initialize the binding subsystem: BindingStore, AgentSessionStore, and BindingRouter.
+   *
+   * Non-fatal — if initialization fails, returns undefined and logs a warning.
+   * AdapterManager continues running without binding-based routing.
+   *
+   * @param deps - Required dependencies for subsystem initialization
+   * @returns Initialized subsystem, or undefined on failure
+   */
+  static async init(deps) {
+    const relayDir = dirname6(deps.configPath);
+    try {
+      const bindingStore = new BindingStore(relayDir);
+      await bindingStore.init();
+      logger.info("[BindingSubsystem] BindingStore initialized");
+      const agentSessionStore = new AgentSessionStore(relayDir);
+      await agentSessionStore.init();
+      logger.info("[BindingSubsystem] AgentSessionStore initialized");
+      const subsystem = new _BindingSubsystem(bindingStore, agentSessionStore);
+      const agentManager = deps.agentManager;
+      const sessionCreator = {
+        async createSession(cwd, permissionMode) {
+          const id = crypto.randomUUID();
+          agentManager.ensureSession(id, { permissionMode: permissionMode ?? "acceptEdits", cwd });
+          return { id };
+        }
       };
-      try {
-        await mkdir7(dirname4(configPath), { recursive: true });
-        await writeFile5(
-          configPath,
-          JSON.stringify(defaultConfig, null, 2),
-          "utf-8"
-        );
-        logger.info("[AdapterConfig] Generated default adapters.json with claude-code adapter");
-      } catch (writeErr) {
-        logger.warn("[AdapterConfig] Failed to write default config:", writeErr);
-      }
-    }
-  }
-}
-function watchAdapterConfig(configPath, onChange) {
-  const watcher = esm_default.watch(configPath, {
-    persistent: true,
-    ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: CONFIG_STABILITY_THRESHOLD_MS,
-      pollInterval: CONFIG_POLL_INTERVAL_MS
-    }
-  });
-  watcher.on("change", onChange);
-  return watcher;
-}
-function maskSensitiveFields(config, manifest) {
-  if (!manifest) return config;
-  const masked = structuredClone(config);
-  for (const field of manifest.configFields) {
-    if (field.type !== "password") continue;
-    const parts = field.key.split(".");
-    let current = masked;
-    let found = true;
-    for (let i2 = 0; i2 < parts.length - 1; i2++) {
-      if (current[parts[i2]] && typeof current[parts[i2]] === "object") {
-        current = current[parts[i2]];
-      } else {
-        found = false;
-        break;
-      }
-    }
-    const lastKey = parts.at(-1);
-    if (found && lastKey in current) {
-      current[lastKey] = "***";
-    }
-  }
-  return masked;
-}
-function mergeWithPasswordPreservation(existing, incoming, manifest) {
-  const result2 = { ...existing, ...incoming };
-  if (!manifest) return result2;
-  for (const field of manifest.configFields) {
-    if (field.type !== "password") continue;
-    const parts = field.key.split(".");
-    const incomingValue = getNestedValue(incoming, parts);
-    if (incomingValue === "" || incomingValue === "***" || incomingValue === void 0) {
-      const existingValue = getNestedValue(existing, parts);
-      if (existingValue !== void 0) {
-        setNestedValue(result2, parts, existingValue);
-      }
+      subsystem.bindingRouter = new BindingRouter({
+        bindingStore,
+        relayCore: deps.relayCore,
+        agentManager: sessionCreator,
+        meshCore: deps.meshCore,
+        relayDir,
+        resolveAdapterInstanceId: deps.resolveAdapterInstanceId
+      });
+      await subsystem.bindingRouter.init();
+      logger.info("[BindingSubsystem] BindingRouter initialized");
+      return subsystem;
+    } catch (err) {
+      logger.warn("[BindingSubsystem] Failed to initialize binding subsystem:", err);
+      return void 0;
     }
   }
-  return result2;
-}
-function getNestedValue(obj, parts) {
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
+  /** Get the BindingStore. */
+  getBindingStore() {
+    return this.bindingStore;
   }
-  return current;
-}
-function setNestedValue(obj, parts, value) {
-  let current = obj;
-  for (let i2 = 0; i2 < parts.length - 1; i2++) {
-    if (!(parts[i2] in current) || typeof current[parts[i2]] !== "object") {
-      current[parts[i2]] = {};
-    }
-    current = current[parts[i2]];
+  /** Get the AgentSessionStore. */
+  getAgentSessionStore() {
+    return this.agentSessionStore;
   }
-  current[parts.at(-1)] = value;
-}
-
-// ../../apps/server/src/services/relay/adapter-factory.ts
-import { dirname as dirname5 } from "node:path";
-function defaultAdapterStatus() {
-  return {
-    state: "disconnected",
-    messageCount: { inbound: 0, outbound: 0 },
-    errorCount: 0
-  };
-}
-async function createAdapter(config, deps, configPath, onPluginManifest) {
-  switch (config.type) {
-    case "telegram": {
-      const adapter = new TelegramAdapter(
-        config.id,
-        config.config
-      );
-      adapter.setLogger(createTaggedLogger(`telegram:${config.id}`));
-      return adapter;
-    }
-    case "webhook":
-      return new WebhookAdapter(
-        config.id,
-        config.config
-      );
-    case "slack": {
-      const adapter = new SlackAdapter(
-        config.id,
-        config.config
-      );
-      adapter.setLogger(createTaggedLogger(`slack:${config.id}`));
-      return adapter;
-    }
-    case "claude-code":
-      return new ClaudeCodeAdapter(
-        config.id,
-        config.config,
-        {
-          agentManager: deps.agentManager,
-          traceStore: deps.traceStore,
-          pulseStore: deps.pulseStore,
-          agentSessionStore: deps.agentSessionStore,
-          logger
-        }
-      );
-    case "plugin":
-      return loadPluginAdapter(config, configPath, onPluginManifest);
-    default:
-      logger.warn(`[AdapterFactory] Unknown adapter type: ${config.type}`);
-      return null;
+  /** Get the BindingRouter, or undefined if initialization did not reach that step. */
+  getBindingRouter() {
+    return this.bindingRouter;
   }
-}
-var CONNECTION_TEST_TIMEOUT_MS = 15e3;
-async function testAdapterConnection(adapter) {
-  try {
-    if (adapter.testConnection) {
-      let timer;
-      try {
-        return await Promise.race([
-          adapter.testConnection(),
-          new Promise((_4, reject) => {
-            timer = setTimeout(
-              () => reject(new Error("Connection test timed out")),
-              CONNECTION_TEST_TIMEOUT_MS
-            );
-          })
-        ]);
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-    const noopRelay = {
-      publish: async () => ({ messageId: "", deliveredTo: 0 }),
-      onSignal: () => () => {
-      },
-      subscribe: () => () => {
-      }
-    };
-    let fallbackTimer;
-    try {
-      await Promise.race([
-        adapter.start(noopRelay),
-        new Promise((_4, reject) => {
-          fallbackTimer = setTimeout(
-            () => reject(new Error("Connection test timed out")),
-            CONNECTION_TEST_TIMEOUT_MS
-          );
-        })
-      ]);
-    } finally {
-      clearTimeout(fallbackTimer);
-    }
-    return { ok: true };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: message };
-  } finally {
-    try {
-      await adapter.stop();
-    } catch {
+  /** Shut down the BindingRouter, AgentSessionStore, and BindingStore. Idempotent. */
+  async shutdown() {
+    if (this.isShutdown) return;
+    this.isShutdown = true;
+    if (this.bindingRouter) {
+      await this.bindingRouter.shutdown();
     }
+    await this.agentSessionStore.shutdown();
+    await this.bindingStore.shutdown();
   }
-}
-async function loadPluginAdapter(config, configPath, onPluginManifest) {
-  if (!config.plugin) {
-    logger.warn(`[AdapterFactory] Plugin adapter '${config.id}' missing plugin source config`);
-    return null;
-  }
-  const builtinMap = /* @__PURE__ */ new Map();
-  const configDir = dirname5(configPath);
-  const results = await loadAdapters(
-    [
-      {
-        id: config.id,
-        type: config.type,
-        enabled: config.enabled,
-        plugin: config.plugin,
-        config: config.config
-      }
-    ],
-    builtinMap,
-    configDir
-  );
-  const result2 = results[0];
-  if (!result2) return null;
-  if (result2.manifest && onPluginManifest) {
-    onPluginManifest(config.type, result2.manifest);
-  }
-  return result2.adapter;
-}
+};
 
 // ../../apps/server/src/services/relay/adapter-manager.ts
 var AdapterManager = class {
@@ -104881,9 +105130,7 @@ var AdapterManager = class {
   configs = [];
   deps;
   manifests = /* @__PURE__ */ new Map();
-  bindingStore;
-  agentSessionStore;
-  bindingRouter;
+  bindingSubsystem;
   constructor(registry2, configPath, deps) {
     this.registry = registry2;
     this.configPath = configPath;
@@ -104895,56 +105142,30 @@ var AdapterManager = class {
     await this.enrichManifestsWithDocs();
     await ensureDefaultAdapterConfig(this.configPath);
     this.configs = await loadAdapterConfig(this.configPath);
+    await this.initBindingSubsystem();
     await this.startEnabledAdapters();
     this.configWatcher = watchAdapterConfig(this.configPath, () => {
       this.reload().catch((err) => {
         logger.warn("[AdapterManager] Hot-reload failed:", err);
       });
     });
-    await this.initBindingSubsystem();
   }
-  /** Initialize the binding store and router subsystem. Non-fatal on failure. */
+  /** Initialize the binding subsystem. Non-fatal on failure — logs and continues. */
   async initBindingSubsystem() {
-    if (!this.deps.relayCore) {
-      logger.info("[AdapterManager] relayCore not provided, skipping binding subsystem");
+    if (!this.deps.relayCore || !this.deps.meshCore) {
+      logger.info("[AdapterManager] relayCore or meshCore not provided, skipping binding subsystem");
       return;
     }
-    const relayDir = dirname6(this.configPath);
-    try {
-      this.bindingStore = new BindingStore(relayDir);
-      await this.bindingStore.init();
-      logger.info("[AdapterManager] BindingStore initialized");
-      this.agentSessionStore = new AgentSessionStore(relayDir);
-      await this.agentSessionStore.init();
-      logger.info("[AdapterManager] AgentSessionStore initialized");
-      const agentManager = this.deps.agentManager;
-      const sessionCreator = {
-        async createSession(cwd, permissionMode) {
-          const id = crypto.randomUUID();
-          agentManager.ensureSession(id, { permissionMode: permissionMode ?? "acceptEdits", cwd });
-          return { id };
-        }
-      };
-      if (!this.deps.meshCore) {
-        logger.info("[AdapterManager] meshCore not provided, skipping binding subsystem");
-        return;
+    this.bindingSubsystem = await BindingSubsystem.init({
+      relayCore: this.deps.relayCore,
+      meshCore: this.deps.meshCore,
+      agentManager: this.deps.agentManager,
+      configPath: this.configPath,
+      resolveAdapterInstanceId: (platformType) => {
+        const match = this.configs.find((c3) => c3.type === platformType && c3.enabled);
+        return match?.id;
       }
-      this.bindingRouter = new BindingRouter({
-        bindingStore: this.bindingStore,
-        relayCore: this.deps.relayCore,
-        agentManager: sessionCreator,
-        meshCore: this.deps.meshCore,
-        relayDir,
-        resolveAdapterInstanceId: (platformType) => {
-          const match = this.configs.find((c3) => c3.type === platformType && c3.enabled);
-          return match?.id;
-        }
-      });
-      await this.bindingRouter.init();
-      logger.info("[AdapterManager] BindingRouter initialized");
-    } catch (err) {
-      logger.warn("[AdapterManager] Failed to initialize binding subsystem:", err);
-    }
+    });
   }
   /** Reload config from disk and reconcile adapter state. */
   async reload() {
@@ -105031,15 +105252,15 @@ var AdapterManager = class {
   }
   /** Get the BindingStore, or undefined if binding subsystem was not initialized. */
   getBindingStore() {
-    return this.bindingStore;
+    return this.bindingSubsystem?.getBindingStore();
   }
   /** Get the AgentSessionStore, or undefined if binding subsystem was not initialized. */
   getAgentSessionStore() {
-    return this.agentSessionStore;
+    return this.bindingSubsystem?.getAgentSessionStore();
   }
   /** Get the BindingRouter, or undefined if binding subsystem was not initialized. */
   getBindingRouter() {
-    return this.bindingRouter;
+    return this.bindingSubsystem?.getBindingRouter();
   }
   /** Enrich AdapterContext with Mesh agent info if meshCore is available. */
   buildContext(subject) {
@@ -105147,10 +105368,11 @@ var AdapterManager = class {
     }
     this.configs.splice(index2, 1);
     await saveAdapterConfig(this.configPath, this.configs);
-    if (this.bindingStore) {
-      const orphanBindings = this.bindingStore.getAll().filter((b3) => b3.adapterId === id);
+    const bindingStore = this.bindingSubsystem?.getBindingStore();
+    if (bindingStore) {
+      const orphanBindings = bindingStore.getAll().filter((b3) => b3.adapterId === id);
       for (const binding of orphanBindings) {
-        await this.bindingStore.delete(binding.id);
+        await bindingStore.delete(binding.id);
       }
       if (orphanBindings.length > 0) {
         logger.info(
@@ -105189,13 +105411,9 @@ var AdapterManager = class {
   }
   /** Stop all adapters and the config file watcher. */
   async shutdown() {
-    if (this.bindingRouter) {
-      await this.bindingRouter.shutdown();
-      this.bindingRouter = void 0;
-    }
-    if (this.bindingStore) {
-      await this.bindingStore.shutdown();
-      this.bindingStore = void 0;
+    if (this.bindingSubsystem) {
+      await this.bindingSubsystem.shutdown();
+      this.bindingSubsystem = void 0;
     }
     if (this.configWatcher) {
       await this.configWatcher.close();
@@ -105229,7 +105447,7 @@ var AdapterManager = class {
   async buildAdapter(config) {
     return createAdapter(
       config,
-      { ...this.deps, agentSessionStore: this.agentSessionStore },
+      { ...this.deps, agentSessionStore: this.bindingSubsystem?.getAgentSessionStore() },
       this.configPath,
       (type, manifest) => this.registerPluginManifest(type, manifest)
     );
@@ -105301,7 +105519,7 @@ var AdapterManager = class {
   resolveAdapterDocsPath(adapterType) {
     const require2 = createRequire(import.meta.url);
     const relayEntry = require2.resolve("@dorkos/relay");
-    const distDir = dirname6(relayEntry);
+    const distDir = dirname7(relayEntry);
     return join12(distDir, "adapters", adapterType, "docs");
   }
 };
@@ -116188,7 +116406,7 @@ async function start() {
       adapterRegistry.setLogger(logger);
       traceStore = new TraceStore(db);
       logger.info("[Relay] TraceStore initialized");
-      relayCore = new RelayCore({ dataDir: relayDataDir, adapterRegistry, db, traceStore });
+      relayCore = new RelayCore({ dataDir: relayDataDir, adapterRegistry, db, traceStore, logger });
       await relayCore.registerEndpoint("relay.system.console");
       logger.info(`[Relay] RelayCore initialized (dataDir: ${relayDataDir})`);
     } catch (err) {
@@ -116374,7 +116592,10 @@ async function shutdownServices() {
   }
   await tunnelManager.stop();
 }
+var shuttingDown = false;
 async function shutdown() {
+  if (shuttingDown) return;
+  shuttingDown = true;
   logger.info("Shutting down...");
   await shutdownServices();
   process.exit(0);