omnius 1.0.65 → 1.0.67

package/dist/index.js

@@ -552883,6 +552883,11 @@ var init_sessionMetrics = __esm({
       toolCallsByName = {};
       inputTokens = 0;
       outputTokens = 0;
+      latestEstimatedContextTokens = 0;
+      peakEstimatedContextTokens = 0;
+      measuredOutputTokens = 0;
+      totalGenerationMs = 0;
+      generationSamples = 0;
       filesModified = /* @__PURE__ */ new Set();
       tasks = [];
       currentTask = null;
@@ -552903,8 +552908,24 @@ var init_sessionMetrics = __esm({
       }
       /** Record token usage. */
       recordTokenUsage(inputTokens, outputTokens) {
-        this.inputTokens += inputTokens;
-        this.outputTokens += outputTokens;
+        this.inputTokens += Math.max(0, Math.trunc(inputTokens || 0));
+        this.outputTokens += Math.max(0, Math.trunc(outputTokens || 0));
+      }
+      /** Record the runner's latest context-token estimate. */
+      recordContextEstimate(tokens) {
+        const normalized = Math.max(0, Math.trunc(tokens || 0));
+        this.latestEstimatedContextTokens = normalized;
+        this.peakEstimatedContextTokens = Math.max(this.peakEstimatedContextTokens, normalized);
+      }
+      /** Record measured generation throughput for one response. */
+      recordGeneration(outputTokens, durationMs) {
+        const tokens = Math.max(0, Math.trunc(outputTokens || 0));
+        const duration = Math.max(0, Math.trunc(durationMs || 0));
+        if (tokens <= 0 || duration <= 0)
+          return;
+        this.measuredOutputTokens += tokens;
+        this.totalGenerationMs += duration;
+        this.generationSamples++;
       }
       /** Record a file modification. */
       recordFileModified(filePath) {
@@ -552912,6 +552933,9 @@ var init_sessionMetrics = __esm({
       }
       /** Start tracking a new task. */
       startTask(description) {
+        if (this.currentTask) {
+          this.endTask();
+        }
         this.currentTask = {
           description,
           startTime: Date.now(),
@@ -552942,6 +552966,13 @@ var init_sessionMetrics = __esm({
           toolCallsByName: { ...this.toolCallsByName },
           totalInputTokens: this.inputTokens,
           totalOutputTokens: this.outputTokens,
+          totalTokens: this.inputTokens + this.outputTokens,
+          latestEstimatedContextTokens: this.latestEstimatedContextTokens,
+          peakEstimatedContextTokens: this.peakEstimatedContextTokens,
+          measuredOutputTokens: this.measuredOutputTokens,
+          totalGenerationMs: this.totalGenerationMs,
+          generationSamples: this.generationSamples,
+          averageOutputTokensPerSecond: this.totalGenerationMs > 0 ? this.measuredOutputTokens / (this.totalGenerationMs / 1e3) : void 0,
           filesModified: [...this.filesModified],
           tasksCompleted: this.tasks.length,
           tasks: [...this.tasks],
@@ -560860,6 +560891,7 @@ function toTelegramBotCommandName(name10) {
 function buildTelegramBotCommands(opts = {}) {
   const maxCommands = Math.max(1, Math.min(100, opts.maxCommands ?? 100));
   const includeAuth = opts.includeAuth !== false;
+  const scope = opts.scope ?? "admin";
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
   const add2 = (command, description, canonical = command) => {
@@ -560872,6 +560904,14 @@ function buildTelegramBotCommands(opts = {}) {
       canonical
     });
   };
+  if (scope === "public") {
+    for (const cmd of TELEGRAM_PUBLIC_BOT_COMMANDS) {
+      if (!includeAuth && cmd.command === "auth") continue;
+      add2(cmd.command, cmd.description, cmd.canonical);
+      if (commands.length >= maxCommands) break;
+    }
+    return commands.slice(0, maxCommands);
+  }
   if (includeAuth) {
     add2("auth", "Authenticate this Telegram user as the bot admin", "auth");
   }
@@ -561071,7 +561111,7 @@ function inferArgsHint(signature) {
 function normalizeCommandName(name10) {
   return name10.replace(/^\//, "").trim().toLowerCase();
 }
-var COMMAND_SIGNATURES, PLANNED_SIGNATURES, CATEGORY_OVERRIDES, ALIASES, USER_ONLY, DESTRUCTIVE, NETWORKED, SECRET_BEARING, PROFILE_GATED, SELF_MODIFY_ALLOWED, REST_BLOCKED, CANONICAL_BY_ALIAS, DYNAMIC_COMMANDS, SLASH_COMMANDS;
+var COMMAND_SIGNATURES, PLANNED_SIGNATURES, CATEGORY_OVERRIDES, ALIASES, USER_ONLY, DESTRUCTIVE, NETWORKED, SECRET_BEARING, PROFILE_GATED, SELF_MODIFY_ALLOWED, REST_BLOCKED, TELEGRAM_PUBLIC_BOT_COMMANDS, CANONICAL_BY_ALIAS, DYNAMIC_COMMANDS, SLASH_COMMANDS;
 var init_command_registry = __esm({
   "packages/cli/src/tui/command-registry.ts"() {
     "use strict";
@@ -561158,6 +561198,7 @@ var init_command_registry = __esm({
       ["/score", "Show inference capability scorecard (memory, compute, speed, models)"],
       ["/task-type", "Set task type (code, document, analysis, plan, general, auto)"],
       ["/stats", "Show session dashboard (metrics, tool usage, task history)"],
+      ["/metrics", "Show runtime metrics: tokens, context window, throughput, and tool usage"],
       ["/sessions", "Browse saved sessions"],
       ["/pause", "Pause after current turn finishes (gentle halt, /resume to continue)"],
       ["/stop", "Kill current inference immediately and save state (/resume to continue)"],
@@ -561440,7 +561481,9 @@ var init_command_registry = __esm({
       selfmodify: "runtime",
       debug: "runtime",
       selfmod: "runtime",
-      "self-modify": "runtime"
+      "self-modify": "runtime",
+      stats: "session",
+      metrics: "session"
     };
     ALIASES = {
       help: ["h", "?"],
@@ -561463,7 +561506,7 @@ var init_command_registry = __esm({
       evaluate: ["eval"],
       score: ["inference"],
       "task-type": ["tasktype", "tt"],
-      stats: ["metrics", "dashboard"],
+      stats: ["dashboard"],
       memory: ["mem"],
       files: ["workspace"],
       skills: ["skill"],
@@ -561627,6 +561670,7 @@ var init_command_registry = __esm({
       "selfmodify",
       "debug",
       "stats",
+      "metrics",
       "stream",
       "style",
       "task-type",
@@ -561646,6 +561690,20 @@ var init_command_registry = __esm({
       "bg",
       "paste"
     ]);
+    TELEGRAM_PUBLIC_BOT_COMMANDS = [
+      { command: "start", description: "Show Telegram bridge status", canonical: "start" },
+      { command: "help", description: "Show available Telegram commands", canonical: "help" },
+      { command: "commands", description: "Show available Telegram commands", canonical: "commands" },
+      { command: "auth", description: "Authenticate this Telegram user as bot admin", canonical: "auth" },
+      { command: "call", description: "Get or request the active voice call link", canonical: "call" },
+      { command: "reflect", description: "Run scoped Telegram chat reflection", canonical: "reflect" },
+      { command: "reflection", description: "Alias for scoped Telegram chat reflection", canonical: "reflect" },
+      { command: "daydream", description: "Alias for scoped Telegram chat reflection", canonical: "reflect" },
+      { command: "remind", description: "Set a scoped Telegram reminder", canonical: "remind" },
+      { command: "reminder", description: "List or update scoped Telegram reminders", canonical: "reminder" },
+      { command: "reminders", description: "Alias for scoped Telegram reminders", canonical: "reminder" },
+      { command: "image", description: "Generate a scoped image from a prompt", canonical: "image" }
+    ];
     CANONICAL_BY_ALIAS = /* @__PURE__ */ new Map();
     for (const [canonical, aliases] of Object.entries(ALIASES)) {
       for (const alias of aliases) CANONICAL_BY_ALIAS.set(alias, canonical);
@@ -589812,11 +589870,32 @@ async function handleSlashCommand(input, ctx3) {
       }
       const summary = ctx3.sessionMetrics.getSummary();
       const dur = SessionMetrics.formatDuration(summary.sessionDurationMs);
+      const contextWindowSize = Math.max(0, Math.trunc(ctx3.getContextWindowSize?.() ?? 0));
+      const contextLabel = contextWindowSize > 0 ? formatContextLength(contextWindowSize) : "unknown";
+      const latestContextPct = contextWindowSize > 0 && summary.latestEstimatedContextTokens > 0 ? ` (${Math.round(summary.latestEstimatedContextTokens / contextWindowSize * 100)}%)` : "";
+      const peakContextPct = contextWindowSize > 0 && summary.peakEstimatedContextTokens > 0 ? ` (${Math.round(summary.peakEstimatedContextTokens / contextWindowSize * 100)}%)` : "";
+      const sessionSeconds = Math.max(1, summary.sessionDurationMs / 1e3);
+      const measuredTokPerSec = summary.averageOutputTokensPerSecond;
+      const sessionOutputTokPerSec = summary.totalOutputTokens / sessionSeconds;
+      const avgInputPerTurn = summary.totalTurns > 0 ? summary.totalInputTokens / summary.totalTurns : 0;
+      const avgOutputPerTurn = summary.totalTurns > 0 ? summary.totalOutputTokens / summary.totalTurns : 0;
+      const avgToolsPerTurn = summary.totalTurns > 0 ? summary.totalToolCalls / summary.totalTurns : 0;
       const lines = [];
       lines.push(`
-  ${c3.bold("Session Dashboard")}
+  ${c3.bold(cmd === "metrics" ? "Runtime Metrics" : "Session Dashboard")}
 `);
       lines.push(`  Duration:       ${c3.bold(dur)}`);
+      lines.push(`  Context window: ${c3.bold(contextLabel)}`);
+      if (summary.latestEstimatedContextTokens > 0) {
+        lines.push(
+          `  Context now:    ${c3.bold(`~${summary.latestEstimatedContextTokens.toLocaleString()}`)} tokens${latestContextPct}`
+        );
+      }
+      if (summary.peakEstimatedContextTokens > 0) {
+        lines.push(
+          `  Context peak:   ${c3.bold(`~${summary.peakEstimatedContextTokens.toLocaleString()}`)} tokens${peakContextPct}`
+        );
+      }
       lines.push(
         `  Tasks completed: ${c3.bold(String(summary.tasksCompleted))}`
       );
@@ -589828,6 +589907,18 @@ async function handleSlashCommand(input, ctx3) {
       lines.push(
         `  Output tokens:  ${c3.bold(summary.totalOutputTokens.toLocaleString())}`
       );
+      lines.push(
+        `  Total tokens:   ${c3.bold(summary.totalTokens.toLocaleString())}`
+      );
+      lines.push(
+        `  Avg / turn:     ${c3.bold(`${Math.round(avgInputPerTurn).toLocaleString()} in / ${Math.round(avgOutputPerTurn).toLocaleString()} out`)}`
+      );
+      lines.push(
+        `  Tool / turn:    ${c3.bold(avgToolsPerTurn.toFixed(2))}`
+      );
+      lines.push(
+        measuredTokPerSec !== void 0 ? `  Output speed:   ${c3.bold(`${measuredTokPerSec.toFixed(1)} tok/s`)} ${c3.dim(`(${summary.generationSamples} measured response${summary.generationSamples === 1 ? "" : "s"})`)}` : `  Output speed:   ${c3.bold(`${sessionOutputTokPerSec.toFixed(1)} tok/s`)} ${c3.dim("session average")}`
+      );
       if (ctx3.costTracker?.hasPricing) {
         lines.push(
           `  Estimated cost: ${c3.bold(c3.yellow(ctx3.costTracker.formatCost()))}`
@@ -609476,6 +609567,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] ?? "";
@@ -609955,8 +610187,7 @@ function telegramSyntheticHelpSignatures() {
 function telegramHelpCommandAllowed(cmd, scope) {
   if (cmd.name === "dream") return false;
   if (scope === "admin") return cmd.implementationStatus === "implemented";
-  if (TELEGRAM_PUBLIC_HELP_COMMANDS.has(cmd.name)) return true;
-  return cmd.surfaces.agentTool && !cmd.safety.secretBearing && !cmd.safety.destructive && !cmd.safety.profileGated;
+  return TELEGRAM_PUBLIC_HELP_COMMANDS.has(cmd.name) || TELEGRAM_PUBLIC_BOT_COMMAND_NAMES.has(cmd.name);
 }
 function buildTelegramHelpHTML(scope, maxPublicCommands = 24) {
   const commands = listCommandRegistry({ includePlanned: false }).filter((cmd) => telegramHelpCommandAllowed(cmd, scope));
@@ -610653,7 +610884,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("│")} ${c3.red("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -610985,6 +611216,9 @@ External acquisition contract:
     TELEGRAM_PUBLIC_HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "start", "auth", "call"]);
     TELEGRAM_REMINDER_SLASH_COMMANDS = /* @__PURE__ */ new Set(["remind", "reminder", "reminders"]);
     TELEGRAM_REFLECTION_SLASH_COMMANDS = /* @__PURE__ */ new Set(["reflect", "reflection", "daydream", "dream"]);
+    TELEGRAM_PUBLIC_BOT_COMMAND_NAMES = new Set(
+      buildTelegramBotCommands({ scope: "public" }).map((cmd) => cmd.command)
+    );
     TELEGRAM_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".tif", ".svg"]);
     MEDIA_CACHE_TTL_MS = 30 * 60 * 1e3;
     TELEGRAM_CHANNEL_DMN_SWEEP_MS = 2 * 60 * 1e3;
@@ -611012,6 +611246,7 @@ External acquisition contract:
         this.telegramConversationDir = resolve43(repoRoot || ".", ".omnius", "telegram-conversations");
         this.telegramSqlitePath = resolve43(repoRoot || ".", ".omnius", "telegram.sqlite");
         this.telegramToolButtonDir = resolve43(repoRoot || ".", ".omnius", "telegram-tool-buttons");
+        this.hydrateTelegramCommandMap(buildTelegramBotCommands({ scope: "admin" }));
       }
       botToken;
       onMessage;
@@ -611240,6 +611475,9 @@ External acquisition contract:
         const botless = first2.startsWith("/") ? first2.slice(1).split("@")[0]?.toLowerCase() : "";
         return !!botless && this.telegramCommandMap.has(botless);
       }
+      isPublicTelegramSlashName(name10) {
+        return TELEGRAM_PUBLIC_BOT_COMMAND_NAMES.has(name10);
+      }
       async handleTelegramReminderSlash(msg, commandText, context2) {
         if (!this.repoRoot) {
           await this.replyToTelegramMessage(msg, "Reminder storage is not available yet.");
@@ -613332,11 +613570,116 @@ ${lines.join("\n")}`);
             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) {
@@ -614305,8 +614648,7 @@ Join: ${newUrl}`);
             return;
           }
         }
-        const publicCreativeSlash = telegramSlash === "image";
-        if (!isAdmin && msg.text.trim().startsWith("/") && this.isKnownTelegramSlash(normalizedCommandText) && !publicCreativeSlash) {
+        if (!isAdmin && msg.text.trim().startsWith("/") && this.isKnownTelegramSlash(normalizedCommandText) && !this.isPublicTelegramSlashName(telegramSlash)) {
           await this.replyToTelegramMessage(
             msg,
             "That command requires Telegram admin authentication. Run /telegram auth in the TUI, then send /auth <code> here."
@@ -615180,7 +615522,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"] : {};
@@ -615191,15 +615533,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) {
@@ -615228,13 +615612,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(",")}` : "";
@@ -615247,13 +615635,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,
@@ -615263,8 +615655,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;
@@ -615272,15 +615665,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}`;
@@ -615327,8 +615729,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")
@@ -617598,21 +618001,45 @@ Content-Type: ${mimeForPath(pathOrFileId, field === "photo" ? "image" : "video")
         }
         return this.sendMessage(`@${clean5}`, text);
       }
-      async setMyCommands(commands) {
+      hydrateTelegramCommandMap(commands) {
+        for (const cmd of commands) {
+          this.telegramCommandMap.set(cmd.command, cmd.canonical);
+        }
+        this.telegramCommandMap.set("auth", "auth");
+        this.telegramCommandMap.set("start", "start");
+      }
+      async setMyCommands(commands, options2 = {}) {
         const apiCommands = commands.map((cmd) => ({
           command: cmd.command,
           description: cmd.description
         }));
-        const result = await this.apiCall("setMyCommands", { commands: apiCommands });
+        const payload = { commands: apiCommands };
+        if (options2.scope) payload["scope"] = options2.scope;
+        if (options2.languageCode) payload["language_code"] = options2.languageCode;
+        const result = await this.apiCall("setMyCommands", payload);
         if (result.ok) {
-          for (const cmd of commands) {
-            this.telegramCommandMap.set(cmd.command, cmd.canonical);
-          }
-          this.telegramCommandMap.set("auth", "auth");
-          this.telegramCommandMap.set("start", "start");
+          this.hydrateTelegramCommandMap(commands);
         }
         return Boolean(result.ok);
       }
+      async registerScopedMyCommands(adminUserId = this.adminUserId) {
+        const publicCommands = buildTelegramBotCommands({ scope: "public" });
+        const adminCommands = buildTelegramBotCommands({ scope: "admin" });
+        this.hydrateTelegramCommandMap([...publicCommands, ...adminCommands]);
+        const publicOk = await this.setMyCommands(publicCommands, { scope: { type: "default" } });
+        const adminId = adminUserId?.trim();
+        if (!adminId || !/^\d+$/.test(adminId)) {
+          return publicOk;
+        }
+        const adminChatId = Number(adminId);
+        if (!Number.isSafeInteger(adminChatId)) {
+          return publicOk;
+        }
+        const adminOk = await this.setMyCommands(adminCommands, {
+          scope: { type: "chat", chat_id: adminChatId }
+        });
+        return publicOk && adminOk;
+      }
       async getMyCommands() {
         const result = await this.apiCall("getMyCommands");
         return Array.isArray(result.result) ? result.result : [];
@@ -643942,7 +644369,7 @@ async function runSelfImprovementCycle(repoRoot) {
   } catch {
   }
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine, flowEnabled, slashCommandHandler, thinkingEnabled, askUserCallback, selfModifyEnabled) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine, flowEnabled, slashCommandHandler, thinkingEnabled, askUserCallback, selfModifyEnabled, sessionMetrics) {
   const voiceStyleMap = {
     concise: 1,
     balanced: 3,
@@ -643964,6 +644391,9 @@ function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce
   }
   const modelTier = getModelTier(config.model);
   const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const taskMetricDescription = cleanForStorage(task).replace(/\s+/g, " ").slice(0, 160) || "task";
+  costTracker?.startTask(taskMetricDescription);
+  sessionMetrics?.startTask(taskMetricDescription);
   const projectCtx = buildProjectContext(repoRoot, taskStores?.contextStores);
   let dynamicContext = formatContextForPrompt(projectCtx, modelTier);
   try {
@@ -644923,6 +645353,7 @@ ${entry.fullContent}`
   let lastToolCall = null;
   let toolCallStartMs = 0;
   let streamStartMs = 0;
+  let lastStreamDurationMs = 0;
   let streamTextBuffer = "";
   let lastAssistantText = "";
   let lastProvenancePath = null;
@@ -644984,6 +645415,9 @@ ${entry.fullContent}`
       case "tool_call":
         if (_apiCallbacks?.onToolCall)
           _apiCallbacks.onToolCall(event.toolName ?? "unknown", event.toolArgs);
+        if (event.toolName && event.toolName !== "task_complete") {
+          sessionMetrics?.recordToolCall(event.toolName);
+        }
         toolSequence.push({
           tool: event.toolName ?? "unknown",
           argKeys: Object.keys(event.toolArgs ?? {})
@@ -645005,6 +645439,7 @@ ${entry.fullContent}`
           const name10 = event.toolName ?? "";
           if (name10 === "file_write" || name10 === "file_edit" || name10 === "file_patch" || name10 === "batch_edit") {
             filesTouched.add(event.toolArgs.path);
+            sessionMetrics?.recordFileModified(event.toolArgs.path);
             if (isNeovimActive()) {
               notifyNeovimFileChange(event.toolArgs.path).catch(
                 () => {
@@ -645233,6 +645668,7 @@ ${entry.fullContent}`
         break;
       case "stream_end": {
         const streamDurationMs = streamStartMs > 0 ? Date.now() - streamStartMs : 0;
+        lastStreamDurationMs = streamDurationMs;
         streamStartMs = 0;
         if (isNeovimActive()) {
           writeToNeovimOutput("\r\n");
@@ -645311,17 +645747,28 @@ ${entry.fullContent}`
         }
         break;
       case "token_usage":
-        if (statusBar && event.tokenUsage) {
+        if (event.tokenUsage) {
+          sessionMetrics?.recordTurn();
           const lastPromptTokens = event.tokenUsage.lastPromptTokens ?? event.tokenUsage.promptTokens;
           const lastCompletionTokens = event.tokenUsage.lastCompletionTokens ?? event.tokenUsage.completionTokens;
+          if (lastPromptTokens > 0 || lastCompletionTokens > 0) {
+            sessionMetrics?.recordTokenUsage(lastPromptTokens, lastCompletionTokens);
+          }
+          sessionMetrics?.recordContextEstimate(event.tokenUsage.estimatedContextTokens);
+          if (lastCompletionTokens > 0 && lastStreamDurationMs > 0) {
+            sessionMetrics?.recordGeneration(lastCompletionTokens, lastStreamDurationMs);
+            lastStreamDurationMs = 0;
+          }
           if (costTracker && (lastPromptTokens > 0 || lastCompletionTokens > 0)) {
             costTracker.trackTokens(lastPromptTokens, lastCompletionTokens);
           }
-          statusBar.updateMetrics({
-            ...event.tokenUsage,
-            estimatedCost: costTracker?.currentCost,
-            hasPricing: costTracker?.hasPricing
-          });
+          if (statusBar) {
+            statusBar.updateMetrics({
+              ...event.tokenUsage,
+              estimatedCost: costTracker?.currentCost,
+              hasPricing: costTracker?.hasPricing
+            });
+          }
           if (config.verbose) {
             const tu = event.tokenUsage;
             const ctxPct = tu.estimatedContextTokens > 0 && statusBar ? ` (ctx: ~${tu.estimatedContextTokens.toLocaleString()} tokens)` : "";
@@ -645434,6 +645881,8 @@ When done, either call task_complete with your answer, or use FINAL_VAR(variable
       total: result.totalTokens,
       estimated: result.estimatedTokens
     };
+    costTracker?.endTask();
+    sessionMetrics?.endTask();
     if (result.completed) {
       statusBar?.removeRecentContentMatchingText(result.summary);
     }
@@ -648652,7 +649101,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       });
       await telegramBridge.start();
       statusBar.setTelegramStatus(true, telegramBridge.stats.activeSubAgents);
-      telegramBridge.setMyCommands(buildTelegramBotCommands()).catch((err) => {
+      telegramBridge.registerScopedMyCommands(adminId).catch((err) => {
         writeContent(
           () => renderWarning(`Telegram command registration failed: ${err instanceof Error ? err.message : String(err)}`)
         );
@@ -649645,6 +650094,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       statusBar.setContextWindowSize(size);
       telegramBridge?.setContextWindowSize(size);
     },
+    getContextWindowSize: () => resolvedContextWindowSize,
     setCapabilities: (caps) => {
       resolvedCaps = caps;
       statusBar.setCapabilities(caps);
@@ -650342,7 +650792,8 @@ Execute this skill now. Follow the behavioral guidance above.`;
             buildSlashCommandHandler(),
             thinkingEnabled,
             handleAskUser,
-            selfModifyEnabled
+            selfModifyEnabled,
+            sessionMetrics
           );
           activeTask = task;
           setTerminalTitle(input.slice(0, 60), version4);
@@ -650770,7 +651221,8 @@ NEW TASK: ${fullInput}`;
         buildSlashCommandHandler(),
         thinkingEnabled,
         handleAskUser,
-        selfModifyEnabled
+        selfModifyEnabled,
+        sessionMetrics
       );
       activeTask = task;
       _recallText = null;

package/npm-shrinkwrap.json

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

package/package.json

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