teleton 0.8.1 → 0.8.3

package/dist/chunk-FUNF6H4W.js

@@ -0,0 +1,251 @@
+import {
+  COINGECKO_API_URL,
+  tonapiFetch
+} from "./chunk-VFA7QMCZ.js";
+import {
+  fetchWithTimeout
+} from "./chunk-XQUHC3JZ.js";
+import {
+  TELETON_ROOT
+} from "./chunk-EYWNOHMJ.js";
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/ton/endpoint.ts
+var ENDPOINT_CACHE_TTL_MS = 6e4;
+var ORBS_HOST = "ton.access.orbs.network";
+var ORBS_TOPOLOGY_URL = `https://${ORBS_HOST}/mngr/nodes?npm_version=2.3.3`;
+var TONCENTER_URL = `https://toncenter.com/api/v2/jsonRPC`;
+var _cache = null;
+var _toncenterApiKey;
+function setToncenterApiKey(key) {
+  _toncenterApiKey = key;
+}
+function getToncenterApiKey() {
+  return _toncenterApiKey;
+}
+async function discoverOrbsEndpoint() {
+  const res = await fetch(ORBS_TOPOLOGY_URL, { signal: AbortSignal.timeout(5e3) });
+  const nodes = await res.json();
+  const healthy = nodes.filter(
+    (n) => n.Healthy === "1" && n.Weight > 0 && n.Mngr?.health?.["v2-mainnet"]
+  );
+  if (healthy.length === 0) throw new Error("no healthy orbs nodes");
+  const totalWeight = healthy.reduce((sum, n) => sum + n.Weight, 0);
+  let r = Math.floor(Math.random() * totalWeight);
+  let chosen = healthy[0];
+  for (const node of healthy) {
+    r -= node.Weight;
+    if (r < 0) {
+      chosen = node;
+      break;
+    }
+  }
+  return `https://${ORBS_HOST}/${chosen.NodeId}/1/mainnet/toncenter-api-v2/jsonRPC`;
+}
+async function getCachedHttpEndpoint() {
+  if (_cache && Date.now() - _cache.ts < ENDPOINT_CACHE_TTL_MS) {
+    return _cache.url;
+  }
+  let url;
+  if (_toncenterApiKey) {
+    try {
+      const testUrl = `https://toncenter.com/api/v2/getAddressInformation?address=EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c`;
+      const res = await fetch(testUrl, {
+        headers: { "X-API-Key": _toncenterApiKey },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!res.ok) throw new Error(`TonCenter ${res.status}`);
+      url = TONCENTER_URL;
+    } catch {
+      try {
+        url = await discoverOrbsEndpoint();
+      } catch {
+        url = TONCENTER_URL;
+      }
+    }
+  } else {
+    try {
+      url = await discoverOrbsEndpoint();
+    } catch {
+      url = TONCENTER_URL;
+    }
+  }
+  _cache = { url, ts: Date.now() };
+  return url;
+}
+function invalidateEndpointCache() {
+  _cache = null;
+}
+
+// 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;
+var _tonClientCache = 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 getCachedTonClient() {
+  const endpoint = await getCachedHttpEndpoint();
+  if (_tonClientCache && _tonClientCache.endpoint === endpoint) {
+    return _tonClientCache.client;
+  }
+  const apiKey = getToncenterApiKey();
+  const client = new TonClient({ endpoint, ...apiKey && { apiKey } });
+  _tonClientCache = { client, endpoint };
+  return client;
+}
+function invalidateTonClientCache() {
+  _tonClientCache = null;
+  invalidateEndpointCache();
+}
+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 client = await getCachedTonClient();
+    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;
+}
+
+export {
+  setToncenterApiKey,
+  invalidateEndpointCache,
+  generateWallet,
+  saveWallet,
+  loadWallet,
+  walletExists,
+  importWallet,
+  getWalletAddress,
+  getCachedTonClient,
+  invalidateTonClientCache,
+  getKeyPair,
+  getWalletBalance,
+  getTonPrice
+};

package/dist/{chunk-7U7BOHCL.js → chunk-GHMXWAXI.js}

@@ -3,20 +3,24 @@ import {
   createEmbeddingProvider,
   hashText,
   serializeEmbedding
-} from "./chunk-3S4GGLLR.js";
+} from "./chunk-35MX4ZUI.js";
 import {
   FEED_MESSAGE_MAX_CHARS,
   HYBRID_SEARCH_MIN_SCORE,
   KNOWLEDGE_CHUNK_SIZE,
+  RECENCY_DECAY_FACTOR,
+  RECENCY_WEIGHT,
+  SECONDS_PER_DAY,
+  SECONDS_PER_HOUR,
   SQLITE_CACHE_SIZE_KB,
   SQLITE_MMAP_SIZE
-} from "./chunk-UP55PXFH.js";
+} from "./chunk-C4NKJT2Z.js";
 import {
   TELETON_ROOT
 } from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/memory/database.ts
 import Database2 from "better-sqlite3";
@@ -456,9 +460,11 @@ function ensureVectorTables(db, dimensions) {
     WHERE type='table' AND name='knowledge_vec'
   `
   ).get();
+  let dimensionsChanged = false;
   if (existingDims?.sql && !existingDims.sql.includes(`[${dimensions}]`)) {
     db.exec(`DROP TABLE IF EXISTS knowledge_vec`);
     db.exec(`DROP TABLE IF EXISTS tg_messages_vec`);
+    dimensionsChanged = true;
   }
   db.exec(`
     CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_vec USING vec0(
@@ -471,6 +477,7 @@ function ensureVectorTables(db, dimensions) {
       embedding FLOAT[${dimensions}] distance_metric=cosine
     );
   `);
+  return dimensionsChanged;
 }
 function getSchemaVersion(db) {
   const row = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
@@ -762,6 +769,7 @@ var MemoryDatabase = class {
   db;
   config;
   vectorReady = false;
+  _dimensionsChanged = false;
   constructor(config) {
     this.config = config;
     const dir = dirname2(config.path);
@@ -773,7 +781,8 @@ var MemoryDatabase = class {
     });
     try {
       chmodSync2(config.path, 384);
-    } catch {
+    } catch (err) {
+      log3.warn({ err, path: config.path }, "Failed to set DB file permissions to 0o600");
     }
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
@@ -787,7 +796,8 @@ var MemoryDatabase = class {
     let currentVersion = null;
     try {
       currentVersion = getSchemaVersion(this.db);
-    } catch {
+    } catch (err) {
+      log3.warn({ err }, "Could not read schema version, assuming fresh database");
       currentVersion = null;
     }
     if (!currentVersion) {
@@ -806,7 +816,7 @@ var MemoryDatabase = class {
       sqliteVec.load(this.db);
       this.db.prepare("SELECT vec_version() as vec_version").get();
       const dims = this.config.vectorDimensions ?? 512;
-      ensureVectorTables(this.db, dims);
+      this._dimensionsChanged = ensureVectorTables(this.db, dims);
       this.vectorReady = true;
     } catch (error) {
       log3.warn(`sqlite-vec not available, vector search disabled: ${error.message}`);
@@ -826,6 +836,9 @@ var MemoryDatabase = class {
   isVectorSearchReady() {
     return this.vectorReady;
   }
+  didDimensionsChange() {
+    return this._dimensionsChanged;
+  }
   getVectorDimensions() {
     return this.config.vectorDimensions;
   }
@@ -847,21 +860,24 @@ var MemoryDatabase = class {
     }
   }
   getStats() {
-    const knowledge = this.db.prepare(`SELECT COUNT(*) as c FROM knowledge`).get();
-    const sessions = this.db.prepare(`SELECT COUNT(*) as c FROM sessions`).get();
-    const tasks = this.db.prepare(`SELECT COUNT(*) as c FROM tasks`).get();
-    const tgChats = this.db.prepare(`SELECT COUNT(*) as c FROM tg_chats`).get();
-    const tgUsers = this.db.prepare(`SELECT COUNT(*) as c FROM tg_users`).get();
-    const tgMessages = this.db.prepare(`SELECT COUNT(*) as c FROM tg_messages`).get();
-    const embeddingCache = this.db.prepare(`SELECT COUNT(*) as c FROM embedding_cache`).get();
+    const counts = this.db.prepare(
+      `SELECT
+          (SELECT COUNT(*) FROM knowledge)       as knowledge,
+          (SELECT COUNT(*) FROM sessions)        as sessions,
+          (SELECT COUNT(*) FROM tasks)           as tasks,
+          (SELECT COUNT(*) FROM tg_chats)        as tg_chats,
+          (SELECT COUNT(*) FROM tg_users)        as tg_users,
+          (SELECT COUNT(*) FROM tg_messages)     as tg_messages,
+          (SELECT COUNT(*) FROM embedding_cache) as embedding_cache`
+    ).get();
     return {
-      knowledge: knowledge.c,
-      sessions: sessions.c,
-      tasks: tasks.c,
-      tgChats: tgChats.c,
-      tgUsers: tgUsers.c,
-      tgMessages: tgMessages.c,
-      embeddingCache: embeddingCache.c,
+      knowledge: counts.knowledge,
+      sessions: counts.sessions,
+      tasks: counts.tasks,
+      tgChats: counts.tg_chats,
+      tgUsers: counts.tg_users,
+      tgMessages: counts.tg_messages,
+      embeddingCache: counts.embedding_cache,
       vectorSearchEnabled: this.vectorReady
     };
   }
@@ -929,12 +945,12 @@ var KnowledgeIndexer = class {
     this.embedder = embedder;
     this.vectorEnabled = vectorEnabled;
   }
-  async indexAll() {
+  async indexAll(options) {
     const files = this.listMemoryFiles();
     let indexed = 0;
     let skipped = 0;
     for (const file of files) {
-      const wasIndexed = await this.indexFile(file);
+      const wasIndexed = await this.indexFile(file, options?.force);
       if (wasIndexed) {
         indexed++;
       } else {
@@ -943,16 +959,18 @@ var KnowledgeIndexer = class {
     }
     return { indexed, skipped };
   }
-  async indexFile(absPath) {
+  async indexFile(absPath, force) {
     if (!existsSync3(absPath) || !absPath.endsWith(".md")) {
       return false;
     }
     const content = readFileSync(absPath, "utf-8");
     const relPath = absPath.replace(this.workspaceDir + "/", "");
     const fileHash = hashText(content);
-    const existing = this.db.prepare(`SELECT hash FROM knowledge WHERE path = ? AND source = 'memory' LIMIT 1`).get(relPath);
-    if (existing?.hash === fileHash) {
-      return false;
+    if (!force) {
+      const existing = this.db.prepare(`SELECT hash FROM knowledge WHERE path = ? AND source = 'memory' LIMIT 1`).get(relPath);
+      if (existing?.hash === fileHash) {
+        return false;
+      }
     }
     const chunks = this.chunkMarkdown(content, relPath);
     const texts = chunks.map((c) => c.text);
@@ -981,7 +999,7 @@ var KnowledgeIndexer = class {
           serializeEmbedding(embedding),
           chunk.startLine,
           chunk.endLine,
-          chunk.hash
+          fileHash
         );
         if (insertVec && embedding.length > 0) {
           insertVec.run(chunk.id, serializeEmbedding(embedding));
@@ -1022,6 +1040,7 @@ var KnowledgeIndexer = class {
     let startLine = 1;
     let currentLine = 1;
     let inCodeBlock = false;
+    let overlapPrefix = "";
     const flushChunk = () => {
       const text = currentChunk.trim();
       if (text.length > 0) {
@@ -1034,8 +1053,10 @@ var KnowledgeIndexer = class {
           endLine: currentLine - 1,
           hash: hashText(text)
         });
+        const nonEmpty = text.split("\n").filter((l) => l.trim());
+        overlapPrefix = nonEmpty.length > 0 ? nonEmpty.slice(-2).join("\n") + "\n" : "";
       }
-      currentChunk = "";
+      currentChunk = overlapPrefix;
       startLine = currentLine;
     };
     for (const line of lines) {
@@ -1559,6 +1580,33 @@ var UserStore = class {
 
 // src/memory/search/hybrid.ts
 var log5 = createLogger("Memory");
+var UNIT_SECONDS = {
+  hour: SECONDS_PER_HOUR,
+  day: SECONDS_PER_DAY,
+  week: 7 * SECONDS_PER_DAY,
+  month: 30 * SECONDS_PER_DAY
+};
+function parseTemporalIntent(query) {
+  const now = Math.floor(Date.now() / 1e3);
+  const lower = query.toLowerCase();
+  const agoMatch = lower.match(/(\d+)\s*(day|hour|week|month)s?\s*ago/);
+  if (agoMatch) {
+    const n = parseInt(agoMatch[1], 10);
+    return { afterTimestamp: now - n * (UNIT_SECONDS[agoMatch[2]] ?? SECONDS_PER_DAY) };
+  }
+  const lastNMatch = lower.match(/last\s+(\d+)\s*(day|hour|week|month)s?/);
+  if (lastNMatch) {
+    const n = parseInt(lastNMatch[1], 10);
+    return { afterTimestamp: now - n * (UNIT_SECONDS[lastNMatch[2]] ?? SECONDS_PER_DAY) };
+  }
+  if (/\btoday\b/.test(lower)) return { afterTimestamp: now - SECONDS_PER_DAY };
+  if (/\byesterday\b/.test(lower)) return { afterTimestamp: now - 2 * SECONDS_PER_DAY };
+  if (/\blast\s+week\b/.test(lower)) return { afterTimestamp: now - 7 * SECONDS_PER_DAY };
+  if (/\bthis\s+week\b/.test(lower)) return { afterTimestamp: now - 7 * SECONDS_PER_DAY };
+  if (/\blast\s+month\b/.test(lower)) return { afterTimestamp: now - 30 * SECONDS_PER_DAY };
+  if (/\brecently?\b/.test(lower)) return { afterTimestamp: now - 3 * SECONDS_PER_DAY };
+  return {};
+}
 function escapeFts5Query(query) {
   return query.replace(/["\*\-\+\(\)\:\^\~\?\.\@\#\$\%\&\!\[\]\{\}\|\\\/<>=,;'`]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -1579,8 +1627,18 @@ var HybridSearch = class {
     const limit = options.limit ?? 10;
     const vectorWeight = options.vectorWeight ?? 0.5;
     const keywordWeight = options.keywordWeight ?? 0.5;
-    const vectorResults = this.vectorEnabled ? this.vectorSearchMessages(queryEmbedding, Math.ceil(limit * 3), options.chatId) : [];
-    const keywordResults = this.keywordSearchMessages(query, Math.ceil(limit * 3), options.chatId);
+    const vectorResults = this.vectorEnabled ? this.vectorSearchMessages(
+      queryEmbedding,
+      Math.ceil(limit * 3),
+      options.chatId,
+      options.afterTimestamp
+    ) : [];
+    const keywordResults = this.keywordSearchMessages(
+      query,
+      Math.ceil(limit * 3),
+      options.chatId,
+      options.afterTimestamp
+    );
     return this.mergeResults(vectorResults, keywordResults, vectorWeight, keywordWeight, limit);
   }
   vectorSearchKnowledge(embedding, limit) {
@@ -1589,7 +1647,7 @@ var HybridSearch = class {
       const embeddingBuffer = serializeEmbedding(embedding);
       const rows = this.db.prepare(
         `
-        SELECT kv.id, k.text, k.source, kv.distance
+        SELECT kv.id, k.text, k.source, kv.distance, k.created_at
         FROM (
           SELECT id, distance
           FROM knowledge_vec
@@ -1603,7 +1661,8 @@ var HybridSearch = class {
         text: row.text,
         source: row.source,
         score: 1 - row.distance,
-        vectorScore: 1 - row.distance
+        vectorScore: 1 - row.distance,
+        createdAt: row.created_at ?? void 0
       }));
     } catch (error) {
       log5.error({ err: error }, "Vector search error (knowledge)");
@@ -1616,7 +1675,7 @@ var HybridSearch = class {
     try {
       const rows = this.db.prepare(
         `
-        SELECT k.id, k.text, k.source, rank as score
+        SELECT k.id, k.text, k.source, rank as score, k.created_at
         FROM knowledge_fts kf
         JOIN knowledge k ON k.rowid = kf.rowid
         WHERE knowledge_fts MATCH ?
@@ -1626,72 +1685,82 @@ var HybridSearch = class {
       ).all(safeQuery, limit);
       return rows.map((row) => ({
         ...row,
-        keywordScore: this.bm25ToScore(row.score)
+        keywordScore: this.bm25ToScore(row.score),
+        createdAt: row.created_at ?? void 0
       }));
     } catch (error) {
       log5.error({ err: error }, "FTS5 search error (knowledge)");
       return [];
     }
   }
-  vectorSearchMessages(embedding, limit, chatId) {
+  vectorSearchMessages(embedding, limit, chatId, afterTimestamp) {
     if (!this.vectorEnabled || embedding.length === 0) return [];
     try {
       const embeddingBuffer = serializeEmbedding(embedding);
-      const sql = chatId ? `
-        SELECT mv.id, m.text, m.chat_id as source, mv.distance
-        FROM (
-          SELECT id, distance
-          FROM tg_messages_vec
-          WHERE embedding MATCH ? AND k = ?
-        ) mv
-        JOIN tg_messages m ON m.id = mv.id
-        WHERE m.chat_id = ?
-      ` : `
-        SELECT mv.id, m.text, m.chat_id as source, mv.distance
+      const conditions = [];
+      const params = [embeddingBuffer, limit];
+      if (chatId) {
+        conditions.push("m.chat_id = ?");
+        params.push(chatId);
+      }
+      if (afterTimestamp) {
+        conditions.push("m.timestamp >= ?");
+        params.push(afterTimestamp);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sql = `
+        SELECT mv.id, m.text, m.chat_id as source, mv.distance, m.timestamp
         FROM (
           SELECT id, distance
           FROM tg_messages_vec
           WHERE embedding MATCH ? AND k = ?
         ) mv
         JOIN tg_messages m ON m.id = mv.id
+        ${whereClause}
       `;
-      const rows = chatId ? this.db.prepare(sql).all(embeddingBuffer, limit, chatId) : this.db.prepare(sql).all(embeddingBuffer, limit);
+      const rows = this.db.prepare(sql).all(...params);
       return rows.map((row) => ({
         id: row.id,
         text: row.text ?? "",
         source: row.source,
         score: 1 - row.distance,
-        vectorScore: 1 - row.distance
+        vectorScore: 1 - row.distance,
+        createdAt: row.timestamp ?? void 0
       }));
     } catch (error) {
       log5.error({ err: error }, "Vector search error (messages)");
       return [];
     }
   }
-  keywordSearchMessages(query, limit, chatId) {
+  keywordSearchMessages(query, limit, chatId, afterTimestamp) {
     const safeQuery = escapeFts5Query(query);
     if (!safeQuery) return [];
     try {
-      const sql = chatId ? `
-        SELECT m.id, m.text, m.chat_id as source, rank as score
-        FROM tg_messages_fts mf
-        JOIN tg_messages m ON m.rowid = mf.rowid
-        WHERE tg_messages_fts MATCH ? AND m.chat_id = ?
-        ORDER BY rank
-        LIMIT ?
-      ` : `
-        SELECT m.id, m.text, m.chat_id as source, rank as score
+      const conditions = ["tg_messages_fts MATCH ?"];
+      const params = [safeQuery];
+      if (chatId) {
+        conditions.push("m.chat_id = ?");
+        params.push(chatId);
+      }
+      if (afterTimestamp) {
+        conditions.push("m.timestamp >= ?");
+        params.push(afterTimestamp);
+      }
+      params.push(limit);
+      const sql = `
+        SELECT m.id, m.text, m.chat_id as source, rank as score, m.timestamp
         FROM tg_messages_fts mf
         JOIN tg_messages m ON m.rowid = mf.rowid
-        WHERE tg_messages_fts MATCH ?
+        WHERE ${conditions.join(" AND ")}
         ORDER BY rank
         LIMIT ?
       `;
-      const rows = chatId ? this.db.prepare(sql).all(safeQuery, chatId, limit) : this.db.prepare(sql).all(safeQuery, limit);
+      const rows = this.db.prepare(sql).all(...params);
       return rows.map((row) => ({
         ...row,
         text: row.text ?? "",
-        keywordScore: this.bm25ToScore(row.score)
+        keywordScore: this.bm25ToScore(row.score),
+        createdAt: row.timestamp ?? void 0
       }));
     } catch (error) {
       log5.error({ err: error }, "FTS5 search error (messages)");
@@ -1712,7 +1781,16 @@ var HybridSearch = class {
         byId.set(r.id, { ...r, score: keywordWeight * (r.keywordScore ?? 0) });
       }
     }
-    return Array.from(byId.values()).filter((r) => r.score >= HYBRID_SEARCH_MIN_SCORE).sort((a, b) => b.score - a.score).slice(0, limit);
+    const now = Math.floor(Date.now() / 1e3);
+    const results = Array.from(byId.values());
+    for (const r of results) {
+      if (r.createdAt) {
+        const ageDays = Math.max(0, (now - r.createdAt) / SECONDS_PER_DAY);
+        const boost = 1 / (1 + ageDays * RECENCY_DECAY_FACTOR);
+        r.score *= 1 - RECENCY_WEIGHT + RECENCY_WEIGHT * boost;
+      }
+    }
+    return results.filter((r) => r.score >= HYBRID_SEARCH_MIN_SCORE).sort((a, b) => b.score - a.score).slice(0, limit);
   }
   /**
    * Convert BM25 rank to normalized score.
@@ -1776,7 +1854,12 @@ var ContextBuilder = class {
       log6.warn({ err: error }, "Knowledge search failed");
       return [];
     }) : Promise.resolve([]);
-    const feedPromise = includeFeedHistory ? this.hybridSearch.searchMessages(query, queryEmbedding, { chatId, limit: maxRelevantChunks }).catch((error) => {
+    const { afterTimestamp } = parseTemporalIntent(query);
+    const feedPromise = includeFeedHistory ? this.hybridSearch.searchMessages(query, queryEmbedding, {
+      chatId,
+      limit: maxRelevantChunks,
+      afterTimestamp
+    }).catch((error) => {
       log6.warn({ err: error }, "Feed search failed");
       return [];
     }) : Promise.resolve([]);
@@ -1863,6 +1946,7 @@ export {
   MessageStore,
   ChatStore,
   UserStore,
+  parseTemporalIntent,
   HybridSearch,
   ContextBuilder,
   initializeMemory

package/dist/{chunk-QBHRXLZS.js → chunk-H7MFXJZK.js}

@@ -1,9 +1,9 @@
 import {
   getErrorMessage
-} from "./chunk-XBE4JB7C.js";
+} from "./chunk-3UFPFWYP.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/agent/tools/telegram/gifts/get-my-gifts.ts
 import { Type } from "@sinclair/typebox";