teleton 0.8.0 → 0.8.2

package/dist/{chunk-RQBAMUCV.js → chunk-GGXJLMOH.js}

@@ -7,7 +7,7 @@ import {
   getWalletBalance,
   invalidateTonClientCache,
   loadWallet
-} from "./chunk-JHYZYFZJ.js";
+} from "./chunk-7YKSXOQQ.js";
 import {
   getOrCreateSession,
   getSession,
@@ -15,7 +15,15 @@ import {
   resetSessionWithPolicy,
   shouldResetSession,
   updateSession
-} from "./chunk-TVRZJIZX.js";
+} from "./chunk-55SKE6YH.js";
+import {
+  saveSessionMemory,
+  summarizeWithFallback
+} from "./chunk-W25Z7CM6.js";
+import {
+  getErrorMessage,
+  isHttpError
+} from "./chunk-3UFPFWYP.js";
 import {
   Mi,
   Mn,
@@ -26,41 +34,33 @@ import {
   ut,
   ye
 } from "./chunk-7TECSLJ4.js";
-import {
-  getErrorMessage
-} from "./chunk-XBE4JB7C.js";
 import {
   chatWithContext,
   getEffectiveApiKey,
   getProviderModel,
-  getUtilityModel,
   loadContextFromTranscript
-} from "./chunk-QVBSUYVX.js";
+} from "./chunk-J73TA3UM.js";
 import {
   getProviderMetadata,
   getSupportedProviders
-} from "./chunk-PHSAHTK4.js";
+} from "./chunk-YOSUPUAJ.js";
 import {
   appendToTranscript,
   archiveTranscript,
   transcriptExists
-} from "./chunk-P36I6OIV.js";
+} from "./chunk-LC4TV3KL.js";
 import {
   ContextBuilder,
   createDbWrapper,
   getDatabase,
   migrateFromMainDb,
   openModuleDb
-} from "./chunk-SD4NLLYG.js";
+} from "./chunk-VYKW7FMV.js";
 import {
   GECKOTERMINAL_API_URL,
   tonapiFetch
 } from "./chunk-VFA7QMCZ.js";
 import {
-  ADAPTIVE_CHUNK_RATIO_BASE,
-  ADAPTIVE_CHUNK_RATIO_MIN,
-  ADAPTIVE_CHUNK_RATIO_TRIGGER,
-  CHARS_PER_TOKEN_ESTIMATE,
   COMPACTION_KEEP_RECENT,
   COMPACTION_MAX_MESSAGES,
   COMPACTION_MAX_TOKENS_RATIO,
@@ -72,19 +72,18 @@ import {
   DEFAULT_MAX_SUMMARY_TOKENS,
   DEFAULT_MAX_TOKENS,
   DEFAULT_SOFT_THRESHOLD_TOKENS,
-  DEFAULT_SUMMARY_FALLBACK_TOKENS,
+  EMBEDDING_QUERY_MAX_CHARS,
   FALLBACK_SOFT_THRESHOLD_TOKENS,
   MASKING_KEEP_RECENT_COUNT,
   MAX_TOOL_RESULT_SIZE,
   MEMORY_FLUSH_RECENT_MESSAGES,
-  OVERSIZED_MESSAGE_RATIO,
   PAYMENT_TOLERANCE_RATIO,
   RATE_LIMIT_MAX_RETRIES,
+  RESULT_TRUNCATION_KEEP_CHARS,
+  RESULT_TRUNCATION_THRESHOLD,
   SERVER_ERROR_MAX_RETRIES,
-  SESSION_SLUG_MAX_TOKENS,
-  SESSION_SLUG_RECENT_MESSAGES,
-  TOKEN_ESTIMATE_SAFETY_MARGIN
-} from "./chunk-IJBWWQE4.js";
+  TOOL_CONCURRENCY_LIMIT
+} from "./chunk-C4NKJT2Z.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
@@ -105,7 +104,7 @@ import {
 } from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/config/loader.ts
 import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
@@ -191,6 +190,17 @@ Run 'teleton setup' to create one.`);
       );
     }
   }
+  if (process.env.TELETON_API_ENABLED) {
+    if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+    config.api.enabled = process.env.TELETON_API_ENABLED === "true";
+  }
+  if (process.env.TELETON_API_PORT) {
+    const port = parseInt(process.env.TELETON_API_PORT, 10);
+    if (!isNaN(port) && port >= 1024 && port <= 65535) {
+      if (!config.api) config.api = { enabled: false, port: 7778, key_hash: "", allowed_ips: [] };
+      config.api.port = port;
+    }
+  }
   if (process.env.TELETON_BASE_URL) {
     try {
       new URL(process.env.TELETON_BASE_URL);
@@ -364,7 +374,7 @@ function appendToDailyLog(content, date = /* @__PURE__ */ new Date()) {
       const header = `# Daily Log - ${formatDate(date)}
 
 `;
-      appendFileSync(logPath, header, "utf-8");
+      appendFileSync(logPath, header, { encoding: "utf-8", mode: 384 });
     }
     const entry = `## ${timestamp}
 
@@ -739,398 +749,6 @@ ${body}`;
 
 // src/memory/compaction.ts
 import { randomUUID } from "crypto";
-
-// src/memory/ai-summarization.ts
-import {
-  complete
-} from "@mariozechner/pi-ai";
-var log3 = createLogger("Memory");
-function estimateMessageTokens(content) {
-  return Math.ceil(content.length / CHARS_PER_TOKEN_ESTIMATE * TOKEN_ESTIMATE_SAFETY_MARGIN);
-}
-function splitMessagesByTokens(messages, maxChunkTokens) {
-  if (messages.length === 0) {
-    return [];
-  }
-  const chunks = [];
-  let currentChunk = [];
-  let currentTokens = 0;
-  for (const message of messages) {
-    const content = extractMessageContent(message);
-    const messageTokens = estimateMessageTokens(content);
-    if (currentChunk.length > 0 && currentTokens + messageTokens > maxChunkTokens) {
-      chunks.push(currentChunk);
-      currentChunk = [];
-      currentTokens = 0;
-    }
-    currentChunk.push(message);
-    currentTokens += messageTokens;
-    if (messageTokens > maxChunkTokens && currentChunk.length === 1) {
-      chunks.push(currentChunk);
-      currentChunk = [];
-      currentTokens = 0;
-    }
-  }
-  if (currentChunk.length > 0) {
-    chunks.push(currentChunk);
-  }
-  return chunks;
-}
-function extractMessageContent(message) {
-  if (message.role === "user") {
-    return typeof message.content === "string" ? message.content : "[complex content]";
-  } else if (message.role === "assistant") {
-    return message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-  }
-  return "";
-}
-function formatMessagesForSummary(messages) {
-  const formatted = [];
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      const content = typeof msg.content === "string" ? msg.content : "[complex]";
-      const bodyMatch = content.match(/\] (.+)/s);
-      const body = bodyMatch ? bodyMatch[1] : content;
-      formatted.push(`User: ${body}`);
-    } else if (msg.role === "assistant") {
-      const textBlocks = msg.content.filter((b) => b.type === "text");
-      if (textBlocks.length > 0) {
-        const text = textBlocks.map((b) => b.text).join("\n");
-        formatted.push(`Assistant: ${text}`);
-      }
-      const toolCalls = msg.content.filter((b) => b.type === "toolCall");
-      if (toolCalls.length > 0) {
-        const toolNames = toolCalls.map((b) => b.name).join(", ");
-        formatted.push(`[Used tools: ${toolNames}]`);
-      }
-    } else if (msg.role === "toolResult") {
-      formatted.push(`[Tool result: ${msg.toolName}]`);
-    }
-  }
-  return formatted.join("\n\n");
-}
-function isOversizedForSummary(message, contextWindow) {
-  const content = extractMessageContent(message);
-  const tokens = estimateMessageTokens(content);
-  return tokens > contextWindow * OVERSIZED_MESSAGE_RATIO;
-}
-function computeAdaptiveChunkRatio(messages, contextWindow) {
-  const BASE_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_BASE;
-  const MIN_CHUNK_RATIO = ADAPTIVE_CHUNK_RATIO_MIN;
-  if (messages.length === 0) {
-    return BASE_CHUNK_RATIO;
-  }
-  let totalTokens = 0;
-  for (const msg of messages) {
-    const content = extractMessageContent(msg);
-    totalTokens += estimateMessageTokens(content);
-  }
-  const avgTokens = totalTokens / messages.length;
-  const avgRatio = avgTokens / contextWindow;
-  if (avgRatio > ADAPTIVE_CHUNK_RATIO_TRIGGER) {
-    const reduction = Math.min(avgRatio * 2, BASE_CHUNK_RATIO - MIN_CHUNK_RATIO);
-    return Math.max(MIN_CHUNK_RATIO, BASE_CHUNK_RATIO - reduction);
-  }
-  return BASE_CHUNK_RATIO;
-}
-async function summarizeViaClaude(params) {
-  const provider = params.provider || "anthropic";
-  const model = getUtilityModel(provider, params.utilityModel);
-  const maxTokens = params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS;
-  const formatted = formatMessagesForSummary(params.messages);
-  if (!formatted.trim()) {
-    return "No conversation content to summarize.";
-  }
-  const defaultInstructions = `Summarize this conversation concisely. Focus on:
-- Key decisions made
-- Action items and TODOs
-- Open questions
-- Important context and constraints
-- Technical details that matter
-
-Be specific but concise. Preserve critical information.`;
-  const instructions = params.customInstructions ? `${defaultInstructions}
-
-Additional focus:
-${params.customInstructions}` : defaultInstructions;
-  try {
-    const context = {
-      messages: [
-        {
-          role: "user",
-          content: `${instructions}
-
-Conversation:
-${formatted}`,
-          timestamp: Date.now()
-        }
-      ]
-    };
-    const response = await complete(model, context, {
-      apiKey: params.apiKey,
-      maxTokens
-    });
-    const textContent = response.content.find((block) => block.type === "text");
-    const summary = textContent?.type === "text" ? textContent.text : "";
-    return summary.trim() || "Unable to generate summary.";
-  } catch (error) {
-    log3.error({ err: error }, "Summarization error");
-    throw new Error(`Summarization failed: ${getErrorMessage(error)}`);
-  }
-}
-async function summarizeInChunks(params) {
-  if (params.messages.length === 0) {
-    return {
-      summary: "No messages to summarize.",
-      tokensUsed: 0,
-      chunksProcessed: 0
-    };
-  }
-  const chunks = splitMessagesByTokens(params.messages, params.maxChunkTokens);
-  log3.info(`Splitting into ${chunks.length} chunks for summarization`);
-  if (chunks.length === 1) {
-    const summary = await summarizeViaClaude({
-      messages: chunks[0],
-      apiKey: params.apiKey,
-      maxSummaryTokens: params.maxSummaryTokens,
-      customInstructions: params.customInstructions,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-    return {
-      summary,
-      tokensUsed: estimateMessageTokens(summary),
-      chunksProcessed: 1
-    };
-  }
-  const partialSummaries = [];
-  for (let i = 0; i < chunks.length; i++) {
-    log3.info(`Summarizing chunk ${i + 1}/${chunks.length} (${chunks[i].length} messages)`);
-    const partial = await summarizeViaClaude({
-      messages: chunks[i],
-      apiKey: params.apiKey,
-      maxSummaryTokens: Math.floor(
-        (params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS) / 2
-      ),
-      customInstructions: params.customInstructions,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-    partialSummaries.push(partial);
-  }
-  log3.info(`Merging ${partialSummaries.length} partial summaries`);
-  const provider = params.provider || "anthropic";
-  const model = getUtilityModel(provider, params.utilityModel);
-  const mergeContext = {
-    messages: [
-      {
-        role: "user",
-        content: `Merge these partial conversation summaries into one cohesive summary.
-Preserve all key decisions, action items, open questions, and important context.
-Do not add new information - only synthesize what's provided.
-
-Partial summaries:
-
-${partialSummaries.map((s, i) => `Part ${i + 1}:
-${s}`).join("\n\n---\n\n")}`,
-        timestamp: Date.now()
-      }
-    ]
-  };
-  const mergeResponse = await complete(model, mergeContext, {
-    apiKey: params.apiKey,
-    maxTokens: params.maxSummaryTokens ?? DEFAULT_SUMMARY_FALLBACK_TOKENS
-  });
-  const textContent = mergeResponse.content.find((block) => block.type === "text");
-  const merged = textContent?.type === "text" ? textContent.text : "";
-  return {
-    summary: merged.trim() || "Unable to merge summaries.",
-    tokensUsed: estimateMessageTokens(merged),
-    chunksProcessed: chunks.length
-  };
-}
-async function summarizeWithFallback(params) {
-  if (params.messages.length === 0) {
-    return {
-      summary: "No messages to summarize.",
-      tokensUsed: 0,
-      chunksProcessed: 0
-    };
-  }
-  const chunkRatio = computeAdaptiveChunkRatio(params.messages, params.contextWindow);
-  const maxChunkTokens = Math.floor(params.contextWindow * chunkRatio);
-  log3.info(
-    `AI Summarization: ${params.messages.length} messages, chunk ratio: ${(chunkRatio * 100).toFixed(0)}%`
-  );
-  try {
-    return await summarizeInChunks({
-      messages: params.messages,
-      apiKey: params.apiKey,
-      maxChunkTokens,
-      maxSummaryTokens: params.maxSummaryTokens,
-      customInstructions: params.customInstructions,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-  } catch (fullError) {
-    log3.warn(
-      `Full summarization failed: ${fullError instanceof Error ? fullError.message : String(fullError)}`
-    );
-  }
-  const smallMessages = [];
-  const oversizedNotes = [];
-  for (const msg of params.messages) {
-    if (isOversizedForSummary(msg, params.contextWindow)) {
-      const content = extractMessageContent(msg);
-      const tokens = estimateMessageTokens(content);
-      oversizedNotes.push(
-        `[Large ${msg.role} message (~${Math.round(tokens / 1e3)}K tokens) omitted from summary]`
-      );
-    } else {
-      smallMessages.push(msg);
-    }
-  }
-  log3.info(
-    `Fallback: Processing ${smallMessages.length} messages, skipping ${oversizedNotes.length} oversized`
-  );
-  if (smallMessages.length > 0) {
-    try {
-      const result = await summarizeInChunks({
-        messages: smallMessages,
-        apiKey: params.apiKey,
-        maxChunkTokens,
-        maxSummaryTokens: params.maxSummaryTokens,
-        customInstructions: params.customInstructions,
-        provider: params.provider,
-        utilityModel: params.utilityModel
-      });
-      const notes = oversizedNotes.length > 0 ? `
-
-${oversizedNotes.join("\n")}` : "";
-      return {
-        summary: result.summary + notes,
-        tokensUsed: result.tokensUsed,
-        chunksProcessed: result.chunksProcessed
-      };
-    } catch (partialError) {
-      log3.warn(
-        `Partial summarization also failed: ${partialError instanceof Error ? partialError.message : String(partialError)}`
-      );
-    }
-  }
-  const note = `Context contained ${params.messages.length} messages (${oversizedNotes.length} were oversized). AI summarization unavailable due to size constraints. Recent conversation history was preserved.`;
-  return {
-    summary: note,
-    tokensUsed: estimateMessageTokens(note),
-    chunksProcessed: 0
-  };
-}
-
-// src/session/memory-hook.ts
-import { writeFile, mkdir } from "fs/promises";
-import { join as join3 } from "path";
-import { complete as complete2 } from "@mariozechner/pi-ai";
-var log4 = createLogger("Session");
-async function generateSlugViaClaude(params) {
-  const provider = params.provider || "anthropic";
-  const model = getUtilityModel(provider, params.utilityModel);
-  const formatted = formatMessagesForSummary(params.messages.slice(-SESSION_SLUG_RECENT_MESSAGES));
-  if (!formatted.trim()) {
-    return "empty-session";
-  }
-  try {
-    const context = {
-      messages: [
-        {
-          role: "user",
-          content: `Generate a short, descriptive slug (2-4 words, kebab-case) for this conversation.
-Examples: "gift-transfer-fix", "context-overflow-debug", "telegram-integration"
-
-Conversation:
-${formatted}
-
-Slug:`,
-          timestamp: Date.now()
-        }
-      ]
-    };
-    const response = await complete2(model, context, {
-      apiKey: params.apiKey,
-      maxTokens: SESSION_SLUG_MAX_TOKENS
-    });
-    const textContent = response.content.find((block) => block.type === "text");
-    const slug = textContent?.type === "text" ? textContent.text.trim() : "";
-    return slug.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50) || "session";
-  } catch (error) {
-    log4.warn({ err: error }, "Slug generation failed, using fallback");
-    const now = /* @__PURE__ */ new Date();
-    return `session-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
-  }
-}
-async function saveSessionMemory(params) {
-  try {
-    const { TELETON_ROOT: TELETON_ROOT2 } = await import("./paths-XA2RJH4S.js");
-    const memoryDir = join3(TELETON_ROOT2, "memory");
-    await mkdir(memoryDir, { recursive: true });
-    const now = /* @__PURE__ */ new Date();
-    const dateStr = now.toISOString().split("T")[0];
-    log4.info("Generating semantic slug for session memory...");
-    const slug = await generateSlugViaClaude({
-      messages: params.context.messages,
-      apiKey: params.apiKey,
-      provider: params.provider,
-      utilityModel: params.utilityModel
-    });
-    const filename = `${dateStr}-${slug}.md`;
-    const filepath = join3(memoryDir, filename);
-    const timeStr = now.toISOString().split("T")[1].split(".")[0];
-    log4.info("Generating session summary...");
-    let summary;
-    try {
-      summary = await summarizeViaClaude({
-        messages: params.context.messages,
-        apiKey: params.apiKey,
-        maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
-        customInstructions: "Summarize this session comprehensively. Include key topics, decisions made, problems solved, and important context.",
-        provider: params.provider,
-        utilityModel: params.utilityModel
-      });
-    } catch (error) {
-      log4.warn({ err: error }, "Session summary generation failed");
-      summary = `Session contained ${params.context.messages.length} messages. Summary generation failed.`;
-    }
-    const content = `# Session Memory: ${dateStr} ${timeStr} UTC
-
-## Metadata
-
-- **Old Session ID**: \`${params.oldSessionId}\`
-- **New Session ID**: \`${params.newSessionId}\`
-- **Chat ID**: \`${params.chatId}\`
-- **Timestamp**: ${now.toISOString()}
-- **Message Count**: ${params.context.messages.length}
-
-## Session Summary
-
-${summary}
-
-## Context
-
-This session was compacted and migrated to a new session ID. The summary above preserves key information for continuity.
-
----
-
-*Generated automatically by Teleton-AI session memory hook*
-`;
-    await writeFile(filepath, content, "utf-8");
-    const relPath = filepath.replace(TELETON_ROOT2, "~/.teleton");
-    log4.info(`Session memory saved: ${relPath}`);
-  } catch (error) {
-    log4.error({ err: error }, "Failed to save session memory");
-  }
-}
-
-// src/memory/compaction.ts
-import { encodingForModel } from "js-tiktoken";
 var DEFAULT_COMPACTION_CONFIG = {
   enabled: true,
   maxMessages: COMPACTION_MAX_MESSAGES,
@@ -1139,7 +757,7 @@ var DEFAULT_COMPACTION_CONFIG = {
   memoryFlushEnabled: true,
   softThresholdTokens: DEFAULT_SOFT_THRESHOLD_TOKENS
 };
-var log5 = createLogger("Memory");
+var log3 = createLogger("Memory");
 function estimateContextTokens(context) {
   let charCount = 0;
   if (context.systemPrompt) {
@@ -1171,7 +789,7 @@ function shouldFlushMemory(context, config, tokenCount) {
   const tokens = tokenCount ?? estimateContextTokens(context);
   const softThreshold = config.softThresholdTokens ?? FALLBACK_SOFT_THRESHOLD_TOKENS;
   if (tokens >= softThreshold) {
-    log5.info(`Memory flush needed: ~${tokens} tokens (soft threshold: ${softThreshold})`);
+    log3.info(`Memory flush needed: ~${tokens} tokens (soft threshold: ${softThreshold})`);
     return true;
   }
   return false;
@@ -1193,7 +811,7 @@ function flushMemoryToDailyLog(context) {
     }
   }
   writeSummaryToDailyLog(summary.join("\n"));
-  log5.info(`Memory flushed to daily log`);
+  log3.info(`Memory flushed to daily log`);
 }
 function shouldCompact(context, config, tokenCount) {
   if (!config.enabled) {
@@ -1201,13 +819,13 @@ function shouldCompact(context, config, tokenCount) {
   }
   const messageCount = context.messages.length;
   if (config.maxMessages && messageCount >= config.maxMessages) {
-    log5.info(`Compaction needed: ${messageCount} messages (max: ${config.maxMessages})`);
+    log3.info(`Compaction needed: ${messageCount} messages (max: ${config.maxMessages})`);
     return true;
   }
   if (config.maxTokens) {
     const tokens = tokenCount ?? estimateContextTokens(context);
     if (tokens >= config.maxTokens) {
-      log5.info(`Compaction needed: ~${tokens} tokens (max: ${config.maxTokens})`);
+      log3.info(`Compaction needed: ~${tokens} tokens (max: ${config.maxTokens})`);
       return true;
     }
   }
@@ -1253,12 +871,12 @@ async function compactContext(context, config, apiKey, provider, utilityModel) {
     iterations++;
   }
   if (hasOrphanedToolResults(context.messages.slice(cutIndex))) {
-    log5.warn(`Compaction: couldn't find clean cut point, keeping all messages`);
+    log3.warn(`Compaction: couldn't find clean cut point, keeping all messages`);
     return context;
   }
   const recentMessages = context.messages.slice(cutIndex);
   const oldMessages = context.messages.slice(0, cutIndex);
-  log5.info(
+  log3.info(
     `Compacting ${oldMessages.length} old messages, keeping ${recentMessages.length} recent (cut at clean boundary)`
   );
   try {
@@ -1288,7 +906,7 @@ Keep each section concise. Omit a section if empty. Preserve specific names, num
       provider,
       utilityModel
     });
-    log5.info(`AI Summary: ${result.tokensUsed} tokens, ${result.chunksProcessed} chunks processed`);
+    log3.info(`AI Summary: ${result.tokensUsed} tokens, ${result.chunksProcessed} chunks processed`);
     const summaryText = `[Auto-compacted ${oldMessages.length} messages]
 
 ${result.summary}`;
@@ -1302,7 +920,7 @@ ${result.summary}`;
       messages: [summaryMessage, ...recentMessages]
     };
   } catch (error) {
-    log5.error({ err: error }, "AI summarization failed, using fallback");
+    log3.error({ err: error }, "AI summarization failed, using fallback");
     const summaryText = `[Auto-compacted: ${oldMessages.length} earlier messages from this conversation]`;
     const summaryMessage = {
       role: "user",
@@ -1317,7 +935,7 @@ ${result.summary}`;
 }
 async function compactAndSaveTranscript(sessionId, context, config, apiKey, chatId, provider, utilityModel) {
   const newSessionId = randomUUID();
-  log5.info(`Creating compacted transcript: ${sessionId} \u2192 ${newSessionId}`);
+  log3.info(`Creating compacted transcript: ${sessionId} \u2192 ${newSessionId}`);
   if (chatId) {
     await saveSessionMemory({
       oldSessionId: sessionId,
@@ -1351,7 +969,7 @@ var CompactionManager = class {
     if (this.config.memoryFlushEnabled) {
       flushMemoryToDailyLog(context);
     }
-    log5.info(`Auto-compacting session ${sessionId}`);
+    log3.info(`Auto-compacting session ${sessionId}`);
     const newSessionId = await compactAndSaveTranscript(
       sessionId,
       context,
@@ -1361,7 +979,7 @@ var CompactionManager = class {
       provider,
       utilityModel
     );
-    log5.info(`Compaction complete: ${newSessionId}`);
+    log3.info(`Compaction complete: ${newSessionId}`);
     return newSessionId;
   }
   updateConfig(config) {
@@ -1375,62 +993,125 @@ var CompactionManager = class {
 // src/memory/observation-masking.ts
 var DEFAULT_MASKING_CONFIG = {
   keepRecentCount: MASKING_KEEP_RECENT_COUNT,
-  keepErrorResults: true
+  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 maskOldToolResults(messages, config = DEFAULT_MASKING_CONFIG, toolRegistry) {
+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));
-  if (toolResults.length <= config.keepRecentCount) {
+  const needsMasking = toolResults.length > config.keepRecentCount;
+  const needsTruncation = iterStart !== void 0 && config.truncationThreshold > 0;
+  if (!needsMasking && !needsTruncation) {
     return messages;
   }
-  const toMask = toolResults.slice(0, -config.keepRecentCount);
   const result = [...messages];
-  for (const { msg, index } of toMask) {
-    if (isCocoonToolResult(msg)) {
+  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] = {
-        ...msg,
-        content: [{ type: "text", text: "[Tool response masked]" }]
+        ...toolMsg,
+        content: [
+          {
+            type: "text",
+            text: `[Tool: ${toolMsg.toolName} - ${toolMsg.isError ? "ERROR" : "OK"}${summaryText}]`
+          }
+        ]
       };
-      continue;
-    }
-    const toolMsg = msg;
-    if (config.keepErrorResults && toolMsg.isError) {
-      continue;
     }
-    if (toolRegistry) {
-      const category = toolRegistry.getToolCategory(toolMsg.toolName);
-      if (category === "data-bearing") {
+  }
+  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;
       }
-    }
-    let summaryText = "";
-    try {
+      const toolMsg = msg;
+      if (isExempt(toolMsg, config, toolRegistry)) continue;
       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 {
+      if (!textBlock || textBlock.text.length <= config.truncationThreshold) continue;
+      result[index] = {
+        ...toolMsg,
+        content: [
+          {
+            type: "text",
+            text: truncateToolResult(textBlock.text, config.truncationKeepChars)
+          }
+        ]
+      };
     }
-    result[index] = {
-      ...toolMsg,
-      content: [
-        {
-          type: "text",
-          text: `[Tool: ${toolMsg.toolName} - ${toolMsg.isError ? "ERROR" : "OK"}${summaryText}]`
-        }
-      ]
-    };
   }
   return result;
 }
 
 // src/agent/runtime.ts
-var log6 = createLogger("Agent");
+var log4 = createLogger("Agent");
 var globalTokenUsage = { totalTokens: 0, totalCost: 0 };
 function getTokenUsage() {
   return { ...globalTokenUsage };
@@ -1484,6 +1165,8 @@ var AgentRuntime = class {
   contextBuilder = null;
   toolRegistry = null;
   embedder = null;
+  hookRunner;
+  userHookEvaluator;
   constructor(config, soul, toolRegistry) {
     this.config = config;
     this.soul = soul ?? "";
@@ -1504,6 +1187,12 @@ var AgentRuntime = class {
       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();
@@ -1528,15 +1217,62 @@ var AgentRuntime = class {
       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) {
+          log4.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) {
+          log4.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)) {
-        log6.info(`\u{1F504} Auto-resetting session based on policy`);
+        log4.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 {
-            log6.info(`\u{1F4BE} Saving memory before daily reset...`);
+            log4.info(`\u{1F4BE} Saving memory before daily reset...`);
             const oldContext = loadContextFromTranscript(session.sessionId);
             await saveSessionMemory({
               oldSessionId: session.sessionId,
@@ -1547,18 +1283,26 @@ var AgentRuntime = class {
               provider: this.config.agent.provider,
               utilityModel: this.config.agent.utility_model
             });
-            log6.info(`\u2705 Memory saved before reset`);
+            log4.info(`\u2705 Memory saved before reset`);
           } catch (error) {
-            log6.warn({ err: error }, `\u26A0\uFE0F Failed to save memory before reset`);
+            log4.warn({ err: error }, `\u26A0\uFE0F Failed to save memory before reset`);
           }
         }
         session = resetSessionWithPolicy(chatId, resetPolicy);
       }
       let context = loadContextFromTranscript(session.sessionId);
-      if (context.messages.length > 0) {
-        log6.info(`\u{1F4D6} Loading existing session: ${session.sessionId}`);
+      const isNewSession = context.messages.length === 0;
+      if (!isNewSession) {
+        log4.info(`\u{1F4D6} Loading existing session: ${session.sessionId}`);
       } else {
-        log6.info(`\u{1F195} Starting new session: ${session.sessionId}`);
+        log4.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({
@@ -1569,8 +1313,8 @@ var AgentRuntime = class {
         senderRank,
         timestamp: now,
         previousTimestamp,
-        body: userMessage,
-        isGroup: isGroup ?? false,
+        body: effectiveMessage,
+        isGroup: effectiveIsGroup,
         hasMedia,
         mediaType,
         messageId,
@@ -1580,27 +1324,38 @@ var AgentRuntime = class {
         formattedMessage = `${pendingContext}
 
 ${formattedMessage}`;
-        log6.debug(`\u{1F4CB} Including ${pendingContext.split("\n").length - 1} pending messages`);
+        log4.debug(`\u{1F4CB} Including ${pendingContext.split("\n").length - 1} pending messages`);
       }
-      log6.debug(`\u{1F4E8} Formatted message: ${formattedMessage.substring(0, 100)}...`);
+      log4.debug(`\u{1F4E8} Formatted message: ${formattedMessage.substring(0, 100)}...`);
       const preview = formattedMessage.slice(0, 50).replace(/\n/g, " ");
       const who = senderUsername ? `@${senderUsername}` : userName;
       const msgType = isGroup ? `Group ${chatId} ${who}` : `DM ${who}`;
-      log6.info(`\u{1F4E8} ${msgType}: "${preview}${formattedMessage.length > 50 ? "..." : ""}"`);
+      log4.info(`\u{1F4E8} ${msgType}: "${preview}${formattedMessage.length > 50 ? "..." : ""}"`);
       let relevantContext = "";
       let queryEmbedding;
-      const isNonTrivial = !isTrivialMessage(userMessage);
+      const isNonTrivial = !isTrivialMessage(effectiveMessage);
       if (this.embedder && isNonTrivial) {
         try {
-          queryEmbedding = await this.embedder.embedQuery(userMessage);
+          let searchQuery = effectiveMessage;
+          const recentUserMsgs = context.messages.filter((m) => m.role === "user" && typeof m.content === "string").slice(-3).map((m) => {
+            const text = m.content;
+            const bodyMatch = text.match(/\] (.+)/s);
+            return (bodyMatch ? bodyMatch[1] : text).trim();
+          }).filter((t) => t.length > 0);
+          if (recentUserMsgs.length > 0) {
+            searchQuery = recentUserMsgs.join(" ") + " " + effectiveMessage;
+          }
+          queryEmbedding = await this.embedder.embedQuery(
+            searchQuery.slice(0, EMBEDDING_QUERY_MAX_CHARS)
+          );
         } catch (error) {
-          log6.warn({ err: error }, "Embedding computation failed");
+          log4.warn({ err: error }, "Embedding computation failed");
         }
       }
       if (this.contextBuilder && isNonTrivial) {
         try {
           const dbContext = await this.contextBuilder.buildContext({
-            query: userMessage,
+            query: effectiveMessage,
             chatId,
             includeAgentMemory: true,
             includeFeedHistory: true,
@@ -1628,12 +1383,12 @@ ${sanitizedFeed.join("\n")}`
           }
           if (contextParts.length > 0) {
             relevantContext = contextParts.join("\n\n");
-            log6.debug(
+            log4.debug(
               `\u{1F50D} Found ${dbContext.relevantKnowledge.length} knowledge chunks, ${dbContext.relevantFeed.length} feed messages`
             );
           }
         } catch (error) {
-          log6.warn({ err: error }, "Context building failed");
+          log4.warn({ err: error }, "Context building failed");
         }
       }
       const memoryStats = this.getMemoryStats();
@@ -1645,8 +1400,23 @@ ${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,
@@ -1654,11 +1424,23 @@ ${statsContext}`;
         senderId: toolContext?.senderId,
         ownerName: this.config.telegram.owner_name,
         ownerUsername: this.config.telegram.owner_username,
-        context: additionalContext,
-        includeMemory: !isGroup,
-        includeStrategy: !isGroup,
+        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,
@@ -1674,7 +1456,7 @@ ${statsContext}`;
         this.config.agent.utility_model
       );
       if (preemptiveCompaction) {
-        log6.info(`\u{1F5DC}\uFE0F  Preemptive compaction triggered, reloading session...`);
+        log4.info(`\u{1F5DC}\uFE0F  Preemptive compaction triggered, reloading session...`);
         session = getSession(chatId);
         context = loadContextFromTranscript(session.sessionId);
         context.messages.push(userMsg);
@@ -1686,20 +1468,20 @@ ${statsContext}`;
       let tools;
       {
         const toolIndex = this.toolRegistry?.getToolIndex();
-        const useRAG = toolIndex?.isIndexed && this.config.tool_rag?.enabled !== false && !isTrivialMessage(userMessage) && !(providerMeta.toolLimit === null && this.config.tool_rag?.skip_unlimited_providers !== false);
+        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(
-            userMessage,
+            effectiveMessage,
             queryEmbedding,
-            isGroup ?? false,
+            effectiveIsGroup,
             providerMeta.toolLimit,
             chatId,
             isAdmin
           );
-          log6.info(`\u{1F50D} Tool RAG: ${tools.length}/${this.toolRegistry.count} tools selected`);
+          log4.info(`\u{1F50D} Tool RAG: ${tools.length}/${this.toolRegistry.count} tools selected`);
         } else {
           tools = this.toolRegistry?.getForContext(
-            isGroup ?? false,
+            effectiveIsGroup,
             providerMeta.toolLimit,
             chatId,
             isAdmin
@@ -1715,14 +1497,15 @@ ${statsContext}`;
       const totalToolCalls = [];
       const accumulatedTexts = [];
       const accumulatedUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalCost: 0 };
+      const seenToolSignatures = /* @__PURE__ */ new Set();
       while (iteration < maxIterations) {
         iteration++;
-        log6.debug(`\u{1F504} Agentic iteration ${iteration}/${maxIterations}`);
-        const maskedMessages = maskOldToolResults(
-          context.messages,
-          void 0,
-          this.toolRegistry ?? void 0
-        );
+        log4.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,
@@ -1734,6 +1517,21 @@ ${statsContext}`;
         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) {
@@ -1741,35 +1539,35 @@ ${statsContext}`;
                 "Context overflow persists after session reset. Message may be too large for the model's context window."
               );
             }
-            log6.error(`\u{1F6A8} Context overflow detected: ${errorMsg}`);
-            log6.info(`\u{1F4BE} Saving session memory before reset...`);
+            log4.error(`\u{1F6A8} Context overflow detected: ${errorMsg}`);
+            log4.info(`\u{1F4BE} Saving session memory before reset...`);
             const summary = extractContextSummary(context, CONTEXT_OVERFLOW_SUMMARY_MESSAGES);
             appendToDailyLog(summary);
-            log6.info(`\u2705 Memory saved to daily log`);
+            log4.info(`\u2705 Memory saved to daily log`);
             const archived = archiveTranscript(session.sessionId);
             if (!archived) {
-              log6.error(
+              log4.error(
                 `\u26A0\uFE0F  Failed to archive transcript ${session.sessionId}, proceeding with reset anyway`
               );
             }
-            log6.info(`\u{1F504} Resetting session due to context overflow...`);
+            log4.info(`\u{1F504} Resetting session due to context overflow...`);
             session = resetSession(chatId);
             context = { messages: [userMsg] };
             appendToTranscript(session.sessionId, userMsg);
-            log6.info(`\u{1F504} Retrying with fresh context...`);
+            log4.info(`\u{1F504} Retrying with fresh context...`);
             continue;
           } else if (errorMsg.toLowerCase().includes("rate") || errorMsg.includes("429")) {
             rateLimitRetries++;
             if (rateLimitRetries <= RATE_LIMIT_MAX_RETRIES) {
               const delay = 1e3 * Math.pow(2, rateLimitRetries - 1);
-              log6.warn(
+              log4.warn(
                 `\u{1F6AB} Rate limited, retrying in ${delay}ms (attempt ${rateLimitRetries}/${RATE_LIMIT_MAX_RETRIES})...`
               );
               await new Promise((r3) => setTimeout(r3, delay));
               iteration--;
               continue;
             }
-            log6.error(`\u{1F6AB} Rate limited after ${RATE_LIMIT_MAX_RETRIES} retries: ${errorMsg}`);
+            log4.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.`
             );
@@ -1777,19 +1575,19 @@ ${statsContext}`;
             serverErrorRetries++;
             if (serverErrorRetries <= SERVER_ERROR_MAX_RETRIES) {
               const delay = 2e3 * Math.pow(2, serverErrorRetries - 1);
-              log6.warn(
+              log4.warn(
                 `\u{1F504} Server error, retrying in ${delay}ms (attempt ${serverErrorRetries}/${SERVER_ERROR_MAX_RETRIES})...`
               );
               await new Promise((r3) => setTimeout(r3, delay));
               iteration--;
               continue;
             }
-            log6.error(`\u{1F6A8} Server error after ${SERVER_ERROR_MAX_RETRIES} retries: ${errorMsg}`);
+            log4.error(`\u{1F6A8} Server error after ${SERVER_ERROR_MAX_RETRIES} retries: ${errorMsg}`);
             throw new Error(
               `API server error after ${SERVER_ERROR_MAX_RETRIES} retries. The provider may be experiencing issues.`
             );
           } else {
-            log6.error(`\u{1F6A8} API error: ${errorMsg}`);
+            log4.error(`\u{1F6A8} API error: ${errorMsg}`);
             throw new Error(`API error: ${errorMsg || "Unknown error"}`);
           }
         }
@@ -1806,55 +1604,156 @@ ${statsContext}`;
         }
         const toolCalls = response2.message.content.filter((block) => block.type === "toolCall");
         if (toolCalls.length === 0) {
-          log6.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 done`);
+          log4.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 done`);
           finalResponse = response2;
           break;
         }
         if (!this.toolRegistry || !toolContext) {
-          log6.error("\u26A0\uFE0F Cannot execute tools: registry or context missing");
+          log4.error("\u26A0\uFE0F Cannot execute tools: registry or context missing");
           break;
         }
-        log6.debug(`\u{1F527} Executing ${toolCalls.length} tool call(s)`);
+        log4.debug(`\u{1F527} Executing ${toolCalls.length} tool call(s)`);
         context.messages.push(response2.message);
         const iterationToolNames = [];
+        const fullContext = {
+          ...toolContext,
+          chatId,
+          isGroup: effectiveIsGroup
+        };
+        const toolPlans = [];
         for (const block of toolCalls) {
           if (block.type !== "toolCall") continue;
-          const fullContext = {
-            ...toolContext,
-            chatId,
-            isGroup: isGroup ?? false
+          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 result = await this.toolRegistry.execute(block, fullContext);
-          log6.debug(`${block.name}: ${result.success ? "\u2713" : "\u2717"} ${result.error || ""}`);
-          iterationToolNames.push(`${block.name} ${result.success ? "\u2713" : "\u2717"}`);
+          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);
+          }
+          log4.debug(`${block.name}: ${exec.result.success ? "\u2713" : "\u2717"} ${exec.result.error || ""}`);
+          iterationToolNames.push(`${block.name} ${exec.result.success ? "\u2713" : "\u2717"}`);
           totalToolCalls.push({
             name: block.name,
             input: block.arguments
           });
-          let resultText = JSON.stringify(result, null, 2);
+          let resultText = JSON.stringify(exec.result);
           if (resultText.length > MAX_TOOL_RESULT_SIZE) {
-            log6.warn(`\u26A0\uFE0F Tool result too large (${resultText.length} chars), truncating...`);
-            const data = result.data;
+            log4.warn(`\u26A0\uFE0F Tool result too large (${resultText.length} chars), truncating...`);
+            const data = exec.result.data;
             if (data?.summary || data?.message) {
-              resultText = JSON.stringify(
-                {
-                  success: result.success,
-                  data: {
-                    summary: data.summary || data.message,
-                    _truncated: true,
-                    _originalSize: resultText.length,
-                    _message: "Full data truncated. Use limit parameter for smaller results."
-                  }
-                },
-                null,
-                2
-              );
+              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 {
-              resultText = resultText.slice(0, MAX_TOOL_RESULT_SIZE) + "\n...[TRUNCATED]";
+              const summarized = {
+                _truncated: true,
+                _originalSize: resultText.length,
+                _message: "Full data truncated. Use limit parameter for smaller results."
+              };
+              if (data && typeof data === "object") {
+                for (const [key, value] of Object.entries(data)) {
+                  if (Array.isArray(value)) {
+                    summarized[key] = `[${value.length} items]`;
+                  } else if (typeof value === "string" && value.length > 500) {
+                    summarized[key] = value.slice(0, 500) + "...[truncated]";
+                  } else {
+                    summarized[key] = value;
+                  }
+                }
+              }
+              resultText = JSON.stringify({ success: exec.result.success, data: summarized });
             }
           }
           if (provider === "cocoon") {
-            const { wrapToolResult } = await import("./tool-adapter-IH5VGBOO.js");
+            const { wrapToolResult } = await import("./tool-adapter-IVX2XQJE.js");
             const cocoonResultMsg = {
               role: "user",
               content: [
@@ -1878,21 +1777,33 @@ ${statsContext}`;
                   text: resultText
                 }
               ],
-              isError: !result.success,
+              isError: !exec.result.success,
               timestamp: Date.now()
             };
             context.messages.push(toolResultMsg);
             appendToTranscript(session.sessionId, toolResultMsg);
           }
         }
-        log6.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 ${iterationToolNames.join(", ")}`);
+        log4.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) {
+          log4.warn(
+            `\u{1F501} Loop stall detected: all ${iterSignatures.length} tool call(s) are repeats \u2014 breaking early`
+          );
+          finalResponse = response2;
+          break;
+        }
         if (iteration === maxIterations) {
-          log6.info(`\u26A0\uFE0F Max iterations reached (${maxIterations})`);
+          log4.info(`\u26A0\uFE0F Max iterations reached (${maxIterations})`);
           finalResponse = response2;
         }
       }
       if (!finalResponse) {
-        log6.error("\u26A0\uFE0F Agentic loop exited early without final response");
+        log4.error("\u26A0\uFE0F Agentic loop exited early without final response");
         return {
           content: "Internal error: Agent loop failed to produce a response.",
           toolCalls: []
@@ -1903,14 +1814,6 @@ ${statsContext}`;
       if (lastMsg?.role !== "assistant") {
         context.messages.push(response.message);
       }
-      const newSessionId = await this.compactionManager.checkAndCompact(
-        session.sessionId,
-        context,
-        getEffectiveApiKey(this.config.agent.provider, this.config.agent.api_key),
-        chatId,
-        this.config.agent.provider,
-        this.config.agent.utility_model
-      );
       const sessionUpdate = {
         updatedAt: Date.now(),
         messageCount: session.messageCount + 1,
@@ -1919,9 +1822,6 @@ ${statsContext}`;
         inputTokens: (session.inputTokens ?? 0) + accumulatedUsage.input + accumulatedUsage.cacheRead + accumulatedUsage.cacheWrite,
         outputTokens: (session.outputTokens ?? 0) + accumulatedUsage.output
       };
-      if (newSessionId) {
-        sessionUpdate.sessionId = newSessionId;
-      }
       updateSession(chatId, sessionUpdate);
       if (accumulatedUsage.input > 0 || accumulatedUsage.output > 0) {
         const u = accumulatedUsage;
@@ -1931,28 +1831,64 @@ ${statsContext}`;
         if (u.cacheRead) cacheParts.push(`${(u.cacheRead / 1e3).toFixed(1)}K cached`);
         if (u.cacheWrite) cacheParts.push(`${(u.cacheWrite / 1e3).toFixed(1)}K new`);
         const cacheInfo = cacheParts.length > 0 ? ` (${cacheParts.join(", ")})` : "";
-        log6.info(`\u{1F4B0} ${inK}K in${cacheInfo}, ${u.output} out | $${u.totalCost.toFixed(3)}`);
+        log4.info(`\u{1F4B0} ${inK}K in${cacheInfo}, ${u.output} out | $${u.totalCost.toFixed(3)}`);
         globalTokenUsage.totalTokens += u.input + u.output + u.cacheRead + u.cacheWrite;
         globalTokenUsage.totalCost += u.totalCost;
       }
       let content = accumulatedTexts.join("\n").trim() || response.text;
       const usedTelegramSendTool = totalToolCalls.some((tc) => TELEGRAM_SEND_TOOLS.has(tc.name));
       if (!content && totalToolCalls.length > 0 && !usedTelegramSendTool) {
-        log6.warn("\u26A0\uFE0F Empty response after tool calls - generating fallback");
+        log4.warn("\u26A0\uFE0F Empty response after tool calls - generating fallback");
         content = "I executed the requested action but couldn't generate a response. Please try again.";
       } else if (!content && usedTelegramSendTool) {
-        log6.info("\u2705 Response sent via Telegram tool - no additional text needed");
+        log4.info("\u2705 Response sent via Telegram tool - no additional text needed");
         content = "";
       } else if (!content && accumulatedUsage.input === 0 && accumulatedUsage.output === 0) {
-        log6.warn("\u26A0\uFE0F Empty response with zero tokens - possible API issue");
+        log4.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) {
+          log4.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) {
-      log6.error({ err: error }, "Agent error");
+      log4.error({ err: error }, "Agent error");
       throw error;
     }
   }
@@ -1965,7 +1901,7 @@ ${statsContext}`;
     ).run(chatId);
     db.prepare(`DELETE FROM tg_messages WHERE chat_id = ?`).run(chatId);
     resetSession(chatId);
-    log6.info(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
+    log4.info(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
   }
   getConfig() {
     return this.config;
@@ -1986,7 +1922,7 @@ ${statsContext}`;
   }
   configureCompaction(config) {
     this.compactionManager.updateConfig(config);
-    log6.info({ config: this.compactionManager.getConfig() }, `\u{1F5DC}\uFE0F  Compaction config updated`);
+    log4.info({ config: this.compactionManager.getConfig() }, `\u{1F5DC}\uFE0F  Compaction config updated`);
   }
   getCompactionConfig() {
     return this.compactionManager.getConfig();
@@ -2074,6 +2010,17 @@ function prefixButtons(rows, pluginName) {
 
 // src/bot/services/html-parser.ts
 import { Api as Api2 } from "telegram";
+
+// src/utils/gramjs-bigint.ts
+import { randomBytes } from "crypto";
+function toLong(value) {
+  return typeof value === "bigint" ? value : BigInt(value);
+}
+function randomLong() {
+  return randomBytes(8).readBigUInt64BE();
+}
+
+// src/bot/services/html-parser.ts
 function parseHtml(html) {
   const entities = [];
   let text = "";
@@ -2124,7 +2071,7 @@ function parseHtml(html) {
                       new Api2.MessageEntityCustomEmoji({
                         offset: open.offset,
                         length,
-                        documentId: BigInt(open.emojiId)
+                        documentId: toLong(open.emojiId)
                       })
                     );
                   }
@@ -2185,7 +2132,7 @@ function unescapeHtml(text) {
 }
 
 // src/bot/inline-router.ts
-var log7 = createLogger("InlineRouter");
+var log5 = createLogger("InlineRouter");
 var INLINE_TIMEOUT_MS = 5e3;
 var CALLBACK_TIMEOUT_MS = 15e3;
 function compileGlob(pattern) {
@@ -2206,11 +2153,11 @@ var InlineRouter = class {
   }
   registerPlugin(name, handlers) {
     this.plugins.set(name, handlers);
-    log7.info(`Registered plugin "${name}" for inline routing`);
+    log5.info(`Registered plugin "${name}" for inline routing`);
   }
   unregisterPlugin(name) {
     this.plugins.delete(name);
-    log7.info(`Unregistered plugin "${name}" from inline routing`);
+    log5.info(`Unregistered plugin "${name}" from inline routing`);
   }
   hasPlugin(name) {
     return this.plugins.has(name);
@@ -2262,11 +2209,14 @@ var InlineRouter = class {
   }
   async handleInlineQuery(ctx, pluginName, query, plugin) {
     try {
+      const inlineQuery = ctx.inlineQuery;
+      const from = ctx.from;
+      if (!inlineQuery || !from || !plugin.onInlineQuery) return;
       const iqCtx = {
         query,
-        queryId: ctx.inlineQuery.id,
-        userId: ctx.from.id,
-        offset: ctx.inlineQuery.offset
+        queryId: inlineQuery.id,
+        userId: from.id,
+        offset: inlineQuery.offset
       };
       const results = await withTimeout(
         plugin.onInlineQuery(iqCtx),
@@ -2279,7 +2229,7 @@ var InlineRouter = class {
         is_personal: true
       });
     } catch (error) {
-      log7.error({ err: error }, `Plugin "${pluginName}" inline query handler failed`);
+      log5.error({ err: error }, `Plugin "${pluginName}" inline query handler failed`);
       try {
         await ctx.answerInlineQuery([], { cache_time: 0, is_personal: true });
       } catch {
@@ -2291,7 +2241,7 @@ var InlineRouter = class {
     try {
       let matchedHandler;
       let matchGroups = [];
-      for (const entry of plugin.onCallback) {
+      for (const entry of plugin.onCallback ?? []) {
         const groups = globMatch(entry.regex, strippedData);
         if (groups !== null) {
           matchedHandler = entry.handler;
@@ -2304,14 +2254,17 @@ var InlineRouter = class {
         return;
       }
       const gramjsBotRef = this.gramjsBot;
+      const callbackQuery = ctx.callbackQuery;
+      const from = ctx.from;
+      if (!from || !callbackQuery) return;
       const cbCtx = {
         data: strippedData,
         match: matchGroups,
-        userId: ctx.from.id,
-        username: ctx.from.username,
-        inlineMessageId: ctx.callbackQuery.inline_message_id,
+        userId: from.id,
+        username: from.username,
+        inlineMessageId: callbackQuery.inline_message_id,
         chatId: ctx.chat?.id?.toString(),
-        messageId: ctx.callbackQuery.message?.message_id,
+        messageId: callbackQuery.message?.message_id,
         async answer(text, alert) {
           if (!answered) {
             answered = true;
@@ -2320,7 +2273,7 @@ var InlineRouter = class {
         },
         async editMessage(text, opts) {
           const styledButtons = opts?.keyboard ? prefixButtons(opts.keyboard, pluginName) : void 0;
-          const inlineMsgId = ctx.callbackQuery.inline_message_id;
+          const inlineMsgId = ctx.callbackQuery?.inline_message_id;
           if (inlineMsgId && gramjsBotRef?.isConnected() && styledButtons) {
             try {
               const strippedHtml = stripCustomEmoji(text);
@@ -2334,10 +2287,9 @@ var InlineRouter = class {
               });
               return;
             } catch (error) {
-              if (error?.errorMessage === "MESSAGE_NOT_MODIFIED") return;
-              log7.debug(
-                `GramJS edit failed, falling back to Grammy: ${error?.errorMessage || error}`
-              );
+              const errMsg = error?.errorMessage;
+              if (errMsg === "MESSAGE_NOT_MODIFIED") return;
+              log5.debug(`GramJS edit failed, falling back to Grammy: ${errMsg || error}`);
             }
           }
           const replyMarkup = styledButtons ? toGrammyKeyboard(styledButtons) : void 0;
@@ -2357,7 +2309,7 @@ var InlineRouter = class {
         await ctx.answerCallbackQuery();
       }
     } catch (error) {
-      log7.error({ err: error }, `Plugin "${pluginName}" callback handler failed`);
+      log5.error({ err: error }, `Plugin "${pluginName}" callback handler failed`);
       if (!answered) {
         try {
           await ctx.answerCallbackQuery({ text: "Error processing action" });
@@ -2368,17 +2320,19 @@ var InlineRouter = class {
   }
   async handleChosenResult(ctx, pluginName, plugin) {
     try {
-      const resultId = ctx.chosenInlineResult.result_id;
+      const chosenResult = ctx.chosenInlineResult;
+      if (!chosenResult || !plugin.onChosenResult) return;
+      const resultId = chosenResult.result_id;
       const colonIdx = resultId.indexOf(":");
       const strippedResultId = colonIdx > 0 ? resultId.slice(colonIdx + 1) : resultId;
       const crCtx = {
         resultId: strippedResultId,
-        inlineMessageId: ctx.chosenInlineResult.inline_message_id,
-        query: ctx.chosenInlineResult.query
+        inlineMessageId: chosenResult.inline_message_id,
+        query: chosenResult.query
       };
       await plugin.onChosenResult(crCtx);
     } catch (error) {
-      log7.error({ err: error }, `Plugin "${pluginName}" chosen result handler failed`);
+      log5.error({ err: error }, `Plugin "${pluginName}" chosen result handler failed`);
     }
   }
   /**
@@ -2457,14 +2411,38 @@ function withTimeout(promise, ms, message) {
 
 // src/agent/tools/plugin-loader.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync5, existsSync as existsSync6, statSync } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 import { pathToFileURL } from "url";
 import { execFile } from "child_process";
+
+// src/agent/tools/plugin-config-store.ts
+function getPluginPriorities(db) {
+  const rows = db.prepare("SELECT plugin_name, priority FROM plugin_config").all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    map.set(row.plugin_name, row.priority);
+  }
+  return map;
+}
+function setPluginPriority(db, pluginName, priority) {
+  db.prepare(
+    `INSERT INTO plugin_config (plugin_name, priority, updated_at)
+     VALUES (?, ?, datetime('now'))
+     ON CONFLICT(plugin_name) DO UPDATE SET
+       priority = excluded.priority,
+       updated_at = excluded.updated_at`
+  ).run(pluginName, priority);
+}
+function resetPluginPriority(db, pluginName) {
+  db.prepare("DELETE FROM plugin_config WHERE plugin_name = ?").run(pluginName);
+}
+
+// src/agent/tools/plugin-loader.ts
 import { promisify } from "util";
 
 // src/agent/tools/plugin-validator.ts
 import { z } from "zod";
-var log8 = createLogger("PluginValidator");
+var log6 = createLogger("PluginValidator");
 var ManifestSchema = z.object({
   name: z.string().min(1).max(64).regex(
     /^[a-z0-9][a-z0-9-]*$/,
@@ -2491,7 +2469,14 @@ var ManifestSchema = z.object({
       inlinePerMinute: z.number().positive().optional(),
       callbackPerMinute: z.number().positive().optional()
     }).optional()
-  }).optional()
+  }).optional(),
+  hooks: z.array(
+    z.object({
+      name: z.string().min(1).max(64),
+      priority: z.number().optional(),
+      description: z.string().max(256).optional()
+    })
+  ).optional()
 });
 function validateManifest(raw) {
   return ManifestSchema.parse(raw);
@@ -2500,20 +2485,20 @@ function validateToolDefs(defs, pluginName) {
   const valid = [];
   for (const def of defs) {
     if (!def || typeof def !== "object") {
-      log8.warn(`[${pluginName}] tool is not an object, skipping`);
+      log6.warn(`[${pluginName}] tool is not an object, skipping`);
       continue;
     }
     const t = def;
     if (!t.name || typeof t.name !== "string") {
-      log8.warn(`[${pluginName}] tool missing 'name', skipping`);
+      log6.warn(`[${pluginName}] tool missing 'name', skipping`);
       continue;
     }
     if (!t.description || typeof t.description !== "string") {
-      log8.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
+      log6.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
       continue;
     }
     if (!t.execute || typeof t.execute !== "function") {
-      log8.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
+      log6.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
       continue;
     }
     valid.push(t);
@@ -2550,8 +2535,19 @@ import { Address, SendMode } from "@ton/core";
 
 // src/ton/tx-lock.ts
 var pending = Promise.resolve();
+var TX_LOCK_TIMEOUT_MS = 6e4;
 function withTxLock(fn) {
-  const execute = pending.then(fn, fn);
+  const guarded = () => {
+    let timerId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timerId = setTimeout(
+        () => reject(new Error("TON tx-lock timeout (60s)")),
+        TX_LOCK_TIMEOUT_MS
+      );
+    });
+    return Promise.race([fn(), timeoutPromise]).finally(() => clearTimeout(timerId));
+  };
+  const execute = pending.then(guarded, guarded);
   pending = execute.then(
     () => {
     },
@@ -2562,25 +2558,25 @@ function withTxLock(fn) {
 }
 
 // src/ton/transfer.ts
-var log9 = createLogger("TON");
+var log7 = createLogger("TON");
 async function sendTon(params) {
   return withTxLock(async () => {
     try {
       const { toAddress: toAddress2, amount, comment = "", bounce = false } = params;
       if (!Number.isFinite(amount) || amount <= 0) {
-        log9.error({ amount }, "Invalid transfer amount");
+        log7.error({ amount }, "Invalid transfer amount");
         return null;
       }
       let recipientAddress;
       try {
         recipientAddress = Address.parse(toAddress2);
       } catch (e) {
-        log9.error({ err: e }, `Invalid recipient address: ${toAddress2}`);
+        log7.error({ err: e }, `Invalid recipient address: ${toAddress2}`);
         return null;
       }
       const keyPair = await getKeyPair();
       if (!keyPair) {
-        log9.error("Wallet not initialized");
+        log7.error("Wallet not initialized");
         return null;
       }
       const wallet = WalletContractV5R1.create({
@@ -2604,21 +2600,22 @@ async function sendTon(params) {
         ]
       });
       const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-      log9.info(`Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
+      log7.info(`Sent ${amount} TON to ${toAddress2.slice(0, 8)}... - seqno: ${seqno}`);
       return pseudoHash;
     } catch (error) {
-      const status = error?.status || error?.response?.status;
-      if (status === 429 || status >= 500) {
+      const err = error;
+      const status = err?.status || err?.response?.status;
+      if (status === 429 || status !== void 0 && status >= 500) {
         invalidateTonClientCache();
       }
-      log9.error({ err: error }, "Error sending TON");
+      log7.error({ err: error }, "Error sending TON");
       throw error;
     }
   });
 }
 
 // src/utils/retry.ts
-var log10 = createLogger("Utils");
+var log8 = createLogger("Utils");
 var DEFAULT_OPTIONS = {
   maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
   baseDelayMs: RETRY_DEFAULT_BASE_DELAY_MS,
@@ -2642,7 +2639,7 @@ async function withRetry(fn, options = {}) {
       return result;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
-      log10.warn(`Retry attempt ${attempt}/${opts.maxAttempts} failed: ${lastError.message}`);
+      log8.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);
@@ -3142,9 +3139,9 @@ var retryStatusCodes = /* @__PURE__ */ new Set([
 var nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
 function createFetch(globalOptions = {}) {
   const {
-    fetch: fetch2 = globalThis.fetch,
+    fetch: fetch3 = globalThis.fetch,
     Headers: Headers2 = globalThis.Headers,
-    AbortController: AbortController2 = globalThis.AbortController
+    AbortController: AbortController3 = globalThis.AbortController
   } = globalOptions;
   async function onError(context) {
     const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
@@ -3228,7 +3225,7 @@ function createFetch(globalOptions = {}) {
     }
     let abortTimeout;
     if (!context.options.signal && context.options.timeout) {
-      const controller = new AbortController2();
+      const controller = new AbortController3();
       abortTimeout = setTimeout(() => {
         const error = new Error(
           "[TimeoutError]: The operation was aborted due to timeout"
@@ -3240,7 +3237,7 @@ function createFetch(globalOptions = {}) {
       context.options.signal = controller.signal;
     }
     try {
-      context.response = await fetch2(
+      context.response = await fetch3(
         context.request,
         context.options
       );
@@ -3302,7 +3299,7 @@ function createFetch(globalOptions = {}) {
     return r3._data;
   };
   $fetch.raw = $fetchRaw;
-  $fetch.native = (...args) => fetch2(...args);
+  $fetch.native = (...args) => fetch3(...args);
   $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
     ...globalOptions,
     ...customGlobalOptions,
@@ -3333,10 +3330,10 @@ function createNodeFetch() {
     return r(input, { ...nodeFetchOptions, ...init });
   };
 }
-var fetch = globalThis.fetch ? (...args) => globalThis.fetch(...args) : createNodeFetch();
+var fetch2 = globalThis.fetch ? (...args) => globalThis.fetch(...args) : createNodeFetch();
 var Headers = globalThis.Headers || n;
-var AbortController = globalThis.AbortController || T;
-var ofetch = createFetch({ fetch, Headers, AbortController });
+var AbortController2 = globalThis.AbortController || T;
+var ofetch = createFetch({ fetch: fetch2, Headers, AbortController: AbortController2 });
 
 // node_modules/@ston-fi/api/dist/esm/index.js
 var __create = Object.create;
@@ -6120,7 +6117,7 @@ var DEDUST_GAS = {
 var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 
 // src/agent/tools/dedust/asset-cache.ts
-var log11 = createLogger("Tools");
+var log9 = createLogger("Tools");
 var ASSET_LIST_URL = "https://assets.dedust.io/list.json";
 var CACHE_TTL_MS = 10 * 60 * 1e3;
 var cachedAssets = [];
@@ -6139,7 +6136,7 @@ async function getAssetList() {
     return cachedAssets;
   } catch (error) {
     if (cachedAssets.length > 0) {
-      log11.warn({ err: error }, "Asset list fetch failed, using stale cache");
+      log9.warn({ err: error }, "Asset list fetch failed, using stale cache");
       return cachedAssets;
     }
     throw error;
@@ -6265,7 +6262,7 @@ async function getDedustQuote(fromAsset, toAsset, amount, slippage, log13) {
     return null;
   }
 }
-async function executeSTONfiSwap(params, log13) {
+async function executeSTONfiSwap(params, _log) {
   const { fromAsset, toAsset, amount, slippage = 0.01 } = params;
   const walletData = loadWallet();
   if (!walletData) {
@@ -6352,7 +6349,7 @@ async function executeSTONfiSwap(params, log13) {
     };
   });
 }
-async function executeDedustSwap(params, log13) {
+async function executeDedustSwap(params, _log) {
   const { fromAsset, toAsset, amount, slippage = 0.01 } = params;
   const walletData = loadWallet();
   if (!walletData) {
@@ -6372,7 +6369,7 @@ async function executeDedustSwap(params, log13) {
   const fromDecimals = await getDecimals(isTonInput ? "ton" : fromAsset);
   const toDecimals = await getDecimals(isTonOutput ? "ton" : toAsset);
   const amountIn = toUnits(amount, fromDecimals);
-  const { amountOut, tradeFee } = await pool.getEstimatedSwapOut({
+  const { amountOut } = await pool.getEstimatedSwapOut({
     assetIn: fromAssetObj,
     amountIn
   });
@@ -6648,7 +6645,10 @@ function createDnsSDK(log13) {
         throw new PluginSDKError(`No active auction found for ${normalized}`, "OPERATION_FAILED");
       }
       try {
-        await sendWalletMessage(Address6.parse(checkResult.nftAddress), toNano15(amount.toString()));
+        await sendWalletMessage(
+          Address6.parse(checkResult.nftAddress),
+          toNano15(amount.toString())
+        );
         return { domain: normalized, bidAmount: amount.toString(), success: true };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
@@ -6745,7 +6745,7 @@ import {
   WalletContractV5R1 as WalletContractV5R14,
   internal as internal4
 } from "@ton/ton";
-import { Address as TonAddress, beginCell as beginCell13, SendMode as SendMode4 } from "@ton/core";
+import { Address as TonAddress, beginCell as beginCell13, SendMode as SendMode4, storeMessage } from "@ton/core";
 
 // src/ton/format-transactions.ts
 import { fromNano } from "@ton/ton";
@@ -7114,26 +7114,222 @@ function createTonSDK(log13, db) {
           log13.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
           return null;
         }
-        const data = await response.json();
-        const metadata = data.metadata || {};
-        const decimals = parseInt(metadata.decimals || "9");
+        const data = await response.json();
+        const metadata = data.metadata || {};
+        const decimals = parseInt(metadata.decimals || "9");
+        return {
+          address: metadata.address || jettonAddress,
+          name: metadata.name || "Unknown",
+          symbol: metadata.symbol || "UNKNOWN",
+          decimals,
+          totalSupply: data.total_supply || "0",
+          holdersCount: data.holders_count || 0,
+          verified: data.verification === "whitelist",
+          description: metadata.description || void 0,
+          image: data.preview || metadata.image || void 0
+        };
+      } catch (err) {
+        log13.error("ton.getJettonInfo() failed:", err);
+        return null;
+      }
+    },
+    async sendJetton(jettonAddress, to, amount, opts) {
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      if (!Number.isFinite(amount) || amount <= 0) {
+        throw new PluginSDKError("Amount must be a positive number", "OPERATION_FAILED");
+      }
+      try {
+        TonAddress.parse(to);
+      } catch {
+        throw new PluginSDKError("Invalid recipient address", "INVALID_ADDRESS");
+      }
+      try {
+        const jettonsResponse = await tonapiFetch(
+          `/accounts/${encodeURIComponent(walletData.address)}/jettons`
+        );
+        if (!jettonsResponse.ok) {
+          throw new PluginSDKError(
+            `Failed to fetch jetton balances: ${jettonsResponse.status}`,
+            "OPERATION_FAILED"
+          );
+        }
+        const jettonsData = await jettonsResponse.json();
+        const jettonBalance = findJettonBalance(jettonsData.balances ?? [], jettonAddress);
+        if (!jettonBalance) {
+          throw new PluginSDKError(
+            `You don't own any of this jetton: ${jettonAddress}`,
+            "OPERATION_FAILED"
+          );
+        }
+        const senderJettonWallet = jettonBalance.wallet_address.address;
+        const decimals = jettonBalance.jetton.decimals ?? 9;
+        const currentBalance = BigInt(jettonBalance.balance);
+        const amountStr = amount.toFixed(decimals);
+        const [whole, frac = ""] = amountStr.split(".");
+        const amountInUnits = BigInt(whole + (frac + "0".repeat(decimals)).slice(0, decimals));
+        if (amountInUnits > currentBalance) {
+          const balStr = formatTokenBalance(currentBalance, decimals);
+          throw new PluginSDKError(
+            `Insufficient balance. Have ${balStr}, need ${amount}`,
+            "OPERATION_FAILED"
+          );
+        }
+        const comment = opts?.comment;
+        let forwardPayload = beginCell13().endCell();
+        if (comment) {
+          forwardPayload = beginCell13().storeUint(0, 32).storeStringTail(comment).endCell();
+        }
+        const JETTON_TRANSFER_OP = 260734629;
+        const messageBody = beginCell13().storeUint(JETTON_TRANSFER_OP, 32).storeUint(0, 64).storeCoins(amountInUnits).storeAddress(TonAddress.parse(to)).storeAddress(TonAddress.parse(walletData.address)).storeBit(false).storeCoins(comment ? tonToNano("0.01") : BigInt(1)).storeBit(comment ? 1 : 0).storeRef(comment ? forwardPayload : beginCell13().endCell()).endCell();
+        const keyPair = await getKeyPair();
+        if (!keyPair) {
+          throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+        }
+        const seqno = await withTxLock(async () => {
+          const MAX_SEND_ATTEMPTS = 3;
+          let lastErr;
+          for (let attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {
+            try {
+              const wallet = WalletContractV5R14.create({
+                workchain: 0,
+                publicKey: keyPair.publicKey
+              });
+              const client = await getCachedTonClient();
+              const walletContract = client.open(wallet);
+              const seq = await walletContract.getSeqno();
+              await walletContract.sendTransfer({
+                seqno: seq,
+                secretKey: keyPair.secretKey,
+                sendMode: SendMode4.PAY_GAS_SEPARATELY,
+                messages: [
+                  internal4({
+                    to: TonAddress.parse(senderJettonWallet),
+                    value: tonToNano("0.05"),
+                    body: messageBody,
+                    bounce: true
+                  })
+                ]
+              });
+              return seq;
+            } catch (err) {
+              lastErr = err;
+              const httpErr = isHttpError(err) ? err : void 0;
+              const status = httpErr?.status || httpErr?.response?.status;
+              const respData = httpErr?.response?.data;
+              if (status === 429 || status && status >= 500) {
+                invalidateTonClientCache();
+                if (attempt < MAX_SEND_ATTEMPTS) {
+                  log13.warn(
+                    `sendJetton attempt ${attempt} failed (${status}): ${JSON.stringify(respData ?? err.message)}, retrying...`
+                  );
+                  await new Promise((r3) => setTimeout(r3, 1e3 * attempt));
+                  continue;
+                }
+              }
+              throw err;
+            }
+          }
+          throw lastErr;
+        });
+        return { success: true, seqno };
+      } catch (err) {
+        const outerHttpErr = isHttpError(err) ? err : void 0;
+        const status = outerHttpErr?.status || outerHttpErr?.response?.status;
+        if (status === 429 || status && status >= 500) {
+          invalidateTonClientCache();
+        }
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to send jetton: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
+      }
+    },
+    async getJettonWalletAddress(ownerAddress, jettonAddress) {
+      try {
+        const response = await tonapiFetch(`/accounts/${encodeURIComponent(ownerAddress)}/jettons`);
+        if (!response.ok) {
+          log13.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) {
+        log13.error("ton.getJettonWalletAddress() failed:", err);
+        return null;
+      }
+    },
+    // ─── Signed Transfers (no broadcast) ──────────────────────────
+    async createTransfer(to, amount, comment) {
+      const walletData = loadWallet();
+      if (!walletData) {
+        throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
+      }
+      if (!Number.isFinite(amount) || amount <= 0) {
+        throw new PluginSDKError("Amount must be a positive number", "OPERATION_FAILED");
+      }
+      try {
+        TonAddress.parse(to);
+      } catch {
+        throw new PluginSDKError("Invalid TON address format", "INVALID_ADDRESS");
+      }
+      try {
+        const keyPair = await getKeyPair();
+        if (!keyPair) {
+          throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
+        }
+        const boc = await withTxLock(async () => {
+          const wallet = WalletContractV5R14.create({
+            workchain: 0,
+            publicKey: keyPair.publicKey
+          });
+          const client = await getCachedTonClient();
+          const contract = client.open(wallet);
+          const seqno = await contract.getSeqno();
+          const transferCell = wallet.createTransfer({
+            seqno,
+            secretKey: keyPair.secretKey,
+            sendMode: SendMode4.PAY_GAS_SEPARATELY,
+            messages: [
+              internal4({
+                to: TonAddress.parse(to),
+                value: tonToNano(amount),
+                body: comment || "",
+                bounce: false
+              })
+            ]
+          });
+          const extMsg = beginCell13().store(
+            storeMessage({
+              info: {
+                type: "external-in",
+                dest: wallet.address,
+                importFee: 0n
+              },
+              init: seqno === 0 ? wallet.init : void 0,
+              body: transferCell
+            })
+          ).endCell();
+          return extMsg.toBoc().toString("base64");
+        });
         return {
-          address: metadata.address || jettonAddress,
-          name: metadata.name || "Unknown",
-          symbol: metadata.symbol || "UNKNOWN",
-          decimals,
-          totalSupply: data.total_supply || "0",
-          holdersCount: data.holders_count || 0,
-          verified: data.verification === "whitelist",
-          description: metadata.description || void 0,
-          image: data.preview || metadata.image || void 0
+          boc,
+          publicKey: walletData.publicKey,
+          walletVersion: "v5r1"
         };
       } catch (err) {
-        log13.error("ton.getJettonInfo() failed:", err);
-        return null;
+        if (err instanceof PluginSDKError) throw err;
+        throw new PluginSDKError(
+          `Failed to create transfer: ${err instanceof Error ? err.message : String(err)}`,
+          "OPERATION_FAILED"
+        );
       }
     },
-    async sendJetton(jettonAddress, to, amount, opts) {
+    async createJettonTransfer(jettonAddress, to, amount, opts) {
       const walletData = loadWallet();
       if (!walletData) {
         throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
@@ -7188,79 +7384,65 @@ function createTonSDK(log13, db) {
         if (!keyPair) {
           throw new PluginSDKError("Wallet key derivation failed", "OPERATION_FAILED");
         }
-        const seqno = await withTxLock(async () => {
-          const MAX_SEND_ATTEMPTS = 3;
-          let lastErr;
-          for (let attempt = 1; attempt <= MAX_SEND_ATTEMPTS; attempt++) {
-            try {
-              const wallet = WalletContractV5R14.create({
-                workchain: 0,
-                publicKey: keyPair.publicKey
-              });
-              const client = await getCachedTonClient();
-              const walletContract = client.open(wallet);
-              const seq = await walletContract.getSeqno();
-              await walletContract.sendTransfer({
-                seqno: seq,
-                secretKey: keyPair.secretKey,
-                sendMode: SendMode4.PAY_GAS_SEPARATELY,
-                messages: [
-                  internal4({
-                    to: TonAddress.parse(senderJettonWallet),
-                    value: tonToNano("0.05"),
-                    body: messageBody,
-                    bounce: true
-                  })
-                ]
-              });
-              return seq;
-            } catch (err) {
-              lastErr = err;
-              const status = err?.status || err?.response?.status;
-              const respData = err?.response?.data;
-              if (status === 429 || status && status >= 500) {
-                invalidateTonClientCache();
-                if (attempt < MAX_SEND_ATTEMPTS) {
-                  log13.warn(
-                    `sendJetton attempt ${attempt} failed (${status}): ${JSON.stringify(respData ?? err.message)}, retrying...`
-                  );
-                  await new Promise((r3) => setTimeout(r3, 1e3 * attempt));
-                  continue;
-                }
-              }
-              throw err;
-            }
-          }
-          throw lastErr;
+        const boc = await withTxLock(async () => {
+          const wallet = WalletContractV5R14.create({
+            workchain: 0,
+            publicKey: keyPair.publicKey
+          });
+          const client = await getCachedTonClient();
+          const walletContract = client.open(wallet);
+          const seqno = await walletContract.getSeqno();
+          const transferCell = wallet.createTransfer({
+            seqno,
+            secretKey: keyPair.secretKey,
+            sendMode: SendMode4.PAY_GAS_SEPARATELY,
+            messages: [
+              internal4({
+                to: TonAddress.parse(senderJettonWallet),
+                value: tonToNano("0.05"),
+                body: messageBody,
+                bounce: true
+              })
+            ]
+          });
+          const extMsg = beginCell13().store(
+            storeMessage({
+              info: {
+                type: "external-in",
+                dest: wallet.address,
+                importFee: 0n
+              },
+              init: seqno === 0 ? wallet.init : void 0,
+              body: transferCell
+            })
+          ).endCell();
+          return extMsg.toBoc().toString("base64");
         });
-        return { success: true, seqno };
+        return {
+          boc,
+          publicKey: walletData.publicKey,
+          walletVersion: "v5r1"
+        };
       } catch (err) {
-        const status = err?.status || err?.response?.status;
-        if (status === 429 || status && status >= 500) {
-          invalidateTonClientCache();
-        }
         if (err instanceof PluginSDKError) throw err;
         throw new PluginSDKError(
-          `Failed to send jetton: ${err instanceof Error ? err.message : String(err)}`,
+          `Failed to create jetton transfer: ${err instanceof Error ? err.message : String(err)}`,
           "OPERATION_FAILED"
         );
       }
     },
-    async getJettonWalletAddress(ownerAddress, jettonAddress) {
+    getPublicKey() {
       try {
-        const response = await tonapiFetch(`/accounts/${encodeURIComponent(ownerAddress)}/jettons`);
-        if (!response.ok) {
-          log13.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;
+        const wallet = loadWallet();
+        return wallet?.publicKey ?? null;
       } catch (err) {
-        log13.error("ton.getJettonWalletAddress() failed:", err);
+        log13.error("ton.getPublicKey() failed:", err);
         return null;
       }
     },
+    getWalletVersion() {
+      return "v5r1";
+    },
     // ─── NFT ─────────────────────────────────────────────────────
     async getNftItems(ownerAddress) {
       try {
@@ -7475,15 +7657,6 @@ function mapNftItem(item) {
 // src/sdk/telegram.ts
 import { Api as Api3 } from "telegram";
 
-// src/utils/gramjs-bigint.ts
-import { randomBytes } from "crypto";
-function toLong(value) {
-  return typeof value === "bigint" ? value : BigInt(value);
-}
-function randomLong() {
-  return randomBytes(8).readBigUInt64BE();
-}
-
 // src/sdk/telegram-utils.ts
 function requireBridge(bridge) {
   if (!bridge.isAvailable()) {
@@ -7657,7 +7830,7 @@ function createTelegramMessagesSDK(bridge, log13) {
             limit,
             maxId: 0,
             minId: 0,
-            hash: 0n
+            hash: toLong(0n)
           })
         );
         const messages = [];
@@ -7820,10 +7993,12 @@ function createTelegramMessagesSDK(bridge, log13) {
         if (!messages || messages.length === 0 || !messages[0].media) {
           return null;
         }
-        const doc = messages[0].media?.document;
-        if (doc?.size && Number(doc.size) > MAX_DOWNLOAD_SIZE) {
+        const media = messages[0].media;
+        const doc = media && "document" in media ? media.document : void 0;
+        const docSize = doc && "size" in doc ? doc.size : void 0;
+        if (docSize && Number(docSize) > MAX_DOWNLOAD_SIZE) {
           throw new PluginSDKError(
-            `File too large (${Math.round(Number(doc.size) / 1024 / 1024)}MB). Max: 50MB`,
+            `File too large (${Math.round(Number(docSize) / 1024 / 1024)}MB). Max: 50MB`,
             "OPERATION_FAILED"
           );
         }
@@ -7847,7 +8022,7 @@ function createTelegramMessagesSDK(bridge, log13) {
         const result = await gramJsClient.invoke(
           new Api4.messages.GetScheduledHistory({
             peer,
-            hash: 0n
+            hash: toLong(0n)
           })
         );
         const messages = [];
@@ -8005,7 +8180,6 @@ function createTelegramSocialSDK(bridge, log13) {
       requireBridge2();
       try {
         const client = getClient2();
-        const Api4 = await getApi();
         let entity;
         try {
           const id = typeof userId === "string" ? userId.replace("@", "") : userId.toString();
@@ -8329,7 +8503,7 @@ function createTelegramSocialSDK(bridge, log13) {
         const user = await client.getInputEntity(userId.toString());
         const invoiceData = {
           peer: user,
-          giftId: BigInt(giftId),
+          giftId: toLong(giftId),
           hideName: opts?.anonymous ?? false,
           message: opts?.message ? new Api4.TextWithEntities({ text: opts.message, entities: [] }) : void 0
         };
@@ -8413,7 +8587,7 @@ function createTelegramSocialSDK(bridge, log13) {
         const Api4 = await getApi();
         const result = await client.invoke(
           new Api4.payments.GetResaleStarGifts({
-            giftId: BigInt(giftId),
+            giftId: toLong(giftId),
             offset: "",
             limit: limit ?? 50
           })
@@ -8572,7 +8746,7 @@ function createTelegramSocialSDK(bridge, log13) {
           new Api4.payments.UpdateStarGiftPrice({
             stargift: new Api4.InputSavedStarGiftUser({ msgId }),
             resellAmount: new Api4.StarsAmount({
-              amount: BigInt(price),
+              amount: toLong(price),
               nanos: 0
             })
           })
@@ -8703,7 +8877,7 @@ function createTelegramSocialSDK(bridge, log13) {
           new Api4.payments.SendStarGiftOffer({
             peer,
             slug: giftSlug,
-            price: new Api4.StarsAmount({ amount: BigInt(price), nanos: 0 }),
+            price: new Api4.StarsAmount({ amount: toLong(price), nanos: 0 }),
             duration,
             randomId: randomLong()
           })
@@ -8723,7 +8897,7 @@ function createTelegramSocialSDK(bridge, log13) {
         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: readFileSync8, statSync: statSync2 } = await import("fs");
         const { basename: basename2 } = await import("path");
         const { resolve: resolve2, normalize: normalize2 } = await import("path");
         const { homedir: homedir3 } = await import("os");
@@ -8748,7 +8922,7 @@ function createTelegramSocialSDK(bridge, log13) {
         }
         const fileName = basename2(filePath);
         const fileSize = statSync2(filePath).size;
-        const fileBuffer = readFileSync7(filePath);
+        const fileBuffer = readFileSync8(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({
@@ -8941,10 +9115,10 @@ function createTelegramSDK(bridge, log13) {
 
 // src/sdk/secrets.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
-import { join as join4 } from "path";
-var SECRETS_DIR = join4(TELETON_ROOT, "plugins", "data");
+import { join as join3 } from "path";
+var SECRETS_DIR = join3(TELETON_ROOT, "plugins", "data");
 function getSecretsPath(pluginName) {
-  return join4(SECRETS_DIR, `${pluginName}.secrets.json`);
+  return join3(SECRETS_DIR, `${pluginName}.secrets.json`);
 }
 function readSecretsFile(pluginName) {
   const filePath = getSecretsPath(pluginName);
@@ -9102,7 +9276,7 @@ function createBotSDK(router, gramjsBot, grammyBot, pluginName, manifest, rateLi
   const callbackLimit = manifest.rateLimits?.callbackPerMinute ?? 60;
   const handlers = {};
   function syncToRouter() {
-    router.registerPlugin(pluginName, { ...handlers });
+    router?.registerPlugin(pluginName, { ...handlers });
   }
   const sdk = {
     get isAvailable() {
@@ -9269,6 +9443,36 @@ function createPluginSDK(deps, opts) {
       );
       if (result) cachedBot = result;
       return result;
+    },
+    on(hookName, handler, onOpts) {
+      if (!opts.hookRegistry) {
+        log13.warn(`Hook registration unavailable \u2014 sdk.on() ignored`);
+        return;
+      }
+      if (opts.declaredHooks) {
+        const declared = opts.declaredHooks.some((h2) => h2.name === hookName);
+        if (!declared) {
+          log13.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) {
+        log13.debug(`Hook "${hookName}" priority ${rawPriority} clamped to ${clampedPriority}`);
+      }
+      const registered = opts.hookRegistry.register({
+        pluginId: opts.pluginName,
+        hookName,
+        handler,
+        priority: clampedPriority,
+        globalPriority: opts.globalPriority ?? 0
+      });
+      if (!registered) {
+        log13.warn(
+          `Hook registration limit reached for plugin "${opts.pluginName}" \u2014 "${hookName}" rejected`
+        );
+      }
     }
   };
   return Object.freeze(sdk);
@@ -9329,23 +9533,76 @@ function semverSatisfies(current, range) {
   return cur.major === req.major && cur.minor === req.minor && cur.patch === req.patch;
 }
 
+// src/sdk/hooks/registry.ts
+var MAX_HOOKS_PER_PLUGIN = 100;
+var HookRegistry = class {
+  hooks = [];
+  hookMap = /* @__PURE__ */ new Map();
+  rebuildMap() {
+    this.hookMap.clear();
+    for (const h2 of this.hooks) {
+      let arr = this.hookMap.get(h2.hookName);
+      if (!arr) {
+        arr = [];
+        this.hookMap.set(h2.hookName, arr);
+      }
+      arr.push(h2);
+    }
+    for (const arr of this.hookMap.values()) {
+      arr.sort((a, b) => {
+        const aPrio = a.globalPriority + a.priority;
+        const bPrio = b.globalPriority + b.priority;
+        return aPrio - bPrio;
+      });
+    }
+  }
+  register(reg) {
+    const pluginHookCount = this.hooks.filter((h2) => h2.pluginId === reg.pluginId).length;
+    if (pluginHookCount >= MAX_HOOKS_PER_PLUGIN) {
+      return false;
+    }
+    this.hooks.push({ ...reg, globalPriority: reg.globalPriority ?? 0 });
+    this.rebuildMap();
+    return true;
+  }
+  getHooks(name) {
+    return this.hookMap.get(name) ?? [];
+  }
+  hasHooks(name) {
+    return (this.hookMap.get(name)?.length ?? 0) > 0;
+  }
+  hasAnyHooks() {
+    return this.hooks.length > 0;
+  }
+  unregister(pluginId) {
+    const before = this.hooks.length;
+    this.hooks = this.hooks.filter((h2) => h2.pluginId !== pluginId);
+    this.rebuildMap();
+    return before - this.hooks.length;
+  }
+  clear() {
+    this.hooks = [];
+    this.hookMap.clear();
+  }
+};
+
 // src/agent/tools/plugin-loader.ts
 var execFileAsync = promisify(execFile);
-var log12 = createLogger("PluginLoader");
-var PLUGIN_DATA_DIR = join5(TELETON_ROOT, "plugins", "data");
-function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
+var log10 = createLogger("PluginLoader");
+var PLUGIN_DATA_DIR = join4(TELETON_ROOT, "plugins", "data");
+function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps, hookRegistry, pluginPriorities) {
   let manifest = null;
   if (raw.manifest) {
     try {
       manifest = validateManifest(raw.manifest);
     } catch (err) {
-      log12.warn(
+      log10.warn(
         `[${entryName}] invalid manifest, ignoring: ${err instanceof Error ? err.message : err}`
       );
     }
   }
   if (!manifest) {
-    const manifestPath = join5(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
+    const manifestPath = join4(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
     try {
       if (existsSync6(manifestPath)) {
         const diskManifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
@@ -9363,6 +9620,7 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
   }
   const pluginName = manifest?.name ?? entryName.replace(/\.js$/, "");
   const pluginVersion = manifest?.version ?? "0.0.0";
+  const globalPriority = pluginPriorities?.get(pluginName) ?? 0;
   if (manifest?.dependencies) {
     for (const dep of manifest.dependencies) {
       if (!loadedModuleNames.includes(dep)) {
@@ -9422,10 +9680,10 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
     },
     migrate() {
       try {
-        const dbPath = join5(PLUGIN_DATA_DIR, `${pluginName}.db`);
+        const dbPath = join4(PLUGIN_DATA_DIR, `${pluginName}.db`);
         pluginDb = openModuleDb(dbPath);
         if (hasMigrate) {
-          raw.migrate(pluginDb);
+          raw.migrate?.(pluginDb);
           const pluginTables = pluginDb.prepare(
             `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`
           ).all().map((t) => t.name).filter((n2) => n2 !== "_kv");
@@ -9453,7 +9711,10 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
             db: pluginDb,
             sanitizedConfig,
             pluginConfig,
-            botManifest: manifest?.bot
+            botManifest: manifest?.bot,
+            hookRegistry,
+            declaredHooks: manifest?.hooks,
+            globalPriority
           });
           toolDefs = raw.tools(sdk);
         } else if (Array.isArray(raw.tools)) {
@@ -9524,51 +9785,59 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
   return module;
 }
 async function ensurePluginDeps(pluginDir, pluginEntry) {
-  const pkgJson = join5(pluginDir, "package.json");
-  const lockfile = join5(pluginDir, "package-lock.json");
-  const nodeModules = join5(pluginDir, "node_modules");
+  const pkgJson = join4(pluginDir, "package.json");
+  const lockfile = join4(pluginDir, "package-lock.json");
+  const nodeModules = join4(pluginDir, "node_modules");
   if (!existsSync6(pkgJson)) return;
   if (!existsSync6(lockfile)) {
-    log12.warn(
+    log10.warn(
       `[${pluginEntry}] package.json without package-lock.json \u2014 skipping (lockfile required)`
     );
     return;
   }
   if (existsSync6(nodeModules)) {
-    const marker = join5(nodeModules, ".package-lock.json");
+    const marker = join4(nodeModules, ".package-lock.json");
     if (existsSync6(marker) && statSync(marker).mtimeMs >= statSync(lockfile).mtimeMs) return;
   }
-  log12.info(`[${pluginEntry}] Installing dependencies...`);
+  log10.info(`[${pluginEntry}] Installing dependencies...`);
   try {
     await execFileAsync("npm", ["ci", "--ignore-scripts", "--no-audit", "--no-fund"], {
       cwd: pluginDir,
       timeout: 6e4,
       env: { ...process.env, NODE_ENV: "production" }
     });
-    log12.info(`[${pluginEntry}] Dependencies installed`);
+    log10.info(`[${pluginEntry}] Dependencies installed`);
   } catch (err) {
-    log12.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
+    log10.error(`[${pluginEntry}] Failed to install deps: ${String(err).slice(0, 300)}`);
   }
 }
-async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
+async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps, db) {
+  const hookRegistry = new HookRegistry();
   const pluginsDir = WORKSPACE_PATHS.PLUGINS_DIR;
   if (!existsSync6(pluginsDir)) {
-    return [];
+    return { modules: [], hookRegistry };
+  }
+  let pluginPriorities = /* @__PURE__ */ new Map();
+  if (db) {
+    try {
+      pluginPriorities = getPluginPriorities(db);
+    } catch {
+    }
   }
-  const entries = readdirSync2(pluginsDir);
+  const entries = readdirSync2(pluginsDir).sort();
   const modules = [];
   const loadedNames = /* @__PURE__ */ new Set();
   const pluginPaths = [];
   for (const entry of entries) {
     if (entry === "data") continue;
-    const entryPath = join5(pluginsDir, entry);
+    const entryPath = join4(pluginsDir, entry);
     let modulePath = null;
     try {
       const stat = statSync(entryPath);
       if (stat.isFile() && entry.endsWith(".js")) {
         modulePath = entryPath;
       } else if (stat.isDirectory()) {
-        const indexPath = join5(entryPath, "index.js");
+        const indexPath = join4(entryPath, "index.js");
         if (existsSync6(indexPath)) {
           modulePath = indexPath;
         }
@@ -9581,7 +9850,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
     }
   }
   await Promise.allSettled(
-    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join5(pluginsDir, entry), entry))
+    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join4(pluginsDir, entry), entry))
   );
   const loadResults = await Promise.allSettled(
     pluginPaths.map(async ({ entry, path }) => {
@@ -9592,7 +9861,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
   );
   for (const result of loadResults) {
     if (result.status === "rejected") {
-      log12.error(
+      log10.error(
         `Plugin failed to load: ${result.reason instanceof Error ? result.reason.message : result.reason}`
       );
       continue;
@@ -9600,21 +9869,29 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
     const { entry, mod } = result.value;
     try {
       if (!mod.tools || typeof mod.tools !== "function" && !Array.isArray(mod.tools)) {
-        log12.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
+        log10.warn(`Plugin "${entry}": no 'tools' array or function exported, skipping`);
         continue;
       }
-      const adapted = adaptPlugin(mod, entry, config, loadedModuleNames, sdkDeps);
+      const adapted = adaptPlugin(
+        mod,
+        entry,
+        config,
+        loadedModuleNames,
+        sdkDeps,
+        hookRegistry,
+        pluginPriorities
+      );
       if (loadedNames.has(adapted.name)) {
-        log12.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
+        log10.warn(`Plugin "${adapted.name}" already loaded, skipping duplicate from "${entry}"`);
         continue;
       }
       loadedNames.add(adapted.name);
       modules.push(adapted);
     } catch (err) {
-      log12.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
+      log10.error(`Plugin "${entry}" failed to adapt: ${err instanceof Error ? err.message : err}`);
     }
   }
-  return modules;
+  return { modules, hookRegistry };
 }
 
 // src/config/configurable-keys.ts
@@ -10122,6 +10399,40 @@ var CONFIGURABLE_KEYS = {
     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",
@@ -10227,6 +10538,392 @@ function writeRawConfig(raw, configPath) {
   writeFileSync3(fullPath, stringify2(raw), { encoding: "utf-8", mode: 384 });
 }
 
+// src/ton-proxy/manager.ts
+import { spawn, execSync } from "child_process";
+import {
+  existsSync as existsSync8,
+  chmodSync,
+  createWriteStream,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync4,
+  unlinkSync
+} from "fs";
+import { mkdir } from "fs/promises";
+import { join as join5 } from "path";
+import { pipeline } from "stream/promises";
+var log11 = createLogger("TonProxy");
+var GITHUB_REPO = "xssnick/Tonutils-Proxy";
+var BINARY_DIR = join5(TELETON_ROOT, "bin");
+var PID_FILE = join5(TELETON_ROOT, "ton-proxy.pid");
+var HEALTH_CHECK_INTERVAL_MS = 3e4;
+var HEALTH_CHECK_TIMEOUT_MS = 5e3;
+var KILL_GRACE_MS = 5e3;
+var TonProxyManager = class {
+  process = null;
+  healthInterval = null;
+  config;
+  restartCount = 0;
+  maxRestarts = 3;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Resolve the binary path — user-specified or auto-detected */
+  getBinaryPath() {
+    if (this.config.binary_path) return this.config.binary_path;
+    return join5(BINARY_DIR, getBinaryName());
+  }
+  /** Check if the binary exists on disk */
+  isInstalled() {
+    return existsSync8(this.getBinaryPath());
+  }
+  /** Whether the proxy process is currently running */
+  isRunning() {
+    return this.process !== null && this.process.exitCode === null;
+  }
+  /**
+   * Download the latest CLI binary from GitHub releases.
+   * Fetches the latest release tag, then downloads the platform-appropriate binary.
+   */
+  async install() {
+    const binaryName = getBinaryName();
+    log11.info(`Downloading TON Proxy binary (${binaryName})...`);
+    await mkdir(BINARY_DIR, { recursive: true });
+    const releaseUrl = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+    const releaseRes = await fetch(releaseUrl, {
+      headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!releaseRes.ok) {
+      throw new Error(`Failed to fetch latest release: ${releaseRes.status}`);
+    }
+    const release = await releaseRes.json();
+    const tag = release.tag_name;
+    const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/${tag}/${binaryName}`;
+    log11.info(`Downloading ${downloadUrl}`);
+    const res = await fetch(downloadUrl);
+    if (!res.ok || !res.body) {
+      throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+    }
+    const dest = this.getBinaryPath();
+    const fileStream = createWriteStream(dest);
+    await pipeline(res.body, fileStream);
+    chmodSync(dest, 493);
+    log11.info(`TON Proxy installed: ${dest} (${tag})`);
+  }
+  /** Kill any orphan proxy process from a previous session */
+  killOrphan() {
+    if (existsSync8(PID_FILE)) {
+      try {
+        const pid = parseInt(readFileSync7(PID_FILE, "utf-8").trim(), 10);
+        if (pid && !isNaN(pid)) {
+          try {
+            process.kill(pid, 0);
+            log11.warn(`Killing orphan TON Proxy (PID ${pid}) from previous session`);
+            process.kill(pid, "SIGTERM");
+          } catch {
+          }
+        }
+        unlinkSync(PID_FILE);
+      } catch {
+      }
+    }
+    try {
+      const out = execSync(`ss -tlnp 2>/dev/null | grep ':${this.config.port} ' || true`, {
+        encoding: "utf-8",
+        timeout: 3e3
+      });
+      const pidMatch = out.match(/pid=(\d+)/);
+      if (pidMatch) {
+        const pid = parseInt(pidMatch[1], 10);
+        log11.warn(`Port ${this.config.port} occupied by PID ${pid}, killing it`);
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {
+        }
+        execSync("sleep 0.5");
+      }
+    } catch {
+    }
+  }
+  /** Write PID to file for orphan detection */
+  writePidFile(pid) {
+    try {
+      writeFileSync4(PID_FILE, String(pid), { mode: 384 });
+    } catch {
+      log11.warn("Failed to write TON Proxy PID file");
+    }
+  }
+  /** Remove PID file */
+  removePidFile() {
+    try {
+      if (existsSync8(PID_FILE)) unlinkSync(PID_FILE);
+    } catch {
+    }
+  }
+  /** Start the proxy process */
+  async start() {
+    if (this.isRunning()) {
+      log11.warn("TON Proxy is already running");
+      return;
+    }
+    this.restartCount = 0;
+    this.maxRestarts = 3;
+    this.killOrphan();
+    if (!this.isInstalled()) {
+      await this.install();
+    }
+    const binaryPath = this.getBinaryPath();
+    const port = String(this.config.port);
+    log11.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"],
+      detached: false
+    });
+    this.process.stdout?.on("data", (chunk) => {
+      const line = chunk.toString().trim();
+      if (line) log11.debug(`[proxy] ${line}`);
+    });
+    this.process.stderr?.on("data", (chunk) => {
+      const line = chunk.toString().trim();
+      if (line) log11.warn(`[proxy:err] ${line}`);
+    });
+    this.process.on("exit", (code, signal) => {
+      log11.info(`TON Proxy exited (code=${code}, signal=${signal})`);
+      this.process = null;
+      this.removePidFile();
+      if (code !== 0 && code !== null && this.restartCount < this.maxRestarts) {
+        this.restartCount++;
+        log11.warn(`Auto-restarting TON Proxy (attempt ${this.restartCount}/${this.maxRestarts})`);
+        this.start().catch((err) => log11.error({ err }, "Failed to auto-restart TON Proxy"));
+      }
+    });
+    this.process.on("error", (err) => {
+      log11.error({ err }, "TON Proxy process error");
+      this.process = null;
+    });
+    this.startHealthCheck();
+    await new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        if (this.isRunning()) {
+          resolve2();
+        } else {
+          reject(new Error("TON Proxy process exited immediately"));
+        }
+      }, 1e3);
+      this.process?.on("exit", () => {
+        clearTimeout(timer);
+        reject(new Error("TON Proxy process exited during startup"));
+      });
+    });
+    if (this.process?.pid) this.writePidFile(this.process.pid);
+    log11.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;
+    log11.info("Stopping TON Proxy...");
+    return new Promise((resolve2) => {
+      if (!this.process) {
+        resolve2();
+        return;
+      }
+      const forceKill = setTimeout(() => {
+        if (this.process) {
+          log11.warn("TON Proxy did not exit gracefully, sending SIGKILL");
+          this.process.kill("SIGKILL");
+        }
+      }, KILL_GRACE_MS);
+      this.process.on("exit", () => {
+        clearTimeout(forceKill);
+        this.process = null;
+        this.removePidFile();
+        resolve2();
+      });
+      this.process.kill("SIGTERM");
+    });
+  }
+  /** Remove the downloaded binary from disk */
+  async uninstall() {
+    if (this.isRunning()) {
+      await this.stop();
+    }
+    const binaryPath = this.getBinaryPath();
+    if (existsSync8(binaryPath)) {
+      const { unlink } = await import("fs/promises");
+      await unlink(binaryPath);
+      log11.info(`TON Proxy binary removed: ${binaryPath}`);
+    }
+  }
+  /** Get proxy status for WebUI / tools */
+  getStatus() {
+    return {
+      running: this.isRunning(),
+      port: this.config.port,
+      installed: this.isInstalled(),
+      pid: this.process?.pid
+    };
+  }
+  startHealthCheck() {
+    this.stopHealthCheck();
+    this.healthInterval = setInterval(() => {
+      void this.checkHealth();
+    }, HEALTH_CHECK_INTERVAL_MS);
+  }
+  stopHealthCheck() {
+    if (this.healthInterval) {
+      clearInterval(this.healthInterval);
+      this.healthInterval = null;
+    }
+  }
+  async checkHealth() {
+    if (!this.isRunning()) return;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT_MS);
+      const res = await fetch(`http://127.0.0.1:${this.config.port}/`, {
+        signal: controller.signal
+      }).catch(() => null);
+      clearTimeout(timeout);
+      if (!res) {
+        log11.warn("TON Proxy health check failed (no response)");
+      }
+    } catch {
+    }
+  }
+};
+function getBinaryName() {
+  const platform = process.platform;
+  const arch = process.arch;
+  let os;
+  switch (platform) {
+    case "linux":
+      os = "linux";
+      break;
+    case "darwin":
+      os = "darwin";
+      break;
+    case "win32":
+      os = "windows";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+  let cpuArch;
+  switch (arch) {
+    case "x64":
+      cpuArch = "amd64";
+      break;
+    case "arm64":
+      cpuArch = "arm64";
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+  const ext = platform === "win32" ? ".exe" : "";
+  return `tonutils-proxy-cli-${os}-${cpuArch}${ext}`;
+}
+
+// src/ton-proxy/tools.ts
+import { Type } from "@sinclair/typebox";
+var proxyManager = null;
+function setProxyManager(mgr) {
+  proxyManager = mgr;
+}
+var tonProxyStatusTool = {
+  name: "ton_proxy_status",
+  description: "Check the status of the TON Proxy (Tonutils-Proxy). Returns whether the proxy is running, installed, the port, and PID.",
+  parameters: Type.Object({})
+};
+var tonProxyStatusExecutor = async () => {
+  if (!proxyManager) {
+    return { success: true, data: { enabled: false, message: "TON Proxy is not configured" } };
+  }
+  return { success: true, data: proxyManager.getStatus() };
+};
+
+// src/ton-proxy/module.ts
+var log12 = createLogger("TonProxyModule");
+var manager = null;
+function getTonProxyManager() {
+  return manager;
+}
+function setTonProxyManager(mgr) {
+  manager = mgr;
+  setProxyManager(mgr);
+}
+var tonProxyModule = {
+  name: "ton-proxy",
+  version: "1.0.0",
+  tools(config) {
+    if (!config.ton_proxy?.enabled) return [];
+    return [{ tool: tonProxyStatusTool, executor: tonProxyStatusExecutor }];
+  },
+  async start(context) {
+    if (!context.config.ton_proxy?.enabled) return;
+    const proxyConfig = context.config.ton_proxy;
+    manager = new TonProxyManager({
+      enabled: proxyConfig.enabled,
+      port: proxyConfig.port,
+      binary_path: proxyConfig.binary_path
+    });
+    setProxyManager(manager);
+    try {
+      await manager.start();
+      log12.info(`TON Proxy started on port ${proxyConfig.port}`);
+    } catch (err) {
+      log12.error({ err }, "Failed to start TON Proxy");
+      manager = null;
+    }
+  },
+  async stop() {
+    if (manager) {
+      await manager.stop();
+      manager = null;
+      setProxyManager(null);
+    }
+  }
+};
+var module_default = tonProxyModule;
+
+// src/agent/hooks/user-hook-store.ts
+function getUserHookConfig(db, key) {
+  const row = db.prepare("SELECT value FROM user_hook_config WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setUserHookConfig(db, key, value) {
+  db.prepare(
+    `INSERT INTO user_hook_config (key, value, updated_at)
+     VALUES (?, ?, datetime('now'))
+     ON CONFLICT(key) DO UPDATE SET
+       value = excluded.value,
+       updated_at = excluded.updated_at`
+  ).run(key, value);
+}
+function getBlocklistConfig(db) {
+  const enabled = getUserHookConfig(db, "blocklist.enabled");
+  const keywords = getUserHookConfig(db, "blocklist.keywords");
+  const message = getUserHookConfig(db, "blocklist.message");
+  return {
+    enabled: enabled === "true",
+    keywords: keywords ? JSON.parse(keywords) : [],
+    message: message ?? ""
+  };
+}
+function setBlocklistConfig(db, config) {
+  setUserHookConfig(db, "blocklist.enabled", String(config.enabled));
+  setUserHookConfig(db, "blocklist.keywords", JSON.stringify(config.keywords));
+  setUserHookConfig(db, "blocklist.message", config.message);
+}
+function getTriggersConfig(db) {
+  const raw = getUserHookConfig(db, "triggers");
+  return raw ? JSON.parse(raw) : [];
+}
+function setTriggersConfig(db, triggers) {
+  setUserHookConfig(db, "triggers", JSON.stringify(triggers));
+}
+
 export {
   loadConfig,
   configExists,
@@ -10268,6 +10965,9 @@ export {
   toUnits,
   fromUnits,
   dexFactory,
+  getPluginPriorities,
+  setPluginPriority,
+  resetPluginPriority,
   InlineRouter,
   adaptPlugin,
   ensurePluginDeps,
@@ -10277,5 +10977,13 @@ export {
   setNestedValue,
   deleteNestedValue,
   readRawConfig,
-  writeRawConfig
+  writeRawConfig,
+  TonProxyManager,
+  getTonProxyManager,
+  setTonProxyManager,
+  module_default,
+  getBlocklistConfig,
+  setBlocklistConfig,
+  getTriggersConfig,
+  setTriggersConfig
 };