omnius 1.0.43 → 1.0.44

package/dist/index.js

@@ -25710,7 +25710,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     bits2int_modN: "function"
   });
   ecdsaOpts = Object.assign({}, ecdsaOpts);
-  const randomBytes26 = ecdsaOpts.randomBytes || randomBytes7;
+  const randomBytes27 = ecdsaOpts.randomBytes || randomBytes7;
   const hmac2 = ecdsaOpts.hmac || ((key, msg) => hmac(hash, key, msg));
   const { Fp, Fn } = Point;
   const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
@@ -25852,7 +25852,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
       throw new Error("invalid private key");
     const seedArgs = [int2octets(d2), int2octets(h1int)];
     if (extraEntropy != null && extraEntropy !== false) {
-      const e2 = extraEntropy === true ? randomBytes26(lengths.secretKey) : extraEntropy;
+      const e2 = extraEntropy === true ? randomBytes27(lengths.secretKey) : extraEntropy;
       seedArgs.push(abytes(e2, void 0, "extraEntropy"));
     }
     const seed = concatBytes(...seedArgs);
@@ -62362,9 +62362,9 @@ var init_cookies = __esm({
 
 // ../node_modules/@libp2p/http-peer-id-auth/dist/src/utils.js
 function generateChallenge() {
-  const randomBytes26 = new Uint8Array(32);
-  crypto.getRandomValues(randomBytes26);
-  return toString2(randomBytes26, "base64urlpad");
+  const randomBytes27 = new Uint8Array(32);
+  crypto.getRandomValues(randomBytes27);
+  return toString2(randomBytes27, "base64urlpad");
 }
 function encodeAuthParams(params) {
   const encodedParams = Object.entries(params).map(([key, value2]) => `${key}="${value2}"`).join(", ");
@@ -234560,7 +234560,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes26, createHash: createHash28 } = __require("crypto");
+    var { randomBytes: randomBytes27, createHash: createHash28 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate2();
@@ -235090,7 +235090,7 @@ var require_websocket2 = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes26(16).toString("base64");
+      const key = randomBytes27(16).toString("base64");
       const request = isSecure ? https4.request : http6.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -553818,7 +553818,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes26, createHash: createHash28 } = __require("crypto");
+    var { randomBytes: randomBytes27, createHash: createHash28 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate3 = require_permessage_deflate3();
@@ -554348,7 +554348,7 @@ var require_websocket3 = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes26(16).toString("base64");
+      const key = randomBytes27(16).toString("base64");
       const request = isSecure ? https4.request : http6.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -555836,6 +555836,9 @@ var init_command_registry = __esm({
       ["/telegram personal <user_id> <limit>", "Fetch last messages from a user's profile personal chat"],
       ["/telegram access get <managed_bot_user_id>", "Show managed-bot access restriction settings"],
       ["/telegram access set <managed_bot_user_id> <restricted|open> [added_user_ids]", "Set managed-bot access restrictions"],
+      ["/telegram tools [group <chat>|panel <chat> [policy_chat]]", "Show unified Telegram tool policy or send inline admin toggle buttons"],
+      ["/telegram delete-message <chat> <message> [reason]", "Delete one Telegram message after policy and Bot API rights checks"],
+      ["/telegram delete-messages <chat> <message,message> [reason]", "Delete multiple Telegram messages after policy and Bot API rights checks"],
       ["/telegram delete-reaction <chat> <message> [--user <id>|--actor <chat>]", "Delete a Telegram message reaction"],
       ["/telegram delete-reactions <chat> [--user <id>|--actor <chat>]", "Delete recent Telegram message reactions by user or chat"],
       ["/platforms", "Show gateway platform state"],
@@ -582247,6 +582250,10 @@ function formatTelegramJsonResult(value2) {
   if (value2 === null || value2 === void 0) return "No data returned.";
   return JSON.stringify(value2, null, 2).slice(0, 3900);
 }
+function parseTelegramMessageIdList(value2) {
+  if (!value2) return [];
+  return [...new Set(value2.split(",").map((part) => Number(part.trim())).filter((num) => Number.isFinite(num)))];
+}
 async function runSudoScript(ctx3, script) {
   const stdinAny = process.stdin;
   const hadRaw = !!(stdinAny && stdinAny.isTTY && stdinAny.isRaw);
@@ -582740,11 +582747,11 @@ async function handleSlashCommand(input, ctx3) {
         }
         if (action === "new") {
           try {
-            const { randomBytes: randomBytes26 } = await import("node:crypto");
+            const { randomBytes: randomBytes27 } = await import("node:crypto");
             const { homedir: homedir48 } = await import("node:os");
             const { mkdirSync: mkdirSync79, writeFileSync: writeFileSync71 } = await import("node:fs");
             const { join: join144 } = await import("node:path");
-            const newKey = randomBytes26(16).toString("hex");
+            const newKey = randomBytes27(16).toString("hex");
             process.env["OMNIUS_API_KEY"] = newKey;
             const dir = join144(homedir48(), ".omnius");
             mkdirSync79(dir, { recursive: true });
@@ -583001,8 +583008,8 @@ async function handleSlashCommand(input, ctx3) {
           }
           process.env["OMNIUS_ACCESS"] = val2;
           if (val2 === "any" && !process.env["OMNIUS_API_KEY"]) {
-            const { randomBytes: randomBytes26 } = await import("node:crypto");
-            const apiKey = randomBytes26(16).toString("hex");
+            const { randomBytes: randomBytes27 } = await import("node:crypto");
+            const apiKey = randomBytes27(16).toString("hex");
             process.env["OMNIUS_API_KEY"] = apiKey;
             renderInfo(`Generated API key: ${c3.bold(c3.yellow(apiKey))}`);
             renderInfo(
@@ -583121,8 +583128,8 @@ async function handleSlashCommand(input, ctx3) {
       }
       process.env["OMNIUS_ACCESS"] = val;
       if (val === "any" && !process.env["OMNIUS_API_KEY"]) {
-        const { randomBytes: randomBytes26 } = await import("node:crypto");
-        const apiKey = randomBytes26(16).toString("hex");
+        const { randomBytes: randomBytes27 } = await import("node:crypto");
+        const apiKey = randomBytes27(16).toString("hex");
         process.env["OMNIUS_API_KEY"] = apiKey;
         renderInfo(`Generated API key: ${c3.bold(c3.yellow(apiKey))}`);
         renderInfo(
@@ -587367,6 +587374,73 @@ sleep 1
         }
         return "handled";
       }
+      if (parts[0] === "tools" || parts[0] === "tooling") {
+        if (parts[1] === "group" || parts[1] === "chat") {
+          const chatId = parseTelegramChatTarget(parts[2]);
+          if (!chatId) {
+            renderWarning("Usage: /telegram tools group <chat>");
+            return "handled";
+          }
+          const policy2 = ctx3.telegramGetToolPolicy?.() ?? {};
+          const override = policy2.chatOverrides?.[String(chatId)] ?? {};
+          renderInfo(`Unified Telegram tool policy override for chat ${String(chatId)}:`);
+          renderInfo(formatTelegramJsonResult(override));
+          renderInfo("Use /telegram tools panel <admin_dm_chat_id> <policy_chat> to edit this scope with buttons.");
+          return "handled";
+        }
+        if (parts[1] === "panel" || parts[1] === "buttons") {
+          const panelChatId = parseTelegramChatTarget(parts[2]);
+          const policyChatId = parts[3] && parts[3] !== "global" ? parseTelegramChatTarget(parts[3]) : void 0;
+          if (!panelChatId) {
+            renderWarning("Usage: /telegram tools panel <panel_chat> [policy_chat|global]");
+            return "handled";
+          }
+          try {
+            const result = await ctx3.telegramSendToolPanel?.(panelChatId, policyChatId ?? void 0);
+            renderInfo(formatTelegramJsonResult(result));
+          } catch (err) {
+            renderError(`Telegram tools panel failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          return "handled";
+        }
+        const policy = ctx3.telegramGetToolPolicy?.();
+        renderInfo("Unified Telegram tool policy:");
+        renderInfo(formatTelegramJsonResult(policy ?? {}));
+        renderInfo("Use /telegram tools panel <admin_dm_chat_id> [policy_chat] to send inline toggle buttons.");
+        return "handled";
+      }
+      if (parts[0] === "delete-message") {
+        const chatId = parseTelegramChatTarget(parts[1]);
+        const messageId = Number(parts[2]);
+        const reason = parts.slice(3).join(" ").trim() || "TUI admin delete-message command";
+        if (!chatId || !Number.isFinite(messageId)) {
+          renderWarning("Usage: /telegram delete-message <chat> <message_id> [reason]");
+          return "handled";
+        }
+        try {
+          const result = await ctx3.telegramDeleteMessage?.(chatId, messageId, reason);
+          renderInfo(formatTelegramJsonResult(result));
+        } catch (err) {
+          renderError(`Telegram delete message failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return "handled";
+      }
+      if (parts[0] === "delete-messages") {
+        const chatId = parseTelegramChatTarget(parts[1]);
+        const messageIds = parseTelegramMessageIdList(parts[2]);
+        const reason = parts.slice(3).join(" ").trim() || "TUI admin delete-messages command";
+        if (!chatId || messageIds.length === 0) {
+          renderWarning("Usage: /telegram delete-messages <chat> <message_id,message_id> [reason]");
+          return "handled";
+        }
+        try {
+          const result = await ctx3.telegramDeleteMessages?.(chatId, messageIds, reason);
+          renderInfo(formatTelegramJsonResult(result));
+        } catch (err) {
+          renderError(`Telegram delete messages failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return "handled";
+      }
       if (parts[0] === "delete-reaction") {
         const chatId = parseTelegramChatTarget(parts[1]);
         const messageId = Number(parts[2]);
@@ -587477,6 +587551,9 @@ sleep 1
       renderInfo("  /telegram admins <chat> [--bots]  List chat admins");
       renderInfo("  /telegram personal <user_id> <limit>  Fetch profile personal chat messages");
       renderInfo("  /telegram access get|set <managed_bot_user_id> ...  Manage bot access restriction");
+      renderInfo("  /telegram tools [group <chat>|panel <chat> [policy_chat]]  Show/send unified tool policy buttons");
+      renderInfo("  /telegram delete-message <chat> <msg> [reason]  Delete one message");
+      renderInfo("  /telegram delete-messages <chat> <msg,msg> [reason]  Delete multiple messages");
       renderInfo("  /telegram delete-reaction <chat> <msg> --user <id>  Delete a reaction");
       renderInfo("  /telegram delete-reactions <chat> --user <id>  Delete recent reactions");
       renderInfo("  Add --local to scope settings to this project only");
@@ -593681,11 +593758,11 @@ var init_commands = __esm({
           process.env["OMNIUS_ACCESS"] = val;
           if (val === "any" && !process.env["OMNIUS_API_KEY"]) {
             try {
-              const { randomBytes: randomBytes26 } = await import("node:crypto");
+              const { randomBytes: randomBytes27 } = await import("node:crypto");
               const { homedir: homedir48 } = await import("node:os");
               const { mkdirSync: mkdirSync79, writeFileSync: writeFileSync71 } = await import("node:fs");
               const { join: join144 } = await import("node:path");
-              const apiKey = randomBytes26(16).toString("hex");
+              const apiKey = randomBytes27(16).toString("hex");
               process.env["OMNIUS_API_KEY"] = apiKey;
               const dir = join144(homedir48(), ".omnius");
               mkdirSync79(dir, { recursive: true });
@@ -600540,6 +600617,7 @@ var init_tool_policy = __esm({
       "reminders",
       "explore_tools",
       "telegram_media_recent",
+      "telegram",
       "generate_image",
       "generate_audio",
       "generate_tts",
@@ -600572,6 +600650,7 @@ var init_tool_policy = __esm({
       "reminders",
       "explore_tools",
       "telegram_media_recent",
+      "telegram",
       "generate_image",
       "generate_audio",
       "generate_tts",
@@ -602825,7 +602904,7 @@ var init_vision_ingress = __esm({
 import { mkdirSync as mkdirSync63, existsSync as existsSync108, unlinkSync as unlinkSync21, readdirSync as readdirSync37, statSync as statSync36, statfsSync as statfsSync3, readFileSync as readFileSync88, writeFileSync as writeFileSync57 } from "node:fs";
 import { join as join123, resolve as resolve41, basename as basename27, relative as relative13, isAbsolute as isAbsolute7, extname as extname16 } from "node:path";
 import { writeFile as writeFileAsync } from "node:fs/promises";
-import { createHash as createHash23, randomInt } from "node:crypto";
+import { createHash as createHash23, randomBytes as randomBytes22, randomInt } from "node:crypto";
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   const cleaned = stripTelegramHiddenThinking(text).replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
   const jsonText = cleaned.startsWith("{") ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? "";
@@ -603809,6 +603888,23 @@ function normalizeTelegramUpdate(update2) {
     sourceUpdateType
   };
 }
+function normalizeTelegramCallbackQuery(update2) {
+  const callback = update2.callback_query;
+  if (!callback || typeof callback !== "object") return null;
+  const from3 = callback.from && typeof callback.from === "object" ? callback.from : {};
+  const message2 = callback.message && typeof callback.message === "object" ? callback.message : void 0;
+  const data = typeof callback.data === "string" ? callback.data : "";
+  if (!callback.id || !data) return null;
+  return {
+    id: String(callback.id),
+    fromUserId: telegramOptionalNumber(from3.id) ?? 0,
+    username: telegramOptionalString(from3.username) ?? "unknown",
+    firstName: telegramOptionalString(from3.first_name),
+    chatId: message2?.chat?.id !== void 0 ? normalizeTelegramChatId(message2.chat.id) : void 0,
+    messageId: telegramOptionalNumber(message2?.message_id),
+    data
+  };
+}
 function adaptTool5(tool, todoSessionId) {
   return {
     name: tool.name,
@@ -603951,7 +604047,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("⎿")} ${c3.red("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -603971,6 +604067,90 @@ var init_telegram_bridge = __esm({
     init_telegram_channel_dmn();
     init_telegram_reflection_corpus();
     init_telegram_reflection_extraction();
+    TELEGRAM_TOOL_ACTION_GROUPS = [
+      "read",
+      "message",
+      "media",
+      "janitorial",
+      "reaction",
+      "moderation",
+      "bot_admin",
+      "policy"
+    ];
+    TELEGRAM_TOOL_ACTION_GROUP = {
+      scope_status: "read",
+      get_tool_scope: "read",
+      get_me: "read",
+      get_chat: "read",
+      get_chat_member: "read",
+      get_chat_administrators: "read",
+      get_message_context: "read",
+      send_message: "message",
+      edit_message_text: "message",
+      edit_message_caption: "message",
+      edit_message_reply_markup: "message",
+      pin_message: "message",
+      unpin_message: "message",
+      unpin_all_messages: "message",
+      delete_message: "janitorial",
+      delete_messages: "janitorial",
+      send_file: "media",
+      send_photo: "media",
+      send_document: "media",
+      send_audio: "media",
+      send_voice: "media",
+      send_video: "media",
+      set_message_reaction: "reaction",
+      delete_message_reaction: "reaction",
+      delete_all_message_reactions: "reaction",
+      ban_chat_member: "moderation",
+      unban_chat_member: "moderation",
+      restrict_chat_member: "moderation",
+      promote_chat_member: "moderation",
+      set_chat_permissions: "moderation",
+      approve_chat_join_request: "moderation",
+      decline_chat_join_request: "moderation",
+      set_my_commands: "bot_admin",
+      get_my_commands: "bot_admin",
+      set_chat_menu_button: "bot_admin",
+      get_chat_menu_button: "bot_admin",
+      set_my_description: "bot_admin",
+      get_my_description: "bot_admin",
+      enable_action: "policy",
+      disable_action: "policy",
+      enable_group: "policy",
+      disable_group: "policy",
+      render_admin_buttons: "policy"
+    };
+    TELEGRAM_TOOL_MUTATING_GROUPS = /* @__PURE__ */ new Set([
+      "message",
+      "media",
+      "janitorial",
+      "reaction",
+      "moderation",
+      "bot_admin",
+      "policy"
+    ]);
+    DEFAULT_TELEGRAM_TOOL_GROUP_POLICY = {
+      read: true,
+      message: false,
+      media: true,
+      janitorial: false,
+      reaction: false,
+      moderation: false,
+      bot_admin: false,
+      policy: true
+    };
+    TELEGRAM_TOOL_BUTTON_LABELS = {
+      read: "Read",
+      message: "Send/Edit",
+      media: "Media",
+      janitorial: "Delete",
+      reaction: "Reactions",
+      moderation: "Moderation",
+      bot_admin: "Bot Admin",
+      policy: "Policy"
+    };
     TELEGRAM_SAFETY_PROMPT = `
 CRITICAL SAFETY NOTICE — PUBLIC TELEGRAM CHANNEL
 
@@ -604168,8 +604348,10 @@ Telegram response contract:
         this.agentConfig = agentConfig;
         this.repoRoot = repoRoot;
         this.toolPolicyConfig = toolPolicyConfig;
+        this.telegramToolPolicy = resolveSettings(repoRoot || ".").telegramToolPolicy ?? {};
         this.mediaCacheDir = resolve41(repoRoot || ".", ".omnius", "telegram-media-cache");
         this.telegramConversationDir = resolve41(repoRoot || ".", ".omnius", "telegram-conversations");
+        this.telegramToolButtonDir = resolve41(repoRoot || ".", ".omnius", "telegram-tool-buttons");
       }
       botToken;
       onMessage;
@@ -604212,6 +604394,14 @@ Telegram response contract:
       onSubAgentEvent = null;
       /** Tool policy config — user overrides from config */
       toolPolicyConfig;
+      /** Action-level policy for the unified Telegram tool */
+      telegramToolPolicy;
+      /** Cached bot id from getMe for permission checks */
+      botUserId = null;
+      /** Cached bot chat rights for mutation guard checks */
+      telegramBotRightsCache = /* @__PURE__ */ new Map();
+      /** Short-lived Telegram inline button state directory */
+      telegramToolButtonDir;
       /** Command handler for admin DM slash commands (wired from interactive.ts) */
       commandHandler = null;
       /** Callback fired after a Telegram user completes the TUI-only admin auth challenge */
@@ -604277,6 +604467,12 @@ Telegram response contract:
       setToolPolicyConfig(config) {
         this.toolPolicyConfig = config;
       }
+      setTelegramToolPolicy(policy) {
+        this.telegramToolPolicy = policy ?? {};
+      }
+      getTelegramToolPolicy() {
+        return this.cloneTelegramToolPolicy(this.telegramToolPolicy);
+      }
       /**
        * Set a command handler for admin DM slash commands.
        * When an admin sends a /command in DM, it gets routed through the TUI's
@@ -606079,6 +606275,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           messagesSent: 0,
           activeSubAgents: 0
         };
+        this.botUserId = typeof me.result?.id === "number" ? me.result.id : this.botUserId;
         this.polling = true;
         this.abortController = new AbortController();
         try {
@@ -606251,6 +606448,20 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           await this.handleTelegramReflectionSlash(msg, normalizedCommandText);
           return;
         }
+        if (msg.text.trim().startsWith("/") && (telegramSlash === "tools" || telegramSlash === "telegram_tools")) {
+          if (!isAdmin) {
+            await this.replyToTelegramMessage(msg, "Telegram tool controls require admin authentication.");
+            return;
+          }
+          const parts = normalizedCommandText.trim().split(/\s+/).slice(1);
+          const target = parts[0] === "chat" || parts[0] === "group" ? this.resolveTelegramFileTarget({ target: parts[1] }, msg.chatId, msg.chatType === "private", msg) : { ok: true, chatId: msg.chatType === "private" ? void 0 : msg.chatId };
+          if (!target.ok) {
+            await this.replyToTelegramMessage(msg, target.error);
+            return;
+          }
+          await this.sendTelegramToolPanel(msg.chatId, target.chatId);
+          return;
+        }
         if (!this.agentConfig || !this.repoRoot) {
           this.onMessage(msg);
           return;
@@ -607465,6 +607676,7 @@ Scoped workspace: ${scopedRoot}`,
           new SkillListTool(repoRoot),
           sharedSkillExtractTool,
           this.buildTelegramMediaRecentTool(chatId, msg),
+          this.buildTelegramTool(context2, repoRoot, chatId, msg),
           ...this.buildTelegramReminderTools(context2, repoRoot, chatId, msg)
         ];
         const adminTools = [
@@ -607527,6 +607739,7 @@ Scoped workspace: ${scopedRoot}`,
           new SkillListTool(repoRoot),
           new SkillExecuteTool(repoRoot),
           adminSkillExtractTool,
+          this.buildTelegramTool(context2, repoRoot, chatId, msg),
           ...this.buildTelegramReminderTools(context2, repoRoot, chatId, msg),
           fullSubAgentTool,
           this.buildTelegramSendFileTool(context2, repoRoot, chatId, msg)
@@ -607573,6 +607786,811 @@ Scoped workspace: ${scopedRoot}`,
         ]);
         return tools.filter((tool) => !blocked.has(tool.name));
       }
+      buildTelegramTool(context2, repoRoot, chatId, currentMsg) {
+        const bridge = this;
+        const adminDm = context2 === "telegram-admin-dm";
+        return {
+          name: "telegram",
+          description: [
+            "Unified scoped Telegram tool. Use action to inspect chat state, send messages/files, delete messages, manage reactions, or manage Telegram tool policy.",
+            "Deletion and moderation actions require authenticated admin context, Omnius Telegram tool policy enablement, current/known chat scoping, and Telegram bot rights.",
+            "Use scope_status before risky actions when uncertain. Use render_admin_buttons to show clickable admin toggles."
+          ].join(" "),
+          parameters: {
+            type: "object",
+            properties: {
+              action: {
+                type: "string",
+                enum: Object.keys(TELEGRAM_TOOL_ACTION_GROUP),
+                description: "Telegram action to perform."
+              },
+              target: {
+                type: "string",
+                description: adminDm ? "Optional target chat/user. Defaults to the current DM; known group chat ids are allowed." : "Current chat only for group/public contexts."
+              },
+              chat_id: { type: "string", description: "Alias for target." },
+              message_id: { type: "number", description: "Telegram message id for single-message actions." },
+              message_ids: {
+                type: "array",
+                items: { type: "number" },
+                description: "Telegram message ids for batch actions."
+              },
+              user_id: { type: "number", description: "Telegram user id for member/moderation/reaction actions." },
+              text: { type: "string", description: "Text for send/edit actions." },
+              caption: { type: "string", description: "Caption for media or caption edit actions." },
+              reply_markup: { type: "object", description: "Raw Telegram reply_markup object for edit_message_reply_markup." },
+              permissions: { type: "object", description: "Raw Telegram ChatPermissions object for restriction or default chat permissions." },
+              rights: { type: "object", description: "Raw Telegram admin-rights fields for promote_chat_member." },
+              reaction: { type: "array", items: { type: "object" }, description: "ReactionType array for set_message_reaction." },
+              commands: { type: "array", items: { type: "object" }, description: "Bot command objects for set_my_commands." },
+              menu_button: { type: "object", description: "Raw MenuButton object for set_chat_menu_button." },
+              description: { type: "string", description: "Bot description text for set_my_description." },
+              language_code: { type: "string", description: "Optional Telegram language code for bot command/description actions." },
+              until_date: { type: "number", description: "Unix timestamp for ban/restrict expiry." },
+              path: { type: "string", description: "File path for send_file; same scoping as telegram_send_file." },
+              kind: {
+                type: "string",
+                enum: ["auto", "image", "photo", "document", "audio", "voice", "video", "animation"],
+                description: "Media kind for send_file."
+              },
+              group: {
+                type: "string",
+                enum: TELEGRAM_TOOL_ACTION_GROUPS,
+                description: "Action group for enable_group/disable_group."
+              },
+              tool_action: { type: "string", description: "Action name for enable_action/disable_action." },
+              scope: { type: "string", enum: ["global", "chat"], description: "Policy scope for enable/disable actions." },
+              dry_run: { type: "boolean", description: "When true, validate and report without calling Telegram." },
+              reason: { type: "string", description: "Short audit reason for risky Telegram actions." }
+            },
+            required: ["action"]
+          },
+          async execute(args) {
+            const start2 = performance.now();
+            const action = String(args["action"] || "").trim().toLowerCase();
+            if (!action || !(action in TELEGRAM_TOOL_ACTION_GROUP)) {
+              return { success: false, output: "", error: `Unsupported Telegram action: ${action || "(missing)"}`, durationMs: performance.now() - start2 };
+            }
+            try {
+              const result = await bridge.executeTelegramToolAction(action, args, {
+                context: context2,
+                repoRoot,
+                chatId,
+                currentMsg
+              });
+              return {
+                success: true,
+                output: typeof result === "string" ? result : JSON.stringify(result, null, 2),
+                llmContent: typeof result === "string" ? result : JSON.stringify(result),
+                durationMs: performance.now() - start2,
+                mutated: TELEGRAM_TOOL_MUTATING_GROUPS.has(TELEGRAM_TOOL_ACTION_GROUP[action]),
+                mutatedFiles: []
+              };
+            } catch (err) {
+              return {
+                success: false,
+                output: "",
+                error: err instanceof Error ? err.message : String(err),
+                durationMs: performance.now() - start2
+              };
+            }
+          }
+        };
+      }
+      async executeTelegramToolAction(action, args, env2) {
+        const target = this.resolveTelegramFileTarget(args, env2.chatId, env2.context === "telegram-admin-dm", env2.currentMsg);
+        if (!target.ok && this.telegramToolHasExplicitTarget(args)) throw new Error(target.error);
+        const targetChatId = target.ok ? target.chatId : env2.chatId;
+        const gate = this.assertTelegramToolActionAllowed(action, env2.context, env2.currentMsg, targetChatId, args);
+        if (!gate.ok) throw new Error(gate.error);
+        const dryRun = this.telegramToolDryRun(args, targetChatId);
+        const messageId = this.telegramNumberArg(args["message_id"]);
+        const messageIds = this.telegramMessageIdsArg(args["message_ids"] ?? args["message_id"]);
+        const userId = this.telegramNumberArg(args["user_id"]);
+        if (!dryRun) {
+          await this.assertTelegramBotRightsForAction(action, targetChatId, messageIds, env2.currentMsg);
+        }
+        switch (action) {
+          case "scope_status":
+          case "get_tool_scope":
+            return this.formatTelegramToolScopeStatus(env2.context, env2.currentMsg, targetChatId);
+          case "get_me":
+            return this.telegramApiResult("getMe", {});
+          case "get_chat":
+            if (targetChatId === void 0) throw new Error("target/chat_id is required for get_chat.");
+            return this.telegramApiResult("getChat", { chat_id: targetChatId });
+          case "get_chat_member":
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id and user_id are required for get_chat_member.");
+            return this.telegramApiResult("getChatMember", { chat_id: targetChatId, user_id: userId });
+          case "get_chat_administrators":
+            if (targetChatId === void 0) throw new Error("target/chat_id is required for get_chat_administrators.");
+            return this.getChatAdministrators(targetChatId, args["return_bots"] === true);
+          case "get_message_context":
+            if (targetChatId === void 0) throw new Error("target/chat_id is required for get_message_context.");
+            return this.telegramMessageContext(targetChatId, messageId);
+          case "send_message": {
+            if (targetChatId === void 0) throw new Error("target/chat_id is required for send_message.");
+            const text = String(args["text"] || "").trim();
+            if (!text) throw new Error("text is required for send_message.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { text });
+            const sent = await this.sendMessage(targetChatId, text);
+            return { action, telegram_method: "sendMessage", ok: true, chat_id: targetChatId, message_id: sent };
+          }
+          case "edit_message_text": {
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for edit_message_text.");
+            const text = String(args["text"] || "").trim();
+            if (!text) throw new Error("text is required for edit_message_text.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId, text });
+            return this.telegramApiResult("editMessageText", { chat_id: targetChatId, message_id: messageId, text: convertMarkdownToTelegramHTML(text), parse_mode: "HTML" });
+          }
+          case "edit_message_caption": {
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for edit_message_caption.");
+            const caption = String(args["caption"] ?? args["text"] ?? "").trim();
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId, caption });
+            return this.telegramApiResult("editMessageCaption", { chat_id: targetChatId, message_id: messageId, caption: convertMarkdownToTelegramHTML(caption), parse_mode: "HTML" });
+          }
+          case "edit_message_reply_markup": {
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for edit_message_reply_markup.");
+            const replyMarkup = this.telegramObjectArg(args["reply_markup"]);
+            if (!replyMarkup) throw new Error("reply_markup object is required for edit_message_reply_markup.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId, reply_markup: replyMarkup });
+            return this.telegramApiResult("editMessageReplyMarkup", { chat_id: targetChatId, message_id: messageId, reply_markup: replyMarkup });
+          }
+          case "delete_message": {
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for delete_message.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId });
+            return this.deleteTelegramMessage(targetChatId, messageId, env2.currentMsg);
+          }
+          case "delete_messages": {
+            if (targetChatId === void 0 || messageIds.length === 0) throw new Error("target/chat_id and message_ids are required for delete_messages.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_ids: messageIds });
+            return this.deleteTelegramMessages(targetChatId, messageIds, env2.currentMsg);
+          }
+          case "pin_message":
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for pin_message.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId });
+            return this.telegramApiResult("pinChatMessage", { chat_id: targetChatId, message_id: messageId, disable_notification: args["disable_notification"] === true });
+          case "unpin_message":
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for unpin_message.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId });
+            return this.telegramApiResult("unpinChatMessage", { chat_id: targetChatId, message_id: messageId });
+          case "unpin_all_messages":
+            if (targetChatId === void 0) throw new Error("target/chat_id is required for unpin_all_messages.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, {});
+            return this.telegramApiResult("unpinAllChatMessages", { chat_id: targetChatId });
+          case "set_message_reaction":
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for set_message_reaction.");
+            if (!Array.isArray(args["reaction"])) throw new Error("reaction array is required for set_message_reaction.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId, reaction: args["reaction"] });
+            return this.telegramApiResult("setMessageReaction", {
+              chat_id: targetChatId,
+              message_id: messageId,
+              reaction: args["reaction"],
+              is_big: args["is_big"] === true
+            });
+          case "delete_message_reaction":
+            if (targetChatId === void 0 || messageId === void 0) throw new Error("target/chat_id and message_id are required for delete_message_reaction.");
+            if (userId === void 0 && args["actor_chat_id"] === void 0) throw new Error("user_id or actor_chat_id is required for delete_message_reaction.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { message_id: messageId, user_id: userId });
+            return { action, ok: await this.deleteMessageReaction(targetChatId, messageId, { userId, actorChatId: args["actor_chat_id"] }) };
+          case "delete_all_message_reactions":
+            if (targetChatId === void 0) throw new Error("target/chat_id is required for delete_all_message_reactions.");
+            if (userId === void 0 && args["actor_chat_id"] === void 0) throw new Error("user_id or actor_chat_id is required for delete_all_message_reactions.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId });
+            return { action, ok: await this.deleteAllMessageReactions(targetChatId, { userId, actorChatId: args["actor_chat_id"] }) };
+          case "send_file": {
+            const tool = this.buildTelegramSendFileTool(env2.context, env2.repoRoot, env2.chatId, env2.currentMsg);
+            const result = await tool.execute(args);
+            if (!result.success) throw new Error(result.error || result.output || "telegram send_file failed");
+            return { action, ok: true, output: result.output };
+          }
+          case "send_photo":
+          case "send_document":
+          case "send_audio":
+          case "send_voice":
+          case "send_video": {
+            const kind = action.slice("send_".length);
+            const tool = this.buildTelegramSendFileTool(env2.context, env2.repoRoot, env2.chatId, env2.currentMsg);
+            const result = await tool.execute({ ...args, kind });
+            if (!result.success) throw new Error(result.error || result.output || `telegram ${action} failed`);
+            return { action, ok: true, output: result.output };
+          }
+          case "ban_chat_member":
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id and user_id are required for ban_chat_member.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId });
+            return this.telegramApiResult("banChatMember", {
+              chat_id: targetChatId,
+              user_id: userId,
+              ...args["until_date"] !== void 0 ? { until_date: this.telegramNumberArg(args["until_date"]) } : {},
+              revoke_messages: args["revoke_messages"] === true
+            });
+          case "unban_chat_member":
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id and user_id are required for unban_chat_member.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId });
+            return this.telegramApiResult("unbanChatMember", {
+              chat_id: targetChatId,
+              user_id: userId,
+              only_if_banned: args["only_if_banned"] === true
+            });
+          case "restrict_chat_member": {
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id, user_id, and permissions are required for restrict_chat_member.");
+            const permissions = this.telegramObjectArg(args["permissions"]);
+            if (!permissions) throw new Error("permissions object is required for restrict_chat_member.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId, permissions });
+            return this.telegramApiResult("restrictChatMember", {
+              chat_id: targetChatId,
+              user_id: userId,
+              permissions,
+              ...args["until_date"] !== void 0 ? { until_date: this.telegramNumberArg(args["until_date"]) } : {},
+              use_independent_chat_permissions: args["use_independent_chat_permissions"] === true
+            });
+          }
+          case "promote_chat_member": {
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id, user_id, and rights are required for promote_chat_member.");
+            const rights = this.telegramObjectArg(args["rights"]);
+            if (!rights) throw new Error("rights object is required for promote_chat_member.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId, rights });
+            return this.telegramApiResult("promoteChatMember", { chat_id: targetChatId, user_id: userId, ...rights });
+          }
+          case "set_chat_permissions": {
+            if (targetChatId === void 0) throw new Error("target/chat_id and permissions are required for set_chat_permissions.");
+            const permissions = this.telegramObjectArg(args["permissions"]);
+            if (!permissions) throw new Error("permissions object is required for set_chat_permissions.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { permissions });
+            return this.telegramApiResult("setChatPermissions", {
+              chat_id: targetChatId,
+              permissions,
+              use_independent_chat_permissions: args["use_independent_chat_permissions"] === true
+            });
+          }
+          case "approve_chat_join_request":
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id and user_id are required for approve_chat_join_request.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId });
+            return this.telegramApiResult("approveChatJoinRequest", { chat_id: targetChatId, user_id: userId });
+          case "decline_chat_join_request":
+            if (targetChatId === void 0 || userId === void 0) throw new Error("target/chat_id and user_id are required for decline_chat_join_request.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId, { user_id: userId });
+            return this.telegramApiResult("declineChatJoinRequest", { chat_id: targetChatId, user_id: userId });
+          case "set_my_commands": {
+            if (!Array.isArray(args["commands"])) throw new Error("commands array is required for set_my_commands.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId ?? "bot", { commands: args["commands"] });
+            return this.telegramApiResult("setMyCommands", {
+              commands: args["commands"],
+              ...args["language_code"] ? { language_code: String(args["language_code"]) } : {}
+            });
+          }
+          case "get_my_commands":
+            return this.telegramApiResult("getMyCommands", args["language_code"] ? { language_code: String(args["language_code"]) } : {});
+          case "set_chat_menu_button": {
+            const menuButton = this.telegramObjectArg(args["menu_button"]);
+            if (!menuButton) throw new Error("menu_button object is required for set_chat_menu_button.");
+            if (dryRun) return this.telegramDryRun(action, targetChatId ?? "bot", { menu_button: menuButton });
+            return this.telegramApiResult("setChatMenuButton", {
+              ...targetChatId !== void 0 ? { chat_id: targetChatId } : {},
+              menu_button: menuButton
+            });
+          }
+          case "get_chat_menu_button":
+            return this.telegramApiResult("getChatMenuButton", targetChatId !== void 0 ? { chat_id: targetChatId } : {});
+          case "set_my_description": {
+            const description = String(args["description"] ?? args["text"] ?? "");
+            if (dryRun) return this.telegramDryRun(action, targetChatId ?? "bot", { description });
+            return this.telegramApiResult("setMyDescription", {
+              description,
+              ...args["language_code"] ? { language_code: String(args["language_code"]) } : {}
+            });
+          }
+          case "get_my_description":
+            return this.telegramApiResult("getMyDescription", args["language_code"] ? { language_code: String(args["language_code"]) } : {});
+          case "enable_group":
+          case "disable_group":
+            return this.setTelegramToolGroupPolicy(args, action === "enable_group", targetChatId);
+          case "enable_action":
+          case "disable_action":
+            return this.setTelegramToolActionPolicy(args, action === "enable_action", targetChatId);
+          case "render_admin_buttons":
+            if (!env2.currentMsg) throw new Error("render_admin_buttons requires a Telegram message context.");
+            if (dryRun) return this.telegramDryRun(action, env2.currentMsg.chatId, {});
+            return this.sendTelegramToolPanel(env2.currentMsg.chatId, String(args["scope"] || "").toLowerCase() === "chat" ? targetChatId : void 0);
+          default:
+            throw new Error(`Unsupported Telegram action: ${action}`);
+        }
+      }
+      cloneTelegramToolPolicy(policy) {
+        return JSON.parse(JSON.stringify(policy ?? {}));
+      }
+      telegramToolHasExplicitTarget(args) {
+        return ["target", "chat_id", "target_chat_id", "username"].some((key) => {
+          const value2 = args[key];
+          return value2 !== void 0 && String(value2).trim() !== "";
+        });
+      }
+      telegramObjectArg(value2) {
+        if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) return void 0;
+        return value2;
+      }
+      telegramNumberArg(value2) {
+        if (typeof value2 === "number" && Number.isFinite(value2)) return Math.trunc(value2);
+        if (typeof value2 === "string" && /^-?\d+$/.test(value2.trim())) return Number(value2.trim());
+        return void 0;
+      }
+      telegramMessageIdsArg(value2) {
+        if (Array.isArray(value2)) {
+          return [...new Set(value2.map((item) => this.telegramNumberArg(item)).filter((item) => item !== void 0))];
+        }
+        if (typeof value2 === "string" && value2.includes(",")) {
+          return [...new Set(value2.split(",").map((item) => this.telegramNumberArg(item.trim())).filter((item) => item !== void 0))];
+        }
+        const single = this.telegramNumberArg(value2);
+        return single === void 0 ? [] : [single];
+      }
+      effectiveTelegramToolPolicy(chatId) {
+        const base3 = this.cloneTelegramToolPolicy(this.telegramToolPolicy);
+        const override = chatId !== void 0 ? base3.chatOverrides?.[String(chatId)] : void 0;
+        if (!override) return base3;
+        return {
+          ...base3,
+          enabledActionGroups: {
+            ...base3.enabledActionGroups ?? {},
+            ...override.enabledActionGroups ?? {}
+          },
+          enabledActions: {
+            ...base3.enabledActions ?? {},
+            ...override.enabledActions ?? {}
+          },
+          requireAdminForMutation: override.requireAdminForMutation ?? base3.requireAdminForMutation,
+          dryRunByDefault: override.dryRunByDefault ?? base3.dryRunByDefault
+        };
+      }
+      telegramToolActionEnabled(action, chatId) {
+        const group = TELEGRAM_TOOL_ACTION_GROUP[action];
+        if (!group) return false;
+        const policy = this.effectiveTelegramToolPolicy(chatId);
+        const actionOverride = policy.enabledActions?.[action];
+        if (actionOverride !== void 0) return actionOverride;
+        const groupOverride = policy.enabledActionGroups?.[group];
+        if (groupOverride !== void 0) return groupOverride;
+        return DEFAULT_TELEGRAM_TOOL_GROUP_POLICY[group];
+      }
+      telegramToolDryRun(args, chatId) {
+        if (args["dry_run"] === true) return true;
+        if (args["dry_run"] === false) return false;
+        return this.effectiveTelegramToolPolicy(chatId).dryRunByDefault === true;
+      }
+      isAdminActor(userId, username) {
+        if (!this.adminUserId) return false;
+        if (userId !== void 0 && String(userId) === this.adminUserId) return true;
+        return Boolean(username && username === this.adminUserId);
+      }
+      assertTelegramToolActionAllowed(action, context2, currentMsg, targetChatId, args) {
+        const group = TELEGRAM_TOOL_ACTION_GROUP[action];
+        if (!group) return { ok: false, error: `Unsupported Telegram action: ${action}` };
+        const currentChatId = currentMsg?.chatId;
+        const isCurrentChat = currentChatId === void 0 || targetChatId === void 0 || String(currentChatId) === String(targetChatId);
+        const allowedPrivateSharedGroupMedia = group === "media" && currentMsg?.chatType === "private";
+        if (context2 !== "telegram-admin-dm" && !isCurrentChat && !allowedPrivateSharedGroupMedia) {
+          return { ok: false, error: "This Telegram context can only target the current chat." };
+        }
+        if (context2 === "telegram-public" && (group === "janitorial" || group === "reaction" || group === "moderation" || group === "bot_admin" || group === "policy" || group === "message")) {
+          return { ok: false, error: `Telegram ${group} actions require authenticated admin context.` };
+        }
+        if ((group === "policy" || group === "bot_admin" || group === "moderation") && context2 !== "telegram-admin-dm" && context2 !== "telegram-admin-group") {
+          return { ok: false, error: `Telegram ${group} actions require admin context.` };
+        }
+        const mutating = TELEGRAM_TOOL_MUTATING_GROUPS.has(group);
+        const policy = this.effectiveTelegramToolPolicy(targetChatId);
+        if (mutating && policy.requireAdminForMutation !== false && context2 === "telegram-public" && group !== "media") {
+          return { ok: false, error: "Telegram mutation requires admin context by policy." };
+        }
+        if (!this.telegramToolActionEnabled(action, targetChatId)) {
+          const scope = targetChatId !== void 0 && this.telegramToolPolicy.chatOverrides?.[String(targetChatId)] ? `chat ${String(targetChatId)}` : "global/default";
+          return { ok: false, error: `Telegram action ${action} is disabled by ${scope} policy. Enable ${group} or ${action} first.` };
+        }
+        if ((action === "delete_messages" || group === "moderation") && !String(args["reason"] || "").trim()) {
+          return { ok: false, error: `Telegram ${action} requires a short reason for the audit trail.` };
+        }
+        return { ok: true };
+      }
+      formatTelegramToolScopeStatus(context2, currentMsg, targetChatId) {
+        const effective = this.effectiveTelegramToolPolicy(targetChatId);
+        const groups = TELEGRAM_TOOL_ACTION_GROUPS.map((group) => ({
+          group,
+          enabled: effective.enabledActionGroups?.[group] ?? DEFAULT_TELEGRAM_TOOL_GROUP_POLICY[group],
+          default: DEFAULT_TELEGRAM_TOOL_GROUP_POLICY[group]
+        }));
+        const knownTargets = context2 === "telegram-admin-dm" ? this.knownTelegramChatTargets().slice(0, 12).map((target) => ({
+          chat_id: target.chatId,
+          chat_type: target.chatType,
+          title: target.title,
+          session: target.sessionKey
+        })) : [];
+        return {
+          context: context2,
+          current_chat_id: currentMsg?.chatId,
+          current_chat_type: currentMsg?.chatType,
+          target_chat_id: targetChatId,
+          bot_username: this.state.botUsername || void 0,
+          admin_configured: Boolean(this.adminUserId),
+          effective_policy: {
+            groups,
+            enabled_actions: effective.enabledActions ?? {},
+            dry_run_by_default: effective.dryRunByDefault === true,
+            require_admin_for_mutation: effective.requireAdminForMutation !== false
+          },
+          known_targets: knownTargets
+        };
+      }
+      telegramMessageContext(chatId, messageId) {
+        this.ensureAllTelegramConversationsLoaded();
+        const sessionKey = `chat:${String(chatId)}`;
+        const history = this.chatHistory.get(sessionKey) ?? [];
+        if (messageId === void 0) {
+          return {
+            chat_id: chatId,
+            recent: history.slice(-20)
+          };
+        }
+        const index = history.findIndex((entry) => entry.messageId === messageId);
+        if (index === -1) {
+          return {
+            chat_id: chatId,
+            message_id: messageId,
+            found: false,
+            recent: history.slice(-10)
+          };
+        }
+        return {
+          chat_id: chatId,
+          message_id: messageId,
+          found: true,
+          before: history.slice(Math.max(0, index - 5), index),
+          message: history[index],
+          after: history.slice(index + 1, index + 6)
+        };
+      }
+      telegramDryRun(action, chatId, detail) {
+        return {
+          action,
+          dry_run: true,
+          ok: true,
+          chat_id: chatId,
+          would_call_telegram: true,
+          detail,
+          policy_scope: this.telegramToolPolicy.chatOverrides?.[String(chatId)] ? "chat" : "global/default"
+        };
+      }
+      async telegramApiResult(method, body) {
+        const result = await this.apiCall(method, body);
+        if (!result.ok) throw new Error(String(result.description || `Telegram ${method} failed`));
+        if (method.startsWith("send") || method === "copyMessage" || method === "forwardMessage") this.state.messagesSent++;
+        return {
+          telegram_method: method,
+          ok: true,
+          result: result.result ?? true
+        };
+      }
+      async getTelegramBotUserId() {
+        if (this.botUserId !== null) return this.botUserId;
+        const result = await this.apiCall("getMe", {});
+        if (!result.ok || typeof result.result?.id !== "number") {
+          throw new Error(String(result.description || "Telegram getMe did not return a bot id."));
+        }
+        const botId = result.result.id;
+        this.botUserId = botId;
+        if (typeof result.result.username === "string") this.state.botUsername = result.result.username;
+        return botId;
+      }
+      async getChatMember(chatId, userId) {
+        const result = await this.apiCall("getChatMember", { chat_id: chatId, user_id: userId });
+        if (!result.ok) return null;
+        return result.result && typeof result.result === "object" ? result.result : null;
+      }
+      async getBotChatRights(chatId, force = false) {
+        const key = String(chatId);
+        const cached = this.telegramBotRightsCache.get(key);
+        if (!force && cached && Date.now() - cached.checkedAt < 6e4) return cached;
+        const botId = await this.getTelegramBotUserId();
+        const member = await this.getChatMember(chatId, botId);
+        if (!member) throw new Error(`Could not inspect Telegram bot rights for chat ${String(chatId)}.`);
+        const status = String(member.status || "unknown");
+        const rights = {
+          chatId,
+          status,
+          isCreator: status === "creator",
+          isAdministrator: status === "creator" || status === "administrator",
+          canDeleteMessages: status === "creator" || member.can_delete_messages === true,
+          canPinMessages: status === "creator" || member.can_pin_messages === true,
+          canRestrictMembers: status === "creator" || member.can_restrict_members === true,
+          canPromoteMembers: status === "creator" || member.can_promote_members === true,
+          canManageChat: status === "creator" || member.can_manage_chat === true,
+          canChangeInfo: status === "creator" || member.can_change_info === true,
+          checkedAt: Date.now(),
+          raw: member
+        };
+        this.telegramBotRightsCache.set(key, rights);
+        return rights;
+      }
+      isKnownAssistantTelegramMessage(chatId, messageId) {
+        this.ensureAllTelegramConversationsLoaded();
+        for (const history of this.chatHistory.values()) {
+          if (history.some((entry) => entry.role === "assistant" && String(entry.chatId) === String(chatId) && entry.messageId === messageId)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      telegramTargetLooksPrivate(chatId, currentMsg) {
+        if (currentMsg && String(currentMsg.chatId) === String(chatId) && currentMsg.chatType === "private") return true;
+        return typeof chatId === "number" && chatId > 0;
+      }
+      async assertTelegramBotRightsForAction(action, chatId, messageIds, currentMsg) {
+        if (chatId === void 0) return;
+        const group = TELEGRAM_TOOL_ACTION_GROUP[action];
+        if (!group || group === "read" || group === "media" || group === "policy" || group === "bot_admin") return;
+        if (group === "message" && action !== "pin_message" && action !== "unpin_message" && action !== "unpin_all_messages") return;
+        if (this.telegramTargetLooksPrivate(chatId, currentMsg)) return;
+        if (action === "delete_message" || action === "delete_messages") {
+          if (messageIds.length > 0 && messageIds.every((id) => this.isKnownAssistantTelegramMessage(chatId, id))) return;
+          const rights2 = await this.getBotChatRights(chatId);
+          if (!rights2.canDeleteMessages) {
+            throw new Error(`Bot lacks can_delete_messages in chat ${String(chatId)}; Telegram status=${rights2.status}.`);
+          }
+          return;
+        }
+        const rights = await this.getBotChatRights(chatId);
+        if ((action === "pin_message" || action === "unpin_message" || action === "unpin_all_messages") && !rights.canPinMessages && !rights.canManageChat) {
+          throw new Error(`Bot lacks pin/manage rights in chat ${String(chatId)}; Telegram status=${rights.status}.`);
+        }
+        if ((action === "ban_chat_member" || action === "unban_chat_member" || action === "restrict_chat_member" || action === "set_chat_permissions" || action === "approve_chat_join_request" || action === "decline_chat_join_request") && !rights.canRestrictMembers) {
+          throw new Error(`Bot lacks restrict/member management rights in chat ${String(chatId)}; Telegram status=${rights.status}.`);
+        }
+        if (action === "promote_chat_member" && !rights.canPromoteMembers) {
+          throw new Error(`Bot lacks promote rights in chat ${String(chatId)}; Telegram status=${rights.status}.`);
+        }
+      }
+      async deleteTelegramMessage(chatId, messageId, currentMsg) {
+        await this.assertTelegramBotRightsForAction("delete_message", chatId, [messageId], currentMsg);
+        const result = await this.apiCall("deleteMessage", { chat_id: chatId, message_id: messageId });
+        if (!result.ok) throw new Error(String(result.description || "Telegram deleteMessage failed"));
+        return {
+          action: "delete_message",
+          telegram_method: "deleteMessage",
+          ok: true,
+          chat_id: chatId,
+          message_id: messageId,
+          bot_rights_checked: !this.telegramTargetLooksPrivate(chatId, currentMsg) && !this.isKnownAssistantTelegramMessage(chatId, messageId),
+          policy_scope: this.telegramToolPolicy.chatOverrides?.[String(chatId)] ? "chat" : "global/default"
+        };
+      }
+      async deleteTelegramMessages(chatId, messageIds, currentMsg) {
+        const unique = [...new Set(messageIds)].filter((id) => Number.isFinite(id));
+        if (unique.length === 0) throw new Error("deleteTelegramMessages requires at least one message id.");
+        await this.assertTelegramBotRightsForAction("delete_messages", chatId, unique, currentMsg);
+        const chunks = [];
+        for (let idx = 0; idx < unique.length; idx += 100) chunks.push(unique.slice(idx, idx + 100));
+        const results = [];
+        for (const chunk of chunks) {
+          const result = await this.apiCall("deleteMessages", { chat_id: chatId, message_ids: chunk });
+          if (!result.ok) throw new Error(String(result.description || "Telegram deleteMessages failed"));
+          results.push({ message_ids: chunk, ok: true });
+        }
+        return {
+          action: "delete_messages",
+          telegram_method: "deleteMessages",
+          ok: true,
+          chat_id: chatId,
+          message_ids: unique,
+          batches: results,
+          bot_rights_checked: !this.telegramTargetLooksPrivate(chatId, currentMsg) && !unique.every((id) => this.isKnownAssistantTelegramMessage(chatId, id)),
+          policy_scope: this.telegramToolPolicy.chatOverrides?.[String(chatId)] ? "chat" : "global/default"
+        };
+      }
+      telegramToolPolicyTarget(args, targetChatId) {
+        const requested = String(args["scope"] || "").trim().toLowerCase();
+        if (requested === "chat" || targetChatId !== void 0 && this.telegramToolHasExplicitTarget(args)) {
+          if (targetChatId === void 0) throw new Error("scope=chat requires target/chat_id.");
+          return { scope: "chat", chatId: targetChatId };
+        }
+        return { scope: "global" };
+      }
+      persistTelegramToolPolicy() {
+        if (!this.repoRoot) return;
+        saveProjectSettings(this.repoRoot, { telegramToolPolicy: this.cloneTelegramToolPolicy(this.telegramToolPolicy) });
+      }
+      setTelegramToolGroupPolicy(args, enabled2, targetChatId) {
+        const group = String(args["group"] || "").trim().toLowerCase();
+        if (!TELEGRAM_TOOL_ACTION_GROUPS.includes(group)) throw new Error(`Unknown Telegram action group: ${group || "(missing)"}`);
+        const target = this.telegramToolPolicyTarget(args, targetChatId);
+        if (target.scope === "chat") {
+          const key = String(target.chatId);
+          this.telegramToolPolicy.chatOverrides ??= {};
+          const override = this.telegramToolPolicy.chatOverrides[key] ?? {};
+          override.enabledActionGroups = { ...override.enabledActionGroups ?? {}, [group]: enabled2 };
+          this.telegramToolPolicy.chatOverrides[key] = override;
+        } else {
+          this.telegramToolPolicy.enabledActionGroups = { ...this.telegramToolPolicy.enabledActionGroups ?? {}, [group]: enabled2 };
+        }
+        this.persistTelegramToolPolicy();
+        return { ok: true, action: enabled2 ? "enable_group" : "disable_group", group, scope: target.scope, chat_id: target.chatId, enabled: enabled2 };
+      }
+      setTelegramToolActionPolicy(args, enabled2, targetChatId) {
+        const toolAction = String(args["tool_action"] ?? args["telegram_action"] ?? "").trim().toLowerCase();
+        if (!toolAction || !(toolAction in TELEGRAM_TOOL_ACTION_GROUP)) throw new Error(`Unknown Telegram action: ${toolAction || "(missing)"}`);
+        const target = this.telegramToolPolicyTarget(args, targetChatId);
+        if (target.scope === "chat") {
+          const key = String(target.chatId);
+          this.telegramToolPolicy.chatOverrides ??= {};
+          const override = this.telegramToolPolicy.chatOverrides[key] ?? {};
+          override.enabledActions = { ...override.enabledActions ?? {}, [toolAction]: enabled2 };
+          this.telegramToolPolicy.chatOverrides[key] = override;
+        } else {
+          this.telegramToolPolicy.enabledActions = { ...this.telegramToolPolicy.enabledActions ?? {}, [toolAction]: enabled2 };
+        }
+        this.persistTelegramToolPolicy();
+        return { ok: true, action: enabled2 ? "enable_action" : "disable_action", tool_action: toolAction, scope: target.scope, chat_id: target.chatId, enabled: enabled2 };
+      }
+      telegramToolButtonPath(nonce) {
+        const safe = nonce.replace(/[^A-Za-z0-9_-]/g, "");
+        return join123(this.telegramToolButtonDir, `${safe}.json`);
+      }
+      writeTelegramToolButtonState(state) {
+        mkdirSync63(this.telegramToolButtonDir, { recursive: true });
+        writeFileSync57(this.telegramToolButtonPath(state.nonce), JSON.stringify(state, null, 2) + "\n", "utf-8");
+      }
+      readTelegramToolButtonState(nonce) {
+        try {
+          const parsed = JSON.parse(readFileSync88(this.telegramToolButtonPath(nonce), "utf-8"));
+          if (!parsed || parsed.expiresAt < Date.now()) return null;
+          return parsed;
+        } catch {
+          return null;
+        }
+      }
+      telegramToolPanelPayload(state) {
+        const policyChatId = state.policyScope === "chat" ? state.policyChatId : void 0;
+        const effective = this.effectiveTelegramToolPolicy(policyChatId);
+        const rows = TELEGRAM_TOOL_ACTION_GROUPS.map((group) => {
+          const enabled2 = effective.enabledActionGroups?.[group] ?? DEFAULT_TELEGRAM_TOOL_GROUP_POLICY[group];
+          return {
+            text: `${enabled2 ? "[x]" : "[ ]"} ${TELEGRAM_TOOL_BUTTON_LABELS[group]}`,
+            callback_data: `omni:v1:tgtool:${state.nonce}:group:${group}`
+          };
+        });
+        const dryRun = effective.dryRunByDefault === true;
+        const requireAdmin = effective.requireAdminForMutation !== false;
+        const keyboard = [];
+        for (let idx = 0; idx < rows.length; idx += 2) keyboard.push(rows.slice(idx, idx + 2));
+        keyboard.push([
+          { text: `${dryRun ? "[x]" : "[ ]"} Dry run`, callback_data: `omni:v1:tgtool:${state.nonce}:flag:dryrun` },
+          { text: `${requireAdmin ? "[x]" : "[ ]"} Admin mutations`, callback_data: `omni:v1:tgtool:${state.nonce}:flag:admin` }
+        ]);
+        const scopeLabel = state.policyScope === "chat" ? `chat ${String(state.policyChatId)}` : "global";
+        return {
+          text: [
+            "<b>Telegram tool controls</b>",
+            `Scope: <code>${escapeTelegramHTML(scopeLabel)}</code>`,
+            "Buttons toggle Omnius policy only. Telegram bot admin rights are still checked before privileged Bot API calls."
+          ].join("\n"),
+          reply_markup: { inline_keyboard: keyboard }
+        };
+      }
+      async sendTelegramToolPanel(panelChatId, policyChatId) {
+        const state = {
+          nonce: randomBytes22(8).toString("hex"),
+          createdAt: Date.now(),
+          expiresAt: Date.now() + 15 * 6e4,
+          panelChatId,
+          policyScope: policyChatId === void 0 ? "global" : "chat",
+          policyChatId
+        };
+        const payload = this.telegramToolPanelPayload(state);
+        const result = await this.apiCall("sendMessage", {
+          chat_id: panelChatId,
+          text: payload.text,
+          parse_mode: "HTML",
+          reply_markup: payload.reply_markup
+        });
+        if (!result.ok) throw new Error(String(result.description || "Telegram sendMessage failed"));
+        this.state.messagesSent++;
+        state.messageId = result.result?.message_id;
+        this.writeTelegramToolButtonState(state);
+        return {
+          action: "render_admin_buttons",
+          telegram_method: "sendMessage",
+          ok: true,
+          chat_id: panelChatId,
+          message_id: state.messageId,
+          policy_scope: state.policyScope,
+          policy_chat_id: state.policyChatId
+        };
+      }
+      async answerCallbackQuery(callbackQueryId, text, showAlert = false) {
+        const result = await this.apiCall("answerCallbackQuery", {
+          callback_query_id: callbackQueryId,
+          ...text ? { text } : {},
+          show_alert: showAlert
+        });
+        return Boolean(result.ok);
+      }
+      async handleTelegramCallbackQuery(callback) {
+        let answerText = "Updated.";
+        let alert = false;
+        try {
+          if (!this.isAdminActor(callback.fromUserId, callback.username)) {
+            answerText = "Only the configured Omnius Telegram admin can change tool policy.";
+            alert = true;
+            return;
+          }
+          const parts = callback.data.split(":");
+          if (parts.length !== 6 || parts[0] !== "omni" || parts[1] !== "v1" || parts[2] !== "tgtool") {
+            answerText = "Unknown Omnius Telegram control.";
+            alert = true;
+            return;
+          }
+          const state = this.readTelegramToolButtonState(parts[3] ?? "");
+          if (!state) {
+            answerText = "This Telegram tool panel expired. Open a new one with /telegram tools.";
+            alert = true;
+            return;
+          }
+          const kind = parts[4];
+          const value2 = parts[5];
+          if (kind === "group") {
+            const group = value2;
+            if (!TELEGRAM_TOOL_ACTION_GROUPS.includes(group)) throw new Error(`Unknown group: ${value2}`);
+            const policy = this.effectiveTelegramToolPolicy(state.policyChatId);
+            const enabled2 = !(policy.enabledActionGroups?.[group] ?? DEFAULT_TELEGRAM_TOOL_GROUP_POLICY[group]);
+            this.setTelegramToolGroupPolicy(
+              { group, scope: state.policyScope, ...state.policyChatId !== void 0 ? { target: String(state.policyChatId) } : {} },
+              enabled2,
+              state.policyChatId
+            );
+            answerText = `${TELEGRAM_TOOL_BUTTON_LABELS[group]} ${enabled2 ? "enabled" : "disabled"}.`;
+          } else if (kind === "flag" && value2 === "dryrun") {
+            this.setTelegramToolBooleanPolicy(state, "dryRunByDefault", this.effectiveTelegramToolPolicy(state.policyChatId).dryRunByDefault !== true);
+            answerText = "Dry-run default toggled.";
+          } else if (kind === "flag" && value2 === "admin") {
+            this.setTelegramToolBooleanPolicy(state, "requireAdminForMutation", this.effectiveTelegramToolPolicy(state.policyChatId).requireAdminForMutation === false);
+            answerText = "Admin mutation requirement toggled.";
+          } else {
+            throw new Error("Unsupported Telegram tool panel action.");
+          }
+          const messageId = state.messageId ?? callback.messageId;
+          if (messageId !== void 0) {
+            const payload = this.telegramToolPanelPayload(state);
+            await this.apiCall("editMessageText", {
+              chat_id: state.panelChatId,
+              message_id: messageId,
+              text: payload.text,
+              parse_mode: "HTML",
+              reply_markup: payload.reply_markup
+            });
+          }
+        } catch (err) {
+          answerText = err instanceof Error ? err.message : String(err);
+          alert = true;
+        } finally {
+          await this.answerCallbackQuery(callback.id, answerText.slice(0, 180), alert).catch(() => false);
+        }
+      }
+      async runTelegramToolActionForAdmin(action, args) {
+        return this.executeTelegramToolAction(action.trim().toLowerCase(), { ...args, action }, {
+          context: "telegram-admin-dm",
+          repoRoot: this.repoRoot ?? "."
+        });
+      }
+      setTelegramToolBooleanPolicy(state, key, value2) {
+        if (state.policyScope === "chat" && state.policyChatId !== void 0) {
+          const chatKey = String(state.policyChatId);
+          this.telegramToolPolicy.chatOverrides ??= {};
+          const override = this.telegramToolPolicy.chatOverrides[chatKey] ?? {};
+          override[key] = value2;
+          this.telegramToolPolicy.chatOverrides[chatKey] = override;
+        } else {
+          this.telegramToolPolicy[key] = value2;
+        }
+        this.persistTelegramToolPolicy();
+      }
       buildTelegramReminderTool(context2, repoRoot, chatId, currentMsg) {
         const rawChatId = String(chatId ?? currentMsg?.chatId ?? "unknown");
         const isPrivate2 = currentMsg?.chatType === "private";
@@ -607744,6 +608762,10 @@ Scoped workspace: ${scopedRoot}`,
             if (!target.ok) {
               return { success: false, output: "", error: target.error, durationMs: performance.now() - start2 };
             }
+            const gate = bridge.assertTelegramToolActionAllowed("send_file", context2, currentMsg, target.chatId, args);
+            if (!gate.ok) {
+              return { success: false, output: "", error: gate.error, durationMs: performance.now() - start2 };
+            }
             const file = bridge.resolveTelegramFilePath(rawPath, repoRoot, scopedRoot);
             if (!file.ok) {
               return { success: false, output: "", error: file.error, durationMs: performance.now() - start2 };
@@ -608652,11 +609674,16 @@ ${caption}\r
             const result = await this.apiCall("getUpdates", {
               offset: this.lastUpdateId + 1,
               timeout: 30,
-              allowed_updates: ["message", "guest_message", "poll", "message_reaction", "message_reaction_count"]
+              allowed_updates: ["message", "guest_message", "callback_query", "poll", "message_reaction", "message_reaction_count"]
             });
             if (result.ok && Array.isArray(result.result)) {
               for (const update2 of result.result) {
                 this.lastUpdateId = update2.update_id;
+                const callback = normalizeTelegramCallbackQuery(update2);
+                if (callback) {
+                  await this.handleTelegramCallbackQuery(callback);
+                  continue;
+                }
                 const msg = normalizeTelegramUpdate(update2);
                 if (!msg) continue;
                 const isAdmin = this.adminUserId ? String(msg.fromUserId) === this.adminUserId || msg.username === this.adminUserId : false;
@@ -612366,7 +613393,7 @@ __export(runtime_keys_exports, {
 import { existsSync as existsSync115, readFileSync as readFileSync94, writeFileSync as writeFileSync61, mkdirSync as mkdirSync69, chmodSync } from "node:fs";
 import { join as join129 } from "node:path";
 import { homedir as homedir40 } from "node:os";
-import { randomBytes as randomBytes22 } from "node:crypto";
+import { randomBytes as randomBytes23 } from "node:crypto";
 function ensureDir2() {
   const dir = join129(homedir40(), ".omnius");
   if (!existsSync115(dir)) mkdirSync69(dir, { recursive: true });
@@ -612392,7 +613419,7 @@ function persistAll(records) {
 }
 function mintKey(args) {
   const records = loadAll();
-  const key = `omnius_${randomBytes22(32).toString("hex")}`;
+  const key = `omnius_${randomBytes23(32).toString("hex")}`;
   const record = {
     key,
     scope: args.scope,
@@ -615510,11 +616537,11 @@ async function handleAimsIncidentPost(ctx3) {
       }));
       return true;
     }
-    const { randomBytes: randomBytes26 } = await import("node:crypto");
+    const { randomBytes: randomBytes27 } = await import("node:crypto");
     const record = await withAimsLock("incidents.json", () => {
       const existing = readAimsFile("incidents.json", []);
       const rec = {
-        id: `INC-${Date.now()}-${randomBytes26(4).toString("hex")}`,
+        id: `INC-${Date.now()}-${randomBytes27(4).toString("hex")}`,
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         raised_by: user ?? "anonymous",
         status: "open",
@@ -624969,7 +625996,7 @@ var init_usage_tracker = __esm({
 import { existsSync as existsSync120, readFileSync as readFileSync98, writeFileSync as writeFileSync64, mkdirSync as mkdirSync72, readdirSync as readdirSync41, unlinkSync as unlinkSync24 } from "node:fs";
 import { join as join134 } from "node:path";
 import { homedir as homedir43 } from "node:os";
-import { createCipheriv as createCipheriv5, createDecipheriv as createDecipheriv5, randomBytes as randomBytes23, scryptSync as scryptSync3 } from "node:crypto";
+import { createCipheriv as createCipheriv5, createDecipheriv as createDecipheriv5, randomBytes as randomBytes24, scryptSync as scryptSync3 } from "node:crypto";
 function globalProfileDir() {
   return join134(homedir43(), ".omnius", "profiles");
 }
@@ -625053,9 +626080,9 @@ function deleteProfile(name10, scope = "global", projectDir2) {
   return false;
 }
 function encryptProfile(profile, password) {
-  const salt = randomBytes23(32);
+  const salt = randomBytes24(32);
   const key = scryptSync3(password, salt, 32);
-  const iv = randomBytes23(16);
+  const iv = randomBytes24(16);
   const cipher = createCipheriv5("aes-256-gcm", key, iv);
   const plaintext = JSON.stringify(profile);
   const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
@@ -625708,7 +626735,7 @@ import { dirname as dirname37, join as join137, resolve as resolve45 } from "nod
 import { homedir as homedir45 } from "node:os";
 import { spawn as spawn29, execSync as execSync57 } from "node:child_process";
 import { mkdirSync as mkdirSync74, writeFileSync as writeFileSync66, readFileSync as readFileSync99, readdirSync as readdirSync42, existsSync as existsSync122, watch as fsWatch3, renameSync as renameSync8, unlinkSync as unlinkSync25 } from "node:fs";
-import { randomBytes as randomBytes24, randomUUID as randomUUID16 } from "node:crypto";
+import { randomBytes as randomBytes25, randomUUID as randomUUID16 } from "node:crypto";
 import { createHash as createHash27 } from "node:crypto";
 function memoryDbPaths3(baseDir = process.cwd()) {
   const dir = join137(baseDir, ".omnius");
@@ -627384,7 +628411,7 @@ ${messages2[firstSystemIdx].content}`
       messages2.unshift({ role: "system", content: SYSTEM_FACTUAL_FIRST });
     }
   }
-  const chatId = `chatcmpl-${randomBytes24(12).toString("hex")}`;
+  const chatId = `chatcmpl-${randomBytes25(12).toString("hex")}`;
   const turnsLog = [];
   for (let turn = 1; turn <= maxTurns; turn++) {
     if (Date.now() > totalDeadline) {
@@ -627650,7 +628677,7 @@ async function handleV1ChatCompletions(req2, res, ollamaUrl) {
       "Cache-Control": "no-cache",
       "Connection": "keep-alive"
     });
-    const chatId = `chatcmpl-${randomBytes24(12).toString("hex")}`;
+    const chatId = `chatcmpl-${randomBytes25(12).toString("hex")}`;
     let buffer2 = "";
     ollamaStream(
       targetUrl,
@@ -627692,7 +628719,7 @@ async function handleV1ChatCompletions(req2, res, ollamaUrl) {
               if (ollamaChunk.message.content) delta.content = ollamaChunk.message.content;
               if (ollamaChunk.message.tool_calls) {
                 delta.tool_calls = ollamaChunk.message.tool_calls.map((tc, idx) => ({
-                  id: tc.id || `call_${randomBytes24(8).toString("hex")}`,
+                  id: tc.id || `call_${randomBytes25(8).toString("hex")}`,
                   type: "function",
                   function: {
                     name: tc?.function?.name ?? tc?.name ?? "",
@@ -627772,14 +628799,14 @@ async function handleV1ChatCompletions(req2, res, ollamaUrl) {
       if (ollamaResp.eval_count) metrics.totalTokensOut += ollamaResp.eval_count;
       if (ollamaResp.prompt_eval_count) metrics.totalTokensIn += ollamaResp.prompt_eval_count;
       trackTokens("local", ollamaResp.prompt_eval_count ?? 0, ollamaResp.eval_count ?? 0);
-      const chatId = `chatcmpl-${randomBytes24(12).toString("hex")}`;
+      const chatId = `chatcmpl-${randomBytes25(12).toString("hex")}`;
       const responseMessage = {
         role: ollamaResp.message?.role ?? "assistant",
         content: ollamaResp.message?.content ?? ""
       };
       if (ollamaResp.message?.tool_calls && ollamaResp.message.tool_calls.length > 0) {
         responseMessage.tool_calls = ollamaResp.message.tool_calls.map((tc, idx) => ({
-          id: tc.id || `call_${randomBytes24(8).toString("hex")}`,
+          id: tc.id || `call_${randomBytes25(8).toString("hex")}`,
           type: "function",
           function: {
             name: tc?.function?.name ?? tc?.name ?? "",
@@ -628564,7 +629591,7 @@ async function handleV1Run(req2, res) {
       return;
     }
   }
-  const id = `job-${randomBytes24(8).toString("hex")}`;
+  const id = `job-${randomBytes25(8).toString("hex")}`;
   const dir = jobsDir();
   const workingDir = requestBody["working_directory"] || req2.headers["x-working-directory"];
   const isolate = requestBody["isolate"] === true;
@@ -639256,6 +640283,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         telegramBridge.setContextWindowSize(resolvedContextWindowSize);
       }
       telegramBridge.setInteractionMode(savedSettings.telegramMode ?? "auto");
+      telegramBridge.setTelegramToolPolicy(savedSettings.telegramToolPolicy);
       if (adminId) {
         telegramBridge.setAdmin(adminId);
       }
@@ -639469,6 +640497,34 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (!telegramBridge?.isActive) throw new Error("Telegram bridge not active.");
       return telegramBridge.deleteAllMessageReactions(chatId, options2);
     },
+    async telegramDeleteMessage(chatId, messageId, reason) {
+      if (!telegramBridge?.isActive) throw new Error("Telegram bridge not active.");
+      return telegramBridge.runTelegramToolActionForAdmin("delete_message", {
+        target: String(chatId),
+        message_id: messageId,
+        reason: reason || "TUI admin delete-message command"
+      });
+    },
+    async telegramDeleteMessages(chatId, messageIds, reason) {
+      if (!telegramBridge?.isActive) throw new Error("Telegram bridge not active.");
+      return telegramBridge.runTelegramToolActionForAdmin("delete_messages", {
+        target: String(chatId),
+        message_ids: messageIds,
+        reason: reason || "TUI admin delete-messages command"
+      });
+    },
+    telegramGetToolPolicy() {
+      return telegramBridge?.getTelegramToolPolicy() ?? savedSettings.telegramToolPolicy ?? {};
+    },
+    telegramSetToolPolicy(policy) {
+      savedSettings.telegramToolPolicy = policy;
+      saveProjectSettings(repoRoot, { telegramToolPolicy: policy });
+      telegramBridge?.setTelegramToolPolicy(policy);
+    },
+    async telegramSendToolPanel(chatId, policyChatId) {
+      if (!telegramBridge?.isActive) throw new Error("Telegram bridge not active.");
+      return telegramBridge.sendTelegramToolPanel(chatId, policyChatId);
+    },
     async telegramGetChatAdministrators(chatId, returnBots) {
       if (!telegramBridge?.isActive) throw new Error("Telegram bridge not active.");
       return telegramBridge.getChatAdministrators(chatId, returnBots);
@@ -642285,7 +643341,7 @@ __export(run_exports, {
 import { resolve as resolve47 } from "node:path";
 import { spawn as spawn30 } from "node:child_process";
 import { mkdirSync as mkdirSync77, writeFileSync as writeFileSync69, readFileSync as readFileSync102, readdirSync as readdirSync44, existsSync as existsSync124 } from "node:fs";
-import { randomBytes as randomBytes25 } from "node:crypto";
+import { randomBytes as randomBytes26 } from "node:crypto";
 import { join as join140 } from "node:path";
 function jobsDir2(repoPath) {
   const root = resolve47(repoPath ?? process.cwd());
@@ -642383,7 +643439,7 @@ function extractSummary(captured) {
   return lines.slice(-3).join(" ").slice(0, 200);
 }
 async function runBackground(task, config, opts) {
-  const id = `job-${randomBytes25(3).toString("hex")}`;
+  const id = `job-${randomBytes26(3).toString("hex")}`;
   const dir = jobsDir2(opts.repoPath);
   const repoRoot = resolve47(opts.repoPath ?? process.cwd());
   const job = {