omnius 1.0.63 → 1.0.66

package/dist/index.js

@@ -609476,6 +609476,147 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
     return null;
   }
 }
+function parseTelegramTimeRangeQuery(query, now = /* @__PURE__ */ new Date()) {
+  const original = String(query || "");
+  const lower = original.toLowerCase();
+  const nowMs = now.getTime();
+  const dayMs = 864e5;
+  const hourMs = 36e5;
+  const minMs = 6e4;
+  const weekMs = 7 * dayMs;
+  const startOfDay = (d2) => {
+    const x = new Date(d2);
+    x.setHours(0, 0, 0, 0);
+    return x;
+  };
+  const endOfDay = (d2) => {
+    const x = new Date(d2);
+    x.setHours(23, 59, 59, 999);
+    return x;
+  };
+  let since;
+  let until;
+  let bucket;
+  let label = "";
+  let residual = original;
+  const strip = (re) => {
+    residual = residual.replace(re, " ").replace(/\s+/g, " ").trim();
+  };
+  if (/\b(oldest|earliest|first)\b/.test(lower)) {
+    bucket = "earliest";
+    label = label || "earliest";
+    strip(/\b(?:the\s+)?(?:oldest|earliest|first)(?:\s+(?:memory|entry|turn|message|memories))?\b/gi);
+  } else if (/\b(newest|latest|most\s+recent|last\s+memory|last\s+turn|last\s+message)\b/.test(lower)) {
+    bucket = "latest";
+    label = label || "latest";
+    strip(/\b(?:the\s+)?(?:newest|latest|most\s+recent|last\s+(?:memory|turn|message))\b/gi);
+  }
+  if (/\byesterday\b/.test(lower)) {
+    const y = new Date(now);
+    y.setDate(y.getDate() - 1);
+    since = startOfDay(y).getTime();
+    until = endOfDay(y).getTime();
+    label = label ? `${label}, yesterday` : "yesterday";
+    strip(/\byesterday\b/gi);
+  } else if (/\btoday\b/.test(lower)) {
+    since = startOfDay(now).getTime();
+    until = endOfDay(now).getTime();
+    label = label ? `${label}, today` : "today";
+    strip(/\btoday\b/gi);
+  }
+  const partMatch = lower.match(/\bthis\s+(morning|afternoon|evening|night|tonight)\b/);
+  if (partMatch) {
+    const today0 = startOfDay(now).getTime();
+    if (partMatch[1] === "morning") {
+      since = today0;
+      until = today0 + 12 * hourMs;
+    } else if (partMatch[1] === "afternoon") {
+      since = today0 + 12 * hourMs;
+      until = today0 + 18 * hourMs;
+    } else if (partMatch[1] === "evening") {
+      since = today0 + 17 * hourMs;
+      until = today0 + 22 * hourMs;
+    } else {
+      since = today0 + 20 * hourMs;
+      until = endOfDay(now).getTime();
+    }
+    label = label ? `${label}, this ${partMatch[1]}` : `this ${partMatch[1]}`;
+    strip(/\bthis\s+(?:morning|afternoon|evening|night|tonight)\b/gi);
+  }
+  const nMatch = lower.match(/\b(?:last|past|in\s+the\s+last|in\s+the\s+past)\s+(\d+)?\s*(minute|min|hour|hr|day|week|wk)s?\b/);
+  if (nMatch) {
+    const n2 = nMatch[1] ? parseInt(nMatch[1], 10) : 1;
+    const u = nMatch[2];
+    const stepMs = u.startsWith("min") ? minMs : u.startsWith("h") ? hourMs : u.startsWith("d") ? dayMs : weekMs;
+    since = nowMs - n2 * stepMs;
+    until = nowMs;
+    label = label ? `${label}, last ${n2} ${u}${n2 === 1 ? "" : "s"}` : `last ${n2} ${u}${n2 === 1 ? "" : "s"}`;
+    strip(/\b(?:last|past|in\s+the\s+last|in\s+the\s+past)\s+\d*\s*(?:minute|min|hour|hr|day|week|wk)s?\b/gi);
+  }
+  const agoMatch = lower.match(/\b(\d+)\s+(minute|min|hour|hr|day|week|wk)s?\s+ago\b/);
+  if (agoMatch) {
+    const n2 = parseInt(agoMatch[1], 10);
+    const u = agoMatch[2];
+    const stepMs = u.startsWith("min") ? minMs : u.startsWith("h") ? hourMs : u.startsWith("d") ? dayMs : weekMs;
+    const center = nowMs - n2 * stepMs;
+    if (u.startsWith("d")) {
+      const at = new Date(center);
+      since = startOfDay(at).getTime();
+      until = endOfDay(at).getTime();
+    } else {
+      since = center - stepMs;
+      until = center + stepMs;
+    }
+    label = label ? `${label}, ${n2} ${u}${n2 === 1 ? "" : "s"} ago` : `${n2} ${u}${n2 === 1 ? "" : "s"} ago`;
+    strip(/\b\d+\s+(?:minute|min|hour|hr|day|week|wk)s?\s+ago\b/gi);
+  }
+  if (/\bearlier\s+today\b/.test(lower)) {
+    const today0 = startOfDay(now).getTime();
+    since = today0;
+    until = nowMs - 30 * minMs;
+    label = label ? `${label}, earlier today` : "earlier today";
+    strip(/\bearlier\s+today\b/gi);
+  } else if (/\bearlier\b/.test(lower) && since === void 0 && bucket === void 0) {
+    since = nowMs - dayMs;
+    until = nowMs - 30 * minMs;
+    label = label ? `${label}, earlier` : "earlier";
+    strip(/\bearlier\b/gi);
+  }
+  const sinceIsoMatch = original.match(/\bsince\s+(\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}(?::\d{2})?)?)\b/i);
+  if (sinceIsoMatch) {
+    const t2 = Date.parse(sinceIsoMatch[1]);
+    if (Number.isFinite(t2)) {
+      since = t2;
+      until = nowMs;
+      label = label ? `${label}, since ${sinceIsoMatch[1]}` : `since ${sinceIsoMatch[1]}`;
+      strip(new RegExp(`\\bsince\\s+${sinceIsoMatch[1].replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi"));
+    }
+  }
+  const onIsoMatch = original.match(/\bon\s+(\d{4}-\d{2}-\d{2})\b/i);
+  if (onIsoMatch) {
+    const t2 = Date.parse(onIsoMatch[1]);
+    if (Number.isFinite(t2)) {
+      const d2 = new Date(t2);
+      since = startOfDay(d2).getTime();
+      until = endOfDay(d2).getTime();
+      label = label ? `${label}, on ${onIsoMatch[1]}` : `on ${onIsoMatch[1]}`;
+      strip(new RegExp(`\\bon\\s+${onIsoMatch[1]}\\b`, "gi"));
+    }
+  }
+  const betweenMatch = original.match(/\bbetween\s+(\d{4}-\d{2}-\d{2})\s+and\s+(\d{4}-\d{2}-\d{2})\b/i);
+  if (betweenMatch) {
+    const a2 = Date.parse(betweenMatch[1]);
+    const b = Date.parse(betweenMatch[2]);
+    if (Number.isFinite(a2) && Number.isFinite(b)) {
+      since = Math.min(a2, b);
+      until = Math.max(a2, b) + dayMs;
+      label = label ? `${label}, between ${betweenMatch[1]} and ${betweenMatch[2]}` : `between ${betweenMatch[1]} and ${betweenMatch[2]}`;
+      strip(/\bbetween\s+\d{4}-\d{2}-\d{2}\s+and\s+\d{4}-\d{2}-\d{2}\b/gi);
+    }
+  }
+  if (since === void 0 && until === void 0 && bucket === void 0) return null;
+  return { since, until, bucket, label: label || "time-range", residualQuery: residual };
+}
 function parseTelegramReflectionFollowupDecision(text) {
   const cleaned = stripTelegramHiddenThinking(text).replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
   const jsonText = cleaned.startsWith("{") ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? "";
@@ -613237,6 +613378,213 @@ ${lines.join("\n")}`);
           return `- ${when} ${speaker}${mode}${messageId}: ${telegramContextJsonString(text, maxText)}`;
         }).join("\n");
       }
+      /**
+       * Build an always-on "memory substrate census" injected into every Telegram
+       * prompt. Anchors the agent against false-empty responses: lists counts for
+       * each store + the chat-scoped memory_read topic filenames that exist on disk.
+       *
+       * Without this, when the lexical scorers (cards/facts/episodes) score zero
+       * for the current query, NO section about those stores reaches the prompt,
+       * and the bot will report "memory empty" in good faith. This section keeps
+       * the substrate visible regardless of per-turn scoring.
+       */
+      buildTelegramMemorySubstrateCensus(sessionKey, msg) {
+        const cardCount = (this.chatMemoryCards.get(sessionKey) ?? []).length;
+        const memory = this.chatAssociativeMemory.get(sessionKey);
+        const factCount = memory?.facts.length ?? 0;
+        const relationshipCount = memory?.relationships.length ?? 0;
+        const userMemoryCount = memory ? Object.keys(memory.users).length : 0;
+        const historyCount = (this.chatHistory.get(sessionKey) ?? []).length;
+        let sqliteCount = 0;
+        let episodeCount2 = 0;
+        try {
+          const db = this.telegramDb();
+          if (db) {
+            const row = db.prepare("SELECT COUNT(*) AS n FROM telegram_messages WHERE session_key = ?").get(sessionKey);
+            sqliteCount = Number(row?.n) || 0;
+          }
+        } catch {
+        }
+        if (this.repoRoot) {
+          try {
+            const paths = omniusMemoryDbPaths(this.repoRoot);
+            if (existsSync113(paths.episodes)) {
+              const graph = new TemporalGraph(paths.knowledge);
+              const store2 = new EpisodeStore(paths.episodes, graph);
+              try {
+                const sample = store2.search({ sessionId: sessionKey, limit: 1 }) ?? [];
+                if (sample.length > 0) {
+                  const dbAny = store2.db;
+                  if (dbAny && typeof dbAny.prepare === "function") {
+                    const row = dbAny.prepare("SELECT COUNT(*) AS n FROM episodes WHERE session_id = ?").get(sessionKey);
+                    episodeCount2 = Number(row?.n) || 0;
+                  } else {
+                    episodeCount2 = 1;
+                  }
+                }
+              } finally {
+                try {
+                  store2.close();
+                } catch {
+                }
+                try {
+                  graph.close();
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        const chatId = msg.chatId;
+        const topicFiles = [];
+        if (this.repoRoot && chatId !== void 0) {
+          try {
+            const memDir = resolve43(this.repoRoot, ".omnius", "memory");
+            if (existsSync113(memDir)) {
+              const prefix = this.telegramScopedMemoryPrefix(chatId);
+              for (const file of readdirSync40(memDir)) {
+                if (!file.endsWith(".json") || !file.startsWith(prefix)) continue;
+                const topic = file.slice(prefix.length, -".json".length);
+                if (topic) topicFiles.push(topic);
+              }
+            }
+          } catch {
+          }
+        }
+        const anyMemory = cardCount + factCount + relationshipCount + userMemoryCount + sqliteCount + episodeCount2 + topicFiles.length > 0;
+        if (!anyMemory && historyCount === 0) return "";
+        const lines = [
+          "### Scoped Memory Substrate (this chat — ALWAYS PRESENT)",
+          "Persistent memory IS available for this chat. The current turn's lexical scorers may",
+          "have surfaced 0 matches above — that does NOT mean the substrate is empty. Counts:",
+          `- Memory cards: ${cardCount}`,
+          `- Associative facts: ${factCount}`,
+          `- Associative relationships: ${relationshipCount}`,
+          `- Per-user memories: ${userMemoryCount}`,
+          `- Rolling history entries retained: ${historyCount}`,
+          `- SQLite mirror rows: ${sqliteCount}`,
+          `- Episodes (durable, day+ scope): ${episodeCount2}`
+        ];
+        if (topicFiles.length > 0) {
+          lines.push("");
+          lines.push("Per-topic memory files (call memory_read with one of these `topic` values):");
+          for (const topic of topicFiles.slice(0, 80)) {
+            lines.push(`  - ${topic}`);
+          }
+        }
+        const sourceHistory = this.chatHistory.get(sessionKey) ?? [];
+        const sortedByTs = [...sourceHistory].filter((e2) => typeof e2.ts === "number" && Number.isFinite(e2.ts)).sort((a2, b) => (a2.ts ?? 0) - (b.ts ?? 0));
+        const fmtHistoryAnchor = (entry) => {
+          const when = entry.ts ? new Date(entry.ts).toISOString() : "(unknown ts)";
+          const speaker = telegramHistorySpeaker(entry);
+          const mode = entry.mode ? `/${entry.mode}` : "";
+          const messageId = entry.messageId ? ` msg:${entry.messageId}` : "";
+          return `${when} ${speaker}${mode}${messageId}: ${telegramContextJsonString(String(entry.text || ""), 320)}`;
+        };
+        if (sortedByTs.length > 0) {
+          lines.push("");
+          lines.push("Chronological anchors — Telegram conversation history (ground truth for 'oldest/newest memory' questions):");
+          lines.push(`  EARLIEST turn: ${fmtHistoryAnchor(sortedByTs[0])}`);
+          if (sortedByTs.length > 1) {
+            lines.push(`  LATEST turn:   ${fmtHistoryAnchor(sortedByTs[sortedByTs.length - 1])}`);
+          }
+          if (sortedByTs.length > 2) {
+            lines.push(`  2nd earliest:  ${fmtHistoryAnchor(sortedByTs[1])}`);
+          }
+          if (sortedByTs.length > 3) {
+            lines.push(`  3rd earliest:  ${fmtHistoryAnchor(sortedByTs[2])}`);
+          }
+        }
+        if (this.repoRoot) {
+          try {
+            const paths = omniusMemoryDbPaths(this.repoRoot);
+            if (existsSync113(paths.episodes)) {
+              const graph = new TemporalGraph(paths.knowledge);
+              const store2 = new EpisodeStore(paths.episodes, graph);
+              try {
+                const dbAny = store2.db;
+                if (dbAny && typeof dbAny.prepare === "function") {
+                  const earliest = dbAny.prepare(
+                    "SELECT timestamp, modality, tool_name, content, gist FROM episodes WHERE session_id = ? ORDER BY timestamp ASC LIMIT 1"
+                  ).get(sessionKey);
+                  const latest = dbAny.prepare(
+                    "SELECT timestamp, modality, tool_name, content, gist FROM episodes WHERE session_id = ? ORDER BY timestamp DESC LIMIT 1"
+                  ).get(sessionKey);
+                  if (earliest || latest) {
+                    lines.push("");
+                    lines.push("Chronological anchors — episodes.db (durable, may reach further back than rolling history):");
+                    const fmtEp = (row) => {
+                      const when = row.timestamp ? new Date(row.timestamp).toISOString() : "(unknown ts)";
+                      const tag = `[${row.modality || "?"}${row.tool_name ? ":" + row.tool_name : ""}]`;
+                      const text = (row.gist || row.content || "").split("\n").filter((ln) => !/^(Telegram|session:|chat:|message_id:|thread_id:|speaker:|mode:)/i.test(ln.trim())).join(" ").replace(/\s+/g, " ").trim();
+                      return `${when} ${tag} ${telegramContextJsonString(text, 320)}`;
+                    };
+                    if (earliest) lines.push(`  EARLIEST episode: ${fmtEp(earliest)}`);
+                    if (latest && (!earliest || earliest.timestamp !== latest.timestamp)) lines.push(`  LATEST episode:   ${fmtEp(latest)}`);
+                  }
+                }
+              } finally {
+                try {
+                  store2.close();
+                } catch {
+                }
+                try {
+                  graph.close();
+                } catch {
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        if (this.repoRoot && chatId !== void 0 && topicFiles.length > 0) {
+          try {
+            const memDir = resolve43(this.repoRoot, ".omnius", "memory");
+            const prefix = this.telegramScopedMemoryPrefix(chatId);
+            let earliestEntry = null;
+            let latestEntry = null;
+            for (const topic of topicFiles) {
+              const file = join127(memDir, `${prefix}${topic}.json`);
+              if (!existsSync113(file)) continue;
+              let parsed;
+              try {
+                parsed = JSON.parse(readFileSync92(file, "utf8"));
+              } catch {
+                continue;
+              }
+              for (const [key, entry] of Object.entries(parsed)) {
+                if (!entry || typeof entry !== "object") continue;
+                const rawTs = entry.timestamp;
+                const ts = typeof rawTs === "string" ? Date.parse(rawTs) : typeof rawTs === "number" ? rawTs : NaN;
+                if (!Number.isFinite(ts)) continue;
+                const value2 = String(entry.value ?? "");
+                if (!earliestEntry || ts < earliestEntry.ts) earliestEntry = { topic, key, value: value2, ts };
+                if (!latestEntry || ts > latestEntry.ts) latestEntry = { topic, key, value: value2, ts };
+              }
+            }
+            if (earliestEntry || latestEntry) {
+              lines.push("");
+              lines.push("Chronological anchors — memory_write entries (most-trusted, agent-asserted):");
+              const fmtMem = (e2) => {
+                const when = new Date(e2.ts).toISOString();
+                return `${when} topic="${e2.topic}" key="${e2.key}" → ${telegramContextJsonString(e2.value, 320)}`;
+              };
+              if (earliestEntry) lines.push(`  EARLIEST memory_write: ${fmtMem(earliestEntry)}`);
+              if (latestEntry && (!earliestEntry || earliestEntry.ts !== latestEntry.ts)) lines.push(`  LATEST memory_write:   ${fmtMem(latestEntry)}`);
+            }
+          } catch {
+          }
+        }
+        lines.push("");
+        lines.push("RULES:");
+        lines.push("  1. NEVER tell the user 'memory is empty' or 'nothing has been stored' for this chat without first calling memory_search and memory_read on a relevant topic from the list above.");
+        lines.push("  2. If the structured sections (cards/facts/sqlite/episodes) above did not surface what the user asked about, that is a SCORING miss, not absence. Call memory_search with broader tokens or pick a topic above with memory_read.");
+        lines.push("  3. The rolling-history block is base context; the cards/facts/episodes are retrieval-augmented. Treat them as the same memory, surfaced different ways.");
+        lines.push("  4. For 'what is your oldest/earliest memory' or 'most recent memory' questions: answer DIRECTLY from the 'Chronological anchors' lines above. Quote the timestamp and content. Do NOT call tools first and do NOT report 'empty'.");
+        lines.push("  5. memory_search accepts NATURAL-LANGUAGE TIME phrases inside the `query` argument or explicit `since`/`until`/`bucket` args. Examples: query='what did manitcor say yesterday', query='last 3 hours', query='earlier today', query='2 days ago', query='since 2026-05-15', query='between 2026-05-15 and 2026-05-16', query='oldest memory about github', query='most recent flux discussion'. Use these for chronological/'how far back' style queries instead of guessing — the tool parses the phrase, filters by time, and returns the right window.");
+        return lines.join("\n");
+      }
       buildTelegramConversationContextStream(sessionKey, msg, maxRecent = TELEGRAM_CONTEXT_RECENT_DEFAULT) {
         this.ensureTelegramConversationLoaded(sessionKey);
         const history = this.chatHistory.get(sessionKey) ?? [];
@@ -613260,6 +613608,11 @@ ${lines.join("\n")}`);
         if (currentReplyContext) {
           sections.push(currentReplyContext);
         }
+        try {
+          const substrateCensus = this.buildTelegramMemorySubstrateCensus(sessionKey, msg);
+          if (substrateCensus) sections.push(substrateCensus);
+        } catch {
+        }
         const scopedPersonality = this.renderTelegramScopedPersonality(sessionKey, msg);
         if (scopedPersonality) {
           sections.push(scopedPersonality);
@@ -615073,7 +615426,7 @@ ${result.llmContent ?? result.output}` };
           if (tool.name === "memory_search") {
             return {
               ...tool,
-              description: "Search only this Telegram chat's isolated durable memory: raw SQLite message mirror, episode/knowledge graph recall, associative user facts, and memory cards. Supports scope=group/current_chat or scope=user with user_id/username, but never crosses into admin/private/global memory.",
+              description: "Search only this Telegram chat's isolated durable memory: raw SQLite message mirror, episode/knowledge graph recall, associative user facts, and memory cards. Supports scope=group/current_chat or scope=user with user_id/username; also supports natural-language time phrases inside the query string ('yesterday', 'last 3 hours', '2 days ago', 'earlier today', 'since 2026-05-15', 'between A and B', 'oldest', 'most recent') OR explicit since/until/bucket arguments. Never crosses into admin/private/global memory.",
               parameters: (() => {
                 const base3 = tool.parameters ?? {};
                 const props = base3["properties"] && typeof base3["properties"] === "object" && !Array.isArray(base3["properties"]) ? base3["properties"] : {};
@@ -615084,15 +615437,57 @@ ${result.llmContent ?? result.output}` };
                     scope: { type: "string", enum: ["group", "current_chat", "user"], description: "Search scope inside the current Telegram chat. scope=user defaults to the current sender when no user_id/username is supplied." },
                     user_id: { type: "number", description: "Optional Telegram user id to search within the current group only." },
                     username: { type: "string", description: "Optional Telegram username to search within the current group only." },
-                    group_id: { type: "string", description: "Optional Telegram group/chat id. Must match the current chat id; other groups are not accessible here." }
+                    group_id: { type: "string", description: "Optional Telegram group/chat id. Must match the current chat id; other groups are not accessible here." },
+                    since: { type: "string", description: "Optional lower-bound timestamp (ISO 8601 or epoch ms). Combine with `until` for an explicit window. If omitted, natural-language phrases inside `query` are auto-parsed (e.g. 'yesterday', '3 days ago')." },
+                    until: { type: "string", description: "Optional upper-bound timestamp (ISO 8601 or epoch ms)." },
+                    bucket: { type: "string", enum: ["earliest", "latest"], description: "Chronological ordering hint when there is no specific window. 'earliest' returns the oldest entries on record; 'latest' returns the newest." }
                   }
                 };
               })(),
               execute: async (args) => {
-                const query = String(args["query"] || "").trim();
+                const rawQuery = String(args["query"] || "").trim();
                 const maxResults = typeof args["max_results"] === "number" && Number.isFinite(args["max_results"]) ? Math.max(1, Math.min(20, Math.floor(args["max_results"]))) : 8;
-                if (!query) return { success: true, output: "Search query is required." };
+                if (!rawQuery) return { success: true, output: "Search query is required." };
                 this.ensureTelegramConversationLoaded(msgSessionKey);
+                const parseTimeArg = (v) => {
+                  if (v === void 0 || v === null || v === "") return void 0;
+                  if (typeof v === "number" && Number.isFinite(v)) return Math.trunc(v);
+                  if (typeof v === "string") {
+                    if (/^\d+$/.test(v.trim())) return Number(v.trim());
+                    const t2 = Date.parse(v);
+                    if (Number.isFinite(t2)) return t2;
+                  }
+                  return void 0;
+                };
+                let since = parseTimeArg(args["since"]);
+                let until = parseTimeArg(args["until"]);
+                let bucket = args["bucket"] === "earliest" || args["bucket"] === "latest" ? args["bucket"] : void 0;
+                let timeLabel = "";
+                let effectiveQuery = rawQuery;
+                if (since === void 0 && until === void 0 && bucket === void 0) {
+                  const parsed = parseTelegramTimeRangeQuery(rawQuery);
+                  if (parsed) {
+                    since = parsed.since;
+                    until = parsed.until;
+                    bucket = parsed.bucket;
+                    timeLabel = parsed.label;
+                    effectiveQuery = parsed.residualQuery || rawQuery;
+                  }
+                } else if (since !== void 0 || until !== void 0 || bucket !== void 0) {
+                  timeLabel = [
+                    since !== void 0 ? `since=${new Date(since).toISOString()}` : "",
+                    until !== void 0 ? `until=${new Date(until).toISOString()}` : "",
+                    bucket ? `bucket=${bucket}` : ""
+                  ].filter(Boolean).join(", ");
+                }
+                const inWindow = (ts) => {
+                  if (since === void 0 && until === void 0) return true;
+                  if (ts == null || !Number.isFinite(ts)) return false;
+                  if (since !== void 0 && ts < since) return false;
+                  if (until !== void 0 && ts > until) return false;
+                  return true;
+                };
+                const query = effectiveQuery.trim();
                 const currentGroupId = chatId === void 0 ? "" : String(chatId);
                 const requestedGroupId = String(args["group_id"] ?? args["chat_id"] ?? "").trim();
                 if (requestedGroupId && currentGroupId && requestedGroupId !== currentGroupId) {
@@ -615121,13 +615516,17 @@ ${result.llmContent ?? result.output}` };
                   return false;
                 });
                 const queryTokens = telegramMemoryTokens(query);
-                const cardResults = cards.map((card) => ({
+                const cardResults = cards.filter((card) => inWindow(card.updatedAt ?? card.createdAt)).map((card) => ({
                   card,
                   score: telegramMemorySimilarity(
                     queryTokens,
                     telegramMemoryTokens([card.title, card.tags.join(" "), card.speakers.join(" "), card.notes.join(" ")].join(" "))
                   )
-                })).filter((item) => item.score > 0).sort((a2, b) => b.score - a2.score || b.card.updatedAt - a2.card.updatedAt).slice(0, maxResults);
+                })).filter((item) => item.score > 0 || since !== void 0 || until !== void 0 || bucket !== void 0).sort((a2, b) => {
+                  if (bucket === "earliest") return (a2.card.updatedAt ?? 0) - (b.card.updatedAt ?? 0);
+                  if (bucket === "latest") return (b.card.updatedAt ?? 0) - (a2.card.updatedAt ?? 0);
+                  return b.score - a2.score || b.card.updatedAt - a2.card.updatedAt;
+                }).slice(0, maxResults);
                 const cardLines = cardResults.map(({ card, score }) => {
                   const notes2 = card.notes.slice(-4).map((note) => `  - ${truncateTelegramContextLine(note, 220)}`).join("\n");
                   const tags = card.tags.length ? ` tags:${card.tags.slice(0, 8).join(",")}` : "";
@@ -615140,13 +615539,17 @@ ${notes2}`;
                   if (!wantsUserScope) return true;
                   if (effectiveUserId !== void 0 && fact.userIds.includes(effectiveUserId)) return true;
                   return !!effectiveUsername && fact.usernames.includes(effectiveUsername);
-                }).map((fact) => ({
+                }).filter((fact) => inWindow(fact.updatedAt ?? fact.createdAt)).map((fact) => ({
                   fact,
                   score: telegramMemorySimilarity(
                     queryTokens,
                     telegramMemoryTokens([fact.text, fact.tags.join(" "), fact.speakers.join(" ")].join(" "))
                   ) + (effectiveUserId !== void 0 && fact.userIds.includes(effectiveUserId) ? 0.3 : 0) + (effectiveUsername && fact.usernames.includes(effectiveUsername) ? 0.3 : 0)
-                })).filter((item) => item.score > 0).sort((a2, b) => b.score - a2.score || b.fact.updatedAt - a2.fact.updatedAt).slice(0, maxResults) : [];
+                })).filter((item) => item.score > 0 || since !== void 0 || until !== void 0 || bucket !== void 0).sort((a2, b) => {
+                  if (bucket === "earliest") return (a2.fact.updatedAt ?? 0) - (b.fact.updatedAt ?? 0);
+                  if (bucket === "latest") return (b.fact.updatedAt ?? 0) - (a2.fact.updatedAt ?? 0);
+                  return b.score - a2.score || b.fact.updatedAt - a2.fact.updatedAt;
+                }).slice(0, maxResults) : [];
                 const rawRows = this.searchTelegramSqliteMirrorRows(msgSessionKey, query, {
                   limit: maxResults,
                   userId: effectiveUserId,
@@ -615156,8 +615559,9 @@ ${notes2}`;
                 const historyForScan = this.chatHistory.get(msgSessionKey) ?? [];
                 const lowerQuery = query.toLowerCase().trim();
                 const queryWords = lowerQuery.split(/\s+/).filter((w) => w.length >= 3);
+                const hasTimeConstraint = since !== void 0 || until !== void 0 || bucket !== void 0;
                 const rawHistoryMatches = [];
-                if (historyForScan.length > 0 && lowerQuery.length > 0) {
+                if (historyForScan.length > 0) {
                   for (const entry of historyForScan) {
                     if (wantsUserScope) {
                       const eUser = entry.fromUserId;
@@ -615165,15 +615569,24 @@ ${notes2}`;
                       const matchesUser = effectiveUserId !== void 0 && eUser === effectiveUserId || effectiveUsername.length > 0 && eName === effectiveUsername;
                       if (!matchesUser) continue;
                     }
+                    if (!inWindow(entry.ts ?? null)) continue;
                     const hay = String(entry.text || "").toLowerCase();
                     if (!hay) continue;
-                    const hasExact = hay.includes(lowerQuery);
-                    const tokenHits = queryWords.filter((w) => hay.includes(w)).length;
-                    if (hasExact || queryWords.length > 0 && tokenHits >= Math.min(2, queryWords.length)) {
+                    let lexMatch = false;
+                    if (lowerQuery.length > 0) {
+                      const hasExact = hay.includes(lowerQuery);
+                      const tokenHits = queryWords.filter((w) => hay.includes(w)).length;
+                      lexMatch = hasExact || queryWords.length > 0 && tokenHits >= Math.min(2, queryWords.length);
+                    }
+                    if (lexMatch || hasTimeConstraint) {
                       rawHistoryMatches.push(entry);
                     }
                   }
-                  rawHistoryMatches.sort((a2, b) => (b.ts ?? 0) - (a2.ts ?? 0));
+                  if (bucket === "earliest") {
+                    rawHistoryMatches.sort((a2, b) => (a2.ts ?? 0) - (b.ts ?? 0));
+                  } else {
+                    rawHistoryMatches.sort((a2, b) => (b.ts ?? 0) - (a2.ts ?? 0));
+                  }
                 }
                 const rawHistorySliced = rawHistoryMatches.slice(0, maxResults);
                 const scopeLabel = wantsUserScope ? `user ${effectiveUsername ? `@${effectiveUsername}` : `id ${effectiveUserId}`}` : `chat ${currentGroupId || msgSessionKey}`;
@@ -615220,8 +615633,9 @@ ${lines.join("\n")}`
                     output: `No structured matches for "${query}" in ${scopeLabel}, but the scope IS populated: ${scannedCount} memory cards, ${associativeCount} associative facts, ${historyCount} history entries scanned. Try a broader query (single keyword), a different angle (related concept), or memory_read with topic="${this.telegramScopedTopic(chatId, "general")}" to enumerate. If you're looking for an older turn, ask for the speaker name plus a topic word.`
                   };
                 }
+                const timeBanner = timeLabel ? ` (time-range: ${timeLabel}${since !== void 0 || until !== void 0 ? `; window=${since !== void 0 ? new Date(since).toISOString() : "−∞"} → ${until !== void 0 ? new Date(until).toISOString() : "+∞"}` : ""})` : "";
                 const output = [
-                  `Scoped Telegram memory search for "${query}" in ${scopeLabel}.`,
+                  `Scoped Telegram memory search for "${query}" in ${scopeLabel}${timeBanner}.`,
                   "Results are scoped to this Telegram chat and may include raw message evidence, graph episodes, associative facts, and memory cards.",
                   "",
                   sections.join("\n\n")

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.63",
+  "version": "1.0.66",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.63",
+      "version": "1.0.66",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.63",
+  "version": "1.0.66",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",