teleton 0.1.19 → 0.1.20

package/dist/chunk-OQGNS2FV.js

@@ -0,0 +1,184 @@
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+
+// src/session/transcript.ts
+import {
+  appendFileSync,
+  readFileSync,
+  existsSync,
+  mkdirSync,
+  unlinkSync,
+  renameSync,
+  readdirSync,
+  statSync
+} from "fs";
+import { join } from "path";
+var SESSIONS_DIR = join(TELETON_ROOT, "sessions");
+function getTranscriptPath(sessionId) {
+  return join(SESSIONS_DIR, `${sessionId}.jsonl`);
+}
+function ensureSessionsDir() {
+  if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+function appendToTranscript(sessionId, message) {
+  ensureSessionsDir();
+  const transcriptPath = getTranscriptPath(sessionId);
+  const line = JSON.stringify(message) + "\n";
+  try {
+    appendFileSync(transcriptPath, line, "utf-8");
+  } catch (error) {
+    console.error(`Failed to append to transcript ${sessionId}:`, error);
+  }
+}
+function extractToolCallIds(msg) {
+  const ids = /* @__PURE__ */ new Set();
+  if (msg.role === "assistant" && Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      const blockType = block.type;
+      if (blockType === "toolCall" || blockType === "tool_use") {
+        const id = block.id || block.toolCallId || block.tool_use_id;
+        if (id) ids.add(id);
+      }
+    }
+  }
+  return ids;
+}
+function sanitizeMessages(messages) {
+  const sanitized = [];
+  let pendingToolCallIds = /* @__PURE__ */ new Set();
+  let removedCount = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role === "assistant") {
+      const newToolIds = extractToolCallIds(msg);
+      if (pendingToolCallIds.size > 0 && newToolIds.size > 0) {
+        console.warn(
+          `\u26A0\uFE0F Found ${pendingToolCallIds.size} pending tool results that were never received`
+        );
+      }
+      pendingToolCallIds = newToolIds;
+      sanitized.push(msg);
+    } else if (msg.role === "toolResult" || msg.role === "tool_result") {
+      const toolCallId = msg.toolCallId || msg.tool_use_id || msg.tool_call_id;
+      if (toolCallId && pendingToolCallIds.has(toolCallId)) {
+        pendingToolCallIds.delete(toolCallId);
+        sanitized.push(msg);
+      } else {
+        removedCount++;
+        console.warn(
+          `\u{1F9F9} Removing out-of-order/orphaned toolResult: ${toolCallId?.slice(0, 20)}...`
+        );
+        continue;
+      }
+    } else if (msg.role === "user") {
+      if (pendingToolCallIds.size > 0) {
+        console.warn(
+          `\u26A0\uFE0F User message arrived while ${pendingToolCallIds.size} tool results pending - marking them as orphaned`
+        );
+        pendingToolCallIds.clear();
+      }
+      sanitized.push(msg);
+    } else {
+      sanitized.push(msg);
+    }
+  }
+  if (removedCount > 0) {
+    console.log(`\u{1F9F9} Sanitized ${removedCount} orphaned/out-of-order toolResult(s) from transcript`);
+  }
+  return sanitized;
+}
+function readTranscript(sessionId) {
+  const transcriptPath = getTranscriptPath(sessionId);
+  if (!existsSync(transcriptPath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(transcriptPath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    const messages = lines.map((line) => JSON.parse(line));
+    return sanitizeMessages(messages);
+  } catch (error) {
+    console.error(`Failed to read transcript ${sessionId}:`, error);
+    return [];
+  }
+}
+function transcriptExists(sessionId) {
+  return existsSync(getTranscriptPath(sessionId));
+}
+function getTranscriptSize(sessionId) {
+  try {
+    const messages = readTranscript(sessionId);
+    return messages.length;
+  } catch {
+    return 0;
+  }
+}
+function deleteTranscript(sessionId) {
+  const transcriptPath = getTranscriptPath(sessionId);
+  if (!existsSync(transcriptPath)) {
+    return false;
+  }
+  try {
+    unlinkSync(transcriptPath);
+    console.log(`\u{1F5D1}\uFE0F Deleted transcript: ${sessionId}`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to delete transcript ${sessionId}:`, error);
+    return false;
+  }
+}
+function archiveTranscript(sessionId) {
+  const transcriptPath = getTranscriptPath(sessionId);
+  const timestamp = Date.now();
+  const archivePath = `${transcriptPath}.${timestamp}.archived`;
+  if (!existsSync(transcriptPath)) {
+    return false;
+  }
+  try {
+    renameSync(transcriptPath, archivePath);
+    console.log(`\u{1F4E6} Archived transcript: ${sessionId} \u2192 ${timestamp}.archived`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to archive transcript ${sessionId}:`, error);
+    return false;
+  }
+}
+function cleanupOldTranscripts(maxAgeDays = 30) {
+  if (!existsSync(SESSIONS_DIR)) return 0;
+  const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+  let deleted = 0;
+  try {
+    for (const file of readdirSync(SESSIONS_DIR)) {
+      if (!file.endsWith(".jsonl") && !file.endsWith(".archived")) continue;
+      const filePath = join(SESSIONS_DIR, file);
+      try {
+        const mtime = statSync(filePath).mtimeMs;
+        if (mtime < cutoff) {
+          unlinkSync(filePath);
+          deleted++;
+        }
+      } catch {
+      }
+    }
+  } catch (error) {
+    console.error("Failed to cleanup old transcripts:", error);
+  }
+  if (deleted > 0) {
+    console.log(`\u{1F9F9} Cleaned up ${deleted} transcript(s) older than ${maxAgeDays} days`);
+  }
+  return deleted;
+}
+
+export {
+  getTranscriptPath,
+  appendToTranscript,
+  readTranscript,
+  transcriptExists,
+  getTranscriptSize,
+  deleteTranscript,
+  archiveTranscript,
+  cleanupOldTranscripts
+};

package/dist/{chunk-ABHUNKXQ.js → chunk-Y4G7HSOQ.js}

@@ -1,3 +1,19 @@
+import {
+  Mi,
+  Mn,
+  br,
+  dt,
+  le,
+  qn,
+  ut,
+  ye
+} from "./chunk-U7FQYCBQ.js";
+import {
+  appendToTranscript,
+  archiveTranscript,
+  readTranscript,
+  transcriptExists
+} from "./chunk-OQGNS2FV.js";
 import {
   ChatStore,
   ContextBuilder,
@@ -62,16 +78,6 @@ import {
   telegramGetMyGiftsExecutor,
   telegramGetMyGiftsTool
 } from "./chunk-B2PRMXOH.js";
-import {
-  Mi,
-  Mn,
-  br,
-  dt,
-  le,
-  qn,
-  ut,
-  ye
-} from "./chunk-U7FQYCBQ.js";
 import {
   __commonJS,
   __toESM
@@ -2044,122 +2050,6 @@ import {
   complete,
   getModel
 } from "@mariozechner/pi-ai";
-
-// src/session/transcript.ts
-import { appendFileSync as appendFileSync2, readFileSync as readFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync4, unlinkSync, renameSync } from "fs";
-import { join as join4 } from "path";
-var SESSIONS_DIR = join4(TELETON_ROOT, "sessions");
-function getTranscriptPath(sessionId) {
-  return join4(SESSIONS_DIR, `${sessionId}.jsonl`);
-}
-function ensureSessionsDir() {
-  if (!existsSync6(SESSIONS_DIR)) {
-    mkdirSync4(SESSIONS_DIR, { recursive: true });
-  }
-}
-function appendToTranscript(sessionId, message) {
-  ensureSessionsDir();
-  const transcriptPath = getTranscriptPath(sessionId);
-  const line = JSON.stringify(message) + "\n";
-  try {
-    appendFileSync2(transcriptPath, line, "utf-8");
-  } catch (error) {
-    console.error(`Failed to append to transcript ${sessionId}:`, error);
-  }
-}
-function extractToolCallIds(msg) {
-  const ids = /* @__PURE__ */ new Set();
-  if (msg.role === "assistant" && Array.isArray(msg.content)) {
-    for (const block of msg.content) {
-      const blockType = block.type;
-      if (blockType === "toolCall" || blockType === "tool_use") {
-        const id = block.id || block.toolCallId || block.tool_use_id;
-        if (id) ids.add(id);
-      }
-    }
-  }
-  return ids;
-}
-function sanitizeMessages(messages) {
-  const sanitized = [];
-  let pendingToolCallIds = /* @__PURE__ */ new Set();
-  let removedCount = 0;
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === "assistant") {
-      const newToolIds = extractToolCallIds(msg);
-      if (pendingToolCallIds.size > 0 && newToolIds.size > 0) {
-        console.warn(
-          `\u26A0\uFE0F Found ${pendingToolCallIds.size} pending tool results that were never received`
-        );
-      }
-      pendingToolCallIds = newToolIds;
-      sanitized.push(msg);
-    } else if (msg.role === "toolResult" || msg.role === "tool_result") {
-      const toolCallId = msg.toolCallId || msg.tool_use_id || msg.tool_call_id;
-      if (toolCallId && pendingToolCallIds.has(toolCallId)) {
-        pendingToolCallIds.delete(toolCallId);
-        sanitized.push(msg);
-      } else {
-        removedCount++;
-        console.warn(
-          `\u{1F9F9} Removing out-of-order/orphaned toolResult: ${toolCallId?.slice(0, 20)}...`
-        );
-        continue;
-      }
-    } else if (msg.role === "user") {
-      if (pendingToolCallIds.size > 0) {
-        console.warn(
-          `\u26A0\uFE0F User message arrived while ${pendingToolCallIds.size} tool results pending - marking them as orphaned`
-        );
-        pendingToolCallIds.clear();
-      }
-      sanitized.push(msg);
-    } else {
-      sanitized.push(msg);
-    }
-  }
-  if (removedCount > 0) {
-    console.log(`\u{1F9F9} Sanitized ${removedCount} orphaned/out-of-order toolResult(s) from transcript`);
-  }
-  return sanitized;
-}
-function readTranscript(sessionId) {
-  const transcriptPath = getTranscriptPath(sessionId);
-  if (!existsSync6(transcriptPath)) {
-    return [];
-  }
-  try {
-    const content = readFileSync5(transcriptPath, "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-    const messages = lines.map((line) => JSON.parse(line));
-    return sanitizeMessages(messages);
-  } catch (error) {
-    console.error(`Failed to read transcript ${sessionId}:`, error);
-    return [];
-  }
-}
-function transcriptExists(sessionId) {
-  return existsSync6(getTranscriptPath(sessionId));
-}
-function archiveTranscript(sessionId) {
-  const transcriptPath = getTranscriptPath(sessionId);
-  const timestamp = Date.now();
-  const archivePath = `${transcriptPath}.${timestamp}.archived`;
-  if (!existsSync6(transcriptPath)) {
-    return false;
-  }
-  try {
-    renameSync(transcriptPath, archivePath);
-    console.log(`\u{1F4E6} Archived transcript: ${sessionId} \u2192 ${timestamp}.archived`);
-    return true;
-  } catch (error) {
-    console.error(`Failed to archive transcript ${sessionId}:`, error);
-    return false;
-  }
-}
-
-// src/agent/client.ts
 var modelCache = /* @__PURE__ */ new Map();
 function getProviderModel(provider, modelId) {
   const cacheKey = `${provider}:${modelId}`;
@@ -2789,7 +2679,7 @@ ${oversizedNotes.join("\n")}` : "";
 
 // src/session/memory-hook.ts
 import { writeFile, mkdir } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 import { complete as complete3 } from "@mariozechner/pi-ai";
 async function generateSlugViaClaude(params) {
   const provider = params.provider || "anthropic";
@@ -2830,7 +2720,7 @@ Slug:`,
 async function saveSessionMemory(params) {
   try {
     const { TELETON_ROOT: TELETON_ROOT2 } = await import("./paths-TMNTEDDD.js");
-    const memoryDir = join5(TELETON_ROOT2, "memory");
+    const memoryDir = join4(TELETON_ROOT2, "memory");
     await mkdir(memoryDir, { recursive: true });
     const now = /* @__PURE__ */ new Date();
     const dateStr = now.toISOString().split("T")[0];
@@ -2842,7 +2732,7 @@ async function saveSessionMemory(params) {
       utilityModel: params.utilityModel
     });
     const filename = `${dateStr}-${slug}.md`;
-    const filepath = join5(memoryDir, filename);
+    const filepath = join4(memoryDir, filename);
     const timeStr = now.toISOString().split("T")[1].split(".")[0];
     console.log("\u{1F4DD} Generating session summary...");
     let summary;
@@ -3722,8 +3612,8 @@ import { TelegramClient, Api } from "telegram";
 import { Logger, LogLevel } from "telegram/extensions/Logger.js";
 import { StringSession } from "telegram/sessions/index.js";
 import { NewMessage } from "telegram/events/index.js";
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync5, chmodSync } from "fs";
-import { dirname as dirname4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, chmodSync } from "fs";
+import { dirname as dirname3 } from "path";
 import { createInterface } from "readline";
 
 // src/telegram/formatting.ts
@@ -3821,8 +3711,8 @@ var TelegramUserClient = class {
    */
   loadSession() {
     try {
-      if (existsSync7(this.config.sessionPath)) {
-        return readFileSync6(this.config.sessionPath, "utf-8").trim();
+      if (existsSync6(this.config.sessionPath)) {
+        return readFileSync5(this.config.sessionPath, "utf-8").trim();
       }
     } catch (error) {
       console.warn("Failed to load session:", error);
@@ -3839,9 +3729,9 @@ var TelegramUserClient = class {
         console.warn("No session string to save");
         return;
       }
-      const dir = dirname4(this.config.sessionPath);
-      if (!existsSync7(dir)) {
-        mkdirSync5(dir, { recursive: true });
+      const dir = dirname3(this.config.sessionPath);
+      if (!existsSync6(dir)) {
+        mkdirSync4(dir, { recursive: true });
       }
       writeFileSync3(this.config.sessionPath, sessionString, { encoding: "utf-8" });
       chmodSync(this.config.sessionPath, 384);
@@ -3859,7 +3749,7 @@ var TelegramUserClient = class {
       return;
     }
     try {
-      const hasSession = existsSync7(this.config.sessionPath);
+      const hasSession = existsSync6(this.config.sessionPath);
       if (hasSession) {
         await this.client.connect();
       } else {
@@ -4352,20 +4242,20 @@ var TelegramBridge = class {
 };
 
 // src/telegram/offset-store.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname5 } from "path";
-import { join as join6 } from "path";
-var OFFSET_FILE = join6(TELETON_ROOT, "telegram-offset.json");
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname4 } from "path";
+import { join as join5 } from "path";
+var OFFSET_FILE = join5(TELETON_ROOT, "telegram-offset.json");
 var STORE_VERSION = 2;
 var offsetCache = null;
 function loadState() {
   if (offsetCache) return offsetCache;
   try {
-    if (!existsSync8(OFFSET_FILE)) {
+    if (!existsSync7(OFFSET_FILE)) {
       offsetCache = { version: STORE_VERSION, perChat: {} };
       return offsetCache;
     }
-    const raw = readFileSync7(OFFSET_FILE, "utf-8");
+    const raw = readFileSync6(OFFSET_FILE, "utf-8");
     const state = JSON.parse(raw);
     if (state.version === 1 || !state.perChat) {
       offsetCache = { version: STORE_VERSION, perChat: {} };
@@ -4381,9 +4271,9 @@ function loadState() {
 }
 function saveState(state) {
   try {
-    const dir = dirname5(OFFSET_FILE);
-    if (!existsSync8(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    const dir = dirname4(OFFSET_FILE);
+    if (!existsSync7(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
     writeFileSync4(OFFSET_FILE, JSON.stringify(state, null, 2), "utf-8");
     offsetCache = state;
@@ -4838,10 +4728,10 @@ var MessageHandler = class {
 // src/ton/wallet-service.ts
 import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
 import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync7, chmodSync as chmodSync2 } from "fs";
-import { join as join7, dirname as dirname6 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync6, chmodSync as chmodSync2 } from "fs";
+import { join as join6, dirname as dirname5 } from "path";
 import { getHttpEndpoint } from "@orbs-network/ton-access";
-var WALLET_FILE = join7(TELETON_ROOT, "wallet.json");
+var WALLET_FILE = join6(TELETON_ROOT, "wallet.json");
 async function generateWallet() {
   const mnemonic = await mnemonicNew(24);
   const keyPair = await mnemonicToPrivateKey(mnemonic);
@@ -4859,19 +4749,19 @@ async function generateWallet() {
   };
 }
 function saveWallet(wallet) {
-  const dir = dirname6(WALLET_FILE);
-  if (!existsSync9(dir)) {
-    mkdirSync7(dir, { recursive: true });
+  const dir = dirname5(WALLET_FILE);
+  if (!existsSync8(dir)) {
+    mkdirSync6(dir, { recursive: true });
   }
   writeFileSync5(WALLET_FILE, JSON.stringify(wallet, null, 2), "utf-8");
   chmodSync2(WALLET_FILE, 384);
 }
 function loadWallet() {
-  if (!existsSync9(WALLET_FILE)) {
+  if (!existsSync8(WALLET_FILE)) {
     return null;
   }
   try {
-    const content = readFileSync8(WALLET_FILE, "utf-8");
+    const content = readFileSync7(WALLET_FILE, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.error("Failed to load wallet:", error);
@@ -4879,7 +4769,7 @@ function loadWallet() {
   }
 }
 function walletExists() {
-  return existsSync9(WALLET_FILE);
+  return existsSync8(WALLET_FILE);
 }
 async function importWallet(mnemonic) {
   const valid = await mnemonicValidate(mnemonic);
@@ -4921,14 +4811,20 @@ async function getWalletBalance(address4) {
     return null;
   }
 }
+var TON_PRICE_CACHE_TTL_MS = 3e4;
+var _tonPriceCache = null;
 async function getTonPrice() {
+  if (_tonPriceCache && Date.now() - _tonPriceCache.timestamp < TON_PRICE_CACHE_TTL_MS) {
+    return { ..._tonPriceCache };
+  }
   try {
     const response = await tonapiFetch(`/rates?tokens=ton&currencies=usd`);
     if (response.ok) {
       const data = await response.json();
       const price = data?.rates?.TON?.prices?.USD;
       if (typeof price === "number" && price > 0) {
-        return { usd: price, source: "TonAPI", timestamp: Date.now() };
+        _tonPriceCache = { usd: price, source: "TonAPI", timestamp: Date.now() };
+        return _tonPriceCache;
       }
     }
   } catch {
@@ -4943,7 +4839,8 @@ async function getTonPrice() {
     const data = await response.json();
     const price = data["the-open-network"]?.usd;
     if (typeof price === "number" && price > 0) {
-      return { usd: price, source: "CoinGecko", timestamp: Date.now() };
+      _tonPriceCache = { usd: price, source: "CoinGecko", timestamp: Date.now() };
+      return _tonPriceCache;
     }
   } catch (error) {
     console.error("Failed to get TON price:", error);
@@ -5445,8 +5342,8 @@ var MessageDebouncer = class {
 
 // src/market/db.ts
 import Database from "better-sqlite3";
-import { join as join8 } from "path";
-var DB_PATH = join8(TELETON_ROOT, "gifts.db");
+import { join as join7 } from "path";
+var DB_PATH = join7(TELETON_ROOT, "gifts.db");
 function getDb2() {
   const db = new Database(DB_PATH);
   db.pragma("journal_mode = WAL");
@@ -5765,7 +5662,7 @@ var MarketPriceService = class {
 };
 
 // src/index.ts
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 
 // src/agent/tools/registry.ts
 import { validateToolCall } from "@mariozechner/pi-ai";
@@ -6554,16 +6451,16 @@ var telegramSendPhotoExecutor = async (params, context) => {
 // src/agent/tools/telegram/media/send-voice.ts
 import { Type as Type11 } from "@sinclair/typebox";
 import { Api as Api10 } from "telegram";
-import { unlinkSync as unlinkSync3 } from "fs";
+import { unlinkSync as unlinkSync2 } from "fs";
 
 // src/services/tts.ts
 import { spawn } from "child_process";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync8, existsSync as existsSync10, unlinkSync as unlinkSync2 } from "fs";
-import { join as join9 } from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, existsSync as existsSync9, unlinkSync } from "fs";
+import { join as join8 } from "path";
 import { tmpdir } from "os";
 import { randomUUID as randomUUID3 } from "crypto";
-var PIPER_VOICES_DIR = join9(TELETON_ROOT, "piper-voices");
-var PIPER_VENV = join9(TELETON_ROOT, "rvc-env");
+var PIPER_VOICES_DIR = join8(TELETON_ROOT, "piper-voices");
+var PIPER_VENV = join8(TELETON_ROOT, "rvc-env");
 var PIPER_VOICES = {
   trump: "en_US-trump-high.onnx",
   // Trump voice (default) ⭐
@@ -6657,21 +6554,21 @@ async function generateSpeech(options) {
   }
 }
 async function generatePiperTTS(text, voice) {
-  const tempDir = join9(tmpdir(), "tonnet-tts");
-  if (!existsSync10(tempDir)) {
-    mkdirSync8(tempDir, { recursive: true });
+  const tempDir = join8(tmpdir(), "tonnet-tts");
+  if (!existsSync9(tempDir)) {
+    mkdirSync7(tempDir, { recursive: true });
   }
   const id = randomUUID3();
-  const wavPath = join9(tempDir, `${id}.wav`);
-  const oggPath = join9(tempDir, `${id}.ogg`);
+  const wavPath = join8(tempDir, `${id}.wav`);
+  const oggPath = join8(tempDir, `${id}.ogg`);
   const modelFile = PIPER_VOICES[voice.toLowerCase()] ?? voice;
-  const modelPath = modelFile.includes("/") ? modelFile : join9(PIPER_VOICES_DIR, modelFile);
-  if (!existsSync10(modelPath)) {
+  const modelPath = modelFile.includes("/") ? modelFile : join8(PIPER_VOICES_DIR, modelFile);
+  if (!existsSync9(modelPath)) {
     throw new Error(
       `Piper voice not found: ${modelPath}. Available: ${Object.keys(PIPER_VOICES).join(", ")}`
     );
   }
-  const piperBin = join9(PIPER_VENV, "bin", "piper");
+  const piperBin = join8(PIPER_VENV, "bin", "piper");
   await new Promise((resolve2, reject) => {
     const proc = spawn(
       piperBin,
@@ -6695,7 +6592,7 @@ async function generatePiperTTS(text, voice) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      if (code === 0 && existsSync10(wavPath)) {
+      if (code === 0 && existsSync9(wavPath)) {
         resolve2();
       } else {
         reject(new Error(`Piper TTS failed (code ${code}): ${stderr}`));
@@ -6734,7 +6631,7 @@ async function generatePiperTTS(text, voice) {
         reject(new Error(`ffmpeg spawn error: ${err.message}`));
       });
     });
-    unlinkSync2(wavPath);
+    unlinkSync(wavPath);
   } catch (err) {
     return {
       filePath: wavPath,
@@ -6749,11 +6646,11 @@ async function generatePiperTTS(text, voice) {
   };
 }
 async function generateEdgeTTS(text, voice, rate, pitch) {
-  const tempDir = join9(tmpdir(), "tonnet-tts");
-  if (!existsSync10(tempDir)) {
-    mkdirSync8(tempDir, { recursive: true });
+  const tempDir = join8(tmpdir(), "tonnet-tts");
+  if (!existsSync9(tempDir)) {
+    mkdirSync7(tempDir, { recursive: true });
   }
-  const outputPath = join9(tempDir, `${randomUUID3()}.mp3`);
+  const outputPath = join8(tempDir, `${randomUUID3()}.mp3`);
   const args = ["--text", text, "--voice", voice, "--write-media", outputPath];
   if (rate) {
     args.push("--rate", rate);
@@ -6790,11 +6687,11 @@ async function generateOpenAITTS(text, voice) {
   if (!apiKey) {
     throw new Error("OPENAI_API_KEY not set. Use Edge TTS (free) or set API key.");
   }
-  const tempDir = join9(tmpdir(), "tonnet-tts");
-  if (!existsSync10(tempDir)) {
-    mkdirSync8(tempDir, { recursive: true });
+  const tempDir = join8(tmpdir(), "tonnet-tts");
+  if (!existsSync9(tempDir)) {
+    mkdirSync7(tempDir, { recursive: true });
   }
-  const outputPath = join9(tempDir, `${randomUUID3()}.mp3`);
+  const outputPath = join8(tempDir, `${randomUUID3()}.mp3`);
   const response = await fetchWithTimeout(OPENAI_TTS_URL, {
     method: "POST",
     headers: {
@@ -6827,11 +6724,11 @@ async function generateElevenLabsTTS(text, voiceId) {
   if (!apiKey) {
     throw new Error("ELEVENLABS_API_KEY not set. Use Edge TTS (free) or set API key.");
   }
-  const tempDir = join9(tmpdir(), "tonnet-tts");
-  if (!existsSync10(tempDir)) {
-    mkdirSync8(tempDir, { recursive: true });
+  const tempDir = join8(tmpdir(), "tonnet-tts");
+  if (!existsSync9(tempDir)) {
+    mkdirSync7(tempDir, { recursive: true });
   }
-  const outputPath = join9(tempDir, `${randomUUID3()}.mp3`);
+  const outputPath = join8(tempDir, `${randomUUID3()}.mp3`);
   const response = await fetchWithTimeout(`${ELEVENLABS_TTS_URL}/${voiceId}`, {
     method: "POST",
     headers: {
@@ -7043,7 +6940,7 @@ var telegramSendVoiceExecutor = async (params, context) => {
   } finally {
     if (generatedFile) {
       try {
-        unlinkSync3(generatedFile);
+        unlinkSync2(generatedFile);
       } catch (e) {
       }
     }
@@ -7423,7 +7320,7 @@ import { Type as Type15 } from "@sinclair/typebox";
 import {
   completeSimple
 } from "@mariozechner/pi-ai";
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
 import { extname as extname3 } from "path";
 var visionAnalyzeTool = {
   name: "vision_analyze",
@@ -7495,7 +7392,7 @@ var visionAnalyzeExecutor = async (params, context) => {
         }
         throw error;
       }
-      if (!existsSync11(validatedPath.absolutePath)) {
+      if (!existsSync10(validatedPath.absolutePath)) {
         return {
           success: false,
           error: `File not found: ${filePath}`
@@ -7509,7 +7406,7 @@ var visionAnalyzeExecutor = async (params, context) => {
           error: `Unsupported file type: ${ext}. Vision supports: .jpg, .jpeg, .png, .gif, .webp`
         };
       }
-      data = readFileSync9(validatedPath.absolutePath);
+      data = readFileSync8(validatedPath.absolutePath);
       source = `file:${filePath}`;
     } else {
       console.log(`\u{1F4F7} Downloading image from message ${messageId}...`);
@@ -8752,7 +8649,7 @@ var telegramCreateGroupExecutor = async (params, context) => {
 // src/agent/tools/telegram/groups/set-chat-photo.ts
 import { Type as Type29 } from "@sinclair/typebox";
 import { Api as Api22 } from "telegram";
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 var telegramSetChatPhotoTool = {
   name: "telegram_set_chat_photo",
   description: `Set or delete a group/channel profile photo. You need admin rights with change info permission. Provide a local image path to set, or use delete_photo to remove.`,
@@ -8821,7 +8718,7 @@ var telegramSetChatPhotoExecutor = async (params, context) => {
       }
       throw error;
     }
-    const fileBuffer = readFileSync10(validatedPath.absolutePath);
+    const fileBuffer = readFileSync9(validatedPath.absolutePath);
     const file = await client.uploadFile({
       file: new CustomFile(
         validatedPath.filename,
@@ -11001,7 +10898,7 @@ var import_big_integer4 = __toESM(require_BigInteger(), 1);
 import { Type as Type59 } from "@sinclair/typebox";
 import { Api as Api51 } from "telegram";
 import { CustomFile as CustomFile2 } from "telegram/client/uploads.js";
-import { readFileSync as readFileSync11, statSync } from "fs";
+import { readFileSync as readFileSync10, statSync } from "fs";
 import { basename as basename2 } from "path";
 var telegramSendStoryTool = {
   name: "telegram_send_story",
@@ -11050,7 +10947,7 @@ var telegramSendStoryExecutor = async (params, context) => {
     const filePath = validatedPath.absolutePath;
     const fileName = basename2(filePath);
     const fileSize = statSync(filePath).size;
-    const fileBuffer = readFileSync11(filePath);
+    const fileBuffer = readFileSync10(filePath);
     const isVideo = filePath.toLowerCase().match(/\.(mp4|mov|avi)$/);
     const customFile = new CustomFile2(fileName, fileSize, filePath, fileBuffer);
     const uploadedFile = await gramJsClient.uploadFile({
@@ -11119,8 +11016,8 @@ var telegramSendStoryExecutor = async (params, context) => {
 
 // src/agent/tools/telegram/memory/memory-write.ts
 import { Type as Type60 } from "@sinclair/typebox";
-import { appendFileSync as appendFileSync3, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync9 } from "fs";
-import { join as join10 } from "path";
+import { appendFileSync as appendFileSync2, writeFileSync as writeFileSync8, existsSync as existsSync11, mkdirSync as mkdirSync8 } from "fs";
+import { join as join9 } from "path";
 var MEMORY_DIR2 = WORKSPACE_PATHS.MEMORY_DIR;
 var MEMORY_FILE = WORKSPACE_PATHS.MEMORY;
 var memoryWriteTool = {
@@ -11142,8 +11039,8 @@ var memoryWriteTool = {
   })
 };
 function ensureMemoryDir2() {
-  if (!existsSync12(MEMORY_DIR2)) {
-    mkdirSync9(MEMORY_DIR2, { recursive: true });
+  if (!existsSync11(MEMORY_DIR2)) {
+    mkdirSync8(MEMORY_DIR2, { recursive: true });
   }
 }
 function formatDate2(date) {
@@ -11153,7 +11050,7 @@ function formatDate2(date) {
   return `${year}-${month}-${day}`;
 }
 function getDailyLogPath2() {
-  return join10(MEMORY_DIR2, `${formatDate2(/* @__PURE__ */ new Date())}.md`);
+  return join9(MEMORY_DIR2, `${formatDate2(/* @__PURE__ */ new Date())}.md`);
 }
 var memoryWriteExecutor = async (params, context) => {
   try {
@@ -11185,10 +11082,10 @@ var memoryWriteExecutor = async (params, context) => {
       entry += `
 _Added: ${now.toISOString()}_
 `;
-      if (!existsSync12(MEMORY_FILE)) {
+      if (!existsSync11(MEMORY_FILE)) {
         writeFileSync8(MEMORY_FILE, "# MEMORY.md - Persistent Memory\n\n", "utf-8");
       }
-      appendFileSync3(MEMORY_FILE, entry, "utf-8");
+      appendFileSync2(MEMORY_FILE, entry, "utf-8");
       console.log(`\u{1F4DD} Memory written to MEMORY.md${section ? ` (section: ${section})` : ""}`);
       return {
         success: true,
@@ -11201,7 +11098,7 @@ _Added: ${now.toISOString()}_
       };
     } else {
       const logPath = getDailyLogPath2();
-      if (!existsSync12(logPath)) {
+      if (!existsSync11(logPath)) {
         const header = `# Daily Log - ${formatDate2(now)}
 
 `;
@@ -11218,7 +11115,7 @@ ${content}
 ---
 
 `;
-      appendFileSync3(logPath, entry, "utf-8");
+      appendFileSync2(logPath, entry, "utf-8");
       console.log(`\u{1F4C5} Memory written to daily log${section ? ` (${section})` : ""}`);
       return {
         success: true,
@@ -11241,8 +11138,8 @@ ${content}
 
 // src/agent/tools/telegram/memory/memory-read.ts
 import { Type as Type61 } from "@sinclair/typebox";
-import { readFileSync as readFileSync13, existsSync as existsSync13, readdirSync as readdirSync2 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync12, readdirSync as readdirSync2 } from "fs";
+import { join as join10 } from "path";
 var MEMORY_DIR3 = WORKSPACE_PATHS.MEMORY_DIR;
 var MEMORY_FILE2 = WORKSPACE_PATHS.MEMORY;
 var memoryReadTool = {
@@ -11271,10 +11168,10 @@ var memoryReadExecutor = async (params, _context) => {
     const { target, date } = params;
     if (target === "list") {
       const files = [];
-      if (existsSync13(MEMORY_FILE2)) {
+      if (existsSync12(MEMORY_FILE2)) {
         files.push("MEMORY.md (persistent)");
       }
-      if (existsSync13(MEMORY_DIR3)) {
+      if (existsSync12(MEMORY_DIR3)) {
         const dailyLogs = readdirSync2(MEMORY_DIR3).filter((f) => f.endsWith(".md")).sort().reverse();
         files.push(...dailyLogs.map((f) => `memory/${f}`));
       }
@@ -11287,7 +11184,7 @@ var memoryReadExecutor = async (params, _context) => {
       };
     }
     if (target === "persistent") {
-      if (!existsSync13(MEMORY_FILE2)) {
+      if (!existsSync12(MEMORY_FILE2)) {
         return {
           success: true,
           data: {
@@ -11296,7 +11193,7 @@ var memoryReadExecutor = async (params, _context) => {
           }
         };
       }
-      const content = readFileSync13(MEMORY_FILE2, "utf-8");
+      const content = readFileSync12(MEMORY_FILE2, "utf-8");
       return {
         success: true,
         data: {
@@ -11309,8 +11206,8 @@ var memoryReadExecutor = async (params, _context) => {
     }
     if (target === "daily") {
       const targetDate = date || formatDate3(/* @__PURE__ */ new Date());
-      const logPath = join11(MEMORY_DIR3, `${targetDate}.md`);
-      if (!existsSync13(logPath)) {
+      const logPath = join10(MEMORY_DIR3, `${targetDate}.md`);
+      if (!existsSync12(logPath)) {
         return {
           success: true,
           data: {
@@ -11320,7 +11217,7 @@ var memoryReadExecutor = async (params, _context) => {
           }
         };
       }
-      const content = readFileSync13(logPath, "utf-8");
+      const content = readFileSync12(logPath, "utf-8");
       return {
         success: true,
         data: {
@@ -11339,15 +11236,15 @@ var memoryReadExecutor = async (params, _context) => {
       const todayStr = formatDate3(today);
       const yesterdayStr = formatDate3(yesterday);
       const result = {};
-      const yesterdayPath = join11(MEMORY_DIR3, `${yesterdayStr}.md`);
-      if (existsSync13(yesterdayPath)) {
-        result[yesterdayStr] = readFileSync13(yesterdayPath, "utf-8");
+      const yesterdayPath = join10(MEMORY_DIR3, `${yesterdayStr}.md`);
+      if (existsSync12(yesterdayPath)) {
+        result[yesterdayStr] = readFileSync12(yesterdayPath, "utf-8");
       } else {
         result[yesterdayStr] = null;
       }
-      const todayPath = join11(MEMORY_DIR3, `${todayStr}.md`);
-      if (existsSync13(todayPath)) {
-        result[todayStr] = readFileSync13(todayPath, "utf-8");
+      const todayPath = join10(MEMORY_DIR3, `${todayStr}.md`);
+      if (existsSync12(todayPath)) {
+        result[todayStr] = readFileSync12(todayPath, "utf-8");
       } else {
         result[todayStr] = null;
       }
@@ -19327,7 +19224,7 @@ var journalUpdateExecutor = async (params) => {
 // src/agent/tools/workspace/list.ts
 import { Type as Type99 } from "@sinclair/typebox";
 import { readdirSync as readdirSync3, lstatSync as lstatSync2 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 var workspaceListTool = {
   name: "workspace_list",
   description: `List files and directories in your workspace.
@@ -19364,7 +19261,7 @@ function listDir(dirPath, recursive, filter) {
   try {
     const entries = readdirSync3(dirPath);
     for (const entry of entries) {
-      const fullPath = join12(dirPath, entry);
+      const fullPath = join11(dirPath, entry);
       const stats = lstatSync2(fullPath);
       const isDir = stats.isDirectory();
       if (filter === "files" && isDir) continue;
@@ -19425,7 +19322,7 @@ var workspaceListExecutor = async (params, _context) => {
 
 // src/agent/tools/workspace/read.ts
 import { Type as Type100 } from "@sinclair/typebox";
-import { readFileSync as readFileSync14, lstatSync as lstatSync3 } from "fs";
+import { readFileSync as readFileSync13, lstatSync as lstatSync3 } from "fs";
 var workspaceReadTool = {
   name: "workspace_read",
   description: `Read a file from your workspace.
@@ -19497,7 +19394,7 @@ var workspaceReadExecutor = async (params, _context) => {
         }
       };
     }
-    const content = readFileSync14(
+    const content = readFileSync13(
       validated.absolutePath,
       encoding === "base64" ? "base64" : "utf-8"
     );
@@ -19527,8 +19424,8 @@ var workspaceReadExecutor = async (params, _context) => {
 
 // src/agent/tools/workspace/write.ts
 import { Type as Type101 } from "@sinclair/typebox";
-import { writeFileSync as writeFileSync9, appendFileSync as appendFileSync4, mkdirSync as mkdirSync10, existsSync as existsSync14 } from "fs";
-import { dirname as dirname7 } from "path";
+import { writeFileSync as writeFileSync9, appendFileSync as appendFileSync3, mkdirSync as mkdirSync9, existsSync as existsSync13 } from "fs";
+import { dirname as dirname6 } from "path";
 var workspaceWriteTool = {
   name: "workspace_write",
   description: `Write a file to your workspace.
@@ -19572,9 +19469,9 @@ var workspaceWriteExecutor = async (params, _context) => {
   try {
     const { path, content, encoding = "utf-8", append = false, createDirs = true } = params;
     const validated = validateWritePath(path);
-    const parentDir = dirname7(validated.absolutePath);
-    if (createDirs && !existsSync14(parentDir)) {
-      mkdirSync10(parentDir, { recursive: true });
+    const parentDir = dirname6(validated.absolutePath);
+    if (createDirs && !existsSync13(parentDir)) {
+      mkdirSync9(parentDir, { recursive: true });
     }
     let writeContent;
     if (encoding === "base64") {
@@ -19591,7 +19488,7 @@ var workspaceWriteExecutor = async (params, _context) => {
       };
     }
     if (append && validated.exists) {
-      appendFileSync4(validated.absolutePath, writeContent);
+      appendFileSync3(validated.absolutePath, writeContent);
     } else {
       writeFileSync9(validated.absolutePath, writeContent);
     }
@@ -19621,7 +19518,7 @@ var workspaceWriteExecutor = async (params, _context) => {
 
 // src/agent/tools/workspace/delete.ts
 import { Type as Type102 } from "@sinclair/typebox";
-import { unlinkSync as unlinkSync4, rmdirSync, readdirSync as readdirSync4, rmSync } from "fs";
+import { unlinkSync as unlinkSync3, rmdirSync, readdirSync as readdirSync4, rmSync } from "fs";
 var PROTECTED_WORKSPACE_FILES = [
   "SOUL.md",
   "STRATEGY.md",
@@ -19677,7 +19574,7 @@ var workspaceDeleteExecutor = async (params, _context) => {
         rmdirSync(validated.absolutePath);
       }
     } else {
-      unlinkSync4(validated.absolutePath);
+      unlinkSync3(validated.absolutePath);
     }
     return {
       success: true,
@@ -19703,8 +19600,8 @@ var workspaceDeleteExecutor = async (params, _context) => {
 
 // src/agent/tools/workspace/info.ts
 import { Type as Type103 } from "@sinclair/typebox";
-import { lstatSync as lstatSync4, readdirSync as readdirSync5, existsSync as existsSync15 } from "fs";
-import { join as join13 } from "path";
+import { lstatSync as lstatSync4, readdirSync as readdirSync5, existsSync as existsSync14 } from "fs";
+import { join as join12 } from "path";
 var MEMES_DIR = WORKSPACE_PATHS.MEMES_DIR;
 var workspaceInfoTool = {
   name: "workspace_info",
@@ -19729,7 +19626,7 @@ function getDirSize(dirPath) {
   try {
     const entries = readdirSync5(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join13(dirPath, entry.name);
+      const fullPath = join12(dirPath, entry.name);
       if (entry.isDirectory()) {
         const subStats = getDirSize(fullPath);
         count += subStats.count;
@@ -19756,11 +19653,11 @@ function formatBytes(bytes) {
 var workspaceInfoExecutor = async (params, _context) => {
   try {
     const { detailed = false } = params;
-    const memoryStats = existsSync15(WORKSPACE_PATHS.MEMORY_DIR) ? getDirSize(WORKSPACE_PATHS.MEMORY_DIR) : { count: 0, size: 0 };
-    const downloadsStats = existsSync15(WORKSPACE_PATHS.DOWNLOADS_DIR) ? getDirSize(WORKSPACE_PATHS.DOWNLOADS_DIR) : { count: 0, size: 0 };
-    const uploadsStats = existsSync15(WORKSPACE_PATHS.UPLOADS_DIR) ? getDirSize(WORKSPACE_PATHS.UPLOADS_DIR) : { count: 0, size: 0 };
-    const tempStats = existsSync15(WORKSPACE_PATHS.TEMP_DIR) ? getDirSize(WORKSPACE_PATHS.TEMP_DIR) : { count: 0, size: 0 };
-    const memesStats = existsSync15(MEMES_DIR) ? getDirSize(MEMES_DIR) : { count: 0, size: 0 };
+    const memoryStats = existsSync14(WORKSPACE_PATHS.MEMORY_DIR) ? getDirSize(WORKSPACE_PATHS.MEMORY_DIR) : { count: 0, size: 0 };
+    const downloadsStats = existsSync14(WORKSPACE_PATHS.DOWNLOADS_DIR) ? getDirSize(WORKSPACE_PATHS.DOWNLOADS_DIR) : { count: 0, size: 0 };
+    const uploadsStats = existsSync14(WORKSPACE_PATHS.UPLOADS_DIR) ? getDirSize(WORKSPACE_PATHS.UPLOADS_DIR) : { count: 0, size: 0 };
+    const tempStats = existsSync14(WORKSPACE_PATHS.TEMP_DIR) ? getDirSize(WORKSPACE_PATHS.TEMP_DIR) : { count: 0, size: 0 };
+    const memesStats = existsSync14(MEMES_DIR) ? getDirSize(MEMES_DIR) : { count: 0, size: 0 };
     const totalSize = memoryStats.size + downloadsStats.size + uploadsStats.size + tempStats.size + memesStats.size;
     const info = {
       workspaceRoot: WORKSPACE_ROOT,
@@ -19796,11 +19693,11 @@ var workspaceInfoExecutor = async (params, _context) => {
     };
     if (detailed) {
       info.files = {
-        memory: existsSync15(WORKSPACE_PATHS.MEMORY_DIR) ? readdirSync5(WORKSPACE_PATHS.MEMORY_DIR) : [],
-        downloads: existsSync15(WORKSPACE_PATHS.DOWNLOADS_DIR) ? readdirSync5(WORKSPACE_PATHS.DOWNLOADS_DIR) : [],
-        uploads: existsSync15(WORKSPACE_PATHS.UPLOADS_DIR) ? readdirSync5(WORKSPACE_PATHS.UPLOADS_DIR) : [],
-        temp: existsSync15(WORKSPACE_PATHS.TEMP_DIR) ? readdirSync5(WORKSPACE_PATHS.TEMP_DIR) : [],
-        memes: existsSync15(MEMES_DIR) ? readdirSync5(MEMES_DIR) : []
+        memory: existsSync14(WORKSPACE_PATHS.MEMORY_DIR) ? readdirSync5(WORKSPACE_PATHS.MEMORY_DIR) : [],
+        downloads: existsSync14(WORKSPACE_PATHS.DOWNLOADS_DIR) ? readdirSync5(WORKSPACE_PATHS.DOWNLOADS_DIR) : [],
+        uploads: existsSync14(WORKSPACE_PATHS.UPLOADS_DIR) ? readdirSync5(WORKSPACE_PATHS.UPLOADS_DIR) : [],
+        temp: existsSync14(WORKSPACE_PATHS.TEMP_DIR) ? readdirSync5(WORKSPACE_PATHS.TEMP_DIR) : [],
+        memes: existsSync14(MEMES_DIR) ? readdirSync5(MEMES_DIR) : []
       };
     }
     return {
@@ -19817,9 +19714,9 @@ var workspaceInfoExecutor = async (params, _context) => {
 
 // src/agent/tools/workspace/rename.ts
 import { Type as Type104 } from "@sinclair/typebox";
-import { renameSync as renameSync2, existsSync as existsSync16 } from "fs";
-import { dirname as dirname8 } from "path";
-import { mkdirSync as mkdirSync11 } from "fs";
+import { renameSync, existsSync as existsSync15 } from "fs";
+import { dirname as dirname7 } from "path";
+import { mkdirSync as mkdirSync10 } from "fs";
 var workspaceRenameTool = {
   name: "workspace_rename",
   description: `Rename or move a file within your workspace.
@@ -19866,11 +19763,11 @@ var workspaceRenameExecutor = async (params, _context) => {
         error: `Destination already exists: '${to}'. Use overwrite=true to replace.`
       };
     }
-    const parentDir = dirname8(validatedTo.absolutePath);
-    if (!existsSync16(parentDir)) {
-      mkdirSync11(parentDir, { recursive: true });
+    const parentDir = dirname7(validatedTo.absolutePath);
+    if (!existsSync15(parentDir)) {
+      mkdirSync10(parentDir, { recursive: true });
     }
-    renameSync2(validatedFrom.absolutePath, validatedTo.absolutePath);
+    renameSync(validatedFrom.absolutePath, validatedTo.absolutePath);
     return {
       success: true,
       data: {
@@ -21805,6 +21702,7 @@ async function executeDeal(dealId, db, bridge) {
         WHERE id = ?`
       ).run(txHash, dealId);
       console.log(`\u2705 [Deal] #${dealId} completed - TON sent - TX: ${txHash.slice(0, 8)}...`);
+      logDealToJournal(deal, db, txHash);
       await bridge.sendMessage({
         chatId: deal.chat_id,
         text: `\u2705 **Deal #${dealId} completed!**
@@ -21875,6 +21773,7 @@ Thank you for trading! \u{1F389}`
           WHERE id = ?`
         ).run(sentMsgId, dealId);
         console.log(`\u2705 [Deal] #${dealId} completed - Gift transferred`);
+        logDealToJournal(deal, db);
         await bridge.sendMessage({
           chatId: deal.chat_id,
           text: `\u2705 **Deal #${dealId} completed!**
@@ -21924,6 +21823,40 @@ Thank you for trading! \u{1F389}`
     };
   }
 }
+function logDealToJournal(deal, db, txHash) {
+  try {
+    const journal = new JournalStore(db);
+    const agentGave = formatAsset(
+      deal.agent_gives_type,
+      deal.agent_gives_ton_amount,
+      deal.agent_gives_gift_slug
+    );
+    const agentReceived = formatAsset(
+      deal.user_gives_type,
+      deal.user_gives_ton_amount,
+      deal.user_gives_gift_slug
+    );
+    const isGiftTrade = deal.agent_gives_type === "gift" || deal.user_gives_type === "gift";
+    journal.addEntry({
+      type: isGiftTrade ? "gift" : "trade",
+      action: deal.agent_gives_type === "gift" ? "sell_gift" : "buy_gift",
+      asset_from: agentGave,
+      asset_to: agentReceived,
+      amount_from: deal.agent_gives_ton_amount ?? void 0,
+      amount_to: deal.user_gives_ton_amount ?? void 0,
+      counterparty: String(deal.user_telegram_id),
+      platform: "telegram_deals",
+      outcome: "neutral",
+      // P&L computed later when floor prices are known
+      tx_hash: txHash,
+      tool_used: "deal_executor",
+      chat_id: deal.chat_id,
+      user_id: deal.user_telegram_id
+    });
+  } catch (error) {
+    console.error(`\u26A0\uFE0F [Deal] Failed to log deal #${deal.id} to journal:`, error);
+  }
+}
 async function autoExecuteAfterVerification(dealId, db, bridge) {
   console.log(`\u{1F504} [Deal] Auto-executing deal #${dealId} after verification...`);
   const result = await executeDeal(dealId, db, bridge);
@@ -22571,25 +22504,25 @@ function registerAllTools(registry, config) {
 }
 
 // src/agent/tools/plugin-loader.ts
-import { readdirSync as readdirSync6, existsSync as existsSync17, statSync as statSync2 } from "fs";
-import { join as join14 } from "path";
+import { readdirSync as readdirSync6, existsSync as existsSync16, statSync as statSync2 } from "fs";
+import { join as join13 } from "path";
 import { pathToFileURL } from "url";
 async function loadPlugins(registry) {
   const pluginsDir = WORKSPACE_PATHS.PLUGINS_DIR;
-  if (!existsSync17(pluginsDir)) {
+  if (!existsSync16(pluginsDir)) {
     return 0;
   }
   const entries = readdirSync6(pluginsDir);
   let totalRegistered = 0;
   for (const entry of entries) {
-    const entryPath = join14(pluginsDir, entry);
+    const entryPath = join13(pluginsDir, entry);
     let modulePath = null;
     const stat = statSync2(entryPath);
     if (stat.isFile() && entry.endsWith(".js")) {
       modulePath = entryPath;
     } else if (stat.isDirectory()) {
-      const indexPath = join14(entryPath, "index.js");
-      if (existsSync17(indexPath)) {
+      const indexPath = join13(entryPath, "index.js");
+      if (existsSync16(indexPath)) {
         modulePath = indexPath;
       }
     }
@@ -23874,7 +23807,7 @@ var TonnetApp = class {
       apiId: this.config.telegram.api_id,
       apiHash: this.config.telegram.api_hash,
       phone: this.config.telegram.phone,
-      sessionPath: join15(TELETON_ROOT, "telegram_session.txt"),
+      sessionPath: join14(TELETON_ROOT, "telegram_session.txt"),
       connectionRetries: TELEGRAM_CONNECTION_RETRIES,
       autoReconnect: true,
       floodSleepThreshold: TELEGRAM_FLOOD_SLEEP_THRESHOLD
@@ -23882,7 +23815,7 @@ var TonnetApp = class {
     const VECTOR_DIMENSIONS = 512;
     const memory = initializeMemory({
       database: {
-        path: join15(TELETON_ROOT, "memory.db"),
+        path: join14(TELETON_ROOT, "memory.db"),
         enableVectorSearch: false,
         vectorDimensions: VECTOR_DIMENSIONS
       },
@@ -23891,7 +23824,7 @@ var TonnetApp = class {
         apiKey: "",
         model: ""
       },
-      workspaceDir: join15(TELETON_ROOT)
+      workspaceDir: join14(TELETON_ROOT)
     });
     const db = getDatabase().getDb();
     if (this.config.market.enabled || this.config.deals.enabled) {
@@ -23943,9 +23876,11 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
     }
     const { migrateSessionsToDb } = await import("./migrate-F256Q7LW.js");
     migrateSessionsToDb();
+    const { cleanupOldTranscripts } = await import("./transcript-DF2Y6CFY.js");
+    cleanupOldTranscripts(30);
     const memory = initializeMemory({
       database: {
-        path: join15(TELETON_ROOT, "memory.db"),
+        path: join14(TELETON_ROOT, "memory.db"),
         enableVectorSearch: false,
         vectorDimensions: 512
       },
@@ -23954,7 +23889,7 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
         apiKey: "",
         model: ""
       },
-      workspaceDir: join15(TELETON_ROOT)
+      workspaceDir: join14(TELETON_ROOT)
     });
     const indexResult = await memory.knowledge.indexAll();
     const db = getDatabase();

package/dist/cli/index.js

@@ -17,7 +17,9 @@ import {
   saveWallet,
   validateApiKeyFormat,
   walletExists
-} from "../chunk-ABHUNKXQ.js";
+} from "../chunk-Y4G7HSOQ.js";
+import "../chunk-U7FQYCBQ.js";
+import "../chunk-OQGNS2FV.js";
 import "../chunk-JDPS46IZ.js";
 import "../chunk-E2NXSWOS.js";
 import {
@@ -33,7 +35,6 @@ import {
   ONBOARDING_PROMPT_TIMEOUT_MS
 } from "../chunk-LJXYESJJ.js";
 import "../chunk-B2PRMXOH.js";
-import "../chunk-U7FQYCBQ.js";
 import "../chunk-QGM4M3NI.js";
 
 // src/cli/index.ts

package/dist/index.js

@@ -1,7 +1,9 @@
 import {
   TonnetApp,
   main
-} from "./chunk-ABHUNKXQ.js";
+} from "./chunk-Y4G7HSOQ.js";
+import "./chunk-U7FQYCBQ.js";
+import "./chunk-OQGNS2FV.js";
 import "./chunk-JDPS46IZ.js";
 import "./chunk-E2NXSWOS.js";
 import "./chunk-EYWNOHMJ.js";
@@ -9,7 +11,6 @@ import "./chunk-WMIN6AGX.js";
 import "./chunk-QMN6ZOA5.js";
 import "./chunk-LJXYESJJ.js";
 import "./chunk-B2PRMXOH.js";
-import "./chunk-U7FQYCBQ.js";
 import "./chunk-QGM4M3NI.js";
 export {
   TonnetApp,

package/dist/transcript-DF2Y6CFY.js

@@ -0,0 +1,22 @@
+import {
+  appendToTranscript,
+  archiveTranscript,
+  cleanupOldTranscripts,
+  deleteTranscript,
+  getTranscriptPath,
+  getTranscriptSize,
+  readTranscript,
+  transcriptExists
+} from "./chunk-OQGNS2FV.js";
+import "./chunk-EYWNOHMJ.js";
+import "./chunk-QGM4M3NI.js";
+export {
+  appendToTranscript,
+  archiveTranscript,
+  cleanupOldTranscripts,
+  deleteTranscript,
+  getTranscriptPath,
+  getTranscriptSize,
+  readTranscript,
+  transcriptExists
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleton",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Personal AI Agent for Telegram",
   "author": "ZKProof (https://t.me/zkproof)",
   "license": "MIT",