negotium 0.1.12 → 0.1.13

package/dist/chunk-03kv7mvj.js

@@ -1,2152 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-import {
-  defineNegotiumAdapter
-} from "./chunk-sa874j5c.js";
-import {
-  startDefaultNode
-} from "./chunk-gxmny6tq.js";
-import"./chunk-edb07sjp.js";
-import {
-  TopicValidationError,
-  executeVaultCommand,
-  isTranscriptionConfigured,
-  isVaultCommandLine,
-  onShutdown,
-  renderTurnFooter,
-  submitUserMessage,
-  topicService,
-  transcribeAudio,
-  waitForRequiredRuntimeProcessLease
-} from "./chunk-h7bj5zwb.js";
-import"./chunk-tcs9qjps.js";
-import {
-  TopicArchiveRequiredError
-} from "./chunk-7k19pcg8.js";
-import"./chunk-8dy7e2a9.js";
-import"./chunk-9hjeemfz.js";
-import"./chunk-1k7t7bnx.js";
-import {
-  composeAttachmentPrompt,
-  ingestAttachment,
-  startAiTurn
-} from "./chunk-xhm1rfpt.js";
-import {
-  TopicTitleConflictError
-} from "./chunk-mnwaext5.js";
-import"./chunk-xpcps28p.js";
-import {
-  ensurePersonalGeneral,
-  runtimeBus
-} from "./chunk-fbtb3v0s.js";
-import {
-  getTopic,
-  getTopicByNameForUser,
-  isTopicVisible,
-  listTopics
-} from "./chunk-ejcm6zx8.js";
-import"./chunk-hp4g7wx7.js";
-import"./chunk-s74rdyqe.js";
-import"./chunk-k778y16p.js";
-import"./chunk-xag86ng3.js";
-import"./chunk-wx83ep8e.js";
-import {
-  errMsg,
-  extractFileTagPaths,
-  isSensitivePath,
-  stripFileTags
-} from "./chunk-00q25k7p.js";
-import"./chunk-gaknyw04.js";
-import"./chunk-mh5mexsf.js";
-import {
-  DATA_DIR,
-  isAgentKind
-} from "./chunk-ezs352qs.js";
-import"./chunk-j0kjscb7.js";
-import"./chunk-82qhv1mq.js";
-import {
-  logger
-} from "./chunk-ffefbd3r.js";
-import"./chunk-81tbfbmt.js";
-import"./chunk-sffqdkvq.js";
-import"./chunk-f5xgprg1.js";
-import"./chunk-hwy3n31w.js";
-
-// ../../adapters/telegram/src/cli.ts
-import TelegramBot from "node-telegram-bot-api";
-
-// ../../adapters/telegram/src/adapter.ts
-import { existsSync } from "fs";
-
-// ../../packages/adapter-sdk/src/outbox.ts
-function exponentialOutboxBackoff(attempts, policy) {
-  return Math.min(policy.baseDelayMs * 2 ** Math.max(0, attempts - 1), policy.maxDelayMs);
-}
-function createDurableOutboxWorker(options) {
-  const now = options.now ?? Date.now;
-  const schedule = options.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
-  const cancel = options.cancel ?? ((timer2) => clearTimeout(timer2));
-  let timer;
-  let started = false;
-  let stopped = false;
-  let flushing = null;
-  let pendingAcknowledgement = null;
-  const reportError = (error) => {
-    try {
-      options.onError?.(error);
-    } catch {}
-  };
-  const scheduleFlush = () => {
-    if (!started || stopped || timer !== undefined)
-      return;
-    timer = schedule(() => {
-      timer = undefined;
-      flush();
-    }, options.policy.pollMs);
-  };
-  const performFlush = async () => {
-    let entries = [];
-    const released = new Set;
-    const release = (entry) => {
-      if (released.has(entry))
-        return;
-      released.add(entry);
-      options.onEntryEnd?.(entry);
-    };
-    try {
-      if (pendingAcknowledgement) {
-        const pending = pendingAcknowledgement;
-        try {
-          await options.store.acknowledge(pending.entry, pending.delivery);
-          pendingAcknowledgement = null;
-        } catch (error) {
-          reportError(error);
-          return;
-        }
-      }
-      entries = await options.store.due(now());
-      for (const entry of entries)
-        options.onEntryStart?.(entry);
-      for (const entry of entries) {
-        if (stopped)
-          return;
-        if (await options.shouldDiscard?.(entry)) {
-          await options.store.discard(entry);
-          release(entry);
-          continue;
-        }
-        let delivery;
-        try {
-          delivery = await options.deliver(entry);
-        } catch (error) {
-          if (stopped)
-            return;
-          const failure = options.classifyError(error);
-          const attempts = entry.attempts + 1;
-          const retry = { attempts, error: failure.message };
-          if (attempts >= options.policy.maxAttempts) {
-            await options.store.deadLetter(entry, retry);
-            options.onDeadLetter?.(entry, retry);
-          } else {
-            const delay = failure.retryAfterMs ?? exponentialOutboxBackoff(attempts, options.policy);
-            await options.store.retry(entry, {
-              ...retry,
-              nextTryAt: now() + Math.max(0, delay)
-            });
-          }
-          release(entry);
-          continue;
-        }
-        if (stopped)
-          return;
-        pendingAcknowledgement = { entry, delivery };
-        try {
-          await options.store.acknowledge(entry, delivery);
-          pendingAcknowledgement = null;
-        } catch (error) {
-          reportError(error);
-          release(entry);
-          return;
-        }
-        release(entry);
-      }
-    } catch (error) {
-      if (!stopped)
-        reportError(error);
-    } finally {
-      for (const entry of entries)
-        release(entry);
-      if (!stopped && started) {
-        let hasPending = pendingAcknowledgement !== null;
-        if (!hasPending) {
-          try {
-            hasPending = await options.store.hasPending();
-          } catch (error) {
-            reportError(error);
-            hasPending = true;
-          }
-        }
-        if (hasPending)
-          scheduleFlush();
-      }
-    }
-  };
-  const flush = () => {
-    if (stopped)
-      return Promise.resolve();
-    if (flushing)
-      return flushing;
-    flushing = performFlush().finally(() => {
-      flushing = null;
-    });
-    return flushing;
-  };
-  return {
-    start() {
-      if (started || stopped)
-        return;
-      started = true;
-      scheduleFlush();
-    },
-    wake() {
-      scheduleFlush();
-    },
-    flush,
-    stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      if (timer !== undefined)
-        cancel(timer);
-      timer = undefined;
-    }
-  };
-}
-
-// ../../adapters/telegram/src/mapping-store.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync } from "fs";
-import { dirname, join } from "path";
-var NO_THREAD = 0;
-function outboxRowToEntry(row) {
-  return {
-    id: row.id,
-    chatId: row.chat_id,
-    ...row.thread_id !== NO_THREAD ? { threadId: row.thread_id } : {},
-    ...row.runtime_message_id !== null ? { runtimeMessageId: row.runtime_message_id } : {},
-    ...row.footer !== null ? { footer: row.footer } : {},
-    html: row.html,
-    plain: row.plain,
-    attempts: row.attempts,
-    nextTryAt: row.next_try_at,
-    dead: row.dead === 1,
-    ...row.last_error !== null ? { lastError: row.last_error } : {}
-  };
-}
-function migrateLegacySchema(db) {
-  const existing = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'mappings'").get();
-  if (!existing?.sql?.includes("UNIQUE (topic_id)"))
-    return;
-  db.run("DROP TABLE IF EXISTS mappings_legacy");
-  db.run("ALTER TABLE mappings RENAME TO mappings_legacy");
-  createTables(db);
-  db.run(`INSERT OR IGNORE INTO mappings (chat_id, thread_id, topic_id)
-     SELECT chat_id, thread_id, topic_id FROM mappings_legacy`);
-  db.run("DROP TABLE mappings_legacy");
-}
-function createTables(db) {
-  db.run(`CREATE TABLE IF NOT EXISTS mappings (
-      chat_id INTEGER NOT NULL,
-      thread_id INTEGER NOT NULL DEFAULT ${NO_THREAD},
-      topic_id TEXT NOT NULL,
-      UNIQUE (chat_id, thread_id)
-    )`);
-  db.run(`CREATE TABLE IF NOT EXISTS tombstones (
-      topic_id TEXT PRIMARY KEY,
-      title TEXT NOT NULL
-    )`);
-  db.run(`CREATE TABLE IF NOT EXISTS outbox (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      chat_id INTEGER NOT NULL,
-      thread_id INTEGER NOT NULL DEFAULT ${NO_THREAD},
-      runtime_message_id TEXT,
-      footer TEXT,
-      html TEXT NOT NULL,
-      plain TEXT NOT NULL,
-      attempts INTEGER NOT NULL DEFAULT 0,
-      next_try_at INTEGER NOT NULL,
-      dead INTEGER NOT NULL DEFAULT 0,
-      last_error TEXT
-    )`);
-  db.run(`CREATE TABLE IF NOT EXISTS settings (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    )`);
-}
-function migrateOutboxSchema(db) {
-  try {
-    db.run("ALTER TABLE outbox ADD COLUMN runtime_message_id TEXT");
-  } catch {}
-  try {
-    db.run("ALTER TABLE outbox ADD COLUMN footer TEXT");
-  } catch {}
-  db.run("CREATE INDEX IF NOT EXISTS idx_telegram_outbox_runtime_message ON outbox(runtime_message_id)");
-}
-function openMappingStore(path) {
-  const dbPath = path ?? join(DATA_DIR, "adapter-telegram.db");
-  if (dbPath !== ":memory:")
-    mkdirSync(dirname(dbPath), { recursive: true });
-  const db = new Database(dbPath);
-  migrateLegacySchema(db);
-  createTables(db);
-  migrateOutboxSchema(db);
-  return {
-    load() {
-      const rows = db.query("SELECT chat_id, thread_id, topic_id FROM mappings").all();
-      return rows.map((row) => ({
-        chatId: row.chat_id,
-        topicId: row.topic_id,
-        ...row.thread_id !== NO_THREAD ? { threadId: row.thread_id } : {}
-      }));
-    },
-    save(mapping) {
-      db.run(`INSERT OR REPLACE INTO mappings (chat_id, thread_id, topic_id)
-         VALUES (?, ?, ?)`, [mapping.chatId, mapping.threadId ?? NO_THREAD, mapping.topicId]);
-    },
-    deleteByChat(chatId, threadId) {
-      db.run("DELETE FROM mappings WHERE chat_id = ? AND thread_id = ?", [
-        chatId,
-        threadId ?? NO_THREAD
-      ]);
-    },
-    deleteByTopic(topicId) {
-      db.run("DELETE FROM mappings WHERE topic_id = ?", [topicId]);
-    },
-    loadTombstones() {
-      const rows = db.query("SELECT topic_id, title FROM tombstones").all();
-      return rows.map((row) => ({ topicId: row.topic_id, title: row.title }));
-    },
-    saveTombstone(topicId, title) {
-      db.run("INSERT OR REPLACE INTO tombstones (topic_id, title) VALUES (?, ?)", [topicId, title]);
-    },
-    deleteTombstone(topicId) {
-      db.run("DELETE FROM tombstones WHERE topic_id = ?", [topicId]);
-    },
-    clearTombstones() {
-      db.run("DELETE FROM tombstones");
-    },
-    loadForumChatId() {
-      const row = db.query("SELECT value FROM settings WHERE key = 'forum_chat_id'").get();
-      if (!row)
-        return;
-      const value = Number.parseInt(row.value, 10);
-      return Number.isSafeInteger(value) ? value : undefined;
-    },
-    saveForumChatId(chatId) {
-      db.run("INSERT OR REPLACE INTO settings (key, value) VALUES ('forum_chat_id', ?)", [
-        String(chatId)
-      ]);
-    },
-    clearForumChatId() {
-      db.run("DELETE FROM settings WHERE key = 'forum_chat_id'");
-    },
-    outboxEnqueue(entry) {
-      db.run(`INSERT INTO outbox
-           (chat_id, thread_id, runtime_message_id, footer, html, plain, attempts, next_try_at, last_error)
-         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)`, [
-        entry.chatId,
-        entry.threadId ?? NO_THREAD,
-        entry.runtimeMessageId ?? null,
-        entry.footer ?? null,
-        entry.html,
-        entry.plain,
-        entry.nextTryAt,
-        entry.lastError ?? null
-      ]);
-    },
-    outboxDue(now) {
-      const rows = db.query("SELECT * FROM outbox WHERE dead = 0 AND next_try_at <= ? ORDER BY id ASC").all(now);
-      return rows.map(outboxRowToEntry);
-    },
-    outboxReschedule(id, attempts, nextTryAt, lastError) {
-      db.run("UPDATE outbox SET attempts = ?, next_try_at = ?, last_error = ? WHERE id = ?", [
-        attempts,
-        nextTryAt,
-        lastError,
-        id
-      ]);
-    },
-    outboxMarkDead(id, attempts, lastError) {
-      db.run("UPDATE outbox SET dead = 1, attempts = ?, last_error = ? WHERE id = ?", [
-        attempts,
-        lastError,
-        id
-      ]);
-    },
-    outboxDelete(id) {
-      db.run("DELETE FROM outbox WHERE id = ?", [id]);
-    },
-    outboxDeleteByChat(chatId) {
-      db.run("DELETE FROM outbox WHERE chat_id = ?", [chatId]);
-    },
-    outboxDeleteByRuntimeMessageId(runtimeMessageId) {
-      db.run("DELETE FROM outbox WHERE runtime_message_id = ?", [runtimeMessageId]);
-    },
-    outboxAll() {
-      const rows = db.query("SELECT * FROM outbox ORDER BY id ASC").all();
-      return rows.map(outboxRowToEntry);
-    },
-    close() {
-      db.close();
-    }
-  };
-}
-
-// ../../adapters/telegram/src/render.ts
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function markdownToTelegramHtml(md) {
-  const codeBlocks = [];
-  let text = md.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, lang, code) => {
-    const escaped = escapeHtml(code.replace(/\n$/, ""));
-    const tag = lang ? `<pre><code class="language-${escapeHtml(lang)}">${escaped}</code></pre>` : `<pre>${escaped}</pre>`;
-    codeBlocks.push(tag);
-    return `\x00CODEBLOCK${codeBlocks.length - 1}\x00`;
-  });
-  const inlineCodes = [];
-  text = text.replace(/`([^`\n]+)`/g, (_match, code) => {
-    inlineCodes.push(`<code>${escapeHtml(code)}</code>`);
-    return `\x00INLINE${inlineCodes.length - 1}\x00`;
-  });
-  text = escapeHtml(text);
-  text = text.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
-  text = text.replace(/\*\*\*(.+?)\*\*\*/g, "<b><i>$1</i></b>");
-  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
-  text = text.replace(/(?<!\w)\*([^\s*](?:.*?[^\s*])?)\*(?!\w)/g, "<i>$1</i>");
-  text = text.replace(/~~(.+?)~~/g, "<s>$1</s>");
-  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-  text = text.replace(/(?:^&gt; .+\n?)+/gm, (block) => {
-    const content = block.replace(/^&gt; /gm, "").trim();
-    return `<blockquote>${content}</blockquote>`;
-  });
-  text = text.replace(/\x00INLINE(\d+)\x00/g, (_m, i) => inlineCodes[Number(i)]);
-  text = text.replace(/\x00CODEBLOCK(\d+)\x00/g, (_m, i) => codeBlocks[Number(i)]);
-  return text;
-}
-function splitMessage(text, maxLen = 4096) {
-  if (text.length <= maxLen)
-    return [text];
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    if (remaining.length <= maxLen) {
-      chunks.push(remaining);
-      break;
-    }
-    let splitAt = remaining.lastIndexOf(`
-`, maxLen);
-    const atNewline = splitAt >= maxLen / 2;
-    if (!atNewline)
-      splitAt = maxLen;
-    chunks.push(remaining.slice(0, splitAt));
-    remaining = remaining.slice(atNewline ? splitAt + 1 : splitAt);
-  }
-  return chunks;
-}
-function renderOutbound(text, maxLen = 4096) {
-  return splitMessage(text, maxLen).map((plain) => ({
-    plain,
-    html: markdownToTelegramHtml(plain)
-  }));
-}
-
-// ../../adapters/telegram/src/adapter.ts
-var FORUM_TOPIC_NAME_MAX = 128;
-var MAX_PARENT_HOPS = 5;
-var DEFAULT_SEND_TIMEOUT_MS = 60000;
-var PHOTO_EXTS = new Set(["png", "jpg", "jpeg", "gif", "webp"]);
-function onboardingGuide(botUsername) {
-  const identity = botUsername ? `
-Bot username: @${botUsername.replace(/^@/, "")}
-` : `
-`;
-  return "Welcome to Negotium. This DM is your General manager: chat naturally here to create, " + `delegate work to, stop, or delete topics.
-
-` + `Connect a Telegram workspace:
-` + `1. Create a supergroup and enable Topics.
-` + `2. Add this bot to the group.
-` + `3. Promote the bot to administrator and enable "Manage Topics".
-` + `4. The group connects automatically; no /connect command is needed.
-` + identity + "After connection, use the group's General topic as the manager and each forum topic as " + "an independent agent conversation.";
-}
-function isChatAdmin(member) {
-  return member.status === "administrator" || member.status === "creator";
-}
-function canManageTopics(member) {
-  return member.status === "creator" || member.status === "administrator" && member.can_manage_topics === true;
-}
-function isManageTopicsPermissionError(info) {
-  return /not enough rights|need administrator rights|chat_admin_required|manage topics/i.test(info.description);
-}
-function defaultTopicTitle(chatId, threadId) {
-  return threadId === undefined ? `tg-${chatId}` : `tg-${chatId}-${threadId}`;
-}
-function extractCommandArg(text) {
-  return text.split(/\s+/).slice(1).join(" ").trim();
-}
-function telegramErrorInfo(err) {
-  const e = err;
-  const status = typeof e?.response?.statusCode === "number" ? e.response.statusCode : undefined;
-  const description = [e?.response?.body?.description, e?.message].filter((s) => typeof s === "string").join(" ");
-  const retryRaw = e?.response?.body?.parameters?.retry_after;
-  return {
-    status,
-    ...typeof e?.code === "string" ? { code: e.code } : {},
-    description,
-    ...typeof retryRaw === "number" ? { retryAfterSec: retryRaw } : {}
-  };
-}
-function isHtmlParseError(info) {
-  if (info.status !== undefined && info.status !== 400)
-    return false;
-  return /can't parse entities/i.test(info.description);
-}
-function isForumTopicAlreadyGone(info) {
-  if (info.status !== undefined && info.status !== 400)
-    return false;
-  return /(?:message thread|forum topic).*not found|topic_id_invalid/i.test(info.description);
-}
-var RETRYABLE_CODES = new Set(["EFATAL", "ETIMEDOUT", "ECONNRESET", "ECONNREFUSED", "EAI_AGAIN"]);
-function isRetryableSendError(info) {
-  if (info.status === 429)
-    return true;
-  if (info.status !== undefined && info.status >= 500 && info.status < 600)
-    return true;
-  return info.code !== undefined && RETRYABLE_CODES.has(info.code);
-}
-function startTelegramAdapter(opts) {
-  const { client, forumChatId } = opts;
-  const userId = opts.userId ?? "local";
-  const allowed = new Set((opts.allowedUsers ?? []).map((s) => s.trim()).filter(Boolean));
-  const configuredVaultOwner = opts.vaultOwnerTelegramUserId?.trim();
-  if (configuredVaultOwner && !allowed.has(configuredVaultOwner)) {
-    throw new Error("vaultOwnerTelegramUserId must appear in allowedUsers");
-  }
-  const vaultOwnerTelegramUserId = configuredVaultOwner || (allowed.size === 1 ? allowed.values().next().value : undefined);
-  const isAllowed = (telegramUserId) => allowed.size === 0 || allowed.has(String(telegramUserId));
-  const isVaultOwner = (telegramUserId) => vaultOwnerTelegramUserId !== undefined && String(telegramUserId) === vaultOwnerTelegramUserId;
-  const titleFor = opts.topicTitleFor ?? defaultTopicTitle;
-  const sendTimeoutMs = opts.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
-  const typingHeartbeatMs = Math.max(250, opts.typingHeartbeatMs ?? 4000);
-  const footerEnabled = opts.footer === true;
-  const dispatchTurn = opts.startTurn ?? startAiTurn;
-  const store = openMappingStore(opts.mappingDbPath);
-  const restoredForumChatId = store.loadForumChatId();
-  const initialForumChatId = forumChatId ?? restoredForumChatId;
-  let forumChat = initialForumChatId ?? 0;
-  let forumMode = initialForumChatId !== undefined && typeof client.createForumTopic === "function";
-  let forumManageTopicsAvailable = forumMode && forumChatId !== undefined;
-  if (forumChatId !== undefined)
-    store.saveForumChatId(forumChatId);
-  if (initialForumChatId !== undefined && !forumMode) {
-    logger.warn({ forumChatId: initialForumChatId }, "telegram adapter: forumChatId set but client lacks createForumTopic \u2014 forum mode disabled");
-  }
-  const personalGeneral = ensurePersonalGeneral(userId);
-  const byKey = new Map;
-  const byTopic = new Map;
-  const targetByQueryId = new Map;
-  const typingHeartbeatByQueryId = new Map;
-  const toolStatusByQueryId = new Map;
-  const runtimeMessages = new Map;
-  const deliveredByRuntimeMessageId = new Map;
-  const deletedRuntimeMessageIds = new Set;
-  const activeRuntimeDeliveries = new Map;
-  const completedRuntimeMessageCleanup = new Set;
-  const forumCleanupInFlight = new Set;
-  const ownerDmChatIds = new Set([...allowed].map((value) => Number.parseInt(value, 10)).filter((value) => Number.isSafeInteger(value) && value > 0));
-  let stopped = false;
-  let botIdentity;
-  let botIdentityPromise;
-  function beginRuntimeDelivery(messageId) {
-    if (!messageId)
-      return;
-    activeRuntimeDeliveries.set(messageId, (activeRuntimeDeliveries.get(messageId) ?? 0) + 1);
-  }
-  function endRuntimeDelivery(messageId) {
-    if (!messageId)
-      return;
-    const remaining = (activeRuntimeDeliveries.get(messageId) ?? 1) - 1;
-    if (remaining > 0)
-      activeRuntimeDeliveries.set(messageId, remaining);
-    else {
-      activeRuntimeDeliveries.delete(messageId);
-      if (completedRuntimeMessageCleanup.delete(messageId)) {
-        deletedRuntimeMessageIds.delete(messageId);
-      }
-    }
-  }
-  function typingTargets(topicId, queryId) {
-    const target = queryId ? targetByQueryId.get(queryId) : undefined;
-    return target ? [target] : [...byTopic.get(topicId) ?? []];
-  }
-  function sendTyping(topicId, queryId) {
-    if (typeof client.sendChatAction !== "function")
-      return;
-    for (const mapping of typingTargets(topicId, queryId)) {
-      client.sendChatAction(mapping.chatId, "typing", threadOpts(mapping.threadId)).catch(() => {});
-    }
-  }
-  function stopTypingHeartbeat(queryId) {
-    const timer = typingHeartbeatByQueryId.get(queryId);
-    if (!timer)
-      return;
-    clearInterval(timer);
-    typingHeartbeatByQueryId.delete(queryId);
-  }
-  function startTypingHeartbeat(topicId, queryId) {
-    stopTypingHeartbeat(queryId);
-    sendTyping(topicId, queryId);
-    const timer = setInterval(() => {
-      if (stopped) {
-        stopTypingHeartbeat(queryId);
-        return;
-      }
-      sendTyping(topicId, queryId);
-    }, typingHeartbeatMs);
-    timer.unref?.();
-    typingHeartbeatByQueryId.set(queryId, timer);
-  }
-  function resolveBotIdentity() {
-    if (botIdentity)
-      return Promise.resolve(botIdentity);
-    if (typeof client.getMe !== "function")
-      return Promise.resolve(undefined);
-    if (botIdentityPromise)
-      return botIdentityPromise;
-    botIdentityPromise = (async () => {
-      let attempt = 0;
-      while (!stopped) {
-        try {
-          botIdentity = await client.getMe();
-          return botIdentity;
-        } catch (err) {
-          attempt += 1;
-          const waitMs = Math.min(5000, 250 * 2 ** Math.min(attempt - 1, 5));
-          logger.warn({ err, attempt, waitMs }, "telegram adapter: getMe failed while resolving onboarding identity; retrying");
-          await new Promise((resolve) => setTimeout(resolve, waitMs));
-        }
-      }
-      return;
-    })().finally(() => {
-      botIdentityPromise = undefined;
-    });
-    return botIdentityPromise;
-  }
-  resolveBotIdentity();
-  const mappingKey = (chatId, threadId) => threadId === undefined ? String(chatId) : `${chatId}:${threadId}`;
-  const threadOpts = (threadId) => threadId === undefined ? {} : { message_thread_id: threadId };
-  function showToolStatus(topicId, queryId, label) {
-    const deleteMessage = client.deleteMessage?.bind(client);
-    if (!deleteMessage)
-      return;
-    let state = toolStatusByQueryId.get(queryId);
-    if (!state) {
-      state = { closed: false, refs: new Map, queue: Promise.resolve() };
-      toolStatusByQueryId.set(queryId, state);
-    }
-    const current = state;
-    const text = `\uD83D\uDD27 ${label}`.slice(0, 512);
-    current.queue = current.queue.then(async () => {
-      if (stopped || current.closed)
-        return;
-      for (const mapping of typingTargets(topicId, queryId)) {
-        if (stopped || current.closed)
-          return;
-        const key = mappingKey(mapping.chatId, mapping.threadId);
-        const existing = current.refs.get(key);
-        if (existing && typeof client.editMessageText === "function") {
-          try {
-            await client.editMessageText(text, {
-              chat_id: mapping.chatId,
-              message_id: existing.messageId
-            });
-            continue;
-          } catch (err) {
-            if (/message is not modified/i.test(telegramErrorInfo(err).description))
-              continue;
-            current.refs.delete(key);
-            await deleteMessage(mapping.chatId, existing.messageId).catch(() => {});
-          }
-        } else if (existing) {
-          current.refs.delete(key);
-          await deleteMessage(mapping.chatId, existing.messageId).catch(() => {});
-        }
-        try {
-          const sent = await client.sendMessage(mapping.chatId, text, threadOpts(mapping.threadId));
-          const messageId = sentMessageId(sent);
-          if (messageId === null)
-            continue;
-          if (stopped || current.closed) {
-            await deleteMessage(mapping.chatId, messageId).catch(() => {});
-          } else {
-            current.refs.set(key, { mapping, messageId });
-          }
-        } catch (err) {
-          logger.warn({ err, topicId, queryId, chatId: mapping.chatId }, "telegram adapter: tool status send failed");
-        }
-      }
-      if (!current.closed)
-        sendTyping(topicId, queryId);
-    });
-  }
-  function closeToolStatus(queryId) {
-    const state = toolStatusByQueryId.get(queryId);
-    if (!state)
-      return;
-    state.closed = true;
-    state.queue = state.queue.then(async () => {
-      if (typeof client.deleteMessage === "function") {
-        for (const { mapping, messageId } of state.refs.values()) {
-          await client.deleteMessage(mapping.chatId, messageId).catch(() => {});
-        }
-      }
-      state.refs.clear();
-      if (toolStatusByQueryId.get(queryId) === state)
-        toolStatusByQueryId.delete(queryId);
-    });
-  }
-  function detachFromTopic(mapping) {
-    const set = byTopic.get(mapping.topicId);
-    if (!set)
-      return;
-    set.delete(mapping);
-    if (set.size === 0)
-      byTopic.delete(mapping.topicId);
-  }
-  function bindMapping(chatId, threadId, topicId, { persist = true } = {}) {
-    const key = mappingKey(chatId, threadId);
-    const prev = byKey.get(key);
-    if (prev) {
-      if (prev.topicId === topicId)
-        return prev;
-      detachFromTopic(prev);
-      logger.info({ chatId, threadId, fromTopicId: prev.topicId, toTopicId: topicId }, "telegram adapter: re-binding chat/thread to a new topic");
-    }
-    const mapping = {
-      topicId,
-      chatId,
-      ...threadId !== undefined ? { threadId } : {}
-    };
-    byKey.set(key, mapping);
-    let set = byTopic.get(topicId);
-    if (!set) {
-      set = new Set;
-      byTopic.set(topicId, set);
-    }
-    set.add(mapping);
-    if (persist)
-      store.save({ chatId, threadId, topicId });
-    return mapping;
-  }
-  function unbindTopic(topicId, { persist = true } = {}) {
-    const set = byTopic.get(topicId);
-    if (set) {
-      for (const mapping of set)
-        byKey.delete(mappingKey(mapping.chatId, mapping.threadId));
-      byTopic.delete(topicId);
-    }
-    if (persist)
-      store.deleteByTopic(topicId);
-  }
-  function cleanupPersistedMapping(mapping, logMessage) {
-    if (mapping.threadId !== undefined && typeof client.deleteForumTopic === "function") {
-      const key = mappingKey(mapping.chatId, mapping.threadId);
-      if (forumCleanupInFlight.has(key))
-        return;
-      forumCleanupInFlight.add(key);
-      client.deleteForumTopic(mapping.chatId, mapping.threadId).then(() => {
-        if (!stopped)
-          store.deleteByChat(mapping.chatId, mapping.threadId);
-      }).catch((err) => {
-        if (isForumTopicAlreadyGone(telegramErrorInfo(err))) {
-          if (!stopped)
-            store.deleteByChat(mapping.chatId, mapping.threadId);
-          return;
-        }
-        logger.warn({ err, topicId: mapping.topicId, threadId: mapping.threadId }, logMessage);
-      }).finally(() => forumCleanupInFlight.delete(key));
-      return;
-    }
-    store.deleteByChat(mapping.chatId, mapping.threadId);
-  }
-  function unloadMapping(chatId, threadId) {
-    const key = mappingKey(chatId, threadId);
-    const mapping = byKey.get(key);
-    if (!mapping)
-      return false;
-    detachFromTopic(mapping);
-    byKey.delete(key);
-    store.deleteByChat(chatId, threadId);
-    return true;
-  }
-  function loadExistingTopic(chatId, topicId, threadId) {
-    const topic = getTopic(topicId);
-    if (!topic?.participants.some((participant) => participant.userId === userId)) {
-      return false;
-    }
-    bindMapping(chatId, threadId, topic.id);
-    return true;
-  }
-  for (const persisted of store.load()) {
-    const topic = getTopic(persisted.topicId);
-    if (topic?.participants.some((participant) => participant.userId === userId)) {
-      bindMapping(persisted.chatId, persisted.threadId, persisted.topicId, { persist: false });
-      continue;
-    }
-    cleanupPersistedMapping(persisted, "telegram adapter: stale forum thread cleanup failed");
-  }
-  function reconcileStaleMappings() {
-    for (const persisted of store.load()) {
-      const topic = getTopic(persisted.topicId);
-      if (!topic?.participants.some((participant) => participant.userId === userId)) {
-        cleanupPersistedMapping(persisted, "telegram adapter: stale forum thread cleanup failed");
-      }
-    }
-  }
-  let suppressMaterialize = 0;
-  function registerTopicLocal(options) {
-    suppressMaterialize++;
-    try {
-      return topicService.create(options);
-    } finally {
-      suppressMaterialize--;
-    }
-  }
-  function getOrCreateTopic(title, agent) {
-    return getTopicByNameForUser(title, userId) ?? registerTopicLocal({ title, userId, kind: "agent", ...agent ? { agent } : {} });
-  }
-  function resolveMapping(chatId, threadId) {
-    const cached = byKey.get(mappingKey(chatId, threadId));
-    if (cached) {
-      const topic2 = getTopic(cached.topicId);
-      if (topic2)
-        return topic2;
-      unbindTopic(cached.topicId);
-    }
-    const topic = getOrCreateTopic(titleFor(chatId, threadId), opts.defaultAgent);
-    bindMapping(chatId, threadId, topic.id);
-    return topic;
-  }
-  const outboxCfg = {
-    pollMs: opts.outbox?.pollMs ?? 500,
-    baseDelayMs: opts.outbox?.baseDelayMs ?? 1000,
-    maxDelayMs: opts.outbox?.maxDelayMs ?? 60000,
-    maxAttempts: opts.outbox?.maxAttempts ?? 6
-  };
-  const outboxWorker = createDurableOutboxWorker({
-    policy: outboxCfg,
-    store: {
-      due: (now) => store.outboxDue(now),
-      hasPending: () => store.outboxAll().some((entry) => !entry.dead),
-      acknowledge: async (entry, delivery) => {
-        store.outboxDelete(entry.id);
-        const telegramMessageId = sentMessageId(delivery.sentValue);
-        if (!entry.runtimeMessageId || telegramMessageId === null)
-          return;
-        const ref = {
-          chatId: entry.chatId,
-          threadId: entry.threadId,
-          messageId: telegramMessageId,
-          kind: "text",
-          text: delivery.sentText,
-          html: delivery.sentAsHtml,
-          ...entry.footer ? { footer: entry.footer } : {}
-        };
-        if (deletedRuntimeMessageIds.has(entry.runtimeMessageId)) {
-          await deleteDeliveredRefs(entry.runtimeMessageId, [ref]);
-        } else {
-          rememberDeliveredRefs(entry.runtimeMessageId, [ref]);
-        }
-      },
-      discard: (entry) => {
-        store.outboxDelete(entry.id);
-      },
-      retry: (entry, retry) => {
-        store.outboxReschedule(entry.id, retry.attempts, retry.nextTryAt, retry.error);
-      },
-      deadLetter: (entry, retry) => {
-        store.outboxMarkDead(entry.id, retry.attempts, retry.error);
-      }
-    },
-    shouldDiscard: (entry) => Boolean(entry.runtimeMessageId && deletedRuntimeMessageIds.has(entry.runtimeMessageId)),
-    deliver: async (entry) => {
-      try {
-        const sentValue = await client.sendMessage(entry.chatId, entry.html, {
-          ...threadOpts(entry.threadId),
-          parse_mode: "HTML"
-        });
-        return { sentValue, sentText: entry.html, sentAsHtml: true };
-      } catch (error) {
-        if (!isHtmlParseError(telegramErrorInfo(error)))
-          throw error;
-        const sentValue = await client.sendMessage(entry.chatId, entry.plain, threadOpts(entry.threadId));
-        return { sentValue, sentText: entry.plain, sentAsHtml: false };
-      }
-    },
-    classifyError: (error) => {
-      const info = telegramErrorInfo(error);
-      return {
-        message: info.description || info.code || "send failed",
-        ...info.status === 429 && info.retryAfterSec !== undefined ? { retryAfterMs: Math.max(info.retryAfterSec * 1000, 0) } : {}
-      };
-    },
-    onEntryStart: (entry) => beginRuntimeDelivery(entry.runtimeMessageId),
-    onEntryEnd: (entry) => endRuntimeDelivery(entry.runtimeMessageId),
-    onDeadLetter: (entry, retry) => {
-      logger.warn({ id: entry.id, chatId: entry.chatId, attempts: retry.attempts, error: retry.error }, "telegram adapter: outbox entry dead-lettered after max attempts");
-    },
-    onError: (error) => {
-      logger.warn({ err: error }, "telegram adapter: outbox flush failed");
-    }
-  });
-  outboxWorker.start();
-  function enqueueOutbox(chatId, threadId, html, plain, info, runtimeMessageId, footer) {
-    if (stopped)
-      return;
-    const initialDelay = info.status === 429 && info.retryAfterSec !== undefined ? info.retryAfterSec * 1000 : outboxCfg.baseDelayMs;
-    store.outboxEnqueue({
-      chatId,
-      threadId,
-      runtimeMessageId,
-      footer,
-      html,
-      plain,
-      nextTryAt: Date.now() + initialDelay,
-      lastError: info.description || info.code || "send failed"
-    });
-    logger.warn({ chatId, threadId, status: info.status, code: info.code }, "telegram adapter: transient send failure \u2014 queued for retry");
-    outboxWorker.wake();
-  }
-  function sentMessageId(value) {
-    if (!value || typeof value !== "object" || !("message_id" in value))
-      return null;
-    const id = value.message_id;
-    return typeof id === "number" && Number.isSafeInteger(id) ? id : null;
-  }
-  function rememberDeliveredRefs(messageId, refs) {
-    if (refs.length === 0)
-      return;
-    const current = deliveredByRuntimeMessageId.get(messageId) ?? [];
-    current.push(...refs);
-    deliveredByRuntimeMessageId.set(messageId, current);
-  }
-  async function deleteDeliveredRefs(runtimeMessageId, refs, topicId) {
-    if (typeof client.deleteMessage !== "function")
-      return;
-    for (const ref of refs) {
-      await client.deleteMessage(ref.chatId, ref.messageId).catch((err) => logger.warn({ err, topicId, messageId: runtimeMessageId, telegramMessageId: ref.messageId }, "telegram adapter: superseded message cleanup failed"));
-    }
-  }
-  function isDeliveredTextRef(ref) {
-    return ref.kind === "text" && typeof ref.text === "string" && typeof ref.html === "boolean";
-  }
-  async function deliver(chatId, threadId, text, runtimeMessageId, footer) {
-    const base = threadOpts(threadId);
-    const htmlOpts = { ...base, parse_mode: "HTML" };
-    const delivered = [];
-    const chunks = renderOutbound(text);
-    for (const [index, chunk] of chunks.entries()) {
-      const chunkFooter = footer && index === chunks.length - 1 ? footer : undefined;
-      try {
-        const sent = await client.sendMessage(chatId, chunk.html, htmlOpts);
-        const messageId = sentMessageId(sent);
-        if (messageId !== null) {
-          delivered.push({
-            messageId,
-            kind: "text",
-            text: chunk.html,
-            html: true,
-            ...chunkFooter ? { footer: chunkFooter } : {}
-          });
-        }
-      } catch (err) {
-        const info = telegramErrorInfo(err);
-        if (isHtmlParseError(info)) {
-          try {
-            const sent = await client.sendMessage(chatId, chunk.plain, base);
-            const messageId = sentMessageId(sent);
-            if (messageId !== null) {
-              delivered.push({
-                messageId,
-                kind: "text",
-                text: chunk.plain,
-                html: false,
-                ...chunkFooter ? { footer: chunkFooter } : {}
-              });
-            }
-          } catch (fallbackErr) {
-            const fallbackInfo = telegramErrorInfo(fallbackErr);
-            if (isRetryableSendError(fallbackInfo)) {
-              enqueueOutbox(chatId, threadId, chunk.plain, chunk.plain, fallbackInfo, runtimeMessageId, chunkFooter);
-            } else {
-              logger.warn({ err: fallbackErr, chatId }, "telegram adapter: plain fallback failed");
-            }
-          }
-          continue;
-        }
-        if (isRetryableSendError(info)) {
-          enqueueOutbox(chatId, threadId, chunk.html, chunk.plain, info, runtimeMessageId, chunkFooter);
-          continue;
-        }
-        logger.warn({ err, chatId }, "telegram adapter: send failed \u2014 dropping chunk");
-      }
-    }
-    return delivered;
-  }
-  async function sendFile(chatId, threadId, path) {
-    const base = threadOpts(threadId);
-    if (isSensitivePath(path)) {
-      logger.warn({ path, chatId }, "telegram adapter: blocked sensitive file path");
-      return null;
-    }
-    if (!existsSync(path)) {
-      const sent = await client.sendMessage(chatId, `File: ${path}`, base).catch(() => null);
-      const messageId = sentMessageId(sent);
-      return messageId === null ? null : { messageId, kind: "media" };
-    }
-    const ext = path.split(".").pop()?.toLowerCase() ?? "";
-    try {
-      let sent;
-      if (PHOTO_EXTS.has(ext) && typeof client.sendPhoto === "function") {
-        sent = await client.sendPhoto(chatId, path, base);
-      } else if (typeof client.sendDocument === "function") {
-        sent = await client.sendDocument(chatId, path, base);
-      } else {
-        sent = await client.sendMessage(chatId, `File: ${path}`, base);
-      }
-      const messageId = sentMessageId(sent);
-      return messageId === null ? null : { messageId, kind: "media" };
-    } catch (err) {
-      logger.warn({ err, path, chatId }, "telegram adapter: file send failed");
-      return null;
-    }
-  }
-  async function deliverPayload(chatId, threadId, payload) {
-    if (payload.runtimeMessageId && deletedRuntimeMessageIds.has(payload.runtimeMessageId))
-      return;
-    beginRuntimeDelivery(payload.runtimeMessageId);
-    const deliveredRefs = [];
-    try {
-      let text = payload.text;
-      let footer = null;
-      if (payload.runtimeMessageId && footerEnabled) {
-        const message = runtimeMessages.get(payload.runtimeMessageId);
-        const shouldRenderFooter = message && (!message.queryId || message.usage);
-        footer = shouldRenderFooter ? renderTurnFooter(message) : null;
-        if (footer) {
-          text = text ? `${text}
-
-*${footer}*` : `*${footer}*`;
-        }
-      }
-      if (text) {
-        const delivered = await deliver(chatId, threadId, text, payload.runtimeMessageId, footer ?? undefined);
-        deliveredRefs.push(...delivered.map((item) => ({
-          ...item,
-          chatId,
-          threadId
-        })));
-      }
-      for (const path of payload.files) {
-        if (payload.runtimeMessageId && deletedRuntimeMessageIds.has(payload.runtimeMessageId)) {
-          break;
-        }
-        const delivered = await sendFile(chatId, threadId, path);
-        if (delivered)
-          deliveredRefs.push({ ...delivered, chatId, threadId });
-      }
-      if (payload.runtimeMessageId && deliveredRefs.length > 0) {
-        if (deletedRuntimeMessageIds.has(payload.runtimeMessageId)) {
-          await deleteDeliveredRefs(payload.runtimeMessageId, deliveredRefs);
-        } else {
-          rememberDeliveredRefs(payload.runtimeMessageId, deliveredRefs);
-        }
-      }
-    } finally {
-      endRuntimeDelivery(payload.runtimeMessageId);
-    }
-  }
-  const sendQueues = new Map;
-  function enqueueSend(topicId, task) {
-    const prev = sendQueues.get(topicId) ?? Promise.resolve();
-    const next = prev.then(() => new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        logger.warn({ topicId, sendTimeoutMs }, "telegram adapter: send timed out \u2014 abandoning it and continuing the queue");
-        resolve();
-      }, sendTimeoutMs);
-      task().catch((err) => logger.warn({ err, topicId }, "telegram adapter: send task failed")).finally(() => {
-        clearTimeout(timer);
-        resolve();
-      });
-    }));
-    sendQueues.set(topicId, next);
-    next.then(() => {
-      if (sendQueues.get(topicId) === next)
-        sendQueues.delete(topicId);
-    });
-  }
-  function enqueueFanout(topicId, mappings, payload) {
-    const targets = [...mappings];
-    enqueueSend(topicId, async () => {
-      for (const m of targets)
-        await deliverPayload(m.chatId, m.threadId, payload);
-    });
-  }
-  function enqueueTarget(topicId, target, payload) {
-    enqueueSend(topicId, () => deliverPayload(target.chatId, target.threadId, payload));
-  }
-  const pendingByTopic = new Map;
-  const permissionBlockedTopics = new Map;
-  const materializeTombstones = new Map;
-  if (forumMode) {
-    for (const t of store.loadTombstones())
-      materializeTombstones.set(t.topicId, t.title);
-  }
-  function deliverFallback(title, payload) {
-    return deliverPayload(forumChat, undefined, {
-      text: payload.text ? `[${title}] ${payload.text}` : "",
-      files: payload.files,
-      runtimeMessageId: payload.runtimeMessageId
-    });
-  }
-  function flushBuffered(topicId, buffer, send) {
-    for (const payload of buffer)
-      enqueueSend(topicId, () => send(payload));
-  }
-  function materializeTopic(topic) {
-    if (!forumManageTopicsAvailable || suppressMaterialize > 0 || byTopic.has(topic.id) || pendingByTopic.has(topic.id) || permissionBlockedTopics.has(topic.id) || materializeTombstones.has(topic.id)) {
-      return;
-    }
-    if (!isTopicVisible(topic))
-      return;
-    if (!topic.participants?.some((p) => p.userId === userId))
-      return;
-    const materializationChat = forumChat;
-    const pending = { buffer: [], cancelled: false };
-    pendingByTopic.set(topic.id, pending);
-    (async () => {
-      let created;
-      try {
-        created = await client.createForumTopic(materializationChat, topic.title.slice(0, FORUM_TOPIC_NAME_MAX));
-      } catch (err) {
-        if (pendingByTopic.get(topic.id) === pending)
-          pendingByTopic.delete(topic.id);
-        if (stopped || pending.cancelled)
-          return;
-        const errorInfo = telegramErrorInfo(err);
-        if (isManageTopicsPermissionError(errorInfo)) {
-          const permissionWasAvailable = forumManageTopicsAvailable;
-          forumManageTopicsAvailable = false;
-          permissionBlockedTopics.set(topic.id, topic.title);
-          logger.warn({ err, topicId: topic.id, title: topic.title }, "telegram adapter: Manage Topics unavailable \u2014 waiting for permission recovery");
-          if (permissionWasAvailable) {
-            reply(forumChat, undefined, 'Forum topic creation is paused. Enable the bot administrator permission "Manage Topics"; pending topics will be retried automatically.');
-          }
-          flushBuffered(topic.id, pending.buffer, (payload) => deliverFallback(topic.title, payload));
-          return;
-        }
-        logger.warn({ err, topicId: topic.id, title: topic.title }, "telegram adapter: createForumTopic failed permanently \u2014 falling back to general chat");
-        materializeTombstones.set(topic.id, topic.title);
-        store.saveTombstone(topic.id, topic.title);
-        flushBuffered(topic.id, pending.buffer, (payload) => deliverFallback(topic.title, payload));
-        return;
-      }
-      if (pendingByTopic.get(topic.id) === pending)
-        pendingByTopic.delete(topic.id);
-      const threadId = created.message_thread_id;
-      if (stopped || pending.cancelled) {
-        if (pending.cancelled && typeof client.deleteForumTopic === "function") {
-          const orphan = { chatId: materializationChat, threadId, topicId: topic.id };
-          store.save(orphan);
-          cleanupPersistedMapping(orphan, "telegram adapter: orphan thread cleanup failed");
-        }
-        return;
-      }
-      bindMapping(materializationChat, threadId, topic.id);
-      flushBuffered(topic.id, pending.buffer, (payload) => deliverPayload(materializationChat, threadId, payload));
-    })();
-  }
-  function handleTopicDeleted(topicId) {
-    if (materializeTombstones.delete(topicId))
-      store.deleteTombstone(topicId);
-    const pending = pendingByTopic.get(topicId);
-    if (pending)
-      pending.cancelled = true;
-    for (const [messageId, message] of runtimeMessages) {
-      if (message.topicId === topicId)
-        deleteDeliveredRuntimeMessage(topicId, messageId);
-    }
-    const set = byTopic.get(topicId);
-    if (!set)
-      return;
-    const mappings = [...set];
-    unbindTopic(topicId, { persist: false });
-    for (const mapping of mappings) {
-      cleanupPersistedMapping(mapping, "telegram adapter: deleteForumTopic failed");
-    }
-  }
-  function findMappedAncestor(topic) {
-    const seen = new Set([topic.id]);
-    let current = topic;
-    for (let hop = 0;hop < MAX_PARENT_HOPS && current; hop++) {
-      const parentId = current.parentTopicId;
-      if (!parentId || seen.has(parentId))
-        return;
-      seen.add(parentId);
-      const mappings = byTopic.get(parentId);
-      if (mappings && mappings.size > 0)
-        return mappings;
-      current = getTopic(parentId);
-    }
-    return;
-  }
-  function routeMessage(topicId, payload, queryId) {
-    const pending = pendingByTopic.get(topicId);
-    if (pending) {
-      pending.buffer.push(payload);
-      return;
-    }
-    const specificTarget = queryId ? targetByQueryId.get(queryId) : undefined;
-    if (specificTarget) {
-      enqueueTarget(topicId, specificTarget, payload);
-      return;
-    }
-    const mappings = byTopic.get(topicId);
-    if (mappings && mappings.size > 0) {
-      enqueueFanout(topicId, mappings, payload);
-      return;
-    }
-    const tombstoneTitle = materializeTombstones.get(topicId);
-    if (tombstoneTitle !== undefined) {
-      enqueueSend(topicId, () => deliverFallback(tombstoneTitle, payload));
-      return;
-    }
-    const topic = getTopic(topicId);
-    if (!topic)
-      return;
-    if (forumMode) {
-      if (!forumManageTopicsAvailable || permissionBlockedTopics.has(topicId)) {
-        enqueueSend(topicId, () => deliverFallback(topic.title, payload));
-        return;
-      }
-      materializeTopic(topic);
-      pendingByTopic.get(topicId)?.buffer.push(payload);
-      return;
-    }
-    const ancestorMappings = findMappedAncestor(topic);
-    if (ancestorMappings) {
-      enqueueFanout(topicId, ancestorMappings, {
-        text: payload.text ? `[${topic.title}] ${payload.text}` : "",
-        files: payload.files,
-        runtimeMessageId: payload.runtimeMessageId
-      });
-    }
-  }
-  function deleteDeliveredRuntimeMessage(topicId, messageId) {
-    deletedRuntimeMessageIds.add(messageId);
-    completedRuntimeMessageCleanup.delete(messageId);
-    runtimeMessages.delete(messageId);
-    const pending = pendingByTopic.get(topicId);
-    if (pending) {
-      pending.buffer = pending.buffer.filter((payload) => payload.runtimeMessageId !== messageId);
-    }
-    store.outboxDeleteByRuntimeMessageId(messageId);
-    enqueueSend(topicId, async () => {
-      const refs = deliveredByRuntimeMessageId.get(messageId) ?? [];
-      deliveredByRuntimeMessageId.delete(messageId);
-      await deleteDeliveredRefs(messageId, refs, topicId);
-      if ((activeRuntimeDeliveries.get(messageId) ?? 0) > 0) {
-        completedRuntimeMessageCleanup.add(messageId);
-      } else {
-        completedRuntimeMessageCleanup.delete(messageId);
-        deletedRuntimeMessageIds.delete(messageId);
-      }
-    });
-  }
-  function attachUpdatedFooter(topicId, messageId, footer) {
-    enqueueSend(topicId, async () => {
-      if (deletedRuntimeMessageIds.has(messageId))
-        return;
-      const refs = deliveredByRuntimeMessageId.get(messageId) ?? [];
-      const refsByTarget = new Map;
-      for (const ref of refs) {
-        if (!isDeliveredTextRef(ref))
-          continue;
-        const key = `${ref.chatId}:${ref.threadId ?? "root"}`;
-        const targetRefs = refsByTarget.get(key) ?? [];
-        targetRefs.push(ref);
-        refsByTarget.set(key, targetRefs);
-      }
-      const footerChunk = renderOutbound(`*${footer}*`)[0];
-      if (!footerChunk)
-        return;
-      for (const targetRefs of refsByTarget.values()) {
-        const ref = targetRefs.findLast((candidate) => candidate.footer !== undefined) ?? targetRefs.at(-1);
-        if (!ref)
-          continue;
-        if (ref.footer === footer)
-          continue;
-        if (typeof client.editMessageText === "function") {
-          const suffix = ref.html ? footerChunk.html : footerChunk.plain;
-          const previousFooterChunk = ref.footer ? renderOutbound(`*${ref.footer}*`)[0] : undefined;
-          const previousSuffix = previousFooterChunk ? ref.html ? previousFooterChunk.html : previousFooterChunk.plain : "";
-          const previousTrailer = previousSuffix ? `
-
-${previousSuffix}` : "";
-          const baseText = previousTrailer && ref.text.endsWith(previousTrailer) ? ref.text.slice(0, -previousTrailer.length) : ref.text;
-          const text = `${baseText}
-
-${suffix}`;
-          const editOptions = {
-            chat_id: ref.chatId,
-            message_id: ref.messageId,
-            ...ref.html ? { parse_mode: "HTML" } : {}
-          };
-          try {
-            await client.editMessageText(text, editOptions);
-            ref.text = text;
-            ref.footer = footer;
-            continue;
-          } catch (err) {
-            let editError = err;
-            const info = telegramErrorInfo(err);
-            if (isRetryableSendError(info)) {
-              const retryDelayMs = Math.max(0, (info.retryAfterSec ?? 0) * 1000);
-              if (retryDelayMs > 30000) {
-                logger.warn({ err, topicId, messageId, retryDelayMs }, "telegram adapter: footer edit rate-limited; leaving footer unchanged");
-                continue;
-              }
-              if (retryDelayMs > 0) {
-                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
-              }
-              try {
-                await client.editMessageText(text, editOptions);
-                ref.text = text;
-                ref.footer = footer;
-                continue;
-              } catch (retryErr) {
-                if (isRetryableSendError(telegramErrorInfo(retryErr))) {
-                  logger.warn({ err: retryErr, topicId, messageId, telegramMessageId: ref.messageId }, "telegram adapter: footer edit retry failed; leaving footer unchanged");
-                  continue;
-                }
-                editError = retryErr;
-              }
-            }
-            logger.warn({ err: editError, topicId, messageId, telegramMessageId: ref.messageId }, "telegram adapter: footer edit failed permanently; sending footer separately");
-          }
-        }
-        const delivered = await deliver(ref.chatId, ref.threadId, `*${footer}*`, messageId, footer);
-        refs.push(...delivered.map((item) => ({
-          ...item,
-          chatId: ref.chatId,
-          threadId: ref.threadId,
-          footer
-        })));
-      }
-      deliveredByRuntimeMessageId.set(messageId, refs);
-    });
-  }
-  function clearQueryDeliveryState(queryId) {
-    const timer = setTimeout(() => {
-      for (const [messageId, message] of runtimeMessages) {
-        if (message.queryId !== queryId)
-          continue;
-        runtimeMessages.delete(messageId);
-        deliveredByRuntimeMessageId.delete(messageId);
-        deletedRuntimeMessageIds.delete(messageId);
-      }
-    }, 5 * 60000);
-    timer.unref?.();
-  }
-  function reply(chatId, threadId, text) {
-    client.sendMessage(chatId, text, threadOpts(threadId)).catch((err) => logger.warn({ err, chatId }, "telegram adapter: reply failed"));
-  }
-  async function sendOnboardingGuide(chatId, threadId) {
-    const bot = await resolveBotIdentity();
-    if (stopped)
-      return;
-    await client.sendMessage(chatId, onboardingGuide(bot?.username), threadOpts(threadId)).catch((err) => logger.warn({ err, chatId }, "telegram adapter: onboarding guide failed"));
-  }
-  function materializeVisibleTopics() {
-    if (!forumMode || !forumManageTopicsAvailable)
-      return;
-    for (const topic of listTopics()) {
-      if (isTopicVisible(topic) && topic.participants.some((participant) => participant.userId === userId)) {
-        materializeTopic(topic);
-      }
-    }
-  }
-  function restoreForumTopicCreation({ retryPermanent = false } = {}) {
-    forumManageTopicsAvailable = true;
-    permissionBlockedTopics.clear();
-    if (retryPermanent) {
-      materializeTombstones.clear();
-      store.clearTombstones();
-    }
-    reconcileStaleMappings();
-    materializeVisibleTopics();
-  }
-  async function notifyOwnerDms(text) {
-    await Promise.allSettled([...ownerDmChatIds].map((chatId) => client.sendMessage(chatId, text)));
-  }
-  async function disconnectForum(chatId) {
-    if (!forumMode || forumChat !== chatId)
-      return false;
-    for (const [topicId, pending] of pendingByTopic) {
-      pending.cancelled = true;
-      if (pendingByTopic.get(topicId) === pending)
-        pendingByTopic.delete(topicId);
-    }
-    for (const mapping of [...byKey.values()]) {
-      if (mapping.chatId === chatId)
-        unloadMapping(mapping.chatId, mapping.threadId);
-    }
-    for (const [queryId, target] of targetByQueryId) {
-      if (target.chatId === chatId)
-        targetByQueryId.delete(queryId);
-    }
-    permissionBlockedTopics.clear();
-    materializeTombstones.clear();
-    store.clearTombstones();
-    store.outboxDeleteByChat(chatId);
-    store.clearForumChatId();
-    forumMode = false;
-    forumManageTopicsAvailable = false;
-    forumChat = 0;
-    await notifyOwnerDms("The Telegram forum was disconnected because the bot left or was removed. Your Negotium topics were preserved; promote the bot in a forum group to reconnect.");
-    logger.info({ userId, forumChatId: chatId }, "telegram adapter: forum disconnected");
-    return true;
-  }
-  async function linkForumAndAnnounce(ownerTelegramId, chat, botMember) {
-    if (typeof client.createForumTopic !== "function") {
-      reply(ownerTelegramId, undefined, "This Telegram client cannot create forum topics, so the group was not connected.");
-      return false;
-    }
-    if (forumMode && forumChat !== chat.id) {
-      reply(ownerTelegramId, undefined, `A different forum group (${forumChat}) is already connected to this Negotium node.`);
-      return false;
-    }
-    const hasManageTopics = canManageTopics(botMember);
-    if (forumMode && forumChat === chat.id) {
-      const recovered = hasManageTopics && !forumManageTopicsAvailable;
-      const lostPermission = !hasManageTopics && forumManageTopicsAvailable;
-      if (hasManageTopics) {
-        restoreForumTopicCreation({ retryPermanent: recovered });
-        if (recovered) {
-          await Promise.allSettled([
-            client.sendMessage(chat.id, "Manage Topics permission confirmed. Pending Negotium topics are being created now."),
-            notifyOwnerDms(`Manage Topics permission confirmed for \u201C${chat.title?.trim() || chat.id}\u201D. Pending topics are being retried.`)
-          ]);
-        }
-      } else {
-        forumManageTopicsAvailable = false;
-        if (lostPermission) {
-          await notifyOwnerDms(`Manage Topics permission was removed from \u201C${chat.title?.trim() || chat.id}\u201D. Existing topics are preserved; restore the permission to resume topic creation.`);
-        }
-      }
-      return true;
-    }
-    forumChat = chat.id;
-    forumMode = true;
-    forumManageTopicsAvailable = hasManageTopics;
-    permissionBlockedTopics.clear();
-    materializeTombstones.clear();
-    store.clearTombstones();
-    store.saveForumChatId(chat.id);
-    bindMapping(chat.id, undefined, personalGeneral.id);
-    ownerDmChatIds.add(ownerTelegramId);
-    materializeVisibleTopics();
-    const title = chat.title?.trim() || String(chat.id);
-    const permissionWarning = hasManageTopics ? "" : `
-
-Warning: enable the bot administrator permission "Manage Topics" before creating or deleting topics.`;
-    await Promise.allSettled([
-      client.sendMessage(chat.id, `Negotium connected to \u201C${title}\u201D. Use this General topic to create and manage topics in natural language.${permissionWarning}`),
-      client.sendMessage(ownerTelegramId, `Connected forum group \u201C${title}\u201D (${chat.id}). No /connect command is needed.${permissionWarning}`)
-    ]);
-    logger.info({
-      userId,
-      ownerTelegramId,
-      forumChatId: chat.id,
-      canManageTopics: hasManageTopics
-    }, "telegram adapter: auto-connected forum group");
-    return true;
-  }
-  async function tryAutoConnectFromMessage(msg) {
-    const senderId = msg.from?.id;
-    if (msg.chat.type !== "supergroup" || !msg.chat.is_forum || senderId === undefined || !isAllowed(senderId)) {
-      return false;
-    }
-    if (forumMode && msg.chat.id !== forumChat)
-      return false;
-    if (forumMode && forumManageTopicsAvailable)
-      return true;
-    if (typeof client.getMe !== "function" || typeof client.getChatMember !== "function") {
-      return false;
-    }
-    try {
-      const bot = await resolveBotIdentity();
-      if (!bot)
-        return false;
-      const [botMember, senderMember] = await Promise.all([
-        client.getChatMember(msg.chat.id, bot.id),
-        client.getChatMember(msg.chat.id, senderId)
-      ]);
-      if (!isChatAdmin(botMember) || !isChatAdmin(senderMember))
-        return false;
-      await linkForumAndAnnounce(senderId, msg.chat, botMember);
-      return forumMode && forumChat === msg.chat.id;
-    } catch (err) {
-      logger.debug({ err, groupId: msg.chat.id, senderId }, "telegram adapter: lazy forum auto-connect check failed");
-      return false;
-    }
-  }
-  async function verifyInitialForumPermissions() {
-    if (!forumMode)
-      return;
-    if (forumChatId !== undefined)
-      return;
-    if (typeof client.getMe !== "function" || typeof client.getChatMember !== "function") {
-      forumManageTopicsAvailable = true;
-      return;
-    }
-    try {
-      const bot = await resolveBotIdentity();
-      if (!bot || stopped || !forumMode)
-        return;
-      const member = await client.getChatMember(forumChat, bot.id);
-      if (member.status === "left" || member.status === "kicked") {
-        await disconnectForum(forumChat);
-        return;
-      }
-      if (canManageTopics(member)) {
-        const restoredAutoConnection = forumChatId === undefined && restoredForumChatId !== undefined;
-        restoreForumTopicCreation({ retryPermanent: restoredAutoConnection });
-      } else {
-        forumManageTopicsAvailable = false;
-      }
-    } catch (err) {
-      logger.warn({ err, forumChatId: forumChat }, "telegram adapter: initial forum permission check failed");
-    }
-  }
-  verifyInitialForumPermissions();
-  function runTurn(topic, prompt, chatId, threadId) {
-    const target = {
-      topicId: topic.id,
-      chatId,
-      ...threadId !== undefined ? { threadId } : {}
-    };
-    const rememberTarget = (queryId2) => {
-      targetByQueryId.set(queryId2, target);
-    };
-    const { queryId } = submitUserMessage({
-      topic,
-      userId,
-      text: prompt,
-      sourceAdapter: "telegram",
-      visualTools: false,
-      onDispatched: rememberTarget,
-      startTurn: dispatchTurn
-    });
-    if (queryId)
-      rememberTarget(queryId);
-  }
-  const inboundQueues = new Map;
-  function enqueueInbound(chatId, threadId, task) {
-    const key = mappingKey(chatId, threadId);
-    const previous = inboundQueues.get(key);
-    const run = async () => {
-      if (stopped)
-        return;
-      await task();
-    };
-    const next = (previous ? previous.catch(() => {}).then(run) : run()).catch((err) => logger.warn({ err, chatId, threadId }, "telegram adapter: inbound task failed"));
-    inboundQueues.set(key, next);
-    next.then(() => {
-      if (inboundQueues.get(key) === next)
-        inboundQueues.delete(key);
-    });
-  }
-  const transcriber = opts.transcribe ?? ((filePath) => transcribeAudio(filePath));
-  const transcriptionAvailable = () => opts.transcribe !== undefined || isTranscriptionConfigured();
-  async function downloadToTopic(topicId, fileId, filename) {
-    const url = await client.getFileLink(fileId);
-    const res = await fetch(url);
-    if (!res.ok)
-      throw new Error(`attachment download failed: HTTP ${res.status}`);
-    return ingestAttachment({
-      topicId,
-      filename,
-      bytes: new Uint8Array(await res.arrayBuffer())
-    });
-  }
-  async function ingestMessageFiles(topicId, msg) {
-    const lines = [];
-    if (msg.photo && msg.photo.length > 0) {
-      const photo = msg.photo[msg.photo.length - 1];
-      lines.push((await downloadToTopic(topicId, photo.file_id, "photo.jpg")).promptLine);
-    }
-    if (msg.document) {
-      const filename = msg.document.file_name || "file";
-      lines.push((await downloadToTopic(topicId, msg.document.file_id, filename)).promptLine);
-    }
-    return lines;
-  }
-  async function handleMediaMessage(msg, chatId, threadId) {
-    const caption = (msg.text ?? msg.caption ?? "").trim();
-    const topic = resolveMapping(chatId, threadId);
-    if (typeof client.getFileLink !== "function") {
-      logger.warn({ chatId }, "telegram adapter: media message but client lacks getFileLink \u2014 caption only");
-      if (caption)
-        runTurn(topic, caption, chatId, threadId);
-      else
-        reply(chatId, threadId, "this bot cannot download attachments");
-      return;
-    }
-    let promptLines = [];
-    let voiceText = "";
-    try {
-      promptLines = await ingestMessageFiles(topic.id, msg);
-      if (msg.voice) {
-        if (!transcriptionAvailable()) {
-          reply(chatId, threadId, "voice transcription is not configured on this bot \u2014 please send text");
-        } else {
-          const ingested = await downloadToTopic(topic.id, msg.voice.file_id, "voice.ogg");
-          const transcript = (await transcriber(ingested.path))?.trim();
-          if (transcript) {
-            voiceText = `[Voice transcript]
-${transcript}`;
-          } else {
-            reply(chatId, threadId, "voice transcription failed \u2014 please send text");
-          }
-        }
-      }
-    } catch (err) {
-      logger.warn({ err, chatId, topicId: topic.id }, "telegram adapter: attachment intake failed");
-      reply(chatId, threadId, errMsg(err, "attachment download failed"));
-    }
-    if (stopped)
-      return;
-    const userText = voiceText ? caption ? `${voiceText}
-
-${caption}` : voiceText : caption;
-    if (!userText && promptLines.length === 0)
-      return;
-    runTurn(topic, composeAttachmentPrompt(userText, promptLines), chatId, threadId);
-  }
-  const mediaGroupCfg = {
-    debounceMs: opts.mediaGroup?.debounceMs ?? 1000,
-    maxWaitMs: opts.mediaGroup?.maxWaitMs ?? 3000
-  };
-  const mediaGroups = new Map;
-  function flushMediaGroup(key) {
-    const entry = mediaGroups.get(key);
-    if (!entry)
-      return;
-    mediaGroups.delete(key);
-    entry.release();
-  }
-  function bufferMediaGroup(msg, chatId, threadId) {
-    const key = `${chatId}:${msg.media_group_id}`;
-    const existing = mediaGroups.get(key);
-    if (existing) {
-      existing.messages.push(msg);
-      clearTimeout(existing.timer);
-      const remaining = existing.firstSeenAt + mediaGroupCfg.maxWaitMs - Date.now();
-      const wait = Math.max(0, Math.min(mediaGroupCfg.debounceMs, remaining));
-      existing.timer = setTimeout(() => flushMediaGroup(key), wait);
-      return;
-    }
-    let releaseReady;
-    const ready = new Promise((resolve) => {
-      releaseReady = resolve;
-    });
-    const entry = {
-      messages: [msg],
-      chatId,
-      ...threadId !== undefined ? { threadId } : {},
-      firstSeenAt: Date.now(),
-      timer: setTimeout(() => flushMediaGroup(key), Math.min(mediaGroupCfg.debounceMs, mediaGroupCfg.maxWaitMs)),
-      ready,
-      release: releaseReady
-    };
-    mediaGroups.set(key, entry);
-    enqueueInbound(chatId, threadId, async () => {
-      await entry.ready;
-      if (stopped)
-        return;
-      await handleMediaGroupFlush(entry);
-    });
-  }
-  async function handleMediaGroupFlush(entry) {
-    const { messages, chatId, threadId } = entry;
-    const topic = resolveMapping(chatId, threadId);
-    const captions = messages.map((m) => (m.text ?? m.caption ?? "").trim()).filter((caption) => caption.length > 0);
-    if (typeof client.getFileLink !== "function") {
-      logger.warn({ chatId }, "telegram adapter: media group but client lacks getFileLink \u2014 captions only");
-      if (captions.length > 0)
-        runTurn(topic, captions.join(`
-`), chatId, threadId);
-      else
-        reply(chatId, threadId, "this bot cannot download attachments");
-      return;
-    }
-    const promptLines = [];
-    for (const msg of messages) {
-      try {
-        promptLines.push(...await ingestMessageFiles(topic.id, msg));
-      } catch (err) {
-        logger.warn({ err, chatId, topicId: topic.id }, "telegram adapter: media group attachment intake failed");
-        reply(chatId, threadId, errMsg(err, "attachment download failed"));
-      }
-    }
-    if (stopped)
-      return;
-    const userText = captions.join(`
-`);
-    if (!userText && promptLines.length === 0)
-      return;
-    runTurn(topic, composeAttachmentPrompt(userText, promptLines), chatId, threadId);
-  }
-  async function handleCommand(text, chatId, threadId, telegramUserId) {
-    const [rawCmd = ""] = text.split(/\s+/);
-    const addressedUsername = rawCmd.match(/@(\w+)$/)?.[1];
-    if (addressedUsername) {
-      const bot = await resolveBotIdentity();
-      if (!bot?.username || bot.username.toLowerCase() !== addressedUsername.toLowerCase())
-        return;
-    }
-    if (isVaultCommandLine(text)) {
-      if (!isVaultOwner(telegramUserId))
-        return;
-      const vaultResponse = executeVaultCommand(userId, text);
-      if (vaultResponse !== null)
-        reply(chatId, threadId, vaultResponse);
-      return;
-    }
-    const cmd = rawCmd.replace(/@\w+$/, "");
-    const arg = extractCommandArg(text);
-    switch (cmd) {
-      case "/start": {
-        await sendOnboardingGuide(chatId, threadId);
-        return;
-      }
-      case "/abort": {
-        const mapping = byKey.get(mappingKey(chatId, threadId));
-        reply(chatId, threadId, mapping && topicService.abortTurn(mapping.topicId, userId) ? "aborted" : "nothing running");
-        return;
-      }
-      case "/agent": {
-        if (!isAgentKind(arg)) {
-          reply(chatId, threadId, "usage: /agent <claude|codex|maestro>");
-          return;
-        }
-        try {
-          const topic = getOrCreateTopic(`${titleFor(chatId, threadId)}-${arg}`, arg);
-          bindMapping(chatId, threadId, topic.id);
-          reply(chatId, threadId, `agent set to ${arg} \u2014 topic "${topic.title}"`);
-        } catch (err) {
-          reply(chatId, threadId, errMsg(err, "agent switch failed"));
-        }
-        return;
-      }
-      case "/topics": {
-        const mine = listTopics().filter((t) => isTopicVisible(t) && t.participants.some((p) => p.userId === userId));
-        reply(chatId, threadId, mine.length ? mine.map((t) => `- ${t.title}${t.agent ? ` (${t.agent})` : ""}`).join(`
-`) : "no topics");
-        return;
-      }
-      case "/new": {
-        if (!arg) {
-          const mapping = byKey.get(mappingKey(chatId, threadId));
-          const topic = mapping ? getTopic(mapping.topicId) : null;
-          if (!topic) {
-            reply(chatId, threadId, "nothing to reset \u2014 this chat has no topic yet");
-            return;
-          }
-          try {
-            const result = await topicService.reset({
-              topicId: topic.id,
-              userId,
-              reason: "telegram-session-reset"
-            });
-            reply(chatId, threadId, result.text);
-          } catch (err) {
-            reply(chatId, threadId, errMsg(err, "session reset failed"));
-          }
-          return;
-        }
-        try {
-          const createOptions = {
-            title: arg,
-            userId,
-            kind: "agent",
-            ...opts.defaultAgent ? { agent: opts.defaultAgent } : {}
-          };
-          const fromForumGeneral = forumMode && chatId === forumChat && threadId === undefined;
-          const topic = fromForumGeneral ? topicService.create(createOptions) : registerTopicLocal(createOptions);
-          if (fromForumGeneral) {
-            reply(chatId, threadId, `creating new topic "${topic.title}"`);
-            return;
-          }
-          bindMapping(chatId, threadId, topic.id);
-          reply(chatId, threadId, `switched to new topic "${topic.title}"`);
-        } catch (err) {
-          if (err instanceof TopicValidationError) {
-            reply(chatId, threadId, err.message);
-          } else {
-            reply(chatId, threadId, errMsg(err, "topic create failed"));
-          }
-        }
-        return;
-      }
-      case "/load": {
-        if (!arg) {
-          reply(chatId, threadId, "usage: /load <topic>");
-          return;
-        }
-        const candidate = getTopicByNameForUser(arg, userId) ?? getTopic(arg);
-        const topic = candidate && isTopicVisible(candidate) ? candidate : null;
-        if (!topic || !loadExistingTopic(chatId, topic.id, threadId)) {
-          reply(chatId, threadId, `no visible topic matching "${arg}"`);
-          return;
-        }
-        reply(chatId, threadId, `loaded topic "${topic.title}"`);
-        return;
-      }
-      case "/unload": {
-        if (!unloadMapping(chatId, threadId)) {
-          reply(chatId, threadId, "this chat has no loaded topic");
-          return;
-        }
-        reply(chatId, threadId, "unloaded topic; the Negotium topic was preserved");
-        return;
-      }
-      case "/fork":
-      case "/spawn": {
-        const label = cmd.slice(1);
-        const mapping = byKey.get(mappingKey(chatId, threadId));
-        if (!mapping) {
-          reply(chatId, threadId, `nothing to ${label} \u2014 this chat has no topic yet`);
-          return;
-        }
-        const copyHistory = cmd === "/fork";
-        topicService.derive({
-          sourceTopicId: mapping.topicId,
-          userId,
-          copyHistory,
-          ...arg ? { name: arg } : {}
-        }).then((derived) => {
-          if (!derived) {
-            reply(chatId, threadId, `${label} failed`);
-            return;
-          }
-          reply(chatId, threadId, `${copyHistory ? "forked into" : "spawned"} "${derived.title}"`);
-        }).catch((err) => {
-          reply(chatId, threadId, err instanceof TopicTitleConflictError ? err.message : errMsg(err, `${label} failed`));
-        });
-        return;
-      }
-      case "/del":
-      case "/del!": {
-        const force = cmd === "/del!";
-        const mapping = byKey.get(mappingKey(chatId, threadId));
-        const topic = arg ? getTopicByNameForUser(arg, userId) : mapping ? getTopic(mapping.topicId) : null;
-        if (!topic) {
-          reply(chatId, threadId, arg ? `no topic named "${arg}"` : "this chat has no topic \u2014 usage: /del [name]");
-          return;
-        }
-        reply(chatId, threadId, `deleting topic "${topic.title}"\u2026`);
-        topicService.delete({ topicId: topic.id, userId, force }).catch((err) => {
-          if (err instanceof TopicArchiveRequiredError) {
-            reply(chatId, threadId, `delete blocked: archiving "${topic.title}" failed and deleting now would lose its history. ` + `Retry after fixing the archive, or force with: /del!${arg ? ` ${arg}` : ""}`);
-          } else {
-            reply(chatId, threadId, errMsg(err, "delete failed"));
-          }
-        });
-        return;
-      }
-      default:
-        reply(chatId, threadId, "commands: /new [name], /topics, /agent <claude|codex|maestro>, " + "/load <topic>, /unload, /fork [name], /spawn [name], " + "/del [name], /del! [name], /abort, /vault <list|set|del>");
-    }
-  }
-  function handleIncomingMessage(msg) {
-    if (stopped)
-      return;
-    const chatId = msg.chat.id;
-    const generalForumMessage = msg.chat.type === "supergroup" && msg.chat.is_forum === true && msg.is_topic_message !== true;
-    const threadId = generalForumMessage ? undefined : msg.message_thread_id;
-    const text = msg.text?.trim();
-    const hasMedia = Boolean(msg.photo?.length || msg.document || msg.voice);
-    const privateDm = msg.chat.type === "private";
-    const firstPrivateContact = privateDm && !byKey.has(mappingKey(chatId));
-    if (privateDm)
-      ownerDmChatIds.add(chatId);
-    if (privateDm || forumMode && chatId === forumChat && threadId === undefined) {
-      bindMapping(chatId, threadId, personalGeneral.id);
-    }
-    if (firstPrivateContact && text !== "/start") {
-      sendOnboardingGuide(chatId);
-    }
-    if (text?.startsWith("/")) {
-      const command = text.split(/\s+/, 1)[0]?.replace(/@\w+$/, "");
-      if (command === "/abort") {
-        handleCommand(text, chatId, threadId, msg.from?.id);
-      } else {
-        enqueueInbound(chatId, threadId, () => handleCommand(text, chatId, threadId, msg.from?.id));
-      }
-      return;
-    }
-    if (hasMedia) {
-      if (msg.media_group_id) {
-        bufferMediaGroup(msg, chatId, threadId);
-        return;
-      }
-      enqueueInbound(chatId, threadId, () => handleMediaMessage(msg, chatId, threadId));
-      return;
-    }
-    if (!text)
-      return;
-    enqueueInbound(chatId, threadId, () => runTurn(resolveMapping(chatId, threadId), text, chatId, threadId));
-  }
-  client.on("message", (msg) => {
-    if (stopped)
-      return;
-    if (!isAllowed(msg.from?.id))
-      return;
-    if (msg.chat.type === "supergroup" && msg.chat.is_forum) {
-      if (forumMode && msg.chat.id !== forumChat)
-        return;
-      if (!forumMode || !forumManageTopicsAvailable) {
-        tryAutoConnectFromMessage(msg).then((connected) => {
-          if (connected && !stopped)
-            handleIncomingMessage(msg);
-        });
-        return;
-      }
-    }
-    handleIncomingMessage(msg);
-  });
-  client.on("my_chat_member", (update) => {
-    if (stopped || update.chat.type !== "supergroup" || !update.chat.is_forum)
-      return;
-    const status = update.new_chat_member?.status;
-    if ((status === "left" || status === "kicked") && forumChat === update.chat.id) {
-      disconnectForum(update.chat.id).catch((err) => logger.warn({ err, groupId: update.chat.id }, "telegram adapter: forum disconnect failed"));
-      return;
-    }
-    if (forumMode && forumChat === update.chat.id && status !== "administrator" && status !== "creator") {
-      const permissionWasAvailable = forumManageTopicsAvailable;
-      forumManageTopicsAvailable = false;
-      if (permissionWasAvailable) {
-        notifyOwnerDms('The bot no longer has forum administrator access. Existing topics are preserved; restore administrator + "Manage Topics" to resume topic creation.');
-      }
-      return;
-    }
-    if (status !== "administrator" && status !== "creator" || update.from?.id === undefined || !isAllowed(update.from.id) && (!forumMode || forumChat !== update.chat.id)) {
-      return;
-    }
-    linkForumAndAnnounce(update.from.id, update.chat, update.new_chat_member).catch((err) => logger.warn({ err, groupId: update.chat.id }, "telegram adapter: forum auto-connect failed"));
-  });
-  const unsubscribe = runtimeBus().subscribe((event) => {
-    if (stopped)
-      return;
-    if (event.type === "topic-created" && forumMode) {
-      materializeTopic(event.payload);
-      return;
-    }
-    if (event.type === "topic-deleted") {
-      handleTopicDeleted(event.topicId);
-      return;
-    }
-    if (event.type === "message-updated") {
-      const payload = event.payload;
-      if (!payload.messageId || !payload.patch)
-        return;
-      if (payload.patch.deleted) {
-        deleteDeliveredRuntimeMessage(event.topicId, payload.messageId);
-        return;
-      }
-      const current = runtimeMessages.get(payload.messageId);
-      if (!current)
-        return;
-      const updated = { ...current, ...payload.patch };
-      runtimeMessages.set(payload.messageId, updated);
-      if (footerEnabled && payload.patch.usage && updated.authorId === "ai") {
-        const footer = renderTurnFooter(updated);
-        if (footer)
-          attachUpdatedFooter(event.topicId, payload.messageId, footer);
-      }
-      return;
-    }
-    if (event.type === "ai-status") {
-      const status = event.payload;
-      if (status?.kind === "ai_active" && typeof client.sendChatAction === "function") {
-        if (status.queryId)
-          startTypingHeartbeat(event.topicId, status.queryId);
-        else
-          sendTyping(event.topicId);
-      }
-      if (status?.queryId && (status.kind === "ai_done" || status.kind === "ai_error" || status.kind === "ai_aborted")) {
-        closeToolStatus(status.queryId);
-        stopTypingHeartbeat(status.queryId);
-        targetByQueryId.delete(status.queryId);
-        clearQueryDeliveryState(status.queryId);
-      }
-      if (status?.kind === "tool_call" && status.queryId && status.label) {
-        showToolStatus(event.topicId, status.queryId, status.label);
-      }
-      return;
-    }
-    if (event.type !== "message")
-      return;
-    const msg = event.payload;
-    if (msg.authorId === userId && msg.sourceAdapter === "telegram")
-      return;
-    if (msg.kind === "tool")
-      return;
-    if (!msg.text)
-      return;
-    const runtimeMessageId = msg.authorId === "ai" ? msg.id : undefined;
-    if (runtimeMessageId) {
-      runtimeMessages.set(runtimeMessageId, msg);
-      if (!msg.queryId) {
-        const timer = setTimeout(() => {
-          runtimeMessages.delete(runtimeMessageId);
-          deliveredByRuntimeMessageId.delete(runtimeMessageId);
-        }, 5 * 60000);
-        timer.unref?.();
-      }
-    }
-    const files = extractFileTagPaths(msg.text);
-    const rawText = files.length > 0 ? stripFileTags(msg.text) : msg.text;
-    const text = msg.authorId === userId && rawText ? `[From: User] ${rawText}` : rawText;
-    if (!text && files.length === 0)
-      return;
-    routeMessage(event.topicId, { text, files, runtimeMessageId }, msg.queryId);
-  });
-  if (forumMode) {
-    bindMapping(forumChat, undefined, personalGeneral.id);
-    materializeVisibleTopics();
-  }
-  return {
-    name: "telegram",
-    loadTopic: loadExistingTopic,
-    unloadTopic: unloadMapping,
-    stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      outboxWorker.stop();
-      for (const timer of typingHeartbeatByQueryId.values())
-        clearInterval(timer);
-      typingHeartbeatByQueryId.clear();
-      for (const queryId of toolStatusByQueryId.keys())
-        closeToolStatus(queryId);
-      for (const entry of mediaGroups.values()) {
-        clearTimeout(entry.timer);
-        entry.release();
-      }
-      mediaGroups.clear();
-      inboundQueues.clear();
-      unsubscribe();
-      store.close();
-    }
-  };
-}
-// ../../adapters/telegram/src/index.ts
-var telegramAdapter = defineNegotiumAdapter({
-  name: "telegram",
-  capabilities: {
-    localUserInput: true,
-    topicManagement: true,
-    externalPlacedTurn: false
-  },
-  projection: {
-    transcript: "live-only",
-    historyBackfill: false,
-    externalAuthors: "relayed"
-  },
-  start: startTelegramAdapter
-});
-
-// ../../adapters/telegram/src/cli.ts
-function startTelegramFromEnv() {
-  const token = process.env.TELEGRAM_BOT_TOKEN?.trim();
-  if (!token)
-    throw new Error("TELEGRAM_BOT_TOKEN is required");
-  const bot = new TelegramBot(token, { polling: true });
-  const requestedAgent = process.env.TELEGRAM_DEFAULT_AGENT?.trim();
-  const forumChatId = Number.parseInt(process.env.TELEGRAM_FORUM_CHAT_ID ?? "", 10);
-  const adapter = startTelegramAdapter({
-    client: bot,
-    allowedUsers: (process.env.TELEGRAM_ALLOWED_USERS ?? "").split(",").map((value) => value.trim()).filter(Boolean),
-    ...process.env.TELEGRAM_VAULT_OWNER_USER_ID?.trim() ? { vaultOwnerTelegramUserId: process.env.TELEGRAM_VAULT_OWNER_USER_ID.trim() } : {},
-    ...isAgentKind(requestedAgent) ? { defaultAgent: requestedAgent } : {},
-    ...Number.isFinite(forumChatId) ? { forumChatId } : {}
-  });
-  let stopped = false;
-  return {
-    name: "telegram",
-    adapter,
-    bot,
-    async stop() {
-      if (stopped)
-        return;
-      stopped = true;
-      await adapter.stop();
-      await bot.stopPolling({ cancel: true }).catch(() => {});
-    }
-  };
-}
-async function runTelegramCli() {
-  if (!process.env.TELEGRAM_BOT_TOKEN?.trim()) {
-    throw new Error("TELEGRAM_BOT_TOKEN is required");
-  }
-  let node;
-  const singleton = await waitForRequiredRuntimeProcessLease("adapter:telegram", {
-    workloadName: "Telegram adapter",
-    onLost: () => {
-      process.stderr.write(`negotium-telegram: singleton lease lost; shutting down
-`);
-      node?.stop();
-    }
-  });
-  try {
-    node = await startDefaultNode({ port: 0 });
-  } catch (error) {
-    singleton.stop();
-    throw error;
-  }
-  let channel;
-  try {
-    channel = startTelegramFromEnv();
-  } catch (error) {
-    await node.stop();
-    singleton.stop();
-    throw error;
-  }
-  onShutdown("telegram-channel", 100, () => channel.stop());
-  onShutdown("telegram-singleton", 90, () => singleton.stop());
-  process.stdout.write(`negotium Telegram adapter listening through node :${node.port}
-`);
-  await node.completed;
-}
-if (false) {}
-export {
-  startTelegramFromEnv,
-  runTelegramCli
-};
-
-//# debugId=42F29D9EFE4D3DE164756E2164756E21