teleton 0.7.3 → 0.7.5

package/dist/{chunk-A4GCOHCE.js → chunk-G2LLMJXJ.js}

@@ -7,27 +7,75 @@ import {
   getWalletBalance,
   invalidateTonClientCache,
   loadWallet
-} from "./chunk-DAMCNMYL.js";
+} from "./chunk-AVDWXYQ7.js";
+import {
+  getOrCreateSession,
+  getSession,
+  resetSession,
+  resetSessionWithPolicy,
+  shouldResetSession,
+  updateSession
+} from "./chunk-5UVXJMOX.js";
 import {
   require_BigInteger
 } from "./chunk-TSKJCWQQ.js";
 import {
   getErrorMessage
 } from "./chunk-XBE4JB7C.js";
+import {
+  chatWithContext,
+  getEffectiveApiKey,
+  getProviderModel,
+  getUtilityModel,
+  loadContextFromTranscript
+} from "./chunk-DMXTIRUW.js";
 import {
   getProviderMetadata
-} from "./chunk-RMLQS3X6.js";
+} from "./chunk-CB2Y45HA.js";
 import {
+  appendToTranscript,
+  archiveTranscript,
+  transcriptExists
+} from "./chunk-OCLG5GKI.js";
+import {
+  ContextBuilder,
   createDbWrapper,
+  getDatabase,
   migrateFromMainDb,
   openModuleDb
-} from "./chunk-UCN6TI25.js";
+} from "./chunk-2GLHOJ5C.js";
 import {
   tonapiFetch
-} from "./chunk-XBKSS6DM.js";
+} from "./chunk-VFA7QMCZ.js";
 import {
-  PAYMENT_TOLERANCE_RATIO
-} from "./chunk-RO62LO6Z.js";
+  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,
+  COMPACTION_SOFT_THRESHOLD_RATIO,
+  CONTEXT_MAX_RECENT_MESSAGES,
+  CONTEXT_MAX_RELEVANT_CHUNKS,
+  CONTEXT_OVERFLOW_SUMMARY_MESSAGES,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_SUMMARY_TOKENS,
+  DEFAULT_MAX_TOKENS,
+  DEFAULT_SOFT_THRESHOLD_TOKENS,
+  DEFAULT_SUMMARY_FALLBACK_TOKENS,
+  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,
+  SERVER_ERROR_MAX_RETRIES,
+  SESSION_SLUG_MAX_TOKENS,
+  SESSION_SLUG_RECENT_MESSAGES,
+  TOKEN_ESTIMATE_SAFETY_MARGIN
+} from "./chunk-YP25WTQK.js";
 import {
   RETRY_BLOCKCHAIN_BASE_DELAY_MS,
   RETRY_BLOCKCHAIN_MAX_DELAY_MS,
@@ -36,7 +84,7 @@ import {
   RETRY_DEFAULT_MAX_ATTEMPTS,
   RETRY_DEFAULT_MAX_DELAY_MS,
   RETRY_DEFAULT_TIMEOUT_MS
-} from "./chunk-4DU3C27M.js";
+} from "./chunk-R4YSJ4EY.js";
 import {
   ALLOWED_EXTENSIONS,
   TELETON_ROOT,
@@ -97,7 +145,6 @@ Run 'teleton setup' to create one.`);
   }
   config.telegram.session_path = expandPath(config.telegram.session_path);
   config.storage.sessions_file = expandPath(config.storage.sessions_file);
-  config.storage.pairing_file = expandPath(config.storage.pairing_file);
   config.storage.memory_file = expandPath(config.storage.memory_file);
   if (process.env.TELETON_API_KEY) {
     config.agent.api_key = process.env.TELETON_API_KEY;
@@ -151,6 +198,9 @@ Run 'teleton setup' to create one.`);
   if (process.env.TELETON_TONAPI_KEY) {
     config.tonapi_key = process.env.TELETON_TONAPI_KEY;
   }
+  if (process.env.TELETON_TONCENTER_API_KEY) {
+    config.toncenter_api_key = process.env.TELETON_TONCENTER_API_KEY;
+  }
   return config;
 }
 function configExists(configPath = DEFAULT_CONFIG_PATH) {
@@ -574,16 +624,1379 @@ Your conversation context is approaching the limit and may be compacted soon.
   return parts.join("\n");
 }
 
+// src/constants/tools.ts
+var TELEGRAM_SEND_TOOLS = /* @__PURE__ */ new Set([
+  "telegram_send_message",
+  "telegram_send_gif",
+  "telegram_send_voice",
+  "telegram_send_sticker",
+  "telegram_send_document",
+  "telegram_send_photo",
+  "telegram_send_video",
+  "telegram_send_poll",
+  "telegram_forward_message",
+  "telegram_reply_message",
+  "deal_propose"
+]);
+
+// src/memory/envelope.ts
+function formatElapsed(elapsedMs) {
+  if (!Number.isFinite(elapsedMs) || elapsedMs < 0) {
+    return "";
+  }
+  const seconds = Math.floor(elapsedMs / 1e3);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
+}
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  const hh = String(date.getHours()).padStart(2, "0");
+  const min = String(date.getMinutes()).padStart(2, "0");
+  const tz = Intl.DateTimeFormat("en", {
+    timeZoneName: "short"
+  }).formatToParts(date).find((part) => part.type === "timeZoneName")?.value;
+  return `${yyyy}-${mm}-${dd} ${hh}:${min}${tz ? ` ${tz}` : ""}`;
+}
+function buildSenderLabel(params) {
+  const name = params.senderName ? sanitizeForPrompt(params.senderName) : void 0;
+  const username = params.senderUsername ? `@${sanitizeForPrompt(params.senderUsername)}` : void 0;
+  const idTag = params.senderId ? `id:${params.senderId}` : void 0;
+  const primary = name || username;
+  const meta = [username, idTag].filter((v) => v && v !== primary);
+  if (primary) {
+    return meta.length > 0 ? `${primary} (${meta.join(", ")})` : primary;
+  }
+  return idTag || "unknown";
+}
+function formatMessageEnvelope(params) {
+  const parts = [params.channel];
+  const senderLabel = buildSenderLabel(params);
+  if (!params.isGroup) {
+    parts.push(senderLabel);
+  }
+  if (params.previousTimestamp) {
+    const elapsed = formatElapsed(params.timestamp - params.previousTimestamp);
+    if (elapsed) {
+      parts.push(`+${elapsed}`);
+    }
+  }
+  const ts = formatTimestamp(params.timestamp);
+  parts.push(ts);
+  const header = `[${parts.join(" ")}]`;
+  const safeBody = params.body.replace(/<\/?user_message>/gi, "");
+  let body = params.isGroup ? `${senderLabel}: <user_message>${safeBody}</user_message>` : `<user_message>${safeBody}</user_message>`;
+  if (params.hasMedia && params.mediaType) {
+    const mediaEmoji = {
+      photo: "\u{1F4F7}",
+      video: "\u{1F3AC}",
+      audio: "\u{1F3B5}",
+      voice: "\u{1F3A4}",
+      document: "\u{1F4CE}",
+      sticker: "\u{1F3A8}"
+    }[params.mediaType] || "\u{1F4CE}";
+    const msgIdHint = params.messageId ? ` msg_id=${params.messageId}` : "";
+    body = `[${mediaEmoji} ${params.mediaType}${msgIdHint}] ${body}`;
+  }
+  if (params.replyContext) {
+    const sender = params.replyContext.isAgent ? "agent" : sanitizeForPrompt(params.replyContext.senderName ?? "unknown");
+    let quotedText = sanitizeForContext(params.replyContext.text);
+    if (quotedText.length > 200) quotedText = quotedText.slice(0, 200) + "...";
+    return `${header}
+[\u21A9 reply to ${sender}: "${quotedText}"]
+${body}`;
+  }
+  return `${header} ${body}`;
+}
+
+// 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-TMNTEDDD.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,
+  maxTokens: DEFAULT_MAX_TOKENS,
+  keepRecentMessages: COMPACTION_KEEP_RECENT,
+  memoryFlushEnabled: true,
+  softThresholdTokens: DEFAULT_SOFT_THRESHOLD_TOKENS
+};
+var log5 = createLogger("Memory");
+var tokenizer = null;
+function getTokenizer() {
+  if (!tokenizer) {
+    tokenizer = encodingForModel("gpt-4");
+  }
+  return tokenizer;
+}
+function estimateTokens(content) {
+  try {
+    const enc = getTokenizer();
+    return enc.encode(content).length;
+  } catch (error) {
+    log5.warn({ err: error }, "Token encoding failed, using fallback");
+    return Math.ceil(content.length / 4);
+  }
+}
+function calculateContextTokens(context) {
+  let total = 0;
+  if (context.systemPrompt) {
+    total += estimateTokens(context.systemPrompt);
+  }
+  for (const message of context.messages) {
+    if (message.role === "user") {
+      if (typeof message.content === "string") {
+        total += estimateTokens(message.content);
+      } else if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+          if (block.type === "text") total += estimateTokens(block.text);
+        }
+      }
+    } else if (message.role === "assistant") {
+      for (const block of message.content) {
+        if (block.type === "text") {
+          total += estimateTokens(block.text);
+        }
+      }
+    }
+  }
+  return total;
+}
+function shouldFlushMemory(context, config, tokenCount) {
+  if (!config.enabled || !config.memoryFlushEnabled) {
+    return false;
+  }
+  const tokens = tokenCount ?? calculateContextTokens(context);
+  const softThreshold = config.softThresholdTokens ?? FALLBACK_SOFT_THRESHOLD_TOKENS;
+  if (tokens >= softThreshold) {
+    log5.info(`Memory flush needed: ~${tokens} tokens (soft threshold: ${softThreshold})`);
+    return true;
+  }
+  return false;
+}
+function flushMemoryToDailyLog(context) {
+  const recentMessages = context.messages.slice(-MEMORY_FLUSH_RECENT_MESSAGES);
+  const summary = [];
+  summary.push("**Recent Context:**\n");
+  for (const msg of recentMessages) {
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? msg.content : "[complex content]";
+      summary.push(`- User: ${content.substring(0, 100)}${content.length > 100 ? "..." : ""}`);
+    } else if (msg.role === "assistant") {
+      const textBlocks = msg.content.filter((b) => b.type === "text");
+      if (textBlocks.length > 0) {
+        const text = textBlocks[0].text || "";
+        summary.push(`- Assistant: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`);
+      }
+    }
+  }
+  writeSummaryToDailyLog(summary.join("\n"));
+  log5.info(`Memory flushed to daily log`);
+}
+function shouldCompact(context, config, tokenCount) {
+  if (!config.enabled) {
+    return false;
+  }
+  const messageCount = context.messages.length;
+  if (config.maxMessages && messageCount >= config.maxMessages) {
+    log5.info(`Compaction needed: ${messageCount} messages (max: ${config.maxMessages})`);
+    return true;
+  }
+  if (config.maxTokens) {
+    const tokens = tokenCount ?? calculateContextTokens(context);
+    if (tokens >= config.maxTokens) {
+      log5.info(`Compaction needed: ~${tokens} tokens (max: ${config.maxTokens})`);
+      return true;
+    }
+  }
+  return false;
+}
+async function compactContext(context, config, apiKey, provider, utilityModel) {
+  const keepCount = config.keepRecentMessages ?? 10;
+  if (context.messages.length <= keepCount) {
+    return context;
+  }
+  let cutIndex = context.messages.length - keepCount;
+  const collectToolUseIds = (msgs) => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const msg of msgs) {
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "toolCall") {
+            if (block.id) ids.add(block.id);
+          }
+        }
+      }
+    }
+    return ids;
+  };
+  const hasOrphanedToolResults = (msgs) => {
+    const toolUseIds = collectToolUseIds(msgs);
+    for (const msg of msgs) {
+      if (msg.role === "toolResult") {
+        if (msg.toolCallId && !toolUseIds.has(msg.toolCallId)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  let iterations = 0;
+  while (cutIndex > 0 && iterations < 50) {
+    const keptMessages = context.messages.slice(cutIndex);
+    if (!hasOrphanedToolResults(keptMessages)) {
+      break;
+    }
+    cutIndex--;
+    iterations++;
+  }
+  if (hasOrphanedToolResults(context.messages.slice(cutIndex))) {
+    log5.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(
+    `Compacting ${oldMessages.length} old messages, keeping ${recentMessages.length} recent (cut at clean boundary)`
+  );
+  try {
+    const result = await summarizeWithFallback({
+      messages: oldMessages,
+      apiKey,
+      contextWindow: config.maxTokens ?? DEFAULT_CONTEXT_WINDOW,
+      maxSummaryTokens: DEFAULT_MAX_SUMMARY_TOKENS,
+      customInstructions: `Output a structured summary using EXACTLY these sections:
+
+## User Intent
+What the user is trying to accomplish (1-2 sentences).
+
+## Key Decisions
+Bullet list of decisions made and commitments agreed upon.
+
+## Important Context
+Critical facts, preferences, constraints, or technical details needed for continuity.
+
+## Actions Taken
+What was done: tools used, messages sent, transactions made (with specific values/addresses if relevant).
+
+## Open Items
+Unfinished tasks, pending questions, or next steps.
+
+Keep each section concise. Omit a section if empty. Preserve specific names, numbers, and identifiers.`,
+      provider,
+      utilityModel
+    });
+    log5.info(`AI Summary: ${result.tokensUsed} tokens, ${result.chunksProcessed} chunks processed`);
+    const summaryText = `[Auto-compacted ${oldMessages.length} messages]
+
+${result.summary}`;
+    const summaryMessage = {
+      role: "user",
+      content: summaryText,
+      timestamp: oldMessages[0]?.timestamp ?? Date.now()
+    };
+    return {
+      ...context,
+      messages: [summaryMessage, ...recentMessages]
+    };
+  } catch (error) {
+    log5.error({ err: error }, "AI summarization failed, using fallback");
+    const summaryText = `[Auto-compacted: ${oldMessages.length} earlier messages from this conversation]`;
+    const summaryMessage = {
+      role: "user",
+      content: summaryText,
+      timestamp: oldMessages[0]?.timestamp ?? Date.now()
+    };
+    return {
+      ...context,
+      messages: [summaryMessage, ...recentMessages]
+    };
+  }
+}
+async function compactAndSaveTranscript(sessionId, context, config, apiKey, chatId, provider, utilityModel) {
+  const newSessionId = randomUUID();
+  log5.info(`Creating compacted transcript: ${sessionId} \u2192 ${newSessionId}`);
+  if (chatId) {
+    await saveSessionMemory({
+      oldSessionId: sessionId,
+      newSessionId,
+      context,
+      chatId,
+      apiKey,
+      provider,
+      utilityModel
+    });
+  }
+  const compactedContext = await compactContext(context, config, apiKey, provider, utilityModel);
+  for (const message of compactedContext.messages) {
+    appendToTranscript(newSessionId, message);
+  }
+  return newSessionId;
+}
+var CompactionManager = class {
+  config;
+  constructor(config = DEFAULT_COMPACTION_CONFIG) {
+    this.config = config;
+  }
+  async checkAndCompact(sessionId, context, apiKey, chatId, provider, utilityModel) {
+    const tokenCount = calculateContextTokens(context);
+    if (shouldFlushMemory(context, this.config, tokenCount)) {
+      flushMemoryToDailyLog(context);
+    }
+    if (!shouldCompact(context, this.config, tokenCount)) {
+      return null;
+    }
+    if (this.config.memoryFlushEnabled) {
+      flushMemoryToDailyLog(context);
+    }
+    log5.info(`Auto-compacting session ${sessionId}`);
+    const newSessionId = await compactAndSaveTranscript(
+      sessionId,
+      context,
+      this.config,
+      apiKey,
+      chatId,
+      provider,
+      utilityModel
+    );
+    log5.info(`Compaction complete: ${newSessionId}`);
+    return newSessionId;
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/memory/observation-masking.ts
+var DEFAULT_MASKING_CONFIG = {
+  keepRecentCount: MASKING_KEEP_RECENT_COUNT,
+  keepErrorResults: true
+};
+var isCocoonToolResult = (msg) => msg.role === "user" && Array.isArray(msg.content) && msg.content.some((c) => c.type === "text" && c.text.includes("<tool_response>"));
+function maskOldToolResults(messages, config = DEFAULT_MASKING_CONFIG, toolRegistry) {
+  const toolResults = messages.map((msg, index) => ({ msg, index })).filter(({ msg }) => msg.role === "toolResult" || isCocoonToolResult(msg));
+  if (toolResults.length <= config.keepRecentCount) {
+    return messages;
+  }
+  const toMask = toolResults.slice(0, -config.keepRecentCount);
+  const result = [...messages];
+  for (const { msg, index } of toMask) {
+    if (isCocoonToolResult(msg)) {
+      result[index] = {
+        ...msg,
+        content: [{ type: "text", text: "[Tool response masked]" }]
+      };
+      continue;
+    }
+    const toolMsg = msg;
+    if (config.keepErrorResults && toolMsg.isError) {
+      continue;
+    }
+    if (toolRegistry) {
+      const category = toolRegistry.getToolCategory(toolMsg.toolName);
+      if (category === "data-bearing") {
+        continue;
+      }
+    }
+    let summaryText = "";
+    try {
+      const textBlock = toolMsg.content.find((c) => c.type === "text");
+      if (textBlock) {
+        const parsed = JSON.parse(textBlock.text);
+        if (parsed.data?.summary) {
+          summaryText = ` - ${parsed.data.summary}`;
+        } else if (parsed.data?.message) {
+          summaryText = ` - ${parsed.data.message}`;
+        }
+      }
+    } catch {
+    }
+    result[index] = {
+      ...toolMsg,
+      content: [
+        {
+          type: "text",
+          text: `[Tool: ${toolMsg.toolName} - ${toolMsg.isError ? "ERROR" : "OK"}${summaryText}]`
+        }
+      ]
+    };
+  }
+  return result;
+}
+
+// src/agent/runtime.ts
+var log6 = createLogger("Agent");
+var globalTokenUsage = { totalTokens: 0, totalCost: 0 };
+function getTokenUsage() {
+  return { ...globalTokenUsage };
+}
+function isContextOverflowError(errorMessage) {
+  if (!errorMessage) return false;
+  const lower = errorMessage.toLowerCase();
+  return lower.includes("prompt is too long") || lower.includes("context length exceeded") || lower.includes("maximum context length") || lower.includes("too many tokens") || lower.includes("request_too_large") || lower.includes("exceeds") && lower.includes("maximum") || lower.includes("context") && lower.includes("limit");
+}
+function isTrivialMessage(text) {
+  const stripped = text.trim();
+  if (!stripped) return true;
+  if (!/[a-zA-Z0-9а-яА-ЯёЁ]/.test(stripped)) return true;
+  const trivial = /^(ok|okay|k|oui|non|yes|no|yep|nope|sure|thanks|merci|thx|ty|lol|haha|cool|nice|wow|bravo|top|parfait|d'accord|alright|fine|got it|np|gg)\.?!?$/i;
+  return trivial.test(stripped);
+}
+function extractContextSummary(context, maxMessages = 10) {
+  const recentMessages = context.messages.slice(-maxMessages);
+  const summaryParts = [];
+  summaryParts.push("### Session Summary (Auto-saved before overflow reset)\n");
+  for (const msg of recentMessages) {
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? msg.content : "[complex]";
+      const bodyMatch = content.match(/\] (.+)/s);
+      const body = bodyMatch ? bodyMatch[1] : content;
+      summaryParts.push(`- **User**: ${body.substring(0, 150)}${body.length > 150 ? "..." : ""}`);
+    } else if (msg.role === "assistant") {
+      const textBlocks = msg.content.filter((b) => b.type === "text");
+      const toolBlocks = msg.content.filter((b) => b.type === "toolCall");
+      if (textBlocks.length > 0) {
+        const text = textBlocks[0].text || "";
+        summaryParts.push(
+          `- **Agent**: ${text.substring(0, 150)}${text.length > 150 ? "..." : ""}`
+        );
+      }
+      if (toolBlocks.length > 0) {
+        const toolNames = toolBlocks.map((b) => b.name).join(", ");
+        summaryParts.push(`  - *Tools used: ${toolNames}*`);
+      }
+    } else if (msg.role === "toolResult") {
+      const status = msg.isError ? "ERROR" : "OK";
+      summaryParts.push(`  - *Tool result: ${msg.toolName} \u2192 ${status}*`);
+    }
+  }
+  return summaryParts.join("\n");
+}
+var AgentRuntime = class {
+  config;
+  soul;
+  compactionManager;
+  contextBuilder = null;
+  toolRegistry = null;
+  embedder = null;
+  constructor(config, soul, toolRegistry) {
+    this.config = config;
+    this.soul = soul ?? "";
+    this.toolRegistry = toolRegistry ?? null;
+    const provider = config.agent.provider || "anthropic";
+    try {
+      const model = getProviderModel(provider, config.agent.model);
+      const ctx = model.contextWindow;
+      this.compactionManager = new CompactionManager({
+        enabled: true,
+        maxMessages: COMPACTION_MAX_MESSAGES,
+        maxTokens: Math.floor(ctx * COMPACTION_MAX_TOKENS_RATIO),
+        keepRecentMessages: COMPACTION_KEEP_RECENT,
+        memoryFlushEnabled: true,
+        softThresholdTokens: Math.floor(ctx * COMPACTION_SOFT_THRESHOLD_RATIO)
+      });
+    } catch {
+      this.compactionManager = new CompactionManager(DEFAULT_COMPACTION_CONFIG);
+    }
+  }
+  initializeContextBuilder(embedder, vectorEnabled) {
+    this.embedder = embedder;
+    const db = getDatabase().getDb();
+    this.contextBuilder = new ContextBuilder(db, embedder, vectorEnabled);
+  }
+  getToolRegistry() {
+    return this.toolRegistry;
+  }
+  async processMessage(chatId, userMessage, userName, timestamp, isGroup, pendingContext, toolContext, senderUsername, hasMedia, mediaType, messageId, replyContext) {
+    try {
+      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`);
+        if (transcriptExists(session.sessionId)) {
+          try {
+            log6.info(`\u{1F4BE} Saving memory before daily reset...`);
+            const oldContext = loadContextFromTranscript(session.sessionId);
+            await saveSessionMemory({
+              oldSessionId: session.sessionId,
+              newSessionId: "pending",
+              context: oldContext,
+              chatId,
+              apiKey: getEffectiveApiKey(this.config.agent.provider, this.config.agent.api_key),
+              provider: this.config.agent.provider,
+              utilityModel: this.config.agent.utility_model
+            });
+            log6.info(`\u2705 Memory saved before reset`);
+          } catch (error) {
+            log6.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}`);
+      } else {
+        log6.info(`\u{1F195} Starting new session: ${session.sessionId}`);
+      }
+      const previousTimestamp = session.updatedAt;
+      let formattedMessage = formatMessageEnvelope({
+        channel: "Telegram",
+        senderId: toolContext?.senderId ? String(toolContext.senderId) : chatId,
+        senderName: userName,
+        senderUsername,
+        timestamp: now,
+        previousTimestamp,
+        body: userMessage,
+        isGroup: isGroup ?? false,
+        hasMedia,
+        mediaType,
+        messageId,
+        replyContext
+      });
+      if (pendingContext) {
+        formattedMessage = `${pendingContext}
+
+${formattedMessage}`;
+        log6.debug(`\u{1F4CB} Including ${pendingContext.split("\n").length - 1} pending messages`);
+      }
+      log6.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 ? "..." : ""}"`);
+      let relevantContext = "";
+      if (this.contextBuilder && !isTrivialMessage(userMessage)) {
+        try {
+          const dbContext = await this.contextBuilder.buildContext({
+            query: userMessage,
+            chatId,
+            includeAgentMemory: true,
+            includeFeedHistory: true,
+            searchAllChats: !isGroup,
+            maxRecentMessages: CONTEXT_MAX_RECENT_MESSAGES,
+            maxRelevantChunks: CONTEXT_MAX_RELEVANT_CHUNKS
+          });
+          const contextParts = [];
+          if (dbContext.relevantKnowledge.length > 0) {
+            const sanitizedKnowledge = dbContext.relevantKnowledge.map(
+              (chunk) => sanitizeForContext(chunk)
+            );
+            contextParts.push(
+              `[Relevant knowledge from memory]
+${sanitizedKnowledge.join("\n---\n")}`
+            );
+          }
+          if (dbContext.relevantFeed.length > 0) {
+            const sanitizedFeed = dbContext.relevantFeed.map((msg) => sanitizeForContext(msg));
+            contextParts.push(
+              `[Relevant messages from Telegram feed]
+${sanitizedFeed.join("\n")}`
+            );
+          }
+          if (contextParts.length > 0) {
+            relevantContext = contextParts.join("\n\n");
+            log6.debug(
+              `\u{1F50D} Found ${dbContext.relevantKnowledge.length} knowledge chunks, ${dbContext.relevantFeed.length} feed messages`
+            );
+          }
+        } catch (error) {
+          log6.warn({ err: error }, "Context building failed");
+        }
+      }
+      const memoryStats = this.getMemoryStats();
+      const statsContext = `[Memory Status: ${memoryStats.totalMessages} messages across ${memoryStats.totalChats} chats, ${memoryStats.knowledgeChunks} knowledge chunks]`;
+      const additionalContext = relevantContext ? `You are in a Telegram conversation with chat ID: ${chatId}. Maintain conversation continuity.
+
+${statsContext}
+
+${relevantContext}` : `You are in a Telegram conversation with chat ID: ${chatId}. Maintain conversation continuity.
+
+${statsContext}`;
+      const compactionConfig = this.compactionManager.getConfig();
+      const needsMemoryFlush = compactionConfig.enabled && compactionConfig.memoryFlushEnabled && context.messages.length > Math.floor((compactionConfig.maxMessages ?? 200) * 0.75);
+      const systemPrompt = buildSystemPrompt({
+        soul: this.soul,
+        userName,
+        senderUsername,
+        senderId: toolContext?.senderId,
+        ownerName: this.config.telegram.owner_name,
+        ownerUsername: this.config.telegram.owner_username,
+        context: additionalContext,
+        includeMemory: !isGroup,
+        includeStrategy: !isGroup,
+        memoryFlushWarning: needsMemoryFlush
+      });
+      const userMsg = {
+        role: "user",
+        content: formattedMessage,
+        timestamp: now
+      };
+      context.messages.push(userMsg);
+      const preemptiveCompaction = await this.compactionManager.checkAndCompact(
+        session.sessionId,
+        context,
+        getEffectiveApiKey(this.config.agent.provider, this.config.agent.api_key),
+        chatId,
+        this.config.agent.provider,
+        this.config.agent.utility_model
+      );
+      if (preemptiveCompaction) {
+        log6.info(`\u{1F5DC}\uFE0F  Preemptive compaction triggered, reloading session...`);
+        session = getSession(chatId);
+        context = loadContextFromTranscript(session.sessionId);
+        context.messages.push(userMsg);
+      }
+      appendToTranscript(session.sessionId, userMsg);
+      const provider = this.config.agent.provider || "anthropic";
+      const providerMeta = getProviderMetadata(provider);
+      const isAdmin = toolContext?.config?.telegram.admin_ids.includes(toolContext.senderId) ?? false;
+      let tools;
+      {
+        const toolIndex = this.toolRegistry?.getToolIndex();
+        const useRAG = toolIndex?.isIndexed && this.config.tool_rag?.enabled !== false && !isTrivialMessage(userMessage) && !(providerMeta.toolLimit === null && this.config.tool_rag?.skip_unlimited_providers !== false);
+        if (useRAG && this.toolRegistry && this.embedder) {
+          const queryEmbedding = await this.embedder.embedQuery(userMessage);
+          tools = await this.toolRegistry.getForContextWithRAG(
+            userMessage,
+            queryEmbedding,
+            isGroup ?? false,
+            providerMeta.toolLimit,
+            chatId,
+            isAdmin
+          );
+          log6.info(`\u{1F50D} Tool RAG: ${tools.length}/${this.toolRegistry.count} tools selected`);
+        } else {
+          tools = this.toolRegistry?.getForContext(
+            isGroup ?? false,
+            providerMeta.toolLimit,
+            chatId,
+            isAdmin
+          );
+        }
+      }
+      const maxIterations = this.config.agent.max_agentic_iterations || 5;
+      let iteration = 0;
+      let overflowResets = 0;
+      let rateLimitRetries = 0;
+      let serverErrorRetries = 0;
+      let finalResponse = null;
+      const totalToolCalls = [];
+      const accumulatedTexts = [];
+      const accumulatedUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalCost: 0 };
+      while (iteration < maxIterations) {
+        iteration++;
+        log6.debug(`\u{1F504} Agentic iteration ${iteration}/${maxIterations}`);
+        const maskedMessages = maskOldToolResults(
+          context.messages,
+          void 0,
+          this.toolRegistry ?? void 0
+        );
+        const maskedContext = { ...context, messages: maskedMessages };
+        const response2 = await chatWithContext(this.config.agent, {
+          systemPrompt,
+          context: maskedContext,
+          sessionId: session.sessionId,
+          persistTranscript: true,
+          tools
+        });
+        const assistantMsg = response2.message;
+        if (assistantMsg.stopReason === "error") {
+          const errorMsg = assistantMsg.errorMessage || "";
+          if (isContextOverflowError(errorMsg)) {
+            overflowResets++;
+            if (overflowResets > 1) {
+              throw new Error(
+                "Context overflow persists after session reset. Message may be too large for the model's context window."
+              );
+            }
+            log6.error(`\u{1F6A8} Context overflow detected: ${errorMsg}`);
+            log6.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`);
+            const archived = archiveTranscript(session.sessionId);
+            if (!archived) {
+              log6.error(
+                `\u26A0\uFE0F  Failed to archive transcript ${session.sessionId}, proceeding with reset anyway`
+              );
+            }
+            log6.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...`);
+            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(
+                `\u{1F6AB} Rate limited, retrying in ${delay}ms (attempt ${rateLimitRetries}/${RATE_LIMIT_MAX_RETRIES})...`
+              );
+              await new Promise((r) => setTimeout(r, delay));
+              iteration--;
+              continue;
+            }
+            log6.error(`\u{1F6AB} Rate limited after ${RATE_LIMIT_MAX_RETRIES} retries: ${errorMsg}`);
+            throw new Error(
+              `API rate limited after ${RATE_LIMIT_MAX_RETRIES} retries. Please try again later.`
+            );
+          } else if (errorMsg.includes("500") || errorMsg.includes("502") || errorMsg.includes("503") || errorMsg.includes("529")) {
+            serverErrorRetries++;
+            if (serverErrorRetries <= SERVER_ERROR_MAX_RETRIES) {
+              const delay = 2e3 * Math.pow(2, serverErrorRetries - 1);
+              log6.warn(
+                `\u{1F504} Server error, retrying in ${delay}ms (attempt ${serverErrorRetries}/${SERVER_ERROR_MAX_RETRIES})...`
+              );
+              await new Promise((r) => setTimeout(r, delay));
+              iteration--;
+              continue;
+            }
+            log6.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}`);
+            throw new Error(`API error: ${errorMsg || "Unknown error"}`);
+          }
+        }
+        const iterUsage = response2.message.usage;
+        if (iterUsage) {
+          accumulatedUsage.input += iterUsage.input;
+          accumulatedUsage.output += iterUsage.output;
+          accumulatedUsage.cacheRead += iterUsage.cacheRead ?? 0;
+          accumulatedUsage.cacheWrite += iterUsage.cacheWrite ?? 0;
+          accumulatedUsage.totalCost += iterUsage.cost?.total ?? 0;
+        }
+        if (response2.text) {
+          accumulatedTexts.push(response2.text);
+        }
+        const toolCalls = response2.message.content.filter((block) => block.type === "toolCall");
+        if (toolCalls.length === 0) {
+          log6.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");
+          break;
+        }
+        log6.debug(`\u{1F527} Executing ${toolCalls.length} tool call(s)`);
+        context.messages.push(response2.message);
+        const iterationToolNames = [];
+        for (const block of toolCalls) {
+          if (block.type !== "toolCall") continue;
+          const fullContext = {
+            ...toolContext,
+            chatId,
+            isGroup: isGroup ?? false
+          };
+          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"}`);
+          totalToolCalls.push({
+            name: block.name,
+            input: block.arguments
+          });
+          let resultText = JSON.stringify(result, null, 2);
+          if (resultText.length > MAX_TOOL_RESULT_SIZE) {
+            log6.warn(`\u26A0\uFE0F Tool result too large (${resultText.length} chars), truncating...`);
+            const data = 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
+              );
+            } else {
+              resultText = resultText.slice(0, MAX_TOOL_RESULT_SIZE) + "\n...[TRUNCATED]";
+            }
+          }
+          if (provider === "cocoon") {
+            const { wrapToolResult } = await import("./tool-adapter-Y3TCEQOC.js");
+            const cocoonResultMsg = {
+              role: "user",
+              content: [
+                {
+                  type: "text",
+                  text: wrapToolResult(resultText)
+                }
+              ],
+              timestamp: Date.now()
+            };
+            context.messages.push(cocoonResultMsg);
+            appendToTranscript(session.sessionId, cocoonResultMsg);
+          } else {
+            const toolResultMsg = {
+              role: "toolResult",
+              toolCallId: block.id,
+              toolName: block.name,
+              content: [
+                {
+                  type: "text",
+                  text: resultText
+                }
+              ],
+              isError: !result.success,
+              timestamp: Date.now()
+            };
+            context.messages.push(toolResultMsg);
+            appendToTranscript(session.sessionId, toolResultMsg);
+          }
+        }
+        log6.info(`\u{1F504} ${iteration}/${maxIterations} \u2192 ${iterationToolNames.join(", ")}`);
+        if (iteration === maxIterations) {
+          log6.info(`\u26A0\uFE0F Max iterations reached (${maxIterations})`);
+          finalResponse = response2;
+        }
+      }
+      if (!finalResponse) {
+        log6.error("\u26A0\uFE0F Agentic loop exited early without final response");
+        return {
+          content: "Internal error: Agent loop failed to produce a response.",
+          toolCalls: []
+        };
+      }
+      const response = finalResponse;
+      const lastMsg = context.messages[context.messages.length - 1];
+      if (lastMsg?.role !== "assistant") {
+        context.messages.push(response.message);
+      }
+      const 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,
+        model: this.config.agent.model,
+        provider: this.config.agent.provider,
+        inputTokens: (session.inputTokens ?? 0) + accumulatedUsage.input + accumulatedUsage.cacheRead + accumulatedUsage.cacheWrite,
+        outputTokens: (session.outputTokens ?? 0) + accumulatedUsage.output
+      };
+      if (newSessionId) {
+        sessionUpdate.sessionId = newSessionId;
+      }
+      updateSession(chatId, sessionUpdate);
+      if (accumulatedUsage.input > 0 || accumulatedUsage.output > 0) {
+        const u = accumulatedUsage;
+        const totalInput = u.input + u.cacheRead + u.cacheWrite;
+        const inK = (totalInput / 1e3).toFixed(1);
+        const cacheParts = [];
+        if (u.cacheRead) cacheParts.push(`${(u.cacheRead / 1e3).toFixed(1)}K cached`);
+        if (u.cacheWrite) cacheParts.push(`${(u.cacheWrite / 1e3).toFixed(1)}K new`);
+        const cacheInfo = cacheParts.length > 0 ? ` (${cacheParts.join(", ")})` : "";
+        log6.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");
+        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");
+        content = "";
+      } else if (!content && accumulatedUsage.input === 0 && accumulatedUsage.output === 0) {
+        log6.warn("\u26A0\uFE0F Empty response with zero tokens - possible API issue");
+        content = "I couldn't process your request. Please try again.";
+      }
+      return {
+        content,
+        toolCalls: totalToolCalls
+      };
+    } catch (error) {
+      log6.error({ err: error }, "Agent error");
+      throw error;
+    }
+  }
+  clearHistory(chatId) {
+    const db = getDatabase().getDb();
+    db.prepare(
+      `DELETE FROM tg_messages_vec WHERE id IN (
+        SELECT id FROM tg_messages WHERE chat_id = ?
+      )`
+    ).run(chatId);
+    db.prepare(`DELETE FROM tg_messages WHERE chat_id = ?`).run(chatId);
+    resetSession(chatId);
+    log6.info(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
+  }
+  getConfig() {
+    return this.config;
+  }
+  getActiveChatIds() {
+    const db = getDatabase().getDb();
+    const rows = db.prepare(
+      `
+      SELECT DISTINCT chat_id
+      FROM tg_messages
+      ORDER BY timestamp DESC
+    `
+    ).all();
+    return rows.map((r) => r.chat_id);
+  }
+  setSoul(soul) {
+    this.soul = soul;
+  }
+  configureCompaction(config) {
+    this.compactionManager.updateConfig(config);
+    log6.info({ config: this.compactionManager.getConfig() }, `\u{1F5DC}\uFE0F  Compaction config updated`);
+  }
+  getCompactionConfig() {
+    return this.compactionManager.getConfig();
+  }
+  _memoryStatsCache = null;
+  getMemoryStats() {
+    const now = Date.now();
+    if (this._memoryStatsCache && now < this._memoryStatsCache.expiry) {
+      return this._memoryStatsCache.data;
+    }
+    const db = getDatabase().getDb();
+    const msgCount = db.prepare(`SELECT COUNT(*) as count FROM tg_messages`).get();
+    const chatCount = db.prepare(`SELECT COUNT(DISTINCT chat_id) as count FROM tg_messages`).get();
+    const knowledgeCount = db.prepare(`SELECT COUNT(*) as count FROM knowledge`).get();
+    const data = {
+      totalMessages: msgCount.count,
+      totalChats: chatCount.count,
+      knowledgeChunks: knowledgeCount.count
+    };
+    this._memoryStatsCache = { data, expiry: now + 5 * 60 * 1e3 };
+    return data;
+  }
+};
+
 // src/agent/tools/plugin-loader.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync5, existsSync as existsSync6, statSync } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { pathToFileURL } from "url";
 import { execFile } from "child_process";
 import { promisify } from "util";
 
 // src/agent/tools/plugin-validator.ts
 import { z } from "zod";
-var log3 = createLogger("PluginValidator");
+var log7 = createLogger("PluginValidator");
 var ManifestSchema = z.object({
   name: z.string().min(1).max(64).regex(
     /^[a-z0-9][a-z0-9-]*$/,
@@ -611,20 +2024,20 @@ function validateToolDefs(defs, pluginName) {
   const valid = [];
   for (const def of defs) {
     if (!def || typeof def !== "object") {
-      log3.warn(`[${pluginName}] tool is not an object, skipping`);
+      log7.warn(`[${pluginName}] tool is not an object, skipping`);
       continue;
     }
     const t = def;
     if (!t.name || typeof t.name !== "string") {
-      log3.warn(`[${pluginName}] tool missing 'name', skipping`);
+      log7.warn(`[${pluginName}] tool missing 'name', skipping`);
       continue;
     }
     if (!t.description || typeof t.description !== "string") {
-      log3.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
+      log7.warn(`[${pluginName}] tool "${t.name}" missing 'description', skipping`);
       continue;
     }
     if (!t.execute || typeof t.execute !== "function") {
-      log3.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
+      log7.warn(`[${pluginName}] tool "${t.name}" missing 'execute' function, skipping`);
       continue;
     }
     valid.push(t);
@@ -673,25 +2086,25 @@ function withTxLock(fn) {
 }
 
 // src/ton/transfer.ts
-var log4 = createLogger("TON");
+var log8 = createLogger("TON");
 async function sendTon(params) {
   return withTxLock(async () => {
     try {
       const { toAddress, amount, comment = "", bounce = false } = params;
       if (!Number.isFinite(amount) || amount <= 0) {
-        log4.error({ amount }, "Invalid transfer amount");
+        log8.error({ amount }, "Invalid transfer amount");
         return null;
       }
       let recipientAddress;
       try {
         recipientAddress = Address.parse(toAddress);
       } catch (e) {
-        log4.error({ err: e }, `Invalid recipient address: ${toAddress}`);
+        log8.error({ err: e }, `Invalid recipient address: ${toAddress}`);
         return null;
       }
       const keyPair = await getKeyPair();
       if (!keyPair) {
-        log4.error("Wallet not initialized");
+        log8.error("Wallet not initialized");
         return null;
       }
       const wallet = WalletContractV5R1.create({
@@ -715,20 +2128,21 @@ async function sendTon(params) {
         ]
       });
       const pseudoHash = `${seqno}_${Date.now()}_${amount.toFixed(2)}`;
-      log4.info(`Sent ${amount} TON to ${toAddress.slice(0, 8)}... - seqno: ${seqno}`);
+      log8.info(`Sent ${amount} TON to ${toAddress.slice(0, 8)}... - seqno: ${seqno}`);
       return pseudoHash;
     } catch (error) {
-      if (error?.status >= 500 || error?.response?.status >= 500) {
+      const status = error?.status || error?.response?.status;
+      if (status === 429 || status >= 500) {
         invalidateTonClientCache();
       }
-      log4.error({ err: error }, "Error sending TON");
+      log8.error({ err: error }, "Error sending TON");
       throw error;
     }
   });
 }
 
 // src/utils/retry.ts
-var log5 = createLogger("Utils");
+var log9 = createLogger("Utils");
 var DEFAULT_OPTIONS = {
   maxAttempts: RETRY_DEFAULT_MAX_ATTEMPTS,
   baseDelayMs: RETRY_DEFAULT_BASE_DELAY_MS,
@@ -752,7 +2166,7 @@ async function withRetry(fn, options = {}) {
       return result;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
-      log5.warn(`Retry attempt ${attempt}/${opts.maxAttempts} failed: ${lastError.message}`);
+      log9.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);
@@ -951,25 +2365,25 @@ function findJettonBalance(balances, jettonAddress) {
     }
   });
 }
-function cleanupOldTransactions(db, retentionDays, log7) {
+function cleanupOldTransactions(db, retentionDays, log11) {
   if (Math.random() > CLEANUP_PROBABILITY) return;
   try {
     const cutoff = Math.floor(Date.now() / 1e3) - retentionDays * 24 * 60 * 60;
     const result = db.prepare("DELETE FROM used_transactions WHERE used_at < ?").run(cutoff);
     if (result.changes > 0) {
-      log7.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
+      log11.debug(`Cleaned up ${result.changes} old transaction records (>${retentionDays}d)`);
     }
   } catch (err) {
-    log7.error("Transaction cleanup failed:", err);
+    log11.error("Transaction cleanup failed:", err);
   }
 }
-function createTonSDK(log7, db) {
+function createTonSDK(log11, db) {
   return {
     getAddress() {
       try {
         return getWalletAddress();
       } catch (err) {
-        log7.error("ton.getAddress() failed:", err);
+        log11.error("ton.getAddress() failed:", err);
         return null;
       }
     },
@@ -979,7 +2393,7 @@ function createTonSDK(log7, db) {
         if (!addr) return null;
         return await getWalletBalance(addr);
       } catch (err) {
-        log7.error("ton.getBalance() failed:", err);
+        log11.error("ton.getBalance() failed:", err);
         return null;
       }
     },
@@ -987,7 +2401,7 @@ function createTonSDK(log7, db) {
       try {
         return await getTonPrice();
       } catch (err) {
-        log7.error("ton.getPrice() failed:", err);
+        log11.error("ton.getPrice() failed:", err);
         return null;
       }
     },
@@ -1038,7 +2452,7 @@ function createTonSDK(log7, db) {
         );
         return formatTransactions(transactions);
       } catch (err) {
-        log7.error("ton.getTransactions() failed:", err);
+        log11.error("ton.getTransactions() failed:", err);
         return [];
       }
     },
@@ -1054,7 +2468,7 @@ function createTonSDK(log7, db) {
         throw new PluginSDKError("Wallet not initialized", "WALLET_NOT_INITIALIZED");
       }
       const maxAgeMinutes = params.maxAgeMinutes ?? DEFAULT_MAX_AGE_MINUTES;
-      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log7);
+      cleanupOldTransactions(db, DEFAULT_TX_RETENTION_DAYS, log11);
       try {
         const txs = await this.getTransactions(address, 20);
         for (const tx of txs) {
@@ -1088,7 +2502,7 @@ function createTonSDK(log7, db) {
         };
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log7.error("ton.verifyPayment() failed:", err);
+        log11.error("ton.verifyPayment() failed:", err);
         return {
           verified: false,
           error: `Verification failed: ${err instanceof Error ? err.message : String(err)}`
@@ -1102,7 +2516,7 @@ function createTonSDK(log7, db) {
         if (!addr) return [];
         const response = await tonapiFetch(`/accounts/${encodeURIComponent(addr)}/jettons`);
         if (!response.ok) {
-          log7.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
+          log11.error(`ton.getJettonBalances() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
@@ -1130,7 +2544,7 @@ function createTonSDK(log7, db) {
         }
         return balances;
       } catch (err) {
-        log7.error("ton.getJettonBalances() failed:", err);
+        log11.error("ton.getJettonBalances() failed:", err);
         return [];
       }
     },
@@ -1139,7 +2553,7 @@ function createTonSDK(log7, db) {
         const response = await tonapiFetch(`/jettons/${encodeURIComponent(jettonAddress)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log7.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
+          log11.error(`ton.getJettonInfo() TonAPI error: ${response.status}`);
           return null;
         }
         const data = await response.json();
@@ -1157,7 +2571,7 @@ function createTonSDK(log7, db) {
           image: data.preview || metadata.image || void 0
         };
       } catch (err) {
-        log7.error("ton.getJettonInfo() failed:", err);
+        log11.error("ton.getJettonInfo() failed:", err);
         return null;
       }
     },
@@ -1251,14 +2665,14 @@ function createTonSDK(log7, db) {
       try {
         const response = await tonapiFetch(`/accounts/${encodeURIComponent(ownerAddress)}/jettons`);
         if (!response.ok) {
-          log7.error(`ton.getJettonWalletAddress() TonAPI error: ${response.status}`);
+          log11.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) {
-        log7.error("ton.getJettonWalletAddress() failed:", err);
+        log11.error("ton.getJettonWalletAddress() failed:", err);
         return null;
       }
     },
@@ -1271,14 +2685,14 @@ function createTonSDK(log7, db) {
           `/accounts/${encodeURIComponent(addr)}/nfts?limit=100&indirect_ownership=true`
         );
         if (!response.ok) {
-          log7.error(`ton.getNftItems() TonAPI error: ${response.status}`);
+          log11.error(`ton.getNftItems() TonAPI error: ${response.status}`);
           return [];
         }
         const data = await response.json();
         if (!Array.isArray(data.nft_items)) return [];
         return data.nft_items.filter((item) => item.trust !== "blacklist").map((item) => mapNftItem(item));
       } catch (err) {
-        log7.error("ton.getNftItems() failed:", err);
+        log11.error("ton.getNftItems() failed:", err);
         return [];
       }
     },
@@ -1287,13 +2701,13 @@ function createTonSDK(log7, db) {
         const response = await tonapiFetch(`/nfts/${encodeURIComponent(nftAddress)}`);
         if (response.status === 404) return null;
         if (!response.ok) {
-          log7.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
+          log11.error(`ton.getNftInfo() TonAPI error: ${response.status}`);
           return null;
         }
         const item = await response.json();
         return mapNftItem(item);
       } catch (err) {
-        log7.error("ton.getNftInfo() failed:", err);
+        log11.error("ton.getNftInfo() failed:", err);
         return null;
       }
     },
@@ -1350,7 +2764,7 @@ function randomLong() {
 }
 
 // src/sdk/telegram-messages.ts
-function createTelegramMessagesSDK(bridge, log7) {
+function createTelegramMessagesSDK(bridge, log11) {
   function requireBridge() {
     if (!bridge.isAvailable()) {
       throw new PluginSDKError(
@@ -1470,7 +2884,7 @@ function createTelegramMessagesSDK(bridge, log7) {
         return (resultData.messages ?? []).map(toSimpleMessage);
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log7.error("telegram.searchMessages() failed:", err);
+        log11.error("telegram.searchMessages() failed:", err);
         return [];
       }
     },
@@ -1695,7 +3109,7 @@ function createTelegramMessagesSDK(bridge, log7) {
 }
 
 // src/sdk/telegram-social.ts
-function createTelegramSocialSDK(bridge, log7) {
+function createTelegramSocialSDK(bridge, log11) {
   function requireBridge() {
     if (!bridge.isAvailable()) {
       throw new PluginSDKError(
@@ -1775,7 +3189,7 @@ function createTelegramSocialSDK(bridge, log7) {
         return null;
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log7.error("telegram.getChatInfo() failed:", err);
+        log11.error("telegram.getChatInfo() failed:", err);
         return null;
       }
     },
@@ -1884,7 +3298,7 @@ function createTelegramSocialSDK(bridge, log7) {
         });
       } catch (err) {
         if (err instanceof PluginSDKError) throw err;
-        log7.error("telegram.getParticipants() failed:", err);
+        log11.error("telegram.getParticipants() failed:", err);
         return [];
       }
     },
@@ -2098,7 +3512,7 @@ function createTelegramSocialSDK(bridge, log7) {
       try {
         const client = getClient();
         const { Api } = await import("telegram");
-        const user = await client.getEntity(userId.toString());
+        const user = await client.getInputEntity(userId.toString());
         const invoiceData = {
           peer: user,
           giftId: BigInt(giftId),
@@ -2183,12 +3597,6 @@ function createTelegramSocialSDK(bridge, log7) {
       try {
         const client = getClient();
         const { Api } = await import("telegram");
-        if (!Api.payments.GetResaleStarGifts) {
-          throw new PluginSDKError(
-            "Resale gift marketplace is not supported in the current Telegram API layer.",
-            "OPERATION_FAILED"
-          );
-        }
         const result = await client.invoke(
           new Api.payments.GetResaleStarGifts({
             offset: "",
@@ -2212,25 +3620,16 @@ function createTelegramSocialSDK(bridge, log7) {
       try {
         const client = getClient();
         const { Api } = await import("telegram");
-        if (!Api.InputInvoiceStarGiftResale) {
-          throw new PluginSDKError(
-            "Resale gift purchasing is not supported in the current Telegram API layer.",
-            "OPERATION_FAILED"
-          );
-        }
-        const stargiftInput = new Api.InputSavedStarGiftUser({
-          odayId: BigInt(giftId)
+        const toId = new Api.InputPeerSelf();
+        const invoice = new Api.InputInvoiceStarGiftResale({
+          slug: giftId,
+          toId
         });
-        const invoiceData = { stargift: stargiftInput };
-        const form = await client.invoke(
-          new Api.payments.GetPaymentForm({
-            invoice: new Api.InputInvoiceStarGiftResale(invoiceData)
-          })
-        );
+        const form = await client.invoke(new Api.payments.GetPaymentForm({ invoice }));
         await client.invoke(
           new Api.payments.SendStarsForm({
             formId: form.formId,
-            invoice: new Api.InputInvoiceStarGiftResale(invoiceData)
+            invoice
           })
         );
       } catch (err) {
@@ -2323,7 +3722,7 @@ function createTelegramSocialSDK(bridge, log7) {
 }
 
 // src/sdk/telegram.ts
-function createTelegramSDK(bridge, log7) {
+function createTelegramSDK(bridge, log11) {
   function requireBridge() {
     if (!bridge.isAvailable()) {
       throw new PluginSDKError(
@@ -2433,7 +3832,7 @@ function createTelegramSDK(bridge, log7) {
           timestamp: m.timestamp
         }));
       } catch (err) {
-        log7.error("telegram.getMessages() failed:", err);
+        log11.error("telegram.getMessages() failed:", err);
         return [];
       }
     },
@@ -2455,7 +3854,7 @@ function createTelegramSDK(bridge, log7) {
       return bridge.isAvailable();
     },
     getRawClient() {
-      log7.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
+      log11.warn("getRawClient() called \u2014 this bypasses SDK sandbox guarantees");
       if (!bridge.isAvailable()) return null;
       try {
         return bridge.getClient().getClient();
@@ -2464,17 +3863,17 @@ function createTelegramSDK(bridge, log7) {
       }
     },
     // Spread extended methods from sub-modules
-    ...createTelegramMessagesSDK(bridge, log7),
-    ...createTelegramSocialSDK(bridge, log7)
+    ...createTelegramMessagesSDK(bridge, log11),
+    ...createTelegramSocialSDK(bridge, log11)
   };
 }
 
 // src/sdk/secrets.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
-import { join as join3 } from "path";
-var SECRETS_DIR = join3(TELETON_ROOT, "plugins", "data");
+import { join as join4 } from "path";
+var SECRETS_DIR = join4(TELETON_ROOT, "plugins", "data");
 function getSecretsPath(pluginName) {
-  return join3(SECRETS_DIR, `${pluginName}.secrets.json`);
+  return join4(SECRETS_DIR, `${pluginName}.secrets.json`);
 }
 function readSecretsFile(pluginName) {
   const filePath = getSecretsPath(pluginName);
@@ -2506,23 +3905,23 @@ function deletePluginSecret(pluginName, key) {
 function listPluginSecretKeys(pluginName) {
   return Object.keys(readSecretsFile(pluginName));
 }
-function createSecretsSDK(pluginName, pluginConfig, log7) {
+function createSecretsSDK(pluginName, pluginConfig, log11) {
   const envPrefix = pluginName.replace(/-/g, "_").toUpperCase();
   function get(key) {
     const envKey = `${envPrefix}_${key.toUpperCase()}`;
     const envValue = process.env[envKey];
     if (envValue) {
-      log7.debug(`Secret "${key}" resolved from env var ${envKey}`);
+      log11.debug(`Secret "${key}" resolved from env var ${envKey}`);
       return envValue;
     }
     const stored = readSecretsFile(pluginName);
     if (key in stored && stored[key]) {
-      log7.debug(`Secret "${key}" resolved from secrets store`);
+      log11.debug(`Secret "${key}" resolved from secrets store`);
       return stored[key];
     }
     const configValue = pluginConfig[key];
     if (configValue !== void 0 && configValue !== null) {
-      log7.debug(`Secret "${key}" resolved from pluginConfig`);
+      log11.debug(`Secret "${key}" resolved from pluginConfig`);
       return String(configValue);
     }
     return void 0;
@@ -2641,13 +4040,13 @@ function createSafeDb(db) {
   });
 }
 function createPluginSDK(deps, opts) {
-  const log7 = createLogger2(opts.pluginName);
+  const log11 = createLogger2(opts.pluginName);
   const safeDb = opts.db ? createSafeDb(opts.db) : null;
-  const ton = Object.freeze(createTonSDK(log7, safeDb));
-  const telegram = Object.freeze(createTelegramSDK(deps.bridge, log7));
-  const secrets = Object.freeze(createSecretsSDK(opts.pluginName, opts.pluginConfig, log7));
+  const ton = Object.freeze(createTonSDK(log11, safeDb));
+  const telegram = Object.freeze(createTelegramSDK(deps.bridge, log11));
+  const secrets = Object.freeze(createSecretsSDK(opts.pluginName, opts.pluginConfig, log11));
   const storage = safeDb ? Object.freeze(createStorageSDK(safeDb)) : null;
-  const frozenLog = Object.freeze(log7);
+  const frozenLog = Object.freeze(log11);
   const frozenConfig = Object.freeze(opts.sanitizedConfig);
   const frozenPluginConfig = Object.freeze(JSON.parse(JSON.stringify(opts.pluginConfig ?? {})));
   return Object.freeze({
@@ -2720,21 +4119,21 @@ function semverSatisfies(current, range) {
 
 // src/agent/tools/plugin-loader.ts
 var execFileAsync = promisify(execFile);
-var log6 = createLogger("PluginLoader");
-var PLUGIN_DATA_DIR = join4(TELETON_ROOT, "plugins", "data");
+var log10 = createLogger("PluginLoader");
+var PLUGIN_DATA_DIR = join5(TELETON_ROOT, "plugins", "data");
 function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
   let manifest = null;
   if (raw.manifest) {
     try {
       manifest = validateManifest(raw.manifest);
     } catch (err) {
-      log6.warn(
+      log10.warn(
         `[${entryName}] invalid manifest, ignoring: ${err instanceof Error ? err.message : err}`
       );
     }
   }
   if (!manifest) {
-    const manifestPath = join4(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
+    const manifestPath = join5(WORKSPACE_PATHS.PLUGINS_DIR, entryName, "manifest.json");
     try {
       if (existsSync6(manifestPath)) {
         const diskManifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
@@ -2811,7 +4210,7 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
     },
     migrate() {
       try {
-        const dbPath = join4(PLUGIN_DATA_DIR, `${pluginName}.db`);
+        const dbPath = join5(PLUGIN_DATA_DIR, `${pluginName}.db`);
         pluginDb = openModuleDb(dbPath);
         if (hasMigrate) {
           raw.migrate(pluginDb);
@@ -2912,30 +4311,30 @@ function adaptPlugin(raw, entryName, config, loadedModuleNames, sdkDeps) {
   return module;
 }
 async function ensurePluginDeps(pluginDir, pluginEntry) {
-  const pkgJson = join4(pluginDir, "package.json");
-  const lockfile = join4(pluginDir, "package-lock.json");
-  const nodeModules = join4(pluginDir, "node_modules");
+  const pkgJson = join5(pluginDir, "package.json");
+  const lockfile = join5(pluginDir, "package-lock.json");
+  const nodeModules = join5(pluginDir, "node_modules");
   if (!existsSync6(pkgJson)) return;
   if (!existsSync6(lockfile)) {
-    log6.warn(
+    log10.warn(
       `[${pluginEntry}] package.json without package-lock.json \u2014 skipping (lockfile required)`
     );
     return;
   }
   if (existsSync6(nodeModules)) {
-    const marker = join4(nodeModules, ".package-lock.json");
+    const marker = join5(nodeModules, ".package-lock.json");
     if (existsSync6(marker) && statSync(marker).mtimeMs >= statSync(lockfile).mtimeMs) return;
   }
-  log6.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" }
     });
-    log6.info(`[${pluginEntry}] Dependencies installed`);
+    log10.info(`[${pluginEntry}] Dependencies installed`);
   } catch (err) {
-    log6.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) {
@@ -2949,14 +4348,14 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
   const pluginPaths = [];
   for (const entry of entries) {
     if (entry === "data") continue;
-    const entryPath = join4(pluginsDir, entry);
+    const entryPath = join5(pluginsDir, entry);
     let modulePath = null;
     try {
       const stat = statSync(entryPath);
       if (stat.isFile() && entry.endsWith(".js")) {
         modulePath = entryPath;
       } else if (stat.isDirectory()) {
-        const indexPath = join4(entryPath, "index.js");
+        const indexPath = join5(entryPath, "index.js");
         if (existsSync6(indexPath)) {
           modulePath = indexPath;
         }
@@ -2969,7 +4368,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
     }
   }
   await Promise.allSettled(
-    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join4(pluginsDir, entry), entry))
+    pluginPaths.filter(({ path }) => path.endsWith("index.js")).map(({ entry }) => ensurePluginDeps(join5(pluginsDir, entry), entry))
   );
   const loadResults = await Promise.allSettled(
     pluginPaths.map(async ({ entry, path }) => {
@@ -2980,7 +4379,7 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
   );
   for (const result of loadResults) {
     if (result.status === "rejected") {
-      log6.error(
+      log10.error(
         `Plugin failed to load: ${result.reason instanceof Error ? result.reason.message : result.reason}`
       );
       continue;
@@ -2988,18 +4387,18 @@ async function loadEnhancedPlugins(config, loadedModuleNames, sdkDeps) {
     const { entry, mod } = result.value;
     try {
       if (!mod.tools || typeof mod.tools !== "function" && !Array.isArray(mod.tools)) {
-        log6.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);
       if (loadedNames.has(adapted.name)) {
-        log6.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) {
-      log6.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;
@@ -3022,13 +4421,25 @@ function numberInRange(min, max) {
 function enumValidator(options) {
   return (v) => options.includes(v) ? void 0 : `Must be one of: ${options.join(", ")}`;
 }
+function positiveInteger(v) {
+  const n = Number(v);
+  if (!Number.isInteger(n) || n <= 0) return "Must be a positive integer";
+  return void 0;
+}
+function validateUrl(v) {
+  if (v === "") return void 0;
+  if (v.startsWith("http://") || v.startsWith("https://")) return void 0;
+  return "Must be empty or start with http:// or https://";
+}
 var CONFIGURABLE_KEYS = {
   // ─── API Keys ──────────────────────────────────────────────────────
   "agent.api_key": {
     type: "string",
     category: "API Keys",
+    label: "LLM API Key",
     description: "LLM provider API key",
     sensitive: true,
+    hotReload: "instant",
     validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
     mask: (v) => v.slice(0, 8) + "****",
     parse: identity
@@ -3036,8 +4447,10 @@ var CONFIGURABLE_KEYS = {
   tavily_api_key: {
     type: "string",
     category: "API Keys",
+    label: "Tavily API Key",
     description: "Tavily API key for web search",
     sensitive: true,
+    hotReload: "instant",
     validate: (v) => v.startsWith("tvly-") ? void 0 : "Must start with 'tvly-'",
     mask: (v) => v.slice(0, 9) + "****",
     parse: identity
@@ -3045,8 +4458,21 @@ var CONFIGURABLE_KEYS = {
   tonapi_key: {
     type: "string",
     category: "API Keys",
+    label: "TonAPI Key",
     description: "TonAPI key for higher rate limits",
     sensitive: true,
+    hotReload: "instant",
+    validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
+    mask: (v) => v.slice(0, 10) + "****",
+    parse: identity
+  },
+  toncenter_api_key: {
+    type: "string",
+    category: "API Keys",
+    label: "TonCenter API Key",
+    description: "TonCenter API key for dedicated RPC endpoint (free at toncenter.com)",
+    sensitive: true,
+    hotReload: "instant",
     validate: (v) => v.length >= 10 ? void 0 : "Must be at least 10 characters",
     mask: (v) => v.slice(0, 10) + "****",
     parse: identity
@@ -3054,8 +4480,10 @@ var CONFIGURABLE_KEYS = {
   "telegram.bot_token": {
     type: "string",
     category: "API Keys",
+    label: "Bot Token",
     description: "Bot token from @BotFather",
     sensitive: true,
+    hotReload: "instant",
     validate: (v) => v.includes(":") ? void 0 : "Must contain ':' (e.g., 123456:ABC...)",
     mask: (v) => v.split(":")[0] + ":****",
     parse: identity
@@ -3064,8 +4492,10 @@ var CONFIGURABLE_KEYS = {
   "agent.provider": {
     type: "enum",
     category: "Agent",
+    label: "Provider",
     description: "LLM provider",
     sensitive: false,
+    hotReload: "instant",
     options: [
       "anthropic",
       "claude-code",
@@ -3098,8 +4528,10 @@ var CONFIGURABLE_KEYS = {
   "agent.model": {
     type: "string",
     category: "Agent",
+    label: "Model",
     description: "Main LLM model ID",
     sensitive: false,
+    hotReload: "instant",
     validate: nonEmpty,
     mask: identity,
     parse: identity
@@ -3107,8 +4539,10 @@ var CONFIGURABLE_KEYS = {
   "agent.utility_model": {
     type: "string",
     category: "Agent",
+    label: "Utility Model",
     description: "Cheap model for summarization (auto-detected if empty)",
     sensitive: false,
+    hotReload: "instant",
     validate: noValidation,
     mask: identity,
     parse: identity
@@ -3116,8 +4550,10 @@ var CONFIGURABLE_KEYS = {
   "agent.temperature": {
     type: "number",
     category: "Agent",
+    label: "Temperature",
     description: "Response creativity (0.0 = deterministic, 2.0 = max)",
     sensitive: false,
+    hotReload: "instant",
     validate: numberInRange(0, 2),
     mask: identity,
     parse: (v) => Number(v)
@@ -3125,8 +4561,10 @@ var CONFIGURABLE_KEYS = {
   "agent.max_tokens": {
     type: "number",
     category: "Agent",
+    label: "Max Tokens",
     description: "Maximum response length in tokens",
     sensitive: false,
+    hotReload: "instant",
     validate: numberInRange(256, 128e3),
     mask: identity,
     parse: (v) => Number(v)
@@ -3134,18 +4572,44 @@ var CONFIGURABLE_KEYS = {
   "agent.max_agentic_iterations": {
     type: "number",
     category: "Agent",
+    label: "Max Iterations",
     description: "Max tool-call loop iterations per message",
     sensitive: false,
+    hotReload: "instant",
     validate: numberInRange(1, 20),
     mask: identity,
     parse: (v) => Number(v)
   },
+  "agent.base_url": {
+    type: "string",
+    category: "Agent",
+    label: "API Base URL",
+    description: "Base URL for local LLM server (requires restart)",
+    sensitive: false,
+    hotReload: "restart",
+    validate: validateUrl,
+    mask: identity,
+    parse: identity
+  },
+  "cocoon.port": {
+    type: "number",
+    category: "Agent",
+    label: "Cocoon Port",
+    description: "Cocoon proxy port (requires restart)",
+    sensitive: false,
+    hotReload: "restart",
+    validate: numberInRange(1, 65535),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
   // ─── Session ───────────────────────────────────────────────────
   "agent.session_reset_policy.daily_reset_enabled": {
     type: "boolean",
     category: "Session",
+    label: "Daily Reset",
     description: "Enable daily session reset at specified hour",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
@@ -3153,8 +4617,10 @@ var CONFIGURABLE_KEYS = {
   "agent.session_reset_policy.daily_reset_hour": {
     type: "number",
     category: "Session",
+    label: "Reset Hour",
     description: "Hour (0-23 UTC) for daily session reset",
     sensitive: false,
+    hotReload: "instant",
     validate: numberInRange(0, 23),
     mask: identity,
     parse: (v) => Number(v)
@@ -3162,8 +4628,10 @@ var CONFIGURABLE_KEYS = {
   "agent.session_reset_policy.idle_expiry_enabled": {
     type: "boolean",
     category: "Session",
+    label: "Idle Expiry",
     description: "Enable automatic session expiry after idle period",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
@@ -3171,8 +4639,10 @@ var CONFIGURABLE_KEYS = {
   "agent.session_reset_policy.idle_expiry_minutes": {
     type: "number",
     category: "Session",
+    label: "Idle Minutes",
     description: "Idle minutes before session expires (minimum 1)",
     sensitive: false,
+    hotReload: "instant",
     validate: numberInRange(1, Number.MAX_SAFE_INTEGER),
     mask: identity,
     parse: (v) => Number(v)
@@ -3181,8 +4651,10 @@ var CONFIGURABLE_KEYS = {
   "telegram.bot_username": {
     type: "string",
     category: "Telegram",
+    label: "Bot Username",
     description: "Bot username without @",
     sensitive: false,
+    hotReload: "instant",
     validate: (v) => v.length >= 3 ? void 0 : "Must be at least 3 characters",
     mask: identity,
     parse: identity
@@ -3190,28 +4662,46 @@ var CONFIGURABLE_KEYS = {
   "telegram.dm_policy": {
     type: "enum",
     category: "Telegram",
-    description: "DM access policy",
+    label: "DM Policy",
+    description: "Who can message the bot in private",
     sensitive: false,
-    options: ["pairing", "allowlist", "open", "disabled"],
-    validate: enumValidator(["pairing", "allowlist", "open", "disabled"]),
+    hotReload: "instant",
+    options: ["admin-only", "allowlist", "open", "disabled"],
+    optionLabels: {
+      "admin-only": "Admin Only",
+      allowlist: "Allow Users",
+      open: "Open",
+      disabled: "Disabled"
+    },
+    validate: enumValidator(["open", "allowlist", "admin-only", "disabled"]),
     mask: identity,
     parse: identity
   },
   "telegram.group_policy": {
     type: "enum",
     category: "Telegram",
-    description: "Group access policy",
+    label: "Group Policy",
+    description: "Which groups the bot can respond in",
     sensitive: false,
-    options: ["open", "allowlist", "disabled"],
-    validate: enumValidator(["open", "allowlist", "disabled"]),
+    hotReload: "instant",
+    options: ["open", "allowlist", "admin-only", "disabled"],
+    optionLabels: {
+      open: "Open",
+      allowlist: "Allow Groups",
+      "admin-only": "Admin Only",
+      disabled: "Disabled"
+    },
+    validate: enumValidator(["open", "allowlist", "admin-only", "disabled"]),
     mask: identity,
     parse: identity
   },
   "telegram.require_mention": {
     type: "boolean",
     category: "Telegram",
+    label: "Require Mention",
     description: "Require @mention in groups to respond",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
@@ -3219,8 +4709,10 @@ var CONFIGURABLE_KEYS = {
   "telegram.owner_name": {
     type: "string",
     category: "Telegram",
+    label: "Owner Name",
     description: "Owner's first name (used in system prompt)",
     sensitive: false,
+    hotReload: "instant",
     validate: noValidation,
     mask: identity,
     parse: identity
@@ -3228,8 +4720,10 @@ var CONFIGURABLE_KEYS = {
   "telegram.owner_username": {
     type: "string",
     category: "Telegram",
+    label: "Owner Username",
     description: "Owner's Telegram username (without @)",
     sensitive: false,
+    hotReload: "instant",
     validate: noValidation,
     mask: identity,
     parse: identity
@@ -3237,8 +4731,10 @@ var CONFIGURABLE_KEYS = {
   "telegram.debounce_ms": {
     type: "number",
     category: "Telegram",
+    label: "Debounce (ms)",
     description: "Group message debounce delay in ms (0 = disabled)",
     sensitive: false,
+    hotReload: "instant",
     validate: numberInRange(0, 1e4),
     mask: identity,
     parse: (v) => Number(v)
@@ -3246,8 +4742,10 @@ var CONFIGURABLE_KEYS = {
   "telegram.agent_channel": {
     type: "string",
     category: "Telegram",
+    label: "Agent Channel",
     description: "Channel username for auto-publishing",
     sensitive: false,
+    hotReload: "instant",
     validate: noValidation,
     mask: identity,
     parse: identity
@@ -3255,29 +4753,126 @@ var CONFIGURABLE_KEYS = {
   "telegram.typing_simulation": {
     type: "boolean",
     category: "Telegram",
+    label: "Typing Simulation",
     description: "Simulate typing indicator before sending replies",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
   },
+  "telegram.owner_id": {
+    type: "number",
+    category: "Telegram",
+    label: "Admin ID",
+    description: "Primary admin Telegram user ID (auto-added to Admin IDs)",
+    sensitive: false,
+    hotReload: "instant",
+    validate: positiveInteger,
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.max_message_length": {
+    type: "number",
+    category: "Telegram",
+    label: "Max Message Length",
+    description: "Maximum message length in characters",
+    sensitive: false,
+    hotReload: "instant",
+    validate: numberInRange(1, 32768),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.rate_limit_messages_per_second": {
+    type: "number",
+    category: "Telegram",
+    label: "Rate Limit \u2014 Messages/sec",
+    description: "Rate limit: messages per second (requires restart)",
+    sensitive: false,
+    hotReload: "restart",
+    validate: numberInRange(0.1, 10),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.rate_limit_groups_per_minute": {
+    type: "number",
+    category: "Telegram",
+    label: "Rate Limit \u2014 Groups/min",
+    description: "Rate limit: groups per minute (requires restart)",
+    sensitive: false,
+    hotReload: "restart",
+    validate: numberInRange(1, 60),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.admin_ids": {
+    type: "array",
+    itemType: "number",
+    category: "Telegram",
+    label: "Admin IDs",
+    description: "Admin user IDs with elevated access",
+    sensitive: false,
+    hotReload: "instant",
+    validate: positiveInteger,
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.allow_from": {
+    type: "array",
+    itemType: "number",
+    category: "Telegram",
+    label: "Allowed Users",
+    description: "User IDs allowed for DM access",
+    sensitive: false,
+    hotReload: "instant",
+    validate: positiveInteger,
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "telegram.group_allow_from": {
+    type: "array",
+    itemType: "number",
+    category: "Telegram",
+    label: "Allowed Groups",
+    description: "Group IDs allowed for group access",
+    sensitive: false,
+    hotReload: "instant",
+    validate: positiveInteger,
+    mask: identity,
+    parse: (v) => Number(v)
+  },
   // ─── Embedding ─────────────────────────────────────────────────────
   "embedding.provider": {
     type: "enum",
     category: "Embedding",
+    label: "Embedding Provider",
     description: "Embedding provider for RAG",
     sensitive: false,
+    hotReload: "instant",
     options: ["local", "anthropic", "none"],
     validate: enumValidator(["local", "anthropic", "none"]),
     mask: identity,
     parse: identity
   },
+  "embedding.model": {
+    type: "string",
+    category: "Embedding",
+    label: "Embedding Model",
+    description: "Embedding model ID (requires restart)",
+    sensitive: false,
+    hotReload: "restart",
+    validate: noValidation,
+    mask: identity,
+    parse: identity
+  },
   // ─── WebUI ─────────────────────────────────────────────────────────
   "webui.port": {
     type: "number",
     category: "WebUI",
+    label: "WebUI Port",
     description: "HTTP server port (requires restart)",
     sensitive: false,
+    hotReload: "restart",
     validate: numberInRange(1024, 65535),
     mask: identity,
     parse: (v) => Number(v)
@@ -3285,8 +4880,10 @@ var CONFIGURABLE_KEYS = {
   "webui.log_requests": {
     type: "boolean",
     category: "WebUI",
+    label: "Log HTTP Requests",
     description: "Log all HTTP requests to console",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
@@ -3295,18 +4892,55 @@ var CONFIGURABLE_KEYS = {
   "deals.enabled": {
     type: "boolean",
     category: "Deals",
+    label: "Deals Enabled",
     description: "Enable the deals/escrow module",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
   },
+  "deals.expiry_seconds": {
+    type: "number",
+    category: "Deals",
+    label: "Deal Expiry",
+    description: "Deal expiry timeout in seconds",
+    sensitive: false,
+    hotReload: "instant",
+    validate: numberInRange(10, 3600),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "deals.buy_max_floor_percent": {
+    type: "number",
+    category: "Deals",
+    label: "Buy Max Floor %",
+    description: "Maximum floor % for buy deals",
+    sensitive: false,
+    hotReload: "instant",
+    validate: numberInRange(1, 100),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
+  "deals.sell_min_floor_percent": {
+    type: "number",
+    category: "Deals",
+    label: "Sell Min Floor %",
+    description: "Minimum floor % for sell deals",
+    sensitive: false,
+    hotReload: "instant",
+    validate: numberInRange(100, 500),
+    mask: identity,
+    parse: (v) => Number(v)
+  },
   // ─── Developer ─────────────────────────────────────────────────────
   "dev.hot_reload": {
     type: "boolean",
     category: "Developer",
+    label: "Hot Reload",
     description: "Watch ~/.teleton/plugins/ for live changes",
     sensitive: false,
+    hotReload: "instant",
     validate: enumValidator(["true", "false"]),
     mask: identity,
     parse: (v) => v === "true"
@@ -3386,19 +5020,20 @@ export {
   validateReadPath,
   validateWritePath,
   validateDirectory,
-  appendToDailyLog,
-  writeSummaryToDailyLog,
   sanitizeForPrompt,
   sanitizeForContext,
   clearPromptCache,
   loadSoul,
-  buildSystemPrompt,
+  TELEGRAM_SEND_TOOLS,
+  getTokenUsage,
+  AgentRuntime,
   writePluginSecret,
   deletePluginSecret,
   listPluginSecretKeys,
   toLong,
   randomLong,
   withBlockchainRetry,
+  withTxLock,
   sendTon,
   formatTransactions,
   adaptPlugin,