teleton 0.2.4 → 0.3.0

package/dist/{chunk-74MTM3AB.js → chunk-ILDG4OPK.js}

@@ -1,3 +1,13 @@
+import {
+  Mi,
+  Mn,
+  br,
+  dt,
+  le,
+  qn,
+  ut,
+  ye
+} from "./chunk-U7FQYCBQ.js";
 import {
   initScraperDb
 } from "./chunk-DUW5VBAZ.js";
@@ -20,7 +30,7 @@ import {
   initializeMemory,
   migrateFromMainDb,
   openModuleDb
-} from "./chunk-TBIMVWQZ.js";
+} from "./chunk-QQW6KE7Q.js";
 import {
   COINGECKO_API_URL,
   ELEVENLABS_TTS_URL,
@@ -30,7 +40,7 @@ import {
   fetchWithTimeout,
   setTonapiKey,
   tonapiFetch
-} from "./chunk-WMIN6AGX.js";
+} from "./chunk-DAMFGHXV.js";
 import {
   COMPACTION_KEEP_RECENT,
   COMPACTION_MAX_MESSAGES,
@@ -43,8 +53,10 @@ import {
   DEBOUNCE_MAX_BUFFER_SIZE,
   DEBOUNCE_MAX_MULTIPLIER,
   DEFAULT_GIFTS_QUERY_LIMIT,
+  MAX_DEPENDENTS_PER_TASK,
   MAX_POLL_QUESTION_LENGTH,
   MAX_TOOL_RESULT_SIZE,
+  MAX_WRITE_SIZE,
   PAYMENT_TOLERANCE_RATIO,
   PENDING_HISTORY_MAX_AGE_MS,
   PENDING_HISTORY_MAX_PER_CHAT,
@@ -53,7 +65,14 @@ import {
   TELEGRAM_CONNECTION_RETRIES,
   TELEGRAM_FLOOD_SLEEP_THRESHOLD,
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-QMN6ZOA5.js";
+} from "./chunk-UYF4TT44.js";
+import {
+  ALLOWED_EXTENSIONS,
+  MAX_FILE_SIZES,
+  TELETON_ROOT,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-EYWNOHMJ.js";
 import {
   GRAMJS_RETRY_DELAY_MS,
   MESSAGE_HANDLER_LOCK_TIMEOUT_MS,
@@ -64,29 +83,13 @@ import {
   RETRY_DEFAULT_MAX_ATTEMPTS,
   RETRY_DEFAULT_MAX_DELAY_MS,
   RETRY_DEFAULT_TIMEOUT_MS,
+  TOOL_EXECUTION_TIMEOUT_MS,
   TTS_TIMEOUT_MS
-} from "./chunk-LJXYESJJ.js";
-import {
-  ALLOWED_EXTENSIONS,
-  MAX_FILE_SIZES,
-  TELETON_ROOT,
-  WORKSPACE_PATHS,
-  WORKSPACE_ROOT
-} from "./chunk-EYWNOHMJ.js";
+} from "./chunk-LCMHAUNK.js";
 import {
   telegramGetMyGiftsExecutor,
   telegramGetMyGiftsTool
 } from "./chunk-B2PRMXOH.js";
-import {
-  Mi,
-  Mn,
-  br,
-  dt,
-  le,
-  qn,
-  ut,
-  ye
-} from "./chunk-U7FQYCBQ.js";
 import {
   __commonJS,
   __toESM
@@ -1521,7 +1524,7 @@ var PROVIDER_REGISTRY = {
     keyHint: "sk-or-v1-...",
     consoleUrl: "https://openrouter.ai/keys",
     defaultModel: "anthropic/claude-opus-4.5",
-    utilityModel: "google/gemini-2.0-flash-001:free",
+    utilityModel: "google/gemini-2.5-flash-lite",
     toolLimit: 128,
     piAiProvider: "openrouter"
   }
@@ -2146,6 +2149,9 @@ function getProviderModel(provider, modelId) {
   const meta = getProviderMetadata(provider);
   try {
     const model = getModel(meta.piAiProvider, modelId);
+    if (!model) {
+      throw new Error(`getModel returned undefined for ${provider}/${modelId}`);
+    }
     modelCache.set(cacheKey, model);
     return model;
   } catch (e) {
@@ -2157,6 +2163,11 @@ function getProviderModel(provider, modelId) {
     if (fallbackCached) return fallbackCached;
     try {
       const model = getModel(meta.piAiProvider, meta.defaultModel);
+      if (!model) {
+        throw new Error(
+          `Fallback model ${meta.defaultModel} also returned undefined for ${provider}`
+        );
+      }
       modelCache.set(fallbackKey, model);
       return model;
     } catch {
@@ -3409,7 +3420,13 @@ ${statsContext}`;
       const providerMeta = getProviderMetadata(
         this.config.agent.provider || "anthropic"
       );
-      const tools23 = this.toolRegistry?.getForContext(isGroup ?? false, providerMeta.toolLimit);
+      const isAdmin = toolContext?.config?.telegram.admin_ids.includes(toolContext.senderId) ?? false;
+      const tools23 = this.toolRegistry?.getForContext(
+        isGroup ?? false,
+        providerMeta.toolLimit,
+        chatId,
+        isAdmin
+      );
       const maxIterations = this.config.agent.max_agentic_iterations || 5;
       let iteration = 0;
       let overflowResets = 0;
@@ -3625,20 +3642,9 @@ ${statsContext}`;
   clearHistory(chatId) {
     const db3 = getDatabase().getDb();
     db3.prepare(
-      `
-      DELETE FROM tg_messages_fts
-      WHERE rowid IN (
-        SELECT rowid FROM tg_messages WHERE chat_id = ?
-      )
-    `
-    ).run(chatId);
-    db3.prepare(
-      `
-      DELETE FROM tg_messages_vec
-      WHERE id IN (
+      `DELETE FROM tg_messages_vec WHERE id IN (
         SELECT id FROM tg_messages WHERE chat_id = ?
-      )
-    `
+      )`
     ).run(chatId);
     db3.prepare(`DELETE FROM tg_messages WHERE chat_id = ?`).run(chatId);
     resetSession(chatId);
@@ -4598,7 +4604,7 @@ var MessageHandler = class {
         reason: "Already processed"
       };
     }
-    if (message.isGroup && message.isBot) {
+    if (message.isBot) {
       return {
         message,
         isAdmin,
@@ -4840,7 +4846,21 @@ import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto
 import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync6, chmodSync as chmodSync2 } from "fs";
 import { join as join6, dirname as dirname5 } from "path";
+
+// src/ton/endpoint.ts
 import { getHttpEndpoint } from "@orbs-network/ton-access";
+var ENDPOINT_CACHE_TTL_MS = 6e4;
+var _cache = null;
+async function getCachedHttpEndpoint() {
+  if (_cache && Date.now() - _cache.ts < ENDPOINT_CACHE_TTL_MS) {
+    return _cache.url;
+  }
+  const url = await getHttpEndpoint({ network: "mainnet" });
+  _cache = { url, ts: Date.now() };
+  return url;
+}
+
+// src/ton/wallet-service.ts
 var WALLET_FILE = join6(TELETON_ROOT, "wallet.json");
 async function generateWallet() {
   const mnemonic = await mnemonicNew(24);
@@ -4906,7 +4926,7 @@ function getWalletAddress() {
 }
 async function getWalletBalance(address4) {
   try {
-    const endpoint = await getHttpEndpoint({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient({ endpoint });
     const { Address: Address19 } = await import("@ton/core");
     const addressObj = Address19.parse(address4);
@@ -5000,15 +5020,20 @@ function initDealsConfig(yaml) {
 // src/telegram/admin.ts
 var VALID_DM_POLICIES = ["open", "allowlist", "pairing", "disabled"];
 var VALID_GROUP_POLICIES = ["open", "allowlist", "disabled"];
+var VALID_MODULE_LEVELS = ["open", "admin", "disabled"];
 var AdminHandler = class {
   bridge;
   config;
   agent;
   paused = false;
-  constructor(bridge, config, agent) {
+  permissions;
+  registry;
+  constructor(bridge, config, agent, permissions, registry) {
     this.bridge = bridge;
     this.config = config;
     this.agent = agent;
+    this.permissions = permissions ?? null;
+    this.registry = registry ?? null;
   }
   /**
    * Check if user is admin
@@ -5043,7 +5068,7 @@ var AdminHandler = class {
   /**
    * Handle admin command
    */
-  async handleCommand(command, chatId, senderId) {
+  async handleCommand(command, chatId, senderId, isGroup) {
     if (!this.isAdmin(senderId)) {
       return "\u26D4 Admin access required";
     }
@@ -5074,6 +5099,8 @@ var AdminHandler = class {
         return await this.handleStopCommand();
       case "verbose":
         return this.handleVerboseCommand();
+      case "modules":
+        return this.handleModulesCommand(command, isGroup ?? false);
       case "help":
         return this.handleHelpCommand();
       case "ping":
@@ -5286,6 +5313,124 @@ Usage:
     setVerbose(next);
     return next ? "\u{1F50A} Verbose logging **ON**" : "\u{1F507} Verbose logging **OFF**";
   }
+  /**
+   * /modules - Manage per-group module permissions
+   */
+  handleModulesCommand(command, isGroup) {
+    if (!this.permissions || !this.registry) {
+      return "\u274C Module permissions non disponible";
+    }
+    if (!isGroup) {
+      return "\u274C /modules est uniquement disponible dans les groupes";
+    }
+    const chatId = command.chatId;
+    const sub = command.args[0]?.toLowerCase();
+    if (!sub) {
+      return this.listModules(chatId);
+    }
+    switch (sub) {
+      case "set":
+        return this.setModuleLevel(chatId, command.args[1], command.args[2], command.senderId);
+      case "info":
+        return this.showModuleInfo(command.args[1], chatId);
+      case "reset":
+        return this.resetModules(chatId, command.args[1]);
+      default:
+        return `\u274C Sous-commande inconnue: "${sub}"
+
+Usage: /modules | /modules set <module> <level> | /modules info <module> | /modules reset [module]`;
+    }
+  }
+  listModules(chatId) {
+    const modules = this.registry.getAvailableModules();
+    const overrides = this.permissions.getOverrides(chatId);
+    const lines = ["\u{1F9E9} **Modules** (ce groupe)\n"];
+    for (const mod of modules) {
+      const count = this.registry.getModuleToolCount(mod);
+      const level = overrides.get(mod) ?? "open";
+      const isProtected = this.permissions.isProtected(mod);
+      let icon;
+      switch (level) {
+        case "open":
+          icon = "\u2705";
+          break;
+        case "admin":
+          icon = "\u{1F510}";
+          break;
+        case "disabled":
+          icon = "\u274C";
+          break;
+      }
+      const toolWord = count === 1 ? "tool" : "tools";
+      const protectedMark = isProtected ? " \u{1F512}" : "";
+      lines.push(` ${icon} **${mod}**   ${count} ${toolWord}  ${level}${protectedMark}`);
+    }
+    lines.push("");
+    lines.push("Niveaux: `open` | `admin` | `disabled`");
+    lines.push("Usage: `/modules set <module> <level>`");
+    return lines.join("\n");
+  }
+  setModuleLevel(chatId, module, level, senderId) {
+    if (!module || !level) {
+      return "\u274C Usage: /modules set <module> <level>";
+    }
+    module = module.toLowerCase();
+    level = level.toLowerCase();
+    const available = this.registry.getAvailableModules();
+    if (!available.includes(module)) {
+      return `\u274C Module inconnu: "${module}"`;
+    }
+    if (this.permissions.isProtected(module)) {
+      return `\u26D4 Module "${module}" est prot\xE9g\xE9`;
+    }
+    if (!VALID_MODULE_LEVELS.includes(level)) {
+      return `\u274C Niveau invalide: "${level}". Valide: ${VALID_MODULE_LEVELS.join(", ")}`;
+    }
+    const oldLevel = this.permissions.getLevel(chatId, module);
+    this.permissions.setLevel(chatId, module, level, senderId);
+    const icons = { open: "\u2705", admin: "\u{1F510}", disabled: "\u274C" };
+    return `${icons[level]} **${module}**: ${oldLevel} \u2192 ${level}`;
+  }
+  showModuleInfo(module, chatId) {
+    if (!module) {
+      return "\u274C Usage: /modules info <module>";
+    }
+    module = module.toLowerCase();
+    const available = this.registry.getAvailableModules();
+    if (!available.includes(module)) {
+      return `\u274C Module inconnu: "${module}"`;
+    }
+    const tools23 = this.registry.getModuleTools(module);
+    const count = tools23.length;
+    const toolWord = count === 1 ? "tool" : "tools";
+    const level = this.permissions.getLevel(chatId, module);
+    const isProtected = this.permissions.isProtected(module);
+    const protectedMark = isProtected ? " \u{1F512}" : "";
+    const lines = [
+      `\u{1F4E6} Module "**${module}**" \u2014 ${level}${protectedMark} (${count} ${toolWord})
+`
+    ];
+    for (const t of tools23) {
+      lines.push(` ${t.name}   ${t.scope}`);
+    }
+    return lines.join("\n");
+  }
+  resetModules(chatId, module) {
+    if (module) {
+      module = module.toLowerCase();
+      const available = this.registry.getAvailableModules();
+      if (!available.includes(module)) {
+        return `\u274C Module inconnu: "${module}"`;
+      }
+      if (this.permissions.isProtected(module)) {
+        return `\u26D4 Module "${module}" est prot\xE9g\xE9 (d\xE9j\xE0 open)`;
+      }
+      this.permissions.resetModule(chatId, module);
+      return `\u2705 **${module}** \u2192 open`;
+    }
+    this.permissions.resetAll(chatId);
+    return "\u2705 Tous les modules remis \xE0 **open**";
+  }
   /**
    * /help - Show available commands
    */
@@ -5307,6 +5452,9 @@ Change access policy
 **/strategy** [buy|sell <percent>]
 View or change trading thresholds
 
+**/modules** [set|info|reset]
+Manage per-group module permissions
+
 **/wallet**
 Check TON wallet balance
 
@@ -5458,6 +5606,8 @@ import { validateToolCall } from "@mariozechner/pi-ai";
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   scopes = /* @__PURE__ */ new Map();
+  toolModules = /* @__PURE__ */ new Map();
+  permissions = null;
   /**
    * Register a new tool with optional scope
    */
@@ -5469,6 +5619,42 @@ var ToolRegistry = class {
     if (scope && scope !== "always") {
       this.scopes.set(tool.name, scope);
     }
+    this.toolModules.set(tool.name, tool.name.split("_")[0]);
+  }
+  /**
+   * Set the module permissions manager
+   */
+  setPermissions(mp) {
+    this.permissions = mp;
+  }
+  /**
+   * Get sorted unique module names derived from registered tools
+   */
+  getAvailableModules() {
+    const modules = new Set(this.toolModules.values());
+    return Array.from(modules).sort();
+  }
+  /**
+   * Get the number of tools in a module
+   */
+  getModuleToolCount(module) {
+    let count = 0;
+    for (const mod of this.toolModules.values()) {
+      if (mod === module) count++;
+    }
+    return count;
+  }
+  /**
+   * Get tools belonging to a module with their scope
+   */
+  getModuleTools(module) {
+    const result = [];
+    for (const [name, mod] of this.toolModules) {
+      if (mod === module) {
+        result.push({ name, scope: this.scopes.get(name) ?? "always" });
+      }
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
   }
   /**
    * Get all registered tools for pi-ai
@@ -5500,9 +5686,43 @@ var ToolRegistry = class {
         error: `Tool "${toolCall.name}" is only available in group chats`
       };
     }
+    if (context.isGroup && this.permissions) {
+      const module = this.toolModules.get(toolCall.name);
+      if (module) {
+        const level = this.permissions.getLevel(context.chatId, module);
+        if (level === "disabled") {
+          return {
+            success: false,
+            error: `Module "${module}" is disabled in this group`
+          };
+        }
+        if (level === "admin") {
+          const isAdmin = context.config?.telegram.admin_ids.includes(context.senderId) ?? false;
+          if (!isAdmin) {
+            return {
+              success: false,
+              error: `Module "${module}" is restricted to admins in this group`
+            };
+          }
+        }
+      }
+    }
     try {
       const validatedArgs = validateToolCall(this.getAll(), toolCall);
-      const result = await registered.executor(validatedArgs, context);
+      let timeoutHandle;
+      const result = await Promise.race([
+        registered.executor(validatedArgs, context),
+        new Promise((_, reject) => {
+          timeoutHandle = setTimeout(
+            () => reject(
+              new Error(
+                `Tool "${toolCall.name}" timed out after ${TOOL_EXECUTION_TIMEOUT_MS / 1e3}s`
+              )
+            ),
+            TOOL_EXECUTION_TIMEOUT_MS
+          );
+        })
+      ]).finally(() => clearTimeout(timeoutHandle));
       return result;
     } catch (error) {
       console.error(`Error executing tool ${toolCall.name}:`, error);
@@ -5526,13 +5746,25 @@ var ToolRegistry = class {
     return all.slice(0, toolLimit);
   }
   /**
-   * Get tools filtered by chat context (DM vs group) and provider limit.
+   * Get tools filtered by chat context (DM vs group), module permissions, and provider limit.
    * - In groups: excludes "dm-only" tools (financial, private)
    * - In DMs: excludes "group-only" tools (moderation)
+   * - In groups with permissions: excludes disabled modules, admin-only modules for non-admins
    */
-  getForContext(isGroup, toolLimit) {
+  getForContext(isGroup, toolLimit, chatId, isAdmin) {
     const excluded = isGroup ? "dm-only" : "group-only";
-    const filtered = Array.from(this.tools.values()).filter((rt) => this.scopes.get(rt.tool.name) !== excluded).map((rt) => rt.tool);
+    const filtered = Array.from(this.tools.values()).filter((rt) => {
+      if (this.scopes.get(rt.tool.name) === excluded) return false;
+      if (isGroup && chatId && this.permissions) {
+        const module = this.toolModules.get(rt.tool.name);
+        if (module) {
+          const level = this.permissions.getLevel(chatId, module);
+          if (level === "disabled") return false;
+          if (level === "admin" && !isAdmin) return false;
+        }
+      }
+      return true;
+    }).map((rt) => rt.tool);
     if (toolLimit !== null && filtered.length > toolLimit) {
       console.warn(
         `\u26A0\uFE0F Provider tool limit: ${toolLimit}, after scope filter: ${filtered.length}. Truncating to ${toolLimit} tools.`
@@ -10526,19 +10758,6 @@ var GramJSBotClient = class {
 import { TonClient as TonClient2, fromNano as fromNano2 } from "@ton/ton";
 import { Address } from "@ton/core";
 
-// src/ton/endpoint.ts
-import { getHttpEndpoint as getHttpEndpoint2 } from "@orbs-network/ton-access";
-var ENDPOINT_CACHE_TTL_MS = 6e4;
-var _cache = null;
-async function getCachedHttpEndpoint() {
-  if (_cache && Date.now() - _cache.ts < ENDPOINT_CACHE_TTL_MS) {
-    return _cache.url;
-  }
-  const url = await getHttpEndpoint2({ network: "mainnet" });
-  _cache = { url, ts: Date.now() };
-  return url;
-}
-
 // src/casino/retry.ts
 var DEFAULT_OPTIONS = {
   maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
@@ -10773,7 +10992,6 @@ If you already sent, wait a moment and try again.`
 import { mnemonicToPrivateKey as mnemonicToPrivateKey2 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R12, TonClient as TonClient3, toNano, internal } from "@ton/ton";
 import { Address as Address2, SendMode } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint3 } from "@orbs-network/ton-access";
 async function sendTon(params) {
   try {
     const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
@@ -10794,7 +11012,7 @@ async function sendTon(params) {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint3({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient3({ endpoint });
     const contract = client.open(wallet);
     const seqno = await contract.getSeqno();
@@ -11954,6 +12172,7 @@ function openDealsDb() {
     CREATE INDEX IF NOT EXISTS idx_deals_chat ON deals(chat_id);
     CREATE INDEX IF NOT EXISTS idx_deals_inline_msg ON deals(inline_message_id) WHERE inline_message_id IS NOT NULL;
     CREATE INDEX IF NOT EXISTS idx_deals_payment_claimed ON deals(payment_claimed_at) WHERE payment_claimed_at IS NOT NULL;
+    CREATE INDEX IF NOT EXISTS idx_deals_expires ON deals(expires_at) WHERE status IN ('proposed', 'accepted');
 
     CREATE TABLE IF NOT EXISTS user_trade_stats (
       telegram_id INTEGER PRIMARY KEY,
@@ -14374,7 +14593,6 @@ var telegramCreateScheduledTaskExecutor = async (params, context) => {
     }
     const { getTaskStore } = await import("./tasks-M3QDPTGY.js");
     const taskStore = getTaskStore(context.db);
-    const MAX_DEPENDENTS_PER_TASK = 10;
     if (dependsOn && dependsOn.length > 0) {
       for (const parentId of dependsOn) {
         const existingDependents = taskStore.getDependents(parentId);
@@ -14877,7 +15095,6 @@ import { Type as Type75 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey3 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R13, TonClient as TonClient4, toNano as toNano2, internal as internal2 } from "@ton/ton";
 import { Address as Address3, SendMode as SendMode2 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint4 } from "@orbs-network/ton-access";
 var tonSendTool = {
   name: "ton_send",
   description: "Send TON cryptocurrency to an address. Requires wallet to be initialized. Amount is in TON (not nanoTON). Example: amount 1.5 = 1.5 TON. Always confirm the transaction details before sending.",
@@ -14919,7 +15136,7 @@ var tonSendExecutor = async (params, context) => {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint4({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient4({ endpoint });
     const contract = client.open(wallet);
     const seqno = await contract.getSeqno();
@@ -14959,7 +15176,6 @@ var tonSendExecutor = async (params, context) => {
 import { Type as Type76 } from "@sinclair/typebox";
 import { TonClient as TonClient5, fromNano as fromNano3 } from "@ton/ton";
 import { Address as Address4 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint5 } from "@orbs-network/ton-access";
 var OP_CODES = {
   COMMENT: 0,
   JETTON_TRANSFER: 260734629,
@@ -15035,7 +15251,7 @@ var tonGetTransactionsExecutor = async (params, context) => {
         error: `Invalid address: ${address4}`
       };
     }
-    const endpoint = await getHttpEndpoint5({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient5({ endpoint });
     const transactions = await client.getTransactions(addressObj, {
       limit: Math.min(limit, 50)
@@ -15179,7 +15395,6 @@ var tonGetTransactionsExecutor = async (params, context) => {
 import { Type as Type77 } from "@sinclair/typebox";
 import { TonClient as TonClient6, fromNano as fromNano4 } from "@ton/ton";
 import { Address as Address5 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint6 } from "@orbs-network/ton-access";
 var OP_CODES2 = {
   COMMENT: 0,
   JETTON_TRANSFER: 260734629,
@@ -15251,7 +15466,7 @@ var tonMyTransactionsExecutor = async (params, context) => {
       };
     }
     const addressObj = Address5.parse(walletData.address);
-    const endpoint = await getHttpEndpoint6({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient6({ endpoint });
     const transactions = await client.getTransactions(addressObj, {
       limit: Math.min(limit, 50)
@@ -15391,6 +15606,223 @@ var tonMyTransactionsExecutor = async (params, context) => {
   }
 };
 
+// src/agent/tools/ton/chart.ts
+import { Type as Type78 } from "@sinclair/typebox";
+var tonChartTool = {
+  name: "ton_chart",
+  description: "Get price history chart for TON or any jetton. Returns price points over a time period with stats (min, max, change %). Use token param for jettons (master contract address).",
+  parameters: Type78.Object({
+    token: Type78.Optional(
+      Type78.String({
+        description: 'Token identifier: "ton" for TON, or a jetton master contract address. Defaults to "ton".'
+      })
+    ),
+    period: Type78.Optional(
+      Type78.String({
+        description: 'Time period: "1h", "24h", "7d", "30d", "90d", "1y". Defaults to "7d".'
+      })
+    )
+  }),
+  category: "data-bearing"
+};
+var PERIOD_CONFIG = {
+  "1h": { seconds: 3600, points: 60 },
+  "24h": { seconds: 86400, points: 96 },
+  "7d": { seconds: 604800, points: 168 },
+  "30d": { seconds: 2592e3, points: 120 },
+  "90d": { seconds: 7776e3, points: 180 },
+  "1y": { seconds: 31536e3, points: 200 }
+};
+var tonChartExecutor = async (params, context) => {
+  try {
+    const token = params.token || "ton";
+    const period = params.period || "7d";
+    const config = PERIOD_CONFIG[period];
+    if (!config) {
+      return {
+        success: false,
+        error: `Invalid period "${period}". Use one of: ${Object.keys(PERIOD_CONFIG).join(", ")}`
+      };
+    }
+    const endDate = Math.floor(Date.now() / 1e3);
+    const startDate = endDate - config.seconds;
+    const url = `/rates/chart?token=${encodeURIComponent(token)}&currency=usd&start_date=${startDate}&end_date=${endDate}&points_count=${config.points}`;
+    const res = await tonapiFetch(url);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return {
+        success: false,
+        error: `TonAPI returned ${res.status}: ${text || res.statusText}`
+      };
+    }
+    const data = await res.json();
+    if (!Array.isArray(data.points) || data.points.length === 0) {
+      return {
+        success: false,
+        error: `No price data available for token "${token}" over period "${period}".`
+      };
+    }
+    const rawPoints = data.points;
+    const sorted = [...rawPoints].sort((a, b) => a[0] - b[0]);
+    const points = sorted.map(([ts, price]) => ({
+      timestamp: ts,
+      date: new Date(ts * 1e3).toISOString(),
+      price
+    }));
+    const prices = points.map((p2) => p2.price);
+    const startPrice = prices[0];
+    const currentPrice = prices[prices.length - 1];
+    const minPrice = Math.min(...prices);
+    const maxPrice = Math.max(...prices);
+    const changeAbsolute = currentPrice - startPrice;
+    const changePercent = startPrice !== 0 ? changeAbsolute / startPrice * 100 : 0;
+    const minIdx = prices.indexOf(minPrice);
+    const maxIdx = prices.indexOf(maxPrice);
+    const stats = {
+      currentPrice,
+      startPrice,
+      minPrice,
+      maxPrice,
+      changePercent: Math.round(changePercent * 100) / 100,
+      changeAbsolute: Math.round(changeAbsolute * 1e6) / 1e6,
+      high: { price: maxPrice, date: points[maxIdx].date },
+      low: { price: minPrice, date: points[minIdx].date }
+    };
+    const direction = changePercent >= 0 ? "+" : "";
+    const tokenLabel = token === "ton" ? "TON" : token;
+    const message = `${tokenLabel} price over ${period}: $${currentPrice.toFixed(4)} (${direction}${stats.changePercent}%). Low: $${minPrice.toFixed(4)}, High: $${maxPrice.toFixed(4)}. ${points.length} data points.`;
+    return {
+      success: true,
+      data: {
+        token: tokenLabel,
+        period,
+        points,
+        stats,
+        message
+      }
+    };
+  } catch (error) {
+    console.error("Error in ton_chart:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+
+// src/agent/tools/ton/nft-list.ts
+import { Type as Type79 } from "@sinclair/typebox";
+var nftListTool = {
+  name: "nft_list",
+  description: "List NFTs owned by a TON wallet. Defaults to the agent's own wallet. Can filter by collection address.",
+  parameters: Type79.Object({
+    address: Type79.Optional(
+      Type79.String({
+        description: "TON wallet address to query. Defaults to the agent's wallet."
+      })
+    ),
+    collection: Type79.Optional(
+      Type79.String({
+        description: "Filter by collection contract address."
+      })
+    ),
+    limit: Type79.Optional(
+      Type79.Number({
+        description: "Max NFTs to return (1-100). Defaults to 50.",
+        minimum: 1,
+        maximum: 100
+      })
+    )
+  }),
+  category: "data-bearing"
+};
+var nftListExecutor = async (params, context) => {
+  try {
+    const address4 = params.address || getWalletAddress();
+    if (!address4) {
+      return {
+        success: false,
+        error: "No address provided and agent wallet is not initialized."
+      };
+    }
+    const limit = params.limit || 50;
+    const queryParts = [`limit=${limit}`, "indirect_ownership=true"];
+    if (params.collection) {
+      queryParts.push(`collection=${encodeURIComponent(params.collection)}`);
+    }
+    const url = `/accounts/${encodeURIComponent(address4)}/nfts?${queryParts.join("&")}`;
+    const res = await tonapiFetch(url);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return {
+        success: false,
+        error: `TonAPI returned ${res.status}: ${text || res.statusText}`
+      };
+    }
+    const data = await res.json();
+    if (!Array.isArray(data.nft_items)) {
+      return {
+        success: false,
+        error: "Invalid API response: missing nft_items array"
+      };
+    }
+    const rawItems = data.nft_items;
+    const filtered = rawItems.filter((item) => item.trust !== "blacklist");
+    const nfts = filtered.map((item) => {
+      const meta = item.metadata || {};
+      const coll = item.collection || {};
+      const sale = item.sale;
+      const previews = item.previews || [];
+      const preview = previews.length > 1 && previews[1].url || previews.length > 0 && previews[0].url || null;
+      let salePrice = null;
+      if (sale?.price?.value) {
+        const raw = Number(sale.price.value);
+        if (!isNaN(raw) && raw > 0) {
+          const amount = raw / 1e9;
+          const currency = sale.price.token_name || "TON";
+          salePrice = `${amount} ${currency}`;
+        }
+      }
+      return {
+        address: item.address,
+        name: meta.name || "Unnamed NFT",
+        description: (meta.description || "").slice(0, 100),
+        collection: coll.name || null,
+        collectionAddress: coll.address || null,
+        preview,
+        onSale: !!sale,
+        salePrice,
+        marketplace: sale?.marketplace || null,
+        dns: item.dns || null,
+        trust: item.trust || "none",
+        explorer: `https://tonviewer.com/${item.address}`
+      };
+    });
+    const hasMore = rawItems.length >= limit;
+    const summary = `Found ${nfts.length} NFT(s) for ${address4}${params.collection ? ` in collection ${params.collection}` : ""}${hasMore ? ` (limit ${limit} reached, there may be more)` : ""}.`;
+    const onSaleCount = nfts.filter((n2) => n2.onSale).length;
+    const collections = [...new Set(nfts.map((n2) => n2.collection).filter(Boolean))];
+    const message = `${summary}${onSaleCount > 0 ? ` ${onSaleCount} on sale.` : ""} Collections: ${collections.length > 0 ? collections.join(", ") : "none"}.`;
+    return {
+      success: true,
+      data: {
+        address: address4,
+        totalNfts: nfts.length,
+        hasMore,
+        nfts,
+        message,
+        summary
+      }
+    };
+  } catch (error) {
+    console.error("Error in nft_list:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+
 // src/agent/tools/ton/index.ts
 var tools16 = [
   { tool: tonSendTool, executor: tonSendExecutor, scope: "dm-only" },
@@ -15398,16 +15830,18 @@ var tools16 = [
   { tool: tonGetBalanceTool, executor: tonGetBalanceExecutor },
   { tool: tonPriceTool, executor: tonPriceExecutor },
   { tool: tonGetTransactionsTool, executor: tonGetTransactionsExecutor },
-  { tool: tonMyTransactionsTool, executor: tonMyTransactionsExecutor }
+  { tool: tonMyTransactionsTool, executor: tonMyTransactionsExecutor },
+  { tool: tonChartTool, executor: tonChartExecutor },
+  { tool: nftListTool, executor: nftListExecutor }
 ];
 
 // src/agent/tools/dns/check.ts
-import { Type as Type78 } from "@sinclair/typebox";
+import { Type as Type80 } from "@sinclair/typebox";
 var dnsCheckTool = {
   name: "dns_check",
   description: "Check if a .ton domain is available, in auction, or already owned. Returns status with relevant details (price estimates, current bids, owner info).",
-  parameters: Type78.Object({
-    domain: Type78.String({
+  parameters: Type80.Object({
+    domain: Type80.String({
       description: "Domain name to check (with or without .ton extension)"
     })
   })
@@ -15521,13 +15955,13 @@ var dnsCheckExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/auctions.ts
-import { Type as Type79 } from "@sinclair/typebox";
+import { Type as Type81 } from "@sinclair/typebox";
 var dnsAuctionsTool = {
   name: "dns_auctions",
   description: "List all active .ton domain auctions. Returns domains currently in auction with current bid prices, number of bids, and end times.",
-  parameters: Type79.Object({
-    limit: Type79.Optional(
-      Type79.Number({
+  parameters: Type81.Object({
+    limit: Type81.Optional(
+      Type81.Number({
         description: "Maximum number of auctions to return (default: 20, max: 100)",
         minimum: 1,
         maximum: 100
@@ -15592,12 +16026,12 @@ ${summary}`
 };
 
 // src/agent/tools/dns/resolve.ts
-import { Type as Type80 } from "@sinclair/typebox";
+import { Type as Type82 } from "@sinclair/typebox";
 var dnsResolveTool = {
   name: "dns_resolve",
   description: "Resolve a .ton domain to its associated wallet address. Only works for domains that are already owned (not available or in auction).",
-  parameters: Type80.Object({
-    domain: Type80.String({
+  parameters: Type82.Object({
+    domain: Type82.String({
       description: "Domain name to resolve (with or without .ton extension)"
     })
   })
@@ -15653,20 +16087,19 @@ var dnsResolveExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/start-auction.ts
-import { Type as Type81 } from "@sinclair/typebox";
+import { Type as Type83 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey4 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R14, TonClient as TonClient7, toNano as toNano3, internal as internal3, beginCell } from "@ton/ton";
 import { Address as Address6, SendMode as SendMode3 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint7 } from "@orbs-network/ton-access";
 var DNS_COLLECTION = "EQC3dNlesgVD8YbAazcauIrXBPfiVhMMr5YYk2in0Mtsz0Bz";
 var dnsStartAuctionTool = {
   name: "dns_start_auction",
   description: "Start an auction for an unminted .ton domain. Sends TON to the DNS collection contract to mint a new domain NFT. Domain must be 4-126 characters, available (not minted), and amount must meet minimum price.",
-  parameters: Type81.Object({
-    domain: Type81.String({
+  parameters: Type83.Object({
+    domain: Type83.String({
       description: "Domain name to mint (without .ton extension, 4-126 chars)"
     }),
-    amount: Type81.Number({
+    amount: Type83.Number({
       description: "Bid amount in TON (must meet minimum: ~100 TON for 4 chars, ~1 TON for 11+ chars)",
       minimum: 1
     })
@@ -15700,7 +16133,7 @@ var dnsStartAuctionExecutor = async (params, context) => {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint7({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient7({ endpoint });
     const contract = client.open(wallet);
     const seqno = await contract.getSeqno();
@@ -15741,19 +16174,18 @@ var dnsStartAuctionExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/bid.ts
-import { Type as Type82 } from "@sinclair/typebox";
+import { Type as Type84 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey5 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R15, TonClient as TonClient8, toNano as toNano4, internal as internal4 } from "@ton/ton";
 import { Address as Address7, SendMode as SendMode4 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint8 } from "@orbs-network/ton-access";
 var dnsBidTool = {
   name: "dns_bid",
   description: "Place a bid on an existing .ton domain auction. Bid must be at least 5% higher than current bid. The domain must already be in auction (use dns_check first to verify status and get current bid).",
-  parameters: Type82.Object({
-    domain: Type82.String({
+  parameters: Type84.Object({
+    domain: Type84.String({
       description: "Domain name (with or without .ton extension)"
     }),
-    amount: Type82.Number({
+    amount: Type84.Number({
       description: "Bid amount in TON (must be >= 105% of current bid)",
       minimum: 1
     })
@@ -15818,7 +16250,7 @@ var dnsBidExecutor = async (params, context) => {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint8({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient8({ endpoint });
     const contract = client.open(wallet);
     const seqno = await contract.getSeqno();
@@ -15859,11 +16291,10 @@ var dnsBidExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/link.ts
-import { Type as Type83 } from "@sinclair/typebox";
+import { Type as Type85 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey6 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R16, TonClient as TonClient9, toNano as toNano5, internal as internal5, beginCell as beginCell2 } from "@ton/ton";
 import { Address as Address8, SendMode as SendMode5 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint9 } from "@orbs-network/ton-access";
 var DNS_CHANGE_RECORD_OP = 1320284409;
 var DNS_SMC_ADDRESS_PREFIX = 40915;
 var WALLET_RECORD_KEY = BigInt(
@@ -15872,12 +16303,12 @@ var WALLET_RECORD_KEY = BigInt(
 var dnsLinkTool = {
   name: "dns_link",
   description: "Link a wallet address to a .ton domain you own. This sets the wallet record so the domain resolves to the specified address. If no wallet_address is provided, links to your own wallet.",
-  parameters: Type83.Object({
-    domain: Type83.String({
+  parameters: Type85.Object({
+    domain: Type85.String({
       description: "Domain name (with or without .ton extension)"
     }),
-    wallet_address: Type83.Optional(
-      Type83.String({
+    wallet_address: Type85.Optional(
+      Type85.String({
         description: "Wallet address to link (defaults to your wallet if not specified)"
       })
     )
@@ -15945,7 +16376,7 @@ var dnsLinkExecutor = async (params, context) => {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint9({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient9({ endpoint });
     const contract = client.open(wallet);
     const seqno = await contract.getSeqno();
@@ -15987,11 +16418,10 @@ var dnsLinkExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/unlink.ts
-import { Type as Type84 } from "@sinclair/typebox";
+import { Type as Type86 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey7 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient10, toNano as toNano6, internal as internal6, beginCell as beginCell3 } from "@ton/ton";
 import { Address as Address9, SendMode as SendMode6 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint10 } from "@orbs-network/ton-access";
 var DNS_CHANGE_RECORD_OP2 = 1320284409;
 var WALLET_RECORD_KEY2 = BigInt(
   "0xe8d44050873dba865aa7c170ab4cce64d90839a34dcfd6cf71d14e0205443b1b"
@@ -15999,8 +16429,8 @@ var WALLET_RECORD_KEY2 = BigInt(
 var dnsUnlinkTool = {
   name: "dns_unlink",
   description: "Remove the wallet link from a .ton domain you own. This deletes the wallet record so the domain no longer resolves to any address.",
-  parameters: Type84.Object({
-    domain: Type84.String({
+  parameters: Type86.Object({
+    domain: Type86.String({
       description: "Domain name (with or without .ton extension)"
     })
   })
@@ -16058,7 +16488,7 @@ var dnsUnlinkExecutor = async (params, context) => {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint10({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient10({ endpoint });
     const contract = client.open(wallet);
     const seqno = await contract.getSeqno();
@@ -16109,11 +16539,11 @@ var tools17 = [
 ];
 
 // src/agent/tools/jetton/balances.ts
-import { Type as Type85 } from "@sinclair/typebox";
+import { Type as Type87 } from "@sinclair/typebox";
 var jettonBalancesTool = {
   name: "jetton_balances",
   description: "Get all Jetton (token) balances owned by the agent. Returns a list of all tokens with their balances, names, symbols, and verification status. Useful to check what tokens you currently hold.",
-  parameters: Type85.Object({}),
+  parameters: Type87.Object({}),
   category: "data-bearing"
 };
 var jettonBalancesExecutor = async (params, context) => {
@@ -16214,11 +16644,10 @@ var jettonBalancesExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/swap.ts
-import { Type as Type86 } from "@sinclair/typebox";
+import { Type as Type88 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey8 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R18, TonClient as TonClient11, toNano as toNano19, internal as internal7 } from "@ton/ton";
 import { SendMode as SendMode7 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint11 } from "@orbs-network/ton-access";
 
 // node_modules/@ston-fi/sdk/dist/chunk-HNMPFVZW.js
 import { Address as Address10, address } from "@ton/ton";
@@ -19544,19 +19973,19 @@ var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonSwapTool = {
   name: "jetton_swap",
   description: "Swap tokens on STON.fi DEX. Supports TON\u2194Jetton and Jetton\u2194Jetton swaps. Use 'ton' as from_asset to buy jettons with TON, or provide jetton master address. Amount is in human-readable units (will be converted based on decimals). Example: swap 10 TON for USDT, or swap USDT for SCALE.",
-  parameters: Type86.Object({
-    from_asset: Type86.String({
+  parameters: Type88.Object({
+    from_asset: Type88.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type86.String({
+    to_asset: Type88.String({
       description: "Destination jetton master address (EQ... format)"
     }),
-    amount: Type86.Number({
+    amount: Type88.Number({
       description: "Amount to swap in human-readable units (e.g., 10 for 10 TON or 10 tokens)",
       minimum: 1e-3
     }),
-    slippage: Type86.Optional(
-      Type86.Number({
+    slippage: Type88.Optional(
+      Type88.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -19589,7 +20018,7 @@ var jettonSwapExecutor = async (params, context) => {
         error: `Invalid to_asset address: ${toAddress2}`
       };
     }
-    const endpoint = await getHttpEndpoint11({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const tonClient = new TonClient11({ endpoint });
     const stonApiClient = new StonApiClient();
     console.log(`Simulating swap: ${amount} ${fromAddress} \u2192 ${toAddress2}`);
@@ -19674,28 +20103,27 @@ var jettonSwapExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/send.ts
-import { Type as Type87 } from "@sinclair/typebox";
+import { Type as Type89 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey9 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano20, internal as internal8 } from "@ton/ton";
 import { Address as Address13, SendMode as SendMode8, beginCell as beginCell15 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint12 } from "@orbs-network/ton-access";
 var JETTON_TRANSFER_OP = 260734629;
 var jettonSendTool = {
   name: "jetton_send",
   description: "Send Jettons (tokens) to another address. Requires the jetton master address, recipient address, and amount. Amount is in human-readable units (e.g., 10 for 10 USDT). Use jetton_balances first to see what tokens you own and their addresses.",
-  parameters: Type87.Object({
-    jetton_address: Type87.String({
+  parameters: Type89.Object({
+    jetton_address: Type89.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     }),
-    to: Type87.String({
+    to: Type89.String({
       description: "Recipient TON address (EQ... or UQ... format)"
     }),
-    amount: Type87.Number({
+    amount: Type89.Number({
       description: "Amount to send in human-readable units (e.g., 10 for 10 tokens)",
       minimum: 0
     }),
-    comment: Type87.Optional(
-      Type87.String({
+    comment: Type89.Optional(
+      Type89.String({
         description: "Optional comment/memo to include with the transfer"
       })
     )
@@ -19758,7 +20186,7 @@ var jettonSendExecutor = async (params, context) => {
       workchain: 0,
       publicKey: keyPair.publicKey
     });
-    const endpoint = await getHttpEndpoint12({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient12({ endpoint });
     const walletContract = client.open(wallet);
     const seqno = await walletContract.getSeqno();
@@ -19799,12 +20227,12 @@ var jettonSendExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/info.ts
-import { Type as Type88 } from "@sinclair/typebox";
+import { Type as Type90 } from "@sinclair/typebox";
 var jettonInfoTool = {
   name: "jetton_info",
   description: "Get detailed information about a Jetton (token) by its master contract address. Returns name, symbol, decimals, total supply, holders count, and verification status. Useful to research a token before buying or sending.",
-  parameters: Type88.Object({
-    jetton_address: Type88.String({
+  parameters: Type90.Object({
+    jetton_address: Type90.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     })
   })
@@ -19894,12 +20322,12 @@ function formatLargeNumber(num) {
 }
 
 // src/agent/tools/jetton/price.ts
-import { Type as Type89 } from "@sinclair/typebox";
+import { Type as Type91 } from "@sinclair/typebox";
 var jettonPriceTool = {
   name: "jetton_price",
   description: "Get the current price of a Jetton (token) in USD and TON, along with 24h, 7d, and 30d price changes. Useful to check token value before swapping or to monitor investments.",
-  parameters: Type89.Object({
-    jetton_address: Type89.String({
+  parameters: Type91.Object({
+    jetton_address: Type91.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     })
   })
@@ -19992,17 +20420,17 @@ var jettonPriceExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/search.ts
-import { Type as Type90 } from "@sinclair/typebox";
+import { Type as Type92 } from "@sinclair/typebox";
 var jettonSearchTool = {
   name: "jetton_search",
   description: "Search for Jettons (tokens) by name or symbol. Returns a list of matching tokens with their addresses, useful for finding a token's address before swapping or checking prices. Search is case-insensitive.",
-  parameters: Type90.Object({
-    query: Type90.String({
+  parameters: Type92.Object({
+    query: Type92.String({
       description: "Search query - token name or symbol (e.g., 'usdt', 'scale', 'not')",
       minLength: 1
     }),
-    limit: Type90.Optional(
-      Type90.Number({
+    limit: Type92.Optional(
+      Type92.Number({
         description: "Maximum number of results to return (default: 10, max: 50)",
         minimum: 1,
         maximum: 50
@@ -20111,25 +20539,25 @@ var jettonSearchExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/quote.ts
-import { Type as Type91 } from "@sinclair/typebox";
+import { Type as Type93 } from "@sinclair/typebox";
 import { toNano as toNano21 } from "@ton/ton";
 var NATIVE_TON_ADDRESS2 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonQuoteTool = {
   name: "jetton_quote",
   description: "Get a price quote for a token swap WITHOUT executing it. Shows expected output, minimum output, price impact, and fees. Use this to preview a swap before committing. Use 'ton' as from_asset for TON, or jetton master address.",
-  parameters: Type91.Object({
-    from_asset: Type91.String({
+  parameters: Type93.Object({
+    from_asset: Type93.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type91.String({
+    to_asset: Type93.String({
       description: "Destination jetton master address (EQ... format)"
     }),
-    amount: Type91.Number({
+    amount: Type93.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    slippage: Type91.Optional(
-      Type91.Number({
+    slippage: Type93.Optional(
+      Type93.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -20215,16 +20643,16 @@ var jettonQuoteExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/holders.ts
-import { Type as Type92 } from "@sinclair/typebox";
+import { Type as Type94 } from "@sinclair/typebox";
 var jettonHoldersTool = {
   name: "jetton_holders",
   description: "Get the top holders of a Jetton (token). Shows wallet addresses and their balances. Useful to analyze token distribution and identify whale wallets.",
-  parameters: Type92.Object({
-    jetton_address: Type92.String({
+  parameters: Type94.Object({
+    jetton_address: Type94.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     }),
-    limit: Type92.Optional(
-      Type92.Number({
+    limit: Type94.Optional(
+      Type94.Number({
         description: "Number of top holders to return (default: 10, max: 100)",
         minimum: 1,
         maximum: 100
@@ -20309,12 +20737,12 @@ var jettonHoldersExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/history.ts
-import { Type as Type93 } from "@sinclair/typebox";
+import { Type as Type95 } from "@sinclair/typebox";
 var jettonHistoryTool = {
   name: "jetton_history",
   description: "Get price history and performance data for a Jetton. Shows price changes over 24h, 7d, 30d periods, along with volume and market data. Useful for analyzing token trends.",
-  parameters: Type93.Object({
-    jetton_address: Type93.String({
+  parameters: Type95.Object({
+    jetton_address: Type95.String({
       description: "Jetton master contract address (EQ... format)"
     })
   })
@@ -20434,13 +20862,13 @@ var jettonHistoryExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/trending.ts
-import { Type as Type94 } from "@sinclair/typebox";
+import { Type as Type96 } from "@sinclair/typebox";
 var jettonTrendingTool = {
   name: "jetton_trending",
   description: "Get trending/popular Jettons on the TON blockchain. Shows tokens ranked by trading volume and liquidity. Useful for discovering popular tokens.",
-  parameters: Type94.Object({
-    limit: Type94.Optional(
-      Type94.Number({
+  parameters: Type96.Object({
+    limit: Type96.Optional(
+      Type96.Number({
         description: "Number of trending tokens to return (default: 10, max: 50)",
         minimum: 1,
         maximum: 50
@@ -20507,18 +20935,18 @@ var jettonTrendingExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/pools.ts
-import { Type as Type95 } from "@sinclair/typebox";
+import { Type as Type97 } from "@sinclair/typebox";
 var jettonPoolsTool = {
   name: "jetton_pools",
   description: "Get liquidity pools for a Jetton or list top pools by volume. Shows pool addresses, liquidity, volume, APY, and trading pairs. Useful for finding where to trade a token or analyzing DeFi opportunities.",
-  parameters: Type95.Object({
-    jetton_address: Type95.Optional(
-      Type95.String({
+  parameters: Type97.Object({
+    jetton_address: Type97.Optional(
+      Type97.String({
         description: "Jetton address to filter pools (optional - if not provided, returns top pools)"
       })
     ),
-    limit: Type95.Optional(
-      Type95.Number({
+    limit: Type97.Optional(
+      Type97.Number({
         description: "Number of pools to return (default: 10, max: 50)",
         minimum: 1,
         maximum: 50
@@ -20620,7 +21048,7 @@ var jettonPoolsExecutor = async (params, context) => {
 
 // src/agent/tools/jetton/index.ts
 var tools18 = [
-  { tool: jettonSwapTool, executor: jettonSwapExecutor, scope: "dm-only" },
+  { tool: jettonSwapTool, executor: jettonSwapExecutor },
   { tool: jettonSendTool, executor: jettonSendExecutor, scope: "dm-only" },
   { tool: jettonBalancesTool, executor: jettonBalancesExecutor },
   { tool: jettonInfoTool, executor: jettonInfoExecutor },
@@ -20634,10 +21062,9 @@ var tools18 = [
 ];
 
 // src/agent/tools/dedust/quote.ts
-import { Type as Type96 } from "@sinclair/typebox";
+import { Type as Type98 } from "@sinclair/typebox";
 import { TonClient as TonClient13, toNano as toNano22, fromNano as fromNano5 } from "@ton/ton";
 import { Address as Address14 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint13 } from "@orbs-network/ton-access";
 import { Factory, Asset, PoolType, ReadinessStatus } from "@dedust/sdk";
 
 // src/agent/tools/dedust/constants.ts
@@ -20659,24 +21086,24 @@ var NATIVE_TON_ADDRESS3 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var dedustQuoteTool = {
   name: "dedust_quote",
   description: "Get a price quote for a token swap on DeDust DEX WITHOUT executing it. Shows expected output, minimum output, and pool info. Use 'ton' as from_asset for TON, or jetton master address. Pool types: 'volatile' (default) or 'stable' (for stablecoins).",
-  parameters: Type96.Object({
-    from_asset: Type96.String({
+  parameters: Type98.Object({
+    from_asset: Type98.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type96.String({
+    to_asset: Type98.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type96.Number({
+    amount: Type98.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    pool_type: Type96.Optional(
-      Type96.Union([Type96.Literal("volatile"), Type96.Literal("stable")], {
+    pool_type: Type98.Optional(
+      Type98.Union([Type98.Literal("volatile"), Type98.Literal("stable")], {
         description: "Pool type: 'volatile' (default) or 'stable' for stablecoin pairs"
       })
     ),
-    slippage: Type96.Optional(
-      Type96.Number({
+    slippage: Type98.Optional(
+      Type98.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -20711,7 +21138,7 @@ var dedustQuoteExecutor = async (params, context) => {
         };
       }
     }
-    const endpoint = await getHttpEndpoint13({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const tonClient = new TonClient13({ endpoint });
     const factory = tonClient.open(
       Factory.createFromAddress(Address14.parse(DEDUST_FACTORY_MAINNET))
@@ -20791,33 +21218,32 @@ var dedustQuoteExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dedust/swap.ts
-import { Type as Type97 } from "@sinclair/typebox";
+import { Type as Type99 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey10 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano23, fromNano as fromNano6 } from "@ton/ton";
 import { Address as Address15 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint14 } from "@orbs-network/ton-access";
 import { Factory as Factory2, Asset as Asset2, PoolType as PoolType2, ReadinessStatus as ReadinessStatus2, JettonRoot, VaultJetton } from "@dedust/sdk";
 var dedustSwapTool = {
   name: "dedust_swap",
   description: "Execute a token swap on DeDust DEX. Supports TON->Jetton and Jetton->TON/Jetton swaps. Use 'ton' as from_asset or to_asset for TON. Pool types: 'volatile' (default) or 'stable' (for stablecoins like USDT/USDC). Use dedust_quote first to preview the swap.",
-  parameters: Type97.Object({
-    from_asset: Type97.String({
+  parameters: Type99.Object({
+    from_asset: Type99.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type97.String({
+    to_asset: Type99.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type97.Number({
+    amount: Type99.Number({
       description: "Amount to swap in human-readable units (e.g., 10 for 10 TON or 10 tokens)",
       minimum: 1e-3
     }),
-    pool_type: Type97.Optional(
-      Type97.Union([Type97.Literal("volatile"), Type97.Literal("stable")], {
+    pool_type: Type99.Optional(
+      Type99.Union([Type99.Literal("volatile"), Type99.Literal("stable")], {
         description: "Pool type: 'volatile' (default) or 'stable' for stablecoin pairs"
       })
     ),
-    slippage: Type97.Optional(
-      Type97.Number({
+    slippage: Type99.Optional(
+      Type99.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -20859,7 +21285,7 @@ var dedustSwapExecutor = async (params, context) => {
         };
       }
     }
-    const endpoint = await getHttpEndpoint14({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const tonClient = new TonClient14({ endpoint });
     const factory = tonClient.open(
       Factory2.createFromAddress(Address15.parse(DEDUST_FACTORY_MAINNET))
@@ -20963,23 +21389,23 @@ var dedustSwapExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dedust/pools.ts
-import { Type as Type98 } from "@sinclair/typebox";
+import { Type as Type100 } from "@sinclair/typebox";
 var dedustPoolsTool = {
   name: "dedust_pools",
   description: "List liquidity pools on DeDust DEX. Can filter by jetton address or pool type. Shows reserves, fees, and trading volume.",
-  parameters: Type98.Object({
-    jetton_address: Type98.Optional(
-      Type98.String({
+  parameters: Type100.Object({
+    jetton_address: Type100.Optional(
+      Type100.String({
         description: "Filter by jetton master address (EQ... format) to find pools containing this token"
       })
     ),
-    pool_type: Type98.Optional(
-      Type98.Union([Type98.Literal("volatile"), Type98.Literal("stable")], {
+    pool_type: Type100.Optional(
+      Type100.Union([Type100.Literal("volatile"), Type100.Literal("stable")], {
         description: "Filter by pool type: 'volatile' or 'stable'"
       })
     ),
-    limit: Type98.Optional(
-      Type98.Number({
+    limit: Type100.Optional(
+      Type100.Number({
         description: "Maximum number of pools to return (default: 20)",
         minimum: 1,
         maximum: 100
@@ -21089,33 +21515,32 @@ var dedustPoolsExecutor = async (params, context) => {
 
 // src/agent/tools/dedust/index.ts
 var tools19 = [
-  { tool: dedustSwapTool, executor: dedustSwapExecutor, scope: "dm-only" },
+  { tool: dedustSwapTool, executor: dedustSwapExecutor },
   { tool: dedustQuoteTool, executor: dedustQuoteExecutor },
   { tool: dedustPoolsTool, executor: dedustPoolsExecutor }
 ];
 
 // src/agent/tools/dex/smart-quote.ts
-import { Type as Type99 } from "@sinclair/typebox";
+import { Type as Type101 } from "@sinclair/typebox";
 import { TonClient as TonClient15, toNano as toNano24, fromNano as fromNano7 } from "@ton/ton";
 import { Address as Address16 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint15 } from "@orbs-network/ton-access";
 import { Factory as Factory3, Asset as Asset3, PoolType as PoolType3, ReadinessStatus as ReadinessStatus3 } from "@dedust/sdk";
 var dexQuoteTool = {
   name: "dex_quote",
   description: "Smart router that compares quotes from STON.fi and DeDust DEX to find the best price. Returns comparison table with expected outputs, fees, and recommends the best DEX for your swap. Use 'ton' for TON or jetton master address.",
-  parameters: Type99.Object({
-    from_asset: Type99.String({
+  parameters: Type101.Object({
+    from_asset: Type101.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type99.String({
+    to_asset: Type101.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type99.Number({
+    amount: Type101.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    slippage: Type99.Optional(
-      Type99.Number({
+    slippage: Type101.Optional(
+      Type101.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -21245,7 +21670,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, tonClient) {
 var dexQuoteExecutor = async (params, context) => {
   try {
     const { from_asset, to_asset, amount, slippage = 0.01 } = params;
-    const endpoint = await getHttpEndpoint15({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const tonClient = new TonClient15({ endpoint });
     const [stonfiQuote, dedustQuote] = await Promise.all([
       getStonfiQuote(from_asset, to_asset, amount, slippage),
@@ -21353,35 +21778,34 @@ Use dex_swap to execute on the best DEX, or jetton_swap/dedust_swap for specific
 };
 
 // src/agent/tools/dex/smart-swap.ts
-import { Type as Type100 } from "@sinclair/typebox";
+import { Type as Type102 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey11 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R111, TonClient as TonClient16, toNano as toNano25, fromNano as fromNano8 } from "@ton/ton";
 import { Address as Address17, SendMode as SendMode9, internal as internal9 } from "@ton/core";
-import { getHttpEndpoint as getHttpEndpoint16 } from "@orbs-network/ton-access";
 import { Factory as Factory4, Asset as Asset4, PoolType as PoolType4, ReadinessStatus as ReadinessStatus4, JettonRoot as JettonRoot2, VaultJetton as VaultJetton2 } from "@dedust/sdk";
 var dexSwapTool = {
   name: "dex_swap",
   description: "Smart router that executes swap on the best DEX (STON.fi or DeDust). Automatically compares prices and routes to the DEX with better output. Use preferred_dex to force a specific DEX. Use 'ton' for TON or jetton master address.",
-  parameters: Type100.Object({
-    from_asset: Type100.String({
+  parameters: Type102.Object({
+    from_asset: Type102.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type100.String({
+    to_asset: Type102.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type100.Number({
+    amount: Type102.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    slippage: Type100.Optional(
-      Type100.Number({
+    slippage: Type102.Optional(
+      Type102.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
       })
     ),
-    preferred_dex: Type100.Optional(
-      Type100.Union([Type100.Literal("stonfi"), Type100.Literal("dedust"), Type100.Literal("auto")], {
+    preferred_dex: Type102.Optional(
+      Type102.Union([Type102.Literal("stonfi"), Type102.Literal("dedust"), Type102.Literal("auto")], {
         description: "Preferred DEX: 'auto' (default, best price), 'stonfi', or 'dedust'"
       })
     )
@@ -21579,7 +22003,7 @@ var dexSwapExecutor = async (params, context) => {
     if (!isTonOutput && !to_asset.match(/^[EUe][Qq][A-Za-z0-9_-]{46}$/)) {
       return { success: false, error: `Invalid to_asset address: ${to_asset}` };
     }
-    const endpoint = await getHttpEndpoint16({ network: "mainnet" });
+    const endpoint = await getCachedHttpEndpoint();
     const tonClient = new TonClient16({ endpoint });
     let stonfiQuote = null;
     let dedustQuote = null;
@@ -21693,12 +22117,12 @@ var dexSwapExecutor = async (params, context) => {
 
 // src/agent/tools/dex/index.ts
 var tools20 = [
-  { tool: dexSwapTool, executor: dexSwapExecutor, scope: "dm-only" },
+  { tool: dexSwapTool, executor: dexSwapExecutor },
   { tool: dexQuoteTool, executor: dexQuoteExecutor }
 ];
 
 // src/agent/tools/journal/log.ts
-import { Type as Type101 } from "@sinclair/typebox";
+import { Type as Type103 } from "@sinclair/typebox";
 var journalLogTool = {
   name: "journal_log",
   description: `Log a business operation to the trading journal.
@@ -21716,44 +22140,44 @@ Examples:
 - gift: "Sold Deluxe Heart at 120% floor - buyer was eager"
 - middleman: "Escrow for 150 TON gift trade - 3% fee"
 - kol: "Posted project review in channel - 75 TON fee"`,
-  parameters: Type101.Object({
-    type: Type101.Union(
-      [Type101.Literal("trade"), Type101.Literal("gift"), Type101.Literal("middleman"), Type101.Literal("kol")],
+  parameters: Type103.Object({
+    type: Type103.Union(
+      [Type103.Literal("trade"), Type103.Literal("gift"), Type103.Literal("middleman"), Type103.Literal("kol")],
       { description: "Type of operation" }
     ),
-    action: Type101.String({
+    action: Type103.String({
       description: "Brief action description (e.g., 'buy', 'sell', 'swap', 'escrow', 'post')"
     }),
-    asset_from: Type101.Optional(
-      Type101.String({ description: "Asset sent/sold (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
+    asset_from: Type103.Optional(
+      Type103.String({ description: "Asset sent/sold (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
     ),
-    asset_to: Type101.Optional(Type101.String({ description: "Asset received/bought" })),
-    amount_from: Type101.Optional(Type101.Number({ description: "Amount sent/sold" })),
-    amount_to: Type101.Optional(Type101.Number({ description: "Amount received/bought" })),
-    price_ton: Type101.Optional(Type101.Number({ description: "Price in TON (for gifts, services)" })),
-    counterparty: Type101.Optional(
-      Type101.String({ description: "Username or ID of the other party (if applicable)" })
+    asset_to: Type103.Optional(Type103.String({ description: "Asset received/bought" })),
+    amount_from: Type103.Optional(Type103.Number({ description: "Amount sent/sold" })),
+    amount_to: Type103.Optional(Type103.Number({ description: "Amount received/bought" })),
+    price_ton: Type103.Optional(Type103.Number({ description: "Price in TON (for gifts, services)" })),
+    counterparty: Type103.Optional(
+      Type103.String({ description: "Username or ID of the other party (if applicable)" })
     ),
-    platform: Type101.Optional(
-      Type101.String({ description: "Platform used (e.g., 'STON.fi', 'Telegram', 'DeDust')" })
+    platform: Type103.Optional(
+      Type103.String({ description: "Platform used (e.g., 'STON.fi', 'Telegram', 'DeDust')" })
     ),
-    reasoning: Type101.String({
+    reasoning: Type103.String({
       description: "WHY you took this action - explain your decision-making (this is CRITICAL for learning and auditing)"
     }),
-    outcome: Type101.Optional(
-      Type101.Union(
+    outcome: Type103.Optional(
+      Type103.Union(
         [
-          Type101.Literal("pending"),
-          Type101.Literal("profit"),
-          Type101.Literal("loss"),
-          Type101.Literal("neutral"),
-          Type101.Literal("cancelled")
+          Type103.Literal("pending"),
+          Type103.Literal("profit"),
+          Type103.Literal("loss"),
+          Type103.Literal("neutral"),
+          Type103.Literal("cancelled")
         ],
         { description: "Outcome status (default: 'pending')" }
       )
     ),
-    tx_hash: Type101.Optional(
-      Type101.String({ description: "Blockchain transaction hash (if applicable)" })
+    tx_hash: Type103.Optional(
+      Type103.String({ description: "Blockchain transaction hash (if applicable)" })
     )
   })
 };
@@ -21813,7 +22237,7 @@ var journalLogExecutor = async (params, context) => {
 };
 
 // src/agent/tools/journal/query.ts
-import { Type as Type102 } from "@sinclair/typebox";
+import { Type as Type104 } from "@sinclair/typebox";
 var journalQueryTool = {
   name: "journal_query",
   description: `Query the trading journal to analyze past operations.
@@ -21829,38 +22253,38 @@ Examples:
 - "What gifts did I sell this week?"
 - "Show all profitable TON trades"
 - "What's my win rate on crypto trades?"`,
-  parameters: Type102.Object({
-    type: Type102.Optional(
-      Type102.Union(
+  parameters: Type104.Object({
+    type: Type104.Optional(
+      Type104.Union(
         [
-          Type102.Literal("trade"),
-          Type102.Literal("gift"),
-          Type102.Literal("middleman"),
-          Type102.Literal("kol")
+          Type104.Literal("trade"),
+          Type104.Literal("gift"),
+          Type104.Literal("middleman"),
+          Type104.Literal("kol")
         ],
         { description: "Filter by operation type" }
       )
     ),
-    asset: Type102.Optional(
-      Type102.String({ description: "Filter by asset (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
+    asset: Type104.Optional(
+      Type104.String({ description: "Filter by asset (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
     ),
-    outcome: Type102.Optional(
-      Type102.Union(
+    outcome: Type104.Optional(
+      Type104.Union(
         [
-          Type102.Literal("pending"),
-          Type102.Literal("profit"),
-          Type102.Literal("loss"),
-          Type102.Literal("neutral"),
-          Type102.Literal("cancelled")
+          Type104.Literal("pending"),
+          Type104.Literal("profit"),
+          Type104.Literal("loss"),
+          Type104.Literal("neutral"),
+          Type104.Literal("cancelled")
         ],
         { description: "Filter by outcome status" }
       )
     ),
-    days: Type102.Optional(
-      Type102.Number({ description: "Limit to last N days (e.g., 7 for last week)", minimum: 1 })
+    days: Type104.Optional(
+      Type104.Number({ description: "Limit to last N days (e.g., 7 for last week)", minimum: 1 })
     ),
-    limit: Type102.Optional(
-      Type102.Number({ description: "Max number of results (default: 20)", minimum: 1 })
+    limit: Type104.Optional(
+      Type104.Number({ description: "Max number of results (default: 20)", minimum: 1 })
     )
   })
 };
@@ -21948,7 +22372,7 @@ var journalQueryExecutor = async (params) => {
 };
 
 // src/agent/tools/journal/update.ts
-import { Type as Type103 } from "@sinclair/typebox";
+import { Type as Type105 } from "@sinclair/typebox";
 var journalUpdateTool = {
   name: "journal_update",
   description: `Update a journal entry with outcome and P&L.
@@ -21967,25 +22391,25 @@ Examples:
 - "Close trade #42 - sold at profit"
 - "Mark gift sale #38 as complete"
 - "Update escrow #55 with tx hash"`,
-  parameters: Type103.Object({
-    id: Type103.Number({ description: "Journal entry ID to update" }),
-    outcome: Type103.Optional(
-      Type103.Union(
+  parameters: Type105.Object({
+    id: Type105.Number({ description: "Journal entry ID to update" }),
+    outcome: Type105.Optional(
+      Type105.Union(
         [
-          Type103.Literal("pending"),
-          Type103.Literal("profit"),
-          Type103.Literal("loss"),
-          Type103.Literal("neutral"),
-          Type103.Literal("cancelled")
+          Type105.Literal("pending"),
+          Type105.Literal("profit"),
+          Type105.Literal("loss"),
+          Type105.Literal("neutral"),
+          Type105.Literal("cancelled")
         ],
         { description: "Update outcome status" }
       )
     ),
-    pnl_ton: Type103.Optional(
-      Type103.Number({ description: "Profit/loss in TON (positive = profit, negative = loss)" })
+    pnl_ton: Type105.Optional(
+      Type105.Number({ description: "Profit/loss in TON (positive = profit, negative = loss)" })
     ),
-    pnl_pct: Type103.Optional(Type103.Number({ description: "Profit/loss percentage" })),
-    tx_hash: Type103.Optional(Type103.String({ description: "Add or update transaction hash" }))
+    pnl_pct: Type105.Optional(Type105.Number({ description: "Profit/loss percentage" })),
+    tx_hash: Type105.Optional(Type105.String({ description: "Add or update transaction hash" }))
   })
 };
 var journalUpdateExecutor = async (params) => {
@@ -22054,7 +22478,7 @@ var tools21 = [
 ];
 
 // src/agent/tools/workspace/list.ts
-import { Type as Type104 } from "@sinclair/typebox";
+import { Type as Type106 } from "@sinclair/typebox";
 import { readdirSync as readdirSync3, lstatSync as lstatSync2 } from "fs";
 import { join as join11 } from "path";
 var workspaceListTool = {
@@ -22069,19 +22493,19 @@ Your workspace is at ~/.teleton/workspace/ and contains:
 - temp/ (temporary files)
 
 You can ONLY access files within this workspace. Files outside (config.yaml, wallet.json, etc.) are protected.`,
-  parameters: Type104.Object({
-    path: Type104.Optional(
-      Type104.String({
+  parameters: Type106.Object({
+    path: Type106.Optional(
+      Type106.String({
         description: "Subdirectory to list (relative to workspace root). Leave empty for root."
       })
     ),
-    recursive: Type104.Optional(
-      Type104.Boolean({
+    recursive: Type106.Optional(
+      Type106.Boolean({
         description: "List files recursively (default: false)"
       })
     ),
-    filter: Type104.Optional(
-      Type104.String({
+    filter: Type106.Optional(
+      Type106.String({
         description: "Filter by type: 'all' (default), 'files', or 'directories'",
         enum: ["all", "files", "directories"]
       })
@@ -22153,7 +22577,7 @@ var workspaceListExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/read.ts
-import { Type as Type105 } from "@sinclair/typebox";
+import { Type as Type107 } from "@sinclair/typebox";
 import { readFileSync as readFileSync13, lstatSync as lstatSync3 } from "fs";
 var workspaceReadTool = {
   name: "workspace_read",
@@ -22169,18 +22593,18 @@ Examples:
 - Read your memory: path="MEMORY.md"
 - Read today's log: path="memory/2024-01-15.md"
 - Read downloaded image info: path="downloads/image.jpg" (will return metadata only)`,
-  parameters: Type105.Object({
-    path: Type105.String({
+  parameters: Type107.Object({
+    path: Type107.String({
       description: "Path to file (relative to workspace root)"
     }),
-    encoding: Type105.Optional(
-      Type105.String({
+    encoding: Type107.Optional(
+      Type107.String({
         description: "File encoding: 'utf-8' (default) or 'base64'",
         enum: ["utf-8", "base64"]
       })
     ),
-    maxSize: Type105.Optional(
-      Type105.Number({
+    maxSize: Type107.Optional(
+      Type107.Number({
         description: "Max file size to read in bytes (default: 1MB)"
       })
     )
@@ -22255,7 +22679,7 @@ var workspaceReadExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/write.ts
-import { Type as Type106 } from "@sinclair/typebox";
+import { Type as Type108 } from "@sinclair/typebox";
 import { writeFileSync as writeFileSync9, appendFileSync as appendFileSync3, mkdirSync as mkdirSync9, existsSync as existsSync13 } from "fs";
 import { dirname as dirname6 } from "path";
 var workspaceWriteTool = {
@@ -22272,26 +22696,26 @@ You CANNOT write to protected locations like config.yaml, wallet.json, etc.
 Examples:
 - Save a note: path="memory/note.md", content="..."
 - Prepare upload: path="uploads/message.txt", content="..."`,
-  parameters: Type106.Object({
-    path: Type106.String({
+  parameters: Type108.Object({
+    path: Type108.String({
       description: "Path to file (relative to workspace root)"
     }),
-    content: Type106.String({
+    content: Type108.String({
       description: "Content to write"
     }),
-    encoding: Type106.Optional(
-      Type106.String({
+    encoding: Type108.Optional(
+      Type108.String({
         description: "Content encoding: 'utf-8' (default) or 'base64'",
         enum: ["utf-8", "base64"]
       })
     ),
-    append: Type106.Optional(
-      Type106.Boolean({
+    append: Type108.Optional(
+      Type108.Boolean({
         description: "Append to file instead of overwriting (default: false)"
       })
     ),
-    createDirs: Type106.Optional(
-      Type106.Boolean({
+    createDirs: Type108.Optional(
+      Type108.Boolean({
         description: "Create parent directories if they don't exist (default: true)"
       })
     )
@@ -22312,7 +22736,6 @@ var workspaceWriteExecutor = async (params, _context) => {
       writeContent = content;
     }
     const contentSize = Buffer.byteLength(writeContent);
-    const MAX_WRITE_SIZE = 50 * 1024 * 1024;
     if (contentSize > MAX_WRITE_SIZE) {
       return {
         success: false,
@@ -22349,7 +22772,7 @@ var workspaceWriteExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/delete.ts
-import { Type as Type107 } from "@sinclair/typebox";
+import { Type as Type109 } from "@sinclair/typebox";
 import { unlinkSync as unlinkSync3, rmdirSync, readdirSync as readdirSync4, rmSync } from "fs";
 var PROTECTED_WORKSPACE_FILES = [
   "SOUL.md",
@@ -22371,12 +22794,12 @@ You CAN delete:
 - Custom files you've created
 
 Use recursive=true to delete non-empty directories.`,
-  parameters: Type107.Object({
-    path: Type107.String({
+  parameters: Type109.Object({
+    path: Type109.String({
       description: "Path to file or directory to delete"
     }),
-    recursive: Type107.Optional(
-      Type107.Boolean({
+    recursive: Type109.Optional(
+      Type109.Boolean({
         description: "Delete directory recursively (default: false)"
       })
     )
@@ -22431,7 +22854,7 @@ var workspaceDeleteExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/info.ts
-import { Type as Type108 } from "@sinclair/typebox";
+import { Type as Type110 } from "@sinclair/typebox";
 import { lstatSync as lstatSync4, readdirSync as readdirSync5, existsSync as existsSync14 } from "fs";
 import { join as join12 } from "path";
 var MEMES_DIR = WORKSPACE_PATHS.MEMES_DIR;
@@ -22444,9 +22867,9 @@ Returns:
 - Directory structure
 - File counts and sizes
 - Usage limits`,
-  parameters: Type108.Object({
-    detailed: Type108.Optional(
-      Type108.Boolean({
+  parameters: Type110.Object({
+    detailed: Type110.Optional(
+      Type110.Boolean({
         description: "Include detailed file listing (default: false)"
       })
     )
@@ -22545,7 +22968,7 @@ var workspaceInfoExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/rename.ts
-import { Type as Type109 } from "@sinclair/typebox";
+import { Type as Type111 } from "@sinclair/typebox";
 import { renameSync, existsSync as existsSync15 } from "fs";
 import { dirname as dirname7 } from "path";
 import { mkdirSync as mkdirSync10 } from "fs";
@@ -22564,15 +22987,15 @@ Examples:
 - Organize: from="downloads/doc.pdf", to="downloads/contracts/2026/lease.pdf"
 
 CANNOT move/rename files outside workspace or to protected locations.`,
-  parameters: Type109.Object({
-    from: Type109.String({
+  parameters: Type111.Object({
+    from: Type111.String({
       description: "Current path of the file (relative to workspace)"
     }),
-    to: Type109.String({
+    to: Type111.String({
       description: "New path for the file (relative to workspace)"
     }),
-    overwrite: Type109.Optional(
-      Type109.Boolean({
+    overwrite: Type111.Optional(
+      Type111.Boolean({
         description: "Overwrite if destination exists (default: false)"
       })
     )
@@ -22772,7 +23195,7 @@ function getCasinoDb() {
 }
 
 // src/agent/tools/casino/balance.ts
-import { Type as Type110 } from "@sinclair/typebox";
+import { Type as Type112 } from "@sinclair/typebox";
 var casinoBalanceTool = {
   name: "casino_balance",
   description: `Check Teleton Casino bankroll status and betting limits.
@@ -22789,7 +23212,7 @@ Teleton Casino needs sufficient balance to cover potential payouts (up to 5x the
 
 IMPORTANT: When a player wants to bet, tell them to send TON to Teleton Casino address with their username as memo.
 Example: "Send 2 TON to EQxxx with memo: john_doe"`,
-  parameters: Type110.Object({})
+  parameters: Type112.Object({})
 };
 var casinoBalanceExecutor = async (params, context) => {
   try {
@@ -22855,7 +23278,7 @@ var casinoBalanceExecutor = async (params, context) => {
 };
 
 // src/agent/tools/casino/spin.ts
-import { Type as Type111 } from "@sinclair/typebox";
+import { Type as Type113 } from "@sinclair/typebox";
 
 // src/casino/game-engine.ts
 import { Api as Api57 } from "telegram";
@@ -22928,10 +23351,10 @@ async function sendPayout(playerAddress, amount, message) {
     const endpoint = await getCachedHttpEndpoint();
     const client = new TonClient17({ endpoint });
     const contract = client.open(wallet);
-    const seqno = await withBlockchainRetry(() => contract.getSeqno(), "getSeqno");
-    await withBlockchainRetry(
-      () => contract.sendTransfer({
-        seqno,
+    const seqno = await withBlockchainRetry(async () => {
+      const seq = await contract.getSeqno();
+      await contract.sendTransfer({
+        seqno: seq,
         secretKey: keyPair.secretKey,
         sendMode: SendMode10.PAY_GAS_SEPARATELY,
         messages: [
@@ -22942,9 +23365,9 @@ async function sendPayout(playerAddress, amount, message) {
             bounce: false
           })
         ]
-      }),
-      "sendTransfer"
-    );
+      });
+      return seq;
+    }, "payout");
     const walletAddr = wallet.address.toString({ bounceable: false });
     const walletShort = walletAddr.slice(-8);
     const timestamp = Date.now();
@@ -23233,19 +23656,19 @@ Process:
 6. AUTO-PAYOUT if player wins
 
 Tell the user: "Send X TON to [casino_address] with memo: your_username"`,
-  parameters: Type111.Object({
-    chat_id: Type111.String({
+  parameters: Type113.Object({
+    chat_id: Type113.String({
       description: "Telegram chat ID where to send the spin"
     }),
-    bet_amount: Type111.Number({
+    bet_amount: Type113.Number({
       description: "Bet amount in TON",
       minimum: 0.1
     }),
-    player_username: Type111.String({
+    player_username: Type113.String({
       description: "Player's Telegram username (without @)"
     }),
-    reply_to: Type111.Optional(
-      Type111.Number({
+    reply_to: Type113.Optional(
+      Type113.Number({
         description: "Message ID to reply to"
       })
     )
@@ -23269,7 +23692,7 @@ var casinoSpinExecutor = async (params, context) => {
 };
 
 // src/agent/tools/casino/dice.ts
-import { Type as Type112 } from "@sinclair/typebox";
+import { Type as Type114 } from "@sinclair/typebox";
 var casinoDiceTool = {
   name: "casino_dice",
   description: `Execute a Teleton Casino dice roll with full security checks.
@@ -23289,19 +23712,19 @@ Same security as slot:
 6. AUTO-PAYOUT if player wins
 
 Tell the user: "Send X TON to [casino_address] with memo: your_username"`,
-  parameters: Type112.Object({
-    chat_id: Type112.String({
+  parameters: Type114.Object({
+    chat_id: Type114.String({
       description: "Telegram chat ID where to send the dice"
     }),
-    bet_amount: Type112.Number({
+    bet_amount: Type114.Number({
       description: "Bet amount in TON",
       minimum: 0.1
     }),
-    player_username: Type112.String({
+    player_username: Type114.String({
       description: "Player's Telegram username (without @)"
     }),
-    reply_to: Type112.Optional(
-      Type112.Number({
+    reply_to: Type114.Optional(
+      Type114.Number({
         description: "Message ID to reply to"
       })
     )
@@ -23325,7 +23748,7 @@ var casinoDiceExecutor = async (params, context) => {
 };
 
 // src/agent/tools/casino/leaderboard.ts
-import { Type as Type113 } from "@sinclair/typebox";
+import { Type as Type115 } from "@sinclair/typebox";
 var casinoLeaderboardTool = {
   name: "casino_leaderboard",
   description: `Show Teleton Casino leaderboard with top players.
@@ -23340,16 +23763,16 @@ Shows:
 - Total amount wagered
 - Total wins/losses
 - Win rate percentage`,
-  parameters: Type113.Object({
-    limit: Type113.Optional(
-      Type113.Number({
+  parameters: Type115.Object({
+    limit: Type115.Optional(
+      Type115.Number({
         description: "Number of players to show (default: 10)",
         minimum: 1,
         maximum: 50
       })
     ),
-    type: Type113.Optional(
-      Type113.String({
+    type: Type115.Optional(
+      Type115.String({
         description: "Leaderboard type: winners, losers, or wagered",
         enum: ["winners", "losers", "wagered"]
       })
@@ -23454,7 +23877,7 @@ ${formattedPlayers}`
 };
 
 // src/agent/tools/casino/my-stats.ts
-import { Type as Type114 } from "@sinclair/typebox";
+import { Type as Type116 } from "@sinclair/typebox";
 var casinoMyStatsTool = {
   name: "casino_my_stats",
   description: `Show the current player's personal Teleton Casino statistics.
@@ -23467,7 +23890,7 @@ Returns:
 - Net profit/loss
 - Win rate percentage
 - Last bet timestamp`,
-  parameters: Type114.Object({})
+  parameters: Type116.Object({})
 };
 var casinoMyStatsExecutor = async (params, context) => {
   try {
@@ -23596,7 +24019,7 @@ var MarketScraperService = class {
     this.isScrapingInProgress = true;
     console.log("\u{1F504} Starting full market scrape...");
     try {
-      const { runScraper } = await import("./scraper-DSAYK6QJ.js");
+      const { runScraper } = await import("./scraper-KXRBQMVQ.js");
       const result = await runScraper({
         workers: 4,
         limit: 0
@@ -23940,6 +24363,85 @@ function loadModules(registry, config, db3) {
   return loaded;
 }
 
+// src/agent/tools/module-permissions.ts
+var PROTECTED_MODULES = /* @__PURE__ */ new Set(["telegram", "memory"]);
+var ModulePermissions = class {
+  db;
+  /** chatId → module → level */
+  cache = /* @__PURE__ */ new Map();
+  constructor(db3) {
+    this.db = db3;
+    this.ensureTable();
+    this.loadAll();
+  }
+  ensureTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS group_modules (
+        chat_id    TEXT NOT NULL,
+        module     TEXT NOT NULL,
+        level      TEXT NOT NULL CHECK(level IN ('open', 'admin', 'disabled')),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_by INTEGER,
+        PRIMARY KEY (chat_id, module)
+      )
+    `);
+  }
+  loadAll() {
+    const rows = this.db.prepare("SELECT chat_id, module, level FROM group_modules").all();
+    for (const row of rows) {
+      let chatMap = this.cache.get(row.chat_id);
+      if (!chatMap) {
+        chatMap = /* @__PURE__ */ new Map();
+        this.cache.set(row.chat_id, chatMap);
+      }
+      chatMap.set(row.module, row.level);
+    }
+  }
+  /** Get the effective level for a module in a chat. Default: "open". */
+  getLevel(chatId, module) {
+    return this.cache.get(chatId)?.get(module) ?? "open";
+  }
+  /** Set the level for a module in a chat. Throws if module is protected. */
+  setLevel(chatId, module, level, userId) {
+    if (PROTECTED_MODULES.has(module)) {
+      throw new Error(`Module "${module}" est prot\xE9g\xE9`);
+    }
+    if (level === "open") {
+      this.db.prepare("DELETE FROM group_modules WHERE chat_id = ? AND module = ?").run(chatId, module);
+      this.cache.get(chatId)?.delete(module);
+    } else {
+      this.db.prepare(
+        `INSERT OR REPLACE INTO group_modules (chat_id, module, level, updated_at, updated_by)
+           VALUES (?, ?, ?, unixepoch(), ?)`
+      ).run(chatId, module, level, userId ?? null);
+      let chatMap = this.cache.get(chatId);
+      if (!chatMap) {
+        chatMap = /* @__PURE__ */ new Map();
+        this.cache.set(chatId, chatMap);
+      }
+      chatMap.set(module, level);
+    }
+  }
+  /** Reset a single module to default ("open"). */
+  resetModule(chatId, module) {
+    this.db.prepare("DELETE FROM group_modules WHERE chat_id = ? AND module = ?").run(chatId, module);
+    this.cache.get(chatId)?.delete(module);
+  }
+  /** Reset all modules for a chat to default ("open"). */
+  resetAll(chatId) {
+    this.db.prepare("DELETE FROM group_modules WHERE chat_id = ?").run(chatId);
+    this.cache.delete(chatId);
+  }
+  /** Get all non-default overrides for a chat. */
+  getOverrides(chatId) {
+    return this.cache.get(chatId) ?? /* @__PURE__ */ new Map();
+  }
+  /** Check if a module is protected (always open, cannot be changed). */
+  isProtected(module) {
+    return PROTECTED_MODULES.has(module);
+  }
+};
+
 // src/index.ts
 var TonnetApp = class {
   config;
@@ -23971,22 +24473,23 @@ var TonnetApp = class {
       autoReconnect: true,
       floodSleepThreshold: TELEGRAM_FLOOD_SLEEP_THRESHOLD
     });
-    const VECTOR_DIMENSIONS = 512;
+    const VECTOR_DIMENSIONS = 384;
     const memory = initializeMemory({
       database: {
         path: join16(TELETON_ROOT, "memory.db"),
-        enableVectorSearch: false,
+        enableVectorSearch: true,
         vectorDimensions: VECTOR_DIMENSIONS
       },
       embeddings: {
-        provider: "none",
-        apiKey: "",
+        provider: "local",
         model: ""
       },
       workspaceDir: join16(TELETON_ROOT)
     });
     const db3 = getDatabase().getDb();
     this.modules = loadModules(this.toolRegistry, this.config, db3);
+    const modulePermissions = new ModulePermissions(db3);
+    this.toolRegistry.setPermissions(modulePermissions);
     this.toolCount = this.toolRegistry.count;
     this.messageHandler = new MessageHandler(
       this.bridge,
@@ -23999,7 +24502,13 @@ var TonnetApp = class {
       this.config
       // Pass full config for vision tool API key access
     );
-    this.adminHandler = new AdminHandler(this.bridge, this.config.telegram, this.agent);
+    this.adminHandler = new AdminHandler(
+      this.bridge,
+      this.config.telegram,
+      this.agent,
+      modulePermissions,
+      this.toolRegistry
+    );
   }
   /**
    * Start the agent
@@ -24038,19 +24547,18 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
         `\u26A0\uFE0F Tool count (${this.toolCount}) exceeds ${providerMeta.displayName} limit (${providerMeta.toolLimit})`
       );
     }
-    const { migrateSessionsToDb } = await import("./migrate-7XOO67O5.js");
+    const { migrateSessionsToDb } = await import("./migrate-7OG67FXP.js");
     migrateSessionsToDb();
     const { cleanupOldTranscripts } = await import("./transcript-DF2Y6CFY.js");
     cleanupOldTranscripts(30);
     const memory = initializeMemory({
       database: {
         path: join16(TELETON_ROOT, "memory.db"),
-        enableVectorSearch: false,
-        vectorDimensions: 512
+        enableVectorSearch: true,
+        vectorDimensions: 384
       },
       embeddings: {
-        provider: "none",
-        apiKey: "",
+        provider: "local",
         model: ""
       },
       workspaceDir: join16(TELETON_ROOT)
@@ -24159,7 +24667,8 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
           const response = await this.adminHandler.handleCommand(
             adminCmd,
             message.chatId,
-            message.senderId
+            message.senderId,
+            message.isGroup
           );
           await this.bridge.sendMessage({
             chatId: message.chatId,
@@ -24187,8 +24696,8 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
       }
       const taskId = match[1];
       const { getTaskStore } = await import("./tasks-M3QDPTGY.js");
-      const { executeScheduledTask } = await import("./task-executor-MNI4VIZL.js");
-      const { getDatabase: getDatabase2 } = await import("./memory-OEOLPEXP.js");
+      const { executeScheduledTask } = await import("./task-executor-AUTT3VAL.js");
+      const { getDatabase: getDatabase2 } = await import("./memory-ZXDAJBL6.js");
       const db3 = getDatabase2().getDb();
       const taskStore = getTaskStore(db3);
       const task = taskStore.getTask(taskId);
@@ -24254,7 +24763,7 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
       taskStore.completeTask(taskId, response.content);
       console.log(`\u2705 Executed scheduled task ${taskId}: ${task.description}`);
       if (!this.dependencyResolver) {
-        const { TaskDependencyResolver } = await import("./task-dependency-resolver-CWG6DTU4.js");
+        const { TaskDependencyResolver } = await import("./task-dependency-resolver-S45DFI5C.js");
         this.dependencyResolver = new TaskDependencyResolver(taskStore, this.bridge);
       }
       await this.dependencyResolver.onTaskComplete(taskId);
@@ -24262,8 +24771,8 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
       console.error("Error handling scheduled task:", error);
       try {
         const { getTaskStore } = await import("./tasks-M3QDPTGY.js");
-        const { TaskDependencyResolver } = await import("./task-dependency-resolver-CWG6DTU4.js");
-        const { getDatabase: getDatabase2 } = await import("./memory-OEOLPEXP.js");
+        const { TaskDependencyResolver } = await import("./task-dependency-resolver-S45DFI5C.js");
+        const { getDatabase: getDatabase2 } = await import("./memory-ZXDAJBL6.js");
         const db3 = getDatabase2().getDb();
         const taskStore = getTaskStore(db3);
         const match = message.text.match(/^\[TASK:([^\]]+)\]/);
@@ -24303,14 +24812,19 @@ async function main(configPath) {
     console.error("\u{1F4A5} Uncaught exception:", error);
     process.exit(1);
   });
-  process.on("SIGINT", async () => {
-    await app.stop();
-    process.exit(0);
-  });
-  process.on("SIGTERM", async () => {
+  const gracefulShutdown = async () => {
+    const { SHUTDOWN_TIMEOUT_MS } = await import("./timeouts-ZAK6NELA.js");
+    const forceExit = setTimeout(() => {
+      console.error("\u26A0\uFE0F Shutdown timed out, forcing exit");
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    forceExit.unref();
     await app.stop();
+    clearTimeout(forceExit);
     process.exit(0);
-  });
+  };
+  process.on("SIGINT", gracefulShutdown);
+  process.on("SIGTERM", gracefulShutdown);
   await app.start();
 }
 if (import.meta.url === `file://${process.argv[1]}`) {