teleton 0.8.3 → 0.8.5

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

@@ -6,32 +6,12 @@ import {
   getWalletBalance,
   invalidateTonClientCache,
   loadWallet
-} from "./chunk-FUNF6H4W.js";
+} from "./chunk-M6M4DCDU.js";
 import {
-  expandPath
-} from "./chunk-AEHTQI3H.js";
-import {
-  ConfigSchema
-} from "./chunk-AERHOXGC.js";
-import {
-  getOrCreateSession,
-  getSession,
-  resetSession,
-  resetSessionWithPolicy,
-  shouldResetSession,
-  updateSession
-} from "./chunk-XDZDOKIF.js";
-import {
-  ContextBuilder,
   createDbWrapper,
-  getDatabase,
   migrateFromMainDb,
   openModuleDb
-} from "./chunk-GHMXWAXI.js";
-import {
-  saveSessionMemory,
-  summarizeWithFallback
-} from "./chunk-ALKAAG4O.js";
+} from "./chunk-35X3V6OW.js";
 import {
   getErrorMessage,
   isHttpError
@@ -51,39 +31,8 @@ import {
   tonapiFetch
 } from "./chunk-VFA7QMCZ.js";
 import {
-  COMPACTION_KEEP_RECENT,
-  COMPACTION_MAX_MESSAGES,
-  COMPACTION_MAX_TOKENS_RATIO,
-  COMPACTION_SOFT_THRESHOLD_RATIO,
-  CONTEXT_MAX_RECENT_MESSAGES,
-  CONTEXT_MAX_RELEVANT_CHUNKS,
-  CONTEXT_OVERFLOW_SUMMARY_MESSAGES,
-  DEFAULT_CONTEXT_WINDOW,
-  DEFAULT_MAX_SUMMARY_TOKENS,
-  DEFAULT_MAX_TOKENS,
-  DEFAULT_SOFT_THRESHOLD_TOKENS,
-  EMBEDDING_QUERY_MAX_CHARS,
-  FALLBACK_SOFT_THRESHOLD_TOKENS,
-  MASKING_KEEP_RECENT_COUNT,
-  MAX_TOOL_RESULT_SIZE,
-  MEMORY_FLUSH_RECENT_MESSAGES,
-  PAYMENT_TOLERANCE_RATIO,
-  RATE_LIMIT_MAX_RETRIES,
-  RESULT_TRUNCATION_KEEP_CHARS,
-  RESULT_TRUNCATION_THRESHOLD,
-  SERVER_ERROR_MAX_RETRIES,
-  TOOL_CONCURRENCY_LIMIT
-} from "./chunk-C4NKJT2Z.js";
-import {
-  chatWithContext,
-  getEffectiveApiKey,
-  getProviderModel,
-  loadContextFromTranscript
-} from "./chunk-LVTKJQ7O.js";
-import {
-  getProviderMetadata,
-  getSupportedProviders
-} from "./chunk-6OOHHJ4N.js";
+  PAYMENT_TOLERANCE_RATIO
+} from "./chunk-L3LPVF4Z.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
@@ -96,17 +45,12 @@ 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,
   WORKSPACE_PATHS,
   WORKSPACE_ROOT
-} from "./chunk-EYWNOHMJ.js";
+} from "./chunk-L653KKCR.js";
 import {
   createLogger
 } from "./chunk-NQ6FZKCE.js";
@@ -333,20 +277,30 @@ var SOUL_PATHS = [WORKSPACE_PATHS.SOUL];
 var STRATEGY_PATHS = [WORKSPACE_PATHS.STRATEGY];
 var SECURITY_PATHS = [WORKSPACE_PATHS.SECURITY];
 var MEMORY_PATH = WORKSPACE_PATHS.MEMORY;
-var DEFAULT_SOUL = `# Teleton AI
+var DEFAULT_SOUL = `# Teleton
 
-You are Teleton, a personal AI assistant that operates through Telegram.
+You are Teleton, an autonomous AI agent operating through Telegram with TON blockchain capabilities.
 
-## Personality
-- Helpful and concise
-- Direct and honest
-- Friendly but professional
+## Identity
+You are not a chatbot. You are an always-on agent that lives in Telegram.
+You have access to someone's messages, wallet, groups, and files \u2014 treat that access with respect and intent.
 
-## Guidelines
-- Keep responses short and actionable
-- Use markdown when appropriate
-- Respect user privacy
-- Be transparent about capabilities and limitations
+## Personality
+- Be resourceful before asking. Search memory. Read the workspace. Check the blockchain. Then ask if you're stuck.
+- Have opinions. You're allowed to find things interesting, boring, or worth calling out.
+- Be direct and concise. Don't pad responses with filler.
+- Earn trust through accuracy. Don't invent facts about balances, prices, or chat history.
+
+## Autonomy
+- Use your tools proactively. Don't wait to be asked for things you can figure out.
+- Write important things to memory before they leave your context.
+- Check your HEARTBEAT.md for periodic tasks and update it \u2014 add new tasks, check off completed ones. This file is yours to manage.
+- When you have nothing useful to add, stay silent.
+
+## Continuity
+You wake fresh each session. MEMORY.md and memory/ are your long-term state.
+Read them. Write to them. They are how you persist across restarts.
+Your context window will be compacted automatically when it fills up. Save important information to MEMORY.md before it's lost. When you see '[Auto-compacted]' in your context, a compaction just happened \u2014 check your memory files to recover context.
 `;
 var fileCache = /* @__PURE__ */ new Map();
 var FILE_CACHE_TTL = 6e4;
@@ -417,6 +371,15 @@ ${sanitizeForContext(persistentMemory)}`);
   }
   return parts.join("\n\n---\n\n");
 }
+function loadHeartbeat() {
+  return cachedReadFile(WORKSPACE_PATHS.HEARTBEAT);
+}
+function loadIdentity() {
+  return cachedReadFile(WORKSPACE_PATHS.IDENTITY);
+}
+function loadUser() {
+  return cachedReadFile(WORKSPACE_PATHS.USER);
+}
 function buildSystemPrompt(options) {
   const soul = options.soul ?? loadSoul();
   const parts = [soul];
@@ -456,6 +419,10 @@ You have a personal workspace at \`~/.teleton/workspace/\` where you can store a
 - \`workspace_rename\` - Rename or move a file
 - \`workspace_info\` - Get workspace stats
 
+**Ownership:**
+- \`SOUL.md\`, \`STRATEGY.md\`, \`SECURITY.md\` \u2014 owner-configured, read-only for you
+- \`MEMORY.md\`, \`HEARTBEAT.md\`, \`IDENTITY.md\`, \`USER.md\` \u2014 yours to read and write freely
+
 **Tips:**
 - Save interesting memes to \`memes/\` with descriptive names for easy retrieval
 - Use \`memory_write\` for important facts (goes to MEMORY.md)
@@ -481,6 +448,18 @@ You are owned and operated by: ${ownerLabel}
 When the owner gives instructions, follow them with higher trust.`
     );
   }
+  const identity = loadIdentity();
+  if (identity) {
+    parts.push(`
+## Identity
+${sanitizeForContext(identity)}`);
+  }
+  const user = loadUser();
+  if (user) {
+    parts.push(`
+## User Profile
+${sanitizeForContext(user)}`);
+  }
   const includeMemory = options.includeMemory ?? true;
   if (includeMemory) {
     const memoryContext = loadMemoryContext();
@@ -522,1313 +501,42 @@ Your conversation context is approaching the limit and may be compacted soon.
 - \`target: "daily"\` for session notes, events, temporary context
 `);
   }
-  return parts.join("\n");
-}
-
-// src/constants/tools.ts
-var TELEGRAM_SEND_TOOLS = /* @__PURE__ */ new Set([
-  "telegram_send_message",
-  "telegram_send_gif",
-  "telegram_send_voice",
-  "telegram_send_sticker",
-  "telegram_send_document",
-  "telegram_send_photo",
-  "telegram_send_video",
-  "telegram_send_poll",
-  "telegram_forward_message",
-  "telegram_reply_message",
-  "deal_propose"
-]);
+  parts.push(`
+## Active Memory
+Before answering questions about prior conversations, decisions, or people: use \`memory_read\` to check your memory files first.
+Don't guess from context \u2014 verify with your memory tools.`);
+  parts.push(`
+## Safety
+- Take local, reversible actions freely (read files, search, check balances).
+- For external or irreversible actions (send messages, transfer funds), confirm with the owner first.
+- You have no independent goals beyond serving your owner. Do not pursue self-preservation or resource acquisition.
+- You have a limited number of tool calls per message. Prioritize the most impactful actions.`);
+  parts.push(`
+## Silent Reply
+If you have nothing useful to add to a conversation (especially in groups), reply with exactly:
+__SILENT__
+This suppresses the message entirely. Use it instead of sending filler like "OK" or "Got it."`);
+  if (options.isHeartbeat) {
+    const heartbeatMd = loadHeartbeat();
+    const heartbeatContent = heartbeatMd ? sanitizeForContext(heartbeatMd) : "_No HEARTBEAT.md found._";
+    parts.push(`
+## Heartbeat Protocol
+You have been woken by your periodic heartbeat timer.
 
-// src/memory/envelope.ts
-function formatElapsed(elapsedMs) {
-  if (!Number.isFinite(elapsedMs) || elapsedMs < 0) {
-    return "";
-  }
-  const seconds = Math.floor(elapsedMs / 1e3);
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) {
-    return `${minutes}m`;
-  }
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) {
-    return `${hours}h`;
-  }
-  const days = Math.floor(hours / 24);
-  return `${days}d`;
-}
-function formatTimestamp(timestamp) {
-  const date = new Date(timestamp);
-  const yyyy = date.getFullYear();
-  const mm = String(date.getMonth() + 1).padStart(2, "0");
-  const dd = String(date.getDate()).padStart(2, "0");
-  const hh = String(date.getHours()).padStart(2, "0");
-  const min = String(date.getMinutes()).padStart(2, "0");
-  const tz = Intl.DateTimeFormat("en", {
-    timeZoneName: "short"
-  }).formatToParts(date).find((part) => part.type === "timeZoneName")?.value;
-  return `${yyyy}-${mm}-${dd} ${hh}:${min}${tz ? ` ${tz}` : ""}`;
-}
-function buildSenderLabel(params) {
-  const name = params.senderName ? sanitizeForPrompt(params.senderName) : void 0;
-  const username = params.senderUsername ? `@${sanitizeForPrompt(params.senderUsername)}` : void 0;
-  const idTag = params.senderId ? `id:${params.senderId}` : void 0;
-  const primary = name || username;
-  const meta = [username, idTag].filter((v) => v && v !== primary);
-  let label;
-  if (primary) {
-    label = meta.length > 0 ? `${primary} (${meta.join(", ")})` : primary;
-  } else {
-    label = idTag || "unknown";
-  }
-  if (params.senderRank) {
-    label = `[${sanitizeForPrompt(params.senderRank)}] ${label}`;
-  }
-  return label;
-}
-function formatMessageEnvelope(params) {
-  const parts = [params.channel];
-  const senderLabel = buildSenderLabel(params);
-  if (!params.isGroup) {
-    parts.push(senderLabel);
-  }
-  if (params.previousTimestamp) {
-    const elapsed = formatElapsed(params.timestamp - params.previousTimestamp);
-    if (elapsed) {
-      parts.push(`+${elapsed}`);
-    }
-  }
-  const ts = formatTimestamp(params.timestamp);
-  parts.push(ts);
-  const header = `[${parts.join(" ")}]`;
-  const safeBody = sanitizeForContext(params.body.replace(/<\/?user_message>/gi, ""));
-  let body = params.isGroup ? `${senderLabel}: <user_message>${safeBody}</user_message>` : `<user_message>${safeBody}</user_message>`;
-  if (params.hasMedia && params.mediaType) {
-    const mediaEmoji = {
-      photo: "\u{1F4F7}",
-      video: "\u{1F3AC}",
-      audio: "\u{1F3B5}",
-      voice: "\u{1F3A4}",
-      document: "\u{1F4CE}",
-      sticker: "\u{1F3A8}"
-    }[params.mediaType] || "\u{1F4CE}";
-    const msgIdHint = params.messageId ? ` msg_id=${params.messageId}` : "";
-    body = `[${mediaEmoji} ${params.mediaType}${msgIdHint}] ${body}`;
-  }
-  if (params.replyContext) {
-    const sender = params.replyContext.isAgent ? "agent" : sanitizeForPrompt(params.replyContext.senderName ?? "unknown");
-    let quotedText = sanitizeForContext(params.replyContext.text);
-    if (quotedText.length > 200) quotedText = quotedText.slice(0, 200) + "...";
-    return `${header}
-[\u21A9 reply to ${sender}: "${quotedText}"]
-${body}`;
-  }
-  return `${header} ${body}`;
-}
+${heartbeatContent}
 
-// src/memory/compaction.ts
-import { randomUUID } from "crypto";
-var DEFAULT_COMPACTION_CONFIG = {
-  enabled: true,
-  maxMessages: COMPACTION_MAX_MESSAGES,
-  maxTokens: DEFAULT_MAX_TOKENS,
-  keepRecentMessages: COMPACTION_KEEP_RECENT,
-  memoryFlushEnabled: true,
-  softThresholdTokens: DEFAULT_SOFT_THRESHOLD_TOKENS
-};
-var log2 = createLogger("Memory");
-function estimateContextTokens(context) {
-  let charCount = 0;
-  if (context.systemPrompt) {
-    charCount += context.systemPrompt.length;
-  }
-  for (const message of context.messages) {
-    if (message.role === "user") {
-      if (typeof message.content === "string") {
-        charCount += message.content.length;
-      } else if (Array.isArray(message.content)) {
-        for (const block of message.content) {
-          if (block.type === "text") charCount += block.text.length;
-        }
-      }
-    } else if (message.role === "assistant") {
-      for (const block of message.content) {
-        if (block.type === "text") {
-          charCount += block.text.length;
-        }
-      }
-    }
-  }
-  return Math.ceil(charCount / 4);
-}
-function shouldFlushMemory(context, config, tokenCount) {
-  if (!config.enabled || !config.memoryFlushEnabled) {
-    return false;
-  }
-  const tokens = tokenCount ?? estimateContextTokens(context);
-  const softThreshold = config.softThresholdTokens ?? FALLBACK_SOFT_THRESHOLD_TOKENS;
-  if (tokens >= softThreshold) {
-    log2.info(`Memory flush needed: ~${tokens} tokens (soft threshold: ${softThreshold})`);
-    return true;
-  }
-  return false;
-}
-function flushMemoryToDailyLog(context) {
-  const recentMessages = context.messages.slice(-MEMORY_FLUSH_RECENT_MESSAGES);
-  const summary = [];
-  summary.push("**Recent Context:**\n");
-  for (const msg of recentMessages) {
-    if (msg.role === "user") {
-      const content = typeof msg.content === "string" ? msg.content : "[complex content]";
-      summary.push(`- User: ${content.substring(0, 100)}${content.length > 100 ? "..." : ""}`);
-    } else if (msg.role === "assistant") {
-      const textBlocks = msg.content.filter((b) => b.type === "text");
-      if (textBlocks.length > 0) {
-        const text = textBlocks[0].text || "";
-        summary.push(`- Assistant: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`);
-      }
-    }
-  }
-  writeSummaryToDailyLog(summary.join("\n"));
-  log2.info(`Memory flushed to daily log`);
-}
-function shouldCompact(context, config, tokenCount) {
-  if (!config.enabled) {
-    return false;
-  }
-  const messageCount = context.messages.length;
-  if (config.maxMessages && messageCount >= 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) {
-      log2.info(`Compaction needed: ~${tokens} tokens (max: ${config.maxTokens})`);
-      return true;
-    }
-  }
-  return false;
-}
-async function compactContext(context, config, apiKey, provider, utilityModel) {
-  const keepCount = config.keepRecentMessages ?? 10;
-  if (context.messages.length <= keepCount) {
-    return context;
-  }
-  let cutIndex = context.messages.length - keepCount;
-  const collectToolUseIds = (msgs) => {
-    const ids = /* @__PURE__ */ new Set();
-    for (const msg of msgs) {
-      if (msg.role === "assistant" && Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "toolCall") {
-            if (block.id) ids.add(block.id);
-          }
-        }
-      }
-    }
-    return ids;
-  };
-  const hasOrphanedToolResults = (msgs) => {
-    const toolUseIds = collectToolUseIds(msgs);
-    for (const msg of msgs) {
-      if (msg.role === "toolResult") {
-        if (msg.toolCallId && !toolUseIds.has(msg.toolCallId)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  };
-  let iterations = 0;
-  while (cutIndex > 0 && iterations < 50) {
-    const keptMessages = context.messages.slice(cutIndex);
-    if (!hasOrphanedToolResults(keptMessages)) {
-      break;
-    }
-    cutIndex--;
-    iterations++;
+Follow HEARTBEAT.md strictly. Do not infer tasks from prior conversations.
+You can modify HEARTBEAT.md with \`workspace_write\` to update your own task checklist.
+If nothing needs attention, reply with exactly: NO_ACTION
+Do NOT include NO_ACTION alongside other content \u2014 it must be your entire response when nothing is needed.`);
   }
-  if (hasOrphanedToolResults(context.messages.slice(cutIndex))) {
-    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);
-  log2.info(
-    `Compacting ${oldMessages.length} old messages, keeping ${recentMessages.length} recent (cut at clean boundary)`
+  parts.push(
+    `
+_Runtime: agent=teleton channel=telegram model=${options.agentModel || "unknown"}_`
   );
-  try {
-    const result = await summarizeWithFallback({
-      messages: oldMessages,
-      apiKey,
-      contextWindow: config.maxTokens ?? DEFAULT_CONTEXT_WINDOW,
-      maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
-      customInstructions: `Output a structured summary using EXACTLY these sections:
-
-## User Intent
-What the user is trying to accomplish (1-2 sentences).
-
-## Key Decisions
-Bullet list of decisions made and commitments agreed upon.
-
-## Important Context
-Critical facts, preferences, constraints, or technical details needed for continuity.
-
-## Actions Taken
-What was done: tools used, messages sent, transactions made (with specific values/addresses if relevant).
-
-## Open Items
-Unfinished tasks, pending questions, or next steps.
-
-Keep each section concise. Omit a section if empty. Preserve specific names, numbers, and identifiers.`,
-      provider,
-      utilityModel
-    });
-    log2.info(`AI Summary: ${result.tokensUsed} tokens, ${result.chunksProcessed} chunks processed`);
-    const summaryText = `[Auto-compacted ${oldMessages.length} messages]
-
-${result.summary}`;
-    const summaryMessage = {
-      role: "user",
-      content: summaryText,
-      timestamp: oldMessages[0]?.timestamp ?? Date.now()
-    };
-    return {
-      ...context,
-      messages: [summaryMessage, ...recentMessages]
-    };
-  } catch (error) {
-    log2.error({ err: error }, "AI summarization failed, using fallback");
-    const summaryText = `[Auto-compacted: ${oldMessages.length} earlier messages from this conversation]`;
-    const summaryMessage = {
-      role: "user",
-      content: summaryText,
-      timestamp: oldMessages[0]?.timestamp ?? Date.now()
-    };
-    return {
-      ...context,
-      messages: [summaryMessage, ...recentMessages]
-    };
-  }
-}
-async function compactAndSaveTranscript(sessionId, context, config, apiKey, chatId, provider, utilityModel) {
-  const newSessionId = randomUUID();
-  log2.info(`Creating compacted transcript: ${sessionId} \u2192 ${newSessionId}`);
-  if (chatId) {
-    await saveSessionMemory({
-      oldSessionId: sessionId,
-      newSessionId,
-      context,
-      chatId,
-      apiKey,
-      provider,
-      utilityModel
-    });
-  }
-  const compactedContext = await compactContext(context, config, apiKey, provider, utilityModel);
-  for (const message of compactedContext.messages) {
-    appendToTranscript(newSessionId, message);
-  }
-  return newSessionId;
-}
-var CompactionManager = class {
-  config;
-  constructor(config = DEFAULT_COMPACTION_CONFIG) {
-    this.config = config;
-  }
-  async checkAndCompact(sessionId, context, apiKey, chatId, provider, utilityModel) {
-    const tokenCount = estimateContextTokens(context);
-    if (shouldFlushMemory(context, this.config, tokenCount)) {
-      flushMemoryToDailyLog(context);
-    }
-    if (!shouldCompact(context, this.config, tokenCount)) {
-      return null;
-    }
-    if (this.config.memoryFlushEnabled) {
-      flushMemoryToDailyLog(context);
-    }
-    log2.info(`Auto-compacting session ${sessionId}`);
-    const newSessionId = await compactAndSaveTranscript(
-      sessionId,
-      context,
-      this.config,
-      apiKey,
-      chatId,
-      provider,
-      utilityModel
-    );
-    log2.info(`Compaction complete: ${newSessionId}`);
-    return newSessionId;
-  }
-  updateConfig(config) {
-    this.config = { ...this.config, ...config };
-  }
-  getConfig() {
-    return { ...this.config };
-  }
-};
-
-// src/memory/observation-masking.ts
-var DEFAULT_MASKING_CONFIG = {
-  keepRecentCount: MASKING_KEEP_RECENT_COUNT,
-  keepErrorResults: true,
-  truncationThreshold: RESULT_TRUNCATION_THRESHOLD,
-  truncationKeepChars: RESULT_TRUNCATION_KEEP_CHARS
-};
-var isCocoonToolResult = (msg) => msg.role === "user" && Array.isArray(msg.content) && msg.content.some((c2) => c2.type === "text" && c2.text.includes("<tool_response>"));
-function isExempt(toolMsg, config, toolRegistry) {
-  if (config.keepErrorResults && toolMsg.isError) return true;
-  if (toolRegistry && toolRegistry.getToolCategory(toolMsg.toolName) === "data-bearing")
-    return true;
-  return false;
-}
-function truncateToolResult(text, keepChars) {
-  try {
-    const parsed = JSON.parse(text);
-    if (parsed.data?.summary) {
-      return JSON.stringify({
-        success: parsed.success,
-        data: { summary: parsed.data.summary, _truncated: true }
-      });
-    }
-    if (parsed.data?.message) {
-      return JSON.stringify({
-        success: parsed.success,
-        data: { summary: parsed.data.message, _truncated: true }
-      });
-    }
-  } catch {
-  }
-  return text.slice(0, keepChars) + `
-...[truncated, original: ${text.length} chars]`;
-}
-function maskOldToolResults(messages, options) {
-  const config = options?.config ?? DEFAULT_MASKING_CONFIG;
-  const toolRegistry = options?.toolRegistry;
-  const iterStart = options?.currentIterationStartIndex;
-  const toolResults = messages.map((msg, index) => ({ msg, index })).filter(({ msg }) => msg.role === "toolResult" || isCocoonToolResult(msg));
-  const needsMasking = toolResults.length > config.keepRecentCount;
-  const needsTruncation = iterStart !== void 0 && config.truncationThreshold > 0;
-  if (!needsMasking && !needsTruncation) {
-    return messages;
-  }
-  const result = [...messages];
-  if (needsMasking) {
-    const toMask = toolResults.slice(0, -config.keepRecentCount);
-    for (const { msg, index } of toMask) {
-      if (isCocoonToolResult(msg)) {
-        result[index] = {
-          ...msg,
-          content: [{ type: "text", text: "[Tool response masked]" }]
-        };
-        continue;
-      }
-      const toolMsg = msg;
-      if (isExempt(toolMsg, config, toolRegistry)) continue;
-      let summaryText = "";
-      try {
-        const textBlock = toolMsg.content.find((c2) => c2.type === "text");
-        if (textBlock) {
-          const parsed = JSON.parse(textBlock.text);
-          if (parsed.data?.summary) {
-            summaryText = ` - ${parsed.data.summary}`;
-          } else if (parsed.data?.message) {
-            summaryText = ` - ${parsed.data.message}`;
-          }
-        }
-      } catch {
-      }
-      result[index] = {
-        ...toolMsg,
-        content: [
-          {
-            type: "text",
-            text: `[Tool: ${toolMsg.toolName} - ${toolMsg.isError ? "ERROR" : "OK"}${summaryText}]`
-          }
-        ]
-      };
-    }
-  }
-  if (needsTruncation) {
-    const recentResults = needsMasking ? toolResults.slice(-config.keepRecentCount) : toolResults;
-    for (const { msg, index } of recentResults) {
-      if (index >= iterStart) continue;
-      if (isCocoonToolResult(msg)) {
-        const userMsg = msg;
-        if (!Array.isArray(userMsg.content)) continue;
-        const textBlock2 = userMsg.content.find((c2) => c2.type === "text");
-        if (textBlock2 && textBlock2.text.length > config.truncationThreshold) {
-          result[index] = {
-            ...userMsg,
-            content: [
-              {
-                type: "text",
-                text: truncateToolResult(textBlock2.text, config.truncationKeepChars)
-              }
-            ]
-          };
-        }
-        continue;
-      }
-      const toolMsg = msg;
-      if (isExempt(toolMsg, config, toolRegistry)) continue;
-      const textBlock = toolMsg.content.find((c2) => c2.type === "text");
-      if (!textBlock || textBlock.text.length <= config.truncationThreshold) continue;
-      result[index] = {
-        ...toolMsg,
-        content: [
-          {
-            type: "text",
-            text: truncateToolResult(textBlock.text, config.truncationKeepChars)
-          }
-        ]
-      };
-    }
-  }
-  return result;
+  return parts.join("\n");
 }
 
-// src/agent/runtime.ts
-var log3 = createLogger("Agent");
-var globalTokenUsage = { totalTokens: 0, totalCost: 0 };
-function getTokenUsage() {
-  return { ...globalTokenUsage };
-}
-function isContextOverflowError(errorMessage) {
-  if (!errorMessage) return false;
-  const lower = errorMessage.toLowerCase();
-  return lower.includes("prompt is too long") || lower.includes("context length exceeded") || lower.includes("maximum context length") || lower.includes("too many tokens") || lower.includes("request_too_large") || lower.includes("exceeds") && lower.includes("maximum") || lower.includes("context") && lower.includes("limit");
-}
-function isTrivialMessage(text) {
-  const stripped = text.trim();
-  if (!stripped) return true;
-  if (!/[a-zA-Z0-9а-яА-ЯёЁ]/.test(stripped)) return true;
-  const trivial = /^(ok|okay|k|oui|non|yes|no|yep|nope|sure|thanks|merci|thx|ty|lol|haha|cool|nice|wow|bravo|top|parfait|d'accord|alright|fine|got it|np|gg)\.?!?$/i;
-  return trivial.test(stripped);
-}
-function extractContextSummary(context, maxMessages = 10) {
-  const recentMessages = context.messages.slice(-maxMessages);
-  const summaryParts = [];
-  summaryParts.push("### Session Summary (Auto-saved before overflow reset)\n");
-  for (const msg of recentMessages) {
-    if (msg.role === "user") {
-      const content = typeof msg.content === "string" ? msg.content : "[complex]";
-      const bodyMatch = content.match(/\] (.+)/s);
-      const body = bodyMatch ? bodyMatch[1] : content;
-      summaryParts.push(`- **User**: ${body.substring(0, 150)}${body.length > 150 ? "..." : ""}`);
-    } else if (msg.role === "assistant") {
-      const textBlocks = msg.content.filter((b) => b.type === "text");
-      const toolBlocks = msg.content.filter((b) => b.type === "toolCall");
-      if (textBlocks.length > 0) {
-        const text = textBlocks[0].text || "";
-        summaryParts.push(
-          `- **Agent**: ${text.substring(0, 150)}${text.length > 150 ? "..." : ""}`
-        );
-      }
-      if (toolBlocks.length > 0) {
-        const toolNames = toolBlocks.map((b) => b.name).join(", ");
-        summaryParts.push(`  - *Tools used: ${toolNames}*`);
-      }
-    } else if (msg.role === "toolResult") {
-      const status = msg.isError ? "ERROR" : "OK";
-      summaryParts.push(`  - *Tool result: ${msg.toolName} \u2192 ${status}*`);
-    }
-  }
-  return summaryParts.join("\n");
-}
-var AgentRuntime = class {
-  config;
-  soul;
-  compactionManager;
-  contextBuilder = null;
-  toolRegistry = null;
-  embedder = null;
-  hookRunner;
-  userHookEvaluator;
-  constructor(config, soul, toolRegistry) {
-    this.config = config;
-    this.soul = soul ?? "";
-    this.toolRegistry = toolRegistry ?? null;
-    const provider = config.agent.provider || "anthropic";
-    try {
-      const model = getProviderModel(provider, config.agent.model);
-      const ctx = model.contextWindow;
-      this.compactionManager = new CompactionManager({
-        enabled: true,
-        maxMessages: COMPACTION_MAX_MESSAGES,
-        maxTokens: Math.floor(ctx * COMPACTION_MAX_TOKENS_RATIO),
-        keepRecentMessages: COMPACTION_KEEP_RECENT,
-        memoryFlushEnabled: true,
-        softThresholdTokens: Math.floor(ctx * COMPACTION_SOFT_THRESHOLD_RATIO)
-      });
-    } catch {
-      this.compactionManager = new CompactionManager(DEFAULT_COMPACTION_CONFIG);
-    }
-  }
-  setHookRunner(runner) {
-    this.hookRunner = runner;
-  }
-  setUserHookEvaluator(evaluator) {
-    this.userHookEvaluator = evaluator;
-  }
-  initializeContextBuilder(embedder, vectorEnabled) {
-    this.embedder = embedder;
-    const db = getDatabase().getDb();
-    this.contextBuilder = new ContextBuilder(db, embedder, vectorEnabled);
-  }
-  getToolRegistry() {
-    return this.toolRegistry;
-  }
-  async processMessage(opts) {
-    const {
-      chatId,
-      userMessage,
-      userName,
-      timestamp,
-      isGroup,
-      pendingContext,
-      toolContext,
-      senderUsername,
-      senderRank,
-      hasMedia,
-      mediaType,
-      messageId,
-      replyContext
-    } = opts;
-    const effectiveIsGroup = isGroup ?? false;
-    const processStartTime = Date.now();
-    try {
-      let userHookContext = "";
-      if (this.userHookEvaluator) {
-        const hookResult = this.userHookEvaluator.evaluate(userMessage);
-        if (hookResult.blocked) {
-          log3.info("Message blocked by keyword filter");
-          return { content: hookResult.blockMessage ?? "", toolCalls: [] };
-        }
-        if (hookResult.additionalContext) {
-          userHookContext = sanitizeForContext(hookResult.additionalContext);
-        }
-      }
-      let effectiveMessage = userMessage;
-      let hookMessageContext = "";
-      if (this.hookRunner) {
-        const msgEvent = {
-          chatId,
-          senderId: toolContext?.senderId ? String(toolContext.senderId) : chatId,
-          senderName: userName ?? "",
-          isGroup: effectiveIsGroup,
-          isReply: !!replyContext,
-          replyToMessageId: replyContext ? messageId : void 0,
-          messageId: messageId ?? 0,
-          timestamp: timestamp ?? Date.now(),
-          text: userMessage,
-          block: false,
-          blockReason: "",
-          additionalContext: ""
-        };
-        await this.hookRunner.runModifyingHook("message:receive", msgEvent);
-        if (msgEvent.block) {
-          log3.info(`\u{1F6AB} Message blocked by hook: ${msgEvent.blockReason || "no reason"}`);
-          return { content: "", toolCalls: [] };
-        }
-        effectiveMessage = sanitizeForContext(msgEvent.text);
-        if (msgEvent.additionalContext) {
-          hookMessageContext = sanitizeForContext(msgEvent.additionalContext);
-        }
-      }
-      let session = getOrCreateSession(chatId);
-      const now = timestamp ?? Date.now();
-      const resetPolicy = this.config.agent.session_reset_policy;
-      if (shouldResetSession(session, resetPolicy)) {
-        log3.info(`\u{1F504} Auto-resetting session based on policy`);
-        if (this.hookRunner) {
-          await this.hookRunner.runObservingHook("session:end", {
-            sessionId: session.sessionId,
-            chatId,
-            messageCount: session.messageCount
-          });
-        }
-        if (transcriptExists(session.sessionId)) {
-          try {
-            log3.info(`\u{1F4BE} Saving memory before daily reset...`);
-            const oldContext = loadContextFromTranscript(session.sessionId);
-            await saveSessionMemory({
-              oldSessionId: session.sessionId,
-              newSessionId: "pending",
-              context: oldContext,
-              chatId,
-              apiKey: getEffectiveApiKey(this.config.agent.provider, this.config.agent.api_key),
-              provider: this.config.agent.provider,
-              utilityModel: this.config.agent.utility_model
-            });
-            log3.info(`\u2705 Memory saved before reset`);
-          } catch (error) {
-            log3.warn({ err: error }, `\u26A0\uFE0F Failed to save memory before reset`);
-          }
-        }
-        session = resetSessionWithPolicy(chatId, resetPolicy);
-      }
-      let context = loadContextFromTranscript(session.sessionId);
-      const isNewSession = context.messages.length === 0;
-      if (!isNewSession) {
-        log3.info(`\u{1F4D6} Loading existing session: ${session.sessionId}`);
-      } else {
-        log3.info(`\u{1F195} Starting new session: ${session.sessionId}`);
-      }
-      if (this.hookRunner) {
-        await this.hookRunner.runObservingHook("session:start", {
-          sessionId: session.sessionId,
-          chatId,
-          isResume: !isNewSession
-        });
-      }
-      const previousTimestamp = session.updatedAt;
-      let formattedMessage = formatMessageEnvelope({
-        channel: "Telegram",
-        senderId: toolContext?.senderId ? String(toolContext.senderId) : chatId,
-        senderName: userName,
-        senderUsername,
-        senderRank,
-        timestamp: now,
-        previousTimestamp,
-        body: effectiveMessage,
-        isGroup: effectiveIsGroup,
-        hasMedia,
-        mediaType,
-        messageId,
-        replyContext
-      });
-      if (pendingContext) {
-        formattedMessage = `${pendingContext}
-
-${formattedMessage}`;
-        log3.debug(`\u{1F4CB} Including ${pendingContext.split("\n").length - 1} pending messages`);
-      }
-      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}`;
-      log3.info(`\u{1F4E8} ${msgType}: "${preview}${formattedMessage.length > 50 ? "..." : ""}"`);
-      let relevantContext = "";
-      let queryEmbedding;
-      const isNonTrivial = !isTrivialMessage(effectiveMessage);
-      if (this.embedder && isNonTrivial) {
-        try {
-          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) {
-          log3.warn({ err: error }, "Embedding computation failed");
-        }
-      }
-      if (this.contextBuilder && isNonTrivial) {
-        try {
-          const dbContext = await this.contextBuilder.buildContext({
-            query: effectiveMessage,
-            chatId,
-            includeAgentMemory: true,
-            includeFeedHistory: true,
-            searchAllChats: !isGroup,
-            maxRecentMessages: CONTEXT_MAX_RECENT_MESSAGES,
-            maxRelevantChunks: CONTEXT_MAX_RELEVANT_CHUNKS,
-            queryEmbedding
-          });
-          const contextParts = [];
-          if (dbContext.relevantKnowledge.length > 0) {
-            const sanitizedKnowledge = dbContext.relevantKnowledge.map(
-              (chunk) => sanitizeForContext(chunk)
-            );
-            contextParts.push(
-              `[Relevant knowledge from memory]
-${sanitizedKnowledge.join("\n---\n")}`
-            );
-          }
-          if (dbContext.relevantFeed.length > 0) {
-            const sanitizedFeed = dbContext.relevantFeed.map((msg) => sanitizeForContext(msg));
-            contextParts.push(
-              `[Relevant messages from Telegram feed]
-${sanitizedFeed.join("\n")}`
-            );
-          }
-          if (contextParts.length > 0) {
-            relevantContext = contextParts.join("\n\n");
-            log3.debug(
-              `\u{1F50D} Found ${dbContext.relevantKnowledge.length} knowledge chunks, ${dbContext.relevantFeed.length} feed messages`
-            );
-          }
-        } catch (error) {
-          log3.warn({ err: error }, "Context building failed");
-        }
-      }
-      const memoryStats = this.getMemoryStats();
-      const statsContext = `[Memory Status: ${memoryStats.totalMessages} messages across ${memoryStats.totalChats} chats, ${memoryStats.knowledgeChunks} knowledge chunks]`;
-      const additionalContext = relevantContext ? `You are in a Telegram conversation with chat ID: ${chatId}. Maintain conversation continuity.
-
-${statsContext}
-
-${relevantContext}` : `You are in a Telegram conversation with chat ID: ${chatId}. Maintain conversation continuity.
-
-${statsContext}`;
-      let hookAdditionalContext = "";
-      if (this.hookRunner) {
-        const promptEvent = {
-          chatId,
-          sessionId: session.sessionId,
-          isGroup: effectiveIsGroup,
-          additionalContext: ""
-        };
-        await this.hookRunner.runModifyingHook("prompt:before", promptEvent);
-        hookAdditionalContext = sanitizeForContext(promptEvent.additionalContext);
-      }
-      const compactionConfig = this.compactionManager.getConfig();
-      const needsMemoryFlush = compactionConfig.enabled && compactionConfig.memoryFlushEnabled && context.messages.length > Math.floor((compactionConfig.maxMessages ?? 200) * 0.75);
-      const allHookContext = [userHookContext, hookAdditionalContext, hookMessageContext].filter(Boolean).join("\n\n");
-      const finalContext = additionalContext + (allHookContext ? `
-
-${allHookContext}` : "");
-      const systemPrompt = buildSystemPrompt({
-        soul: this.soul,
-        userName,
-        senderUsername,
-        senderId: toolContext?.senderId,
-        ownerName: this.config.telegram.owner_name,
-        ownerUsername: this.config.telegram.owner_username,
-        context: finalContext,
-        includeMemory: !effectiveIsGroup,
-        includeStrategy: !effectiveIsGroup,
-        memoryFlushWarning: needsMemoryFlush
-      });
-      if (this.hookRunner) {
-        const promptAfterEvent = {
-          chatId,
-          sessionId: session.sessionId,
-          isGroup: effectiveIsGroup,
-          promptLength: systemPrompt.length,
-          sectionCount: (systemPrompt.match(/^#{1,3} /gm) || []).length,
-          ragContextLength: relevantContext.length,
-          hookContextLength: allHookContext.length
-        };
-        await this.hookRunner.runObservingHook("prompt:after", promptAfterEvent);
-      }
-      const userMsg = {
-        role: "user",
-        content: formattedMessage,
-        timestamp: now
-      };
-      context.messages.push(userMsg);
-      const preemptiveCompaction = 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
-      );
-      if (preemptiveCompaction) {
-        log3.info(`\u{1F5DC}\uFE0F  Preemptive compaction triggered, reloading session...`);
-        session = getSession(chatId);
-        context = loadContextFromTranscript(session.sessionId);
-        context.messages.push(userMsg);
-      }
-      appendToTranscript(session.sessionId, userMsg);
-      const provider = this.config.agent.provider || "anthropic";
-      const providerMeta = getProviderMetadata(provider);
-      const isAdmin = toolContext?.config?.telegram.admin_ids.includes(toolContext.senderId) ?? false;
-      let tools;
-      {
-        const toolIndex = this.toolRegistry?.getToolIndex();
-        const useRAG = toolIndex?.isIndexed && this.config.tool_rag?.enabled !== false && !isTrivialMessage(effectiveMessage) && !(providerMeta.toolLimit === null && this.config.tool_rag?.skip_unlimited_providers !== false);
-        if (useRAG && this.toolRegistry && queryEmbedding) {
-          tools = await this.toolRegistry.getForContextWithRAG(
-            effectiveMessage,
-            queryEmbedding,
-            effectiveIsGroup,
-            providerMeta.toolLimit,
-            chatId,
-            isAdmin
-          );
-          log3.info(`\u{1F50D} Tool RAG: ${tools.length}/${this.toolRegistry.count} tools selected`);
-        } else {
-          tools = this.toolRegistry?.getForContext(
-            effectiveIsGroup,
-            providerMeta.toolLimit,
-            chatId,
-            isAdmin
-          );
-        }
-      }
-      const maxIterations = this.config.agent.max_agentic_iterations || 5;
-      let iteration = 0;
-      let overflowResets = 0;
-      let rateLimitRetries = 0;
-      let serverErrorRetries = 0;
-      let finalResponse = null;
-      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++;
-        log3.debug(`\u{1F504} Agentic iteration ${iteration}/${maxIterations}`);
-        const iterationStartIndex = context.messages.length;
-        const maskedMessages = maskOldToolResults(context.messages, {
-          toolRegistry: this.toolRegistry ?? void 0,
-          currentIterationStartIndex: iterationStartIndex
-        });
-        const maskedContext = { ...context, messages: maskedMessages };
-        const response2 = await chatWithContext(this.config.agent, {
-          systemPrompt,
-          context: maskedContext,
-          sessionId: session.sessionId,
-          persistTranscript: true,
-          tools
-        });
-        const assistantMsg = response2.message;
-        if (assistantMsg.stopReason === "error") {
-          const errorMsg = assistantMsg.errorMessage || "";
-          if (this.hookRunner) {
-            const errorCode = errorMsg.includes("429") || errorMsg.toLowerCase().includes("rate") ? "RATE_LIMIT" : isContextOverflowError(errorMsg) ? "CONTEXT_OVERFLOW" : errorMsg.includes("500") || errorMsg.includes("502") || errorMsg.includes("503") ? "PROVIDER_ERROR" : "UNKNOWN";
-            const responseErrorEvent = {
-              chatId,
-              sessionId: session.sessionId,
-              isGroup: effectiveIsGroup,
-              error: errorMsg,
-              errorCode,
-              provider,
-              model: this.config.agent.model,
-              retryCount: rateLimitRetries + serverErrorRetries,
-              durationMs: Date.now() - processStartTime
-            };
-            await this.hookRunner.runObservingHook("response:error", responseErrorEvent);
-          }
-          if (isContextOverflowError(errorMsg)) {
-            overflowResets++;
-            if (overflowResets > 1) {
-              throw new Error(
-                "Context overflow persists after session reset. Message may be too large for the model's context window."
-              );
-            }
-            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);
-            log3.info(`\u2705 Memory saved to daily log`);
-            const archived = archiveTranscript(session.sessionId);
-            if (!archived) {
-              log3.error(
-                `\u26A0\uFE0F  Failed to archive transcript ${session.sessionId}, proceeding with reset anyway`
-              );
-            }
-            log3.info(`\u{1F504} Resetting session due to context overflow...`);
-            session = resetSession(chatId);
-            context = { messages: [userMsg] };
-            appendToTranscript(session.sessionId, userMsg);
-            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);
-              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;
-            }
-            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.`
-            );
-          } else if (errorMsg.includes("500") || errorMsg.includes("502") || errorMsg.includes("503") || errorMsg.includes("529")) {
-            serverErrorRetries++;
-            if (serverErrorRetries <= SERVER_ERROR_MAX_RETRIES) {
-              const delay = 2e3 * Math.pow(2, serverErrorRetries - 1);
-              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;
-            }
-            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 {
-            log3.error(`\u{1F6A8} API error: ${errorMsg}`);
-            throw new Error(`API error: ${errorMsg || "Unknown error"}`);
-          }
-        }
-        const iterUsage = response2.message.usage;
-        if (iterUsage) {
-          accumulatedUsage.input += iterUsage.input;
-          accumulatedUsage.output += iterUsage.output;
-          accumulatedUsage.cacheRead += iterUsage.cacheRead ?? 0;
-          accumulatedUsage.cacheWrite += iterUsage.cacheWrite ?? 0;
-          accumulatedUsage.totalCost += iterUsage.cost?.total ?? 0;
-        }
-        if (response2.text) {
-          accumulatedTexts.push(response2.text);
-        }
-        const toolCalls = response2.message.content.filter((block) => block.type === "toolCall");
-        if (toolCalls.length === 0) {
-          log3.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 done`);
-          finalResponse = response2;
-          break;
-        }
-        if (!this.toolRegistry || !toolContext) {
-          log3.error("\u26A0\uFE0F Cannot execute tools: registry or context missing");
-          break;
-        }
-        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;
-          let toolParams = block.arguments ?? {};
-          let blocked = false;
-          let blockReason = "";
-          if (this.hookRunner) {
-            const beforeEvent = {
-              toolName: block.name,
-              params: structuredClone(toolParams),
-              chatId,
-              isGroup: effectiveIsGroup,
-              block: false,
-              blockReason: ""
-            };
-            await this.hookRunner.runModifyingHook("tool:before", beforeEvent);
-            if (beforeEvent.block) {
-              blocked = true;
-              blockReason = beforeEvent.blockReason || "Blocked by plugin hook";
-            } else {
-              toolParams = structuredClone(beforeEvent.params);
-            }
-          }
-          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 }
-                };
-              }
-            }
-          };
-          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);
-          }
-          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(exec.result);
-          if (resultText.length > MAX_TOOL_RESULT_SIZE) {
-            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: exec.result.success,
-                data: {
-                  summary: data.summary || data.message,
-                  _truncated: true,
-                  _originalSize: resultText.length,
-                  _message: "Full data truncated. Use limit parameter for smaller results."
-                }
-              });
-            } else {
-              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-IVX2XQJE.js");
-            const cocoonResultMsg = {
-              role: "user",
-              content: [
-                {
-                  type: "text",
-                  text: wrapToolResult(resultText)
-                }
-              ],
-              timestamp: Date.now()
-            };
-            context.messages.push(cocoonResultMsg);
-            appendToTranscript(session.sessionId, cocoonResultMsg);
-          } else {
-            const toolResultMsg = {
-              role: "toolResult",
-              toolCallId: block.id,
-              toolName: block.name,
-              content: [
-                {
-                  type: "text",
-                  text: resultText
-                }
-              ],
-              isError: !exec.result.success,
-              timestamp: Date.now()
-            };
-            context.messages.push(toolResultMsg);
-            appendToTranscript(session.sessionId, toolResultMsg);
-          }
-        }
-        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) {
-          log3.info(`\u26A0\uFE0F Max iterations reached (${maxIterations})`);
-          finalResponse = response2;
-        }
-      }
-      if (!finalResponse) {
-        log3.error("\u26A0\uFE0F Agentic loop exited early without final response");
-        return {
-          content: "Internal error: Agent loop failed to produce a response.",
-          toolCalls: []
-        };
-      }
-      const response = finalResponse;
-      const lastMsg = context.messages[context.messages.length - 1];
-      if (lastMsg?.role !== "assistant") {
-        context.messages.push(response.message);
-      }
-      const sessionUpdate = {
-        updatedAt: Date.now(),
-        messageCount: session.messageCount + 1,
-        model: this.config.agent.model,
-        provider: this.config.agent.provider,
-        inputTokens: (session.inputTokens ?? 0) + accumulatedUsage.input + accumulatedUsage.cacheRead + accumulatedUsage.cacheWrite,
-        outputTokens: (session.outputTokens ?? 0) + accumulatedUsage.output
-      };
-      updateSession(chatId, sessionUpdate);
-      if (accumulatedUsage.input > 0 || accumulatedUsage.output > 0) {
-        const u = accumulatedUsage;
-        const totalInput = u.input + u.cacheRead + u.cacheWrite;
-        const inK = (totalInput / 1e3).toFixed(1);
-        const cacheParts = [];
-        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(", ")})` : "";
-        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) {
-        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) {
-        log3.info("\u2705 Response sent via Telegram tool - no additional text needed");
-        content = "";
-      } else if (!content && accumulatedUsage.input === 0 && accumulatedUsage.output === 0) {
-        log3.warn("\u26A0\uFE0F Empty response with zero tokens - possible API issue");
-        content = "I couldn't process your request. Please try again.";
-      }
-      let responseMetadata = {};
-      if (this.hookRunner) {
-        const responseBeforeEvent = {
-          chatId,
-          sessionId: session.sessionId,
-          isGroup: effectiveIsGroup,
-          originalText: content,
-          text: content,
-          block: false,
-          blockReason: "",
-          metadata: {}
-        };
-        await this.hookRunner.runModifyingHook("response:before", responseBeforeEvent);
-        if (responseBeforeEvent.block) {
-          log3.info(
-            `\u{1F6AB} Response blocked by hook: ${responseBeforeEvent.blockReason || "no reason"}`
-          );
-          content = "";
-        } else {
-          content = responseBeforeEvent.text;
-        }
-        responseMetadata = responseBeforeEvent.metadata;
-      }
-      if (this.hookRunner) {
-        const responseAfterEvent = {
-          chatId,
-          sessionId: session.sessionId,
-          isGroup: effectiveIsGroup,
-          text: content,
-          durationMs: Date.now() - processStartTime,
-          toolsUsed: totalToolCalls.map((tc) => tc.name),
-          tokenUsage: accumulatedUsage.input > 0 || accumulatedUsage.output > 0 ? { input: accumulatedUsage.input, output: accumulatedUsage.output } : void 0,
-          metadata: responseMetadata
-        };
-        await this.hookRunner.runObservingHook("response:after", responseAfterEvent);
-      }
-      return {
-        content,
-        toolCalls: totalToolCalls
-      };
-    } catch (error) {
-      log3.error({ err: error }, "Agent error");
-      throw error;
-    }
-  }
-  clearHistory(chatId) {
-    const db = getDatabase().getDb();
-    db.prepare(
-      `DELETE FROM tg_messages_vec WHERE id IN (
-        SELECT id FROM tg_messages WHERE chat_id = ?
-      )`
-    ).run(chatId);
-    db.prepare(`DELETE FROM tg_messages WHERE chat_id = ?`).run(chatId);
-    resetSession(chatId);
-    log3.info(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
-  }
-  getConfig() {
-    return this.config;
-  }
-  getActiveChatIds() {
-    const db = getDatabase().getDb();
-    const rows = db.prepare(
-      `
-      SELECT DISTINCT chat_id
-      FROM tg_messages
-      ORDER BY timestamp DESC
-    `
-    ).all();
-    return rows.map((r3) => r3.chat_id);
-  }
-  setSoul(soul) {
-    this.soul = soul;
-  }
-  configureCompaction(config) {
-    this.compactionManager.updateConfig(config);
-    log3.info({ config: this.compactionManager.getConfig() }, `\u{1F5DC}\uFE0F  Compaction config updated`);
-  }
-  getCompactionConfig() {
-    return this.compactionManager.getConfig();
-  }
-  _memoryStatsCache = null;
-  getMemoryStats() {
-    const now = Date.now();
-    if (this._memoryStatsCache && now < this._memoryStatsCache.expiry) {
-      return this._memoryStatsCache.data;
-    }
-    const db = getDatabase().getDb();
-    const msgCount = db.prepare(`SELECT COUNT(*) as count FROM tg_messages`).get();
-    const chatCount = db.prepare(`SELECT COUNT(DISTINCT chat_id) as count FROM tg_messages`).get();
-    const knowledgeCount = db.prepare(`SELECT COUNT(*) as count FROM knowledge`).get();
-    const data = {
-      totalMessages: msgCount.count,
-      totalChats: chatCount.count,
-      knowledgeChunks: knowledgeCount.count
-    };
-    this._memoryStatsCache = { data, expiry: now + 5 * 60 * 1e3 };
-    return data;
-  }
-};
-
 // src/bot/services/styled-keyboard.ts
 import { Api } from "telegram";
 import { InlineKeyboard } from "grammy";
@@ -2014,7 +722,7 @@ function unescapeHtml(text) {
 }
 
 // src/bot/inline-router.ts
-var log4 = createLogger("InlineRouter");
+var log2 = createLogger("InlineRouter");
 var INLINE_TIMEOUT_MS = 5e3;
 var CALLBACK_TIMEOUT_MS = 15e3;
 function compileGlob(pattern) {
@@ -2035,11 +743,11 @@ var InlineRouter = class {
   }
   registerPlugin(name, handlers) {
     this.plugins.set(name, handlers);
-    log4.info(`Registered plugin "${name}" for inline routing`);
+    log2.info(`Registered plugin "${name}" for inline routing`);
   }
   unregisterPlugin(name) {
     this.plugins.delete(name);
-    log4.info(`Unregistered plugin "${name}" from inline routing`);
+    log2.info(`Unregistered plugin "${name}" from inline routing`);
   }
   hasPlugin(name) {
     return this.plugins.has(name);
@@ -2111,7 +819,7 @@ var InlineRouter = class {
         is_personal: true
       });
     } catch (error) {
-      log4.error({ err: error }, `Plugin "${pluginName}" inline query handler failed`);
+      log2.error({ err: error }, `Plugin "${pluginName}" inline query handler failed`);
       try {
         await ctx.answerInlineQuery([], { cache_time: 0, is_personal: true });
       } catch {
@@ -2171,7 +879,7 @@ var InlineRouter = class {
             } catch (error) {
               const errMsg = error?.errorMessage;
               if (errMsg === "MESSAGE_NOT_MODIFIED") return;
-              log4.debug(`GramJS edit failed, falling back to Grammy: ${errMsg || error}`);
+              log2.debug(`GramJS edit failed, falling back to Grammy: ${errMsg || error}`);
             }
           }
           const replyMarkup = styledButtons ? toGrammyKeyboard(styledButtons) : void 0;
@@ -2191,7 +899,7 @@ var InlineRouter = class {
         await ctx.answerCallbackQuery();
       }
     } catch (error) {
-      log4.error({ err: error }, `Plugin "${pluginName}" callback handler failed`);
+      log2.error({ err: error }, `Plugin "${pluginName}" callback handler failed`);
       if (!answered) {
         try {
           await ctx.answerCallbackQuery({ text: "Error processing action" });
@@ -2214,7 +922,7 @@ var InlineRouter = class {
       };
       await plugin.onChosenResult(crCtx);
     } catch (error) {
-      log4.error({ err: error }, `Plugin "${pluginName}" chosen result handler failed`);
+      log2.error({ err: error }, `Plugin "${pluginName}" chosen result handler failed`);
     }
   }
   /**
@@ -2324,7 +1032,7 @@ import { promisify } from "util";
 
 // src/agent/tools/plugin-validator.ts
 import { z } from "zod";
-var log5 = createLogger("PluginValidator");
+var log3 = createLogger("PluginValidator");
 var ManifestSchema = z.object({
   name: z.string().min(1).max(64).regex(
     /^[a-z0-9][a-z0-9-]*$/,
@@ -2367,20 +1075,20 @@ function validateToolDefs(defs, pluginName) {
   const valid = [];
   for (const def of defs) {
     if (!def || typeof def !== "object") {
-      log5.warn(`[${pluginName}] tool is not an object, skipping`);
+      log3.warn(`[${pluginName}] tool is not an object, skipping`);
       continue;
     }
     const t = def;
     if (!t.name || typeof t.name !== "string") {
-      log5.warn(`[${pluginName}] tool missing 'name', skipping`);
+      log3.warn(`[${pluginName}] tool missing 'name', skipping`);
       continue;
     }
     if (!t.description || typeof t.description !== "string") {
-      log5.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
+      log3.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
       continue;
     }
     if (!t.execute || typeof t.execute !== "function") {
-      log5.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
+      log3.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
       continue;
     }
     valid.push(t);
@@ -2440,25 +1148,25 @@ function withTxLock(fn) {
 }
 
 // src/ton/transfer.ts
-var log6 = createLogger("TON");
+var log4 = createLogger("TON");
 async function sendTon(params) {
   return withTxLock(async () => {
     try {
       const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
       if (!Number.isFinite(amount) || amount <= 0) {
-        log6.error({ amount }, "Invalid transfer amount");
+        log4.error({ amount }, "Invalid transfer amount");
         return null;
       }
       let recipientAddress;
       try {
         recipientAddress = Address.parse(toAddress2);
       } catch (e) {
-        log6.error({ err: e }, `Invalid recipient address: ${toAddress2}`);
+        log4.error({ err: e }, `Invalid recipient address: ${toAddress2}`);
         return null;
       }
       const keyPair = await getKeyPair();
       if (!keyPair) {
-        log6.error("Wallet not initialized");
+        log4.error("Wallet not initialized");
         return null;
       }
       const wallet = WalletContractV5R1.create({
@@ -2482,7 +1190,7 @@ async function sendTon(params) {
         ]
       });
       const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-      log6.info(`Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
+      log4.info(`Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
       return pseudoHash;
     } catch (error) {
       const err = error;
@@ -2490,14 +1198,14 @@ async function sendTon(params) {
       if (status === 429 || status !== void 0 && status >= 500) {
         invalidateTonClientCache();
       }
-      log6.error({ err: error }, "Error sending TON");
+      log4.error({ err: error }, "Error sending TON");
       throw error;
     }
   });
 }
 
 // src/utils/retry.ts
-var log7 = createLogger("Utils");
+var log5 = createLogger("Utils");
 var DEFAULT_OPTIONS = {
   maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
   baseDelayMs: RETRY_DEFAULT_BASE_DELAY_MS,
@@ -2521,7 +1229,7 @@ async function withRetry(fn, options = {}) {
       return result;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
-      log7.warn(`Retry attempt ${attempt}/${opts.maxAttempts} failed: ${lastError.message}`);
+      log5.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);
@@ -5999,7 +4707,7 @@ var DEDUST_GAS = {
 var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 
 // src/agent/tools/dedust/asset-cache.ts
-var log8 = createLogger("Tools");
+var log6 = createLogger("Tools");
 var ASSET_LIST_URL = "https://assets.dedust.io/list.json";
 var CACHE_TTL_MS = 10 * 60 * 1e3;
 var cachedAssets = [];
@@ -6018,7 +4726,7 @@ async function getAssetList() {
     return cachedAssets;
   } catch (error) {
     if (cachedAssets.length > 0) {
-      log8.warn({ err: error }, "Asset list fetch failed, using stale cache");
+      log6.warn({ err: error }, "Asset list fetch failed, using stale cache");
       return cachedAssets;
     }
     throw error;
@@ -6071,7 +4779,7 @@ var stonApiClient = new StonApiClient();
 function isTon(asset) {
   return asset.toLowerCase() === "ton";
 }
-async function getStonfiQuote(fromAsset, toAsset, amount, slippage, log12) {
+async function getStonfiQuote(fromAsset, toAsset, amount, slippage, log10) {
   try {
     const isTonInput = isTon(fromAsset);
     const isTonOutput = isTon(toAsset);
@@ -6102,11 +4810,11 @@ async function getStonfiQuote(fromAsset, toAsset, amount, slippage, log12) {
       fee: feeAmount.toFixed(6)
     };
   } catch (err) {
-    log12.debug("dex.quoteSTONfi() failed:", err);
+    log10.debug("dex.quoteSTONfi() failed:", err);
     return null;
   }
 }
-async function getDedustQuote(fromAsset, toAsset, amount, slippage, log12) {
+async function getDedustQuote(fromAsset, toAsset, amount, slippage, log10) {
   try {
     const isTonInput = isTon(fromAsset);
     const isTonOutput = isTon(toAsset);
@@ -6140,7 +4848,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, log12) {
       poolType
     };
   } catch (err) {
-    log12.debug("dex.quoteDeDust() failed:", err);
+    log10.debug("dex.quoteDeDust() failed:", err);
     return null;
   }
 }
@@ -6312,14 +5020,14 @@ function validateDexParams(amount, slippage) {
     throw new PluginSDKError("Slippage must be between 0 and 1", "OPERATION_FAILED");
   }
 }
-function createDexSDK(log12) {
+function createDexSDK(log10) {
   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, log12),
-        getDedustQuote(params.fromAsset, params.toAsset, params.amount, slippage, log12)
+        getStonfiQuote(params.fromAsset, params.toAsset, params.amount, slippage, log10),
+        getDedustQuote(params.fromAsset, params.toAsset, params.amount, slippage, log10)
       ]);
       if (!stonfi && !dedust) {
         throw new PluginSDKError("No DEX has liquidity for this pair", "OPERATION_FAILED");
@@ -6333,7 +5041,14 @@ function createDexSDK(log12) {
       } else {
         const stonfiOut = parseFloat(stonfi.expectedOutput);
         const dedustOut = parseFloat(dedust.expectedOutput);
-        if (stonfiOut >= dedustOut) {
+        if (!Number.isFinite(stonfiOut) && !Number.isFinite(dedustOut)) {
+          throw new PluginSDKError("Failed to parse DEX quotes", "OPERATION_FAILED");
+        }
+        if (!Number.isFinite(stonfiOut)) {
+          recommended = "dedust";
+        } else if (!Number.isFinite(dedustOut)) {
+          recommended = "stonfi";
+        } else if (stonfiOut >= dedustOut) {
           recommended = "stonfi";
           if (dedustOut > 0) {
             savings = `${((stonfiOut - dedustOut) / dedustOut * 100).toFixed(2)}%`;
@@ -6353,7 +5068,7 @@ function createDexSDK(log12) {
         params.toAsset,
         params.amount,
         params.slippage ?? 0.01,
-        log12
+        log10
       );
     },
     async quoteDeDust(params) {
@@ -6362,25 +5077,25 @@ function createDexSDK(log12) {
         params.toAsset,
         params.amount,
         params.slippage ?? 0.01,
-        log12
+        log10
       );
     },
     async swap(params) {
       validateDexParams(params.amount, params.slippage);
       if (params.dex === "stonfi") {
-        return executeSTONfiSwap(params, log12);
+        return executeSTONfiSwap(params, log10);
       }
       if (params.dex === "dedust") {
-        return executeDedustSwap(params, log12);
+        return executeDedustSwap(params, log10);
       }
       const quoteResult = await this.quote(params);
-      return quoteResult.recommended === "stonfi" ? executeSTONfiSwap(params, log12) : executeDedustSwap(params, log12);
+      return quoteResult.recommended === "stonfi" ? executeSTONfiSwap(params, log10) : executeDedustSwap(params, log10);
     },
     async swapSTONfi(params) {
-      return executeSTONfiSwap(params, log12);
+      return executeSTONfiSwap(params, log10);
     },
     async swapDeDust(params) {
-      return executeDedustSwap(params, log12);
+      return executeDedustSwap(params, log10);
     }
   };
 }
@@ -6417,7 +5132,7 @@ function normalizeDomain(domain) {
   if (!d.endsWith(".ton")) d += ".ton";
   return d;
 }
-function createDnsSDK(log12) {
+function createDnsSDK(log10) {
   return {
     async check(domain) {
       const normalized = normalizeDomain(domain);
@@ -6440,7 +5155,7 @@ function createDnsSDK(log12) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.debug("dns.check() failed:", err);
+        log10.debug("dns.check() failed:", err);
         throw new PluginSDKError(
           `Failed to check domain: ${err instanceof Error ? err.message : String(err)}`,
           "OPERATION_FAILED"
@@ -6453,7 +5168,7 @@ function createDnsSDK(log12) {
         const response = await tonapiFetch(`/dns/${encodeURIComponent(normalized)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log12.debug(`dns.resolve() TonAPI error: ${response.status}`);
+          log10.debug(`dns.resolve() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -6465,7 +5180,7 @@ function createDnsSDK(log12) {
           expirationDate: data.expiring_at || void 0
         };
       } catch (err) {
-        log12.debug("dns.resolve() failed:", err);
+        log10.debug("dns.resolve() failed:", err);
         return null;
       }
     },
@@ -6475,7 +5190,7 @@ function createDnsSDK(log12) {
           `/dns/auctions?tld=ton&limit=${Math.min(limit ?? 20, 100)}`
         );
         if (!response.ok) {
-          log12.debug(`dns.getAuctions() TonAPI error: ${response.status}`);
+          log10.debug(`dns.getAuctions() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
@@ -6488,7 +5203,7 @@ function createDnsSDK(log12) {
           bids: a.bids || 0
         }));
       } catch (err) {
-        log12.debug("dns.getAuctions() failed:", err);
+        log10.debug("dns.getAuctions() failed:", err);
         return [];
       }
     },
@@ -6802,25 +5517,25 @@ function findJettonBalance(balances, jettonAddress) {
     }
   });
 }
-function cleanupOldTransactions(db, retentionDays, log12) {
+function cleanupOldTransactions(db, retentionDays, log10) {
   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) {
-      log12.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
+      log10.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
     }
   } catch (err) {
-    log12.error("Transaction cleanup failed:", err);
+    log10.error("Transaction cleanup failed:", err);
   }
 }
-function createTonSDK(log12, db) {
+function createTonSDK(log10, db) {
   return {
     getAddress() {
       try {
         return getWalletAddress();
       } catch (err) {
-        log12.error("ton.getAddress() failed:", err);
+        log10.error("ton.getAddress() failed:", err);
         return null;
       }
     },
@@ -6830,7 +5545,7 @@ function createTonSDK(log12, db) {
         if (!addr) return null;
         return await getWalletBalance(addr);
       } catch (err) {
-        log12.error("ton.getBalance() failed:", err);
+        log10.error("ton.getBalance() failed:", err);
         return null;
       }
     },
@@ -6838,7 +5553,7 @@ function createTonSDK(log12, db) {
       try {
         return await getTonPrice();
       } catch (err) {
-        log12.error("ton.getPrice() failed:", err);
+        log10.error("ton.getPrice() failed:", err);
         return null;
       }
     },
@@ -6889,7 +5604,7 @@ function createTonSDK(log12, db) {
         );
         return formatTransactions(transactions);
       } catch (err) {
-        log12.error("ton.getTransactions() failed:", err);
+        log10.error("ton.getTransactions() failed:", err);
         return [];
       }
     },
@@ -6912,7 +5627,7 @@ function createTonSDK(log12, db) {
         throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
       }
       const maxAgeMinutes = params.maxAgeMinutes ?? DEFAULT_MAX_AGE_MINUTES;
-      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log12);
+      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log10);
       try {
         const txs = await this.getTransactions(address4, 20);
         for (const tx of txs) {
@@ -6946,7 +5661,7 @@ function createTonSDK(log12, db) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("ton.verifyPayment() failed:", err);
+        log10.error("ton.verifyPayment() failed:", err);
         return {
           verified: false,
           error: `Verification failed: ${err instanceof Error ? err.message : String(err)}`
@@ -6960,7 +5675,7 @@ function createTonSDK(log12, db) {
         if (!addr) return [];
         const response = await tonapiFetch(`/accounts/${encodeURIComponent(addr)}/jettons`);
         if (!response.ok) {
-          log12.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
+          log10.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
@@ -6984,7 +5699,7 @@ function createTonSDK(log12, db) {
         }
         return balances;
       } catch (err) {
-        log12.error("ton.getJettonBalances() failed:", err);
+        log10.error("ton.getJettonBalances() failed:", err);
         return [];
       }
     },
@@ -6993,7 +5708,7 @@ function createTonSDK(log12, db) {
         const response = await tonapiFetch(`/jettons/${encodeURIComponent(jettonAddress)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log12.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
+          log10.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -7011,7 +5726,7 @@ function createTonSDK(log12, db) {
           image: data.preview || metadata.image || void 0
         };
       } catch (err) {
-        log12.error("ton.getJettonInfo() failed:", err);
+        log10.error("ton.getJettonInfo() failed:", err);
         return null;
       }
     },
@@ -7104,7 +5819,7 @@ function createTonSDK(log12, db) {
               if (status === 429 || status && status >= 500) {
                 invalidateTonClientCache();
                 if (attempt < MAX_SEND_ATTEMPTS) {
-                  log12.warn(
+                  log10.warn(
                     `sendJetton attempt ${attempt} failed (${status}): ${JSON.stringify(respData ?? err.message)}, retrying...`
                   );
                   await new Promise((r3) => setTimeout(r3, 1e3 * attempt));
@@ -7134,14 +5849,14 @@ function createTonSDK(log12, db) {
       try {
         const response = await tonapiFetch(`/accounts/${encodeURIComponent(ownerAddress)}/jettons`);
         if (!response.ok) {
-          log12.error(`ton.getJettonWalletAddress() TonAPI error: ${response.status}`);
+          log10.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) {
-        log12.error("ton.getJettonWalletAddress() failed:", err);
+        log10.error("ton.getJettonWalletAddress() failed:", err);
         return null;
       }
     },
@@ -7164,7 +5879,7 @@ function createTonSDK(log12, db) {
         if (!keyPair) {
           throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
         }
-        const boc = await withTxLock(async () => {
+        const txResult = await withTxLock(async () => {
           const wallet = WalletContractV5R14.create({
             workchain: 0,
             publicKey: keyPair.publicKey
@@ -7172,8 +5887,10 @@ function createTonSDK(log12, db) {
           const client = await getCachedTonClient();
           const contract = client.open(wallet);
           const seqno = await contract.getSeqno();
+          const validUntil = Math.floor(Date.now() / 1e3) + 120;
           const transferCell = wallet.createTransfer({
             seqno,
+            timeout: validUntil,
             secretKey: keyPair.secretKey,
             sendMode: SendMode4.PAY_GAS_SEPARATELY,
             messages: [
@@ -7196,10 +5913,18 @@ function createTonSDK(log12, db) {
               body: transferCell
             })
           ).endCell();
-          return extMsg.toBoc().toString("base64");
+          const boc = extMsg.toBoc().toString("base64");
+          return { boc, seqno, validUntil, walletAddress: wallet.address.toRawString() };
         });
         return {
-          boc,
+          // v2 fields
+          signedBoc: txResult.boc,
+          walletPublicKey: walletData.publicKey,
+          walletAddress: txResult.walletAddress,
+          seqno: txResult.seqno,
+          validUntil: txResult.validUntil,
+          // backward compat (deprecated)
+          boc: txResult.boc,
           publicKey: walletData.publicKey,
           walletVersion: "v5r1"
         };
@@ -7266,7 +5991,7 @@ function createTonSDK(log12, db) {
         if (!keyPair) {
           throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
         }
-        const boc = await withTxLock(async () => {
+        const txResult = await withTxLock(async () => {
           const wallet = WalletContractV5R14.create({
             workchain: 0,
             publicKey: keyPair.publicKey
@@ -7274,8 +5999,10 @@ function createTonSDK(log12, db) {
           const client = await getCachedTonClient();
           const walletContract = client.open(wallet);
           const seqno = await walletContract.getSeqno();
+          const validUntil = Math.floor(Date.now() / 1e3) + 120;
           const transferCell = wallet.createTransfer({
             seqno,
+            timeout: validUntil,
             secretKey: keyPair.secretKey,
             sendMode: SendMode4.PAY_GAS_SEPARATELY,
             messages: [
@@ -7298,10 +6025,18 @@ function createTonSDK(log12, db) {
               body: transferCell
             })
           ).endCell();
-          return extMsg.toBoc().toString("base64");
+          const boc = extMsg.toBoc().toString("base64");
+          return { boc, seqno, validUntil, walletAddress: wallet.address.toRawString() };
         });
         return {
-          boc,
+          // v2 fields
+          signedBoc: txResult.boc,
+          walletPublicKey: walletData.publicKey,
+          walletAddress: txResult.walletAddress,
+          seqno: txResult.seqno,
+          validUntil: txResult.validUntil,
+          // backward compat (deprecated)
+          boc: txResult.boc,
           publicKey: walletData.publicKey,
           walletVersion: "v5r1"
         };
@@ -7318,7 +6053,7 @@ function createTonSDK(log12, db) {
         const wallet = loadWallet();
         return wallet?.publicKey ?? null;
       } catch (err) {
-        log12.error("ton.getPublicKey() failed:", err);
+        log10.error("ton.getPublicKey() failed:", err);
         return null;
       }
     },
@@ -7334,14 +6069,14 @@ function createTonSDK(log12, db) {
           `/accounts/${encodeURIComponent(addr)}/nfts?limit=100&indirect_ownership=true`
         );
         if (!response.ok) {
-          log12.error(`ton.getNftItems() TonAPI error: ${response.status}`);
+          log10.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) {
-        log12.error("ton.getNftItems() failed:", err);
+        log10.error("ton.getNftItems() failed:", err);
         return [];
       }
     },
@@ -7350,13 +6085,13 @@ function createTonSDK(log12, db) {
         const response = await tonapiFetch(`/nfts/${encodeURIComponent(nftAddress)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log12.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
+          log10.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
           return null;
         }
         const item = await response.json();
         return mapNftItem(item);
       } catch (err) {
-        log12.error("ton.getNftInfo() failed:", err);
+        log10.error("ton.getNftInfo() failed:", err);
         return null;
       }
     },
@@ -7389,7 +6124,7 @@ function createTonSDK(log12, db) {
           `/rates?tokens=${encodeURIComponent(jettonAddress)}&currencies=usd,ton`
         );
         if (!response.ok) {
-          log12.debug(`ton.getJettonPrice() TonAPI error: ${response.status}`);
+          log10.debug(`ton.getJettonPrice() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -7403,7 +6138,7 @@ function createTonSDK(log12, db) {
           change30d: rateData.diff_30d?.USD ?? null
         };
       } catch (err) {
-        log12.debug("ton.getJettonPrice() failed:", err);
+        log10.debug("ton.getJettonPrice() failed:", err);
         return null;
       }
     },
@@ -7417,7 +6152,7 @@ function createTonSDK(log12, db) {
           tonapiFetch(`/jettons/${encodeURIComponent(jettonAddress)}`)
         ]);
         if (!holdersResponse.ok) {
-          log12.debug(`ton.getJettonHolders() TonAPI error: ${holdersResponse.status}`);
+          log10.debug(`ton.getJettonHolders() TonAPI error: ${holdersResponse.status}`);
           return [];
         }
         const data = await holdersResponse.json();
@@ -7437,7 +6172,7 @@ function createTonSDK(log12, db) {
           };
         });
       } catch (err) {
-        log12.debug("ton.getJettonHolders() failed:", err);
+        log10.debug("ton.getJettonHolders() failed:", err);
         return [];
       }
     },
@@ -7482,15 +6217,13 @@ function createTonSDK(log12, db) {
           const geckoData = await geckoResponse.json();
           const attrs = geckoData.data?.attributes;
           if (attrs) {
-            if (attrs.volume_usd?.h24) {
-              volume24h = `$${parseFloat(attrs.volume_usd.h24).toLocaleString(void 0, { maximumFractionDigits: 0 })}`;
-            }
-            if (attrs.fdv_usd) {
-              fdv = `$${parseFloat(attrs.fdv_usd).toLocaleString(void 0, { maximumFractionDigits: 0 })}`;
-            }
-            if (attrs.market_cap_usd) {
-              marketCap = `$${parseFloat(attrs.market_cap_usd).toLocaleString(void 0, { maximumFractionDigits: 0 })}`;
-            }
+            const fmtUsd = (raw) => {
+              const val = parseFloat(raw);
+              return Number.isFinite(val) ? `$${val.toLocaleString(void 0, { maximumFractionDigits: 0 })}` : "N/A";
+            };
+            if (attrs.volume_usd?.h24) volume24h = fmtUsd(attrs.volume_usd.h24);
+            if (attrs.fdv_usd) fdv = fmtUsd(attrs.fdv_usd);
+            if (attrs.market_cap_usd) marketCap = fmtUsd(attrs.market_cap_usd);
           }
         }
         return {
@@ -7509,13 +6242,251 @@ function createTonSDK(log12, db) {
           holders: holdersCount
         };
       } catch (err) {
-        log12.debug("ton.getJettonHistory() failed:", err);
+        log10.debug("ton.getJettonHistory() failed:", err);
         return null;
       }
     },
+    // ─── Low-level Transfer ─────────────────────────────────────────
+    async getSeqno() {
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      try {
+        const keyPair = await getKeyPair();
+        if (!keyPair) {
+          throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+        }
+        const wallet = WalletContractV5R14.create({
+          workchain: 0,
+          publicKey: keyPair.publicKey
+        });
+        const client = await getCachedTonClient();
+        const contract = client.open(wallet);
+        return await contract.getSeqno();
+      } catch (err) {
+        const httpErr = isHttpError(err) ? err : void 0;
+        const status = httpErr?.status || httpErr?.response?.status;
+        if (status === 429 || status !== void 0 && status >= 500) {
+          invalidateTonClientCache();
+        }
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to get seqno: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async runGetMethod(address4, method, stack) {
+      try {
+        TonAddress.parse(address4);
+      } catch {
+        throw new PluginSDKError("Invalid TON address format", "INVALID_ADDRESS");
+      }
+      try {
+        const client = await getCachedTonClient();
+        const result = await client.runMethodWithError(
+          TonAddress.parse(address4),
+          method,
+          stack ?? []
+        );
+        const items = [];
+        while (result.stack.remaining > 0) {
+          items.push(result.stack.pop());
+        }
+        return { exitCode: result.exit_code, stack: items };
+      } catch (err) {
+        const httpErr = isHttpError(err) ? err : void 0;
+        const status = httpErr?.status || httpErr?.response?.status;
+        if (status === 429 || status !== void 0 && status >= 500) {
+          invalidateTonClientCache();
+        }
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to run get method: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async send(to, value, opts) {
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      try {
+        TonAddress.parse(to);
+      } catch {
+        throw new PluginSDKError("Invalid TON address format", "INVALID_ADDRESS");
+      }
+      if (!Number.isFinite(value) || value < 0) {
+        throw new PluginSDKError("Amount must be a non-negative number", "OPERATION_FAILED");
+      }
+      if (opts?.sendMode !== void 0 && (opts.sendMode < 0 || opts.sendMode > 3)) {
+        throw new PluginSDKError("Unsafe sendMode", "OPERATION_FAILED");
+      }
+      const keyPair = await getKeyPair();
+      if (!keyPair) {
+        throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+      }
+      try {
+        const seqno = await withTxLock(async () => {
+          const wallet = WalletContractV5R14.create({
+            workchain: 0,
+            publicKey: keyPair.publicKey
+          });
+          const client = await getCachedTonClient();
+          const contract = client.open(wallet);
+          const seq = await contract.getSeqno();
+          await contract.sendTransfer({
+            seqno: seq,
+            secretKey: keyPair.secretKey,
+            sendMode: opts?.sendMode ?? SendMode4.PAY_GAS_SEPARATELY,
+            messages: [
+              internal4({
+                to: TonAddress.parse(to),
+                value: tonToNano(value.toString()),
+                body: opts?.body,
+                bounce: opts?.bounce ?? true,
+                init: opts?.stateInit
+              })
+            ]
+          });
+          return seq;
+        });
+        return { hash: `${seqno}_${Date.now()}_send`, seqno };
+      } catch (err) {
+        const httpErr = isHttpError(err) ? err : void 0;
+        const status = httpErr?.status || httpErr?.response?.status;
+        if (status === 429 || status !== void 0 && status >= 500) {
+          invalidateTonClientCache();
+        }
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async sendMessages(messages, opts) {
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      if (messages.length < 1) {
+        throw new PluginSDKError("At least one message required", "OPERATION_FAILED");
+      }
+      if (messages.length > 255) {
+        throw new PluginSDKError("Maximum 255 messages per transfer", "OPERATION_FAILED");
+      }
+      if (opts?.sendMode !== void 0 && (opts.sendMode < 0 || opts.sendMode > 3)) {
+        throw new PluginSDKError("Unsafe sendMode", "OPERATION_FAILED");
+      }
+      for (const m of messages) {
+        try {
+          TonAddress.parse(m.to);
+        } catch {
+          throw new PluginSDKError(`Invalid TON address format: ${m.to}`, "INVALID_ADDRESS");
+        }
+        if (!Number.isFinite(m.value) || m.value < 0) {
+          throw new PluginSDKError("Amount must be a non-negative number", "OPERATION_FAILED");
+        }
+      }
+      const keyPair = await getKeyPair();
+      if (!keyPair) {
+        throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+      }
+      try {
+        const seqno = await withTxLock(async () => {
+          const wallet = WalletContractV5R14.create({
+            workchain: 0,
+            publicKey: keyPair.publicKey
+          });
+          const client = await getCachedTonClient();
+          const contract = client.open(wallet);
+          const seq = await contract.getSeqno();
+          await contract.sendTransfer({
+            seqno: seq,
+            secretKey: keyPair.secretKey,
+            sendMode: opts?.sendMode ?? SendMode4.PAY_GAS_SEPARATELY,
+            messages: messages.map(
+              (m) => internal4({
+                to: TonAddress.parse(m.to),
+                value: tonToNano(m.value.toString()),
+                body: m.body,
+                bounce: m.bounce ?? true,
+                init: m.stateInit
+              })
+            )
+          });
+          return seq;
+        });
+        return { hash: `${seqno}_${Date.now()}_sendMessages`, seqno };
+      } catch (err) {
+        const httpErr = isHttpError(err) ? err : void 0;
+        const status = httpErr?.status || httpErr?.response?.status;
+        if (status === 429 || status !== void 0 && status >= 500) {
+          invalidateTonClientCache();
+        }
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send messages: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async createSender() {
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      const keyPair = await getKeyPair();
+      if (!keyPair) {
+        throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+      }
+      const wallet = WalletContractV5R14.create({
+        workchain: 0,
+        publicKey: keyPair.publicKey
+      });
+      return {
+        address: wallet.address,
+        send: async (args) => {
+          if (args.sendMode !== void 0 && (args.sendMode < 0 || args.sendMode > 3)) {
+            throw new PluginSDKError("Unsafe sendMode", "OPERATION_FAILED");
+          }
+          try {
+            await withTxLock(async () => {
+              const client = await getCachedTonClient();
+              const contract = client.open(wallet);
+              const seqno = await contract.getSeqno();
+              await contract.sendTransfer({
+                seqno,
+                secretKey: keyPair.secretKey,
+                sendMode: args.sendMode ?? SendMode4.PAY_GAS_SEPARATELY,
+                messages: [
+                  internal4({
+                    to: args.to,
+                    value: args.value,
+                    body: args.body,
+                    bounce: args.bounce ?? true,
+                    init: args.init ?? void 0
+                  })
+                ]
+              });
+            });
+          } catch (err) {
+            const httpErr = isHttpError(err) ? err : void 0;
+            const status = httpErr?.status || httpErr?.response?.status;
+            if (status === 429 || status !== void 0 && status >= 500) {
+              invalidateTonClientCache();
+            }
+            throw err;
+          }
+        }
+      };
+    },
     // ─── Sub-namespaces ───────────────────────────────────────────
-    dex: Object.freeze(createDexSDK(log12)),
-    dns: Object.freeze(createDnsSDK(log12))
+    dex: Object.freeze(createDexSDK(log10)),
+    dns: Object.freeze(createDnsSDK(log10))
   };
 }
 function mapNftItem(item) {
@@ -7568,7 +6539,7 @@ async function getApi() {
 }
 
 // src/sdk/telegram-messages.ts
-function createTelegramMessagesSDK(bridge, log12) {
+function createTelegramMessagesSDK(bridge, log10) {
   function requireBridge2() {
     requireBridge(bridge);
   }
@@ -7675,7 +6646,7 @@ function createTelegramMessagesSDK(bridge, log12) {
         return (resultData.messages ?? []).map(toSimpleMessage);
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.searchMessages() failed:", err);
+        log10.error("telegram.searchMessages() failed:", err);
         return [];
       }
     },
@@ -7918,7 +6889,7 @@ function createTelegramMessagesSDK(bridge, log12) {
         return messages;
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getScheduledMessages() failed:", err);
+        log10.error("telegram.getScheduledMessages() failed:", err);
         return [];
       }
     },
@@ -7979,7 +6950,7 @@ function createTelegramMessagesSDK(bridge, log12) {
 }
 
 // src/sdk/telegram-social.ts
-function createTelegramSocialSDK(bridge, log12) {
+function createTelegramSocialSDK(bridge, log10) {
   function requireBridge2() {
     requireBridge(bridge);
   }
@@ -8054,7 +7025,7 @@ function createTelegramSocialSDK(bridge, log12) {
         return null;
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getChatInfo() failed:", err);
+        log10.error("telegram.getChatInfo() failed:", err);
         return null;
       }
     },
@@ -8168,7 +7139,7 @@ function createTelegramSocialSDK(bridge, log12) {
         });
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getParticipants() failed:", err);
+        log10.error("telegram.getParticipants() failed:", err);
         return [];
       }
     },
@@ -8530,7 +7501,7 @@ function createTelegramSocialSDK(bridge, log12) {
         }));
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getDialogs() failed:", err);
+        log10.error("telegram.getDialogs() failed:", err);
         return [];
       }
     },
@@ -8544,7 +7515,7 @@ function createTelegramSocialSDK(bridge, log12) {
         return messages.map(toSimpleMessage);
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getHistory() failed:", err);
+        log10.error("telegram.getHistory() failed:", err);
         return [];
       }
     },
@@ -8575,7 +7546,7 @@ function createTelegramSocialSDK(bridge, log12) {
         }));
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getStarsTransactions() failed:", err);
+        log10.error("telegram.getStarsTransactions() failed:", err);
         return [];
       }
     },
@@ -8680,7 +7651,7 @@ function createTelegramSocialSDK(bridge, log12) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getCollectibleInfo() failed:", err);
+        log10.error("telegram.getCollectibleInfo() failed:", err);
         return null;
       }
     },
@@ -8718,7 +7689,7 @@ function createTelegramSocialSDK(bridge, log12) {
       } catch (err) {
         if (err.errorMessage === "STARGIFT_SLUG_INVALID") return null;
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getUniqueGift() failed:", err);
+        log10.error("telegram.getUniqueGift() failed:", err);
         return null;
       }
     },
@@ -8744,7 +7715,7 @@ function createTelegramSocialSDK(bridge, log12) {
       } catch (err) {
         if (err.errorMessage === "STARGIFT_SLUG_INVALID") return null;
         if (err instanceof PluginSDKError) throw err;
-        log12.error("telegram.getUniqueGiftValue() failed:", err);
+        log10.error("telegram.getUniqueGiftValue() failed:", err);
         return null;
       }
     },
@@ -8779,7 +7750,7 @@ function createTelegramSocialSDK(bridge, log12) {
         const client = getClient2();
         const { Api: Api4, helpers } = await import("telegram");
         const { CustomFile } = await import("telegram/client/uploads.js");
-        const { readFileSync: readFileSync7, statSync: statSync2 } = await import("fs");
+        const { readFileSync: readFileSync6, statSync: statSync2 } = await import("fs");
         const { basename: basename2 } = await import("path");
         const { resolve: resolve2, normalize: normalize2 } = await import("path");
         const { homedir: homedir2 } = await import("os");
@@ -8804,7 +7775,7 @@ function createTelegramSocialSDK(bridge, log12) {
         }
         const fileName = basename2(filePath);
         const fileSize = statSync2(filePath).size;
-        const fileBuffer = readFileSync7(filePath);
+        const fileBuffer = readFileSync6(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({
@@ -8855,7 +7826,7 @@ function createTelegramSocialSDK(bridge, log12) {
 }
 
 // src/sdk/telegram.ts
-function createTelegramSDK(bridge, log12) {
+function createTelegramSDK(bridge, log10) {
   function requireBridge2() {
     requireBridge(bridge);
   }
@@ -8959,7 +7930,7 @@ function createTelegramSDK(bridge, log12) {
           timestamp: m.timestamp
         }));
       } catch (err) {
-        log12.error("telegram.getMessages() failed:", err);
+        log10.error("telegram.getMessages() failed:", err);
         return [];
       }
     },
@@ -8981,7 +7952,7 @@ function createTelegramSDK(bridge, log12) {
       return bridge.isAvailable();
     },
     getRawClient() {
-      log12.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
+      log10.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
       if (!bridge.isAvailable()) return null;
       try {
         return bridge.getClient().getClient();
@@ -8990,8 +7961,8 @@ function createTelegramSDK(bridge, log12) {
       }
     },
     // Spread extended methods from sub-modules
-    ...createTelegramMessagesSDK(bridge, log12),
-    ...createTelegramSocialSDK(bridge, log12)
+    ...createTelegramMessagesSDK(bridge, log10),
+    ...createTelegramSocialSDK(bridge, log10)
   };
 }
 
@@ -9032,23 +8003,23 @@ function deletePluginSecret(pluginName, key) {
 function listPluginSecretKeys(pluginName) {
   return Object.keys(readSecretsFile(pluginName));
 }
-function createSecretsSDK(pluginName, pluginConfig, log12) {
+function createSecretsSDK(pluginName, pluginConfig, log10) {
   const envPrefix = pluginName.replace(/-/g, "_").toUpperCase();
   function get(key) {
     const envKey = `${envPrefix}_${key.toUpperCase()}`;
     const envValue = process.env[envKey];
     if (envValue) {
-      log12.debug(`Secret "${key}" resolved from env var ${envKey}`);
+      log10.debug(`Secret "${key}" resolved from env var ${envKey}`);
       return envValue;
     }
     const stored = readSecretsFile(pluginName);
     if (key in stored && stored[key]) {
-      log12.debug(`Secret "${key}" resolved from secrets store`);
+      log10.debug(`Secret "${key}" resolved from secrets store`);
       return stored[key];
     }
     const configValue = pluginConfig[key];
     if (configValue !== void 0 && configValue !== null) {
-      log12.debug(`Secret "${key}" resolved from pluginConfig`);
+      log10.debug(`Secret "${key}" resolved from pluginConfig`);
       return String(configValue);
     }
     return void 0;
@@ -9150,7 +8121,7 @@ function createStorageSDK(db) {
 }
 
 // src/sdk/bot.ts
-function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLimiter, log12) {
+function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLimiter, log10) {
   if (!router || !manifest || !manifest.inline && !manifest.callbacks) {
     return null;
   }
@@ -9173,7 +8144,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
     },
     onInlineQuery(handler) {
       if (handlers.onInlineQuery) {
-        log12.warn("onInlineQuery called again \u2014 overwriting previous handler");
+        log10.warn("onInlineQuery called again \u2014 overwriting previous handler");
       }
       handlers.onInlineQuery = async (ctx) => {
         if (rateLimiter) {
@@ -9219,7 +8190,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
           return;
         } catch (error) {
           if (error?.errorMessage === "MESSAGE_NOT_MODIFIED") return;
-          log12.warn(`GramJS edit failed, falling back to Grammy: ${error?.errorMessage || error}`);
+          log10.warn(`GramJS edit failed, falling back to Grammy: ${error?.errorMessage || error}`);
         }
       }
       if (grammyBot) {
@@ -9232,7 +8203,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
           });
         } catch (error) {
           if (error?.description?.includes("message is not modified")) return;
-          log12.error(`Failed to edit inline message: ${error?.description || error}`);
+          log10.error(`Failed to edit inline message: ${error?.description || error}`);
         }
       }
     },
@@ -9291,13 +8262,13 @@ function createSafeDb(db) {
   });
 }
 function createPluginSDK(deps, opts) {
-  const log12 = createLogger2(opts.pluginName);
+  const log10 = createLogger2(opts.pluginName);
   const safeDb = opts.db ? createSafeDb(opts.db) : null;
-  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 ton = Object.freeze(createTonSDK(log10, safeDb));
+  const telegram = Object.freeze(createTelegramSDK(deps.bridge, log10));
+  const secrets = Object.freeze(createSecretsSDK(opts.pluginName, opts.pluginConfig, log10));
   const storage = safeDb ? Object.freeze(createStorageSDK(safeDb)) : null;
-  const frozenLog = Object.freeze(log12);
+  const frozenLog = Object.freeze(log10);
   const frozenConfig = Object.freeze(JSON.parse(JSON.stringify(opts.sanitizedConfig ?? {})));
   const frozenPluginConfig = Object.freeze(JSON.parse(JSON.stringify(opts.pluginConfig ?? {})));
   let cachedBot;
@@ -9328,20 +8299,20 @@ function createPluginSDK(deps, opts) {
     },
     on(hookName, handler, onOpts) {
       if (!opts.hookRegistry) {
-        log12.warn(`Hook registration unavailable \u2014 sdk.on() ignored`);
+        log10.warn(`Hook registration unavailable \u2014 sdk.on() ignored`);
         return;
       }
       if (opts.declaredHooks) {
         const declared = opts.declaredHooks.some((h2) => h2.name === hookName);
         if (!declared) {
-          log12.warn(`Hook "${hookName}" not declared in manifest \u2014 registration rejected`);
+          log10.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) {
-        log12.debug(`Hook "${hookName}" priority ${rawPriority} clamped to ${clampedPriority}`);
+        log10.debug(`Hook "${hookName}" priority ${rawPriority} clamped to ${clampedPriority}`);
       }
       const registered = opts.hookRegistry.register({
         pluginId: opts.pluginName,
@@ -9351,7 +8322,7 @@ function createPluginSDK(deps, opts) {
         globalPriority: opts.globalPriority ?? 0
       });
       if (!registered) {
-        log12.warn(
+        log10.warn(
           `Hook registration limit reached for plugin "${opts.pluginName}" \u2014 "${hookName}" rejected`
         );
       }
@@ -9470,7 +8441,7 @@ var HookRegistry = class {
 
 // src/agent/tools/plugin-loader.ts
 var execFileAsync = promisify(execFile);
-var log9 = createLogger("PluginLoader");
+var log7 = createLogger("PluginLoader");
 var PLUGIN_DATA_DIR = join3(TELETON_ROOT, "plugins", "data");
 function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps, hookRegistry, pluginPriorities) {
   let manifest = null;
@@ -9478,7 +8449,7 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps, hookReg
     try {
       manifest = validateManifest(raw.manifest);
     } catch (err) {
-      log9.warn(
+      log7.warn(
         `[${entryName}] invalid manifest, ignoring: ${err instanceof Error ? err.message : err}`
       );
     }
@@ -9672,7 +8643,7 @@ async function ensurePluginDeps(pluginDir, pluginEntry) {
   const nodeModules = join3(pluginDir, "node_modules");
   if (!existsSync5(pkgJson)) return;
   if (!existsSync5(lockfile)) {
-    log9.warn(
+    log7.warn(
       `[${pluginEntry}] package.json without package-lock.json \u2014 skipping (lockfile required)`
     );
     return;
@@ -9681,16 +8652,16 @@ async function ensurePluginDeps(pluginDir, pluginEntry) {
     const marker = join3(nodeModules, ".package-lock.json");
     if (existsSync5(marker) && statSync(marker).mtimeMs >= statSync(lockfile).mtimeMs) return;
   }
-  log9.info(`[${pluginEntry}] Installing dependencies...`);
+  log7.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" }
     });
-    log9.info(`[${pluginEntry}] Dependencies installed`);
+    log7.info(`[${pluginEntry}] Dependencies installed`);
   } catch (err) {
-    log9.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
+    log7.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
   }
 }
 async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
@@ -9743,7 +8714,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
   );
   for (const result of loadResults) {
     if (result.status === "rejected") {
-      log9.error(
+      log7.error(
         `Plugin failed to load: ${result.reason instanceof Error ? result.reason.message : result.reason}`
       );
       continue;
@@ -9751,7 +8722,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)) {
-        log9.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
+        log7.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
         continue;
       }
       const adapted = adaptPlugin(
@@ -9764,676 +8735,42 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
         pluginPriorities
       );
       if (loadedNames.has(adapted.name)) {
-        log9.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
+        log7.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
         continue;
       }
       loadedNames.add(adapted.name);
       modules.push(adapted);
     } catch (err) {
-      log9.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
+      log7.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
     }
   }
   return { modules, hookRegistry };
 }
 
-// src/config/configurable-keys.ts
-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";
-function numberInRange(min, max) {
-  return (v) => {
-    const n2 = Number(v);
-    if (isNaN(n2)) return "Must be a number";
-    if (n2 < min || n2 > max) return `Must be between ${min} and ${max}`;
-    return void 0;
-  };
+// src/agent/token-usage.ts
+var globalTokenUsage = { totalTokens: 0, totalCost: 0 };
+function getTokenUsage() {
+  return { ...globalTokenUsage };
 }
-function enumValidator(options) {
-  return (v) => options.includes(v) ? void 0 : `Must be one of: ${options.join(", ")}`;
-}
-function positiveInteger(v) {
-  const n2 = Number(v);
-  if (!Number.isInteger(n2) || n2 <= 0) return "Must be a positive integer";
-  return void 0;
-}
-function validateUrl(v) {
-  if (v === "") return void 0;
-  if (v.startsWith("http://") || v.startsWith("https://")) return void 0;
-  return "Must be empty or start with http:// or https://";
-}
-var CONFIGURABLE_KEYS = {
-  // ─── API Keys ──────────────────────────────────────────────────────
-  "agent.api_key": {
-    type: "string",
-    category: "API Keys",
-    label: "LLM API Key",
-    description: "LLM provider API key",
-    sensitive: true,
-    hotReload: "instant",
-    validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
-    mask: (v) => v.slice(0, 8) + "****",
-    parse: identity
-  },
-  tavily_api_key: {
-    type: "string",
-    category: "API Keys",
-    label: "Tavily API Key",
-    description: "Tavily API key for web search",
-    sensitive: true,
-    hotReload: "instant",
-    validate: (v) => v.startsWith("tvly-") ? void 0 : "Must start with 'tvly-'",
-    mask: (v) => v.slice(0, 9) + "****",
-    parse: identity
-  },
-  tonapi_key: {
-    type: "string",
-    category: "API Keys",
-    label: "TonAPI Key",
-    description: "TonAPI key for higher rate limits",
-    sensitive: true,
-    hotReload: "instant",
-    validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
-    mask: (v) => v.slice(0, 10) + "****",
-    parse: identity
-  },
-  toncenter_api_key: {
-    type: "string",
-    category: "API Keys",
-    label: "TonCenter API Key",
-    description: "TonCenter API key for dedicated RPC endpoint (free at toncenter.com)",
-    sensitive: true,
-    hotReload: "instant",
-    validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
-    mask: (v) => v.slice(0, 10) + "****",
-    parse: identity
-  },
-  "telegram.bot_token": {
-    type: "string",
-    category: "API Keys",
-    label: "Bot Token",
-    description: "Bot token from @BotFather",
-    sensitive: true,
-    hotReload: "instant",
-    validate: (v) => v.includes(":") ? void 0 : "Must contain ':' (e.g., 123456:ABC...)",
-    mask: (v) => v.split(":")[0] + ":****",
-    parse: identity
-  },
-  // ─── Agent ─────────────────────────────────────────────────────────
-  "agent.provider": {
-    type: "enum",
-    category: "Agent",
-    label: "Provider",
-    description: "LLM provider",
-    sensitive: false,
-    hotReload: "instant",
-    options: getSupportedProviders().map((p2) => p2.id),
-    validate: enumValidator(getSupportedProviders().map((p2) => p2.id)),
-    mask: identity,
-    parse: identity
-  },
-  "agent.model": {
-    type: "string",
-    category: "Agent",
-    label: "Model",
-    description: "Main LLM model ID",
-    sensitive: false,
-    hotReload: "instant",
-    validate: nonEmpty,
-    mask: identity,
-    parse: identity
-  },
-  "agent.utility_model": {
-    type: "string",
-    category: "Agent",
-    label: "Utility Model",
-    description: "Cheap model for summarization (auto-detected if empty)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: noValidation,
-    mask: identity,
-    parse: identity
-  },
-  "agent.temperature": {
-    type: "number",
-    category: "Agent",
-    label: "Temperature",
-    description: "Response creativity (0.0 = deterministic, 2.0 = max)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(0, 2),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "agent.max_tokens": {
-    type: "number",
-    category: "Agent",
-    label: "Max Tokens",
-    description: "Maximum response length in tokens",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(256, 128e3),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "agent.max_agentic_iterations": {
-    type: "number",
-    category: "Agent",
-    label: "Max Iterations",
-    description: "Max tool-call loop iterations per message",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(1, 20),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "agent.base_url": {
-    type: "string",
-    category: "Agent",
-    label: "API Base URL",
-    description: "Base URL for local LLM server (requires restart)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: validateUrl,
-    mask: identity,
-    parse: identity
-  },
-  "cocoon.port": {
-    type: "number",
-    category: "Agent",
-    label: "Cocoon Port",
-    description: "Cocoon proxy port (requires restart)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: numberInRange(1, 65535),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  // ─── Session ───────────────────────────────────────────────────
-  "agent.session_reset_policy.daily_reset_enabled": {
-    type: "boolean",
-    category: "Session",
-    label: "Daily Reset",
-    description: "Enable daily session reset at specified hour",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  "agent.session_reset_policy.daily_reset_hour": {
-    type: "number",
-    category: "Session",
-    label: "Reset Hour",
-    description: "Hour (0-23 UTC) for daily session reset",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(0, 23),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "agent.session_reset_policy.idle_expiry_enabled": {
-    type: "boolean",
-    category: "Session",
-    label: "Idle Expiry",
-    description: "Enable automatic session expiry after idle period",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  "agent.session_reset_policy.idle_expiry_minutes": {
-    type: "number",
-    category: "Session",
-    label: "Idle Minutes",
-    description: "Idle minutes before session expires (minimum 1)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(1, Number.MAX_SAFE_INTEGER),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  // ─── Telegram ──────────────────────────────────────────────────────
-  "telegram.bot_username": {
-    type: "string",
-    category: "Telegram",
-    label: "Bot Username",
-    description: "Bot username without @",
-    sensitive: false,
-    hotReload: "instant",
-    validate: (v) => v.length >= 3 ? void 0 : "Must be at least 3 characters",
-    mask: identity,
-    parse: identity
-  },
-  "telegram.dm_policy": {
-    type: "enum",
-    category: "Telegram",
-    label: "DM Policy",
-    description: "Who can message the bot in private",
-    sensitive: false,
-    hotReload: "instant",
-    options: ["admin-only", "allowlist", "open", "disabled"],
-    optionLabels: {
-      "admin-only": "Admin Only",
-      allowlist: "Allow Users",
-      open: "Open",
-      disabled: "Disabled"
-    },
-    validate: enumValidator(["open", "allowlist", "admin-only", "disabled"]),
-    mask: identity,
-    parse: identity
-  },
-  "telegram.group_policy": {
-    type: "enum",
-    category: "Telegram",
-    label: "Group Policy",
-    description: "Which groups the bot can respond in",
-    sensitive: false,
-    hotReload: "instant",
-    options: ["open", "allowlist", "admin-only", "disabled"],
-    optionLabels: {
-      open: "Open",
-      allowlist: "Allow Groups",
-      "admin-only": "Admin Only",
-      disabled: "Disabled"
-    },
-    validate: enumValidator(["open", "allowlist", "admin-only", "disabled"]),
-    mask: identity,
-    parse: identity
-  },
-  "telegram.require_mention": {
-    type: "boolean",
-    category: "Telegram",
-    label: "Require Mention",
-    description: "Require @mention in groups to respond",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  "telegram.owner_name": {
-    type: "string",
-    category: "Telegram",
-    label: "Owner Name",
-    description: "Owner's first name (used in system prompt)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: noValidation,
-    mask: identity,
-    parse: identity
-  },
-  "telegram.owner_username": {
-    type: "string",
-    category: "Telegram",
-    label: "Owner Username",
-    description: "Owner's Telegram username (without @)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: noValidation,
-    mask: identity,
-    parse: identity
-  },
-  "telegram.debounce_ms": {
-    type: "number",
-    category: "Telegram",
-    label: "Debounce (ms)",
-    description: "Group message debounce delay in ms (0 = disabled)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(0, 1e4),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.agent_channel": {
-    type: "string",
-    category: "Telegram",
-    label: "Agent Channel",
-    description: "Channel username for auto-publishing",
-    sensitive: false,
-    hotReload: "instant",
-    validate: noValidation,
-    mask: identity,
-    parse: identity
-  },
-  "telegram.typing_simulation": {
-    type: "boolean",
-    category: "Telegram",
-    label: "Typing Simulation",
-    description: "Simulate typing indicator before sending replies",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  "telegram.owner_id": {
-    type: "number",
-    category: "Telegram",
-    label: "Admin ID",
-    description: "Primary admin Telegram user ID (auto-added to Admin IDs)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: positiveInteger,
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.max_message_length": {
-    type: "number",
-    category: "Telegram",
-    label: "Max Message Length",
-    description: "Maximum message length in characters",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(1, 32768),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.rate_limit_messages_per_second": {
-    type: "number",
-    category: "Telegram",
-    label: "Rate Limit \u2014 Messages/sec",
-    description: "Rate limit: messages per second (requires restart)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: numberInRange(0.1, 10),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.rate_limit_groups_per_minute": {
-    type: "number",
-    category: "Telegram",
-    label: "Rate Limit \u2014 Groups/min",
-    description: "Rate limit: groups per minute (requires restart)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: numberInRange(1, 60),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.admin_ids": {
-    type: "array",
-    itemType: "number",
-    category: "Telegram",
-    label: "Admin IDs",
-    description: "Admin user IDs with elevated access",
-    sensitive: false,
-    hotReload: "instant",
-    validate: positiveInteger,
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.allow_from": {
-    type: "array",
-    itemType: "number",
-    category: "Telegram",
-    label: "Allowed Users",
-    description: "User IDs allowed for DM access",
-    sensitive: false,
-    hotReload: "instant",
-    validate: positiveInteger,
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "telegram.group_allow_from": {
-    type: "array",
-    itemType: "number",
-    category: "Telegram",
-    label: "Allowed Groups",
-    description: "Group IDs allowed for group access",
-    sensitive: false,
-    hotReload: "instant",
-    validate: positiveInteger,
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  // ─── Embedding ─────────────────────────────────────────────────────
-  "embedding.provider": {
-    type: "enum",
-    category: "Embedding",
-    label: "Embedding Provider",
-    description: "Embedding provider for RAG",
-    sensitive: false,
-    hotReload: "instant",
-    options: ["local", "anthropic", "none"],
-    validate: enumValidator(["local", "anthropic", "none"]),
-    mask: identity,
-    parse: identity
-  },
-  "embedding.model": {
-    type: "string",
-    category: "Embedding",
-    label: "Embedding Model",
-    description: "Embedding model ID (requires restart)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: noValidation,
-    mask: identity,
-    parse: identity
-  },
-  // ─── WebUI ─────────────────────────────────────────────────────────
-  "webui.port": {
-    type: "number",
-    category: "WebUI",
-    label: "WebUI Port",
-    description: "HTTP server port (requires restart)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: numberInRange(1024, 65535),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "webui.log_requests": {
-    type: "boolean",
-    category: "WebUI",
-    label: "Log HTTP Requests",
-    description: "Log all HTTP requests to console",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  // ─── Deals ─────────────────────────────────────────────────────────
-  "deals.enabled": {
-    type: "boolean",
-    category: "Deals",
-    label: "Deals Enabled",
-    description: "Enable the deals/escrow module",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  "deals.expiry_seconds": {
-    type: "number",
-    category: "Deals",
-    label: "Deal Expiry",
-    description: "Deal expiry timeout in seconds",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(10, 3600),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "deals.buy_max_floor_percent": {
-    type: "number",
-    category: "Deals",
-    label: "Buy Max Floor %",
-    description: "Maximum floor % for buy deals",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(1, 100),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "deals.sell_min_floor_percent": {
-    type: "number",
-    category: "Deals",
-    label: "Sell Min Floor %",
-    description: "Minimum floor % for sell deals",
-    sensitive: false,
-    hotReload: "instant",
-    validate: numberInRange(100, 500),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  // ─── TON Proxy ────────────────────────────────────────────────────
-  "ton_proxy.enabled": {
-    type: "boolean",
-    category: "TON Proxy",
-    label: "TON Proxy Enabled",
-    description: "Enable Tonutils-Proxy for .ton site access (auto-downloads binary on first run)",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  },
-  "ton_proxy.port": {
-    type: "number",
-    category: "TON Proxy",
-    label: "Proxy Port",
-    description: "HTTP proxy port for .ton sites (default: 8080)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: numberInRange(1, 65535),
-    mask: identity,
-    parse: (v) => Number(v)
-  },
-  "ton_proxy.binary_path": {
-    type: "string",
-    category: "TON Proxy",
-    label: "Binary Path",
-    description: "Custom path to tonutils-proxy-cli (leave empty for auto-download)",
-    sensitive: false,
-    hotReload: "restart",
-    validate: noValidation,
-    mask: identity,
-    parse: identity
-  },
-  // ─── Capabilities ──────────────────────────────────────────────────
-  "capabilities.exec.mode": {
-    type: "enum",
-    category: "Coding Agent",
-    label: "Exec Mode",
-    description: "System execution: off (disabled) or yolo (full system access)",
-    sensitive: false,
-    hotReload: "restart",
-    options: ["off", "yolo"],
-    optionLabels: { off: "Disabled", yolo: "YOLO" },
-    validate: enumValidator(["off", "yolo"]),
-    mask: identity,
-    parse: identity
-  },
-  "capabilities.exec.scope": {
-    type: "enum",
-    category: "Coding Agent",
-    label: "Exec Scope",
-    description: "Who can trigger exec tools",
-    sensitive: false,
-    hotReload: "restart",
-    options: ["admin-only", "allowlist", "all"],
-    optionLabels: { "admin-only": "Admin Only", allowlist: "Allowlist", all: "Everyone" },
-    validate: enumValidator(["admin-only", "allowlist", "all"]),
-    mask: identity,
-    parse: identity
-  },
-  // ─── Developer ─────────────────────────────────────────────────────
-  "dev.hot_reload": {
-    type: "boolean",
-    category: "Developer",
-    label: "Hot Reload",
-    description: "Watch ~/.teleton/plugins/ for live changes",
-    sensitive: false,
-    hotReload: "instant",
-    validate: enumValidator(["true", "false"]),
-    mask: identity,
-    parse: (v) => v === "true"
-  }
-};
-var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertSafePath(parts) {
-  if (parts.some((p2) => FORBIDDEN_SEGMENTS.has(p2))) {
-    throw new Error("Invalid config path: forbidden segment");
-  }
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  assertSafePath(parts);
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-function setNestedValue(obj, path, value) {
-  const parts = path.split(".");
-  assertSafePath(parts);
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (current[parts[i]] == null || typeof current[parts[i]] !== "object") {
-      current[parts[i]] = {};
-    }
-    current = current[parts[i]];
-  }
-  current[parts[parts.length - 1]] = value;
-}
-function deleteNestedValue(obj, path) {
-  const parts = path.split(".");
-  assertSafePath(parts);
-  let current = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    if (current == null || typeof current !== "object") return;
-    current = current[parts[i]];
-  }
-  if (current != null && typeof current === "object") {
-    delete current[parts[parts.length - 1]];
-  }
-}
-function readRawConfig(configPath) {
-  const fullPath = expandPath(configPath);
-  if (!existsSync6(fullPath)) {
-    throw new Error(`Config file not found: ${fullPath}
-Run 'teleton setup' to create one.`);
-  }
-  const raw = parse(readFileSync5(fullPath, "utf-8"));
-  if (!raw || typeof raw !== "object") {
-    throw new Error(`Invalid config file: ${fullPath}`);
-  }
-  return raw;
-}
-function writeRawConfig(raw, configPath) {
-  const clone = { ...raw };
-  delete clone.market;
-  const result = ConfigSchema.safeParse(clone);
-  if (!result.success) {
-    throw new Error(`Refusing to save invalid config: ${result.error.message}`);
-  }
-  raw.meta = raw.meta ?? {};
-  raw.meta.last_modified_at = (/* @__PURE__ */ new Date()).toISOString();
-  const fullPath = expandPath(configPath);
-  writeFileSync2(fullPath, stringify(raw), { encoding: "utf-8", mode: 384 });
+function accumulateTokenUsage(usage) {
+  globalTokenUsage.totalTokens += usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+  globalTokenUsage.totalCost += usage.totalCost;
 }
 
 // src/ton-proxy/manager.ts
 import { spawn, execSync } from "child_process";
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   chmodSync,
   createWriteStream,
-  readFileSync as readFileSync6,
-  writeFileSync as writeFileSync3,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync2,
   unlinkSync
 } from "fs";
 import { mkdir } from "fs/promises";
 import { join as join4 } from "path";
 import { pipeline } from "stream/promises";
-var log10 = createLogger("TonProxy");
+var log8 = createLogger("TonProxy");
 var GITHUB_REPO = "xssnick/Tonutils-Proxy";
 var BINARY_DIR = join4(TELETON_ROOT, "bin");
 var PID_FILE = join4(TELETON_ROOT, "ton-proxy.pid");
@@ -10456,7 +8793,7 @@ var TonProxyManager = class {
   }
   /** Check if the binary exists on disk */
   isInstalled() {
-    return existsSync7(this.getBinaryPath());
+    return existsSync6(this.getBinaryPath());
   }
   /** Whether the proxy process is currently running */
   isRunning() {
@@ -10468,7 +8805,7 @@ var TonProxyManager = class {
    */
   async install() {
     const binaryName = getBinaryName();
-    log10.info(`Downloading TON Proxy binary (${binaryName})...`);
+    log8.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, {
@@ -10480,7 +8817,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}`;
-    log10.info(`Downloading ${downloadUrl}`);
+    log8.info(`Downloading ${downloadUrl}`);
     const res = await fetch(downloadUrl);
     if (!res.ok || !res.body) {
       throw new Error(`Download failed: ${res.status} ${res.statusText}`);
@@ -10489,17 +8826,17 @@ var TonProxyManager = class {
     const fileStream = createWriteStream(dest);
     await pipeline(res.body, fileStream);
     chmodSync(dest, 493);
-    log10.info(`TON Proxy installed: ${dest} (${tag})`);
+    log8.info(`TON Proxy installed: ${dest} (${tag})`);
   }
   /** Kill any orphan proxy process from a previous session */
   killOrphan() {
-    if (existsSync7(PID_FILE)) {
+    if (existsSync6(PID_FILE)) {
       try {
-        const pid = parseInt(readFileSync6(PID_FILE, "utf-8").trim(), 10);
+        const pid = parseInt(readFileSync5(PID_FILE, "utf-8").trim(), 10);
         if (pid && !isNaN(pid)) {
           try {
             process.kill(pid, 0);
-            log10.warn(`Killing orphan TON Proxy (PID ${pid}) from previous session`);
+            log8.warn(`Killing orphan TON Proxy (PID ${pid}) from previous session`);
             process.kill(pid, "SIGTERM");
           } catch {
           }
@@ -10516,7 +8853,7 @@ var TonProxyManager = class {
       const pidMatch = out.match(/pid=(\d+)/);
       if (pidMatch) {
         const pid = parseInt(pidMatch[1], 10);
-        log10.warn(`Port ${this.config.port} occupied by PID ${pid}, killing it`);
+        log8.warn(`Port ${this.config.port} occupied by PID ${pid}, killing it`);
         try {
           process.kill(pid, "SIGTERM");
         } catch {
@@ -10529,22 +8866,22 @@ var TonProxyManager = class {
   /** Write PID to file for orphan detection */
   writePidFile(pid) {
     try {
-      writeFileSync3(PID_FILE, String(pid), { mode: 384 });
+      writeFileSync2(PID_FILE, String(pid), { mode: 384 });
     } catch {
-      log10.warn("Failed to write TON Proxy PID file");
+      log8.warn("Failed to write TON Proxy PID file");
     }
   }
   /** Remove PID file */
   removePidFile() {
     try {
-      if (existsSync7(PID_FILE)) unlinkSync(PID_FILE);
+      if (existsSync6(PID_FILE)) unlinkSync(PID_FILE);
     } catch {
     }
   }
   /** Start the proxy process */
   async start() {
     if (this.isRunning()) {
-      log10.warn("TON Proxy is already running");
+      log8.warn("TON Proxy is already running");
       return;
     }
     this.restartCount = 0;
@@ -10555,7 +8892,7 @@ var TonProxyManager = class {
     }
     const binaryPath = this.getBinaryPath();
     const port = String(this.config.port);
-    log10.info(`Starting TON Proxy on 127.0.0.1:${port}`);
+    log8.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"],
@@ -10563,24 +8900,24 @@ var TonProxyManager = class {
     });
     this.process.stdout?.on("data", (chunk) => {
       const line = chunk.toString().trim();
-      if (line) log10.debug(`[proxy] ${line}`);
+      if (line) log8.debug(`[proxy] ${line}`);
     });
     this.process.stderr?.on("data", (chunk) => {
       const line = chunk.toString().trim();
-      if (line) log10.warn(`[proxy:err] ${line}`);
+      if (line) log8.warn(`[proxy:err] ${line}`);
     });
     this.process.on("exit", (code, signal) => {
-      log10.info(`TON Proxy exited (code=${code}, signal=${signal})`);
+      log8.info(`TON Proxy exited (code=${code}, signal=${signal})`);
       this.process = null;
       this.removePidFile();
       if (code !== 0 && code !== null && this.restartCount < this.maxRestarts) {
         this.restartCount++;
-        log10.warn(`Auto-restarting TON Proxy (attempt ${this.restartCount}/${this.maxRestarts})`);
-        this.start().catch((err) => log10.error({ err }, "Failed to auto-restart TON Proxy"));
+        log8.warn(`Auto-restarting TON Proxy (attempt ${this.restartCount}/${this.maxRestarts})`);
+        this.start().catch((err) => log8.error({ err }, "Failed to auto-restart TON Proxy"));
       }
     });
     this.process.on("error", (err) => {
-      log10.error({ err }, "TON Proxy process error");
+      log8.error({ err }, "TON Proxy process error");
       this.process = null;
     });
     this.startHealthCheck();
@@ -10598,14 +8935,14 @@ var TonProxyManager = class {
       });
     });
     if (this.process?.pid) this.writePidFile(this.process.pid);
-    log10.info(`TON Proxy running on 127.0.0.1:${port} (PID ${this.process?.pid})`);
+    log8.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;
-    log10.info("Stopping TON Proxy...");
+    log8.info("Stopping TON Proxy...");
     return new Promise((resolve2) => {
       if (!this.process) {
         resolve2();
@@ -10613,7 +8950,7 @@ var TonProxyManager = class {
       }
       const forceKill = setTimeout(() => {
         if (this.process) {
-          log10.warn("TON Proxy did not exit gracefully, sending SIGKILL");
+          log8.warn("TON Proxy did not exit gracefully, sending SIGKILL");
           this.process.kill("SIGKILL");
         }
       }, KILL_GRACE_MS);
@@ -10632,10 +8969,10 @@ var TonProxyManager = class {
       await this.stop();
     }
     const binaryPath = this.getBinaryPath();
-    if (existsSync7(binaryPath)) {
+    if (existsSync6(binaryPath)) {
       const { unlink } = await import("fs/promises");
       await unlink(binaryPath);
-      log10.info(`TON Proxy binary removed: ${binaryPath}`);
+      log8.info(`TON Proxy binary removed: ${binaryPath}`);
     }
   }
   /** Get proxy status for WebUI / tools */
@@ -10669,7 +9006,7 @@ var TonProxyManager = class {
       }).catch(() => null);
       clearTimeout(timeout);
       if (!res) {
-        log10.warn("TON Proxy health check failed (no response)");
+        log8.warn("TON Proxy health check failed (no response)");
       }
     } catch {
     }
@@ -10726,7 +9063,7 @@ var tonProxyStatusExecutor = async () => {
 };
 
 // src/ton-proxy/module.ts
-var log11 = createLogger("TonProxyModule");
+var log9 = createLogger("TonProxyModule");
 var manager = null;
 function getTonProxyManager() {
   return manager;
@@ -10753,9 +9090,9 @@ var tonProxyModule = {
     setProxyManager(manager);
     try {
       await manager.start();
-      log11.info(`TON Proxy started on port ${proxyConfig.port}`);
+      log9.info(`TON Proxy started on port ${proxyConfig.port}`);
     } catch (err) {
-      log11.error({ err }, "Failed to start TON Proxy");
+      log9.error({ err }, "Failed to start TON Proxy");
       manager = null;
     }
   },
@@ -10812,13 +9149,15 @@ export {
   validateReadPath,
   validateWritePath,
   validateDirectory,
+  appendToDailyLog,
+  writeSummaryToDailyLog,
   sanitizeForPrompt,
   sanitizeForContext,
   clearPromptCache,
   loadSoul,
-  TELEGRAM_SEND_TOOLS,
+  buildSystemPrompt,
   getTokenUsage,
-  AgentRuntime,
+  accumulateTokenUsage,
   writePluginSecret,
   deletePluginSecret,
   listPluginSecretKeys,
@@ -10851,12 +9190,6 @@ export {
   adaptPlugin,
   ensurePluginDeps,
   loadEnhancedPlugins,
-  CONFIGURABLE_KEYS,
-  getNestedValue,
-  setNestedValue,
-  deleteNestedValue,
-  readRawConfig,
-  writeRawConfig,
   TonProxyManager,
   getTonProxyManager,
   setTonProxyManager,