teleton 0.8.1 → 0.8.3

package/dist/{chunk-CGOXE4WP.js → chunk-7MWKT67G.js}

@@ -1,5 +1,4 @@
 import {
-  ConfigSchema,
   getCachedTonClient,
   getKeyPair,
   getTonPrice,
@@ -7,7 +6,13 @@ import {
   getWalletBalance,
   invalidateTonClientCache,
   loadWallet
-} from "./chunk-S6PHGKOC.js";
+} from "./chunk-FUNF6H4W.js";
+import {
+  expandPath
+} from "./chunk-AEHTQI3H.js";
+import {
+  ConfigSchema
+} from "./chunk-AERHOXGC.js";
 import {
   getOrCreateSession,
   getSession,
@@ -15,7 +20,22 @@ import {
   resetSessionWithPolicy,
   shouldResetSession,
   updateSession
-} from "./chunk-KVXV7EF7.js";
+} from "./chunk-XDZDOKIF.js";
+import {
+  ContextBuilder,
+  createDbWrapper,
+  getDatabase,
+  migrateFromMainDb,
+  openModuleDb
+} from "./chunk-GHMXWAXI.js";
+import {
+  saveSessionMemory,
+  summarizeWithFallback
+} from "./chunk-ALKAAG4O.js";
+import {
+  getErrorMessage,
+  isHttpError
+} from "./chunk-3UFPFWYP.js";
 import {
   Mi,
   Mn,
@@ -26,41 +46,11 @@ import {
   ut,
   ye
 } from "./chunk-7TECSLJ4.js";
-import {
-  getErrorMessage
-} from "./chunk-XBE4JB7C.js";
-import {
-  chatWithContext,
-  getEffectiveApiKey,
-  getProviderModel,
-  getUtilityModel,
-  loadContextFromTranscript
-} from "./chunk-AYWEJCDB.js";
-import {
-  getProviderMetadata,
-  getSupportedProviders
-} from "./chunk-PHSAHTK4.js";
-import {
-  appendToTranscript,
-  archiveTranscript,
-  transcriptExists
-} from "./chunk-QV2GLOTK.js";
-import {
-  ContextBuilder,
-  createDbWrapper,
-  getDatabase,
-  migrateFromMainDb,
-  openModuleDb
-} from "./chunk-7U7BOHCL.js";
 import {
   GECKOTERMINAL_API_URL,
   tonapiFetch
 } from "./chunk-VFA7QMCZ.js";
 import {
-  ADAPTIVE_CHUNK_RATIO_BASE,
-  ADAPTIVE_CHUNK_RATIO_MIN,
-  ADAPTIVE_CHUNK_RATIO_TRIGGER,
-  CHARS_PER_TOKEN_ESTIMATE,
   COMPACTION_KEEP_RECENT,
   COMPACTION_MAX_MESSAGES,
   COMPACTION_MAX_TOKENS_RATIO,
@@ -72,21 +62,28 @@ import {
   DEFAULT_MAX_SUMMARY_TOKENS,
   DEFAULT_MAX_TOKENS,
   DEFAULT_SOFT_THRESHOLD_TOKENS,
-  DEFAULT_SUMMARY_FALLBACK_TOKENS,
+  EMBEDDING_QUERY_MAX_CHARS,
   FALLBACK_SOFT_THRESHOLD_TOKENS,
   MASKING_KEEP_RECENT_COUNT,
   MAX_TOOL_RESULT_SIZE,
   MEMORY_FLUSH_RECENT_MESSAGES,
-  OVERSIZED_MESSAGE_RATIO,
   PAYMENT_TOLERANCE_RATIO,
   RATE_LIMIT_MAX_RETRIES,
   RESULT_TRUNCATION_KEEP_CHARS,
   RESULT_TRUNCATION_THRESHOLD,
   SERVER_ERROR_MAX_RETRIES,
-  SESSION_SLUG_MAX_TOKENS,
-  SESSION_SLUG_RECENT_MESSAGES,
-  TOKEN_ESTIMATE_SAFETY_MARGIN
-} from "./chunk-UP55PXFH.js";
+  TOOL_CONCURRENCY_LIMIT
+} from "./chunk-C4NKJT2Z.js";
+import {
+  chatWithContext,
+  getEffectiveApiKey,
+  getProviderModel,
+  loadContextFromTranscript
+} from "./chunk-LVTKJQ7O.js";
+import {
+  getProviderMetadata,
+  getSupportedProviders
+} from "./chunk-6OOHHJ4N.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
@@ -99,6 +96,11 @@ import {
   RETRY_DEFAULT_MAX_DELAY_MS,
   RETRY_DEFAULT_TIMEOUT_MS
 } from "./chunk-R4YSJ4EY.js";
+import {
+  appendToTranscript,
+  archiveTranscript,
+  transcriptExists
+} from "./chunk-LC4TV3KL.js";
 import {
   ALLOWED_EXTENSIONS,
   TELETON_ROOT,
@@ -107,131 +109,19 @@ import {
 } from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
-
-// src/config/loader.ts
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
-import { parse, stringify } from "yaml";
-import { homedir } from "os";
-import { dirname, join } from "path";
-var log = createLogger("Config");
-var DEFAULT_CONFIG_PATH = join(TELETON_ROOT, "config.yaml");
-function expandPath(path) {
-  if (path.startsWith("~")) {
-    return join(homedir(), path.slice(1));
-  }
-  return path;
-}
-function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
-  const fullPath = expandPath(configPath);
-  if (!existsSync(fullPath)) {
-    throw new Error(`Config file not found: ${fullPath}
-Run 'teleton setup' to create one.`);
-  }
-  let content;
-  try {
-    content = readFileSync(fullPath, "utf-8");
-  } catch (error) {
-    throw new Error(`Cannot read config file ${fullPath}: ${error.message}`);
-  }
-  let raw;
-  try {
-    raw = parse(content);
-  } catch (error) {
-    throw new Error(`Invalid YAML in ${fullPath}: ${error.message}`);
-  }
-  if (raw && typeof raw === "object" && "market" in raw) {
-    log.warn("config.market is deprecated and ignored. Use market-api plugin instead.");
-    delete raw.market;
-  }
-  const result = ConfigSchema.safeParse(raw);
-  if (!result.success) {
-    throw new Error(`Invalid config: ${result.error.message}`);
-  }
-  const config = result.data;
-  const provider = config.agent.provider;
-  if (provider !== "anthropic" && provider !== "claude-code" && !raw.agent?.model) {
-    const meta = getProviderMetadata(provider);
-    config.agent.model = meta.defaultModel;
-  }
-  config.telegram.session_path = expandPath(config.telegram.session_path);
-  config.storage.sessions_file = expandPath(config.storage.sessions_file);
-  config.storage.memory_file = expandPath(config.storage.memory_file);
-  if (process.env.TELETON_API_KEY) {
-    config.agent.api_key = process.env.TELETON_API_KEY;
-  }
-  if (process.env.TELETON_TG_API_ID) {
-    const apiId = parseInt(process.env.TELETON_TG_API_ID, 10);
-    if (isNaN(apiId)) {
-      throw new Error(
-        `Invalid TELETON_TG_API_ID environment variable: "${process.env.TELETON_TG_API_ID}" is not a valid integer`
-      );
-    }
-    config.telegram.api_id = apiId;
-  }
-  if (process.env.TELETON_TG_API_HASH) {
-    config.telegram.api_hash = process.env.TELETON_TG_API_HASH;
-  }
-  if (process.env.TELETON_TG_PHONE) {
-    config.telegram.phone = process.env.TELETON_TG_PHONE;
-  }
-  if (process.env.TELETON_WEBUI_ENABLED) {
-    config.webui.enabled = process.env.TELETON_WEBUI_ENABLED === "true";
-  }
-  if (process.env.TELETON_WEBUI_PORT) {
-    const port = parseInt(process.env.TELETON_WEBUI_PORT, 10);
-    if (!isNaN(port) && port >= 1024 && port <= 65535) {
-      config.webui.port = port;
-    }
-  }
-  if (process.env.TELETON_WEBUI_HOST) {
-    config.webui.host = process.env.TELETON_WEBUI_HOST;
-    if (!["127.0.0.1", "localhost", "::1"].includes(config.webui.host)) {
-      log.warn(
-        { host: config.webui.host },
-        "WebUI bound to non-loopback address \u2014 ensure auth_token is set"
-      );
-    }
-  }
-  if (process.env.TELETON_BASE_URL) {
-    try {
-      new URL(process.env.TELETON_BASE_URL);
-      config.agent.base_url = process.env.TELETON_BASE_URL;
-    } catch {
-      throw new Error(
-        `Invalid TELETON_BASE_URL: "${process.env.TELETON_BASE_URL}" is not a valid URL`
-      );
-    }
-  }
-  if (process.env.TELETON_TAVILY_API_KEY) {
-    config.tavily_api_key = process.env.TELETON_TAVILY_API_KEY;
-  }
-  if (process.env.TELETON_TONAPI_KEY) {
-    config.tonapi_key = process.env.TELETON_TONAPI_KEY;
-  }
-  if (process.env.TELETON_TONCENTER_API_KEY) {
-    config.toncenter_api_key = process.env.TELETON_TONCENTER_API_KEY;
-  }
-  return config;
-}
-function configExists(configPath = DEFAULT_CONFIG_PATH) {
-  return existsSync(expandPath(configPath));
-}
-function getDefaultConfigPath() {
-  return DEFAULT_CONFIG_PATH;
-}
+} from "./chunk-NQ6FZKCE.js";
 
 // src/soul/loader.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
 
 // src/memory/daily-logs.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, appendFileSync, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync, appendFileSync, readFileSync } from "fs";
+import { join } from "path";
 
 // src/workspace/validator.ts
-import { existsSync as existsSync2, lstatSync, readdirSync } from "fs";
+import { existsSync, lstatSync, readdirSync } from "fs";
 import { resolve, normalize, relative, extname, basename } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir } from "os";
 var WorkspaceSecurityError = class extends Error {
   constructor(message, attemptedPath) {
     super(message);
@@ -265,7 +155,7 @@ function validatePath(inputPath, allowCreate = false) {
   if (decodedPath.startsWith("/")) {
     absolutePath = resolve(normalize(decodedPath));
   } else if (decodedPath.startsWith("~/")) {
-    const expanded = decodedPath.replace(/^~(?=$|[\\/])/, homedir2());
+    const expanded = decodedPath.replace(/^~(?=$|[\\/])/, homedir());
     absolutePath = resolve(expanded);
   } else {
     absolutePath = resolve(WORKSPACE_ROOT, normalize(decodedPath));
@@ -277,7 +167,7 @@ function validatePath(inputPath, allowCreate = false) {
       inputPath
     );
   }
-  const exists = existsSync2(absolutePath);
+  const exists = existsSync(absolutePath);
   if (!exists && !allowCreate) {
     throw new WorkspaceSecurityError(
       `File not found: '${inputPath}' does not exist in workspace.`,
@@ -341,7 +231,7 @@ function validateDirectory(inputPath) {
 }
 
 // src/memory/daily-logs.ts
-var log2 = createLogger("Memory");
+var log = createLogger("Memory");
 var MEMORY_DIR = WORKSPACE_PATHS.MEMORY_DIR;
 function formatDate(date) {
   const year = date.getFullYear();
@@ -350,11 +240,11 @@ function formatDate(date) {
   return `${year}-${month}-${day}`;
 }
 function getDailyLogPath(date = /* @__PURE__ */ new Date()) {
-  return join2(MEMORY_DIR, `${formatDate(date)}.md`);
+  return join(MEMORY_DIR, `${formatDate(date)}.md`);
 }
 function ensureMemoryDir() {
-  if (!existsSync3(MEMORY_DIR)) {
-    mkdirSync2(MEMORY_DIR, { recursive: true });
+  if (!existsSync2(MEMORY_DIR)) {
+    mkdirSync(MEMORY_DIR, { recursive: true });
   }
 }
 function appendToDailyLog(content, date = /* @__PURE__ */ new Date()) {
@@ -362,11 +252,11 @@ function appendToDailyLog(content, date = /* @__PURE__ */ new Date()) {
     ensureMemoryDir();
     const logPath = getDailyLogPath(date);
     const timestamp = date.toLocaleTimeString("en-US", { hour12: false });
-    if (!existsSync3(logPath)) {
+    if (!existsSync2(logPath)) {
       const header = `# Daily Log - ${formatDate(date)}
 
 `;
-      appendFileSync(logPath, header, "utf-8");
+      appendFileSync(logPath, header, { encoding: "utf-8", mode: 384 });
     }
     const entry = `## ${timestamp}
 
@@ -376,16 +266,16 @@ ${content}
 
 `;
     appendFileSync(logPath, entry, "utf-8");
-    log2.info(`Daily log updated: ${logPath}`);
+    log.info(`Daily log updated: ${logPath}`);
   } catch (error) {
-    log2.error({ err: error }, "Failed to write daily log");
+    log.error({ err: error }, "Failed to write daily log");
   }
 }
 function readDailyLog(date = /* @__PURE__ */ new Date()) {
   try {
     const logPath = getDailyLogPath(date);
-    if (!existsSync3(logPath)) return null;
-    return readFileSync2(logPath, "utf-8");
+    if (!existsSync2(logPath)) return null;
+    return readFileSync(logPath, "utf-8");
   } catch {
     return null;
   }
@@ -466,7 +356,7 @@ function cachedReadFile(path) {
   if (cached && now < cached.expiry) return cached.content;
   let content = null;
   try {
-    if (existsSync4(path)) content = readFileSync3(path, "utf-8");
+    if (existsSync3(path)) content = readFileSync2(path, "utf-8");
   } catch {
   }
   fileCache.set(path, { content, expiry: now + FILE_CACHE_TTL });
@@ -741,397 +631,6 @@ ${body}`;
 
 // src/memory/compaction.ts
 import { randomUUID } from "crypto";
-
-// src/memory/ai-summarization.ts
-import {
-  complete
-} from "@mariozechner/pi-ai";
-var log3 = createLogger("Memory");
-function estimateMessageTokens(content) {
-  return Math.ceil(content.length / CHARS_PER_TOKEN_ESTIMATE * TOKEN_ESTIMATE_SAFETY_MARGIN);
-}
-function splitMessagesByTokens(messages, maxChunkTokens) {
-  if (messages.length === 0) {
-    return [];
-  }
-  const chunks = [];
-  let currentChunk = [];
-  let currentTokens = 0;
-  for (const message of messages) {
-    const content = extractMessageContent(message);
-    const messageTokens = estimateMessageTokens(content);
-    if (currentChunk.length > 0 && currentTokens + messageTokens > maxChunkTokens) {
-      chunks.push(currentChunk);
-      currentChunk = [];
-      currentTokens = 0;
-    }
-    currentChunk.push(message);
-    currentTokens += messageTokens;
-    if (messageTokens > maxChunkTokens && currentChunk.length === 1) {
-      chunks.push(currentChunk);
-      currentChunk = [];
-      currentTokens = 0;
-    }
-  }
-  if (currentChunk.length > 0) {
-    chunks.push(currentChunk);
-  }
-  return chunks;
-}
-function extractMessageContent(message) {
-  if (message.role === "user") {
-    return typeof message.content === "string" ? message.content : "[complex content]";
-  } else if (message.role === "assistant") {
-    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-  }
-  return "";
-}
-function formatMessagesForSummary(messages) {
-  const formatted = [];
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      const content = typeof msg.content === "string" ? msg.content : "[complex]";
-      const bodyMatch = content.match(/\] (.+)/s);
-      const body = bodyMatch ? bodyMatch[1] : content;
-      formatted.push(`User: ${body}`);
-    } else if (msg.role === "assistant") {
-      const textBlocks = msg.content.filter((b) => b.type === "text");
-      if (textBlocks.length > 0) {
-        const text = textBlocks.map((b) => b.text).join("\n");
-        formatted.push(`Assistant: ${text}`);
-      }
-      const toolCalls = msg.content.filter((b) => b.type === "toolCall");
-      if (toolCalls.length > 0) {
-        const toolNames = toolCalls.map((b) => b.name).join(", ");
-        formatted.push(`[Used tools: ${toolNames}]`);
-      }
-    } else if (msg.role === "toolResult") {
-      formatted.push(`[Tool result: ${msg.toolName}]`);
-    }
-  }
-  return formatted.join("\n\n");
-}
-function isOversizedForSummary(message, contextWindow) {
-  const content = extractMessageContent(message);
-  const tokens = estimateMessageTokens(content);
-  return tokens > contextWindow * OVERSIZED_MESSAGE_RATIO;
-}
-function computeAdaptiveChunkRatio(messages, contextWindow) {
-  const BASE_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_BASE;
-  const MIN_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_MIN;
-  if (messages.length === 0) {
-    return BASE_CHUNK_RATIO;
-  }
-  let totalTokens = 0;
-  for (const msg of messages) {
-    const content = extractMessageContent(msg);
-    totalTokens += estimateMessageTokens(content);
-  }
-  const avgTokens = totalTokens / messages.length;
-  const avgRatio = avgTokens / contextWindow;
-  if (avgRatio > ADAPTIVE_CHUNK_RATIO_TRIGGER) {
-    const reduction = Math.min(avgRatio * 2, BASE_CHUNK_RATIO - MIN_CHUNK_RATIO);
-    return Math.max(MIN_CHUNK_RATIO, BASE_CHUNK_RATIO - reduction);
-  }
-  return BASE_CHUNK_RATIO;
-}
-async function summarizeViaClaude(params) {
-  const provider = params.provider || "anthropic";
-  const model = getUtilityModel(provider, params.utilityModel);
-  const maxTokens = params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS;
-  const formatted = formatMessagesForSummary(params.messages);
-  if (!formatted.trim()) {
-    return "No conversation content to summarize.";
-  }
-  const defaultInstructions = `Summarize this conversation concisely. Focus on:
-- Key decisions made
-- Action items and TODOs
-- Open questions
-- Important context and constraints
-- Technical details that matter
-
-Be specific but concise. Preserve critical information.`;
-  const instructions = params.customInstructions ? `${defaultInstructions}
-
-Additional focus:
-${params.customInstructions}` : defaultInstructions;
-  try {
-    const context = {
-      messages: [
-        {
-          role: "user",
-          content: `${instructions}
-
-Conversation:
-${formatted}`,
-          timestamp: Date.now()
-        }
-      ]
-    };
-    const response = await complete(model, context, {
-      apiKey: params.apiKey,
-      maxTokens
-    });
-    const textContent = response.content.find((block) => block.type === "text");
-    const summary = textContent?.type === "text" ? textContent.text : "";
-    return summary.trim() || "Unable to generate summary.";
-  } catch (error) {
-    log3.error({ err: error }, "Summarization error");
-    throw new Error(`Summarization failed: ${getErrorMessage(error)}`);
-  }
-}
-async function summarizeInChunks(params) {
-  if (params.messages.length === 0) {
-    return {
-      summary: "No messages to summarize.",
-      tokensUsed: 0,
-      chunksProcessed: 0
-    };
-  }
-  const chunks = splitMessagesByTokens(params.messages, params.maxChunkTokens);
-  log3.info(`Splitting into ${chunks.length} chunks for summarization`);
-  if (chunks.length === 1) {
-    const summary = await summarizeViaClaude({
-      messages: chunks[0],
-      apiKey: params.apiKey,
-      maxSummaryTokens: params.maxSummaryTokens,
-      customInstructions: params.customInstructions,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-    return {
-      summary,
-      tokensUsed: estimateMessageTokens(summary),
-      chunksProcessed: 1
-    };
-  }
-  const partialSummaries = [];
-  for (let i = 0; i < chunks.length; i++) {
-    log3.info(`Summarizing chunk ${i + 1}/${chunks.length} (${chunks[i].length} messages)`);
-    const partial = await summarizeViaClaude({
-      messages: chunks[i],
-      apiKey: params.apiKey,
-      maxSummaryTokens: Math.floor(
-        (params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS) / 2
-      ),
-      customInstructions: params.customInstructions,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-    partialSummaries.push(partial);
-  }
-  log3.info(`Merging ${partialSummaries.length} partial summaries`);
-  const provider = params.provider || "anthropic";
-  const model = getUtilityModel(provider, params.utilityModel);
-  const mergeContext = {
-    messages: [
-      {
-        role: "user",
-        content: `Merge these partial conversation summaries into one cohesive summary.
-Preserve all key decisions, action items, open questions, and important context.
-Do not add new information - only synthesize what's provided.
-
-Partial summaries:
-
-${partialSummaries.map((s, i) => `Part ${i + 1}:
-${s}`).join("\n\n---\n\n")}`,
-        timestamp: Date.now()
-      }
-    ]
-  };
-  const mergeResponse = await complete(model, mergeContext, {
-    apiKey: params.apiKey,
-    maxTokens: params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS
-  });
-  const textContent = mergeResponse.content.find((block) => block.type === "text");
-  const merged = textContent?.type === "text" ? textContent.text : "";
-  return {
-    summary: merged.trim() || "Unable to merge summaries.",
-    tokensUsed: estimateMessageTokens(merged),
-    chunksProcessed: chunks.length
-  };
-}
-async function summarizeWithFallback(params) {
-  if (params.messages.length === 0) {
-    return {
-      summary: "No messages to summarize.",
-      tokensUsed: 0,
-      chunksProcessed: 0
-    };
-  }
-  const chunkRatio = computeAdaptiveChunkRatio(params.messages, params.contextWindow);
-  const maxChunkTokens = Math.floor(params.contextWindow * chunkRatio);
-  log3.info(
-    `AI Summarization: ${params.messages.length} messages, chunk ratio: ${(chunkRatio * 100).toFixed(0)}%`
-  );
-  try {
-    return await summarizeInChunks({
-      messages: params.messages,
-      apiKey: params.apiKey,
-      maxChunkTokens,
-      maxSummaryTokens: params.maxSummaryTokens,
-      customInstructions: params.customInstructions,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-  } catch (fullError) {
-    log3.warn(
-      `Full summarization failed: ${fullError instanceof Error ? fullError.message : String(fullError)}`
-    );
-  }
-  const smallMessages = [];
-  const oversizedNotes = [];
-  for (const msg of params.messages) {
-    if (isOversizedForSummary(msg, params.contextWindow)) {
-      const content = extractMessageContent(msg);
-      const tokens = estimateMessageTokens(content);
-      oversizedNotes.push(
-        `[Large ${msg.role} message (~${Math.round(tokens / 1e3)}K tokens) omitted from summary]`
-      );
-    } else {
-      smallMessages.push(msg);
-    }
-  }
-  log3.info(
-    `Fallback: Processing ${smallMessages.length} messages, skipping ${oversizedNotes.length} oversized`
-  );
-  if (smallMessages.length > 0) {
-    try {
-      const result = await summarizeInChunks({
-        messages: smallMessages,
-        apiKey: params.apiKey,
-        maxChunkTokens,
-        maxSummaryTokens: params.maxSummaryTokens,
-        customInstructions: params.customInstructions,
-        provider: params.provider,
-        utilityModel: params.utilityModel
-      });
-      const notes = oversizedNotes.length > 0 ? `
-
-${oversizedNotes.join("\n")}` : "";
-      return {
-        summary: result.summary + notes,
-        tokensUsed: result.tokensUsed,
-        chunksProcessed: result.chunksProcessed
-      };
-    } catch (partialError) {
-      log3.warn(
-        `Partial summarization also failed: ${partialError instanceof Error ? partialError.message : String(partialError)}`
-      );
-    }
-  }
-  const note = `Context contained ${params.messages.length} messages (${oversizedNotes.length} were oversized). AI summarization unavailable due to size constraints. Recent conversation history was preserved.`;
-  return {
-    summary: note,
-    tokensUsed: estimateMessageTokens(note),
-    chunksProcessed: 0
-  };
-}
-
-// src/session/memory-hook.ts
-import { writeFile, mkdir } from "fs/promises";
-import { join as join3 } from "path";
-import { complete as complete2 } from "@mariozechner/pi-ai";
-var log4 = createLogger("Session");
-async function generateSlugViaClaude(params) {
-  const provider = params.provider || "anthropic";
-  const model = getUtilityModel(provider, params.utilityModel);
-  const formatted = formatMessagesForSummary(params.messages.slice(-SESSION_SLUG_RECENT_MESSAGES));
-  if (!formatted.trim()) {
-    return "empty-session";
-  }
-  try {
-    const context = {
-      messages: [
-        {
-          role: "user",
-          content: `Generate a short, descriptive slug (2-4 words, kebab-case) for this conversation.
-Examples: "gift-transfer-fix", "context-overflow-debug", "telegram-integration"
-
-Conversation:
-${formatted}
-
-Slug:`,
-          timestamp: Date.now()
-        }
-      ]
-    };
-    const response = await complete2(model, context, {
-      apiKey: params.apiKey,
-      maxTokens: SESSION_SLUG_MAX_TOKENS
-    });
-    const textContent = response.content.find((block) => block.type === "text");
-    const slug = textContent?.type === "text" ? textContent.text.trim() : "";
-    return slug.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50) || "session";
-  } catch (error) {
-    log4.warn({ err: error }, "Slug generation failed, using fallback");
-    const now = /* @__PURE__ */ new Date();
-    return `session-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
-  }
-}
-async function saveSessionMemory(params) {
-  try {
-    const { TELETON_ROOT: TELETON_ROOT2 } = await import("./paths-XA2RJH4S.js");
-    const memoryDir = join3(TELETON_ROOT2, "memory");
-    await mkdir(memoryDir, { recursive: true });
-    const now = /* @__PURE__ */ new Date();
-    const dateStr = now.toISOString().split("T")[0];
-    log4.info("Generating semantic slug for session memory...");
-    const slug = await generateSlugViaClaude({
-      messages: params.context.messages,
-      apiKey: params.apiKey,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-    const filename = `${dateStr}-${slug}.md`;
-    const filepath = join3(memoryDir, filename);
-    const timeStr = now.toISOString().split("T")[1].split(".")[0];
-    log4.info("Generating session summary...");
-    let summary;
-    try {
-      summary = await summarizeViaClaude({
-        messages: params.context.messages,
-        apiKey: params.apiKey,
-        maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
-        customInstructions: "Summarize this session comprehensively. Include key topics, decisions made, problems solved, and important context.",
-        provider: params.provider,
-        utilityModel: params.utilityModel
-      });
-    } catch (error) {
-      log4.warn({ err: error }, "Session summary generation failed");
-      summary = `Session contained ${params.context.messages.length} messages. Summary generation failed.`;
-    }
-    const content = `# Session Memory: ${dateStr} ${timeStr} UTC
-
-## Metadata
-
-- **Old Session ID**: \`${params.oldSessionId}\`
-- **New Session ID**: \`${params.newSessionId}\`
-- **Chat ID**: \`${params.chatId}\`
-- **Timestamp**: ${now.toISOString()}
-- **Message Count**: ${params.context.messages.length}
-
-## Session Summary
-
-${summary}
-
-## Context
-
-This session was compacted and migrated to a new session ID. The summary above preserves key information for continuity.
-
----
-
-*Generated automatically by Teleton-AI session memory hook*
-`;
-    await writeFile(filepath, content, "utf-8");
-    const relPath = filepath.replace(TELETON_ROOT2, "~/.teleton");
-    log4.info(`Session memory saved: ${relPath}`);
-  } catch (error) {
-    log4.error({ err: error }, "Failed to save session memory");
-  }
-}
-
-// src/memory/compaction.ts
 var DEFAULT_COMPACTION_CONFIG = {
   enabled: true,
   maxMessages: COMPACTION_MAX_MESSAGES,
@@ -1140,7 +639,7 @@ var DEFAULT_COMPACTION_CONFIG = {
   memoryFlushEnabled: true,
   softThresholdTokens: DEFAULT_SOFT_THRESHOLD_TOKENS
 };
-var log5 = createLogger("Memory");
+var log2 = createLogger("Memory");
 function estimateContextTokens(context) {
   let charCount = 0;
   if (context.systemPrompt) {
@@ -1172,7 +671,7 @@ function shouldFlushMemory(context, config, tokenCount) {
   const tokens = tokenCount ?? estimateContextTokens(context);
   const softThreshold = config.softThresholdTokens ?? FALLBACK_SOFT_THRESHOLD_TOKENS;
   if (tokens >= softThreshold) {
-    log5.info(`Memory flush needed: ~${tokens} tokens (soft threshold: ${softThreshold})`);
+    log2.info(`Memory flush needed: ~${tokens} tokens (soft threshold: ${softThreshold})`);
     return true;
   }
   return false;
@@ -1194,7 +693,7 @@ function flushMemoryToDailyLog(context) {
     }
   }
   writeSummaryToDailyLog(summary.join("\n"));
-  log5.info(`Memory flushed to daily log`);
+  log2.info(`Memory flushed to daily log`);
 }
 function shouldCompact(context, config, tokenCount) {
   if (!config.enabled) {
@@ -1202,13 +701,13 @@ function shouldCompact(context, config, tokenCount) {
   }
   const messageCount = context.messages.length;
   if (config.maxMessages && messageCount >= config.maxMessages) {
-    log5.info(`Compaction needed: ${messageCount} messages (max: ${config.maxMessages})`);
+    log2.info(`Compaction needed: ${messageCount} messages (max: ${config.maxMessages})`);
     return true;
   }
   if (config.maxTokens) {
     const tokens = tokenCount ?? estimateContextTokens(context);
     if (tokens >= config.maxTokens) {
-      log5.info(`Compaction needed: ~${tokens} tokens (max: ${config.maxTokens})`);
+      log2.info(`Compaction needed: ~${tokens} tokens (max: ${config.maxTokens})`);
       return true;
     }
   }
@@ -1254,12 +753,12 @@ async function compactContext(context, config, apiKey, provider, utilityModel) {
     iterations++;
   }
   if (hasOrphanedToolResults(context.messages.slice(cutIndex))) {
-    log5.warn(`Compaction: couldn't find clean cut point, keeping all messages`);
+    log2.warn(`Compaction: couldn't find clean cut point, keeping all messages`);
     return context;
   }
   const recentMessages = context.messages.slice(cutIndex);
   const oldMessages = context.messages.slice(0, cutIndex);
-  log5.info(
+  log2.info(
     `Compacting ${oldMessages.length} old messages, keeping ${recentMessages.length} recent (cut at clean boundary)`
   );
   try {
@@ -1289,7 +788,7 @@ Keep each section concise. Omit a section if empty. Preserve specific names, num
       provider,
       utilityModel
     });
-    log5.info(`AI Summary: ${result.tokensUsed} tokens, ${result.chunksProcessed} chunks processed`);
+    log2.info(`AI Summary: ${result.tokensUsed} tokens, ${result.chunksProcessed} chunks processed`);
     const summaryText = `[Auto-compacted ${oldMessages.length} messages]
 
 ${result.summary}`;
@@ -1303,7 +802,7 @@ ${result.summary}`;
       messages: [summaryMessage, ...recentMessages]
     };
   } catch (error) {
-    log5.error({ err: error }, "AI summarization failed, using fallback");
+    log2.error({ err: error }, "AI summarization failed, using fallback");
     const summaryText = `[Auto-compacted: ${oldMessages.length} earlier messages from this conversation]`;
     const summaryMessage = {
       role: "user",
@@ -1318,7 +817,7 @@ ${result.summary}`;
 }
 async function compactAndSaveTranscript(sessionId, context, config, apiKey, chatId, provider, utilityModel) {
   const newSessionId = randomUUID();
-  log5.info(`Creating compacted transcript: ${sessionId} \u2192 ${newSessionId}`);
+  log2.info(`Creating compacted transcript: ${sessionId} \u2192 ${newSessionId}`);
   if (chatId) {
     await saveSessionMemory({
       oldSessionId: sessionId,
@@ -1352,7 +851,7 @@ var CompactionManager = class {
     if (this.config.memoryFlushEnabled) {
       flushMemoryToDailyLog(context);
     }
-    log5.info(`Auto-compacting session ${sessionId}`);
+    log2.info(`Auto-compacting session ${sessionId}`);
     const newSessionId = await compactAndSaveTranscript(
       sessionId,
       context,
@@ -1362,7 +861,7 @@ var CompactionManager = class {
       provider,
       utilityModel
     );
-    log5.info(`Compaction complete: ${newSessionId}`);
+    log2.info(`Compaction complete: ${newSessionId}`);
     return newSessionId;
   }
   updateConfig(config) {
@@ -1494,7 +993,7 @@ function maskOldToolResults(messages, options) {
 }
 
 // src/agent/runtime.ts
-var log6 = createLogger("Agent");
+var log3 = createLogger("Agent");
 var globalTokenUsage = { totalTokens: 0, totalCost: 0 };
 function getTokenUsage() {
   return { ...globalTokenUsage };
@@ -1607,7 +1106,7 @@ var AgentRuntime = class {
       if (this.userHookEvaluator) {
         const hookResult = this.userHookEvaluator.evaluate(userMessage);
         if (hookResult.blocked) {
-          log6.info("Message blocked by keyword filter");
+          log3.info("Message blocked by keyword filter");
           return { content: hookResult.blockMessage ?? "", toolCalls: [] };
         }
         if (hookResult.additionalContext) {
@@ -1633,7 +1132,7 @@ var AgentRuntime = class {
         };
         await this.hookRunner.runModifyingHook("message:receive", msgEvent);
         if (msgEvent.block) {
-          log6.info(`\u{1F6AB} Message blocked by hook: ${msgEvent.blockReason || "no reason"}`);
+          log3.info(`\u{1F6AB} Message blocked by hook: ${msgEvent.blockReason || "no reason"}`);
           return { content: "", toolCalls: [] };
         }
         effectiveMessage = sanitizeForContext(msgEvent.text);
@@ -1645,7 +1144,7 @@ var AgentRuntime = class {
       const now = timestamp ?? Date.now();
       const resetPolicy = this.config.agent.session_reset_policy;
       if (shouldResetSession(session, resetPolicy)) {
-        log6.info(`\u{1F504} Auto-resetting session based on policy`);
+        log3.info(`\u{1F504} Auto-resetting session based on policy`);
         if (this.hookRunner) {
           await this.hookRunner.runObservingHook("session:end", {
             sessionId: session.sessionId,
@@ -1655,7 +1154,7 @@ var AgentRuntime = class {
         }
         if (transcriptExists(session.sessionId)) {
           try {
-            log6.info(`\u{1F4BE} Saving memory before daily reset...`);
+            log3.info(`\u{1F4BE} Saving memory before daily reset...`);
             const oldContext = loadContextFromTranscript(session.sessionId);
             await saveSessionMemory({
               oldSessionId: session.sessionId,
@@ -1666,9 +1165,9 @@ var AgentRuntime = class {
               provider: this.config.agent.provider,
               utilityModel: this.config.agent.utility_model
             });
-            log6.info(`\u2705 Memory saved before reset`);
+            log3.info(`\u2705 Memory saved before reset`);
           } catch (error) {
-            log6.warn({ err: error }, `\u26A0\uFE0F Failed to save memory before reset`);
+            log3.warn({ err: error }, `\u26A0\uFE0F Failed to save memory before reset`);
           }
         }
         session = resetSessionWithPolicy(chatId, resetPolicy);
@@ -1676,9 +1175,9 @@ var AgentRuntime = class {
       let context = loadContextFromTranscript(session.sessionId);
       const isNewSession = context.messages.length === 0;
       if (!isNewSession) {
-        log6.info(`\u{1F4D6} Loading existing session: ${session.sessionId}`);
+        log3.info(`\u{1F4D6} Loading existing session: ${session.sessionId}`);
       } else {
-        log6.info(`\u{1F195} Starting new session: ${session.sessionId}`);
+        log3.info(`\u{1F195} Starting new session: ${session.sessionId}`);
       }
       if (this.hookRunner) {
         await this.hookRunner.runObservingHook("session:start", {
@@ -1707,21 +1206,32 @@ var AgentRuntime = class {
         formattedMessage = `${pendingContext}
 
 ${formattedMessage}`;
-        log6.debug(`\u{1F4CB} Including ${pendingContext.split("\n").length - 1} pending messages`);
+        log3.debug(`\u{1F4CB} Including ${pendingContext.split("\n").length - 1} pending messages`);
       }
-      log6.debug(`\u{1F4E8} Formatted message: ${formattedMessage.substring(0, 100)}...`);
+      log3.debug(`\u{1F4E8} Formatted message: ${formattedMessage.substring(0, 100)}...`);
       const preview = formattedMessage.slice(0, 50).replace(/\n/g, " ");
       const who = senderUsername ? `@${senderUsername}` : userName;
       const msgType = isGroup ? `Group ${chatId} ${who}` : `DM ${who}`;
-      log6.info(`\u{1F4E8} ${msgType}: "${preview}${formattedMessage.length > 50 ? "..." : ""}"`);
+      log3.info(`\u{1F4E8} ${msgType}: "${preview}${formattedMessage.length > 50 ? "..." : ""}"`);
       let relevantContext = "";
       let queryEmbedding;
       const isNonTrivial = !isTrivialMessage(effectiveMessage);
       if (this.embedder && isNonTrivial) {
         try {
-          queryEmbedding = await this.embedder.embedQuery(effectiveMessage);
+          let searchQuery = effectiveMessage;
+          const recentUserMsgs = context.messages.filter((m) => m.role === "user" && typeof m.content === "string").slice(-3).map((m) => {
+            const text = m.content;
+            const bodyMatch = text.match(/\] (.+)/s);
+            return (bodyMatch ? bodyMatch[1] : text).trim();
+          }).filter((t) => t.length > 0);
+          if (recentUserMsgs.length > 0) {
+            searchQuery = recentUserMsgs.join(" ") + " " + effectiveMessage;
+          }
+          queryEmbedding = await this.embedder.embedQuery(
+            searchQuery.slice(0, EMBEDDING_QUERY_MAX_CHARS)
+          );
         } catch (error) {
-          log6.warn({ err: error }, "Embedding computation failed");
+          log3.warn({ err: error }, "Embedding computation failed");
         }
       }
       if (this.contextBuilder && isNonTrivial) {
@@ -1755,12 +1265,12 @@ ${sanitizedFeed.join("\n")}`
           }
           if (contextParts.length > 0) {
             relevantContext = contextParts.join("\n\n");
-            log6.debug(
+            log3.debug(
               `\u{1F50D} Found ${dbContext.relevantKnowledge.length} knowledge chunks, ${dbContext.relevantFeed.length} feed messages`
             );
           }
         } catch (error) {
-          log6.warn({ err: error }, "Context building failed");
+          log3.warn({ err: error }, "Context building failed");
         }
       }
       const memoryStats = this.getMemoryStats();
@@ -1828,7 +1338,7 @@ ${allHookContext}` : "");
         this.config.agent.utility_model
       );
       if (preemptiveCompaction) {
-        log6.info(`\u{1F5DC}\uFE0F  Preemptive compaction triggered, reloading session...`);
+        log3.info(`\u{1F5DC}\uFE0F  Preemptive compaction triggered, reloading session...`);
         session = getSession(chatId);
         context = loadContextFromTranscript(session.sessionId);
         context.messages.push(userMsg);
@@ -1850,7 +1360,7 @@ ${allHookContext}` : "");
             chatId,
             isAdmin
           );
-          log6.info(`\u{1F50D} Tool RAG: ${tools.length}/${this.toolRegistry.count} tools selected`);
+          log3.info(`\u{1F50D} Tool RAG: ${tools.length}/${this.toolRegistry.count} tools selected`);
         } else {
           tools = this.toolRegistry?.getForContext(
             effectiveIsGroup,
@@ -1869,9 +1379,10 @@ ${allHookContext}` : "");
       const totalToolCalls = [];
       const accumulatedTexts = [];
       const accumulatedUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalCost: 0 };
+      const seenToolSignatures = /* @__PURE__ */ new Set();
       while (iteration < maxIterations) {
         iteration++;
-        log6.debug(`\u{1F504} Agentic iteration ${iteration}/${maxIterations}`);
+        log3.debug(`\u{1F504} Agentic iteration ${iteration}/${maxIterations}`);
         const iterationStartIndex = context.messages.length;
         const maskedMessages = maskOldToolResults(context.messages, {
           toolRegistry: this.toolRegistry ?? void 0,
@@ -1910,35 +1421,35 @@ ${allHookContext}` : "");
                 "Context overflow persists after session reset. Message may be too large for the model's context window."
               );
             }
-            log6.error(`\u{1F6A8} Context overflow detected: ${errorMsg}`);
-            log6.info(`\u{1F4BE} Saving session memory before reset...`);
+            log3.error(`\u{1F6A8} Context overflow detected: ${errorMsg}`);
+            log3.info(`\u{1F4BE} Saving session memory before reset...`);
             const summary = extractContextSummary(context, CONTEXT_OVERFLOW_SUMMARY_MESSAGES);
             appendToDailyLog(summary);
-            log6.info(`\u2705 Memory saved to daily log`);
+            log3.info(`\u2705 Memory saved to daily log`);
             const archived = archiveTranscript(session.sessionId);
             if (!archived) {
-              log6.error(
+              log3.error(
                 `\u26A0\uFE0F  Failed to archive transcript ${session.sessionId}, proceeding with reset anyway`
               );
             }
-            log6.info(`\u{1F504} Resetting session due to context overflow...`);
+            log3.info(`\u{1F504} Resetting session due to context overflow...`);
             session = resetSession(chatId);
             context = { messages: [userMsg] };
             appendToTranscript(session.sessionId, userMsg);
-            log6.info(`\u{1F504} Retrying with fresh context...`);
+            log3.info(`\u{1F504} Retrying with fresh context...`);
             continue;
           } else if (errorMsg.toLowerCase().includes("rate") || errorMsg.includes("429")) {
             rateLimitRetries++;
             if (rateLimitRetries <= RATE_LIMIT_MAX_RETRIES) {
               const delay = 1e3 * Math.pow(2, rateLimitRetries - 1);
-              log6.warn(
+              log3.warn(
                 `\u{1F6AB} Rate limited, retrying in ${delay}ms (attempt ${rateLimitRetries}/${RATE_LIMIT_MAX_RETRIES})...`
               );
               await new Promise((r3) => setTimeout(r3, delay));
               iteration--;
               continue;
             }
-            log6.error(`\u{1F6AB} Rate limited after ${RATE_LIMIT_MAX_RETRIES} retries: ${errorMsg}`);
+            log3.error(`\u{1F6AB} Rate limited after ${RATE_LIMIT_MAX_RETRIES} retries: ${errorMsg}`);
             throw new Error(
               `API rate limited after ${RATE_LIMIT_MAX_RETRIES} retries. Please try again later.`
             );
@@ -1946,19 +1457,19 @@ ${allHookContext}` : "");
             serverErrorRetries++;
             if (serverErrorRetries <= SERVER_ERROR_MAX_RETRIES) {
               const delay = 2e3 * Math.pow(2, serverErrorRetries - 1);
-              log6.warn(
+              log3.warn(
                 `\u{1F504} Server error, retrying in ${delay}ms (attempt ${serverErrorRetries}/${SERVER_ERROR_MAX_RETRIES})...`
               );
               await new Promise((r3) => setTimeout(r3, delay));
               iteration--;
               continue;
             }
-            log6.error(`\u{1F6A8} Server error after ${SERVER_ERROR_MAX_RETRIES} retries: ${errorMsg}`);
+            log3.error(`\u{1F6A8} Server error after ${SERVER_ERROR_MAX_RETRIES} retries: ${errorMsg}`);
             throw new Error(
               `API server error after ${SERVER_ERROR_MAX_RETRIES} retries. The provider may be experiencing issues.`
             );
           } else {
-            log6.error(`\u{1F6A8} API error: ${errorMsg}`);
+            log3.error(`\u{1F6A8} API error: ${errorMsg}`);
             throw new Error(`API error: ${errorMsg || "Unknown error"}`);
           }
         }
@@ -1975,24 +1486,25 @@ ${allHookContext}` : "");
         }
         const toolCalls = response2.message.content.filter((block) => block.type === "toolCall");
         if (toolCalls.length === 0) {
-          log6.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 done`);
+          log3.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 done`);
           finalResponse = response2;
           break;
         }
         if (!this.toolRegistry || !toolContext) {
-          log6.error("\u26A0\uFE0F Cannot execute tools: registry or context missing");
+          log3.error("\u26A0\uFE0F Cannot execute tools: registry or context missing");
           break;
         }
-        log6.debug(`\u{1F527} Executing ${toolCalls.length} tool call(s)`);
+        log3.debug(`\u{1F527} Executing ${toolCalls.length} tool call(s)`);
         context.messages.push(response2.message);
         const iterationToolNames = [];
+        const fullContext = {
+          ...toolContext,
+          chatId,
+          isGroup: effectiveIsGroup
+        };
+        const toolPlans = [];
         for (const block of toolCalls) {
           if (block.type !== "toolCall") continue;
-          const fullContext = {
-            ...toolContext,
-            chatId,
-            isGroup: effectiveIsGroup
-          };
           let toolParams = block.arguments ?? {};
           let blocked = false;
           let blockReason = "";
@@ -2013,74 +1525,88 @@ ${allHookContext}` : "");
               toolParams = structuredClone(beforeEvent.params);
             }
           }
-          let result;
-          if (blocked) {
-            result = { success: false, error: blockReason };
-            if (this.hookRunner) {
-              const afterEvent = {
-                toolName: block.name,
-                params: structuredClone(toolParams),
-                result: { success: false, error: blockReason },
-                durationMs: 0,
-                chatId,
-                isGroup: effectiveIsGroup,
-                blocked: true,
-                blockReason
-              };
-              await this.hookRunner.runObservingHook("tool:after", afterEvent);
-            }
-          } else {
-            const startTime = Date.now();
-            try {
-              result = await this.toolRegistry.execute(
-                { ...block, arguments: toolParams },
-                fullContext
-              );
-            } catch (execErr) {
-              const durationMs2 = Date.now() - startTime;
-              const errMsg = execErr instanceof Error ? execErr.message : String(execErr);
-              const errStack = execErr instanceof Error ? execErr.stack : void 0;
-              result = { success: false, error: errMsg };
-              if (this.hookRunner) {
-                const errorEvent = {
-                  toolName: block.name,
-                  params: structuredClone(toolParams),
-                  error: errMsg,
-                  // Note: stack traces are exposed to plugins for debugging — accepted tradeoff
-                  stack: errStack,
-                  chatId,
-                  isGroup: effectiveIsGroup,
-                  durationMs: durationMs2
+          toolPlans.push({ block, blocked, blockReason, params: toolParams });
+        }
+        const execResults = new Array(toolPlans.length);
+        {
+          let cursor = 0;
+          const runWorker = async () => {
+            while (cursor < toolPlans.length) {
+              const idx = cursor++;
+              const plan = toolPlans[idx];
+              if (plan.blocked) {
+                execResults[idx] = {
+                  result: { success: false, error: plan.blockReason },
+                  durationMs: 0
+                };
+                continue;
+              }
+              const startTime = Date.now();
+              try {
+                const result = await this.toolRegistry.execute(
+                  { ...plan.block, arguments: plan.params },
+                  fullContext
+                );
+                execResults[idx] = { result, durationMs: Date.now() - startTime };
+              } catch (execErr) {
+                const errMsg = execErr instanceof Error ? execErr.message : String(execErr);
+                const errStack = execErr instanceof Error ? execErr.stack : void 0;
+                execResults[idx] = {
+                  result: { success: false, error: errMsg },
+                  durationMs: Date.now() - startTime,
+                  execError: { message: errMsg, stack: errStack }
                 };
-                await this.hookRunner.runObservingHook("tool:error", errorEvent);
               }
             }
-            const durationMs = Date.now() - startTime;
-            if (this.hookRunner) {
-              const afterEvent = {
-                toolName: block.name,
-                params: structuredClone(toolParams),
-                result: { success: result.success, data: result.data, error: result.error },
-                durationMs,
-                chatId,
-                isGroup: effectiveIsGroup
-              };
-              await this.hookRunner.runObservingHook("tool:after", afterEvent);
-            }
+          };
+          const workers = Math.min(TOOL_CONCURRENCY_LIMIT, toolPlans.length);
+          await Promise.all(Array.from({ length: workers }, () => runWorker()));
+        }
+        for (let i = 0; i < toolPlans.length; i++) {
+          const plan = toolPlans[i];
+          const { block } = plan;
+          const exec = execResults[i];
+          if (exec.execError && this.hookRunner) {
+            const errorEvent = {
+              toolName: block.name,
+              params: structuredClone(plan.params),
+              error: exec.execError.message,
+              stack: exec.execError.stack,
+              chatId,
+              isGroup: effectiveIsGroup,
+              durationMs: exec.durationMs
+            };
+            await this.hookRunner.runObservingHook("tool:error", errorEvent);
           }
-          log6.debug(`${block.name}: ${result.success ? "\u2713" : "\u2717"} ${result.error || ""}`);
-          iterationToolNames.push(`${block.name} ${result.success ? "\u2713" : "\u2717"}`);
+          if (this.hookRunner) {
+            const afterEvent = {
+              toolName: block.name,
+              params: structuredClone(plan.params),
+              result: {
+                success: exec.result.success,
+                data: exec.result.data,
+                error: exec.result.error
+              },
+              durationMs: exec.durationMs,
+              chatId,
+              isGroup: effectiveIsGroup,
+              ...plan.blocked ? { blocked: true, blockReason: plan.blockReason } : {}
+            };
+            await this.hookRunner.runObservingHook("tool:after", afterEvent);
+          }
+          log3.debug(`${block.name}: ${exec.result.success ? "\u2713" : "\u2717"} ${exec.result.error || ""}`);
+          iterationToolNames.push(`${block.name} ${exec.result.success ? "\u2713" : "\u2717"}`);
           totalToolCalls.push({
             name: block.name,
             input: block.arguments
           });
-          let resultText = JSON.stringify(result);
+          let resultText = JSON.stringify(exec.result);
           if (resultText.length > MAX_TOOL_RESULT_SIZE) {
-            log6.warn(`\u26A0\uFE0F Tool result too large (${resultText.length} chars), truncating...`);
-            const data = result.data;
+            log3.warn(`\u26A0\uFE0F Tool result too large (${resultText.length} chars), truncating...`);
+            const data = exec.result.data;
             if (data?.summary || data?.message) {
               resultText = JSON.stringify({
-                success: result.success,
+                success: exec.result.success,
                 data: {
                   summary: data.summary || data.message,
                   _truncated: true,
@@ -2089,11 +1615,27 @@ ${allHookContext}` : "");
                 }
               });
             } else {
-              resultText = resultText.slice(0, MAX_TOOL_RESULT_SIZE) + "\n...[TRUNCATED]";
+              const summarized = {
+                _truncated: true,
+                _originalSize: resultText.length,
+                _message: "Full data truncated. Use limit parameter for smaller results."
+              };
+              if (data && typeof data === "object") {
+                for (const [key, value] of Object.entries(data)) {
+                  if (Array.isArray(value)) {
+                    summarized[key] = `[${value.length} items]`;
+                  } else if (typeof value === "string" && value.length > 500) {
+                    summarized[key] = value.slice(0, 500) + "...[truncated]";
+                  } else {
+                    summarized[key] = value;
+                  }
+                }
+              }
+              resultText = JSON.stringify({ success: exec.result.success, data: summarized });
             }
           }
           if (provider === "cocoon") {
-            const { wrapToolResult } = await import("./tool-adapter-IH5VGBOO.js");
+            const { wrapToolResult } = await import("./tool-adapter-IVX2XQJE.js");
             const cocoonResultMsg = {
               role: "user",
               content: [
@@ -2117,21 +1659,33 @@ ${allHookContext}` : "");
                   text: resultText
                 }
               ],
-              isError: !result.success,
+              isError: !exec.result.success,
               timestamp: Date.now()
             };
             context.messages.push(toolResultMsg);
             appendToTranscript(session.sessionId, toolResultMsg);
           }
         }
-        log6.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 ${iterationToolNames.join(", ")}`);
+        log3.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 ${iterationToolNames.join(", ")}`);
+        const iterSignatures = toolPlans.map(
+          (p2) => `${p2.block.name}:${JSON.stringify(p2.params, Object.keys(p2.params).sort())}`
+        );
+        const allDuplicates = iterSignatures.length > 0 && iterSignatures.every((sig) => seenToolSignatures.has(sig));
+        for (const sig of iterSignatures) seenToolSignatures.add(sig);
+        if (allDuplicates) {
+          log3.warn(
+            `\u{1F501} Loop stall detected: all ${iterSignatures.length} tool call(s) are repeats \u2014 breaking early`
+          );
+          finalResponse = response2;
+          break;
+        }
         if (iteration === maxIterations) {
-          log6.info(`\u26A0\uFE0F Max iterations reached (${maxIterations})`);
+          log3.info(`\u26A0\uFE0F Max iterations reached (${maxIterations})`);
           finalResponse = response2;
         }
       }
       if (!finalResponse) {
-        log6.error("\u26A0\uFE0F Agentic loop exited early without final response");
+        log3.error("\u26A0\uFE0F Agentic loop exited early without final response");
         return {
           content: "Internal error: Agent loop failed to produce a response.",
           toolCalls: []
@@ -2142,14 +1696,6 @@ ${allHookContext}` : "");
       if (lastMsg?.role !== "assistant") {
         context.messages.push(response.message);
       }
-      const newSessionId = await this.compactionManager.checkAndCompact(
-        session.sessionId,
-        context,
-        getEffectiveApiKey(this.config.agent.provider, this.config.agent.api_key),
-        chatId,
-        this.config.agent.provider,
-        this.config.agent.utility_model
-      );
       const sessionUpdate = {
         updatedAt: Date.now(),
         messageCount: session.messageCount + 1,
@@ -2158,9 +1704,6 @@ ${allHookContext}` : "");
         inputTokens: (session.inputTokens ?? 0) + accumulatedUsage.input + accumulatedUsage.cacheRead + accumulatedUsage.cacheWrite,
         outputTokens: (session.outputTokens ?? 0) + accumulatedUsage.output
       };
-      if (newSessionId) {
-        sessionUpdate.sessionId = newSessionId;
-      }
       updateSession(chatId, sessionUpdate);
       if (accumulatedUsage.input > 0 || accumulatedUsage.output > 0) {
         const u = accumulatedUsage;
@@ -2170,20 +1713,20 @@ ${allHookContext}` : "");
         if (u.cacheRead) cacheParts.push(`${(u.cacheRead / 1e3).toFixed(1)}K cached`);
         if (u.cacheWrite) cacheParts.push(`${(u.cacheWrite / 1e3).toFixed(1)}K new`);
         const cacheInfo = cacheParts.length > 0 ? ` (${cacheParts.join(", ")})` : "";
-        log6.info(`\u{1F4B0} ${inK}K in${cacheInfo}, ${u.output} out | $${u.totalCost.toFixed(3)}`);
+        log3.info(`\u{1F4B0} ${inK}K in${cacheInfo}, ${u.output} out | $${u.totalCost.toFixed(3)}`);
         globalTokenUsage.totalTokens += u.input + u.output + u.cacheRead + u.cacheWrite;
         globalTokenUsage.totalCost += u.totalCost;
       }
       let content = accumulatedTexts.join("\n").trim() || response.text;
       const usedTelegramSendTool = totalToolCalls.some((tc) => TELEGRAM_SEND_TOOLS.has(tc.name));
       if (!content && totalToolCalls.length > 0 && !usedTelegramSendTool) {
-        log6.warn("\u26A0\uFE0F Empty response after tool calls - generating fallback");
+        log3.warn("\u26A0\uFE0F Empty response after tool calls - generating fallback");
         content = "I executed the requested action but couldn't generate a response. Please try again.";
       } else if (!content && usedTelegramSendTool) {
-        log6.info("\u2705 Response sent via Telegram tool - no additional text needed");
+        log3.info("\u2705 Response sent via Telegram tool - no additional text needed");
         content = "";
       } else if (!content && accumulatedUsage.input === 0 && accumulatedUsage.output === 0) {
-        log6.warn("\u26A0\uFE0F Empty response with zero tokens - possible API issue");
+        log3.warn("\u26A0\uFE0F Empty response with zero tokens - possible API issue");
         content = "I couldn't process your request. Please try again.";
       }
       let responseMetadata = {};
@@ -2200,7 +1743,7 @@ ${allHookContext}` : "");
         };
         await this.hookRunner.runModifyingHook("response:before", responseBeforeEvent);
         if (responseBeforeEvent.block) {
-          log6.info(
+          log3.info(
             `\u{1F6AB} Response blocked by hook: ${responseBeforeEvent.blockReason || "no reason"}`
           );
           content = "";
@@ -2227,7 +1770,7 @@ ${allHookContext}` : "");
         toolCalls: totalToolCalls
       };
     } catch (error) {
-      log6.error({ err: error }, "Agent error");
+      log3.error({ err: error }, "Agent error");
       throw error;
     }
   }
@@ -2240,7 +1783,7 @@ ${allHookContext}` : "");
     ).run(chatId);
     db.prepare(`DELETE FROM tg_messages WHERE chat_id = ?`).run(chatId);
     resetSession(chatId);
-    log6.info(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
+    log3.info(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
   }
   getConfig() {
     return this.config;
@@ -2261,7 +1804,7 @@ ${allHookContext}` : "");
   }
   configureCompaction(config) {
     this.compactionManager.updateConfig(config);
-    log6.info({ config: this.compactionManager.getConfig() }, `\u{1F5DC}\uFE0F  Compaction config updated`);
+    log3.info({ config: this.compactionManager.getConfig() }, `\u{1F5DC}\uFE0F  Compaction config updated`);
   }
   getCompactionConfig() {
     return this.compactionManager.getConfig();
@@ -2349,6 +1892,17 @@ function prefixButtons(rows, pluginName) {
 
 // src/bot/services/html-parser.ts
 import { Api as Api2 } from "telegram";
+
+// src/utils/gramjs-bigint.ts
+import { randomBytes } from "crypto";
+function toLong(value) {
+  return typeof value === "bigint" ? value : BigInt(value);
+}
+function randomLong() {
+  return randomBytes(8).readBigUInt64BE();
+}
+
+// src/bot/services/html-parser.ts
 function parseHtml(html) {
   const entities = [];
   let text = "";
@@ -2399,8 +1953,7 @@ function parseHtml(html) {
                       new Api2.MessageEntityCustomEmoji({
                         offset: open.offset,
                         length,
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- GramJS BigInteger compat
-                        documentId: BigInt(open.emojiId)
+                        documentId: toLong(open.emojiId)
                       })
                     );
                   }
@@ -2461,7 +2014,7 @@ function unescapeHtml(text) {
 }
 
 // src/bot/inline-router.ts
-var log7 = createLogger("InlineRouter");
+var log4 = createLogger("InlineRouter");
 var INLINE_TIMEOUT_MS = 5e3;
 var CALLBACK_TIMEOUT_MS = 15e3;
 function compileGlob(pattern) {
@@ -2482,11 +2035,11 @@ var InlineRouter = class {
   }
   registerPlugin(name, handlers) {
     this.plugins.set(name, handlers);
-    log7.info(`Registered plugin "${name}" for inline routing`);
+    log4.info(`Registered plugin "${name}" for inline routing`);
   }
   unregisterPlugin(name) {
     this.plugins.delete(name);
-    log7.info(`Unregistered plugin "${name}" from inline routing`);
+    log4.info(`Unregistered plugin "${name}" from inline routing`);
   }
   hasPlugin(name) {
     return this.plugins.has(name);
@@ -2558,7 +2111,7 @@ var InlineRouter = class {
         is_personal: true
       });
     } catch (error) {
-      log7.error({ err: error }, `Plugin "${pluginName}" inline query handler failed`);
+      log4.error({ err: error }, `Plugin "${pluginName}" inline query handler failed`);
       try {
         await ctx.answerInlineQuery([], { cache_time: 0, is_personal: true });
       } catch {
@@ -2618,7 +2171,7 @@ var InlineRouter = class {
             } catch (error) {
               const errMsg = error?.errorMessage;
               if (errMsg === "MESSAGE_NOT_MODIFIED") return;
-              log7.debug(`GramJS edit failed, falling back to Grammy: ${errMsg || error}`);
+              log4.debug(`GramJS edit failed, falling back to Grammy: ${errMsg || error}`);
             }
           }
           const replyMarkup = styledButtons ? toGrammyKeyboard(styledButtons) : void 0;
@@ -2638,7 +2191,7 @@ var InlineRouter = class {
         await ctx.answerCallbackQuery();
       }
     } catch (error) {
-      log7.error({ err: error }, `Plugin "${pluginName}" callback handler failed`);
+      log4.error({ err: error }, `Plugin "${pluginName}" callback handler failed`);
       if (!answered) {
         try {
           await ctx.answerCallbackQuery({ text: "Error processing action" });
@@ -2661,7 +2214,7 @@ var InlineRouter = class {
       };
       await plugin.onChosenResult(crCtx);
     } catch (error) {
-      log7.error({ err: error }, `Plugin "${pluginName}" chosen result handler failed`);
+      log4.error({ err: error }, `Plugin "${pluginName}" chosen result handler failed`);
     }
   }
   /**
@@ -2739,8 +2292,8 @@ function withTimeout(promise, ms, message) {
 }
 
 // src/agent/tools/plugin-loader.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync5, existsSync as existsSync6, statSync } from "fs";
-import { join as join5 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, existsSync as existsSync5, statSync } from "fs";
+import { join as join3 } from "path";
 import { pathToFileURL } from "url";
 import { execFile } from "child_process";
 
@@ -2771,7 +2324,7 @@ import { promisify } from "util";
 
 // src/agent/tools/plugin-validator.ts
 import { z } from "zod";
-var log8 = createLogger("PluginValidator");
+var log5 = createLogger("PluginValidator");
 var ManifestSchema = z.object({
   name: z.string().min(1).max(64).regex(
     /^[a-z0-9][a-z0-9-]*$/,
@@ -2814,20 +2367,20 @@ function validateToolDefs(defs, pluginName) {
   const valid = [];
   for (const def of defs) {
     if (!def || typeof def !== "object") {
-      log8.warn(`[${pluginName}] tool is not an object, skipping`);
+      log5.warn(`[${pluginName}] tool is not an object, skipping`);
       continue;
     }
     const t = def;
     if (!t.name || typeof t.name !== "string") {
-      log8.warn(`[${pluginName}] tool missing 'name', skipping`);
+      log5.warn(`[${pluginName}] tool missing 'name', skipping`);
       continue;
     }
     if (!t.description || typeof t.description !== "string") {
-      log8.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
+      log5.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
       continue;
     }
     if (!t.execute || typeof t.execute !== "function") {
-      log8.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
+      log5.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
       continue;
     }
     valid.push(t);
@@ -2864,8 +2417,19 @@ import { Address, SendMode } from "@ton/core";
 
 // src/ton/tx-lock.ts
 var pending = Promise.resolve();
+var TX_LOCK_TIMEOUT_MS = 6e4;
 function withTxLock(fn) {
-  const execute = pending.then(fn, fn);
+  const guarded = () => {
+    let timerId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timerId = setTimeout(
+        () => reject(new Error("TON tx-lock timeout (60s)")),
+        TX_LOCK_TIMEOUT_MS
+      );
+    });
+    return Promise.race([fn(), timeoutPromise]).finally(() => clearTimeout(timerId));
+  };
+  const execute = pending.then(guarded, guarded);
   pending = execute.then(
     () => {
     },
@@ -2876,25 +2440,25 @@ function withTxLock(fn) {
 }
 
 // src/ton/transfer.ts
-var log9 = createLogger("TON");
+var log6 = createLogger("TON");
 async function sendTon(params) {
   return withTxLock(async () => {
     try {
       const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
       if (!Number.isFinite(amount) || amount <= 0) {
-        log9.error({ amount }, "Invalid transfer amount");
+        log6.error({ amount }, "Invalid transfer amount");
         return null;
       }
       let recipientAddress;
       try {
         recipientAddress = Address.parse(toAddress2);
       } catch (e) {
-        log9.error({ err: e }, `Invalid recipient address: ${toAddress2}`);
+        log6.error({ err: e }, `Invalid recipient address: ${toAddress2}`);
         return null;
       }
       const keyPair = await getKeyPair();
       if (!keyPair) {
-        log9.error("Wallet not initialized");
+        log6.error("Wallet not initialized");
         return null;
       }
       const wallet = WalletContractV5R1.create({
@@ -2918,7 +2482,7 @@ async function sendTon(params) {
         ]
       });
       const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-      log9.info(`Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
+      log6.info(`Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
       return pseudoHash;
     } catch (error) {
       const err = error;
@@ -2926,14 +2490,14 @@ async function sendTon(params) {
       if (status === 429 || status !== void 0 && status >= 500) {
         invalidateTonClientCache();
       }
-      log9.error({ err: error }, "Error sending TON");
+      log6.error({ err: error }, "Error sending TON");
       throw error;
     }
   });
 }
 
 // src/utils/retry.ts
-var log10 = createLogger("Utils");
+var log7 = createLogger("Utils");
 var DEFAULT_OPTIONS = {
   maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
   baseDelayMs: RETRY_DEFAULT_BASE_DELAY_MS,
@@ -2957,7 +2521,7 @@ async function withRetry(fn, options = {}) {
       return result;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
-      log10.warn(`Retry attempt ${attempt}/${opts.maxAttempts} failed: ${lastError.message}`);
+      log7.warn(`Retry attempt ${attempt}/${opts.maxAttempts} failed: ${lastError.message}`);
       if (attempt < opts.maxAttempts) {
         const delay = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
         await sleep(delay);
@@ -6435,7 +5999,7 @@ var DEDUST_GAS = {
 var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 
 // src/agent/tools/dedust/asset-cache.ts
-var log11 = createLogger("Tools");
+var log8 = createLogger("Tools");
 var ASSET_LIST_URL = "https://assets.dedust.io/list.json";
 var CACHE_TTL_MS = 10 * 60 * 1e3;
 var cachedAssets = [];
@@ -6454,7 +6018,7 @@ async function getAssetList() {
     return cachedAssets;
   } catch (error) {
     if (cachedAssets.length > 0) {
-      log11.warn({ err: error }, "Asset list fetch failed, using stale cache");
+      log8.warn({ err: error }, "Asset list fetch failed, using stale cache");
       return cachedAssets;
     }
     throw error;
@@ -6507,7 +6071,7 @@ var stonApiClient = new StonApiClient();
 function isTon(asset) {
   return asset.toLowerCase() === "ton";
 }
-async function getStonfiQuote(fromAsset, toAsset, amount, slippage, log15) {
+async function getStonfiQuote(fromAsset, toAsset, amount, slippage, log12) {
   try {
     const isTonInput = isTon(fromAsset);
     const isTonOutput = isTon(toAsset);
@@ -6538,11 +6102,11 @@ async function getStonfiQuote(fromAsset, toAsset, amount, slippage, log15) {
       fee: feeAmount.toFixed(6)
     };
   } catch (err) {
-    log15.debug("dex.quoteSTONfi() failed:", err);
+    log12.debug("dex.quoteSTONfi() failed:", err);
     return null;
   }
 }
-async function getDedustQuote(fromAsset, toAsset, amount, slippage, log15) {
+async function getDedustQuote(fromAsset, toAsset, amount, slippage, log12) {
   try {
     const isTonInput = isTon(fromAsset);
     const isTonOutput = isTon(toAsset);
@@ -6576,7 +6140,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, log15) {
       poolType
     };
   } catch (err) {
-    log15.debug("dex.quoteDeDust() failed:", err);
+    log12.debug("dex.quoteDeDust() failed:", err);
     return null;
   }
 }
@@ -6748,14 +6312,14 @@ function validateDexParams(amount, slippage) {
     throw new PluginSDKError("Slippage must be between 0 and 1", "OPERATION_FAILED");
   }
 }
-function createDexSDK(log15) {
+function createDexSDK(log12) {
   return {
     async quote(params) {
       validateDexParams(params.amount, params.slippage);
       const slippage = params.slippage ?? 0.01;
       const [stonfi, dedust] = await Promise.all([
-        getStonfiQuote(params.fromAsset, params.toAsset, params.amount, slippage, log15),
-        getDedustQuote(params.fromAsset, params.toAsset, params.amount, slippage, log15)
+        getStonfiQuote(params.fromAsset, params.toAsset, params.amount, slippage, log12),
+        getDedustQuote(params.fromAsset, params.toAsset, params.amount, slippage, log12)
       ]);
       if (!stonfi && !dedust) {
         throw new PluginSDKError("No DEX has liquidity for this pair", "OPERATION_FAILED");
@@ -6789,7 +6353,7 @@ function createDexSDK(log15) {
         params.toAsset,
         params.amount,
         params.slippage ?? 0.01,
-        log15
+        log12
       );
     },
     async quoteDeDust(params) {
@@ -6798,25 +6362,25 @@ function createDexSDK(log15) {
         params.toAsset,
         params.amount,
         params.slippage ?? 0.01,
-        log15
+        log12
       );
     },
     async swap(params) {
       validateDexParams(params.amount, params.slippage);
       if (params.dex === "stonfi") {
-        return executeSTONfiSwap(params, log15);
+        return executeSTONfiSwap(params, log12);
       }
       if (params.dex === "dedust") {
-        return executeDedustSwap(params, log15);
+        return executeDedustSwap(params, log12);
       }
       const quoteResult = await this.quote(params);
-      return quoteResult.recommended === "stonfi" ? executeSTONfiSwap(params, log15) : executeDedustSwap(params, log15);
+      return quoteResult.recommended === "stonfi" ? executeSTONfiSwap(params, log12) : executeDedustSwap(params, log12);
     },
     async swapSTONfi(params) {
-      return executeSTONfiSwap(params, log15);
+      return executeSTONfiSwap(params, log12);
     },
     async swapDeDust(params) {
-      return executeDedustSwap(params, log15);
+      return executeDedustSwap(params, log12);
     }
   };
 }
@@ -6853,7 +6417,7 @@ function normalizeDomain(domain) {
   if (!d.endsWith(".ton")) d += ".ton";
   return d;
 }
-function createDnsSDK(log15) {
+function createDnsSDK(log12) {
   return {
     async check(domain) {
       const normalized = normalizeDomain(domain);
@@ -6876,7 +6440,7 @@ function createDnsSDK(log15) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.debug("dns.check() failed:", err);
+        log12.debug("dns.check() failed:", err);
         throw new PluginSDKError(
           `Failed to check domain: ${err instanceof Error ? err.message : String(err)}`,
           "OPERATION_FAILED"
@@ -6889,7 +6453,7 @@ function createDnsSDK(log15) {
         const response = await tonapiFetch(`/dns/${encodeURIComponent(normalized)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log15.debug(`dns.resolve() TonAPI error: ${response.status}`);
+          log12.debug(`dns.resolve() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -6901,7 +6465,7 @@ function createDnsSDK(log15) {
           expirationDate: data.expiring_at || void 0
         };
       } catch (err) {
-        log15.debug("dns.resolve() failed:", err);
+        log12.debug("dns.resolve() failed:", err);
         return null;
       }
     },
@@ -6911,7 +6475,7 @@ function createDnsSDK(log15) {
           `/dns/auctions?tld=ton&limit=${Math.min(limit ?? 20, 100)}`
         );
         if (!response.ok) {
-          log15.debug(`dns.getAuctions() TonAPI error: ${response.status}`);
+          log12.debug(`dns.getAuctions() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
@@ -6924,7 +6488,7 @@ function createDnsSDK(log15) {
           bids: a.bids || 0
         }));
       } catch (err) {
-        log15.debug("dns.getAuctions() failed:", err);
+        log12.debug("dns.getAuctions() failed:", err);
         return [];
       }
     },
@@ -7238,25 +6802,25 @@ function findJettonBalance(balances, jettonAddress) {
     }
   });
 }
-function cleanupOldTransactions(db, retentionDays, log15) {
+function cleanupOldTransactions(db, retentionDays, log12) {
   if (Math.random() > CLEANUP_PROBABILITY) return;
   try {
     const cutoff = Math.floor(Date.now() / 1e3) - retentionDays * 24 * 60 * 60;
     const result = db.prepare("DELETE FROM used_transactions WHERE used_at < ?").run(cutoff);
     if (result.changes > 0) {
-      log15.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
+      log12.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
     }
   } catch (err) {
-    log15.error("Transaction cleanup failed:", err);
+    log12.error("Transaction cleanup failed:", err);
   }
 }
-function createTonSDK(log15, db) {
+function createTonSDK(log12, db) {
   return {
     getAddress() {
       try {
         return getWalletAddress();
       } catch (err) {
-        log15.error("ton.getAddress() failed:", err);
+        log12.error("ton.getAddress() failed:", err);
         return null;
       }
     },
@@ -7266,7 +6830,7 @@ function createTonSDK(log15, db) {
         if (!addr) return null;
         return await getWalletBalance(addr);
       } catch (err) {
-        log15.error("ton.getBalance() failed:", err);
+        log12.error("ton.getBalance() failed:", err);
         return null;
       }
     },
@@ -7274,7 +6838,7 @@ function createTonSDK(log15, db) {
       try {
         return await getTonPrice();
       } catch (err) {
-        log15.error("ton.getPrice() failed:", err);
+        log12.error("ton.getPrice() failed:", err);
         return null;
       }
     },
@@ -7325,7 +6889,7 @@ function createTonSDK(log15, db) {
         );
         return formatTransactions(transactions);
       } catch (err) {
-        log15.error("ton.getTransactions() failed:", err);
+        log12.error("ton.getTransactions() failed:", err);
         return [];
       }
     },
@@ -7348,7 +6912,7 @@ function createTonSDK(log15, db) {
         throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
       }
       const maxAgeMinutes = params.maxAgeMinutes ?? DEFAULT_MAX_AGE_MINUTES;
-      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log15);
+      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log12);
       try {
         const txs = await this.getTransactions(address4, 20);
         for (const tx of txs) {
@@ -7382,7 +6946,7 @@ function createTonSDK(log15, db) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("ton.verifyPayment() failed:", err);
+        log12.error("ton.verifyPayment() failed:", err);
         return {
           verified: false,
           error: `Verification failed: ${err instanceof Error ? err.message : String(err)}`
@@ -7396,7 +6960,7 @@ function createTonSDK(log15, db) {
         if (!addr) return [];
         const response = await tonapiFetch(`/accounts/${encodeURIComponent(addr)}/jettons`);
         if (!response.ok) {
-          log15.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
+          log12.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
@@ -7420,7 +6984,7 @@ function createTonSDK(log15, db) {
         }
         return balances;
       } catch (err) {
-        log15.error("ton.getJettonBalances() failed:", err);
+        log12.error("ton.getJettonBalances() failed:", err);
         return [];
       }
     },
@@ -7429,7 +6993,7 @@ function createTonSDK(log15, db) {
         const response = await tonapiFetch(`/jettons/${encodeURIComponent(jettonAddress)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log15.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
+          log12.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -7447,7 +7011,7 @@ function createTonSDK(log15, db) {
           image: data.preview || metadata.image || void 0
         };
       } catch (err) {
-        log15.error("ton.getJettonInfo() failed:", err);
+        log12.error("ton.getJettonInfo() failed:", err);
         return null;
       }
     },
@@ -7534,12 +7098,13 @@ function createTonSDK(log15, db) {
               return seq;
             } catch (err) {
               lastErr = err;
-              const status = err?.status || err?.response?.status;
-              const respData = err?.response?.data;
+              const httpErr = isHttpError(err) ? err : void 0;
+              const status = httpErr?.status || httpErr?.response?.status;
+              const respData = httpErr?.response?.data;
               if (status === 429 || status && status >= 500) {
                 invalidateTonClientCache();
                 if (attempt < MAX_SEND_ATTEMPTS) {
-                  log15.warn(
+                  log12.warn(
                     `sendJetton attempt ${attempt} failed (${status}): ${JSON.stringify(respData ?? err.message)}, retrying...`
                   );
                   await new Promise((r3) => setTimeout(r3, 1e3 * attempt));
@@ -7553,7 +7118,8 @@ function createTonSDK(log15, db) {
         });
         return { success: true, seqno };
       } catch (err) {
-        const status = err?.status || err?.response?.status;
+        const outerHttpErr = isHttpError(err) ? err : void 0;
+        const status = outerHttpErr?.status || outerHttpErr?.response?.status;
         if (status === 429 || status && status >= 500) {
           invalidateTonClientCache();
         }
@@ -7568,14 +7134,14 @@ function createTonSDK(log15, db) {
       try {
         const response = await tonapiFetch(`/accounts/${encodeURIComponent(ownerAddress)}/jettons`);
         if (!response.ok) {
-          log15.error(`ton.getJettonWalletAddress() TonAPI error: ${response.status}`);
+          log12.error(`ton.getJettonWalletAddress() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
         const match = findJettonBalance(data.balances ?? [], jettonAddress);
         return match ? match.wallet_address.address : null;
       } catch (err) {
-        log15.error("ton.getJettonWalletAddress() failed:", err);
+        log12.error("ton.getJettonWalletAddress() failed:", err);
         return null;
       }
     },
@@ -7752,7 +7318,7 @@ function createTonSDK(log15, db) {
         const wallet = loadWallet();
         return wallet?.publicKey ?? null;
       } catch (err) {
-        log15.error("ton.getPublicKey() failed:", err);
+        log12.error("ton.getPublicKey() failed:", err);
         return null;
       }
     },
@@ -7768,14 +7334,14 @@ function createTonSDK(log15, db) {
           `/accounts/${encodeURIComponent(addr)}/nfts?limit=100&indirect_ownership=true`
         );
         if (!response.ok) {
-          log15.error(`ton.getNftItems() TonAPI error: ${response.status}`);
+          log12.error(`ton.getNftItems() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
         if (!Array.isArray(data.nft_items)) return [];
         return data.nft_items.filter((item) => item.trust !== "blacklist").map((item) => mapNftItem(item));
       } catch (err) {
-        log15.error("ton.getNftItems() failed:", err);
+        log12.error("ton.getNftItems() failed:", err);
         return [];
       }
     },
@@ -7784,13 +7350,13 @@ function createTonSDK(log15, db) {
         const response = await tonapiFetch(`/nfts/${encodeURIComponent(nftAddress)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log15.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
+          log12.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
           return null;
         }
         const item = await response.json();
         return mapNftItem(item);
       } catch (err) {
-        log15.error("ton.getNftInfo() failed:", err);
+        log12.error("ton.getNftInfo() failed:", err);
         return null;
       }
     },
@@ -7823,7 +7389,7 @@ function createTonSDK(log15, db) {
           `/rates?tokens=${encodeURIComponent(jettonAddress)}&currencies=usd,ton`
         );
         if (!response.ok) {
-          log15.debug(`ton.getJettonPrice() TonAPI error: ${response.status}`);
+          log12.debug(`ton.getJettonPrice() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -7837,7 +7403,7 @@ function createTonSDK(log15, db) {
           change30d: rateData.diff_30d?.USD ?? null
         };
       } catch (err) {
-        log15.debug("ton.getJettonPrice() failed:", err);
+        log12.debug("ton.getJettonPrice() failed:", err);
         return null;
       }
     },
@@ -7851,7 +7417,7 @@ function createTonSDK(log15, db) {
           tonapiFetch(`/jettons/${encodeURIComponent(jettonAddress)}`)
         ]);
         if (!holdersResponse.ok) {
-          log15.debug(`ton.getJettonHolders() TonAPI error: ${holdersResponse.status}`);
+          log12.debug(`ton.getJettonHolders() TonAPI error: ${holdersResponse.status}`);
           return [];
         }
         const data = await holdersResponse.json();
@@ -7871,7 +7437,7 @@ function createTonSDK(log15, db) {
           };
         });
       } catch (err) {
-        log15.debug("ton.getJettonHolders() failed:", err);
+        log12.debug("ton.getJettonHolders() failed:", err);
         return [];
       }
     },
@@ -7943,13 +7509,13 @@ function createTonSDK(log15, db) {
           holders: holdersCount
         };
       } catch (err) {
-        log15.debug("ton.getJettonHistory() failed:", err);
+        log12.debug("ton.getJettonHistory() failed:", err);
         return null;
       }
     },
     // ─── Sub-namespaces ───────────────────────────────────────────
-    dex: Object.freeze(createDexSDK(log15)),
-    dns: Object.freeze(createDnsSDK(log15))
+    dex: Object.freeze(createDexSDK(log12)),
+    dns: Object.freeze(createDnsSDK(log12))
   };
 }
 function mapNftItem(item) {
@@ -7973,15 +7539,6 @@ function mapNftItem(item) {
 // src/sdk/telegram.ts
 import { Api as Api3 } from "telegram";
 
-// src/utils/gramjs-bigint.ts
-import { randomBytes } from "crypto";
-function toLong(value) {
-  return typeof value === "bigint" ? value : BigInt(value);
-}
-function randomLong() {
-  return randomBytes(8).readBigUInt64BE();
-}
-
 // src/sdk/telegram-utils.ts
 function requireBridge(bridge) {
   if (!bridge.isAvailable()) {
@@ -7998,7 +7555,6 @@ function toSimpleMessage(msg) {
   return {
     id: msg.id,
     text: msg.message ?? "",
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- GramJS fromId is a union of untyped peer types
     senderId: Number(msg.fromId?.userId ?? msg.fromId?.channelId ?? 0),
     timestamp: new Date(msg.date * 1e3)
   };
@@ -8012,7 +7568,7 @@ async function getApi() {
 }
 
 // src/sdk/telegram-messages.ts
-function createTelegramMessagesSDK(bridge, log15) {
+function createTelegramMessagesSDK(bridge, log12) {
   function requireBridge2() {
     requireBridge(bridge);
   }
@@ -8119,7 +7675,7 @@ function createTelegramMessagesSDK(bridge, log15) {
         return (resultData.messages ?? []).map(toSimpleMessage);
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.searchMessages() failed:", err);
+        log12.error("telegram.searchMessages() failed:", err);
         return [];
       }
     },
@@ -8156,8 +7712,7 @@ function createTelegramMessagesSDK(bridge, log15) {
             limit,
             maxId: 0,
             minId: 0,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- GramJS BigInteger compat requires bigint cast
-            hash: 0n
+            hash: toLong(0n)
           })
         );
         const messages = [];
@@ -8320,10 +7875,12 @@ function createTelegramMessagesSDK(bridge, log15) {
         if (!messages || messages.length === 0 || !messages[0].media) {
           return null;
         }
-        const doc = messages[0].media?.document;
-        if (doc?.size && Number(doc.size) > MAX_DOWNLOAD_SIZE) {
+        const media = messages[0].media;
+        const doc = media && "document" in media ? media.document : void 0;
+        const docSize = doc && "size" in doc ? doc.size : void 0;
+        if (docSize && Number(docSize) > MAX_DOWNLOAD_SIZE) {
           throw new PluginSDKError(
-            `File too large (${Math.round(Number(doc.size) / 1024 / 1024)}MB). Max: 50MB`,
+            `File too large (${Math.round(Number(docSize) / 1024 / 1024)}MB). Max: 50MB`,
             "OPERATION_FAILED"
           );
         }
@@ -8347,8 +7904,7 @@ function createTelegramMessagesSDK(bridge, log15) {
         const result = await gramJsClient.invoke(
           new Api4.messages.GetScheduledHistory({
             peer,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- GramJS BigInteger compat requires bigint cast
-            hash: 0n
+            hash: toLong(0n)
           })
         );
         const messages = [];
@@ -8362,7 +7918,7 @@ function createTelegramMessagesSDK(bridge, log15) {
         return messages;
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getScheduledMessages() failed:", err);
+        log12.error("telegram.getScheduledMessages() failed:", err);
         return [];
       }
     },
@@ -8423,7 +7979,7 @@ function createTelegramMessagesSDK(bridge, log15) {
 }
 
 // src/sdk/telegram-social.ts
-function createTelegramSocialSDK(bridge, log15) {
+function createTelegramSocialSDK(bridge, log12) {
   function requireBridge2() {
     requireBridge(bridge);
   }
@@ -8498,7 +8054,7 @@ function createTelegramSocialSDK(bridge, log15) {
         return null;
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getChatInfo() failed:", err);
+        log12.error("telegram.getChatInfo() failed:", err);
         return null;
       }
     },
@@ -8612,7 +8168,7 @@ function createTelegramSocialSDK(bridge, log15) {
         });
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getParticipants() failed:", err);
+        log12.error("telegram.getParticipants() failed:", err);
         return [];
       }
     },
@@ -8829,7 +8385,7 @@ function createTelegramSocialSDK(bridge, log15) {
         const user = await client.getInputEntity(userId.toString());
         const invoiceData = {
           peer: user,
-          giftId: BigInt(giftId),
+          giftId: toLong(giftId),
           hideName: opts?.anonymous ?? false,
           message: opts?.message ? new Api4.TextWithEntities({ text: opts.message, entities: [] }) : void 0
         };
@@ -8913,7 +8469,7 @@ function createTelegramSocialSDK(bridge, log15) {
         const Api4 = await getApi();
         const result = await client.invoke(
           new Api4.payments.GetResaleStarGifts({
-            giftId: BigInt(giftId),
+            giftId: toLong(giftId),
             offset: "",
             limit: limit ?? 50
           })
@@ -8974,7 +8530,7 @@ function createTelegramSocialSDK(bridge, log15) {
         }));
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getDialogs() failed:", err);
+        log12.error("telegram.getDialogs() failed:", err);
         return [];
       }
     },
@@ -8988,7 +8544,7 @@ function createTelegramSocialSDK(bridge, log15) {
         return messages.map(toSimpleMessage);
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getHistory() failed:", err);
+        log12.error("telegram.getHistory() failed:", err);
         return [];
       }
     },
@@ -9019,7 +8575,7 @@ function createTelegramSocialSDK(bridge, log15) {
         }));
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getStarsTransactions() failed:", err);
+        log12.error("telegram.getStarsTransactions() failed:", err);
         return [];
       }
     },
@@ -9072,7 +8628,7 @@ function createTelegramSocialSDK(bridge, log15) {
           new Api4.payments.UpdateStarGiftPrice({
             stargift: new Api4.InputSavedStarGiftUser({ msgId }),
             resellAmount: new Api4.StarsAmount({
-              amount: BigInt(price),
+              amount: toLong(price),
               nanos: 0
             })
           })
@@ -9124,7 +8680,7 @@ function createTelegramSocialSDK(bridge, log15) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getCollectibleInfo() failed:", err);
+        log12.error("telegram.getCollectibleInfo() failed:", err);
         return null;
       }
     },
@@ -9162,7 +8718,7 @@ function createTelegramSocialSDK(bridge, log15) {
       } catch (err) {
         if (err.errorMessage === "STARGIFT_SLUG_INVALID") return null;
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getUniqueGift() failed:", err);
+        log12.error("telegram.getUniqueGift() failed:", err);
         return null;
       }
     },
@@ -9188,7 +8744,7 @@ function createTelegramSocialSDK(bridge, log15) {
       } catch (err) {
         if (err.errorMessage === "STARGIFT_SLUG_INVALID") return null;
         if (err instanceof PluginSDKError) throw err;
-        log15.error("telegram.getUniqueGiftValue() failed:", err);
+        log12.error("telegram.getUniqueGiftValue() failed:", err);
         return null;
       }
     },
@@ -9203,7 +8759,7 @@ function createTelegramSocialSDK(bridge, log15) {
           new Api4.payments.SendStarGiftOffer({
             peer,
             slug: giftSlug,
-            price: new Api4.StarsAmount({ amount: BigInt(price), nanos: 0 }),
+            price: new Api4.StarsAmount({ amount: toLong(price), nanos: 0 }),
             duration,
             randomId: randomLong()
           })
@@ -9223,13 +8779,13 @@ function createTelegramSocialSDK(bridge, log15) {
         const client = getClient2();
         const { Api: Api4, helpers } = await import("telegram");
         const { CustomFile } = await import("telegram/client/uploads.js");
-        const { readFileSync: readFileSync8, statSync: statSync2 } = await import("fs");
+        const { readFileSync: readFileSync7, statSync: statSync2 } = await import("fs");
         const { basename: basename2 } = await import("path");
         const { resolve: resolve2, normalize: normalize2 } = await import("path");
-        const { homedir: homedir3 } = await import("os");
+        const { homedir: homedir2 } = await import("os");
         const { realpathSync } = await import("fs");
         const filePath = realpathSync(resolve2(normalize2(mediaPath)));
-        const home = homedir3();
+        const home = homedir2();
         const teletonWorkspace = `${home}/.teleton/workspace/`;
         const allowedPrefixes = [
           "/tmp/",
@@ -9248,7 +8804,7 @@ function createTelegramSocialSDK(bridge, log15) {
         }
         const fileName = basename2(filePath);
         const fileSize = statSync2(filePath).size;
-        const fileBuffer = readFileSync8(filePath);
+        const fileBuffer = readFileSync7(filePath);
         const isVideo = filePath.toLowerCase().match(/\.(mp4|mov|avi|webm|mkv|m4v)$/);
         const customFile = new CustomFile(fileName, fileSize, filePath, fileBuffer);
         const uploadedFile = await client.uploadFile({
@@ -9299,7 +8855,7 @@ function createTelegramSocialSDK(bridge, log15) {
 }
 
 // src/sdk/telegram.ts
-function createTelegramSDK(bridge, log15) {
+function createTelegramSDK(bridge, log12) {
   function requireBridge2() {
     requireBridge(bridge);
   }
@@ -9403,7 +8959,7 @@ function createTelegramSDK(bridge, log15) {
           timestamp: m.timestamp
         }));
       } catch (err) {
-        log15.error("telegram.getMessages() failed:", err);
+        log12.error("telegram.getMessages() failed:", err);
         return [];
       }
     },
@@ -9425,7 +8981,7 @@ function createTelegramSDK(bridge, log15) {
       return bridge.isAvailable();
     },
     getRawClient() {
-      log15.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
+      log12.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
       if (!bridge.isAvailable()) return null;
       try {
         return bridge.getClient().getClient();
@@ -9434,23 +8990,23 @@ function createTelegramSDK(bridge, log15) {
       }
     },
     // Spread extended methods from sub-modules
-    ...createTelegramMessagesSDK(bridge, log15),
-    ...createTelegramSocialSDK(bridge, log15)
+    ...createTelegramMessagesSDK(bridge, log12),
+    ...createTelegramSocialSDK(bridge, log12)
   };
 }
 
 // src/sdk/secrets.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
-var SECRETS_DIR = join4(TELETON_ROOT, "plugins", "data");
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
+import { join as join2 } from "path";
+var SECRETS_DIR = join2(TELETON_ROOT, "plugins", "data");
 function getSecretsPath(pluginName) {
-  return join4(SECRETS_DIR, `${pluginName}.secrets.json`);
+  return join2(SECRETS_DIR, `${pluginName}.secrets.json`);
 }
 function readSecretsFile(pluginName) {
   const filePath = getSecretsPath(pluginName);
   try {
-    if (!existsSync5(filePath)) return {};
-    const raw = readFileSync4(filePath, "utf-8");
+    if (!existsSync4(filePath)) return {};
+    const raw = readFileSync3(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return {};
     return parsed;
@@ -9459,40 +9015,40 @@ function readSecretsFile(pluginName) {
   }
 }
 function writePluginSecret(pluginName, key, value) {
-  mkdirSync3(SECRETS_DIR, { recursive: true, mode: 448 });
+  mkdirSync2(SECRETS_DIR, { recursive: true, mode: 448 });
   const filePath = getSecretsPath(pluginName);
   const existing = readSecretsFile(pluginName);
   existing[key] = value;
-  writeFileSync2(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
+  writeFileSync(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
 }
 function deletePluginSecret(pluginName, key) {
   const existing = readSecretsFile(pluginName);
   if (!(key in existing)) return false;
   delete existing[key];
   const filePath = getSecretsPath(pluginName);
-  writeFileSync2(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
+  writeFileSync(filePath, JSON.stringify(existing, null, 2), { mode: 384 });
   return true;
 }
 function listPluginSecretKeys(pluginName) {
   return Object.keys(readSecretsFile(pluginName));
 }
-function createSecretsSDK(pluginName, pluginConfig, log15) {
+function createSecretsSDK(pluginName, pluginConfig, log12) {
   const envPrefix = pluginName.replace(/-/g, "_").toUpperCase();
   function get(key) {
     const envKey = `${envPrefix}_${key.toUpperCase()}`;
     const envValue = process.env[envKey];
     if (envValue) {
-      log15.debug(`Secret "${key}" resolved from env var ${envKey}`);
+      log12.debug(`Secret "${key}" resolved from env var ${envKey}`);
       return envValue;
     }
     const stored = readSecretsFile(pluginName);
     if (key in stored && stored[key]) {
-      log15.debug(`Secret "${key}" resolved from secrets store`);
+      log12.debug(`Secret "${key}" resolved from secrets store`);
       return stored[key];
     }
     const configValue = pluginConfig[key];
     if (configValue !== void 0 && configValue !== null) {
-      log15.debug(`Secret "${key}" resolved from pluginConfig`);
+      log12.debug(`Secret "${key}" resolved from pluginConfig`);
       return String(configValue);
     }
     return void 0;
@@ -9594,7 +9150,7 @@ function createStorageSDK(db) {
 }
 
 // src/sdk/bot.ts
-function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLimiter, log15) {
+function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLimiter, log12) {
   if (!router || !manifest || !manifest.inline && !manifest.callbacks) {
     return null;
   }
@@ -9617,7 +9173,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
     },
     onInlineQuery(handler) {
       if (handlers.onInlineQuery) {
-        log15.warn("onInlineQuery called again \u2014 overwriting previous handler");
+        log12.warn("onInlineQuery called again \u2014 overwriting previous handler");
       }
       handlers.onInlineQuery = async (ctx) => {
         if (rateLimiter) {
@@ -9663,7 +9219,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
           return;
         } catch (error) {
           if (error?.errorMessage === "MESSAGE_NOT_MODIFIED") return;
-          log15.warn(`GramJS edit failed, falling back to Grammy: ${error?.errorMessage || error}`);
+          log12.warn(`GramJS edit failed, falling back to Grammy: ${error?.errorMessage || error}`);
         }
       }
       if (grammyBot) {
@@ -9676,7 +9232,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
           });
         } catch (error) {
           if (error?.description?.includes("message is not modified")) return;
-          log15.error(`Failed to edit inline message: ${error?.description || error}`);
+          log12.error(`Failed to edit inline message: ${error?.description || error}`);
         }
       }
     },
@@ -9735,13 +9291,13 @@ function createSafeDb(db) {
   });
 }
 function createPluginSDK(deps, opts) {
-  const log15 = createLogger2(opts.pluginName);
+  const log12 = createLogger2(opts.pluginName);
   const safeDb = opts.db ? createSafeDb(opts.db) : null;
-  const ton = Object.freeze(createTonSDK(log15, safeDb));
-  const telegram = Object.freeze(createTelegramSDK(deps.bridge, log15));
-  const secrets = Object.freeze(createSecretsSDK(opts.pluginName, opts.pluginConfig, log15));
+  const ton = Object.freeze(createTonSDK(log12, safeDb));
+  const telegram = Object.freeze(createTelegramSDK(deps.bridge, log12));
+  const secrets = Object.freeze(createSecretsSDK(opts.pluginName, opts.pluginConfig, log12));
   const storage = safeDb ? Object.freeze(createStorageSDK(safeDb)) : null;
-  const frozenLog = Object.freeze(log15);
+  const frozenLog = Object.freeze(log12);
   const frozenConfig = Object.freeze(JSON.parse(JSON.stringify(opts.sanitizedConfig ?? {})));
   const frozenPluginConfig = Object.freeze(JSON.parse(JSON.stringify(opts.pluginConfig ?? {})));
   let cachedBot;
@@ -9772,20 +9328,20 @@ function createPluginSDK(deps, opts) {
     },
     on(hookName, handler, onOpts) {
       if (!opts.hookRegistry) {
-        log15.warn(`Hook registration unavailable \u2014 sdk.on() ignored`);
+        log12.warn(`Hook registration unavailable \u2014 sdk.on() ignored`);
         return;
       }
       if (opts.declaredHooks) {
         const declared = opts.declaredHooks.some((h2) => h2.name === hookName);
         if (!declared) {
-          log15.warn(`Hook "${hookName}" not declared in manifest \u2014 registration rejected`);
+          log12.warn(`Hook "${hookName}" not declared in manifest \u2014 registration rejected`);
           return;
         }
       }
       const rawPriority = Number(onOpts?.priority) || 0;
       const clampedPriority = Math.max(-1e3, Math.min(1e3, rawPriority));
       if (rawPriority !== clampedPriority) {
-        log15.debug(`Hook "${hookName}" priority ${rawPriority} clamped to ${clampedPriority}`);
+        log12.debug(`Hook "${hookName}" priority ${rawPriority} clamped to ${clampedPriority}`);
       }
       const registered = opts.hookRegistry.register({
         pluginId: opts.pluginName,
@@ -9795,7 +9351,7 @@ function createPluginSDK(deps, opts) {
         globalPriority: opts.globalPriority ?? 0
       });
       if (!registered) {
-        log15.warn(
+        log12.warn(
           `Hook registration limit reached for plugin "${opts.pluginName}" \u2014 "${hookName}" rejected`
         );
       }
@@ -9914,24 +9470,24 @@ var HookRegistry = class {
 
 // src/agent/tools/plugin-loader.ts
 var execFileAsync = promisify(execFile);
-var log12 = createLogger("PluginLoader");
-var PLUGIN_DATA_DIR = join5(TELETON_ROOT, "plugins", "data");
+var log9 = createLogger("PluginLoader");
+var PLUGIN_DATA_DIR = join3(TELETON_ROOT, "plugins", "data");
 function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps, hookRegistry, pluginPriorities) {
   let manifest = null;
   if (raw.manifest) {
     try {
       manifest = validateManifest(raw.manifest);
     } catch (err) {
-      log12.warn(
+      log9.warn(
         `[${entryName}] invalid manifest, ignoring: ${err instanceof Error ? err.message : err}`
       );
     }
   }
   if (!manifest) {
-    const manifestPath = join5(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
+    const manifestPath = join3(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
     try {
-      if (existsSync6(manifestPath)) {
-        const diskManifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+      if (existsSync5(manifestPath)) {
+        const diskManifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
         if (diskManifest && typeof diskManifest.version === "string") {
           manifest = {
             name: entryName,
@@ -10006,7 +9562,7 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps, hookReg
     },
     migrate() {
       try {
-        const dbPath = join5(PLUGIN_DATA_DIR, `${pluginName}.db`);
+        const dbPath = join3(PLUGIN_DATA_DIR, `${pluginName}.db`);
         pluginDb = openModuleDb(dbPath);
         if (hasMigrate) {
           raw.migrate?.(pluginDb);
@@ -10111,36 +9667,36 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps, hookReg
   return module;
 }
 async function ensurePluginDeps(pluginDir, pluginEntry) {
-  const pkgJson = join5(pluginDir, "package.json");
-  const lockfile = join5(pluginDir, "package-lock.json");
-  const nodeModules = join5(pluginDir, "node_modules");
-  if (!existsSync6(pkgJson)) return;
-  if (!existsSync6(lockfile)) {
-    log12.warn(
+  const pkgJson = join3(pluginDir, "package.json");
+  const lockfile = join3(pluginDir, "package-lock.json");
+  const nodeModules = join3(pluginDir, "node_modules");
+  if (!existsSync5(pkgJson)) return;
+  if (!existsSync5(lockfile)) {
+    log9.warn(
       `[${pluginEntry}] package.json without package-lock.json \u2014 skipping (lockfile required)`
     );
     return;
   }
-  if (existsSync6(nodeModules)) {
-    const marker = join5(nodeModules, ".package-lock.json");
-    if (existsSync6(marker) && statSync(marker).mtimeMs >= statSync(lockfile).mtimeMs) return;
+  if (existsSync5(nodeModules)) {
+    const marker = join3(nodeModules, ".package-lock.json");
+    if (existsSync5(marker) && statSync(marker).mtimeMs >= statSync(lockfile).mtimeMs) return;
   }
-  log12.info(`[${pluginEntry}] Installing dependencies...`);
+  log9.info(`[${pluginEntry}] Installing dependencies...`);
   try {
     await execFileAsync("npm", ["ci", "--ignore-scripts", "--no-audit", "--no-fund"], {
       cwd: pluginDir,
       timeout: 6e4,
       env: { ...process.env, NODE_ENV: "production" }
     });
-    log12.info(`[${pluginEntry}] Dependencies installed`);
+    log9.info(`[${pluginEntry}] Dependencies installed`);
   } catch (err) {
-    log12.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
+    log9.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
   }
 }
 async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
   const hookRegistry = new HookRegistry();
   const pluginsDir = WORKSPACE_PATHS.PLUGINS_DIR;
-  if (!existsSync6(pluginsDir)) {
+  if (!existsSync5(pluginsDir)) {
     return { modules: [], hookRegistry };
   }
   let pluginPriorities = /* @__PURE__ */ new Map();
@@ -10156,15 +9712,15 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
   const pluginPaths = [];
   for (const entry of entries) {
     if (entry === "data") continue;
-    const entryPath = join5(pluginsDir, entry);
+    const entryPath = join3(pluginsDir, entry);
     let modulePath = null;
     try {
       const stat = statSync(entryPath);
       if (stat.isFile() && entry.endsWith(".js")) {
         modulePath = entryPath;
       } else if (stat.isDirectory()) {
-        const indexPath = join5(entryPath, "index.js");
-        if (existsSync6(indexPath)) {
+        const indexPath = join3(entryPath, "index.js");
+        if (existsSync5(indexPath)) {
           modulePath = indexPath;
         }
       }
@@ -10176,7 +9732,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
     }
   }
   await Promise.allSettled(
-    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join5(pluginsDir, entry), entry))
+    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join3(pluginsDir, entry), entry))
   );
   const loadResults = await Promise.allSettled(
     pluginPaths.map(async ({ entry, path }) => {
@@ -10187,7 +9743,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
   );
   for (const result of loadResults) {
     if (result.status === "rejected") {
-      log12.error(
+      log9.error(
         `Plugin failed to load: ${result.reason instanceof Error ? result.reason.message : result.reason}`
       );
       continue;
@@ -10195,7 +9751,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
     const { entry, mod } = result.value;
     try {
       if (!mod.tools || typeof mod.tools !== "function" && !Array.isArray(mod.tools)) {
-        log12.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
+        log9.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
         continue;
       }
       const adapted = adaptPlugin(
@@ -10208,21 +9764,21 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
         pluginPriorities
       );
       if (loadedNames.has(adapted.name)) {
-        log12.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
+        log9.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
         continue;
       }
       loadedNames.add(adapted.name);
       modules.push(adapted);
     } catch (err) {
-      log12.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
+      log9.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
     }
   }
   return { modules, hookRegistry };
 }
 
 // src/config/configurable-keys.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "fs";
-import { parse as parse2, stringify as stringify2 } from "yaml";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync6 } from "fs";
+import { parse, stringify } from "yaml";
 var noValidation = () => void 0;
 var identity = (v) => v;
 var nonEmpty = (v) => v.length > 0 ? void 0 : "Must not be empty";
@@ -10841,11 +10397,11 @@ function deleteNestedValue(obj, path) {
 }
 function readRawConfig(configPath) {
   const fullPath = expandPath(configPath);
-  if (!existsSync7(fullPath)) {
+  if (!existsSync6(fullPath)) {
     throw new Error(`Config file not found: ${fullPath}
 Run 'teleton setup' to create one.`);
   }
-  const raw = parse2(readFileSync6(fullPath, "utf-8"));
+  const raw = parse(readFileSync5(fullPath, "utf-8"));
   if (!raw || typeof raw !== "object") {
     throw new Error(`Invalid config file: ${fullPath}`);
   }
@@ -10861,26 +10417,26 @@ function writeRawConfig(raw, configPath) {
   raw.meta = raw.meta ?? {};
   raw.meta.last_modified_at = (/* @__PURE__ */ new Date()).toISOString();
   const fullPath = expandPath(configPath);
-  writeFileSync3(fullPath, stringify2(raw), { encoding: "utf-8", mode: 384 });
+  writeFileSync2(fullPath, stringify(raw), { encoding: "utf-8", mode: 384 });
 }
 
 // src/ton-proxy/manager.ts
 import { spawn, execSync } from "child_process";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync7,
   chmodSync,
   createWriteStream,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync4,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync3,
   unlinkSync
 } from "fs";
-import { mkdir as mkdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { mkdir } from "fs/promises";
+import { join as join4 } from "path";
 import { pipeline } from "stream/promises";
-var log13 = createLogger("TonProxy");
+var log10 = createLogger("TonProxy");
 var GITHUB_REPO = "xssnick/Tonutils-Proxy";
-var BINARY_DIR = join6(TELETON_ROOT, "bin");
-var PID_FILE = join6(TELETON_ROOT, "ton-proxy.pid");
+var BINARY_DIR = join4(TELETON_ROOT, "bin");
+var PID_FILE = join4(TELETON_ROOT, "ton-proxy.pid");
 var HEALTH_CHECK_INTERVAL_MS = 3e4;
 var HEALTH_CHECK_TIMEOUT_MS = 5e3;
 var KILL_GRACE_MS = 5e3;
@@ -10896,11 +10452,11 @@ var TonProxyManager = class {
   /** Resolve the binary path — user-specified or auto-detected */
   getBinaryPath() {
     if (this.config.binary_path) return this.config.binary_path;
-    return join6(BINARY_DIR, getBinaryName());
+    return join4(BINARY_DIR, getBinaryName());
   }
   /** Check if the binary exists on disk */
   isInstalled() {
-    return existsSync8(this.getBinaryPath());
+    return existsSync7(this.getBinaryPath());
   }
   /** Whether the proxy process is currently running */
   isRunning() {
@@ -10912,8 +10468,8 @@ var TonProxyManager = class {
    */
   async install() {
     const binaryName = getBinaryName();
-    log13.info(`Downloading TON Proxy binary (${binaryName})...`);
-    await mkdir2(BINARY_DIR, { recursive: true });
+    log10.info(`Downloading TON Proxy binary (${binaryName})...`);
+    await mkdir(BINARY_DIR, { recursive: true });
     const releaseUrl = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
     const releaseRes = await fetch(releaseUrl, {
       headers: { Accept: "application/vnd.github.v3+json" }
@@ -10924,7 +10480,7 @@ var TonProxyManager = class {
     const release = await releaseRes.json();
     const tag = release.tag_name;
     const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/${tag}/${binaryName}`;
-    log13.info(`Downloading ${downloadUrl}`);
+    log10.info(`Downloading ${downloadUrl}`);
     const res = await fetch(downloadUrl);
     if (!res.ok || !res.body) {
       throw new Error(`Download failed: ${res.status} ${res.statusText}`);
@@ -10933,17 +10489,17 @@ var TonProxyManager = class {
     const fileStream = createWriteStream(dest);
     await pipeline(res.body, fileStream);
     chmodSync(dest, 493);
-    log13.info(`TON Proxy installed: ${dest} (${tag})`);
+    log10.info(`TON Proxy installed: ${dest} (${tag})`);
   }
   /** Kill any orphan proxy process from a previous session */
   killOrphan() {
-    if (existsSync8(PID_FILE)) {
+    if (existsSync7(PID_FILE)) {
       try {
-        const pid = parseInt(readFileSync7(PID_FILE, "utf-8").trim(), 10);
+        const pid = parseInt(readFileSync6(PID_FILE, "utf-8").trim(), 10);
         if (pid && !isNaN(pid)) {
           try {
             process.kill(pid, 0);
-            log13.warn(`Killing orphan TON Proxy (PID ${pid}) from previous session`);
+            log10.warn(`Killing orphan TON Proxy (PID ${pid}) from previous session`);
             process.kill(pid, "SIGTERM");
           } catch {
           }
@@ -10960,7 +10516,7 @@ var TonProxyManager = class {
       const pidMatch = out.match(/pid=(\d+)/);
       if (pidMatch) {
         const pid = parseInt(pidMatch[1], 10);
-        log13.warn(`Port ${this.config.port} occupied by PID ${pid}, killing it`);
+        log10.warn(`Port ${this.config.port} occupied by PID ${pid}, killing it`);
         try {
           process.kill(pid, "SIGTERM");
         } catch {
@@ -10973,22 +10529,22 @@ var TonProxyManager = class {
   /** Write PID to file for orphan detection */
   writePidFile(pid) {
     try {
-      writeFileSync4(PID_FILE, String(pid), { mode: 384 });
+      writeFileSync3(PID_FILE, String(pid), { mode: 384 });
     } catch {
-      log13.warn("Failed to write TON Proxy PID file");
+      log10.warn("Failed to write TON Proxy PID file");
     }
   }
   /** Remove PID file */
   removePidFile() {
     try {
-      if (existsSync8(PID_FILE)) unlinkSync(PID_FILE);
+      if (existsSync7(PID_FILE)) unlinkSync(PID_FILE);
     } catch {
     }
   }
   /** Start the proxy process */
   async start() {
     if (this.isRunning()) {
-      log13.warn("TON Proxy is already running");
+      log10.warn("TON Proxy is already running");
       return;
     }
     this.restartCount = 0;
@@ -10999,7 +10555,7 @@ var TonProxyManager = class {
     }
     const binaryPath = this.getBinaryPath();
     const port = String(this.config.port);
-    log13.info(`Starting TON Proxy on 127.0.0.1:${port}`);
+    log10.info(`Starting TON Proxy on 127.0.0.1:${port}`);
     this.process = spawn(binaryPath, ["-addr", `127.0.0.1:${port}`], {
       cwd: BINARY_DIR,
       stdio: ["ignore", "pipe", "pipe"],
@@ -11007,24 +10563,24 @@ var TonProxyManager = class {
     });
     this.process.stdout?.on("data", (chunk) => {
       const line = chunk.toString().trim();
-      if (line) log13.debug(`[proxy] ${line}`);
+      if (line) log10.debug(`[proxy] ${line}`);
     });
     this.process.stderr?.on("data", (chunk) => {
       const line = chunk.toString().trim();
-      if (line) log13.warn(`[proxy:err] ${line}`);
+      if (line) log10.warn(`[proxy:err] ${line}`);
     });
     this.process.on("exit", (code, signal) => {
-      log13.info(`TON Proxy exited (code=${code}, signal=${signal})`);
+      log10.info(`TON Proxy exited (code=${code}, signal=${signal})`);
       this.process = null;
       this.removePidFile();
       if (code !== 0 && code !== null && this.restartCount < this.maxRestarts) {
         this.restartCount++;
-        log13.warn(`Auto-restarting TON Proxy (attempt ${this.restartCount}/${this.maxRestarts})`);
-        this.start().catch((err) => log13.error({ err }, "Failed to auto-restart TON Proxy"));
+        log10.warn(`Auto-restarting TON Proxy (attempt ${this.restartCount}/${this.maxRestarts})`);
+        this.start().catch((err) => log10.error({ err }, "Failed to auto-restart TON Proxy"));
       }
     });
     this.process.on("error", (err) => {
-      log13.error({ err }, "TON Proxy process error");
+      log10.error({ err }, "TON Proxy process error");
       this.process = null;
     });
     this.startHealthCheck();
@@ -11042,14 +10598,14 @@ var TonProxyManager = class {
       });
     });
     if (this.process?.pid) this.writePidFile(this.process.pid);
-    log13.info(`TON Proxy running on 127.0.0.1:${port} (PID ${this.process?.pid})`);
+    log10.info(`TON Proxy running on 127.0.0.1:${port} (PID ${this.process?.pid})`);
   }
   /** Stop the proxy process gracefully */
   async stop() {
     this.stopHealthCheck();
     if (!this.process) return;
     this.maxRestarts = 0;
-    log13.info("Stopping TON Proxy...");
+    log10.info("Stopping TON Proxy...");
     return new Promise((resolve2) => {
       if (!this.process) {
         resolve2();
@@ -11057,7 +10613,7 @@ var TonProxyManager = class {
       }
       const forceKill = setTimeout(() => {
         if (this.process) {
-          log13.warn("TON Proxy did not exit gracefully, sending SIGKILL");
+          log10.warn("TON Proxy did not exit gracefully, sending SIGKILL");
           this.process.kill("SIGKILL");
         }
       }, KILL_GRACE_MS);
@@ -11076,10 +10632,10 @@ var TonProxyManager = class {
       await this.stop();
     }
     const binaryPath = this.getBinaryPath();
-    if (existsSync8(binaryPath)) {
+    if (existsSync7(binaryPath)) {
       const { unlink } = await import("fs/promises");
       await unlink(binaryPath);
-      log13.info(`TON Proxy binary removed: ${binaryPath}`);
+      log10.info(`TON Proxy binary removed: ${binaryPath}`);
     }
   }
   /** Get proxy status for WebUI / tools */
@@ -11113,7 +10669,7 @@ var TonProxyManager = class {
       }).catch(() => null);
       clearTimeout(timeout);
       if (!res) {
-        log13.warn("TON Proxy health check failed (no response)");
+        log10.warn("TON Proxy health check failed (no response)");
       }
     } catch {
     }
@@ -11170,7 +10726,7 @@ var tonProxyStatusExecutor = async () => {
 };
 
 // src/ton-proxy/module.ts
-var log14 = createLogger("TonProxyModule");
+var log11 = createLogger("TonProxyModule");
 var manager = null;
 function getTonProxyManager() {
   return manager;
@@ -11197,9 +10753,9 @@ var tonProxyModule = {
     setProxyManager(manager);
     try {
       await manager.start();
-      log14.info(`TON Proxy started on port ${proxyConfig.port}`);
+      log11.info(`TON Proxy started on port ${proxyConfig.port}`);
     } catch (err) {
-      log14.error({ err }, "Failed to start TON Proxy");
+      log11.error({ err }, "Failed to start TON Proxy");
       manager = null;
     }
   },
@@ -11251,9 +10807,6 @@ function setTriggersConfig(db, triggers) {
 }
 
 export {
-  loadConfig,
-  configExists,
-  getDefaultConfigPath,
   WorkspaceSecurityError,
   validatePath,
   validateReadPath,