omnius 1.0.84 → 1.0.86

package/dist/index.js

@@ -607686,6 +607686,398 @@ var init_tool_policy = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-help-menu.ts
+function telegramSyntheticHelpSignatures() {
+  return [
+    { signature: "/help", description: "Show interactive command help" },
+    { 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" },
+    { signature: "/reflect", description: "Run scoped Telegram chat reflection over retained chat history" },
+    { signature: "/reflect status", description: "Show the latest scoped Telegram reflection artifact" },
+    { signature: "/reflect now", description: "Run reflection and let the model decide whether to post a public follow-up" },
+    { signature: "/reflect auto on|off", description: "Enable or disable model-gated idle follow-ups for this chat" },
+    { signature: "/reflection", description: "Alias for /reflect" },
+    { signature: "/daydream", description: "Alias for /reflect in Telegram chats" }
+  ];
+}
+function telegramHelpCommandAllowed(cmd, scope) {
+  if (cmd.name === "dream") return false;
+  if (scope === "admin") return cmd.implementationStatus === "implemented";
+  return TELEGRAM_PUBLIC_HELP_COMMANDS.has(cmd.name);
+}
+function parseArgsHint(argsHint) {
+  if (!argsHint) return [];
+  const args = [];
+  const re = /<(\w+)(\?)?>/g;
+  let match;
+  while ((match = re.exec(argsHint)) !== null) {
+    const name10 = match[1];
+    const optional2 = match[2] === "?";
+    args.push({
+      name: name10,
+      type: "string",
+      required: !optional2,
+      description: ""
+    });
+  }
+  return args;
+}
+function buildScopedToolList(scope) {
+  const commands = listCommandRegistry({ includePlanned: false }).filter((cmd) => telegramHelpCommandAllowed(cmd, scope));
+  const syntheticSigs = telegramSyntheticHelpSignatures();
+  const commandSigs = commands.flatMap((cmd) => cmd.signatures);
+  const allSigs = [...syntheticSigs, ...commandSigs];
+  const seen = /* @__PURE__ */ new Set();
+  const unique = allSigs.filter((sig) => {
+    if (seen.has(sig.signature)) return false;
+    seen.add(sig.signature);
+    return true;
+  });
+  const entries = [];
+  for (const sig of unique) {
+    const matchingCmd = commands.find(
+      (cmd) => cmd.signatures.some((s2) => s2.signature === sig.signature)
+    );
+    const args = matchingCmd ? parseArgsHint(matchingCmd.argsHint) : [];
+    const name10 = sig.signature.replace(/^\//, "").split(/\s+/)[0] ?? sig.signature;
+    entries.push({
+      name: name10,
+      signature: sig.signature,
+      description: sig.description,
+      arguments: args
+    });
+  }
+  return entries;
+}
+function encodeHelpCallback(action, value2) {
+  const raw = `${CALLBACK_PREFIX}:${action}:${value2}`;
+  return raw.slice(0, MAX_CALLBACK_DATA);
+}
+function decodeHelpCallback(data) {
+  if (!data.startsWith(CALLBACK_PREFIX + ":")) return null;
+  const parts = data.split(":");
+  if (parts.length < 3) return null;
+  const action = parts[1];
+  const value2 = parts.slice(2).join(":");
+  if (action !== "page" && action !== "detail" && action !== "back" && action !== "close") return null;
+  return { action, value: value2 };
+}
+function buildToolListKeyboard(tools, page2, scope, countdown = null) {
+  const totalPages = Math.max(1, Math.ceil(tools.length / TOOLS_PER_PAGE));
+  const start2 = page2 * TOOLS_PER_PAGE;
+  const pageTools = tools.slice(start2, start2 + TOOLS_PER_PAGE);
+  const rows = [];
+  let currentRow = [];
+  for (const tool of pageTools) {
+    const label = tool.name.length > 18 ? tool.name.slice(0, 17) + "…" : tool.name;
+    currentRow.push({
+      text: label,
+      callback_data: encodeHelpCallback("detail", tool.name)
+    });
+    if (currentRow.length >= GRID_COLS) {
+      rows.push(currentRow);
+      currentRow = [];
+    }
+  }
+  if (currentRow.length > 0) {
+    rows.push(currentRow);
+  }
+  const navRow = [];
+  if (page2 === 0) {
+    const closeLabel = countdown != null ? `✖ ${countdown}` : "✖ Close";
+    navRow.push({ text: closeLabel, callback_data: encodeHelpCallback("close", "0") });
+  }
+  if (page2 > 0) {
+    navRow.push({ text: "◀️ Back", callback_data: encodeHelpCallback("page", page2 - 1) });
+  }
+  navRow.push({
+    text: `${page2 + 1}/${totalPages}`,
+    callback_data: encodeHelpCallback("page", page2.toString())
+    // re-send same page (no-op, just indicator)
+  });
+  if (page2 < totalPages - 1) {
+    navRow.push({ text: "▶️ Next", callback_data: encodeHelpCallback("page", page2 + 1) });
+  }
+  rows.push(navRow);
+  return rows;
+}
+function buildToolDetailKeyboard(tool, page2) {
+  const rows = [];
+  for (const arg of tool.arguments) {
+    const req2 = arg.required ? "●" : "○";
+    const label = `${req2} ${arg.name}`.slice(0, 30);
+    rows.push([{
+      text: label,
+      callback_data: encodeHelpCallback("detail", tool.name)
+      // stay on detail
+    }]);
+  }
+  rows.push([{
+    text: "🔙 Back to tools",
+    callback_data: encodeHelpCallback("back", page2.toString())
+  }]);
+  return rows;
+}
+function escapeHTML(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildToolListText(tools, page2, scope) {
+  const totalPages = Math.max(1, Math.ceil(tools.length / TOOLS_PER_PAGE));
+  const start2 = page2 * TOOLS_PER_PAGE;
+  const pageTools = tools.slice(start2, start2 + TOOLS_PER_PAGE);
+  const lines = [
+    `<b>🛠 Commands (${scope === "admin" ? "admin full scope" : "public secure scope"})</b>`,
+    `<i>Page ${page2 + 1} of ${totalPages} — ${tools.length} commands</i>`,
+    ""
+  ];
+  for (const tool of pageTools) {
+    lines.push(`<code>${escapeHTML(tool.signature)}</code>`);
+    lines.push(`  ${escapeHTML(tool.description)}`);
+  }
+  lines.push("");
+  lines.push("<i>Tap a command for details, or use ◀️▶️ to navigate.</i>");
+  return lines.join("\n");
+}
+function buildToolDetailText(tool) {
+  const lines = [
+    `<b>📌 ${escapeHTML(tool.signature)}</b>`,
+    "",
+    escapeHTML(tool.description),
+    ""
+  ];
+  if (tool.arguments.length > 0) {
+    lines.push("<b>Arguments:</b>");
+    lines.push("");
+    for (const arg of tool.arguments) {
+      const reqBadge = arg.required ? "<b>[required]</b>" : "<i>[optional]</i>";
+      lines.push(`<code>${escapeHTML(arg.name)}</code> ${reqBadge} <i>${escapeHTML(arg.type)}</i>`);
+      if (arg.description) {
+        lines.push(`  ${escapeHTML(arg.description)}`);
+      }
+      lines.push("");
+    }
+  } else {
+    lines.push("<i>No arguments.</i>");
+  }
+  lines.push("🔙 <i>Tap Back to return to the tool list.</i>");
+  return lines.join("\n");
+}
+function renderHelpMenu(scope) {
+  const tools = buildScopedToolList(scope);
+  const text = buildToolListText(tools, 0, scope);
+  const inline_keyboard = buildToolListKeyboard(tools, 0, scope);
+  return { text, replyMarkup: { inline_keyboard } };
+}
+function renderHelpMenuPage(scope, page2) {
+  const tools = buildScopedToolList(scope);
+  const totalPages = Math.max(1, Math.ceil(tools.length / TOOLS_PER_PAGE));
+  page2 = Math.max(0, Math.min(page2, totalPages - 1));
+  const text = buildToolListText(tools, page2, scope);
+  const inline_keyboard = buildToolListKeyboard(tools, page2, scope);
+  return { text, replyMarkup: { inline_keyboard } };
+}
+function renderHelpMenuPageWithCountdown(scope, page2, countdown) {
+  const tools = buildScopedToolList(scope);
+  const totalPages = Math.max(1, Math.ceil(tools.length / TOOLS_PER_PAGE));
+  page2 = Math.max(0, Math.min(page2, totalPages - 1));
+  const text = buildToolListText(tools, page2, scope);
+  const inline_keyboard = buildToolListKeyboard(tools, page2, scope, countdown);
+  return { text, replyMarkup: { inline_keyboard } };
+}
+function renderHelpToolDetail(scope, toolName, returnPage) {
+  const tools = buildScopedToolList(scope);
+  const tool = tools.find((t2) => t2.name === toolName);
+  if (!tool) return null;
+  const text = buildToolDetailText(tool);
+  const inline_keyboard = buildToolDetailKeyboard(tool, returnPage);
+  return { text, replyMarkup: { inline_keyboard } };
+}
+function handleHelpCallback(callbackData, currentState) {
+  const decoded = decodeHelpCallback(callbackData);
+  if (!decoded) return null;
+  const { action, value: value2 } = decoded;
+  let newState;
+  let render2;
+  switch (action) {
+    case "page": {
+      const page2 = parseInt(value2, 10);
+      if (isNaN(page2)) return null;
+      render2 = renderHelpMenuPage(currentState.scope, page2);
+      newState = { ...currentState, page: page2, view: "list", detailToolName: null, lastInteractionAt: Date.now() };
+      break;
+    }
+    case "detail": {
+      const detail = renderHelpToolDetail(currentState.scope, value2, currentState.page);
+      if (!detail) return null;
+      render2 = detail;
+      newState = { ...currentState, view: "detail", detailToolName: value2, lastInteractionAt: Date.now() };
+      break;
+    }
+    case "back": {
+      const page2 = parseInt(value2, 10);
+      if (isNaN(page2)) return null;
+      render2 = renderHelpMenuPage(currentState.scope, page2);
+      newState = { ...currentState, page: page2, view: "list", detailToolName: null, lastInteractionAt: Date.now() };
+      break;
+    }
+    case "close": {
+      return { render: null, newState: currentState, close: true };
+    }
+    default:
+      return null;
+  }
+  return { render: render2, newState };
+}
+var TOOLS_PER_PAGE, GRID_COLS, CALLBACK_PREFIX, MAX_CALLBACK_DATA, INACTIVITY_TIMEOUT_MS, COUNTDOWN_SECONDS, TELEGRAM_PUBLIC_HELP_COMMANDS, HelpMenuStateStore, HelpMenuTimerManager;
+var init_telegram_help_menu = __esm({
+  "packages/cli/src/tui/telegram-help-menu.ts"() {
+    "use strict";
+    init_command_registry();
+    TOOLS_PER_PAGE = 10;
+    GRID_COLS = 5;
+    CALLBACK_PREFIX = "help";
+    MAX_CALLBACK_DATA = 64;
+    INACTIVITY_TIMEOUT_MS = 6e4;
+    COUNTDOWN_SECONDS = 10;
+    TELEGRAM_PUBLIC_HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "start", "auth", "call"]);
+    HelpMenuStateStore = class {
+      states = /* @__PURE__ */ new Map();
+      TTL_MS = 30 * 60 * 1e3;
+      // 30 min
+      key(chatId, messageId) {
+        return `${chatId}:${messageId}`;
+      }
+      set(state) {
+        this.states.set(this.key(state.chatId, state.messageId), state);
+      }
+      get(chatId, messageId) {
+        return this.states.get(this.key(chatId, messageId));
+      }
+      delete(chatId, messageId) {
+        this.states.delete(this.key(chatId, messageId));
+      }
+      /** Prune expired states */
+      prune() {
+        const now = Date.now();
+        for (const [k, v] of this.states) {
+          if (now - v.createdAt > this.TTL_MS) this.states.delete(k);
+        }
+      }
+    };
+    HelpMenuTimerManager = class {
+      inactivityTimers = /* @__PURE__ */ new Map();
+      countdownIntervals = /* @__PURE__ */ new Map();
+      stateStore;
+      callbacks;
+      constructor(stateStore, callbacks) {
+        this.stateStore = stateStore;
+        this.callbacks = callbacks;
+      }
+      key(chatId, messageId) {
+        return `${chatId}:${messageId}`;
+      }
+      /** Start the inactivity timer for a newly created menu */
+      startTimer(state) {
+        this.clearTimer(state.chatId, state.messageId);
+        const k = this.key(state.chatId, state.messageId);
+        const timer = setTimeout(() => {
+          this.inactivityTimers.delete(k);
+          this.startCountdown(state);
+        }, INACTIVITY_TIMEOUT_MS);
+        this.inactivityTimers.set(k, timer);
+      }
+      /** Reset the inactivity timer after user interaction */
+      resetTimer(chatId, messageId) {
+        const state = this.stateStore.get(chatId, messageId);
+        if (!state) return;
+        this.cancelCountdown(chatId, messageId);
+        const updated = { ...state, lastInteractionAt: Date.now(), countdownValue: null };
+        this.stateStore.set(updated);
+        this.startTimer(updated);
+      }
+      /** Clear all timers for a menu (used when menu is closed or deleted) */
+      clearTimer(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        const timer = this.inactivityTimers.get(k);
+        if (timer) {
+          clearTimeout(timer);
+          this.inactivityTimers.delete(k);
+        }
+        this.cancelCountdown(chatId, messageId);
+      }
+      /** Start the 10-second countdown, updating the close button each second */
+      startCountdown(state) {
+        const k = this.key(state.chatId, state.messageId);
+        let countdown = COUNTDOWN_SECONDS;
+        const updatedState = { ...state, countdownValue: countdown, lastInteractionAt: Date.now() };
+        this.stateStore.set(updatedState);
+        this.updateCountdownButton(updatedState);
+        const interval = setInterval(() => {
+          countdown--;
+          if (countdown <= 0) {
+            clearInterval(interval);
+            this.countdownIntervals.delete(k);
+            this.deleteMenu(state.chatId, state.messageId);
+          } else {
+            const s2 = { ...state, countdownValue: countdown, lastInteractionAt: Date.now() };
+            this.stateStore.set(s2);
+            this.updateCountdownButton(s2);
+          }
+        }, 1e3);
+        this.countdownIntervals.set(k, interval);
+      }
+      cancelCountdown(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        const interval = this.countdownIntervals.get(k);
+        if (interval) {
+          clearInterval(interval);
+          this.countdownIntervals.delete(k);
+        }
+      }
+      /** Update the close button to show countdown value */
+      async updateCountdownButton(state) {
+        try {
+          let render2;
+          if (state.view === "list") {
+            render2 = renderHelpMenuPageWithCountdown(state.scope, state.page, state.countdownValue);
+          } else {
+            render2 = renderHelpToolDetail(state.scope, state.detailToolName, state.page);
+          }
+          if (!render2) return;
+          await this.callbacks.editMessageText(
+            state.chatId,
+            state.messageId,
+            render2.text,
+            render2.replyMarkup
+          );
+        } catch {
+        }
+      }
+      /** Delete the menu message and clean up state */
+      async deleteMenu(chatId, messageId) {
+        this.clearTimer(chatId, messageId);
+        this.stateStore.delete(chatId, messageId);
+        try {
+          await this.callbacks.deleteMessage(chatId, messageId);
+        } catch {
+        }
+      }
+      /** Clean up all timers (for shutdown) */
+      destroyAll() {
+        for (const [k, timer] of this.inactivityTimers) {
+          clearTimeout(timer);
+        }
+        this.inactivityTimers.clear();
+        for (const [k, interval] of this.countdownIntervals) {
+          clearInterval(interval);
+        }
+        this.countdownIntervals.clear();
+      }
+    };
+  }
+});
+
 // packages/cli/src/tui/telegram-creative-tools.ts
 import { createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, randomBytes as randomBytes21 } from "node:crypto";
 import {
@@ -611355,7 +611747,7 @@ function splitTelegramReminderDue(raw) {
   if (suffixMatch) return { due: suffixMatch[2].trim(), message: suffixMatch[1].trim() };
   return { message: text };
 }
-function telegramSyntheticHelpSignatures() {
+function telegramSyntheticHelpSignatures2() {
   return [
     { signature: "/help", description: "Show Telegram command help" },
     { signature: "/start", description: "Show Telegram bridge status and authentication instructions" },
@@ -611369,15 +611761,15 @@ function telegramSyntheticHelpSignatures() {
     { signature: "/daydream", description: "Alias for /reflect in Telegram chats" }
   ];
 }
-function telegramHelpCommandAllowed(cmd, scope) {
+function telegramHelpCommandAllowed2(cmd, scope) {
   if (cmd.name === "dream") return false;
   if (scope === "admin") return cmd.implementationStatus === "implemented";
-  return TELEGRAM_PUBLIC_HELP_COMMANDS.has(cmd.name) || TELEGRAM_PUBLIC_BOT_COMMAND_NAMES.has(cmd.name);
+  return TELEGRAM_PUBLIC_HELP_COMMANDS2.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));
+  const commands = listCommandRegistry({ includePlanned: false }).filter((cmd) => telegramHelpCommandAllowed2(cmd, scope));
   const signatures = [
-    ...telegramSyntheticHelpSignatures(),
+    ...telegramSyntheticHelpSignatures2(),
     ...commands.flatMap((cmd) => cmd.signatures)
   ];
   const seen = /* @__PURE__ */ new Set();
@@ -612091,7 +612483,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_INTERACTION_DECISION_RESPONSE_FORMAT, 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_MEMORY_GENERIC_QUERY_TOKENS, 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_ALLOWED_UPDATES, 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_INTERACTION_DECISION_RESPONSE_FORMAT, 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_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS2, 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_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -612102,6 +612494,7 @@ var init_telegram_bridge = __esm({
     init_tool_policy();
     init_media_routing();
     init_command_registry();
+    init_telegram_help_menu();
     init_scoped_personality();
     init_telegram_creative_tools();
     init_omnius_directory();
@@ -612468,7 +612861,7 @@ External acquisition contract:
       bruteForceMaxCycles: 0,
       allowTurnExtension: false
     };
-    TELEGRAM_PUBLIC_HELP_COMMANDS = /* @__PURE__ */ new Set(["help", "start", "auth", "call"]);
+    TELEGRAM_PUBLIC_HELP_COMMANDS2 = /* @__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(
@@ -612562,6 +612955,12 @@ External acquisition contract:
       telegramBotRightsCache = /* @__PURE__ */ new Map();
       /** Short-lived Telegram inline button state directory */
       telegramToolButtonDir;
+      /** Interactive help menu state store (inline keyboard navigation) */
+      helpMenuStates = new HelpMenuStateStore();
+      /** Auto-close timer manager for help menus (inactivity → countdown → delete) */
+      helpMenuTimers = null;
+      /** Prune expired help menu states every 5 minutes */
+      helpMenuPruneTimer = 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 */
@@ -612983,21 +613382,53 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
       }
       async replyWithTelegramHelp(msg, isAdmin) {
         const scope = isAdmin ? "admin" : "public";
-        const chunks = splitTelegramHTMLMessage(buildTelegramHelpHTML(scope));
+        const menu = renderHelpMenu(scope);
         if (msg.guestQueryId) {
+          const chunks = splitTelegramHTMLMessage(buildTelegramHelpHTML(isAdmin ? "admin" : "public"));
           await this.answerGuestQuery(msg.guestQueryId, chunks[0] ?? "", { parseMode: "HTML" });
           return;
         }
-        for (let i2 = 0; i2 < chunks.length; i2++) {
-          const chunk = chunks[i2];
-          if (i2 === 0) {
-            await this.replyToTelegramMessage(msg, chunk, {
-              html: true,
-              replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
+        const sent = await this.apiCall("sendMessage", {
+          chat_id: msg.chatId,
+          text: menu.text,
+          parse_mode: "HTML",
+          reply_markup: JSON.stringify(menu.replyMarkup),
+          ...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,
+            view: "list",
+            detailToolName: null,
+            fromUserId: msg.fromUserId ?? 0,
+            createdAt: Date.now(),
+            lastInteractionAt: Date.now(),
+            countdownValue: null
+          };
+          this.helpMenuStates.set(state);
+          if (!this.helpMenuTimers) {
+            this.helpMenuTimers = new HelpMenuTimerManager(this.helpMenuStates, {
+              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
+                });
+              }
             });
-          } else {
-            await this.sendMessageHTML(msg.chatId, chunk);
           }
+          this.helpMenuTimers.startTimer(state);
         }
       }
       recordChatHistory(sessionKey, entry) {
@@ -619310,6 +619741,71 @@ Scoped workspace: ${scopedRoot}`,
         return Boolean(result.ok);
       }
       async handleTelegramCallbackQuery(callback) {
+        const helpDecoded = decodeHelpCallback(callback.data);
+        if (helpDecoded) {
+          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.helpMenuStates.get(chatId, messageId);
+            if (!menuState) {
+              answerText2 = "This help menu expired. Send /help for a fresh one.";
+              alert2 = true;
+              return;
+            }
+            const isAdmin = this.isAdminActor(callback.fromUserId, callback.username);
+            if (callback.fromUserId !== menuState.fromUserId && !isAdmin) {
+              answerText2 = "Only the user who opened this menu can navigate it.";
+              alert2 = true;
+              return;
+            }
+            const result = handleHelpCallback(callback.data, menuState);
+            if (!result) {
+              answerText2 = "Unknown menu action.";
+              alert2 = true;
+              return;
+            }
+            if (result.close) {
+              this.helpMenuStates.delete(chatId, messageId);
+              this.helpMenuTimers?.deleteMenu(chatId, messageId);
+              try {
+                await this.apiCall("deleteMessage", {
+                  chat_id: chatId,
+                  message_id: messageId
+                });
+              } catch {
+              }
+              await this.answerCallbackQuery(callback.id).catch(() => false);
+              return;
+            }
+            this.helpMenuStates.set(result.newState);
+            this.helpMenuTimers?.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.replyMarkup)
+            });
+            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.84",
+  "version": "1.0.86",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.84",
+      "version": "1.0.86",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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