teleton 0.6.0 → 0.7.0

package/dist/chunk-NERLQY2H.js

@@ -0,0 +1,421 @@
+import {
+  getCachedHttpEndpoint
+} from "./chunk-QUAPFI2N.js";
+import {
+  COINGECKO_API_URL,
+  tonapiFetch
+} from "./chunk-XBKSS6DM.js";
+import {
+  TELEGRAM_MAX_MESSAGE_LENGTH
+} from "./chunk-RO62LO6Z.js";
+import {
+  fetchWithTimeout
+} from "./chunk-VAUJSSD3.js";
+import {
+  TELETON_ROOT,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
+// src/ton/wallet-service.ts
+import { mnemonicNew, mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
+import { WalletContractV5R1, TonClient, fromNano } from "@ton/ton";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+var log = createLogger("TON");
+var WALLET_FILE = join(TELETON_ROOT, "wallet.json");
+var _walletCache;
+var _keyPairCache = null;
+async function generateWallet() {
+  const mnemonic = await mnemonicNew(24);
+  const keyPair = await mnemonicToPrivateKey(mnemonic);
+  const wallet = WalletContractV5R1.create({
+    workchain: 0,
+    publicKey: keyPair.publicKey
+  });
+  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  return {
+    version: "w5r1",
+    address,
+    publicKey: keyPair.publicKey.toString("hex"),
+    mnemonic,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function saveWallet(wallet) {
+  const dir = dirname(WALLET_FILE);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { encoding: "utf-8", mode: 384 });
+  _walletCache = void 0;
+  _keyPairCache = null;
+}
+function loadWallet() {
+  if (_walletCache !== void 0) return _walletCache;
+  if (!existsSync(WALLET_FILE)) {
+    _walletCache = null;
+    return null;
+  }
+  try {
+    const content = readFileSync(WALLET_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed.mnemonic || !Array.isArray(parsed.mnemonic) || parsed.mnemonic.length !== 24) {
+      throw new Error("Invalid wallet.json: mnemonic must be a 24-word array");
+    }
+    _walletCache = parsed;
+    return _walletCache;
+  } catch (error) {
+    log.error({ err: error }, "Failed to load wallet");
+    _walletCache = null;
+    return null;
+  }
+}
+function walletExists() {
+  return existsSync(WALLET_FILE);
+}
+async function importWallet(mnemonic) {
+  const valid = await mnemonicValidate(mnemonic);
+  if (!valid) {
+    throw new Error("Invalid mnemonic: words do not form a valid TON seed phrase");
+  }
+  const keyPair = await mnemonicToPrivateKey(mnemonic);
+  const wallet = WalletContractV5R1.create({
+    workchain: 0,
+    publicKey: keyPair.publicKey
+  });
+  const address = wallet.address.toString({ bounceable: true, testOnly: false });
+  return {
+    version: "w5r1",
+    address,
+    publicKey: keyPair.publicKey.toString("hex"),
+    mnemonic,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function getWalletAddress() {
+  const wallet = loadWallet();
+  return wallet?.address || null;
+}
+async function getKeyPair() {
+  if (_keyPairCache) return _keyPairCache;
+  const wallet = loadWallet();
+  if (!wallet) return null;
+  _keyPairCache = await mnemonicToPrivateKey(wallet.mnemonic);
+  return _keyPairCache;
+}
+async function getWalletBalance(address) {
+  try {
+    const endpoint = await getCachedHttpEndpoint();
+    const client = new TonClient({ endpoint });
+    const { Address } = await import("@ton/core");
+    const addressObj = Address.parse(address);
+    const balance = await client.getBalance(addressObj);
+    const balanceFormatted = fromNano(balance);
+    return {
+      balance: balanceFormatted,
+      balanceNano: balance.toString()
+    };
+  } catch (error) {
+    log.error({ err: error }, "Failed to get balance");
+    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) {
+        _tonPriceCache = { usd: price, source: "TonAPI", timestamp: Date.now() };
+        return _tonPriceCache;
+      }
+    }
+  } catch {
+  }
+  try {
+    const response = await fetchWithTimeout(
+      `${COINGECKO_API_URL}/simple/price?ids=the-open-network&vs_currencies=usd`
+    );
+    if (!response.ok) {
+      throw new Error(`CoinGecko API error: ${response.status}`);
+    }
+    const data = await response.json();
+    const price = data["the-open-network"]?.usd;
+    if (typeof price === "number" && price > 0) {
+      _tonPriceCache = { usd: price, source: "CoinGecko", timestamp: Date.now() };
+      return _tonPriceCache;
+    }
+  } catch (error) {
+    log.error({ err: error }, "Failed to get TON price");
+  }
+  return null;
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var DMPolicy = z.enum(["pairing", "allowlist", "open", "disabled"]);
+var GroupPolicy = z.enum(["open", "allowlist", "disabled"]);
+var SessionResetPolicySchema = z.object({
+  daily_reset_enabled: z.boolean().default(true).describe("Enable daily session reset"),
+  daily_reset_hour: z.number().min(0).max(23).default(4).describe("Hour of day (0-23) to reset sessions"),
+  idle_expiry_enabled: z.boolean().default(true).describe("Enable session reset after idle period"),
+  idle_expiry_minutes: z.number().default(1440).describe("Minutes of inactivity before session reset (default: 24h)")
+});
+var AgentConfigSchema = z.object({
+  provider: z.enum([
+    "anthropic",
+    "openai",
+    "google",
+    "xai",
+    "groq",
+    "openrouter",
+    "moonshot",
+    "mistral",
+    "cocoon",
+    "local"
+  ]).default("anthropic"),
+  api_key: z.string().default(""),
+  base_url: z.string().url().optional().describe("Base URL for local LLM server (e.g. http://localhost:11434/v1)"),
+  model: z.string().default("claude-opus-4-5-20251101"),
+  utility_model: z.string().optional().describe("Cheap model for summarization (auto-detected if omitted)"),
+  max_tokens: z.number().default(4096),
+  temperature: z.number().default(0.7),
+  system_prompt: z.string().nullable().default(null),
+  max_agentic_iterations: z.number().default(5).describe("Maximum number of agentic loop iterations (tool call \u2192 result \u2192 tool call cycles)"),
+  session_reset_policy: SessionResetPolicySchema.default(SessionResetPolicySchema.parse({}))
+});
+var TelegramConfigSchema = z.object({
+  api_id: z.number(),
+  api_hash: z.string(),
+  phone: z.string(),
+  session_name: z.string().default("teleton_session"),
+  session_path: z.string().default("~/.teleton"),
+  dm_policy: DMPolicy.default("pairing"),
+  allow_from: z.array(z.number()).default([]),
+  group_policy: GroupPolicy.default("open"),
+  group_allow_from: z.array(z.number()).default([]),
+  require_mention: z.boolean().default(true),
+  max_message_length: z.number().default(TELEGRAM_MAX_MESSAGE_LENGTH),
+  typing_simulation: z.boolean().default(true),
+  rate_limit_messages_per_second: z.number().default(1),
+  rate_limit_groups_per_minute: z.number().default(20),
+  admin_ids: z.array(z.number()).default([]),
+  agent_channel: z.string().nullable().default(null),
+  owner_name: z.string().optional().describe("Owner's first name (e.g., 'Alex')"),
+  owner_username: z.string().optional().describe("Owner's Telegram username (without @)"),
+  owner_id: z.number().optional().describe("Owner's Telegram user ID"),
+  debounce_ms: z.number().default(1500).describe("Debounce delay in milliseconds for group messages (0 = disabled)"),
+  bot_token: z.string().optional().describe("Telegram Bot token from @BotFather for inline deal buttons"),
+  bot_username: z.string().optional().describe("Bot username without @ (e.g., 'teleton_deals_bot')")
+});
+var StorageConfigSchema = z.object({
+  sessions_file: z.string().default("~/.teleton/sessions.json"),
+  pairing_file: z.string().default("~/.teleton/pairing.json"),
+  memory_file: z.string().default("~/.teleton/memory.json"),
+  history_limit: z.number().default(100)
+});
+var MetaConfigSchema = z.object({
+  version: z.string().default("1.0.0"),
+  created_at: z.string().optional(),
+  last_modified_at: z.string().optional(),
+  onboard_command: z.string().default("teleton setup")
+});
+var _DealsObject = z.object({
+  enabled: z.boolean().default(true),
+  expiry_seconds: z.number().default(120),
+  buy_max_floor_percent: z.number().default(100),
+  sell_min_floor_percent: z.number().default(105),
+  poll_interval_ms: z.number().default(5e3),
+  max_verification_retries: z.number().default(12),
+  expiry_check_interval_ms: z.number().default(6e4)
+});
+var DealsConfigSchema = _DealsObject.default(_DealsObject.parse({}));
+var _WebUIObject = z.object({
+  enabled: z.boolean().default(false).describe("Enable WebUI server"),
+  port: z.number().default(7777).describe("HTTP server port"),
+  host: z.string().default("127.0.0.1").describe("Bind address (localhost only for security)"),
+  auth_token: z.string().optional().describe("Bearer token for API auth (auto-generated if omitted)"),
+  cors_origins: z.array(z.string()).default(["http://localhost:5173", "http://localhost:7777"]).describe("Allowed CORS origins for development"),
+  log_requests: z.boolean().default(false).describe("Log all HTTP requests")
+});
+var WebUIConfigSchema = _WebUIObject.default(_WebUIObject.parse({}));
+var _EmbeddingObject = z.object({
+  provider: z.enum(["local", "anthropic", "none"]).default("local").describe("Embedding provider: local (ONNX), anthropic (API), or none (FTS5-only)"),
+  model: z.string().optional().describe("Model override (default: Xenova/all-MiniLM-L6-v2 for local)")
+});
+var EmbeddingConfigSchema = _EmbeddingObject.default(_EmbeddingObject.parse({}));
+var _LoggingObject = z.object({
+  level: z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).default("info").describe("Log level (trace/debug/info/warn/error/fatal)"),
+  pretty: z.boolean().default(true).describe("Enable pino-pretty formatting (human-readable, colored output)")
+});
+var LoggingConfigSchema = _LoggingObject.default(_LoggingObject.parse({}));
+var _DevObject = z.object({
+  hot_reload: z.boolean().default(false).describe("Enable plugin hot-reload (watches ~/.teleton/plugins/ for changes)")
+});
+var DevConfigSchema = _DevObject.default(_DevObject.parse({}));
+var McpServerSchema = z.object({
+  command: z.string().optional().describe("Stdio command (e.g. 'npx @modelcontextprotocol/server-filesystem /tmp')"),
+  args: z.array(z.string()).optional().describe("Explicit args array (overrides command splitting)"),
+  env: z.record(z.string(), z.string()).optional().describe("Environment variables for stdio server"),
+  url: z.string().url().optional().describe("SSE/HTTP endpoint URL (alternative to command)"),
+  scope: z.enum(["always", "dm-only", "group-only", "admin-only"]).default("always").describe("Tool scope"),
+  enabled: z.boolean().default(true).describe("Enable/disable this server")
+}).refine((s) => s.command || s.url, {
+  message: "Each MCP server needs either 'command' (stdio) or 'url' (SSE/HTTP)"
+});
+var _McpObject = z.object({
+  servers: z.record(z.string(), McpServerSchema).default({})
+});
+var McpConfigSchema = _McpObject.default(_McpObject.parse({}));
+var _ToolRagObject = z.object({
+  enabled: z.boolean().default(false).describe("Enable semantic tool retrieval (Tool RAG)"),
+  top_k: z.number().default(25).describe("Max tools to retrieve per LLM call"),
+  always_include: z.array(z.string()).default([
+    "telegram_send_message",
+    "telegram_reply_message",
+    "telegram_send_photo",
+    "telegram_send_document",
+    "journal_*",
+    "workspace_*",
+    "web_*"
+  ]).describe("Tool name patterns always included (prefix glob with *)"),
+  skip_unlimited_providers: z.boolean().default(false).describe("Skip Tool RAG for providers with no tool limit (e.g. Anthropic)")
+});
+var ToolRagConfigSchema = _ToolRagObject.default(_ToolRagObject.parse({}));
+var ConfigSchema = z.object({
+  meta: MetaConfigSchema.default(MetaConfigSchema.parse({})),
+  agent: AgentConfigSchema,
+  telegram: TelegramConfigSchema,
+  storage: StorageConfigSchema.default(StorageConfigSchema.parse({})),
+  embedding: EmbeddingConfigSchema,
+  deals: DealsConfigSchema,
+  webui: WebUIConfigSchema,
+  logging: LoggingConfigSchema,
+  dev: DevConfigSchema,
+  tool_rag: ToolRagConfigSchema,
+  mcp: McpConfigSchema,
+  plugins: z.record(z.string(), z.unknown()).default({}).describe("Per-plugin config (key = plugin name with underscores)"),
+  cocoon: z.object({
+    port: z.number().min(1).max(65535).default(1e4).describe("HTTP port of the cocoon-cli proxy")
+  }).optional().describe("Cocoon Network \u2014 expects external cocoon-cli running on this port"),
+  tonapi_key: z.string().optional().describe("TonAPI key for higher rate limits (from @tonapi_bot)"),
+  tavily_api_key: z.string().optional().describe("Tavily API key for web search & extract (free at https://tavily.com)")
+});
+
+// src/workspace/manager.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, copyFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+var log2 = createLogger("Workspace");
+function findPackageRoot() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join2(dir, "package.json"))) return dir;
+    dir = dirname2(dir);
+  }
+  return process.cwd();
+}
+var TEMPLATES_DIR = join2(findPackageRoot(), "src", "templates");
+async function ensureWorkspace(config) {
+  if (!existsSync2(TELETON_ROOT)) {
+    mkdirSync2(TELETON_ROOT, { recursive: true });
+    log2.info(`Created Teleton root at ${TELETON_ROOT}`);
+  }
+  if (!existsSync2(WORKSPACE_ROOT)) {
+    mkdirSync2(WORKSPACE_ROOT, { recursive: true });
+    log2.info(`Created workspace at ${WORKSPACE_ROOT}`);
+  }
+  const directories = [
+    WORKSPACE_PATHS.MEMORY_DIR,
+    WORKSPACE_PATHS.DOWNLOADS_DIR,
+    WORKSPACE_PATHS.UPLOADS_DIR,
+    WORKSPACE_PATHS.TEMP_DIR,
+    WORKSPACE_PATHS.MEMES_DIR
+  ];
+  for (const dir of directories) {
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  const workspace = {
+    root: TELETON_ROOT,
+    workspace: WORKSPACE_ROOT,
+    // Workspace files
+    soulPath: WORKSPACE_PATHS.SOUL,
+    memoryPath: WORKSPACE_PATHS.MEMORY,
+    identityPath: WORKSPACE_PATHS.IDENTITY,
+    userPath: WORKSPACE_PATHS.USER,
+    strategyPath: WORKSPACE_PATHS.STRATEGY,
+    securityPath: WORKSPACE_PATHS.SECURITY,
+    // Workspace directories
+    memoryDir: WORKSPACE_PATHS.MEMORY_DIR,
+    downloadsDir: WORKSPACE_PATHS.DOWNLOADS_DIR,
+    uploadsDir: WORKSPACE_PATHS.UPLOADS_DIR,
+    tempDir: WORKSPACE_PATHS.TEMP_DIR,
+    memesDir: WORKSPACE_PATHS.MEMES_DIR,
+    // Protected files (outside workspace)
+    sessionPath: join2(TELETON_ROOT, "telegram_session.txt"),
+    configPath: join2(TELETON_ROOT, "config.yaml"),
+    walletPath: join2(TELETON_ROOT, "wallet.json")
+  };
+  if (config?.ensureTemplates) {
+    await bootstrapTemplates(workspace);
+  }
+  return workspace;
+}
+async function bootstrapTemplates(workspace) {
+  const templates = [
+    { name: "SOUL.md", path: workspace.soulPath },
+    { name: "MEMORY.md", path: workspace.memoryPath },
+    { name: "IDENTITY.md", path: workspace.identityPath },
+    { name: "USER.md", path: workspace.userPath },
+    { name: "SECURITY.md", path: workspace.securityPath },
+    { name: "STRATEGY.md", path: workspace.strategyPath }
+  ];
+  for (const template of templates) {
+    if (!existsSync2(template.path)) {
+      const templateSource = join2(TEMPLATES_DIR, template.name);
+      if (existsSync2(templateSource)) {
+        copyFileSync(templateSource, template.path);
+        log2.info(`Created ${template.name}`);
+      }
+    }
+  }
+}
+function isNewWorkspace(workspace) {
+  return !existsSync2(workspace.configPath);
+}
+function loadTemplate(name) {
+  const templatePath = join2(TEMPLATES_DIR, name);
+  if (!existsSync2(templatePath)) {
+    throw new Error(`Template ${name} not found at ${templatePath}`);
+  }
+  return readFileSync2(templatePath, "utf-8");
+}
+
+export {
+  DealsConfigSchema,
+  ConfigSchema,
+  ensureWorkspace,
+  isNewWorkspace,
+  loadTemplate,
+  generateWallet,
+  saveWallet,
+  loadWallet,
+  walletExists,
+  importWallet,
+  getWalletAddress,
+  getKeyPair,
+  getWalletBalance,
+  getTonPrice
+};

package/dist/{chunk-YBA6IBGT.js → chunk-OCLG5GKI.js}

@@ -1,6 +1,9 @@
 import {
   TELETON_ROOT
 } from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
 
 // src/session/transcript.ts
 import {
@@ -14,6 +17,7 @@ import {
   statSync
 } from "fs";
 import { join } from "path";
+var log = createLogger("Session");
 var SESSIONS_DIR = join(TELETON_ROOT, "sessions");
 function getTranscriptPath(sessionId) {
   return join(SESSIONS_DIR, `${sessionId}.jsonl`);
@@ -30,17 +34,15 @@ function appendToTranscript(sessionId, message) {
   try {
     appendFileSync(transcriptPath, line, "utf-8");
   } catch (error) {
-    console.error(`Failed to append to transcript ${sessionId}:`, error);
+    log.error({ err: error }, `Failed to append to transcript ${sessionId}`);
   }
 }
 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);
+      if (block.type === "toolCall") {
+        if (block.id) ids.add(block.id);
       }
     }
   }
@@ -55,17 +57,15 @@ function sanitizeMessages(messages) {
     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`
-        );
+        log.warn(`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;
+    } else if (msg.role === "toolResult") {
+      const toolCallId = msg.toolCallId;
       if (!toolCallId || typeof toolCallId !== "string") {
         removedCount++;
-        console.warn(`\u{1F9F9} Removing toolResult with missing/invalid toolCallId`);
+        log.warn(`Removing toolResult with missing/invalid toolCallId`);
         continue;
       }
       if (pendingToolCallIds.has(toolCallId)) {
@@ -73,13 +73,13 @@ function sanitizeMessages(messages) {
         sanitized.push(msg);
       } else {
         removedCount++;
-        console.warn(`\u{1F9F9} Removing orphaned toolResult: ${toolCallId.slice(0, 20)}...`);
+        log.warn(`Removing 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`
+        log.warn(
+          `User message arrived while ${pendingToolCallIds.size} tool results pending - marking them as orphaned`
         );
         pendingToolCallIds.clear();
       }
@@ -89,7 +89,7 @@ function sanitizeMessages(messages) {
     }
   }
   if (removedCount > 0) {
-    console.log(`\u{1F9F9} Sanitized ${removedCount} orphaned/out-of-order toolResult(s) from transcript`);
+    log.info(`Sanitized ${removedCount} orphaned/out-of-order toolResult(s) from transcript`);
   }
   return sanitized;
 }
@@ -107,16 +107,16 @@ function readTranscript(sessionId) {
         return JSON.parse(line);
       } catch {
         corruptCount++;
-        console.warn(`\u26A0\uFE0F Skipping corrupt line ${i + 1} in transcript ${sessionId}`);
+        log.warn(`Skipping corrupt line ${i + 1} in transcript ${sessionId}`);
         return null;
       }
     }).filter(Boolean);
     if (corruptCount > 0) {
-      console.warn(`\u26A0\uFE0F ${corruptCount} corrupt line(s) skipped in transcript ${sessionId}`);
+      log.warn(`${corruptCount} corrupt line(s) skipped in transcript ${sessionId}`);
     }
     return sanitizeMessages(messages);
   } catch (error) {
-    console.error(`Failed to read transcript ${sessionId}:`, error);
+    log.error({ err: error }, `Failed to read transcript ${sessionId}`);
     return [];
   }
 }
@@ -138,10 +138,10 @@ function deleteTranscript(sessionId) {
   }
   try {
     unlinkSync(transcriptPath);
-    console.log(`\u{1F5D1}\uFE0F Deleted transcript: ${sessionId}`);
+    log.info(`Deleted transcript: ${sessionId}`);
     return true;
   } catch (error) {
-    console.error(`Failed to delete transcript ${sessionId}:`, error);
+    log.error({ err: error }, `Failed to delete transcript ${sessionId}`);
     return false;
   }
 }
@@ -154,10 +154,10 @@ function archiveTranscript(sessionId) {
   }
   try {
     renameSync(transcriptPath, archivePath);
-    console.log(`\u{1F4E6} Archived transcript: ${sessionId} \u2192 ${timestamp}.archived`);
+    log.info(`Archived transcript: ${sessionId} \u2192 ${timestamp}.archived`);
     return true;
   } catch (error) {
-    console.error(`Failed to archive transcript ${sessionId}:`, error);
+    log.error({ err: error }, `Failed to archive transcript ${sessionId}`);
     return false;
   }
 }
@@ -179,10 +179,10 @@ function cleanupOldTranscripts(maxAgeDays = 30) {
       }
     }
   } catch (error) {
-    console.error("Failed to cleanup old transcripts:", error);
+    log.error({ err: error }, "Failed to cleanup old transcripts");
   }
   if (deleted > 0) {
-    console.log(`\u{1F9F9} Cleaned up ${deleted} transcript(s) older than ${maxAgeDays} days`);
+    log.info(`Cleaned up ${deleted} transcript(s) older than ${maxAgeDays} days`);
   }
   return deleted;
 }