teleton 0.1.0

package/dist/get-my-gifts-YKUHPRGS.js

@@ -0,0 +1,8 @@
+import {
+  telegramGetMyGiftsExecutor,
+  telegramGetMyGiftsTool
+} from "./chunk-XBGUNXF2.js";
+export {
+  telegramGetMyGiftsExecutor,
+  telegramGetMyGiftsTool
+};

package/dist/index.js

@@ -0,0 +1,12 @@
+import {
+  TonnetApp,
+  main
+} from "./chunk-WXVHT6CI.js";
+import "./chunk-XBGUNXF2.js";
+import "./chunk-WDUHRPGA.js";
+import "./chunk-UR2LQEKR.js";
+import "./chunk-7NJ46ZIX.js";
+export {
+  TonnetApp,
+  main
+};

package/dist/memory-O5NYYWF3.js

@@ -0,0 +1,60 @@
+import {
+  AnthropicEmbeddingProvider,
+  CURRENT_SCHEMA_VERSION,
+  ChatStore,
+  ContextBuilder,
+  HybridSearch,
+  KnowledgeIndexer,
+  LocalEmbeddingProvider,
+  MemoryDatabase,
+  MessageStore,
+  NoopEmbeddingProvider,
+  SessionStore,
+  UserStore,
+  closeDatabase,
+  createEmbeddingProvider,
+  deserializeEmbedding,
+  embeddingToBlob,
+  ensureSchema,
+  ensureVectorTables,
+  getDatabase,
+  getSchemaVersion,
+  hashText,
+  initializeMemory,
+  runMigrations,
+  serializeEmbedding,
+  setSchemaVersion
+} from "./chunk-WDUHRPGA.js";
+import {
+  TaskStore,
+  getTaskStore
+} from "./chunk-UR2LQEKR.js";
+export {
+  AnthropicEmbeddingProvider,
+  CURRENT_SCHEMA_VERSION,
+  ChatStore,
+  ContextBuilder,
+  HybridSearch,
+  KnowledgeIndexer,
+  LocalEmbeddingProvider,
+  MemoryDatabase,
+  MessageStore,
+  NoopEmbeddingProvider,
+  SessionStore,
+  TaskStore,
+  UserStore,
+  closeDatabase,
+  createEmbeddingProvider,
+  deserializeEmbedding,
+  embeddingToBlob,
+  ensureSchema,
+  ensureVectorTables,
+  getDatabase,
+  getSchemaVersion,
+  getTaskStore,
+  hashText,
+  initializeMemory,
+  runMigrations,
+  serializeEmbedding,
+  setSchemaVersion
+};

package/dist/migrate-25RH22HJ.js

@@ -0,0 +1,59 @@
+import {
+  getDatabase
+} from "./chunk-WDUHRPGA.js";
+import "./chunk-UR2LQEKR.js";
+import {
+  TELETON_ROOT
+} from "./chunk-7NJ46ZIX.js";
+
+// src/session/migrate.ts
+import { readFileSync, existsSync, renameSync } from "fs";
+import { join } from "path";
+var SESSIONS_JSON = join(TELETON_ROOT, "sessions.json");
+var SESSIONS_JSON_BACKUP = join(TELETON_ROOT, "sessions.json.backup");
+function migrateSessionsToDb() {
+  if (!existsSync(SESSIONS_JSON)) {
+    return 0;
+  }
+  try {
+    console.log("\u{1F504} Migrating sessions from JSON to SQLite...");
+    const raw = readFileSync(SESSIONS_JSON, "utf-8");
+    const store = JSON.parse(raw);
+    const db = getDatabase().getDb();
+    let migrated = 0;
+    const insertStmt = db.prepare(`
+      INSERT OR REPLACE INTO sessions (
+        id, chat_id, started_at, updated_at, message_count,
+        last_message_id, last_channel, last_to, context_tokens,
+        model, provider, last_reset_date
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const [chatId, session] of Object.entries(store)) {
+      insertStmt.run(
+        session.sessionId,
+        chatId,
+        session.createdAt,
+        session.updatedAt,
+        session.messageCount || 0,
+        session.lastMessageId || null,
+        session.lastChannel || null,
+        session.lastTo || null,
+        session.contextTokens || null,
+        session.model || null,
+        session.provider || null,
+        session.lastResetDate || null
+      );
+      migrated++;
+    }
+    renameSync(SESSIONS_JSON, SESSIONS_JSON_BACKUP);
+    console.log(`\u2705 Migrated ${migrated} sessions to SQLite`);
+    console.log(`   Backup saved: ${SESSIONS_JSON_BACKUP}`);
+    return migrated;
+  } catch (error) {
+    console.error("\u274C Failed to migrate sessions:", error);
+    return 0;
+  }
+}
+export {
+  migrateSessionsToDb
+};

package/dist/paths-STCOKEXS.js

@@ -0,0 +1,14 @@
+import {
+  ALLOWED_EXTENSIONS,
+  MAX_FILE_SIZES,
+  TELETON_ROOT,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-7NJ46ZIX.js";
+export {
+  ALLOWED_EXTENSIONS,
+  MAX_FILE_SIZES,
+  TELETON_ROOT,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+};

package/dist/scraper-DW5Z2AP5.js

@@ -0,0 +1,377 @@
+import {
+  TELETON_ROOT
+} from "./chunk-7NJ46ZIX.js";
+
+// src/market/scraper.ts
+import { chromium } from "playwright";
+
+// src/market/scraper-db.ts
+import Database from "better-sqlite3";
+import { join } from "path";
+var DB_PATH = join(TELETON_ROOT, "gifts.db");
+function initScraperDb() {
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    -- Collections (Plush Pepes, Heart Lockets, etc.)
+    CREATE TABLE IF NOT EXISTS gift_collections (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      address TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      floor_ton REAL,
+      floor_usd REAL,
+      volume_7d REAL,
+      listed_count INTEGER,
+      owners INTEGER,
+      supply INTEGER,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    -- Mod\xE8les par collection (Cozy Galaxy, Milano, etc.)
+    CREATE TABLE IF NOT EXISTS gift_models (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      collection_id INTEGER NOT NULL,
+      name TEXT NOT NULL,
+      floor_ton REAL,
+      rarity_percent REAL,
+      count INTEGER,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (collection_id) REFERENCES gift_collections(id),
+      UNIQUE(collection_id, name)
+    );
+
+    -- Historique des prix (pour trends)
+    CREATE TABLE IF NOT EXISTS price_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      collection_id INTEGER,
+      model_id INTEGER,
+      floor_ton REAL NOT NULL,
+      floor_usd REAL,
+      timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+      FOREIGN KEY (collection_id) REFERENCES gift_collections(id),
+      FOREIGN KEY (model_id) REFERENCES gift_models(id)
+    );
+
+    -- Index pour les requ\xEAtes fr\xE9quentes
+    CREATE INDEX IF NOT EXISTS idx_price_history_collection ON price_history(collection_id, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_price_history_model ON price_history(model_id, timestamp);
+    CREATE INDEX IF NOT EXISTS idx_models_collection ON gift_models(collection_id);
+  `);
+  return db;
+}
+function upsertCollection(db, collection) {
+  const stmt = db.prepare(`
+    INSERT INTO gift_collections (address, name, floor_ton, floor_usd, volume_7d, updated_at)
+    VALUES (@address, @name, @floor_ton, @floor_usd, @volume_7d, CURRENT_TIMESTAMP)
+    ON CONFLICT(address) DO UPDATE SET
+      name = @name,
+      floor_ton = @floor_ton,
+      floor_usd = @floor_usd,
+      volume_7d = @volume_7d,
+      updated_at = CURRENT_TIMESTAMP
+    RETURNING id
+  `);
+  const result = stmt.get({
+    address: collection.address,
+    name: collection.name,
+    floor_ton: collection.floorTON || null,
+    floor_usd: collection.floorUSD || null,
+    volume_7d: collection.volume7d || null
+  });
+  return result.id;
+}
+function upsertModel(db, collectionId, model) {
+  const stmt = db.prepare(`
+    INSERT INTO gift_models (collection_id, name, floor_ton, rarity_percent, count, updated_at)
+    VALUES (@collection_id, @name, @floor_ton, @rarity_percent, @count, CURRENT_TIMESTAMP)
+    ON CONFLICT(collection_id, name) DO UPDATE SET
+      floor_ton = @floor_ton,
+      rarity_percent = @rarity_percent,
+      count = @count,
+      updated_at = CURRENT_TIMESTAMP
+    RETURNING id
+  `);
+  const result = stmt.get({
+    collection_id: collectionId,
+    name: model.name,
+    floor_ton: model.floor || null,
+    rarity_percent: model.pct ? parseFloat(model.pct) : null,
+    count: model.count || null
+  });
+  return result.id;
+}
+function addPriceHistory(db, collectionId, modelId, floorTon, floorUsd = null) {
+  const stmt = db.prepare(`
+    INSERT INTO price_history (collection_id, model_id, floor_ton, floor_usd)
+    VALUES (?, ?, ?, ?)
+  `);
+  stmt.run(collectionId, modelId, floorTon, floorUsd);
+}
+function getScraperStats(db) {
+  const collections = db.prepare("SELECT COUNT(*) as count FROM gift_collections").get();
+  const models = db.prepare("SELECT COUNT(*) as count FROM gift_models").get();
+  const history = db.prepare("SELECT COUNT(*) as count FROM price_history").get();
+  const lastUpdate = db.prepare("SELECT MAX(updated_at) as last FROM gift_collections").get();
+  return {
+    collections: collections.count,
+    models: models.count,
+    historyEntries: history.count,
+    lastUpdate: lastUpdate.last
+  };
+}
+
+// src/market/scraper.ts
+var BASE_URL = "https://marketapp.ws";
+var PARALLEL_WORKERS = 4;
+async function scrapeAllModels(page, collection, db) {
+  try {
+    const url = `${BASE_URL}/collection/${collection.address}/?tab=nfts`;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    await page.waitForTimeout(2500);
+    try {
+      await page.click('button:has-text("Filters")', { timeout: 3e3 });
+      await page.waitForTimeout(600);
+    } catch (e) {
+      return 0;
+    }
+    try {
+      await page.click("text=Model", { timeout: 2e3 });
+      await page.waitForTimeout(800);
+    } catch (e) {
+      return 0;
+    }
+    const allModels = /* @__PURE__ */ new Map();
+    const wrapperHeight = await page.evaluate(() => {
+      const wrappers = document.querySelectorAll(".virtual-scroll-wrapper");
+      const wrapper = wrappers[1];
+      return wrapper ? wrapper.scrollHeight : 0;
+    });
+    for (let scrollPos = 0; scrollPos <= wrapperHeight + 500; scrollPos += 250) {
+      const text = await page.evaluate((pos) => {
+        const wrappers = document.querySelectorAll(".virtual-scroll-wrapper");
+        const wrapper = wrappers[1];
+        if (wrapper) {
+          wrapper.scrollTop = pos;
+          return wrapper.innerText;
+        }
+        return "";
+      }, scrollPos);
+      if (text) {
+        const lines = text.split("\n").map((l) => l.trim()).filter((l) => l);
+        let currentModel = null;
+        for (const line of lines) {
+          if (line.length > 1 && line.length < 50 && !line.match(/^[\d,.]+$/) && !line.startsWith("Floor:") && !line.includes("%")) {
+            currentModel = { name: line, floor: null, count: null, pct: null };
+          }
+          if (line.startsWith("Floor:") && currentModel) {
+            const match = line.match(/Floor:\s*([\d,.]+)/);
+            if (match) currentModel.floor = parseFloat(match[1].replace(/,/g, ""));
+          }
+          if (currentModel && line.match(/^\d+$/) && !currentModel.count) {
+            currentModel.count = parseInt(line);
+          }
+          if (line.includes("%") && currentModel) {
+            currentModel.pct = line;
+            if (currentModel.name && currentModel.floor) {
+              allModels.set(currentModel.name, { ...currentModel });
+            }
+            currentModel = null;
+          }
+        }
+      }
+      await page.waitForTimeout(80);
+    }
+    const models = [...allModels.values()];
+    const collectionId = upsertCollection(db, {
+      address: collection.address,
+      name: collection.name
+    });
+    for (const model of models) {
+      const modelId = upsertModel(db, collectionId, model);
+      if (model.floor) {
+        addPriceHistory(db, collectionId, modelId, model.floor);
+      }
+    }
+    return models.length;
+  } catch (error) {
+    return -1;
+  }
+}
+async function createWorker(browser, db) {
+  const context = await browser.newContext({
+    userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    viewport: { width: 1920, height: 1080 }
+  });
+  const page = await context.newPage();
+  return {
+    page,
+    async scrape(collection) {
+      return await scrapeAllModels(page, collection, db);
+    },
+    async close() {
+      await context.close();
+    }
+  };
+}
+async function getCollections(page, db) {
+  await page.goto(`${BASE_URL}/?tab=gifts&sort_by=floor_desc`, {
+    waitUntil: "domcontentloaded",
+    timeout: 6e4
+  });
+  await page.waitForTimeout(4e3);
+  for (let i = 0; i < 15; i++) {
+    await page.evaluate(() => window.scrollBy(0, 2e3));
+    await page.waitForTimeout(200);
+  }
+  const collections = await page.evaluate(() => {
+    const results = [];
+    const text = document.body.innerText;
+    const lines = text.split("\n").map((l) => l.trim()).filter((l) => l);
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] === "1% fee" && i > 0) {
+        const name = lines[i - 1];
+        if (name.length < 3 || name.length > 40 || name === "Name") continue;
+        let floorTON = null;
+        let floorUSD = null;
+        let volume7d = null;
+        let skipNext = 0;
+        for (let j = i + 1; j < Math.min(i + 12, lines.length); j++) {
+          const val = lines[j];
+          if (floorTON === null && val.match(/^[\d,.]+$/)) {
+            floorTON = parseFloat(val.replace(/,/g, ""));
+            continue;
+          }
+          if (floorTON !== null && floorUSD === null && val.startsWith("~$")) {
+            floorUSD = parseFloat(val.replace("~$", "").replace(/,/g, ""));
+            skipNext = 2;
+            continue;
+          }
+          if (skipNext > 0 && (val.match(/^[\d,.]+$/) || val.startsWith("~$"))) {
+            skipNext--;
+            continue;
+          }
+          if (floorUSD !== null && volume7d === null && skipNext === 0) {
+            const volMatch = val.match(/^([\d,.]+)(K|M)?$/);
+            if (volMatch) {
+              let vol = parseFloat(volMatch[1].replace(/,/g, ""));
+              if (volMatch[2] === "K") vol *= 1e3;
+              if (volMatch[2] === "M") vol *= 1e6;
+              volume7d = vol;
+              break;
+            }
+          }
+          if (val === "1% fee") break;
+        }
+        if (name && floorTON) {
+          results.push({ name, floorTON, floorUSD, volume7d, address: null });
+        }
+      }
+    }
+    const links = document.querySelectorAll('a[href*="/collection/"]');
+    const addressMap = /* @__PURE__ */ new Map();
+    links.forEach((link) => {
+      const href = link.getAttribute("href");
+      if (!href) return;
+      const match = href.match(/\/collection\/([^/?]+)/);
+      if (match) {
+        const text2 = link.textContent?.trim().split("\n")[0];
+        if (text2 && text2.length > 2) addressMap.set(text2, match[1]);
+      }
+    });
+    return results.map((r) => ({
+      ...r,
+      address: addressMap.get(r.name) || [...addressMap.entries()].find(
+        ([k]) => k.toLowerCase().includes(r.name.toLowerCase().slice(0, 10))
+      )?.[1] || null
+    })).filter((r) => r.address);
+  });
+  for (const col of collections) {
+    const collectionId = upsertCollection(db, col);
+    addPriceHistory(db, collectionId, null, col.floorTON, col.floorUSD);
+  }
+  return collections;
+}
+async function runScraper(options) {
+  const workers = options.workers || PARALLEL_WORKERS;
+  const limit = options.limit || 0;
+  console.log("=".repeat(60));
+  console.log(`SCRAPER TOUS LES MOD\xC8LES (${workers} workers)`);
+  console.log("=".repeat(60));
+  const db = initScraperDb();
+  const startTime = Date.now();
+  let browser = null;
+  try {
+    browser = await chromium.launch({ headless: true });
+    console.log("\n1. Collections...");
+    const mainCtx = await browser.newContext({
+      userAgent: "Mozilla/5.0",
+      viewport: { width: 1920, height: 1080 }
+    });
+    const mainPage = await mainCtx.newPage();
+    const collections = await getCollections(mainPage, db);
+    await mainCtx.close();
+    console.log(`   \u2713 ${collections.length} collections`);
+    console.log(`
+2. Workers (${workers})...`);
+    const workerPool = await Promise.all(
+      Array(workers).fill(null).map(() => createWorker(browser, db))
+    );
+    const toProcess = limit > 0 ? collections.slice(0, limit) : collections;
+    console.log(`
+3. Scraping ${toProcess.length} collections (TOUS les mod\xE8les)...
+`);
+    let completed = 0;
+    let totalModels = 0;
+    const queue = [...toProcess];
+    async function processNext(worker) {
+      while (queue.length > 0) {
+        const col = queue.shift();
+        if (!col) break;
+        const count = await worker.scrape(col);
+        completed++;
+        const status = count > 0 ? `\u2713 ${count.toString().padStart(2)}` : count === 0 ? "- 0 " : "\u2717   ";
+        if (count > 0) totalModels += count;
+        const elapsed2 = ((Date.now() - startTime) / 1e3).toFixed(1);
+        console.log(
+          `   [${completed.toString().padStart(3)}/${toProcess.length}] ${col.name.padEnd(
+            22
+          )} ${status} (${elapsed2}s)`
+        );
+      }
+    }
+    await Promise.all(workerPool.map((w) => processNext(w)));
+    await Promise.all(workerPool.map((w) => w.close()));
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    const stats = getScraperStats(db);
+    console.log("\n" + "=".repeat(60));
+    console.log(`TERMIN\xC9 en ${elapsed}s`);
+    console.log("=".repeat(60));
+    console.log(`Collections: ${stats.collections}`);
+    console.log(`Mod\xE8les: ${stats.models}`);
+    console.log(`Historique: ${stats.historyEntries}`);
+    return {
+      success: true,
+      collections: stats.collections,
+      models: stats.models,
+      duration: parseInt(elapsed)
+    };
+  } catch (error) {
+    return {
+      success: false,
+      collections: 0,
+      models: 0,
+      duration: Math.round((Date.now() - startTime) / 1e3),
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (browser) {
+      await browser.close();
+    }
+    db.close();
+  }
+}
+export {
+  runScraper
+};

package/dist/task-dependency-resolver-5I62EU67.js

@@ -0,0 +1,133 @@
+// src/telegram/task-dependency-resolver.ts
+var MAX_DEPENDENTS_PER_TASK = 10;
+var BATCH_TRIGGER_DELAY_MS = 500;
+var TaskDependencyResolver = class {
+  constructor(taskStore, bridge) {
+    this.taskStore = taskStore;
+    this.bridge = bridge;
+  }
+  /**
+   * Called when a task completes successfully
+   * Triggers any dependent tasks that are now ready to execute
+   *
+   * Security: Processes at most MAX_DEPENDENTS_PER_TASK dependents
+   * to prevent DoS via mass dependency chains
+   */
+  async onTaskComplete(completedTaskId) {
+    try {
+      const allDependentIds = this.taskStore.getDependents(completedTaskId);
+      if (allDependentIds.length === 0) {
+        return;
+      }
+      const dependentIds = allDependentIds.slice(0, MAX_DEPENDENTS_PER_TASK);
+      const truncated = allDependentIds.length > MAX_DEPENDENTS_PER_TASK;
+      if (truncated) {
+        console.warn(
+          `\u26A0\uFE0F Task ${completedTaskId} has ${allDependentIds.length} dependents, only processing first ${MAX_DEPENDENTS_PER_TASK} (security limit)`
+        );
+      }
+      console.log(
+        `\u{1F4CA} Task ${completedTaskId} completed. Checking ${dependentIds.length} dependent task(s)...`
+      );
+      const tasksToTrigger = [];
+      for (const depId of dependentIds) {
+        const task = this.taskStore.getTask(depId);
+        if (!task) {
+          console.warn(`Dependent task ${depId} not found`);
+          continue;
+        }
+        if (task.status !== "pending") {
+          continue;
+        }
+        if (!this.taskStore.canExecute(depId)) {
+          console.log(`\u23F3 Task ${depId} still waiting for dependencies`);
+          continue;
+        }
+        tasksToTrigger.push(task.id);
+      }
+      for (let i = 0; i < tasksToTrigger.length; i++) {
+        if (i > 0) {
+          await this.delay(BATCH_TRIGGER_DELAY_MS);
+        }
+        await this.triggerTask(tasksToTrigger[i]);
+      }
+    } catch (error) {
+      console.error("Error in dependency resolver:", error);
+    }
+  }
+  /**
+   * Utility: delay execution
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Called when a task fails
+   * Cancels all dependent tasks (unless they have skipOnParentFailure flag)
+   *
+   * Security: Processes at most MAX_DEPENDENTS_PER_TASK dependents
+   * Cancellation is less risky than triggering but still limited for consistency
+   */
+  async onTaskFail(failedTaskId) {
+    try {
+      const allDependentIds = this.taskStore.getDependents(failedTaskId);
+      if (allDependentIds.length === 0) {
+        return;
+      }
+      const dependentIds = allDependentIds.slice(0, MAX_DEPENDENTS_PER_TASK);
+      const truncated = allDependentIds.length > MAX_DEPENDENTS_PER_TASK;
+      if (truncated) {
+        console.warn(
+          `\u26A0\uFE0F Task ${failedTaskId} has ${allDependentIds.length} dependents, only cancelling first ${MAX_DEPENDENTS_PER_TASK} (security limit)`
+        );
+      }
+      console.log(`\u274C Task ${failedTaskId} failed. Cancelling ${dependentIds.length} dependent task(s)...`);
+      for (const depId of dependentIds) {
+        const task = this.taskStore.getTask(depId);
+        if (!task || task.status !== "pending") {
+          continue;
+        }
+        let skipOnFailure = true;
+        if (task.payload) {
+          try {
+            const payload = JSON.parse(task.payload);
+            skipOnFailure = payload.skipOnParentFailure !== false;
+          } catch (e) {
+          }
+        }
+        if (skipOnFailure) {
+          this.taskStore.cancelTask(depId);
+          console.log(`  \u21B3 Cancelled task ${depId}: ${task.description}`);
+          await this.onTaskFail(depId);
+        }
+      }
+    } catch (error) {
+      console.error("Error handling task failure cascade:", error);
+    }
+  }
+  /**
+   * Trigger a task by sending [TASK:uuid] message to Saved Messages
+   */
+  async triggerTask(taskId) {
+    try {
+      const task = this.taskStore.getTask(taskId);
+      if (!task) {
+        console.warn(`Cannot trigger task ${taskId}: not found`);
+        return;
+      }
+      console.log(`\u{1F680} Triggering dependent task: ${task.description}`);
+      const gramJsClient = this.bridge.getClient().getClient();
+      const me = await gramJsClient.getMe();
+      await gramJsClient.sendMessage(me, {
+        message: `[TASK:${taskId}] ${task.description}`
+      });
+      console.log(`  \u21B3 Sent [TASK:${taskId}] to Saved Messages`);
+    } catch (error) {
+      console.error(`Error triggering task ${taskId}:`, error);
+      this.taskStore.failTask(taskId, `Failed to trigger: ${error}`);
+    }
+  }
+};
+export {
+  TaskDependencyResolver
+};