@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/gateway-X2TI5X7F.js

@@ -0,0 +1,2484 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  runWithOrigin,
+  splitMessage,
+  startGatewayCron
+} from "./chunk-ECD5L7YI.js";
+import {
+  gatewayConfigPath,
+  isFeatureEnabled,
+  loadGatewayConfig,
+  platformConfigFor,
+  resolvePlatformToken,
+  saveGatewayConfig
+} from "./chunk-RQ5DNUNG.js";
+import "./chunk-CJECDQKP.js";
+import {
+  computeContextBreakdown
+} from "./chunk-A2KQXUJD.js";
+import {
+  findExactModelReferenceMatch
+} from "./chunk-TQNSPERU.js";
+import "./chunk-CGBXPL3E.js";
+import {
+  processImage
+} from "./chunk-AD6VXAO7.js";
+import {
+  NO_HANDLER_REASON,
+  createPermissionContext,
+  deletePermissionContext,
+  registerApprovalHandler
+} from "./chunk-LZAW4ZX3.js";
+import "./chunk-M3LZLQW2.js";
+import {
+  SessionManager
+} from "./chunk-PBC2Y6GS.js";
+import "./chunk-FVDOXRUD.js";
+import "./chunk-RQ2Q5IYR.js";
+import "./chunk-DDGMHUOW.js";
+import {
+  getAgentDir
+} from "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/gateway/adapters/discord.js
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, Client, Events, GatewayIntentBits } from "discord.js";
+var DEFAULT_DEBOUNCE_MS = 600, TYPING_INTERVAL_MS = 8e3, TYPING_SAFETY_MS = 12e4, REPLY_TO_TEXT_MAX = 500, THREAD_NAME_MAX = 40, SEEN_CAP = 500, SENT_CHANNEL_CAP = 500, CALLBACK_INTERACTION_CAP = 500, CHANNEL_CACHE_CAP = 500, PARTICIPATING_THREAD_CAP = 500, ERR_INVALID_FORM_BODY = 50035, ERR_UNKNOWN_MESSAGE = 10008, THREAD_TYPES = [
+  ChannelType.PublicThread,
+  ChannelType.PrivateThread,
+  ChannelType.AnnouncementThread
+];
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function defaultDownloadAttachment(url) {
+  let res = await fetch(url);
+  if (!res.ok)
+    throw new Error(`attachment download HTTP ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+function discordErrorCode(err) {
+  let code = err?.code;
+  return typeof code == "number" ? code : void 0;
+}
+function isImageContentType(contentType) {
+  return typeof contentType == "string" && contentType.split(";")[0]?.trim().toLowerCase().startsWith("image/");
+}
+function collectDiscordImageAttachments(message) {
+  return (message.attachments ?? []).filter((attachment) => isImageContentType(attachment.contentType));
+}
+function messageToEvent(message, botUser, options = {}) {
+  let author = message.author;
+  if (!author || author.id === botUser.id || author.bot || message.system)
+    return null;
+  let content = (message.content ?? "").trim(), imageAttachments = collectDiscordImageAttachments(message);
+  if (content === "" && imageAttachments.length === 0)
+    return null;
+  let channel = message.channel, ignored = options.ignoredChannels ?? [];
+  if (ignored.includes(channel.id) || channel.parentId != null && ignored.includes(channel.parentId))
+    return null;
+  let chatType, chatId, threadId;
+  if (channel.type === ChannelType.DM)
+    chatType = "dm", chatId = channel.id;
+  else if (THREAD_TYPES.includes(channel.type))
+    chatType = "thread", chatId = channel.parentId ?? channel.id, threadId = channel.id;
+  else if (channel.type === ChannelType.GuildText || channel.type === ChannelType.GuildAnnouncement)
+    chatType = "group", chatId = channel.id;
+  else
+    return null;
+  let explicitMention = message.mentions?.has(botUser) === !0, participating = threadId !== void 0 && options.participatingThreads?.has(threadId) === !0, mentionedBot2 = explicitMention || participating;
+  if (!mentionedBot2 && chatType !== "dm" && [...content.matchAll(/<@!?(\d+)>/g)].map((m) => m[1]).some((id) => id !== botUser.id))
+    return null;
+  let text = content;
+  explicitMention && (text = text.replace(new RegExp(`<@!?${botUser.id}>`, "g"), "").trim());
+  let refId = message.reference?.messageId, cachedReply = refId != null ? channel.messages?.cache?.get(refId)?.content : void 0;
+  return {
+    text,
+    messageId: message.id,
+    replyToText: cachedReply !== void 0 ? cachedReply.slice(0, REPLY_TO_TEXT_MAX) : void 0,
+    source: {
+      platform: "discord",
+      chatId,
+      chatType,
+      userId: author.id,
+      userName: author.username,
+      threadId
+    },
+    metadata: mentionedBot2 ? { mentionedBot: !0 } : void 0
+  };
+}
+function mapDiscordChannel(channel) {
+  return channel.type === ChannelType.DM ? { chatType: "dm", chatId: channel.id } : THREAD_TYPES.includes(channel.type) ? { chatType: "thread", chatId: channel.parentId ?? channel.id, threadId: channel.id } : channel.type === ChannelType.GuildText || channel.type === ChannelType.GuildAnnouncement ? { chatType: "group", chatId: channel.id } : null;
+}
+function buttonInteractionToEvent(interaction) {
+  let channel = interaction.message.channel, mapped = mapDiscordChannel(channel);
+  return mapped ? {
+    id: interaction.id,
+    chatId: mapped.chatId,
+    messageId: interaction.message.id,
+    userId: interaction.user.id,
+    userName: interaction.user.username,
+    data: interaction.customId,
+    threadId: mapped.threadId
+  } : null;
+}
+function buildDiscordComponents(buttons) {
+  let rows = [];
+  for (let row of buttons) {
+    let actionRow = new ActionRowBuilder();
+    for (let button of row) {
+      let style = button.data === "" ? ButtonStyle.Secondary : ButtonStyle.Secondary, builder = new ButtonBuilder().setCustomId(button.data).setLabel(button.label).setStyle(style);
+      button.data === "" && builder.setDisabled(!0), actionRow.addComponents(builder);
+    }
+    rows.push(actionRow);
+  }
+  return rows;
+}
+var seenMessageIds = /* @__PURE__ */ new Set();
+function markMessageSeen(id) {
+  if (seenMessageIds.has(id))
+    return !0;
+  if (seenMessageIds.add(id), seenMessageIds.size > SEEN_CAP) {
+    let oldest = seenMessageIds.values().next().value;
+    oldest !== void 0 && seenMessageIds.delete(oldest);
+  }
+  return !1;
+}
+var defaultScheduler = {
+  setTimeout: (fn, ms) => {
+    let handle = setTimeout(fn, ms);
+    return handle.unref?.(), handle;
+  },
+  clearTimeout: (handle) => clearTimeout(handle),
+  setInterval: (fn, ms) => {
+    let handle = setInterval(fn, ms);
+    return handle.unref?.(), handle;
+  },
+  clearInterval: (handle) => clearInterval(handle)
+};
+function defaultClientFactory() {
+  return new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.MessageContent
+    ]
+  });
+}
+function typingKey(chatId, threadId) {
+  return `${chatId}:${threadId ?? ""}`;
+}
+var DiscordAdapter = class {
+  platform = "discord";
+  maxMessageLength = 2e3;
+  cfg;
+  clientFactory;
+  downloadAttachment;
+  maxMediaBytes;
+  scheduler;
+  debounceMs;
+  now;
+  client;
+  botUserId;
+  handler;
+  callbackHandler;
+  pending = /* @__PURE__ */ new Map();
+  typing = /* @__PURE__ */ new Map();
+  channelCache = /* @__PURE__ */ new Map();
+  /** Threads the bot has spoken in (session memory only; hermes persists this). */
+  participatingThreads = /* @__PURE__ */ new Set();
+  /** messageId → channel it was sent to, so editMessage finds thread messages. */
+  sentMessageChannels = /* @__PURE__ */ new Map();
+  /** callbackId → interaction, so answerCallback can acknowledge the click. */
+  callbackInteractions = /* @__PURE__ */ new Map();
+  constructor(cfg, options = {}) {
+    if (this.cfg = cfg, this.scheduler = options.scheduler ?? defaultScheduler, this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS, this.now = options.now ?? Date.now, options.clientFactory)
+      this.clientFactory = options.clientFactory;
+    else {
+      if (!cfg.token)
+        throw new Error("DiscordAdapter: no bot token (set discord.token or LUNR_DISCORD_BOT_TOKEN)");
+      this.clientFactory = defaultClientFactory;
+    }
+    this.downloadAttachment = options.downloadAttachment ?? defaultDownloadAttachment, this.maxMediaBytes = options.maxMediaBytes ?? 10 * 1024 * 1024;
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  onCallback(handler) {
+    this.callbackHandler = handler;
+  }
+  async connect() {
+    if (!this.cfg.token)
+      throw new Error("DiscordAdapter: no bot token (set discord.token or LUNR_DISCORD_BOT_TOKEN)");
+    let client = this.clientFactory();
+    this.client = client, client.on(Events.MessageCreate, (message) => {
+      this.handleMessage(message).catch((err) => {
+        console.error(`[gateway] discord message handling error: ${errMessage(err)}`);
+      });
+    }), client.on(Events.InteractionCreate, (interaction) => {
+      this.handleInteraction(interaction).catch((err) => {
+        console.error(`[gateway] discord interaction handling error: ${errMessage(err)}`);
+      });
+    });
+    let ready = new Promise((resolve) => client.once(Events.ClientReady, () => resolve()));
+    try {
+      await client.login(this.cfg.token);
+    } catch (err) {
+      return console.error(`[gateway] discord login failed: ${errMessage(err)}`), !1;
+    }
+    return await ready, this.botUserId = client.user?.id, this.botUserId === void 0 ? (console.error("[gateway] discord: client ready without a user \u2014 cannot map messages"), !1) : !0;
+  }
+  async disconnect() {
+    for (let key of [...this.pending.keys()])
+      this.cancelPending(key);
+    for (let key of [...this.typing.keys()])
+      this.stopTyping(key);
+    this.channelCache.clear(), this.callbackInteractions.clear(), this.client?.destroy(), this.client = void 0;
+  }
+  // -----------------------------------------------------------------------
+  // Inbound dispatch + debounce
+  // -----------------------------------------------------------------------
+  async handleMessage(message) {
+    if (!this.botUserId || !this.handler || markMessageSeen(message.id))
+      return;
+    let event = messageToEvent(message, { id: this.botUserId }, {
+      ignoredChannels: this.cfg.ignoredChannels,
+      participatingThreads: this.participatingThreads
+    });
+    event && (await this.resolveReplyToText(message, event), await this.maybeAutoThread(message, event), await this.downloadAttachments(message, event), this.dispatchEvent(event));
+  }
+  /** lunr: download + base64-encode inbound image attachments for one Discord message. */
+  async downloadAttachments(message, event) {
+    let imageAttachments = collectDiscordImageAttachments(message);
+    if (imageAttachments.length === 0)
+      return;
+    let attachments = [];
+    for (let attachment of imageAttachments)
+      if (!(attachment.size !== void 0 && attachment.size > this.maxMediaBytes))
+        try {
+          let bytes = await this.downloadAttachment(attachment.url);
+          if (bytes.byteLength > this.maxMediaBytes)
+            continue;
+          attachments.push({
+            data: Buffer.from(bytes).toString("base64"),
+            mimeType: attachment.contentType ?? "image/png",
+            ...attachment.name ? { filename: attachment.name } : {}
+          });
+        } catch {
+        }
+    attachments.length > 0 && (event.attachments = attachments);
+  }
+  async handleInteraction(interaction) {
+    if (!this.callbackHandler || !interaction.isButton())
+      return;
+    let event = buttonInteractionToEvent(interaction);
+    if (event) {
+      if (this.callbackInteractions.set(interaction.id, interaction), this.callbackInteractions.size > CALLBACK_INTERACTION_CAP) {
+        let oldest = this.callbackInteractions.keys().next().value;
+        oldest !== void 0 && this.callbackInteractions.delete(oldest);
+      }
+      this.callbackHandler(event);
+    }
+  }
+  /** Best-effort: fill replyToText from the referenced message when it wasn't cached. */
+  async resolveReplyToText(message, event) {
+    if (event.replyToText !== void 0)
+      return;
+    let refId = message.reference?.messageId;
+    if (refId == null)
+      return;
+    let messages = message.channel.messages;
+    if (messages)
+      try {
+        let referenced = await messages.fetch(refId);
+        referenced?.content && (event.replyToText = referenced.content.slice(0, REPLY_TO_TEXT_MAX));
+      } catch {
+      }
+  }
+  /** autoThread: spin a thread off a bot-mentioning guild-text message and re-target the event. */
+  async maybeAutoThread(message, event) {
+    if (this.cfg.autoThread && event.metadata?.mentionedBot === !0 && message.channel.type === ChannelType.GuildText && typeof message.startThread == "function")
+      try {
+        let thread = await message.startThread({
+          name: (event.text || "conversation").slice(0, THREAD_NAME_MAX),
+          autoArchiveDuration: 60
+        });
+        if (this.participatingThreads.add(thread.id), this.participatingThreads.size > PARTICIPATING_THREAD_CAP) {
+          let oldest = this.participatingThreads.values().next().value;
+          oldest !== void 0 && this.participatingThreads.delete(oldest);
+        }
+        event.source = { ...event.source, chatType: "thread", chatId: message.channel.id, threadId: thread.id };
+      } catch {
+      }
+  }
+  debounceKey(event) {
+    return `${event.source.chatId}:${event.source.threadId ?? ""}:${event.source.userId}`;
+  }
+  dispatchEvent(event) {
+    let key = this.debounceKey(event);
+    if (event.text.trimStart().startsWith("/")) {
+      this.flushPending(key), this.handler?.(event);
+      return;
+    }
+    let existing = this.pending.get(key);
+    if (existing) {
+      this.scheduler.clearTimeout(existing.timer);
+      let mergedAttachments = [...existing.event.attachments ?? [], ...event.attachments ?? []];
+      existing.event = {
+        ...event,
+        text: `${existing.event.text}
+${event.text}`,
+        ...mergedAttachments.length > 0 ? { attachments: mergedAttachments } : {}
+      }, existing.timer = this.scheduler.setTimeout(() => this.flushPending(key), this.debounceMs);
+    } else {
+      let timer = this.scheduler.setTimeout(() => this.flushPending(key), this.debounceMs);
+      this.pending.set(key, { event, timer });
+    }
+  }
+  flushPending(key) {
+    let entry = this.pending.get(key);
+    entry && (this.scheduler.clearTimeout(entry.timer), this.pending.delete(key), this.handler?.(entry.event));
+  }
+  cancelPending(key) {
+    let entry = this.pending.get(key);
+    entry && (this.scheduler.clearTimeout(entry.timer), this.pending.delete(key));
+  }
+  // -----------------------------------------------------------------------
+  // Outbound
+  // -----------------------------------------------------------------------
+  async fetchChannel(id) {
+    if (this.channelCache.has(id))
+      return this.channelCache.get(id) ?? null;
+    if (!this.client)
+      return null;
+    try {
+      let channel = await this.client.channels.fetch(id);
+      if (this.channelCache.set(id, channel), this.channelCache.size > CHANNEL_CACHE_CAP) {
+        let oldest = this.channelCache.keys().next().value;
+        oldest !== void 0 && this.channelCache.delete(oldest);
+      }
+      return channel;
+    } catch {
+      if (this.channelCache.set(id, null), this.channelCache.size > CHANNEL_CACHE_CAP) {
+        let oldest = this.channelCache.keys().next().value;
+        oldest !== void 0 && this.channelCache.delete(oldest);
+      }
+      return null;
+    }
+  }
+  recordSent(messageId, channel) {
+    if (THREAD_TYPES.includes(channel.type) && this.participatingThreads.add(channel.id), this.participatingThreads.size > PARTICIPATING_THREAD_CAP) {
+      let oldest = this.participatingThreads.values().next().value;
+      oldest !== void 0 && this.participatingThreads.delete(oldest);
+    }
+    if (this.sentMessageChannels.set(messageId, channel.id), this.sentMessageChannels.size > SENT_CHANNEL_CAP) {
+      let oldest = this.sentMessageChannels.keys().next().value;
+      oldest !== void 0 && this.sentMessageChannels.delete(oldest);
+    }
+  }
+  async trySend(channel, payload) {
+    if (typeof channel.send != "function")
+      return { success: !1, error: `channel ${channel.id} is not sendable` };
+    try {
+      let sent = await channel.send(payload);
+      return this.recordSent(sent.id, channel), { success: !0, messageId: sent.id };
+    } catch (err) {
+      return { success: !1, error: errMessage(err), retryable: discordErrorCode(err) !== ERR_INVALID_FORM_BODY };
+    }
+  }
+  async send(chatId, text, opts) {
+    this.stopTyping(typingKey(chatId, opts?.threadId));
+    let channel = await this.fetchChannel(opts?.threadId ?? chatId);
+    if (!channel)
+      return { success: !1, error: `channel ${opts?.threadId ?? chatId} not found` };
+    let result = await this.trySend(channel, {
+      content: text,
+      reply: opts?.replyTo !== void 0 ? { messageReference: opts.replyTo } : void 0
+    });
+    return !result.success && opts?.replyTo !== void 0 ? this.trySend(channel, { content: text }) : result;
+  }
+  async sendButtons(chatId, text, buttons, opts) {
+    this.stopTyping(typingKey(chatId, opts?.threadId));
+    let channel = await this.fetchChannel(opts?.threadId ?? chatId);
+    if (!channel)
+      return { success: !1, error: `channel ${opts?.threadId ?? chatId} not found` };
+    let result = await this.trySend(channel, {
+      content: text,
+      reply: opts?.replyTo !== void 0 ? { messageReference: opts.replyTo } : void 0,
+      components: buildDiscordComponents(buttons)
+    });
+    return !result.success && opts?.replyTo !== void 0 ? this.trySend(channel, { content: text, components: buildDiscordComponents(buttons) }) : result;
+  }
+  async answerCallback(id, text) {
+    let interaction = this.callbackInteractions.get(id);
+    if (interaction) {
+      this.callbackInteractions.delete(id);
+      try {
+        text !== void 0 && interaction.reply ? await interaction.reply({ content: text, ephemeral: !0 }) : await interaction.deferUpdate();
+      } catch {
+      }
+    }
+  }
+  async editMessage(chatId, messageId, text, buttons) {
+    let channel = await this.fetchChannel(this.sentMessageChannels.get(messageId) ?? chatId);
+    if (!channel?.messages)
+      return { success: !1, error: `channel ${this.sentMessageChannels.get(messageId) ?? chatId} not found` };
+    try {
+      let message = await channel.messages.fetch(messageId);
+      if (!message || typeof message.edit != "function")
+        return { success: !1, error: `message ${messageId} not found` };
+      let editOptions = { content: text };
+      return buttons !== void 0 && (editOptions.components = buildDiscordComponents(buttons)), await message.edit(editOptions), { success: !0, messageId };
+    } catch (err) {
+      return discordErrorCode(err) === ERR_UNKNOWN_MESSAGE ? { success: !1, error: errMessage(err) } : { success: !1, error: errMessage(err), retryable: !0 };
+    }
+  }
+  async sendTyping(chatId, threadId) {
+    let key = typingKey(chatId, threadId), targetId = threadId ?? chatId;
+    await this.doTyping(targetId);
+    let existing = this.typing.get(key);
+    if (existing) {
+      existing.lastRefresh = this.now();
+      return;
+    }
+    let interval = this.scheduler.setInterval(() => {
+      let entry = this.typing.get(key);
+      if (entry) {
+        if (this.now() - entry.lastRefresh > TYPING_SAFETY_MS) {
+          this.stopTyping(key);
+          return;
+        }
+        this.doTyping(targetId);
+      }
+    }, TYPING_INTERVAL_MS);
+    this.typing.set(key, { interval, lastRefresh: this.now() });
+  }
+  async doTyping(channelId) {
+    try {
+      await (await this.fetchChannel(channelId))?.sendTyping?.();
+    } catch {
+    }
+  }
+  stopTyping(key) {
+    let entry = this.typing.get(key);
+    entry && (this.scheduler.clearInterval(entry.interval), this.typing.delete(key));
+  }
+};
+
+// packages/coding-agent/dist/gateway/adapters/telegram.js
+var API_BASE = "https://api.telegram.org";
+var MARKDOWN_PARSE_ERROR_RE = /can't parse|parse entities/i, NOT_MODIFIED_RE = /message is not modified/i, TelegramApiError = class extends Error {
+  status;
+  retryAfter;
+  constructor(status, description, retryAfter) {
+    super(description), this.name = "TelegramApiError", this.status = status, this.retryAfter = retryAfter;
+  }
+}, BACKOFF_DELAYS_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
+function backoffDelayMs(consecutiveFailures) {
+  let index = Math.min(Math.max(consecutiveFailures, 0), BACKOFF_DELAYS_MS.length - 1);
+  return BACKOFF_DELAYS_MS[index];
+}
+var defaultScheduler2 = {
+  setTimeout: (fn, ms) => {
+    let handle = setTimeout(fn, ms);
+    return handle.unref?.(), handle;
+  },
+  clearTimeout: (handle) => clearTimeout(handle),
+  setInterval: (fn, ms) => {
+    let handle = setInterval(fn, ms);
+    return handle.unref?.(), handle;
+  },
+  clearInterval: (handle) => clearInterval(handle)
+};
+async function defaultCallApi(token, method, body, signal) {
+  let res = await fetch(`${API_BASE}/bot${token}/${method}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal
+  }), data = await res.json().catch(() => {
+  });
+  if (res.status === 429)
+    throw new TelegramApiError(429, data?.description ?? "rate limited", data?.parameters?.retry_after);
+  if (!res.ok || !data?.ok)
+    throw new TelegramApiError(data?.error_code ?? res.status, data?.description ?? `HTTP ${res.status}`, data?.parameters?.retry_after);
+  return data.result;
+}
+async function defaultDownloadFile(token, filePath) {
+  let res = await fetch(`${API_BASE}/file/bot${token}/${filePath}`);
+  if (!res.ok)
+    throw new TelegramApiError(res.status, `file download HTTP ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+function errMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function chatTypeOf(chat) {
+  switch (chat.type) {
+    case "private":
+      return "dm";
+    case "group":
+    case "supergroup":
+      return "group";
+    case "channel":
+      return "channel";
+    default:
+      return null;
+  }
+}
+function extractMention(text, entities, botInfo) {
+  if (!botInfo.botUsername)
+    return { text: text.trim(), mentioned: !1 };
+  let botAt = `@${botInfo.botUsername}`.toLowerCase(), removals = [], mentioned = !1;
+  for (let entity of entities) {
+    let slice = text.slice(entity.offset, entity.offset + entity.length);
+    if (entity.type === "mention" && slice.toLowerCase() === botAt)
+      mentioned = !0, removals.push([entity.offset, entity.offset + entity.length]);
+    else if (entity.type === "text_mention" && entity.user?.id === botInfo.botId)
+      mentioned = !0, removals.push([entity.offset, entity.offset + entity.length]);
+    else if (entity.type === "bot_command" && slice.toLowerCase().includes(botAt)) {
+      mentioned = !0;
+      let at = slice.toLowerCase().indexOf(botAt);
+      removals.push([entity.offset + at, entity.offset + at + botAt.length]);
+    }
+  }
+  if (removals.length === 0)
+    return { text: text.trim(), mentioned };
+  removals.sort((a, b) => a[0] - b[0]);
+  let out = "", pos = 0;
+  for (let [start, end] of removals)
+    out += text.slice(pos, start), pos = Math.max(pos, end);
+  return out += text.slice(pos), { text: out.trim(), mentioned };
+}
+function isImageMimeType(mimeType) {
+  return typeof mimeType == "string" && mimeType.split(";")[0]?.trim().toLowerCase().startsWith("image/");
+}
+function collectTelegramMedia(message) {
+  let descriptors = [];
+  if (message.photo && message.photo.length > 0) {
+    let largest = message.photo[message.photo.length - 1];
+    descriptors.push({
+      fileId: largest.file_id,
+      mimeType: "image/jpeg",
+      ...largest.file_size !== void 0 ? { fileSize: largest.file_size } : {}
+    });
+  }
+  return message.document && isImageMimeType(message.document.mime_type) && descriptors.push({
+    fileId: message.document.file_id,
+    mimeType: message.document.mime_type ?? "image/jpeg",
+    ...message.document.file_name ? { filename: message.document.file_name } : {},
+    ...message.document.file_size !== void 0 ? { fileSize: message.document.file_size } : {}
+  }), descriptors;
+}
+function updateToEvent(update, botInfo) {
+  let message = update.message;
+  if (!message)
+    return null;
+  let from = message.from;
+  if (!from || from.id === botInfo.botId || from.is_bot)
+    return null;
+  let hasMedia = collectTelegramMedia(message).length > 0, rawText = message.text ?? message.caption;
+  if (!rawText && !hasMedia)
+    return null;
+  let rawEntities = message.text !== void 0 ? message.entities : message.caption_entities, chatType = chatTypeOf(message.chat);
+  if (chatType === null)
+    return null;
+  let threadId = message.chat.is_forum === !0 && message.message_thread_id !== void 0 && message.message_thread_id !== 1 ? String(message.message_thread_id) : void 0, { text, mentioned } = extractMention(rawText ?? "", rawEntities ?? [], botInfo), replyText = message.reply_to_message?.text;
+  return {
+    text,
+    messageId: String(message.message_id),
+    replyToText: replyText !== void 0 ? replyText.slice(0, 500) : void 0,
+    source: {
+      platform: "telegram",
+      chatId: String(message.chat.id),
+      chatType,
+      userId: String(from.id),
+      userName: from.username ?? from.first_name,
+      threadId
+    },
+    metadata: mentioned ? { mentionedBot: !0 } : void 0
+  };
+}
+function callbackQueryToEvent(query) {
+  let message = query.message;
+  if (!message)
+    return null;
+  let from = query.from;
+  return chatTypeOf(message.chat) === null ? null : {
+    id: query.id,
+    chatId: String(message.chat.id),
+    messageId: String(message.message_id),
+    userId: String(from.id),
+    userName: from.username ?? from.first_name,
+    data: query.data ?? "",
+    threadId: message.chat.is_forum === !0 && message.message_thread_id !== void 0 && message.message_thread_id !== 1 ? String(message.message_thread_id) : void 0
+  };
+}
+var TelegramAdapter = class {
+  platform = "telegram";
+  maxMessageLength = 4096;
+  callApi;
+  downloadFile;
+  maxMediaBytes;
+  scheduler;
+  debounceMs;
+  now;
+  handler;
+  callbackHandler;
+  botInfo;
+  offset = 0;
+  abortController;
+  pending = /* @__PURE__ */ new Map();
+  typing = /* @__PURE__ */ new Map();
+  constructor(cfg, options = {}) {
+    if (this.scheduler = options.scheduler ?? defaultScheduler2, this.debounceMs = options.debounceMs ?? 300, this.now = options.now ?? Date.now, options.callApi)
+      this.callApi = options.callApi;
+    else {
+      if (!cfg.token)
+        throw new Error("TelegramAdapter: no bot token (set telegram.token or LUNR_TELEGRAM_BOT_TOKEN)");
+      let token = cfg.token;
+      this.callApi = (method, body, signal) => defaultCallApi(token, method, body, signal);
+    }
+    this.downloadFile = options.downloadFile ?? ((filePath) => defaultDownloadFile(cfg.token ?? "", filePath)), this.maxMediaBytes = options.maxMediaBytes ?? 10 * 1024 * 1024;
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  onCallback(handler) {
+    this.callbackHandler = handler;
+  }
+  async connect() {
+    let me = await this.callApi("getMe", {});
+    return this.botInfo = { botId: me.id, botUsername: me.username ?? "" }, this.abortController = new AbortController(), this.pollLoop(this.abortController.signal), !0;
+  }
+  async disconnect() {
+    this.abortController?.abort();
+    for (let key of [...this.pending.keys()])
+      this.cancelPending(key);
+    for (let key of [...this.typing.keys()])
+      this.stopTyping(key);
+  }
+  // -----------------------------------------------------------------------
+  // Long-poll loop
+  // -----------------------------------------------------------------------
+  async pollLoop(signal) {
+    let failures = 0;
+    for (; !signal.aborted; )
+      try {
+        let updates = await this.callApi("getUpdates", { offset: this.offset, timeout: 30, allowed_updates: ["message", "callback_query"] }, signal);
+        failures = 0;
+        for (let update of updates)
+          this.offset = update.update_id + 1, await this.dispatchUpdate(update);
+      } catch (err) {
+        if (signal.aborted)
+          return;
+        if (err instanceof TelegramApiError && err.status === 429) {
+          let retryAfter = Math.min(err.retryAfter ?? 1, 30);
+          await this.sleep(retryAfter * 1e3, signal);
+          continue;
+        }
+        let delay = backoffDelayMs(failures);
+        failures += 1, console.error(`[gateway] telegram poll error (retry in ${delay}ms): ${errMessage2(err)}`), await this.sleep(delay, signal);
+      }
+  }
+  sleep(ms, signal) {
+    return new Promise((resolve) => {
+      let timer = this.scheduler.setTimeout(resolve, ms);
+      signal?.addEventListener("abort", () => {
+        this.scheduler.clearTimeout(timer), resolve();
+      }, { once: !0 });
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Inbound dispatch + debounce
+  // -----------------------------------------------------------------------
+  debounceKey(event) {
+    return `${event.source.chatId}:${event.source.threadId ?? ""}:${event.source.userId}`;
+  }
+  async dispatchUpdate(update) {
+    if (!this.botInfo)
+      return;
+    if (update.callback_query) {
+      let event2 = callbackQueryToEvent(update.callback_query);
+      event2 && this.callbackHandler?.(event2);
+      return;
+    }
+    if (!this.handler)
+      return;
+    let event = updateToEvent(update, this.botInfo);
+    if (!event)
+      return;
+    if (update.message) {
+      let attachments = await this.downloadMedia(update.message);
+      attachments.length > 0 && (event.attachments = attachments);
+    }
+    let key = this.debounceKey(event);
+    if (event.text.trimStart().startsWith("/")) {
+      this.flushPending(key), this.handler(event);
+      return;
+    }
+    let existing = this.pending.get(key);
+    if (existing) {
+      this.scheduler.clearTimeout(existing.timer);
+      let mergedAttachments = [...existing.event.attachments ?? [], ...event.attachments ?? []];
+      existing.event = {
+        ...event,
+        text: `${existing.event.text}
+${event.text}`,
+        ...mergedAttachments.length > 0 ? { attachments: mergedAttachments } : {}
+      }, existing.timer = this.scheduler.setTimeout(() => this.flushPending(key), this.debounceMs);
+    } else {
+      let timer = this.scheduler.setTimeout(() => this.flushPending(key), this.debounceMs);
+      this.pending.set(key, { event, timer });
+    }
+  }
+  /** lunr: download + base64-encode inbound image media for one Telegram message. */
+  async downloadMedia(message) {
+    let descriptors = collectTelegramMedia(message);
+    if (descriptors.length === 0)
+      return [];
+    let attachments = [];
+    for (let descriptor of descriptors)
+      if (!(descriptor.fileSize !== void 0 && descriptor.fileSize > this.maxMediaBytes))
+        try {
+          let fileResult = await this.callApi("getFile", { file_id: descriptor.fileId }), filePath = fileResult?.file_path;
+          if (!filePath || fileResult?.file_size !== void 0 && fileResult.file_size > this.maxMediaBytes)
+            continue;
+          let bytes = await this.downloadFile(filePath);
+          if (bytes.byteLength > this.maxMediaBytes)
+            continue;
+          attachments.push({
+            data: Buffer.from(bytes).toString("base64"),
+            mimeType: descriptor.mimeType,
+            ...descriptor.filename ? { filename: descriptor.filename } : {}
+          });
+        } catch {
+        }
+    return attachments;
+  }
+  flushPending(key) {
+    let entry = this.pending.get(key);
+    entry && (this.scheduler.clearTimeout(entry.timer), this.pending.delete(key), this.handler?.(entry.event));
+  }
+  cancelPending(key) {
+    let entry = this.pending.get(key);
+    entry && (this.scheduler.clearTimeout(entry.timer), this.pending.delete(key));
+  }
+  // -----------------------------------------------------------------------
+  // Outbound
+  // -----------------------------------------------------------------------
+  buildSendBody(chatId, text, opts) {
+    let body = { chat_id: chatId, text, parse_mode: "Markdown" };
+    return opts?.threadId !== void 0 && (body.message_thread_id = Number(opts.threadId)), opts?.replyTo !== void 0 && (body.reply_parameters = { message_id: Number(opts.replyTo) }), body;
+  }
+  buildReplyMarkup(buttons) {
+    if (buttons !== void 0)
+      return {
+        inline_keyboard: buttons.map((row) => row.map((b) => ({ text: b.label, callback_data: b.data })))
+      };
+  }
+  async send(chatId, text, opts) {
+    this.stopTyping(typingKey2(chatId, opts?.threadId));
+    let body = this.buildSendBody(chatId, text, opts);
+    return this.callSend(body);
+  }
+  async sendButtons(chatId, text, buttons, opts) {
+    this.stopTyping(typingKey2(chatId, opts?.threadId));
+    let body = this.buildSendBody(chatId, text, opts), markup = this.buildReplyMarkup(buttons);
+    return markup && (body.reply_markup = markup), this.callSend(body);
+  }
+  async answerCallback(id, text) {
+    let body = { callback_query_id: id };
+    text !== void 0 && (body.text = text), await this.callApi("answerCallbackQuery", body).catch(() => {
+    });
+  }
+  /** lunr: register the bot's slash-command menu (Telegram client autocomplete). Best-effort — caller catches. */
+  async registerCommands(commands) {
+    let valid = commands.filter((c) => /^[a-z0-9_]{1,32}$/.test(c.name) && c.description.trim().length > 0).map((c) => ({ command: c.name, description: c.description.trim().slice(0, 256) }));
+    valid.length !== 0 && await this.callApi("setMyCommands", { commands: valid });
+  }
+  async callSend(body) {
+    try {
+      let result = await this.callApi("sendMessage", body);
+      return { success: !0, messageId: String(result.message_id) };
+    } catch (err) {
+      if (err instanceof TelegramApiError && err.status === 400 && body.parse_mode !== void 0 && MARKDOWN_PARSE_ERROR_RE.test(err.message)) {
+        let { parse_mode: _dropped, ...plain } = body;
+        return this.callSend(plain);
+      }
+      if (err instanceof TelegramApiError && err.status === 429) {
+        await this.sleep((err.retryAfter ?? 1) * 1e3);
+        try {
+          let result = await this.callApi("sendMessage", body);
+          return { success: !0, messageId: String(result.message_id) };
+        } catch (retryErr) {
+          return { success: !1, error: errMessage2(retryErr), retryable: !0 };
+        }
+      }
+      return {
+        success: !1,
+        error: errMessage2(err),
+        retryable: !(err instanceof TelegramApiError) || err.status >= 500
+      };
+    }
+  }
+  async editMessage(chatId, messageId, text, buttons) {
+    let body = {
+      chat_id: chatId,
+      message_id: Number(messageId),
+      text,
+      parse_mode: "Markdown"
+    }, markup = this.buildReplyMarkup(buttons);
+    markup !== void 0 && (body.reply_markup = markup);
+    try {
+      return await this.callApi("editMessageText", body), { success: !0, messageId };
+    } catch (err) {
+      if (err instanceof TelegramApiError && err.status === 400) {
+        if (NOT_MODIFIED_RE.test(err.message))
+          return { success: !0, messageId };
+        if (MARKDOWN_PARSE_ERROR_RE.test(err.message) && body.parse_mode !== void 0) {
+          let { parse_mode: _dropped, ...plain } = body;
+          try {
+            return await this.callApi("editMessageText", plain), { success: !0, messageId };
+          } catch (retryErr) {
+            return { success: !1, error: errMessage2(retryErr) };
+          }
+        }
+      }
+      return {
+        success: !1,
+        error: errMessage2(err),
+        retryable: !(err instanceof TelegramApiError) || err.status >= 500
+      };
+    }
+  }
+  async sendTyping(chatId, threadId) {
+    let key = typingKey2(chatId, threadId), body = { chat_id: chatId, action: "typing" };
+    threadId !== void 0 && (body.message_thread_id = Number(threadId)), await this.callApi("sendChatAction", body).catch(() => {
+    });
+    let existing = this.typing.get(key);
+    if (existing) {
+      existing.lastRefresh = this.now();
+      return;
+    }
+    let interval = this.scheduler.setInterval(() => {
+      let entry = this.typing.get(key);
+      if (entry) {
+        if (this.now() - entry.lastRefresh > 12e4) {
+          this.stopTyping(key);
+          return;
+        }
+        this.callApi("sendChatAction", body).catch(() => {
+        });
+      }
+    }, 4e3);
+    this.typing.set(key, { interval, lastRefresh: this.now() });
+  }
+  stopTyping(key) {
+    let entry = this.typing.get(key);
+    entry && (this.scheduler.clearInterval(entry.interval), this.typing.delete(key));
+  }
+};
+function typingKey2(chatId, threadId) {
+  return `${chatId}:${threadId ?? ""}`;
+}
+
+// packages/coding-agent/dist/gateway/agent-bridge.js
+import { existsSync as existsSync2 } from "node:fs";
+
+// packages/coding-agent/dist/gateway/store.js
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var storePathOverride;
+function storePath() {
+  return storePathOverride ?? join(getAgentDir(), "gateway-sessions.json");
+}
+function readStore() {
+  let path = storePath();
+  if (!existsSync(path))
+    return {};
+  try {
+    let parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (parsed == null || typeof parsed != "object" || Array.isArray(parsed))
+      return {};
+    let out = {};
+    for (let [key, value] of Object.entries(parsed)) {
+      if (value == null || typeof value != "object")
+        continue;
+      let v = value;
+      typeof v.sessionId != "string" || typeof v.sessionFile != "string" || (out[key] = {
+        sessionId: v.sessionId,
+        sessionFile: v.sessionFile,
+        createdAt: typeof v.createdAt == "string" ? v.createdAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+        lastActiveAt: typeof v.lastActiveAt == "string" ? v.lastActiveAt : (/* @__PURE__ */ new Date(0)).toISOString()
+      });
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function writeStore(data) {
+  let path = storePath(), dir = dirname(path);
+  existsSync(dir) || mkdirSync(dir, { recursive: !0 });
+  let tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf-8"), renameSync(tmp, path);
+}
+function getSession(key) {
+  return readStore()[key];
+}
+function putSession(key, entry) {
+  let data = readStore(), existing = data[key], stored = {
+    sessionId: entry.sessionId,
+    sessionFile: entry.sessionFile,
+    createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return data[key] = stored, writeStore(data), stored;
+}
+function touchSession(key) {
+  let data = readStore(), existing = data[key];
+  existing && (existing.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString(), writeStore(data));
+}
+function removeSession(key) {
+  let data = readStore();
+  return key in data ? (delete data[key], writeStore(data), !0) : !1;
+}
+function listSessions() {
+  return readStore();
+}
+
+// packages/coding-agent/dist/gateway/agent-bridge.js
+function isUserMessageEntry(entry) {
+  return entry.type === "message";
+}
+var QUEUED = "__lunr_gateway_queued__", CACHE_CAP = 20, QUEUE_CAP = 5, runDepth = 0;
+async function defaultSessionFactory(key, reopen) {
+  let [{ loadAllBuiltinExtensions }, { getAgentDir: getAgentDir2 }, { registerCustomizeBridge }, { registerMemoryCapBridge }, { registerModelTierBridge }, { createAgentSessionFromServices, createAgentSessionServices }, { SessionManager: SessionManager2 }, { SettingsManager }, { bindRuntimeBridges }] = await Promise.all([
+    import("./builtin-extensions-LYZ3BFWQ.js"),
+    import("./config-FMEOZSWE.js"),
+    import("./customize-XEXL2DGQ.js"),
+    import("./memory-cap-3S4XRLNP.js"),
+    import("./model-tiers-NJLHUEGK.js"),
+    import("./agent-session-services-IFJMSX7Z.js"),
+    import("./session-manager-MQNBYACL.js"),
+    import("./settings-manager-5LF2VQWC.js"),
+    import("./runtime-bridges-PPHNBFWL.js")
+  ]), cwd = process.cwd(), agentDir = getAgentDir2(), settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: !1 });
+  registerModelTierBridge(settingsManager), registerMemoryCapBridge(settingsManager), registerCustomizeBridge(settingsManager);
+  let sessionManager;
+  reopen && existsSync2(reopen.sessionFile) ? sessionManager = SessionManager2.open(reopen.sessionFile) : (reopen && console.warn(`[gateway] stored session file missing for ${key}; starting a fresh session`), sessionManager = SessionManager2.create(cwd));
+  let services = await createAgentSessionServices({
+    cwd,
+    agentDir,
+    settingsManager,
+    resourceLoaderOptions: { extensionFactories: await loadAllBuiltinExtensions() }
+  }), { session } = await createAgentSessionFromServices({ services, sessionManager });
+  return bindRuntimeBridges({ session, services }), await session.bindExtensions({
+    mode: "print",
+    onError: (err) => console.error(`[gateway] extension error (${err.extensionPath}): ${err.error}`)
+  }), session;
+}
+function extractFinalText(session) {
+  let messages = session.state.messages, last = messages[messages.length - 1];
+  if (last?.role !== "assistant")
+    return "";
+  let assistant = last;
+  if (assistant.stopReason === "error" || assistant.stopReason === "aborted")
+    throw new Error(assistant.errorMessage || `Request ${assistant.stopReason}`);
+  let text = "";
+  for (let content of assistant.content)
+    content.type === "text" && (text += content.text);
+  return text;
+}
+var AgentBridge = class {
+  cap;
+  sessionFactory;
+  cache = /* @__PURE__ */ new Map();
+  redoStack = /* @__PURE__ */ new Map();
+  creating = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.cap = options.cacheCap ?? CACHE_CAP, this.sessionFactory = options.sessionFactory ?? defaultSessionFactory;
+  }
+  /**
+   * Run one conversational turn. Resolves with the final assistant text, or
+   * the QUEUED sentinel when the session was busy (router must not reply).
+   */
+  async runTurn(key, event, callbacks = {}) {
+    let entry = await this.getOrCreate(key);
+    if (entry.busy)
+      return entry.queue.length >= QUEUE_CAP && (entry.queue.shift(), entry.dropped++), entry.queue.push(event), QUEUED;
+    entry.busy = !0;
+    let result;
+    try {
+      result = await this.runPrompt(entry, event.text, callbacks, event.source, event.attachments);
+    } catch (err) {
+      throw entry.busy = !1, err;
+    }
+    return touchSession(key), this.drainQueue(entry, callbacks).finally(() => {
+      entry.busy = !1;
+    }), result;
+  }
+  async abort(key) {
+    await this.cache.get(key)?.session.abort();
+  }
+  /** Return the live session for a key, or null when none exists yet. */
+  async getSession(key) {
+    let cached = this.cache.get(key);
+    return cached ? cached.session : getSession(key) ? (await this.getOrCreate(key)).session : null;
+  }
+  /** Switch the chat to a different persisted session file. */
+  async switchSession(key, sessionFile) {
+    let entry = this.cache.get(key);
+    if (entry?.busy)
+      throw new Error("Session is busy \u2014 /stop first or wait");
+    if (entry) {
+      let oldSessionId = entry.session.sessionManager?.getSessionId();
+      entry.unsubscribe?.(), this.cache.delete(key), entry.session.dispose?.(), oldSessionId && deletePermissionContext(oldSessionId);
+    }
+    removeSession(key), this.redoStack.delete(key);
+    let session = await this.sessionFactory(key, { sessionFile }), newFile = session.sessionManager?.getSessionFile(), newSessionId = session.sessionManager?.getSessionId();
+    newFile && putSession(key, { sessionId: newSessionId ?? key, sessionFile: newFile }), newSessionId && createPermissionContext(newSessionId);
+    let newEntry = { session, busy: !1, queue: [], dropped: 0 };
+    this.cache.set(key, newEntry), this._enforceCacheCap(key), newEntry.unsubscribe = this._subscribeToSession(key, newEntry);
+  }
+  /** Undo the last user turn and push the previous leaf onto the redo stack. */
+  async undo(key) {
+    let session = await this.getSession(key);
+    if (!session)
+      throw new Error("No session");
+    if (session.isStreaming)
+      throw new Error("Wait for the current response to finish");
+    let branch = session.sessionManager?.getBranch() ?? [], lastUserIndex = -1;
+    for (let i = branch.length - 1; i >= 0; i--) {
+      let entry = branch[i];
+      if (isUserMessageEntry(entry) && entry.message.role === "user") {
+        lastUserIndex = i;
+        break;
+      }
+    }
+    if (lastUserIndex === -1)
+      throw new Error("Nothing to undo");
+    let lastUser = branch[lastUserIndex];
+    if (!isUserMessageEntry(lastUser))
+      throw new Error("Nothing to undo");
+    let leafId = session.sessionManager?.getLeafId() ?? null, targetId;
+    if (lastUser.id === leafId) {
+      if (!lastUser.parentId)
+        throw new Error("Nothing to undo");
+      targetId = lastUser.parentId;
+    } else
+      targetId = lastUser.id;
+    if ((await session.navigateTree(targetId, {})).cancelled)
+      throw new Error("Navigation cancelled");
+    if (leafId) {
+      let stack = this.redoStack.get(key) ?? [];
+      stack.push(leafId), this.redoStack.set(key, stack);
+    }
+    return { userText: extractUserText(lastUser.message) };
+  }
+  /** Redo to the leaf saved by the most recent undo. */
+  async redo(key) {
+    let session = await this.getSession(key);
+    if (!session)
+      throw new Error("No session");
+    if (session.isStreaming)
+      throw new Error("Wait for the current response to finish");
+    let stack = this.redoStack.get(key) ?? [], targetId = stack.pop();
+    if (!targetId)
+      throw new Error("Nothing to redo");
+    if (this.redoStack.set(key, stack), (await session.navigateTree(targetId, {})).cancelled)
+      throw stack.push(targetId), this.redoStack.set(key, stack), new Error("Navigation cancelled");
+  }
+  /** Test/debug hook: how many redo targets are saved for a key. */
+  getRedoStackLength(key) {
+    return this.redoStack.get(key)?.length ?? 0;
+  }
+  /** Drop the cached session (disposing it) and forget the store entry (/new, /reset). */
+  async reset(key) {
+    let entry = this.cache.get(key);
+    if (entry) {
+      entry.queue.length = 0, entry.dropped = 0;
+      try {
+        await entry.session.abort();
+      } catch {
+      }
+      entry.unsubscribe?.(), this.cache.delete(key), entry.session.dispose?.();
+    }
+    removeSession(key), this.redoStack.delete(key);
+  }
+  getStatus(key) {
+    let entry = this.cache.get(key);
+    return {
+      busy: entry?.busy ?? !1,
+      queueDepth: entry?.queue.length ?? 0,
+      createdAt: getSession(key)?.createdAt
+    };
+  }
+  /** One prompt → final text. Increments runDepth; streams deltas when asked. */
+  async runPrompt(entry, text, callbacks, source, attachments) {
+    let { session } = entry, unsubscribe;
+    if (callbacks.onDelta) {
+      let onDelta = callbacks.onDelta, streamedLen = 0;
+      unsubscribe = session.subscribe((event) => {
+        if (event.type !== "message_update")
+          return;
+        let assistantEvent = event.assistantMessageEvent;
+        if (assistantEvent.type !== "text_delta")
+          return;
+        let full = "";
+        for (let content of assistantEvent.partial.content)
+          content.type === "text" && (full += content.text);
+        full.length < streamedLen && (streamedLen = 0), full.length > streamedLen && (onDelta(full.slice(streamedLen)), streamedLen = full.length);
+      });
+    }
+    runDepth++;
+    try {
+      let images = [], notes = [];
+      for (let attachment of attachments ?? []) {
+        let bytes = Buffer.from(attachment.data, "base64"), processed = await processImage(new Uint8Array(bytes), attachment.mimeType);
+        if (processed.ok) {
+          images.push({ type: "image", data: processed.data, mimeType: processed.mimeType });
+          for (let hint of processed.hints)
+            notes.push(hint);
+        } else
+          notes.push(processed.message);
+      }
+      let promptText = notes.length > 0 ? `${text}
+
+${notes.join(" ")}` : text;
+      await runWithOrigin({
+        platform: source.platform,
+        chatId: source.chatId,
+        threadId: source.threadId,
+        chatType: source.chatType
+      }, () => session.prompt(promptText, { source: "extension", ...images.length ? { images } : {} }));
+    } finally {
+      runDepth--, unsubscribe?.();
+    }
+    return extractFinalText(session);
+  }
+  /** Drain the queue FIFO: all queued messages become one concatenated turn. */
+  async drainQueue(entry, callbacks) {
+    for (; entry.queue.length > 0; ) {
+      let items = entry.queue.splice(0), parts = items.map((item) => item.text), attachments = items.flatMap((item) => item.attachments ?? []);
+      entry.dropped > 0 && (parts.unshift(`[gateway: ${entry.dropped} earlier message(s) were dropped \u2014 the queue was full]`), entry.dropped = 0);
+      try {
+        let text = await this.runPrompt(entry, parts.join(`
+
+`), {}, items[items.length - 1].source, attachments);
+        callbacks.onFollowUpResult?.(text);
+      } catch (err) {
+        callbacks.onError?.(err instanceof Error ? err.message : String(err));
+        return;
+      }
+    }
+  }
+  async getOrCreate(key) {
+    let cached = this.cache.get(key);
+    if (cached)
+      return this.cache.delete(key), this.cache.set(key, cached), cached;
+    let pending2 = this.creating.get(key);
+    if (!pending2) {
+      pending2 = this.createEntry(key), this.creating.set(key, pending2);
+      try {
+        await pending2;
+      } finally {
+        this.creating.delete(key);
+      }
+    }
+    return pending2;
+  }
+  async createEntry(key) {
+    let stored = getSession(key), session = await this.sessionFactory(key, stored ? { sessionFile: stored.sessionFile } : void 0), sessionFile = session.sessionManager?.getSessionFile(), sessionId = session.sessionManager?.getSessionId();
+    sessionFile && putSession(key, { sessionId: sessionId ?? key, sessionFile }), sessionId && createPermissionContext(sessionId);
+    let entry = { session, busy: !1, queue: [], dropped: 0, unsubscribe: void 0 };
+    return this.cache.set(key, entry), this._enforceCacheCap(key), entry.unsubscribe = this._subscribeToSession(key, entry), entry;
+  }
+  _enforceCacheCap(protectedKey) {
+    for (; this.cache.size > this.cap; ) {
+      let oldestKey, oldest;
+      for (let [key, entry] of this.cache)
+        if (key !== protectedKey && !entry.busy) {
+          oldestKey = key, oldest = entry;
+          break;
+        }
+      if (!oldest || !oldestKey) {
+        this.cap = this.cache.size;
+        break;
+      }
+      oldest.unsubscribe?.(), this.cache.delete(oldestKey), oldest.session.dispose?.();
+      let evictedSessionId = oldest.session.sessionManager?.getSessionId();
+      evictedSessionId && deletePermissionContext(evictedSessionId);
+    }
+  }
+  _subscribeToSession(key, entry) {
+    return entry.session.subscribe((event) => this._handleSessionEvent(key, event));
+  }
+  _handleSessionEvent(key, event) {
+    event.type === "message_start" && event.message?.role === "user" && this.redoStack.delete(key);
+  }
+};
+function extractUserText(message) {
+  let text = "";
+  if ("content" in message && Array.isArray(message.content))
+    for (let block of message.content)
+      block && typeof block == "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text == "string" && (text += block.text);
+  return text;
+}
+
+// packages/coding-agent/dist/gateway/approval.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+var CALLBACK_PREFIX = "ap:", ID_LENGTH = 8, CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", DEFAULT_TIMEOUT_MS = 300 * 1e3, approvalContext = new AsyncLocalStorage(), pending = /* @__PURE__ */ new Map();
+function generateId() {
+  let id = "", bytes = randomBytes(ID_LENGTH);
+  for (let i = 0; i < ID_LENGTH; i++)
+    id += CODE_ALPHABET[bytes[i] % CODE_ALPHABET.length];
+  return id;
+}
+function makeCallbackData(id, action) {
+  return `${CALLBACK_PREFIX}${id}:${action}`;
+}
+function parseCallbackData(data) {
+  if (!data.startsWith(CALLBACK_PREFIX))
+    return null;
+  let rest = data.slice(CALLBACK_PREFIX.length), colon = rest.indexOf(":");
+  if (colon === -1)
+    return null;
+  let id = rest.slice(0, colon), action = rest.slice(colon + 1);
+  return action === "once" || action === "session" || action === "reject" || action === "cancel" ? { id, action } : null;
+}
+function runWithApprovalContext(ctx, fn) {
+  return approvalContext.run(ctx, fn);
+}
+async function createApprovalPrompt(adapter, source, req, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  let id = generateId(), title = req.kind === "large-subagent-launch" ? `Approve large subagent launch?
+${req.detail}` : `Approve ${req.toolName}?
+${req.detail}`, rows = [
+    [
+      { label: "\u2713 Approve once", data: makeCallbackData(id, "once") },
+      { label: "\u2713 Approve session", data: makeCallbackData(id, "session") }
+    ],
+    [{ label: "\u2717 Reject", data: makeCallbackData(id, "reject") }]
+  ];
+  return new Promise((resolve, reject) => {
+    let messageId, timeout = setTimeout(() => {
+      pending.delete(id), reject(new Error("Approval request timed out")), messageId && adapter.editMessage(source.chatId, messageId, "\u23F1 Approval expired.", []).catch(() => {
+      });
+    }, timeoutMs);
+    (async () => {
+      try {
+        let result = await adapter.sendButtons(source.chatId, title, rows, { threadId: source.threadId });
+        if (!result.success || !result.messageId) {
+          clearTimeout(timeout), reject(new Error(result.error ?? "Failed to send approval prompt"));
+          return;
+        }
+        messageId = result.messageId, pending.set(id, {
+          resolve,
+          reject,
+          timeout,
+          messageId,
+          adapter,
+          chatId: source.chatId,
+          threadId: source.threadId,
+          userId: source.userId
+        });
+      } catch (err) {
+        clearTimeout(timeout), reject(err);
+      }
+    })();
+  });
+}
+async function createGatewayApprovalRequest(req) {
+  let ctx = approvalContext.getStore();
+  if (!ctx)
+    throw new Error(NO_HANDLER_REASON);
+  return createApprovalPrompt(ctx.adapter, ctx.source, req, ctx.timeoutMs);
+}
+function registerGatewayApprovalHandler() {
+  registerApprovalHandler(createGatewayApprovalRequest);
+}
+async function handleApprovalCallback(event, adapter) {
+  let parsed = parseCallbackData(event.data);
+  if (!parsed)
+    return !1;
+  let entry = pending.get(parsed.id);
+  if (!entry)
+    return await adapter?.answerCallback(event.id, "Approval expired.").catch(() => {
+    }), !0;
+  if (event.userId !== entry.userId)
+    return await entry.adapter.answerCallback(event.id, "\u26D4 Not your approval.").catch(() => {
+    }), !0;
+  clearTimeout(entry.timeout), pending.delete(parsed.id);
+  let response = parsed.action === "reject" || parsed.action === "cancel" ? "reject" : parsed.action;
+  entry.resolve(response);
+  let label = parsed.action === "reject" || parsed.action === "cancel" ? "Rejected." : `Approved (${parsed.action}).`;
+  return await entry.adapter.editMessage(entry.chatId, entry.messageId ?? "", label, []).catch(() => {
+  }), await entry.adapter.answerCallback(event.id).catch(() => {
+  }), !0;
+}
+
+// packages/coding-agent/dist/gateway/authz.js
+function envFlagEnabled(name) {
+  let raw = process.env[name];
+  return raw === void 0 ? !1 : ["1", "true", "yes", "on"].includes(raw.toLowerCase());
+}
+function globalAllowedUsers() {
+  let raw = process.env.LUNR_GATEWAY_ALLOWED_USERS;
+  return raw ? raw.split(",").map((u) => u.trim()).filter((u) => u.length > 0) : [];
+}
+function isAuthorized(source, cfg, pairing) {
+  if (envFlagEnabled("LUNR_GATEWAY_ALLOW_ALL_USERS"))
+    return !0;
+  let platformCfg = platformConfigFor(cfg, source.platform);
+  return !!(platformCfg?.allowedChats.includes(source.chatId) || source.roleAuthorized === !0 || source.userId && pairing.isPaired(source.platform, source.userId) || source.userId && (platformCfg?.allowedUsers.includes(source.userId) || globalAllowedUsers().includes(source.userId)));
+}
+function addAllowedUser(platform, userId) {
+  let cfg = loadGatewayConfig(), platformCfg = platformConfigFor(cfg, platform);
+  if (!platformCfg)
+    throw new Error(`Unknown platform "${platform}"`);
+  platformCfg.allowedUsers.includes(userId) || (platformCfg.allowedUsers.push(userId), saveGatewayConfig(cfg));
+}
+
+// packages/coding-agent/dist/gateway/buttons.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+var PICKER_TTL_MS = 900 * 1e3, SWEEP_INTERVAL_MS = 60 * 1e3, DEFAULT_PER_PAGE = 8, BUTTONS_PER_ROW = 2, CODE_ALPHABET2 = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", CODE_LENGTH = 8, CALLBACK_PREFIX2 = "cp:", registry = /* @__PURE__ */ new Map(), sweeper;
+function generatePickerId() {
+  let id = "", bytes = randomBytes2(CODE_LENGTH);
+  for (let i = 0; i < CODE_LENGTH; i++)
+    id += CODE_ALPHABET2[bytes[i] % CODE_ALPHABET2.length];
+  return id;
+}
+function makeCallbackData2(id, action, payload) {
+  return action === "noop" ? `${CALLBACK_PREFIX2}${id}:` : action === "cancel" ? `${CALLBACK_PREFIX2}${id}:x` : action === "page" ? `${CALLBACK_PREFIX2}${id}:p${payload ?? "0"}` : `${CALLBACK_PREFIX2}${id}:${payload ?? ""}`;
+}
+function parseCallbackData2(data) {
+  if (!data.startsWith(CALLBACK_PREFIX2))
+    return null;
+  let rest = data.slice(CALLBACK_PREFIX2.length), colon = rest.indexOf(":");
+  if (colon === -1)
+    return null;
+  let id = rest.slice(0, colon), tail = rest.slice(colon + 1);
+  return tail === "" ? { id, action: "noop" } : tail === "x" ? { id, action: "cancel" } : tail.startsWith("p") ? { id, action: "page", payload: tail.slice(1) } : { id, action: "select", payload: tail };
+}
+function isSameChat(a, b) {
+  return a.platform === b.platform && a.chatId === b.chatId && a.threadId === b.threadId;
+}
+function sourceForAuth(picker, cb) {
+  return {
+    platform: picker.source.platform,
+    chatId: cb.chatId,
+    chatType: picker.source.chatType,
+    userId: cb.userId,
+    userName: cb.userName,
+    threadId: cb.threadId,
+    // Do NOT inherit the original invoker's role authorization.
+    roleAuthorized: void 0
+  };
+}
+function renderPage(picker) {
+  let { id, title, breadcrumbs, items, page, perPage } = picker, totalPages = Math.max(1, Math.ceil(items.length / perPage)), clampedPage = Math.max(0, Math.min(page, totalPages - 1)), start = clampedPage * perPage, pageItems = items.slice(start, start + perPage), rows = [];
+  for (let i = 0; i < pageItems.length; i += BUTTONS_PER_ROW) {
+    let row = [];
+    for (let j = 0; j < BUTTONS_PER_ROW && i + j < pageItems.length; j++) {
+      let index = start + i + j;
+      row.push({ label: pageItems[i + j].label, data: makeCallbackData2(id, "select", String(index)) });
+    }
+    rows.push(row);
+  }
+  if (totalPages > 1) {
+    let nav = [];
+    clampedPage > 0 && nav.push({ label: "\u25C0 Prev", data: makeCallbackData2(id, "page", String(clampedPage - 1)) }), nav.push({ label: `${clampedPage + 1}/${totalPages}`, data: makeCallbackData2(id, "noop") }), clampedPage < totalPages - 1 && nav.push({ label: "Next \u25B6", data: makeCallbackData2(id, "page", String(clampedPage + 1)) }), rows.push(nav);
+  }
+  rows.push([{ label: "\u2717 Cancel", data: makeCallbackData2(id, "cancel") }]);
+  let header = breadcrumbs ? `${title} \xB7 ${breadcrumbs}` : title;
+  return { text: items.length === 0 ? `${header}
+
+No options available.` : `${header} (${clampedPage + 1}/${totalPages}):`, buttons: rows };
+}
+async function createPicker(adapter, source, spec, opts) {
+  let id = generatePickerId(), pending2 = {
+    ...spec,
+    id,
+    chatId: source.chatId,
+    source,
+    adapter,
+    messageId: "",
+    page: 0,
+    perPage: spec.perPage ?? DEFAULT_PER_PAGE,
+    createdAt: Date.now()
+  }, { text, buttons } = renderPage(pending2), result = await adapter.sendButtons(source.chatId, text, buttons, opts);
+  return result.success && result.messageId && (pending2.messageId = result.messageId, registry.set(id, pending2)), result;
+}
+async function answerExpired(adapter, cb) {
+  await adapter.answerCallback(cb.id, "Picker expired \u2014 run the command again.").catch(() => {
+  });
+}
+async function answerUnauthorized(adapter, cb) {
+  await adapter.answerCallback(cb.id, "\u26D4 Not authorized.").catch(() => {
+  });
+}
+async function answerNotYourPicker(adapter, cb) {
+  await adapter.answerCallback(cb.id, "\u26D4 Not your picker.").catch(() => {
+  });
+}
+async function handleCallback(cb, deps) {
+  let { adapter, cfg, pairing } = deps, parsed = parseCallbackData2(cb.data);
+  if (!parsed)
+    return;
+  let picker = registry.get(parsed.id);
+  if (!picker) {
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (Date.now() > picker.createdAt + PICKER_TTL_MS) {
+    registry.delete(parsed.id);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, "\u23F1 Expired \u2014 run the command again.", []);
+    } catch {
+    }
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (!isSameChat(picker.source, sourceForAuth(picker, cb))) {
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (cb.userId !== picker.invokerId) {
+    await answerNotYourPicker(adapter, cb);
+    return;
+  }
+  if (!isAuthorized(sourceForAuth(picker, cb), cfg, pairing)) {
+    await answerUnauthorized(adapter, cb);
+    return;
+  }
+  if (parsed.action === "cancel") {
+    registry.delete(parsed.id);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, "Cancelled.", []);
+    } catch {
+    }
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+    return;
+  }
+  if (parsed.action === "noop") {
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+    return;
+  }
+  if (parsed.action === "page") {
+    let page = Number.parseInt(parsed.payload ?? "0", 10), totalPages = Math.max(1, Math.ceil(picker.items.length / picker.perPage));
+    picker.page = Math.max(0, Math.min(page, totalPages - 1));
+    let { text, buttons } = renderPage(picker);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, text, buttons);
+    } catch {
+    }
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+    return;
+  }
+  let index = Number.parseInt(parsed.payload ?? "", 10), item = picker.items[index];
+  if (!item) {
+    await adapter.answerCallback(cb.id, "Invalid selection.").catch(() => {
+    });
+    return;
+  }
+  try {
+    let result = await picker.resolve(item);
+    if (!result.done) {
+      picker.items = result.items, picker.title = result.title, picker.breadcrumbs = result.breadcrumbs, picker.page = 0;
+      let { text, buttons } = renderPage(picker);
+      try {
+        await picker.adapter.editMessage(picker.chatId, picker.messageId, text, buttons);
+      } catch {
+      }
+      await adapter.answerCallback(cb.id).catch(() => {
+      });
+      return;
+    }
+    registry.delete(parsed.id);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, result.text, []);
+    } catch {
+    }
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+  } catch (err) {
+    registry.delete(parsed.id);
+    let message = err instanceof Error ? err.message : String(err);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, `\u26A0 ${message}`, []);
+    } catch {
+    }
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+  }
+}
+function startButtonSweeper() {
+  sweeper || (sweeper = setInterval(() => {
+    let cutoff = Date.now() - PICKER_TTL_MS;
+    for (let [id, entry] of registry)
+      if (!(entry.createdAt > cutoff)) {
+        registry.delete(id);
+        try {
+          entry.adapter.editMessage(entry.chatId, entry.messageId, "\u23F1 Expired \u2014 run the command again.", []);
+        } catch {
+        }
+      }
+  }, SWEEP_INTERVAL_MS), sweeper.unref?.());
+}
+function stopButtonSweeper() {
+  sweeper && (clearInterval(sweeper), sweeper = void 0);
+}
+
+// packages/coding-agent/dist/gateway/commands.js
+var MODEL_CACHE_TTL_MS = 300 * 1e3, SESSIONS_CACHE_TTL_MS = 300 * 1e3, MAX_MODEL_LIST_LINES = 15, PROVIDER_PER_PAGE = 10;
+var MAX_MODELS_PER_PROVIDER = 50, MODEL_ID_MAX = 38, MODEL_CACHE_CAP = 100, SESSIONS_CACHE_CAP = 100, modelCache = /* @__PURE__ */ new Map(), sessionsCache = /* @__PURE__ */ new Map();
+function evictLRU(map, cap) {
+  for (; map.size > cap; ) {
+    let first = map.keys().next().value;
+    first !== void 0 && map.delete(first);
+  }
+}
+function getCachedModels(key) {
+  let cached = modelCache.get(key);
+  if (cached) {
+    if (Date.now() > cached.expires) {
+      modelCache.delete(key);
+      return;
+    }
+    return modelCache.delete(key), modelCache.set(key, cached), cached.models;
+  }
+}
+function setCachedModels(key, models) {
+  modelCache.set(key, { models, expires: Date.now() + MODEL_CACHE_TTL_MS }), evictLRU(modelCache, MODEL_CACHE_CAP);
+}
+function getCachedSessions(key) {
+  let cached = sessionsCache.get(key);
+  if (cached) {
+    if (Date.now() > cached.expires) {
+      sessionsCache.delete(key);
+      return;
+    }
+    return sessionsCache.delete(key), sessionsCache.set(key, cached), cached.sessions;
+  }
+}
+function setCachedSessions(key, sessions) {
+  sessionsCache.set(key, { sessions, expires: Date.now() + SESSIONS_CACHE_TTL_MS }), evictLRU(sessionsCache, SESSIONS_CACHE_CAP);
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function prefixLines(text, prefix) {
+  return text.split(`
+`).map((line, index) => (index === 0 ? prefix : "  ") + line).join(`
+`);
+}
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1)}\u2026`;
+}
+function formatRelativeTime(date) {
+  let seconds = Math.max(0, Math.floor((Date.now() - date.getTime()) / 1e3));
+  if (seconds < 60)
+    return `${seconds}s ago`;
+  let minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  let hours = Math.floor(minutes / 60);
+  return hours < 24 ? `${hours}h ago` : `${Math.floor(hours / 24)}d ago`;
+}
+function formatModelList(models, maxLines = MAX_MODEL_LIST_LINES) {
+  if (models.length === 0)
+    return ["No models available."];
+  let byProvider = /* @__PURE__ */ new Map();
+  for (let model of models) {
+    let list = byProvider.get(model.provider) ?? [];
+    list.push(model), byProvider.set(model.provider, list);
+  }
+  let providers = [...byProvider.keys()].sort(), lines = [], index = 1;
+  for (let provider of providers) {
+    let list = (byProvider.get(provider) ?? []).sort((a, b) => a.id.localeCompare(b.id));
+    for (let model of list)
+      lines.push(`${index}) ${provider}/${model.id}`), index++;
+  }
+  return lines.length <= maxLines ? lines : [
+    `${models.length} models across ${providers.length} providers.`,
+    "Use /model <provider/id> or /model <query>.",
+    ...providers.map((p) => `- ${p}`)
+  ];
+}
+function groupModelsByProvider(models) {
+  let byProvider = /* @__PURE__ */ new Map();
+  for (let model of models) {
+    let list = byProvider.get(model.provider) ?? [];
+    list.push(model), byProvider.set(model.provider, list);
+  }
+  for (let list of byProvider.values())
+    list.sort((a, b) => a.id.localeCompare(b.id));
+  return byProvider;
+}
+function truncateModelId(id) {
+  let lastSlash = id.lastIndexOf("/"), name = lastSlash >= 0 ? id.slice(lastSlash + 1) : id;
+  return truncate(name, MODEL_ID_MAX);
+}
+async function refreshAndCacheModels(session, key) {
+  let runtime = session.modelRuntime;
+  await runtime.refresh();
+  let models = [...await runtime.getAvailable()].sort((a, b) => a.provider.localeCompare(b.provider) || a.id.localeCompare(b.id));
+  return setCachedModels(key, models), models;
+}
+async function setModelAndReply(ctx, model) {
+  let session = ctx.session;
+  try {
+    await session.setModel(model);
+  } catch (error) {
+    if ((error instanceof Error ? error.message : String(error)).includes("No API key")) {
+      await ctx.reply(`No API key for ${model.provider}.`);
+      return;
+    }
+    throw error;
+  }
+  await ctx.reply(`Model \u2192 ${model.provider}/${model.id} (thinking level re-clamped to ${session.thinkingLevel})`);
+}
+var newCommand = {
+  name: "new",
+  aliases: ["reset"],
+  description: "start a fresh session for this chat",
+  // lunr: busy-session /new must bypass the guard (same as /stop).
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    await ctx.bridge.reset(ctx.key), await ctx.reply("Session reset \u2014 next message starts a fresh session.");
+  }
+}, undoCommand = {
+  name: "undo",
+  description: "rewind the session tree before the last user turn",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let { userText } = await ctx.bridge.undo(ctx.key), text = userText ? ` "${truncate(userText, 60)}"` : "";
+    await ctx.reply(`Undone \u2014 rewound before${text}. /redo to restore.`);
+  }
+}, redoCommand = {
+  name: "redo",
+  description: "restore the last undone turn",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    await ctx.bridge.redo(ctx.key), await ctx.reply("Redone.");
+  }
+}, stopCommand = {
+  name: "stop",
+  description: "abort the running turn",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    await ctx.bridge.abort(ctx.key), await ctx.reply("Stopped.");
+  }
+}, statusCommand = {
+  name: "status",
+  description: "session status",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    let status = ctx.bridge.getStatus(ctx.key), age = status.createdAt ? `${Math.max(0, Math.round((Date.now() - Date.parse(status.createdAt)) / 1e3))}s` : "no session yet";
+    await ctx.reply(`${ctx.event.source.platform} \xB7 session age ${age} \xB7 ${status.busy ? "busy" : "idle"} \xB7 queue ${status.queueDepth}`);
+  }
+}, whoamiCommand = {
+  name: "whoami",
+  description: "your ids and session key",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    let { userId, chatId } = ctx.event.source;
+    await ctx.reply(`userId: ${userId}
+chatId: ${chatId}
+key: ${ctx.key}`);
+  }
+}, helpCommand = {
+  name: "help",
+  description: "this message",
+  bypassBusy: !0,
+  needsSession: !1,
+  async handler(ctx) {
+    await ctx.reply(formatHelpText());
+  }
+}, modelCommand = {
+  name: "model",
+  description: "list or switch models",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, arg = ctx.args.trim();
+    if (!arg) {
+      let models2 = getCachedModels(ctx.key) ?? await refreshAndCacheModels(session, ctx.key), byProvider = groupModelsByProvider(models2), current = session.model, currentRef = current ? `${current.provider}/${current.id}` : "", providerItems = [...byProvider.keys()].sort().map((provider) => ({
+        label: `${current?.provider === provider ? "\u2713 " : ""}${provider} (${byProvider.get(provider)?.length ?? 0})`,
+        value: provider
+      })), pickerOpts = {
+        replyTo: ctx.event.messageId,
+        threadId: ctx.event.source.threadId
+      };
+      if (!(await createPicker(ctx.adapter, ctx.event.source, {
+        kind: "model",
+        sessionKey: ctx.key,
+        invokerId: ctx.event.source.userId,
+        items: providerItems,
+        perPage: PROVIDER_PER_PAGE,
+        title: "Pick a model provider",
+        async resolve(item) {
+          if (item.value === "__back__")
+            return { done: !1, items: providerItems, title: "Pick a model provider" };
+          if (!item.value.includes("/")) {
+            let provider = item.value, list = byProvider.get(provider) ?? [], capped = list.slice(0, MAX_MODELS_PER_PROVIDER), note = list.length > MAX_MODELS_PER_PROVIDER ? ` \u2014 ${list.length - MAX_MODELS_PER_PROVIDER} more available` : "", modelItems = [];
+            for (let m of capped) {
+              let ref = `${provider}/${m.id}`;
+              modelItems.push({
+                label: `${currentRef === ref ? "\u2713 " : ""}${truncateModelId(m.id)}`,
+                value: ref
+              });
+            }
+            return modelItems.unshift({ label: "\u25C0 Back", value: "__back__" }), {
+              done: !1,
+              items: modelItems,
+              title: `${provider} (${list.length})${note}`,
+              breadcrumbs: provider
+            };
+          }
+          let exact2 = findExactModelReferenceMatch(item.value, models2);
+          if (!exact2)
+            return { done: !0, text: "That model is no longer available." };
+          try {
+            await session.setModel(exact2);
+          } catch (error) {
+            if ((error instanceof Error ? error.message : String(error)).includes("No API key"))
+              return { done: !0, text: `No API key for ${exact2.provider}.` };
+            throw error;
+          }
+          return {
+            done: !0,
+            text: `\u263E Model \u2192 ${exact2.provider}/${exact2.id} (thinking level re-clamped to ${session.thinkingLevel})`
+          };
+        }
+      }, pickerOpts)).success) {
+        let currentText = `${current?.provider ?? "none"}/${current?.id ?? "none"}`, lines = formatModelList(models2);
+        await ctx.reply([`Current: ${currentText}`, ...lines, "Use /model <n> or /model <provider/id>"].join(`
+`));
+      }
+      return;
+    }
+    let numeric = Number.parseInt(arg, 10);
+    if (!Number.isNaN(numeric) && /^\d+$/.test(arg)) {
+      let cached = getCachedModels(ctx.key);
+      if (!cached || numeric < 1 || numeric > cached.length) {
+        await ctx.reply("Invalid selection \u2014 run /model to see the current list.");
+        return;
+      }
+      await setModelAndReply(ctx, cached[numeric - 1]);
+      return;
+    }
+    let models = getCachedModels(ctx.key) ?? await refreshAndCacheModels(session, ctx.key), exact = findExactModelReferenceMatch(arg, models);
+    if (exact) {
+      await setModelAndReply(ctx, exact);
+      return;
+    }
+    let query = arg.toLowerCase(), matches = models.filter((m) => m.id.toLowerCase().includes(query) || `${m.provider}/${m.id}`.toLowerCase().includes(query) || (m.name?.toLowerCase().includes(query) ?? !1));
+    if (matches.length === 0) {
+      await ctx.reply(`No model matches "${arg}".`);
+      return;
+    }
+    if (matches.length > 1) {
+      await ctx.reply(formatModelList(matches).join(`
+`));
+      return;
+    }
+    await setModelAndReply(ctx, matches[0]);
+  }
+}, sessionsCommand = {
+  name: "sessions",
+  description: "list or switch sessions",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, arg = ctx.args.trim(), currentFile = session.sessionManager?.getSessionFile();
+    if (!arg) {
+      let all = await SessionManager.list(process.cwd());
+      all.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+      let sessions = all.slice(0, 10);
+      setCachedSessions(ctx.key, sessions);
+      let items = sessions.map((s) => ({
+        label: `${s.path === currentFile ? "\u263E " : ""}${s.name ? truncate(s.name, 30) : truncate(s.firstMessage, 30) || "(empty)"}`,
+        value: s.path
+      }));
+      if (!(await createPicker(ctx.adapter, ctx.event.source, {
+        kind: "sessions",
+        sessionKey: ctx.key,
+        invokerId: ctx.event.source.userId,
+        items,
+        perPage: 8,
+        title: "Pick a session",
+        async resolve(item) {
+          await ctx.bridge.switchSession(ctx.key, item.value);
+          let switched2 = await ctx.bridge.getSession(ctx.key), name2 = switched2?.sessionManager?.getSessionName() ?? "unnamed", count2 = switched2?.sessionManager?.getEntries().length ?? 0;
+          return { done: !0, text: `\u263E Switched to "${name2}" (${count2} msgs). History continues here.` };
+        }
+      }, { replyTo: ctx.event.messageId, threadId: ctx.event.source.threadId })).success) {
+        let lines = sessions.map((s, i) => {
+          let marker = s.path === currentFile ? " \u263E" : "", label = s.name ? truncate(s.name, 40) : truncate(s.firstMessage, 40) || "(empty)";
+          return `${i + 1}) ${label}${marker} \xB7 ${formatRelativeTime(s.modified)} \xB7 ${s.messageCount} msgs`;
+        });
+        await ctx.reply([`Sessions for ${process.cwd()}`, ...lines, "Use /sessions <n> or /sessions <id-prefix>"].join(`
+`));
+      }
+      return;
+    }
+    let path, numeric = Number.parseInt(arg, 10), cached = getCachedSessions(ctx.key);
+    if (!Number.isNaN(numeric) && /^\d+$/.test(arg)) {
+      if (!cached || numeric < 1 || numeric > cached.length) {
+        await ctx.reply("Invalid selection \u2014 run /sessions to see the current list.");
+        return;
+      }
+      path = cached[numeric - 1].path;
+    } else {
+      let matches = (cached ?? await SessionManager.list(process.cwd())).filter((s) => s.id.startsWith(arg) || s.path.startsWith(arg));
+      if (matches.length === 0) {
+        await ctx.reply(`No session matches "${arg}".`);
+        return;
+      }
+      if (matches.length > 1) {
+        await ctx.reply(`Multiple sessions match "${arg}" \u2014 use a longer prefix.`);
+        return;
+      }
+      path = matches[0].path;
+    }
+    if (!path) {
+      await ctx.reply("No session selected.");
+      return;
+    }
+    await ctx.bridge.switchSession(ctx.key, path);
+    let switched = await ctx.bridge.getSession(ctx.key), name = switched?.sessionManager?.getSessionName() ?? "unnamed", count = switched?.sessionManager?.getEntries().length ?? 0;
+    await ctx.reply(`Switched to "${name}" (${count} msgs). History continues here.`);
+  }
+}, titleCommand = {
+  name: "title",
+  aliases: ["name"],
+  description: "name the current session",
+  bypassBusy: !0,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, name = ctx.args.trim();
+    if (!name) {
+      let current = session.sessionManager?.getSessionName();
+      await ctx.reply(current ? `Session title: ${current}` : "(unnamed)");
+      return;
+    }
+    session.setSessionName(name);
+    let readBack = session.sessionManager?.getSessionName() ?? name;
+    await ctx.reply(`Session titled "${readBack}".`);
+  }
+}, contextCommand = {
+  name: "context",
+  description: "estimated context window breakdown",
+  bypassBusy: !0,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, model = session.model;
+    if (!model) {
+      await ctx.reply("No model selected.");
+      return;
+    }
+    let contextWindow = model.contextWindow ?? 0;
+    if (contextWindow <= 0) {
+      await ctx.reply("Context window unknown for this model.");
+      return;
+    }
+    let tools = session.getActiveToolNames().map((name) => session.getToolDefinition(name)).filter((d) => d !== void 0), breakdown = computeContextBreakdown({
+      systemPrompt: session.systemPrompt,
+      tools,
+      messages: session.messages,
+      contextWindow
+    }), usage = session.getContextUsage(), tokens = usage?.tokens ?? breakdown.total, percent = usage?.percent ?? (contextWindow > 0 ? tokens / contextWindow * 100 : 0), messageTokens = breakdown.user + breakdown.assistantText + breakdown.thinking + breakdown.toolCalls + breakdown.toolResults + breakdown.summaries, stats = session.getSessionStats();
+    await ctx.reply([
+      `Context: ${tokens.toLocaleString("en-US")} / ${contextWindow.toLocaleString("en-US")} tokens (${Math.round(percent)}%)`,
+      `  system ${breakdown.systemPrompt.toLocaleString("en-US")} \xB7 tools ${breakdown.toolDefinitions.toLocaleString("en-US")} \xB7 messages ${messageTokens.toLocaleString("en-US")}`,
+      `Session: ${stats.totalMessages} messages \xB7 ${stats.userMessages} turns \xB7 model ${model.provider}/${model.id}`
+    ].join(`
+`));
+  }
+}, compactCommand = {
+  name: "compact",
+  description: "summarize and compress session context",
+  bypassBusy: !0,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, instructions = ctx.args.trim() || void 0;
+    try {
+      let result = await session.compact(instructions), before = result.tokensBefore.toLocaleString("en-US"), after = result.estimatedTokensAfter !== void 0 ? `~${result.estimatedTokensAfter.toLocaleString("en-US")}` : "~?";
+      await ctx.reply(`Compacted: ${before} \u2192 ${after} tokens.`);
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Nothing to compact") || message.includes("Already compacted") || message.includes("No model selected")) {
+        await ctx.reply(message);
+        return;
+      }
+      throw error;
+    }
+  }
+}, thinkingCommand = {
+  name: "thinking",
+  aliases: ["effort", "reasoning"],
+  description: "get or set the thinking level",
+  bypassBusy: !1,
+  needsSession: !0,
+  async handler(ctx) {
+    let session = ctx.session, levels = session.getAvailableThinkingLevels();
+    if (!session.supportsThinking()) {
+      await ctx.reply(`Model ${session.model?.provider ?? "none"}/${session.model?.id ?? "none"} doesn't support thinking.`);
+      return;
+    }
+    let arg = ctx.args.trim().toLowerCase();
+    if (!arg) {
+      let current = session.thinkingLevel, items = levels.map((level) => ({
+        label: `${level === current ? "\u2713 " : ""}${level}`,
+        value: level
+      }));
+      (await createPicker(ctx.adapter, ctx.event.source, {
+        kind: "thinking",
+        sessionKey: ctx.key,
+        invokerId: ctx.event.source.userId,
+        items,
+        perPage: levels.length,
+        title: "Pick a thinking level",
+        async resolve(item) {
+          let level = item.value;
+          return session.setThinkingLevel(level), { done: !0, text: `\u263E Thinking \u2192 ${level}` };
+        }
+      }, { replyTo: ctx.event.messageId, threadId: ctx.event.source.threadId })).success || await ctx.reply(`Level: ${current} \u2014 available: ${levels.join(", ")}`);
+      return;
+    }
+    if (!levels.includes(arg)) {
+      await ctx.reply(`Invalid level. Available: ${levels.join(", ")}`);
+      return;
+    }
+    session.setThinkingLevel(arg), await ctx.reply(`Thinking \u2192 ${arg}`);
+  }
+}, CHAT_COMMANDS = [
+  newCommand,
+  undoCommand,
+  redoCommand,
+  stopCommand,
+  statusCommand,
+  whoamiCommand,
+  helpCommand,
+  modelCommand,
+  sessionsCommand,
+  titleCommand,
+  contextCommand,
+  compactCommand,
+  thinkingCommand
+];
+function botCommandSpecs() {
+  return CHAT_COMMANDS.map((c) => ({ name: c.name, description: c.description }));
+}
+function formatHelpText() {
+  let lines = ["lunR gateway commands:"];
+  for (let cmd of CHAT_COMMANDS) {
+    let names = [cmd.name, ...cmd.aliases ?? []].map((a) => `/${a}`).join(" | ");
+    lines.push(`${names} \u2014 ${cmd.description}`);
+  }
+  return lines.push(""), lines.push("Tap to pick: /model, /thinking, /sessions (run without args to see buttons)."), lines.join(`
+`);
+}
+async function runChatCommand(cmd, ctx) {
+  if (!cmd.bypassBusy && ctx.bridge.getStatus(ctx.key).busy)
+    return await ctx.reply("\u23F3 busy \u2014 /stop first or wait"), !0;
+  if (cmd.needsSession) {
+    let session = await ctx.bridge.getSession(ctx.key);
+    if (!session)
+      return await ctx.reply("No session yet \u2014 send a message first."), !0;
+    ctx.session = session;
+  }
+  try {
+    return await cmd.handler(ctx) ?? !0;
+  } catch (err) {
+    let message = err instanceof Error ? err.message : String(err);
+    return await ctx.adapter.send(ctx.event.source.chatId, `\u26A0 ${oneLine(message)}`, {
+      replyTo: ctx.event.messageId,
+      threadId: ctx.event.source.threadId
+    }), !0;
+  }
+}
+async function sendCommandReply(adapter, event, text) {
+  await adapter.send(event.source.chatId, prefixLines(text, "\u263E "), {
+    replyTo: event.messageId,
+    threadId: event.source.threadId
+  });
+}
+
+// packages/coding-agent/dist/gateway/pairing.js
+import { randomInt } from "node:crypto";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var CODE_ALPHABET3 = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", CODE_LENGTH2 = 8, DEFAULT_TTL_MS = 3600 * 1e3, DEFAULT_RATE_LIMIT_MS = 600 * 1e3, DEFAULT_MAX_PENDING = 3, DEFAULT_MAX_FAILS = 5, DEFAULT_LOCKOUT_MS = 3600 * 1e3;
+function normalizeCode(code) {
+  return code.replace(/-/g, "").trim().toUpperCase();
+}
+function generateCode() {
+  let code = "";
+  for (let i = 0; i < CODE_LENGTH2; i++)
+    code += CODE_ALPHABET3[randomInt(0, CODE_ALPHABET3.length)];
+  return code;
+}
+function createPairingStore(options = {}) {
+  let dir = options.dir ?? join2(getAgentDir(), "pairing"), ttlMs = options.ttlMs ?? DEFAULT_TTL_MS, rateLimitMs = options.rateLimitMs ?? DEFAULT_RATE_LIMIT_MS, maxPending = options.maxPending ?? DEFAULT_MAX_PENDING, maxFails = options.maxFails ?? DEFAULT_MAX_FAILS, lockoutMs = options.lockoutMs ?? DEFAULT_LOCKOUT_MS, now = options.now ?? (() => Date.now());
+  function storeFile() {
+    return join2(dir, "store.json");
+  }
+  function read() {
+    let path = storeFile();
+    if (!existsSync3(path))
+      return { pending: [], approved: [] };
+    try {
+      let parsed = JSON.parse(readFileSync2(path, "utf-8"));
+      if (parsed == null || typeof parsed != "object" || Array.isArray(parsed))
+        return { pending: [], approved: [] };
+      let p = parsed, pending2 = Array.isArray(p.pending) ? p.pending : [], approved = Array.isArray(p.approved) ? p.approved : [];
+      return {
+        pending: pending2.filter((c) => typeof c?.code == "string" && typeof c?.platform == "string" && typeof c?.userId == "string"),
+        approved: approved.filter((u) => typeof u?.platform == "string" && typeof u?.userId == "string"),
+        failedAttempts: typeof p.failedAttempts == "object" && p.failedAttempts !== null && !Array.isArray(p.failedAttempts) ? p.failedAttempts : void 0,
+        lockedOutUntil: typeof p.lockedOutUntil == "object" && p.lockedOutUntil !== null && !Array.isArray(p.lockedOutUntil) ? p.lockedOutUntil : void 0
+      };
+    } catch {
+      return { pending: [], approved: [] };
+    }
+  }
+  function write(data) {
+    existsSync3(dir) || mkdirSync2(dir, { recursive: !0 });
+    let path = storeFile(), tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync2(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf-8"), renameSync2(tmp, path);
+    try {
+      chmodSync(path, 384);
+    } catch {
+    }
+  }
+  function isLockedOut(platform) {
+    let until = read().lockedOutUntil?.[platform] ?? 0;
+    return now() < until;
+  }
+  function recordFailedAttempt(platform) {
+    let data = read(), failed = data.failedAttempts ?? {};
+    if (failed[platform] = (failed[platform] ?? 0) + 1, failed[platform] >= maxFails) {
+      let locked = data.lockedOutUntil ?? {};
+      locked[platform] = now() + lockoutMs, failed[platform] = 0, data.lockedOutUntil = locked;
+    }
+    data.failedAttempts = failed, write(data);
+  }
+  function livePending(data) {
+    let cutoff = now() - ttlMs;
+    return data.pending.filter((c) => c.issuedAt >= cutoff);
+  }
+  return {
+    issueCode(platform, userId) {
+      if (isLockedOut(platform))
+        return null;
+      let data = read(), lastIssued = data.pending.filter((c) => c.platform === platform && c.userId === userId).reduce((max, c) => Math.max(max, c.issuedAt), 0);
+      if (lastIssued > 0 && now() - lastIssued < rateLimitMs)
+        return null;
+      let live = livePending(data);
+      if (live.filter((c) => c.platform === platform).length >= maxPending)
+        return null;
+      let entry = {
+        code: generateCode(),
+        platform,
+        userId,
+        issuedAt: now()
+      };
+      return data.pending = [...live, entry], write(data), entry.code;
+    },
+    approve(platform, code) {
+      if (isLockedOut(platform))
+        return null;
+      let data = read(), live = livePending(data), normalized = normalizeCode(code), match = live.find((c) => c.platform === platform && c.code === normalized);
+      return match ? (data.pending = live.filter((c) => c !== match), data.approved = [
+        ...data.approved.filter((u) => !(u.platform === platform && u.userId === match.userId)),
+        { platform, userId: match.userId, approvedAt: now() }
+      ], write(data), match.userId) : (recordFailedAttempt(platform), null);
+    },
+    isPaired(platform, userId) {
+      return read().approved.some((u) => u.platform === platform && u.userId === userId);
+    },
+    listPending() {
+      let data = read();
+      return livePending(data).map((c) => ({
+        code: c.code,
+        platform: c.platform,
+        userId: c.userId,
+        expiresAt: c.issuedAt + ttlMs
+      }));
+    },
+    listApproved() {
+      return read().approved.map((u) => ({ platform: u.platform, userId: u.userId, approvedAt: u.approvedAt }));
+    }
+  };
+}
+
+// packages/coding-agent/dist/gateway/router.js
+import { existsSync as existsSync4 } from "node:fs";
+
+// packages/coding-agent/dist/gateway/session-keys.js
+var SESSION_KEY_PREFIX = "agent:main";
+function sanitize(component) {
+  return component.replace(/[\s:]+/g, "_");
+}
+function buildSessionKey(source, options) {
+  let parts = [source.platform, source.chatType, source.chatId].map(sanitize);
+  return source.threadId ? parts.push(sanitize(source.threadId)) : (source.chatType === "group" || source.chatType === "channel") && options.groupSessionsPerUser && parts.push(sanitize(source.userId)), [SESSION_KEY_PREFIX, ...parts].join(":");
+}
+
+// packages/coding-agent/dist/gateway/stream.js
+var SILENCE_MARKERS = /* @__PURE__ */ new Set(["[SILENT]", "NO_REPLY"]);
+function isMarkerLine(line) {
+  return SILENCE_MARKERS.has(line.trim());
+}
+function applySilenceFilter(text) {
+  let trimmed = text.trim();
+  if (trimmed.length === 0 || isMarkerLine(trimmed))
+    return null;
+  let lines = trimmed.split(`
+`);
+  lines.length > 0 && isMarkerLine(lines[0]) && lines.shift(), lines.length > 0 && isMarkerLine(lines[lines.length - 1]) && lines.pop();
+  let result = lines.join(`
+`).trim();
+  return result.length > 0 ? result : null;
+}
+var StreamConsumer = class {
+  options;
+  buffer = "";
+  flushedLen = 0;
+  messageId = null;
+  lastFlushAt = 0;
+  chain = Promise.resolve();
+  maxPreview;
+  now;
+  constructor(options) {
+    this.options = options, this.maxPreview = options.maxPreview ?? 4096, this.now = options.now ?? (() => Date.now());
+  }
+  /** Accumulate a delta; schedule a flush when both gates (chars, interval) pass. */
+  push(delta) {
+    this.buffer += delta, this.buffer.length - this.flushedLen >= this.options.threshold && this.now() - this.lastFlushAt >= this.options.intervalMs && this.schedule();
+  }
+  /** Force a final flush; resolves with the FULL text (caller splits for delivery). */
+  async finalize() {
+    return this.schedule(!0), await this.chain, this.buffer;
+  }
+  /** The platform message id of the preview, when one was successfully sent. */
+  get sentMessageId() {
+    return this.messageId;
+  }
+  /** True when the preview had to truncate the full text (buffer > maxPreview). */
+  get truncated() {
+    return this.buffer.length > this.maxPreview;
+  }
+  /** The streaming preview: full text truncated to maxPreview-3 + "…". */
+  preview() {
+    if (this.buffer.length <= this.maxPreview)
+      return this.buffer;
+    let cut = this.maxPreview - 3, code = this.buffer.charCodeAt(cut - 1);
+    return code >= 55296 && code <= 56319 && (cut -= 1), `${this.buffer.slice(0, cut)}\u2026`;
+  }
+  schedule(force = !1) {
+    this.chain = this.chain.then(() => this.flush(force)).catch(() => {
+    });
+  }
+  async flush(force) {
+    if (!(this.buffer.length > this.flushedLen) || !force && this.messageId !== null && this.now() - this.lastFlushAt < this.options.intervalMs)
+      return;
+    let text = this.preview();
+    if (this.messageId === null) {
+      if (this.messageId = await this.options.sendInitial(text), this.messageId === null)
+        return;
+    } else
+      await this.options.edit(this.messageId, text);
+    this.flushedLen = this.buffer.length, this.lastFlushAt = this.now();
+  }
+};
+
+// packages/coding-agent/dist/gateway/router.js
+function oneLine2(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function formatPairingCode(code) {
+  return code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code;
+}
+function mentionedBot(event) {
+  return event.metadata?.mentionedBot === !0;
+}
+function createRouter(deps) {
+  let { adapters, cfg: initialCfg, pairing, bridge, reloadConfig } = deps;
+  registerGatewayApprovalHandler();
+  function freshCfg() {
+    if (!reloadConfig)
+      return initialCfg;
+    try {
+      if (existsSync4(gatewayConfigPath()))
+        return loadGatewayConfig();
+    } catch {
+    }
+    return initialCfg;
+  }
+  async function sendError(adapter, event, message) {
+    await adapter.send(event.source.chatId, `\u26A0 ${oneLine2(message)}`, {
+      replyTo: event.messageId,
+      threadId: event.source.threadId
+    });
+  }
+  function isGroupGated(event, cfg) {
+    let { source } = event;
+    if (source.chatType === "dm")
+      return !1;
+    let platformCfg = platformConfigFor(cfg, source.platform);
+    if (!platformCfg)
+      return !0;
+    let freeResponse = platformCfg.freeResponseChats.includes(source.chatId);
+    return !!(platformCfg.allowedChats.length > 0 && !platformCfg.allowedChats.includes(source.chatId) && !freeResponse && !mentionedBot(event) || platformCfg.requireMention && !freeResponse && !mentionedBot(event));
+  }
+  async function isDenied(adapter, event, cfg) {
+    if (isAuthorized(event.source, cfg, pairing))
+      return !1;
+    let { source } = event;
+    if (source.chatType !== "dm" || cfg.unauthorizedDmBehavior !== "pair")
+      return !0;
+    let code = pairing.issueCode(source.platform, source.userId);
+    return code === null || await adapter.send(source.chatId, `Your lunR pairing code: ${formatPairingCode(code)} \u2014 ask the owner to run: lunr gateway pair approve ${source.platform} ${formatPairingCode(code)}`, { replyTo: event.messageId, threadId: source.threadId }), !0;
+  }
+  async function handleSlash(adapter, event, key) {
+    let text = event.text.trim();
+    if (!text.startsWith("/"))
+      return !1;
+    let firstToken = text.split(/\s+/, 1)[0].toLowerCase(), commandWord = firstToken.split("@")[0].slice(1), args = text.slice(firstToken.length).trim(), cmd = CHAT_COMMANDS.find((c) => c.name === commandWord || c.aliases?.includes(commandWord));
+    return cmd ? runChatCommand(cmd, {
+      event,
+      key,
+      adapter,
+      bridge,
+      args,
+      reply: (message) => sendCommandReply(adapter, event, message)
+    }) : event.source.chatType !== "dm";
+  }
+  async function deliver(adapter, event, text, opts) {
+    let filtered = applySilenceFilter(text);
+    if (filtered === null)
+      return;
+    let chunks = splitMessage(filtered, adapter.maxMessageLength), startIndex = 0;
+    if (opts.editMessageId) {
+      if (!opts.previewTruncated) {
+        await adapter.editMessage(event.source.chatId, opts.editMessageId, filtered);
+        return;
+      }
+      await adapter.editMessage(event.source.chatId, opts.editMessageId, chunks[0]), startIndex = 1;
+    }
+    for (let index = startIndex; index < chunks.length; index++) {
+      let result = await adapter.send(event.source.chatId, chunks[index], {
+        replyTo: opts.reply && index === 0 ? event.messageId : void 0,
+        threadId: event.source.threadId
+      });
+      if (!result.success) {
+        console.error(`[gateway] send failed on ${adapter.platform}: ${result.error ?? "unknown error"}`);
+        return;
+      }
+    }
+  }
+  async function runTurn(adapter, event, key, cfg) {
+    let streaming = cfg.streaming.enabled && typeof adapter.editMessage == "function", consumer;
+    streaming && (consumer = new StreamConsumer({
+      sendInitial: async (text) => {
+        let result2 = await adapter.send(event.source.chatId, text, {
+          replyTo: event.messageId,
+          threadId: event.source.threadId
+        });
+        return result2.success ? result2.messageId ?? null : null;
+      },
+      edit: async (messageId, text) => {
+        await adapter.editMessage(event.source.chatId, messageId, text);
+      },
+      intervalMs: cfg.streaming.editIntervalMs,
+      threshold: cfg.streaming.bufferThreshold,
+      maxPreview: adapter.maxMessageLength
+    }));
+    let callbacks = {
+      onDelta: consumer ? (delta) => consumer.push(delta) : void 0,
+      onFollowUpResult: (text) => {
+        deliver(adapter, event, text, { reply: !1 });
+      },
+      onError: (message) => {
+        sendError(adapter, event, message);
+      }
+    }, result = await runWithApprovalContext({ key, adapter, source: event.source }, () => bridge.runTurn(key, event, callbacks));
+    result !== QUEUED && (consumer && await consumer.finalize(), await deliver(adapter, event, result, {
+      reply: !consumer,
+      editMessageId: consumer?.sentMessageId ?? void 0,
+      previewTruncated: consumer?.truncated ?? !1
+    }));
+  }
+  return {
+    async handleEvent(event) {
+      let adapter = adapters.get(event.source.platform);
+      if (!adapter)
+        return;
+      let cfg = freshCfg();
+      try {
+        if (isGroupGated(event, cfg) || await isDenied(adapter, event, cfg))
+          return;
+        let key = buildSessionKey(event.source, { groupSessionsPerUser: cfg.groupSessionsPerUser });
+        if (await handleSlash(adapter, event, key))
+          return;
+        await adapter.sendTyping(event.source.chatId, event.source.threadId).catch(() => {
+        }), await runTurn(adapter, event, key, cfg);
+      } catch (err) {
+        await sendError(adapter, event, err instanceof Error ? err.message : String(err)).catch(() => {
+        });
+      }
+    }
+  };
+}
+
+// packages/coding-agent/dist/gateway/index.js
+var ADAPTER_FACTORIES = {
+  telegram: (cfg) => new TelegramAdapter(cfg),
+  discord: (cfg) => new DiscordAdapter(cfg)
+}, KNOWN_PLATFORMS = ["telegram", "discord"], SETUP_INSTRUCTIONS = {
+  telegram: [
+    "Telegram: talk to @BotFather \u2192 /newbot \u2192 copy the token into",
+    "  <agentDir>/gateway.json (telegram.token) or export LUNR_TELEGRAM_BOT_TOKEN,",
+    "  then set telegram.enabled = true."
+  ],
+  discord: [
+    "Discord: discord.com/developers \u2192 New Application \u2192 Bot \u2192 copy the token into",
+    "  <agentDir>/gateway.json (discord.token) or export LUNR_DISCORD_BOT_TOKEN,",
+    "  enable the MESSAGE CONTENT intent, then set discord.enabled = true."
+  ]
+};
+function printSetupInstructions(enabledButUnrunnable) {
+  console.log("lunR gateway: no runnable platforms configured.");
+  for (let platform of enabledButUnrunnable)
+    console.log(`  (platform "${platform}" is enabled but has no registered adapter or resolvable token)`);
+  for (let platform of KNOWN_PLATFORMS)
+    for (let line of SETUP_INSTRUCTIONS[platform])
+      console.log(line);
+}
+async function runPairApprove(platform, code) {
+  if (!code)
+    return console.error("Usage: lunr gateway pair approve <platform> <code>"), 1;
+  let userId = createPairingStore().approve(platform, code);
+  if (userId === null)
+    return console.error(`Pairing failed: no valid pending code "${code}" for ${platform} (wrong, expired, or locked out).`), 1;
+  try {
+    addAllowedUser(platform, userId);
+  } catch (err) {
+    return console.error(`Paired ${platform} user ${userId}, but could not persist allowedUsers: ${err}`), 1;
+  }
+  return console.log(`Approved ${platform} user ${userId} (added to ${platform}.allowedUsers in gateway.json).`), 0;
+}
+function runPairList() {
+  let pairing = createPairingStore(), pending2 = pairing.listPending(), approved = pairing.listApproved();
+  if (console.log("Pending pairing codes:"), pending2.length === 0)
+    console.log("  (none)");
+  else
+    for (let p of pending2)
+      console.log(`  ${p.platform} ${p.code}  user=${p.userId}  expires ${new Date(p.expiresAt).toISOString()}`);
+  if (console.log("Paired users:"), approved.length === 0)
+    console.log("  (none)");
+  else
+    for (let u of approved)
+      console.log(`  ${u.platform} ${u.userId}  approved ${new Date(u.approvedAt).toISOString()}`);
+  return 0;
+}
+function runStatus() {
+  let cfg = loadGatewayConfig();
+  console.log(`chat-platforms: ${isFeatureEnabled("chat-platforms") ? "enabled" : "disabled"} (install-features.json)`), console.log("lunR gateway status:");
+  for (let platform of KNOWN_PLATFORMS) {
+    let platformCfg = platformConfigFor(cfg, platform);
+    if (!platformCfg)
+      continue;
+    let token = resolvePlatformToken(platform, platformCfg), adapter = ADAPTER_FACTORIES[platform] === void 0 ? "no adapter" : "adapter registered";
+    console.log(`  ${platform}: ${platformCfg.enabled ? "enabled" : "disabled"} \xB7 token ${token ? "resolved" : "missing"} \xB7 ${adapter}`);
+  }
+  let sessions = listSessions();
+  return console.log(`  sessions: ${Object.keys(sessions).length} stored`), 0;
+}
+async function runDaemon() {
+  if (!isFeatureEnabled("chat-platforms"))
+    return console.error("lunR gateway: chat platforms are not enabled."), console.error("Enable with: lunr features enable chat-platforms"), 1;
+  let cfg = loadGatewayConfig(), adapters = /* @__PURE__ */ new Map(), skipped = [];
+  for (let platform of KNOWN_PLATFORMS) {
+    let platformCfg = platformConfigFor(cfg, platform);
+    if (!platformCfg?.enabled)
+      continue;
+    let factory = ADAPTER_FACTORIES[platform];
+    if (factory === void 0) {
+      skipped.push(platform);
+      continue;
+    }
+    let token = resolvePlatformToken(platform, platformCfg);
+    if (!token) {
+      skipped.push(platform);
+      continue;
+    }
+    adapters.set(platform, factory({ ...platformCfg, token }));
+  }
+  if (adapters.size === 0)
+    return printSetupInstructions(skipped), 1;
+  let pairing = createPairingStore(), bridge = new AgentBridge(), router = createRouter({ adapters, cfg, pairing, bridge, reloadConfig: !0 }), connected = [];
+  startButtonSweeper();
+  for (let [platform, adapter] of adapters)
+    try {
+      if (!await adapter.connect()) {
+        console.error(`[gateway] ${platform}: connect() reported failure; skipping`);
+        continue;
+      }
+      adapter.onMessage((event) => {
+        router.handleEvent(event);
+      }), adapter.onCallback(async (event) => {
+        await handleApprovalCallback(event, adapter) || handleCallback(event, { adapters, cfg, pairing, bridge, adapter });
+      });
+      try {
+        await adapter.registerCommands?.(botCommandSpecs());
+      } catch (err) {
+        console.error(`[gateway] ${platform}: command menu registration failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      connected.push(adapter), console.log(`lunR gateway: ${platform} connected`);
+    } catch (err) {
+      console.error(`[gateway] ${platform}: connect failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  if (connected.length === 0)
+    return console.error("lunR gateway: every configured platform failed to connect."), stopButtonSweeper(), 1;
+  let cron = startGatewayCron({ adapters, cfg });
+  console.log(`lunR gateway: cron scheduler started (${cron.intervalMs / 1e3}s interval)`);
+  let shutdown = () => {
+    cron.stop(), stopButtonSweeper(), Promise.all(connected.map((adapter) => adapter.disconnect().catch(() => {
+    }))).finally(() => {
+      process.exit(0);
+    });
+  };
+  return process.on("SIGINT", shutdown), process.on("SIGTERM", shutdown), await new Promise(() => {
+  }), 0;
+}
+async function runGateway(args) {
+  let [sub, ...rest] = args;
+  if (sub === "pair") {
+    let [action, platform, code] = rest;
+    return action === "approve" && platform ? runPairApprove(platform, code) : action === "list" ? runPairList() : (console.error("Usage: lunr gateway pair approve <platform> <code> | lunr gateway pair list"), 1);
+  }
+  return sub === "status" ? runStatus() : sub === void 0 ? runDaemon() : (console.error(`Unknown gateway sub-command "${sub}". Expected: pair approve | pair list | status`), 1);
+}
+export {
+  ADAPTER_FACTORIES,
+  runGateway
+};