omnius 1.0.86 → 1.0.87

package/dist/index.js

@@ -608078,6 +608078,395 @@ var init_telegram_help_menu = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-stats-menu.ts
+function emptySnapshot() {
+  return {
+    totalInferences: 0,
+    totalPromptTokens: 0,
+    totalCompletionTokens: 0,
+    totalTokens: 0,
+    avgTokensPerSecond: 0,
+    peakTokensPerSecond: 0,
+    avgInferenceDurationMs: 0,
+    totalInferenceDurationMs: 0,
+    totalToolCalls: 0,
+    successfulToolCalls: 0,
+    failedToolCalls: 0,
+    toolCallBreakdown: [],
+    contextWindowSize: 0,
+    estimatedContextTokens: 0,
+    peakContextTokens: 0,
+    contextUtilizationPct: 0,
+    sessionDurationMs: 0,
+    sessionStartAt: Date.now(),
+    turnCount: 0,
+    compactionCount: 0,
+    model: "unknown",
+    backend: "ollama",
+    gpuName: null,
+    gpuVramUsedMb: null,
+    gpuVramTotalMb: null
+  };
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const s2 = ms / 1e3;
+  if (s2 < 60) return `${s2.toFixed(1)}s`;
+  const m2 = Math.floor(s2 / 60);
+  const rs = Math.round(s2 % 60);
+  if (m2 < 60) return `${m2}m ${rs}s`;
+  const h = Math.floor(m2 / 60);
+  const rm4 = m2 % 60;
+  return `${h}h ${rm4}m`;
+}
+function fmtTokens2(n2) {
+  if (n2 < 1e3) return String(n2);
+  if (n2 < 1e6) return `${(n2 / 1e3).toFixed(1)}K`;
+  return `${(n2 / 1e6).toFixed(2)}M`;
+}
+function fmtPct(n2) {
+  return `${n2.toFixed(1)}%`;
+}
+function escapeHTML2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildMetricEntries(snap, scope) {
+  const entries = [];
+  entries.push({
+    icon: "🧠",
+    label: "Model",
+    value: escapeHTML2(snap.model),
+    category: "inference"
+  });
+  entries.push({
+    icon: "⚡",
+    label: "Inferences",
+    value: String(snap.totalInferences),
+    detail: `Total duration: ${fmtDuration(snap.totalInferenceDurationMs)}`,
+    category: "inference"
+  });
+  entries.push({
+    icon: "🔤",
+    label: "Tokens",
+    value: fmtTokens2(snap.totalTokens),
+    detail: `Prompt: ${fmtTokens2(snap.totalPromptTokens)} · Completion: ${fmtTokens2(snap.totalCompletionTokens)}`,
+    category: "inference"
+  });
+  entries.push({
+    icon: "🚀",
+    label: "Avg Speed",
+    value: `${snap.avgTokensPerSecond.toFixed(1)} tok/s`,
+    detail: `Peak: ${snap.peakTokensPerSecond.toFixed(1)} tok/s`,
+    category: "inference"
+  });
+  entries.push({
+    icon: "⏱",
+    label: "Avg Inference",
+    value: fmtDuration(snap.avgInferenceDurationMs),
+    category: "inference"
+  });
+  entries.push({
+    icon: "🔧",
+    label: "Tool Calls",
+    value: String(snap.totalToolCalls),
+    detail: `✅ ${snap.successfulToolCalls} · ❌ ${snap.failedToolCalls}`,
+    category: "tools"
+  });
+  const topTools = snap.toolCallBreakdown.sort((a2, b) => b.count - a2.count).slice(0, scope === "admin" ? 5 : 3);
+  for (const t2 of topTools) {
+    entries.push({
+      icon: "🔩",
+      label: t2.name,
+      value: `${t2.count}×`,
+      detail: `Avg: ${fmtDuration(t2.avgDurationMs)}`,
+      category: "tools"
+    });
+  }
+  entries.push({
+    icon: "📐",
+    label: "Context Window",
+    value: fmtTokens2(snap.contextWindowSize),
+    category: "context"
+  });
+  entries.push({
+    icon: "📊",
+    label: "Context Used",
+    value: fmtTokens2(snap.estimatedContextTokens),
+    detail: `Utilization: ${fmtPct(snap.contextUtilizationPct)} · Peak: ${fmtTokens2(snap.peakContextTokens)}`,
+    category: "context"
+  });
+  entries.push({
+    icon: "🗜",
+    label: "Compactions",
+    value: String(snap.compactionCount),
+    category: "context"
+  });
+  entries.push({
+    icon: "🕐",
+    label: "Session",
+    value: fmtDuration(snap.sessionDurationMs),
+    category: "session"
+  });
+  entries.push({
+    icon: "🔄",
+    label: "Turns",
+    value: String(snap.turnCount),
+    category: "session"
+  });
+  if (scope === "admin") {
+    entries.push({
+      icon: "🖥",
+      label: "Backend",
+      value: escapeHTML2(snap.backend),
+      category: "system"
+    });
+    if (snap.gpuName) {
+      entries.push({
+        icon: "🎮",
+        label: "GPU",
+        value: escapeHTML2(snap.gpuName),
+        category: "system"
+      });
+    }
+    if (snap.gpuVramTotalMb != null) {
+      const used = snap.gpuVramUsedMb ?? 0;
+      entries.push({
+        icon: "💾",
+        label: "VRAM",
+        value: `${Math.round(used)}/${Math.round(snap.gpuVramTotalMb)} MB`,
+        detail: `Usage: ${fmtPct(used / snap.gpuVramTotalMb * 100)}`,
+        category: "system"
+      });
+    }
+  }
+  return entries;
+}
+function encodeStatsCallback(action, value2) {
+  return `${CB_PREFIX}${action}:${value2}`;
+}
+function decodeStatsCallback(data) {
+  if (!data.startsWith(CB_PREFIX)) return null;
+  const body = data.slice(CB_PREFIX.length);
+  const colonIdx = body.indexOf(":");
+  if (colonIdx === -1) return null;
+  const action = body.slice(0, colonIdx);
+  if (action !== "page" && action !== "close") return null;
+  const value2 = parseInt(body.slice(colonIdx + 1), 10);
+  if (isNaN(value2)) return null;
+  return { action, value: value2 };
+}
+function buildStatsKeyboard(page2, totalPages, countdown) {
+  const rows = [];
+  const navRow = [];
+  if (page2 === 0) {
+    navRow.push({
+      text: countdown != null ? `✖ Close (${countdown}s)` : "✖ Close",
+      callback_data: encodeStatsCallback("close", 0)
+    });
+  }
+  navRow.push({
+    text: `${page2 + 1}/${totalPages}`,
+    callback_data: encodeStatsCallback("page", page2)
+    // current page = no-op refresh
+  });
+  if (page2 > 0) {
+    navRow.unshift({ text: "◀️", callback_data: encodeStatsCallback("page", page2 - 1) });
+  }
+  if (page2 < totalPages - 1) {
+    navRow.push({ text: "▶️", callback_data: encodeStatsCallback("page", page2 + 1) });
+  }
+  rows.push(navRow);
+  return rows;
+}
+function buildStatsPageText(entries, page2, countdown) {
+  const start2 = page2 * PAGE_SIZE;
+  const pageEntries = entries.slice(start2, start2 + PAGE_SIZE);
+  const lines = [];
+  lines.push("<b>📊 Session Metrics</b>");
+  lines.push("");
+  let currentCategory = "";
+  for (const e2 of pageEntries) {
+    if (e2.category !== currentCategory) {
+      currentCategory = e2.category;
+      lines.push(`<b>${CATEGORY_LABELS2[e2.category]}</b>`);
+    }
+    let line = `  ${e2.icon} <b>${e2.label}:</b> ${e2.value}`;
+    lines.push(line);
+    if (e2.detail) {
+      lines.push(`    <i>${escapeHTML2(e2.detail)}</i>`);
+    }
+  }
+  if (countdown != null) {
+    lines.push("");
+    lines.push(`<i>⏳ Auto-closing in ${countdown}s…</i>`);
+  }
+  return lines.join("\n");
+}
+function renderStatsMenu(scope, snapshot) {
+  return renderStatsMenuPage(scope, 0, snapshot);
+}
+function renderStatsMenuPage(scope, page2, snapshot, countdown = null) {
+  const entries = buildMetricEntries(snapshot, scope);
+  const totalPages = Math.max(1, Math.ceil(entries.length / PAGE_SIZE));
+  const safePage = Math.min(page2, totalPages - 1);
+  const text = buildStatsPageText(entries, safePage, countdown);
+  const keyboard = buildStatsKeyboard(safePage, totalPages, countdown);
+  return { text, reply_markup: { inline_keyboard: keyboard } };
+}
+function handleStatsCallback(data, currentState, snapshot) {
+  const decoded = decodeStatsCallback(data);
+  if (!decoded) return null;
+  switch (decoded.action) {
+    case "page": {
+      const page2 = decoded.value;
+      const render2 = renderStatsMenuPage(currentState.scope, page2, snapshot);
+      const newState = {
+        ...currentState,
+        page: page2,
+        lastInteractionAt: Date.now()
+      };
+      return { render: render2, newState };
+    }
+    case "close": {
+      return { render: null, newState: currentState, close: true };
+    }
+    default:
+      return null;
+  }
+}
+var PAGE_SIZE, StatsMenuStateStore, CB_PREFIX, CATEGORY_LABELS2, INACTIVITY_TIMEOUT_MS2, COUNTDOWN_SECONDS2, StatsMenuTimerManager;
+var init_telegram_stats_menu = __esm({
+  "packages/cli/src/tui/telegram-stats-menu.ts"() {
+    "use strict";
+    PAGE_SIZE = 6;
+    StatsMenuStateStore = class {
+      states = /* @__PURE__ */ new Map();
+      key(chatId, messageId) {
+        return `${chatId}:${messageId}`;
+      }
+      get(chatId, messageId) {
+        return this.states.get(this.key(chatId, messageId));
+      }
+      set(state) {
+        this.states.set(this.key(state.chatId, state.messageId), state);
+      }
+      delete(chatId, messageId) {
+        this.states.delete(this.key(chatId, messageId));
+      }
+      prune(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        for (const [k, v] of this.states) {
+          if (v.lastInteractionAt < cutoff) this.states.delete(k);
+        }
+      }
+    };
+    CB_PREFIX = "st_";
+    CATEGORY_LABELS2 = {
+      inference: "🧠 Inference",
+      tools: "🔧 Tools",
+      context: "📐 Context",
+      session: "🕐 Session",
+      system: "🖥 System"
+    };
+    INACTIVITY_TIMEOUT_MS2 = 6e4;
+    COUNTDOWN_SECONDS2 = 10;
+    StatsMenuTimerManager = class {
+      constructor(states, callbacks, getSnapshot) {
+        this.states = states;
+        this.callbacks = callbacks;
+        this.getSnapshot = getSnapshot;
+      }
+      states;
+      callbacks;
+      getSnapshot;
+      inactivityTimers = /* @__PURE__ */ new Map();
+      countdownTimers = /* @__PURE__ */ new Map();
+      countdownValues = /* @__PURE__ */ new Map();
+      key(chatId, messageId) {
+        return `${chatId}:${messageId}`;
+      }
+      startTimer(state) {
+        this.resetTimer(state.chatId, state.messageId);
+      }
+      resetTimer(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        const existingInactivity = this.inactivityTimers.get(k);
+        if (existingInactivity) clearTimeout(existingInactivity);
+        this.cancelCountdown(chatId, messageId);
+        this.inactivityTimers.set(
+          k,
+          setTimeout(() => {
+            this.startCountdown(
+              this.states.get(chatId, messageId) ?? {
+                chatId,
+                messageId,
+                scope: "admin",
+                page: 0,
+                lastInteractionAt: Date.now()
+              }
+            );
+          }, INACTIVITY_TIMEOUT_MS2)
+        );
+      }
+      startCountdown(state) {
+        const k = this.key(state.chatId, state.messageId);
+        this.countdownValues.set(k, COUNTDOWN_SECONDS2);
+        this.renderCountdown(state).catch(() => {
+        });
+        this.countdownTimers.set(
+          k,
+          setInterval(() => {
+            const remaining = (this.countdownValues.get(k) ?? 0) - 1;
+            if (remaining <= 0) {
+              this.deleteMenu(state.chatId, state.messageId);
+              return;
+            }
+            this.countdownValues.set(k, remaining);
+            this.renderCountdown(state).catch(() => {
+            });
+          }, 1e3)
+        );
+      }
+      cancelCountdown(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        const timer = this.countdownTimers.get(k);
+        if (timer) {
+          clearInterval(timer);
+          this.countdownTimers.delete(k);
+          this.countdownValues.delete(k);
+        }
+      }
+      async renderCountdown(state) {
+        const k = this.key(state.chatId, state.messageId);
+        const countdown = this.countdownValues.get(k) ?? null;
+        const snap = this.getSnapshot();
+        const entries = buildMetricEntries(snap, state.scope);
+        const totalPages = Math.max(1, Math.ceil(entries.length / PAGE_SIZE));
+        const text = buildStatsPageText(entries, state.page, countdown);
+        const keyboard = buildStatsKeyboard(state.page, totalPages, countdown);
+        try {
+          await this.callbacks.editMessageText(state.chatId, state.messageId, text, {
+            inline_keyboard: keyboard
+          });
+        } catch {
+        }
+      }
+      async deleteMenu(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        this.cancelCountdown(chatId, messageId);
+        const inactivity = this.inactivityTimers.get(k);
+        if (inactivity) clearTimeout(inactivity);
+        this.inactivityTimers.delete(k);
+        this.states.delete(chatId, messageId);
+        try {
+          await this.callbacks.deleteMessage(chatId, messageId);
+        } catch {
+        }
+      }
+    };
+  }
+});
+
 // packages/cli/src/tui/telegram-creative-tools.ts
 import { createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, randomBytes as randomBytes21 } from "node:crypto";
 import {
@@ -611750,6 +612139,8 @@ function splitTelegramReminderDue(raw) {
 function telegramSyntheticHelpSignatures2() {
   return [
     { signature: "/help", description: "Show Telegram command help" },
+    { signature: "/stats", description: "Show session metrics and inference statistics" },
+    { signature: "/metrics", description: "Alias for /stats — show session metrics" },
     { signature: "/start", description: "Show Telegram bridge status and authentication instructions" },
     { signature: "/auth <code>", description: "Authenticate this Telegram user as bot admin using the TUI code" },
     { signature: "/call", description: "Get the active voice call link when a call session is running" },
@@ -612495,6 +612886,7 @@ var init_telegram_bridge = __esm({
     init_media_routing();
     init_command_registry();
     init_telegram_help_menu();
+    init_telegram_stats_menu();
     init_scoped_personality();
     init_telegram_creative_tools();
     init_omnius_directory();
@@ -612961,6 +613353,12 @@ External acquisition contract:
       helpMenuTimers = null;
       /** Prune expired help menu states every 5 minutes */
       helpMenuPruneTimer = null;
+      /** Interactive stats menu state store (inline keyboard navigation) */
+      statsMenuStates = new StatsMenuStateStore();
+      /** Auto-close timer manager for stats menus (inactivity → countdown → delete) */
+      statsMenuTimers = null;
+      /** Prune expired stats menu states every 5 minutes */
+      statsMenuPruneTimer = null;
       /** Command handler for admin DM slash commands (wired from interactive.ts) */
       commandHandler = null;
       /** Callback fired after a Telegram user completes the TUI-only admin auth challenge */
@@ -612970,7 +613368,9 @@ External acquisition contract:
       /** Telegram command menu names mapped back to canonical TUI command names. */
       telegramCommandMap = /* @__PURE__ */ new Map([
         ["auth", "auth"],
-        ["start", "start"]
+        ["start", "start"],
+        ["stats", "stats"],
+        ["metrics", "stats"]
       ]);
       /** TUI agent-view callbacks for Telegram sub-agent registration. */
       subAgentViewCallbacks = null;
@@ -613245,6 +613645,10 @@ External acquisition contract:
         const name10 = this.telegramSlashName(input);
         return name10 === "help" || name10 === "h" || name10 === "commands" || name10 === "cmds";
       }
+      isTelegramStatsCommand(input) {
+        const name10 = this.telegramSlashName(input);
+        return name10 === "stats" || name10 === "metrics";
+      }
       isKnownTelegramSlash(input) {
         const first2 = input.trim().split(/\s+/)[0] ?? "";
         const botless = first2.startsWith("/") ? first2.slice(1).split("@")[0]?.toLowerCase() : "";
@@ -613431,6 +613835,94 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           this.helpMenuTimers.startTimer(state);
         }
       }
+      collectSessionMetricsSnapshot() {
+        const snap = emptySnapshot();
+        try {
+          const runner = this.activeRunner;
+          if (runner) {
+            snap.model = runner.model ?? runner.modelName ?? "unknown";
+            snap.backend = runner.backend ?? "ollama";
+            snap.totalInferences = runner.inferenceCount ?? runner.totalInferences ?? 0;
+            snap.totalPromptTokens = runner.totalPromptTokens ?? 0;
+            snap.totalCompletionTokens = runner.totalCompletionTokens ?? 0;
+            snap.totalTokens = snap.totalPromptTokens + snap.totalCompletionTokens;
+            snap.totalInferenceDurationMs = runner.totalInferenceDurationMs ?? 0;
+            snap.avgInferenceDurationMs = snap.totalInferences > 0 ? snap.totalInferenceDurationMs / snap.totalInferences : 0;
+            snap.avgTokensPerSecond = runner.avgTokensPerSecond ?? 0;
+            snap.peakTokensPerSecond = runner.peakTokensPerSecond ?? 0;
+            snap.totalToolCalls = runner.toolCallCount ?? runner.totalToolCalls ?? 0;
+            snap.successfulToolCalls = runner.successfulToolCalls ?? snap.totalToolCalls;
+            snap.failedToolCalls = runner.failedToolCalls ?? 0;
+            snap.toolCallBreakdown = runner.toolCallBreakdown ?? [];
+            snap.contextWindowSize = runner.contextWindowSize ?? runner.maxContextTokens ?? 0;
+            snap.estimatedContextTokens = runner.estimatedContextTokens ?? runner.latestEstimatedContextTokens ?? 0;
+            snap.peakContextTokens = runner.peakEstimatedContextTokens ?? snap.estimatedContextTokens;
+            snap.contextUtilizationPct = snap.contextWindowSize > 0 ? snap.estimatedContextTokens / snap.contextWindowSize * 100 : 0;
+            snap.turnCount = runner.turnCount ?? 0;
+            snap.compactionCount = runner.compactionCount ?? 0;
+            snap.sessionStartAt = runner.sessionStartAt ?? Date.now();
+            snap.sessionDurationMs = Date.now() - snap.sessionStartAt;
+          }
+          const env2 = this.envInfo;
+          if (env2) {
+            snap.gpuName = env2.gpuName ?? env2.gpu ?? null;
+            snap.gpuVramUsedMb = env2.gpuVramUsedMb ?? env2.vramUsedMb ?? null;
+            snap.gpuVramTotalMb = env2.gpuVramTotalMb ?? env2.vramTotalMb ?? null;
+          }
+        } catch {
+        }
+        if (snap.sessionDurationMs === 0 && snap.sessionStartAt > 0) {
+          snap.sessionDurationMs = Date.now() - snap.sessionStartAt;
+        }
+        return snap;
+      }
+      async replyWithTelegramStats(msg, isAdmin) {
+        const scope = isAdmin ? "admin" : "public";
+        const snapshot = this.collectSessionMetricsSnapshot();
+        const menu = renderStatsMenu(scope, snapshot);
+        if (msg.guestQueryId) {
+          const plainText = menu.text.replace(/<[^>]+>/g, "");
+          await this.answerGuestQuery(msg.guestQueryId, plainText, { parseMode: "HTML" });
+          return;
+        }
+        const sent = await this.apiCall("sendMessage", {
+          chat_id: msg.chatId,
+          text: menu.text,
+          parse_mode: "HTML",
+          reply_markup: JSON.stringify(menu.reply_markup),
+          ...msg.chatType !== "private" ? { reply_to_message_id: msg.messageId } : {}
+        });
+        if (sent.ok && sent.result?.message_id) {
+          const state = {
+            chatId: msg.chatId,
+            messageId: sent.result.message_id,
+            scope,
+            page: 0,
+            lastInteractionAt: Date.now()
+          };
+          this.statsMenuStates.set(state);
+          if (!this.statsMenuTimers) {
+            this.statsMenuTimers = new StatsMenuTimerManager(this.statsMenuStates, {
+              editMessageText: async (chatId, messageId, text, replyMarkup) => {
+                await this.apiCall("editMessageText", {
+                  chat_id: chatId,
+                  message_id: messageId,
+                  text,
+                  parse_mode: "HTML",
+                  reply_markup: JSON.stringify(replyMarkup)
+                });
+              },
+              deleteMessage: async (chatId, messageId) => {
+                await this.apiCall("deleteMessage", {
+                  chat_id: chatId,
+                  message_id: messageId
+                });
+              }
+            }, () => this.collectSessionMetricsSnapshot());
+          }
+          this.statsMenuTimers.startTimer(state);
+        }
+      }
       recordChatHistory(sessionKey, entry) {
         this.ensureTelegramConversationLoaded(sessionKey);
         const stamped = { ...entry, ts: entry.ts ?? Date.now() };
@@ -617192,6 +617684,10 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           await this.replyWithTelegramHelp(msg, isAdmin);
           return;
         }
+        if (msg.text.trim().startsWith("/") && this.isTelegramStatsCommand(normalizedCommandText)) {
+          await this.replyWithTelegramStats(msg, isAdmin);
+          return;
+        }
         const telegramSlash = this.telegramSlashName(normalizedCommandText);
         if (msg.text.trim().startsWith("/") && TELEGRAM_REFLECTION_SLASH_COMMANDS.has(telegramSlash)) {
           await this.handleTelegramReflectionSlash(msg, normalizedCommandText);
@@ -619806,6 +620302,72 @@ Scoped workspace: ${scopedRoot}`,
           }
           return;
         }
+        const statsDecoded = decodeStatsCallback(callback.data);
+        if (statsDecoded) {
+          let answerText2 = "";
+          let alert2 = false;
+          try {
+            const chatId = callback.chatId;
+            const messageId = callback.messageId;
+            if (!chatId || !messageId) {
+              answerText2 = "Cannot identify menu message.";
+              alert2 = true;
+              return;
+            }
+            const menuState = this.statsMenuStates.get(chatId, messageId);
+            if (!menuState) {
+              answerText2 = "This stats menu expired. Send /stats for a fresh one.";
+              alert2 = true;
+              return;
+            }
+            const isAdmin = this.isAdminActor(callback.fromUserId, callback.username);
+            if (!isAdmin && menuState.scope === "admin") {
+              answerText2 = "Only admin can interact with this menu.";
+              alert2 = true;
+              return;
+            }
+            const snapshot = this.collectSessionMetricsSnapshot();
+            const result = handleStatsCallback(callback.data, menuState, snapshot);
+            if (!result) {
+              answerText2 = "Unknown menu action.";
+              alert2 = true;
+              return;
+            }
+            if (result.close) {
+              this.statsMenuStates.delete(chatId, messageId);
+              this.statsMenuTimers?.deleteMenu(chatId, messageId);
+              try {
+                await this.apiCall("deleteMessage", {
+                  chat_id: chatId,
+                  message_id: messageId
+                });
+              } catch {
+              }
+              await this.answerCallbackQuery(callback.id).catch(() => false);
+              return;
+            }
+            this.statsMenuStates.set(result.newState);
+            this.statsMenuTimers?.resetTimer(chatId, messageId);
+            await this.apiCall("editMessageText", {
+              chat_id: chatId,
+              message_id: messageId,
+              text: result.render.text,
+              parse_mode: "HTML",
+              reply_markup: JSON.stringify(result.render.reply_markup)
+            });
+            answerText2 = "";
+          } catch (err) {
+            answerText2 = err instanceof Error ? err.message : String(err);
+            alert2 = true;
+          } finally {
+            if (answerText2) {
+              await this.answerCallbackQuery(callback.id, answerText2.slice(0, 180), alert2).catch(() => false);
+            } else {
+              await this.answerCallbackQuery(callback.id).catch(() => false);
+            }
+          }
+          return;
+        }
         let answerText = "Updated.";
         let alert = false;
         try {

package/npm-shrinkwrap.json

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

package/package.json

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