omnius 1.0.199 → 1.0.200

package/dist/index.js

@@ -23044,6 +23044,13 @@ function deleteRepoFromCache(repo) {
   }
   return removed;
 }
+function deleteCachedModel(repo) {
+  const bytesFreed = deleteRepoFromCache(repo);
+  const meta = readMeta();
+  meta.entries = meta.entries.filter((entry) => entry.repo !== repo);
+  writeMeta(meta);
+  return { repo, bytesFreed };
+}
 function evictModelsToFreeSpace(args) {
   const safetyMargin = args.safetyMarginBytes ?? 1 * 1024 ** 3;
   const target = args.neededBytes + safetyMargin;
@@ -534863,6 +534870,7 @@ __export(dist_exports, {
   createWorktree: () => createWorktree2,
   defaultExposureForTool: () => defaultExposureForTool,
   defaultExtensionForMime: () => defaultExtensionForMime,
+  deleteCachedModel: () => deleteCachedModel,
   deleteMediaModelAdapter: () => deleteMediaModelAdapter,
   deleteTodos: () => deleteTodos,
   detectCudaDevices: () => detectCudaDevices,
@@ -630825,9 +630833,14 @@ function buildTelegramCommandMenuItems(scope) {
     seen.add(cmd.name);
     items.push({
       label: `/${cmd.name}`,
-      command: `/${cmd.name}`,
       description: cmd.signatures[0]?.description ?? signature,
-      adminOnly: scope === "admin"
+      adminOnly: scope === "admin",
+      action: {
+        type: "command_detail",
+        command: `/${cmd.name}`,
+        label: `/${cmd.name}`,
+        description: cmd.signatures.map((sig) => `${sig.signature} - ${sig.description}`).join("\n")
+      }
     });
   }
   return items.sort((a2, b) => a2.label.localeCompare(b.label));
@@ -630835,10 +630848,18 @@ function buildTelegramCommandMenuItems(scope) {
 function buildTelegramGenerativeMenuItems(commandName) {
   const name10 = commandName.replace(/^\//, "").toLowerCase();
   if (!GENERATIVE_COMMANDS.has(name10)) return [];
+  if (name10 === "models") {
+    return [
+      { label: "CAD models", description: "Browse text-to-CAD adapters.", action: { type: "models", generation: "cad" } },
+      { label: "3D models", description: "Browse 3D mesh/reconstruction adapters.", action: { type: "models", generation: "model3d" } },
+      { label: "Model store", command: "/models", description: "Show unified model store status.", action: { type: "command", command: "/models" } }
+    ];
+  }
   const title = name10[0].toUpperCase() + name10.slice(1);
+  const generation = name10 === "sound" ? "sound" : name10 === "music" ? "music" : name10;
   return [
-    { label: `${title} models`, command: `/${name10} list`, description: `List available ${name10} models and hardware fit.` },
-    { label: `${title} setup`, command: `/${name10} setup`, description: `Show setup commands for the ${name10} backend.` }
+    { label: `${title} models`, description: `Browse selectable ${name10} models, metadata, cache state, and actions.`, action: { type: "models", generation } },
+    { label: `${title} setup`, description: `Show setup commands for the ${name10} backend.`, action: { type: "setup_generation", generation } }
   ];
 }
 function encodeTelegramCommandMenuCallback(action, value2) {
@@ -630848,43 +630869,85 @@ function encodeTelegramCommandMenuCallback(action, value2) {
 function decodeTelegramCommandMenuCallback(data) {
   const parts = data.split(":");
   if (parts.length !== 3 || parts[0] !== CALLBACK_PREFIX2) return null;
-  const action = parts[1] === "p" ? "page" : parts[1] === "r" ? "run" : parts[1] === "c" ? "close" : null;
+  const action = parts[1] === "p" ? "page" : parts[1] === "r" ? "run" : parts[1] === "c" ? "close" : parts[1] === "b" ? "back" : null;
   if (!action) return null;
   return { action, value: parts[2] ?? "" };
 }
+function pushTelegramCommandMenuState(state, next) {
+  const crumb = {
+    kind: state.kind,
+    title: state.title,
+    subtitle: state.subtitle,
+    body: state.body,
+    page: state.page,
+    items: state.items
+  };
+  return {
+    ...state,
+    kind: next.kind ?? state.kind,
+    title: next.title,
+    subtitle: next.subtitle,
+    body: next.body,
+    page: next.page ?? 0,
+    items: next.items,
+    breadcrumbs: [...state.breadcrumbs ?? [], crumb]
+  };
+}
+function popTelegramCommandMenuState(state) {
+  const stack = state.breadcrumbs ?? [];
+  const previous = stack.at(-1);
+  if (!previous) return null;
+  return {
+    ...state,
+    kind: previous.kind,
+    title: previous.title,
+    subtitle: previous.subtitle,
+    body: previous.body,
+    page: previous.page,
+    items: previous.items,
+    breadcrumbs: stack.slice(0, -1)
+  };
+}
 function renderTelegramCommandMenu(state) {
   const totalPages = Math.max(1, Math.ceil(state.items.length / PAGE_SIZE2));
   const page2 = Math.max(0, Math.min(state.page, totalPages - 1));
   const start2 = page2 * PAGE_SIZE2;
   const visible = state.items.slice(start2, start2 + PAGE_SIZE2);
-  const title = state.kind === "generative" ? "Generative command" : "Commands";
+  const title = state.title || (state.kind === "generative" ? "Generative command" : state.kind === "models" ? "Models" : "Commands");
   const scope = state.scope === "admin" ? "admin" : "public";
   const lines = [
     `<b>${escapeHTML3(title)}</b>`,
     `<i>${escapeHTML3(scope)} scope - page ${page2 + 1}/${totalPages}</i>`,
+    state.subtitle ? escapeHTML3(state.subtitle) : "",
+    state.body ? `<blockquote expandable>${escapeHTML3(state.body)}</blockquote>` : "",
     "",
     ...visible.flatMap((item) => [
-      `<code>${escapeHTML3(item.command)}</code>`,
+      item.command ? `<code>${escapeHTML3(item.command)}</code>` : `<b>${escapeHTML3(item.label)}</b>`,
       escapeHTML3(item.description)
     ])
-  ];
+  ].filter((line) => line !== "");
   const keyboard = visible.map((item, offset) => [{
     text: item.label.slice(0, 32),
     callback_data: encodeTelegramCommandMenuCallback("run", start2 + offset)
   }]);
   const nav = [];
   nav.push({ text: "Close", callback_data: encodeTelegramCommandMenuCallback("close", 0) });
+  if ((state.breadcrumbs ?? []).length > 0) nav.push({ text: "Back", callback_data: encodeTelegramCommandMenuCallback("back", 0) });
   if (page2 > 0) nav.push({ text: "Prev", callback_data: encodeTelegramCommandMenuCallback("page", page2 - 1) });
   nav.push({ text: `${page2 + 1}/${totalPages}`, callback_data: encodeTelegramCommandMenuCallback("page", page2) });
   if (page2 < totalPages - 1) nav.push({ text: "Next", callback_data: encodeTelegramCommandMenuCallback("page", page2 + 1) });
   keyboard.push(nav);
-  return { text: lines.join("\n"), reply_markup: { inline_keyboard: keyboard } };
+  return { text: truncateTelegramMenuText(lines.join("\n")), reply_markup: { inline_keyboard: keyboard } };
 }
 function handleTelegramCommandMenuCallback(data, state, now = Date.now()) {
   const decoded = decodeTelegramCommandMenuCallback(data);
   if (!decoded) return null;
   if (state.expiresAt <= now) return null;
   if (decoded.action === "close") return { close: true };
+  if (decoded.action === "back") {
+    const newState = popTelegramCommandMenuState(state);
+    return newState ? { newState, render: renderTelegramCommandMenu(newState) } : null;
+  }
   if (decoded.action === "page") {
     const totalPages = Math.max(1, Math.ceil(state.items.length / PAGE_SIZE2));
     const page2 = Math.max(0, Math.min(Number.parseInt(decoded.value, 10) || 0, totalPages - 1));
@@ -630893,21 +630956,28 @@ function handleTelegramCommandMenuCallback(data, state, now = Date.now()) {
   }
   const index = Number.parseInt(decoded.value, 10);
   const item = Number.isFinite(index) ? state.items[index] : void 0;
-  return item ? { command: item.command } : null;
+  if (!item) return null;
+  return item.command ? { command: item.command, item } : { item };
 }
 function escapeHTML3(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function truncateTelegramMenuText(text) {
+  if (text.length <= 3900) return text;
+  return `${text.slice(0, 3820)}
+
+<i>... menu page clipped; use buttons to narrow this view.</i>`;
+}
 var CALLBACK_PREFIX2, PAGE_SIZE2, TTL_MS, MAX_CALLBACK_DATA_BYTES, GENERATIVE_COMMANDS, TelegramCommandMenuStateStore;
 var init_telegram_command_menu = __esm({
   "packages/cli/src/tui/telegram-command-menu.ts"() {
     "use strict";
     init_command_registry();
     CALLBACK_PREFIX2 = "ocm";
-    PAGE_SIZE2 = 8;
+    PAGE_SIZE2 = 7;
     TTL_MS = 10 * 60 * 1e3;
     MAX_CALLBACK_DATA_BYTES = 64;
-    GENERATIVE_COMMANDS = /* @__PURE__ */ new Set(["image", "video", "sound", "music"]);
+    GENERATIVE_COMMANDS = /* @__PURE__ */ new Set(["image", "video", "sound", "music", "models"]);
     TelegramCommandMenuStateStore = class {
       states = /* @__PURE__ */ new Map();
       key(chatId, messageId) {
@@ -630916,6 +630986,7 @@ var init_telegram_command_menu = __esm({
       create(input, now = Date.now()) {
         return {
           ...input,
+          breadcrumbs: input.breadcrumbs ?? [],
           createdAt: now,
           expiresAt: now + TTL_MS
         };
@@ -634367,6 +634438,17 @@ import { join as join140, resolve as resolve53, basename as basename35, relative
 import { homedir as homedir44 } from "node:os";
 import { writeFile as writeFileAsync } from "node:fs/promises";
 import { createHash as createHash33, randomBytes as randomBytes25, randomInt } from "node:crypto";
+function formatModelBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value2 = bytes;
+  let unit = 0;
+  while (value2 >= 1024 && unit < units.length - 1) {
+    value2 /= 1024;
+    unit++;
+  }
+  return `${value2 >= 10 || unit === 0 ? value2.toFixed(0) : value2.toFixed(1)} ${units[unit]}`;
+}
 function cleanTelegramDecisionNote(value2, maxLength = 260) {
   if (typeof value2 !== "string") return void 0;
   const clean5 = stripTelegramHiddenThinking(value2).replace(/\s+/g, " ").trim();
@@ -637055,6 +637137,8 @@ Telegram link integrity contract:
       statsMenuPruneTimer = null;
       /** Telegram-native command and generative command menus */
       telegramCommandMenuStates = new TelegramCommandMenuStateStore();
+      /** One-shot Telegram prompt intents created by model-menu "Generate" buttons. */
+      telegramGenerationPromptIntents = /* @__PURE__ */ new Map();
       /** 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 */
@@ -637992,7 +638076,7 @@ ${message2}`)
           return;
         }
         if (msg.guestQueryId || !isAdmin) {
-          const lines = items.slice(0, 24).map((item) => `${item.command} - ${item.description}`);
+          const lines = items.slice(0, 24).map((item) => `${item.command ?? item.label} - ${item.description}`);
           const text = ["Available commands:", "", ...lines].join("\n");
           if (msg.guestQueryId) {
             await this.answerGuestQuery(msg.guestQueryId, text);
@@ -638008,9 +638092,14 @@ ${message2}`)
           fromUserId: msg.fromUserId ?? 0,
           scope,
           kind,
+          title: kind === "generative" ? `/${commandName ?? "models"}` : void 0,
+          subtitle: kind === "generative" ? "Telegram-native menu; buttons render data and tools directly here." : void 0,
           page: 0,
           items
         });
+        await this.sendTelegramCommandMenuState(msg, previewState);
+      }
+      async sendTelegramCommandMenuState(msg, previewState) {
         const menu = renderTelegramCommandMenu(previewState);
         const sent = await this.apiCall("sendMessage", {
           chat_id: msg.chatId,
@@ -638027,6 +638116,643 @@ ${message2}`)
           });
         }
       }
+      async editTelegramCommandMenuState(chatId, messageId, state) {
+        const render2 = renderTelegramCommandMenu(state);
+        this.telegramCommandMenuStates.set(state);
+        await this.apiCall("editMessageText", {
+          chat_id: chatId,
+          message_id: messageId,
+          text: render2.text,
+          parse_mode: "HTML",
+          reply_markup: JSON.stringify(render2.reply_markup)
+        });
+      }
+      telegramGenerationIntentKey(chatId, fromUserId) {
+        return `${String(chatId)}:${fromUserId}`;
+      }
+      pruneTelegramGenerationPromptIntents(now = Date.now()) {
+        for (const [key, intent] of this.telegramGenerationPromptIntents) {
+          if (intent.expiresAt <= now) this.telegramGenerationPromptIntents.delete(key);
+        }
+      }
+      telegramGenerationLabel(generation) {
+        if (generation === "model3d") return "3D model";
+        if (generation === "cad") return "CAD";
+        return generation;
+      }
+      telegramModelCachedBytes(dependencies) {
+        return dependencies.reduce((sum, dep) => sum + measureRepoCacheBytes(dep), 0);
+      }
+      telegramImageModelDescriptors() {
+        return imageGenerationModelPresets().map((preset) => {
+          const dependencies = imagePresetDependencyModels(preset, preset.id);
+          return {
+            generation: "image",
+            id: preset.id,
+            label: preset.label,
+            backend: preset.backend,
+            category: preset.category ?? "Image",
+            sizeClass: preset.sizeClass ?? "",
+            quality: preset.quality ?? preset.note,
+            note: preset.note,
+            install: preset.install,
+            minVramGB: preset.minVramGB,
+            recommendedVramGB: preset.recommendedVramGB,
+            approxDownloadGB: preset.approxDownloadGB,
+            dependencies,
+            cachedBytes: this.telegramModelCachedBytes(dependencies)
+          };
+        });
+      }
+      telegramAudioModelDescriptors(kind) {
+        return audioGenerationModelPresets(kind).map((preset) => {
+          const dependencies = [preset.id];
+          return {
+            generation: kind,
+            id: preset.id,
+            label: preset.label,
+            backend: preset.backend,
+            category: preset.category,
+            sizeClass: preset.sizeClass,
+            quality: preset.quality,
+            note: preset.note,
+            install: preset.install,
+            minVramGB: preset.minVramGB,
+            recommendedVramGB: preset.recommendedVramGB,
+            approxDownloadGB: preset.approxDownloadGB,
+            dependencies,
+            cachedBytes: this.telegramModelCachedBytes(dependencies)
+          };
+        });
+      }
+      telegramVideoModelDescriptors() {
+        return videoGenerationModelPresets().map((preset) => {
+          const dependencies = [preset.id];
+          return {
+            generation: "video",
+            id: preset.id,
+            label: preset.label,
+            backend: preset.backend,
+            category: preset.category,
+            sizeClass: preset.sizeClass,
+            quality: preset.quality,
+            note: preset.note,
+            install: preset.install,
+            minVramGB: preset.minVramGB,
+            recommendedVramGB: preset.recommendedVramGB,
+            approxDownloadGB: preset.approxDownloadGB,
+            dependencies,
+            cachedBytes: this.telegramModelCachedBytes(dependencies),
+            unavailableReason: preset.gated ? "Requires Hugging Face token/license acceptance." : void 0
+          };
+        });
+      }
+      telegramCad3dModelDescriptors(generation) {
+        const modality = generation === "cad" ? "cad" : "3d";
+        return listMediaModelCatalog(modality).map((entry) => {
+          const spec = entry.spec;
+          const dependencies = [spec.repoId];
+          const notes = spec.deployment.notes.join(" ");
+          return {
+            generation,
+            id: spec.id,
+            label: spec.label || spec.repoId,
+            backend: spec.backend,
+            category: `${spec.modality}/${spec.status}`,
+            sizeClass: spec.resources.approxDownloadGB ? `~${spec.resources.approxDownloadGB}GB download` : spec.runner,
+            quality: spec.hf.cardExcerpt || notes || spec.runner,
+            note: notes || spec.deployment.install,
+            install: spec.deployment.install,
+            minVramGB: spec.resources.minVramGB,
+            recommendedVramGB: spec.resources.recommendedVramGB,
+            approxDownloadGB: spec.resources.approxDownloadGB,
+            dependencies,
+            cachedBytes: this.telegramModelCachedBytes(dependencies),
+            unavailableReason: spec.deployment.runtimeCompatible ? void 0 : "Catalog metadata exists, but the runtime adapter is not wired for artifact creation."
+          };
+        });
+      }
+      telegramGenerationModelDescriptors(generation) {
+        if (generation === "image") return this.telegramImageModelDescriptors();
+        if (generation === "sound" || generation === "music") return this.telegramAudioModelDescriptors(generation);
+        if (generation === "video") return this.telegramVideoModelDescriptors();
+        return this.telegramCad3dModelDescriptors(generation);
+      }
+      telegramModelDescriptor(generation, id) {
+        return this.telegramGenerationModelDescriptors(generation).find((model) => model.id === id);
+      }
+      telegramModelMenuItems(generation) {
+        return this.telegramGenerationModelDescriptors(generation).map((model) => {
+          const cached = model.cachedBytes > 0 ? `cached ${formatModelBytes(model.cachedBytes)}` : "not downloaded";
+          const fit3 = model.recommendedVramGB ? `${model.recommendedVramGB}GB VRAM rec` : model.minVramGB ? `${model.minVramGB}GB VRAM min` : "VRAM n/a";
+          return {
+            label: model.label,
+            description: `${model.backend} - ${model.category} - ${fit3} - ${cached}`,
+            action: {
+              type: "model_detail",
+              generation,
+              model: model.id
+            }
+          };
+        });
+      }
+      telegramModelDetailBody(model) {
+        const cached = model.cachedBytes > 0 ? `${formatModelBytes(model.cachedBytes)} cached` : "not downloaded";
+        const deps = model.dependencies.length > 0 ? model.dependencies.join(", ") : model.id;
+        return [
+          `id: ${model.id}`,
+          `backend: ${model.backend}`,
+          `category: ${model.category}`,
+          `size: ${model.sizeClass || "unknown"}`,
+          `download: ${model.approxDownloadGB ? `~${model.approxDownloadGB}GB` : "unknown"}; cache: ${cached}`,
+          `vram: min ${model.minVramGB ?? "?"}GB; recommended ${model.recommendedVramGB ?? "?"}GB`,
+          `dependencies: ${deps}`,
+          model.unavailableReason ? `runtime note: ${model.unavailableReason}` : "",
+          "",
+          `quality: ${model.quality}`,
+          "",
+          `note: ${model.note}`,
+          model.install ? `
+install/prewarm: ${model.install}` : ""
+        ].filter(Boolean).join("\n");
+      }
+      telegramModelDetailItems(model) {
+        return [
+          {
+            label: "Generate",
+            description: "Use this model for the next Telegram message you type.",
+            action: { type: "await_prompt", generation: model.generation, model: model.id, backend: model.backend, label: model.label }
+          },
+          {
+            label: "Load",
+            description: "Download/prewarm or check this model in the generation runtime.",
+            action: { type: "prewarm_model", generation: model.generation, model: model.id, backend: model.backend, label: model.label }
+          },
+          {
+            label: "Delete",
+            description: "Remove cached weights for this model and its adapter/base dependencies.",
+            action: { type: "delete_model", generation: model.generation, model: model.id, backend: model.backend, label: model.label }
+          }
+        ];
+      }
+      async replyWithTelegramModelBrowser(msg, isAdmin, generation) {
+        if (!isAdmin) {
+          await this.replyToTelegramMessage(msg, "Model menus require Telegram admin authentication.");
+          return;
+        }
+        const scope = "admin";
+        const title = `${this.telegramGenerationLabel(generation)} models`;
+        const cachedCount = listCachedModels().length;
+        const previewState = this.telegramCommandMenuStates.create({
+          chatId: msg.chatId,
+          messageId: 0,
+          invokerMessageId: msg.messageId,
+          fromUserId: msg.fromUserId ?? 0,
+          scope,
+          kind: "models",
+          title,
+          subtitle: `${cachedCount} cached model record(s). Select a model for metadata, load, delete, or generate.`,
+          page: 0,
+          items: this.telegramModelMenuItems(generation)
+        });
+        await this.sendTelegramCommandMenuState(msg, previewState);
+      }
+      parseTelegramGenerationMenuKind(value2) {
+        const raw = String(value2 ?? "").toLowerCase();
+        if (raw === "image" || raw === "sound" || raw === "music" || raw === "video" || raw === "cad") return raw;
+        if (raw === "model3d" || raw === "3d" || raw === "model") return "model3d";
+        return null;
+      }
+      async handleTelegramCommandMenuAction(callback, state, action) {
+        if (!action) return { handled: false };
+        const chatId = callback.chatId;
+        const messageId = callback.messageId;
+        if (!chatId || !messageId) return { handled: true, answerText: "Cannot identify menu message.", alert: true };
+        if (action.type === "command_detail") {
+          const command = typeof action.command === "string" ? action.command : "";
+          if (!command) return { handled: true, answerText: "Command metadata is missing.", alert: true };
+          const body = [
+            `command: ${command}`,
+            "",
+            typeof action.description === "string" ? action.description : "No command details available."
+          ].join("\n");
+          const nextState = pushTelegramCommandMenuState(state, {
+            kind: "detail",
+            title: command,
+            subtitle: "Telegram command",
+            body,
+            items: [{
+              label: "Run",
+              command,
+              description: `Execute ${command}.`,
+              action: { type: "command", command }
+            }]
+          });
+          await this.editTelegramCommandMenuState(chatId, messageId, nextState);
+          return { handled: true };
+        }
+        if (action.type === "models") {
+          const generation = this.parseTelegramGenerationMenuKind(action.generation);
+          if (!generation) return { handled: true, answerText: "Unknown model menu.", alert: true };
+          const nextState = pushTelegramCommandMenuState(state, {
+            kind: "models",
+            title: `${this.telegramGenerationLabel(generation)} models`,
+            subtitle: "Select a model for metadata, load, delete, or generate.",
+            items: this.telegramModelMenuItems(generation)
+          });
+          await this.editTelegramCommandMenuState(chatId, messageId, nextState);
+          return { handled: true };
+        }
+        if (action.type === "setup_generation") {
+          const generation = this.parseTelegramGenerationMenuKind(action.generation);
+          if (!generation) return { handled: true, answerText: "Unknown setup menu.", alert: true };
+          await this.answerCallbackQuery(callback.id, `Preparing ${this.telegramGenerationLabel(generation)} setup...`).catch(() => false);
+          await this.replyWithTelegramGenerationSetup({
+            chatId,
+            text: "",
+            username: callback.username,
+            firstName: callback.firstName,
+            messageId,
+            fromUserId: callback.fromUserId,
+            chatType: "private"
+          }, generation);
+          return { handled: true, answered: true };
+        }
+        if (action.type === "model_detail") {
+          const generation = this.parseTelegramGenerationMenuKind(action.generation);
+          const modelId = typeof action.model === "string" ? action.model : "";
+          const descriptor = generation ? this.telegramModelDescriptor(generation, modelId) : void 0;
+          if (!generation || !descriptor) return { handled: true, answerText: "Model metadata is no longer available.", alert: true };
+          const nextState = pushTelegramCommandMenuState(state, {
+            kind: "detail",
+            title: descriptor.label,
+            subtitle: `${this.telegramGenerationLabel(generation)} model`,
+            body: this.telegramModelDetailBody(descriptor),
+            items: this.telegramModelDetailItems(descriptor)
+          });
+          await this.editTelegramCommandMenuState(chatId, messageId, nextState);
+          return { handled: true };
+        }
+        if (action.type === "await_prompt") {
+          const generation = this.parseTelegramGenerationMenuKind(action.generation);
+          const modelId = typeof action.model === "string" ? action.model : "";
+          const descriptor = generation ? this.telegramModelDescriptor(generation, modelId) : void 0;
+          if (!generation || !descriptor) return { handled: true, answerText: "Model metadata is no longer available.", alert: true };
+          const now = Date.now();
+          this.pruneTelegramGenerationPromptIntents(now);
+          this.telegramGenerationPromptIntents.set(this.telegramGenerationIntentKey(chatId, callback.fromUserId), {
+            chatId,
+            chatType: "private",
+            fromUserId: callback.fromUserId,
+            username: callback.username,
+            generation,
+            model: descriptor.id,
+            backend: descriptor.backend,
+            label: descriptor.label,
+            createdAt: now,
+            expiresAt: now + 15 * 6e4,
+            menuMessageId: messageId
+          });
+          const nextState = {
+            ...state,
+            subtitle: "Waiting for your next Telegram message.",
+            body: [
+              `Selected: ${descriptor.label}`,
+              `Model: ${descriptor.id}`,
+              "",
+              `Send the prompt you want to generate. Omnius will expand it first, then run the ${this.telegramGenerationLabel(generation)} pipeline with this model.`,
+              "Send /cancel to clear this pending generation."
+            ].join("\n")
+          };
+          await this.editTelegramCommandMenuState(chatId, messageId, nextState);
+          return { handled: true, answerText: "Send the prompt as your next Telegram message." };
+        }
+        if (action.type === "prewarm_model") {
+          const generation = this.parseTelegramGenerationMenuKind(action.generation);
+          const modelId = typeof action.model === "string" ? action.model : "";
+          const descriptor = generation ? this.telegramModelDescriptor(generation, modelId) : void 0;
+          if (!generation || !descriptor) return { handled: true, answerText: "Model metadata is no longer available.", alert: true };
+          await this.answerCallbackQuery(callback.id, `Loading ${descriptor.label}...`).catch(() => false);
+          await this.runTelegramGenerationPrewarm(chatId, descriptor);
+          return { handled: true, answered: true };
+        }
+        if (action.type === "delete_model") {
+          const generation = this.parseTelegramGenerationMenuKind(action.generation);
+          const modelId = typeof action.model === "string" ? action.model : "";
+          const descriptor = generation ? this.telegramModelDescriptor(generation, modelId) : void 0;
+          if (!generation || !descriptor) return { handled: true, answerText: "Model metadata is no longer available.", alert: true };
+          const message2 = await this.deleteTelegramGenerationModelWeights(descriptor);
+          await this.sendMessageHTML(chatId, convertMarkdownToTelegramHTML(message2));
+          return { handled: true, answerText: "Delete complete." };
+        }
+        return { handled: false };
+      }
+      async deleteTelegramGenerationModelWeights(model) {
+        if (model.backend === "ollama" || model.id.startsWith("x/")) {
+          const base3 = String(this.agentConfig?.backendUrl || "http://localhost:11434").replace(/\/v1\/?$/, "").replace(/\/$/, "");
+          const resp = await fetch(`${base3}/api/delete`, {
+            method: "DELETE",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: model.id }),
+            signal: AbortSignal.timeout(3e4)
+          }).catch((err) => {
+            throw new Error(`Ollama delete failed: ${err instanceof Error ? err.message : String(err)}`);
+          });
+          if (resp.status === 404) return `No Ollama weights found for ${model.id}.`;
+          if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            throw new Error(`Ollama delete failed for ${model.id}: HTTP ${resp.status}${text ? ` - ${text.slice(0, 300)}` : ""}`);
+          }
+          return `Deleted Ollama weights for ${model.id}.`;
+        }
+        const results = model.dependencies.map((repo) => deleteCachedModel(repo));
+        const freed = results.reduce((sum, item) => sum + item.bytesFreed, 0);
+        const lines = results.map((item) => `- ${item.repo}: ${item.bytesFreed > 0 ? formatModelBytes(item.bytesFreed) : "not cached"}`);
+        return [`Deleted cached model weights for ${model.label}.`, `Freed: ${formatModelBytes(freed)}`, ...lines].join("\n");
+      }
+      telegramCreativeRootForChat(chatId) {
+        return telegramCreativeWorkspaceRoot(this.repoRoot || process.cwd(), chatId);
+      }
+      buildTelegramGenerationTool(root, model) {
+        if (model.generation === "image") {
+          return {
+            tool: new ImageGenerateTool(root, this.agentConfig?.backendUrl, {
+              model: model.id,
+              backend: model.backend
+            }),
+            args: { model: model.id, backend: model.backend }
+          };
+        }
+        if (model.generation === "sound" || model.generation === "music") {
+          return {
+            tool: new AudioGenerateTool(root, model.generation === "music" ? { musicModel: model.id, musicBackend: model.backend } : { soundModel: model.id, soundBackend: model.backend }),
+            args: { kind: model.generation, model: model.id, backend: model.backend }
+          };
+        }
+        if (model.generation === "video") {
+          return {
+            tool: new VideoGenerateTool(root, {
+              model: model.id,
+              backend: model.backend,
+              defaultKind: "t2v"
+            }),
+            args: { model: model.id, backend: model.backend, kind: "t2v" }
+          };
+        }
+        const kind = model.generation === "cad" ? "cad" : "3d";
+        return {
+          tool: new ModelGenerateTool(root, kind === "cad" ? { cadModel: model.id, cadBackend: model.backend } : { model3dModel: model.id, model3dBackend: model.backend }),
+          args: { kind, model: model.id, backend: model.backend }
+        };
+      }
+      attachTelegramGenerationProgress(chatId, messageId, heading, model, tool) {
+        if (!messageId) return;
+        const setProgress = tool.setProgressCallback;
+        if (typeof setProgress !== "function") return;
+        let lastEdit = 0;
+        setProgress.call(tool, (event) => {
+          const now = Date.now();
+          if (now - lastEdit < 2500 && event.percent === void 0) return;
+          lastEdit = now;
+          const percent = typeof event.percent === "number" ? ` ${Math.round(event.percent)}%` : "";
+          const elapsed = typeof event.elapsedMs === "number" ? `
+Elapsed: ${Math.round(event.elapsedMs / 1e3)}s` : "";
+          const html = [
+            `<b>${escapeTelegramHTML(heading)}</b>`,
+            `Model: <code>${escapeTelegramHTML(model.id)}</code>`,
+            `Stage: <code>${escapeTelegramHTML(String(event.stage || "process"))}</code>${percent}`,
+            escapeTelegramHTML(String(event.message || "")),
+            elapsed
+          ].filter(Boolean).join("\n");
+          void this.editLiveMessage(chatId, messageId, html).catch(() => false);
+        });
+      }
+      async runTelegramGenerationPrewarm(chatId, model) {
+        const root = this.telegramCreativeRootForChat(chatId);
+        const { tool, args } = this.buildTelegramGenerationTool(root, model);
+        const liveId = await this.sendMessageHTML(
+          chatId,
+          `<b>Loading ${escapeTelegramHTML(model.label)}</b>
+Model: <code>${escapeTelegramHTML(model.id)}</code>`
+        );
+        this.attachTelegramGenerationProgress(chatId, liveId, `Loading ${model.label}`, model, tool);
+        const action = model.generation === "model3d" || model.generation === "cad" ? "check" : "prewarm";
+        const result = await tool.execute({ ...args, action });
+        const html = result.success ? `<b>Model load/check complete</b>
+<blockquote expandable>${escapeTelegramHTML(result.output || "Ready.")}</blockquote>` : `<b>Model load/check failed</b>
+<blockquote expandable>${escapeTelegramHTML(result.error || result.output || "Unknown failure.")}</blockquote>`;
+        if (liveId) await this.editLiveMessage(chatId, liveId, html).catch(() => false);
+        else await this.sendMessageHTML(chatId, html);
+      }
+      async expandTelegramGenerationPrompt(intent, prompt, modelId = intent.model, backend = intent.backend ?? "auto") {
+        const raw = prompt.trim();
+        if (!raw || !this.agentConfig) return raw;
+        try {
+          const llm = new OllamaAgenticBackend(
+            this.agentConfig.backendUrl,
+            this.agentConfig.model,
+            this.agentConfig.apiKey
+          );
+          const system = [
+            "You rewrite a user's short media-generation request into a stronger production prompt.",
+            "Preserve the user's subject and intent. Add concrete sensory, compositional, timing, material, and style details only where useful.",
+            "Do not add policy commentary, labels, quotes, or explanation. Output only the expanded prompt."
+          ].join(" ");
+          const user = [
+            `Generation type: ${intent.generation}`,
+            `Target model: ${modelId}`,
+            `Backend: ${backend}`,
+            "",
+            "User prompt:",
+            raw
+          ].join("\n");
+          const result = await this.telegramObservableInference(
+            llm,
+            telegramThinkSuppressedRequest({
+              messages: [
+                { role: "system", content: system },
+                { role: "user", content: user }
+              ],
+              tools: [],
+              temperature: 0.4,
+              maxTokens: 700,
+              timeoutMs: Math.min(Math.max(this.agentConfig.timeoutMs ?? 3e4, 5e3), 3e4)
+            }),
+            "chat-fast-path",
+            `generation-prompt:${String(intent.chatId)}:${intent.fromUserId}`
+          );
+          const text = result.choices[0]?.message?.content;
+          if (typeof text !== "string") return raw;
+          const cleaned = text.replace(/^["'`]+|["'`]+$/g, "").replace(/^(?:expanded prompt|prompt|output)\s*:\s*/i, "").trim();
+          return cleaned || raw;
+        } catch {
+          return raw;
+        }
+      }
+      installTelegramPromptExpander(tool, intent) {
+        const setExpander = tool.setPromptExpander;
+        if (typeof setExpander !== "function") return;
+        setExpander.call(tool, async (ctx3) => this.expandTelegramGenerationPrompt(intent, ctx3.originalPrompt, ctx3.model, ctx3.backend));
+      }
+      async sendTelegramGenerationArtifacts(msg, root, result) {
+        const paths = /* @__PURE__ */ new Set();
+        for (const path12 of result.mutatedFiles ?? []) {
+          if (typeof path12 === "string" && path12.trim()) paths.add(resolve53(path12));
+        }
+        for (const path12 of collectGeneratedArtifactPathsFromText(result.output || "", root)) {
+          paths.add(resolve53(path12));
+        }
+        let sent = 0;
+        for (const path12 of paths) {
+          if (!existsSync127(path12) || !statSync46(path12).isFile()) continue;
+          const kind = classifyMedia(path12) ?? "document";
+          const messageId = await this.sendMediaReference(msg.chatId, {
+            original: path12,
+            value: path12,
+            kind,
+            source: "file",
+            audioAsVoice: kind === "voice"
+          }, {
+            replyToMessageId: msg.messageId
+          }).catch(() => null);
+          if (messageId !== null) sent++;
+        }
+        return sent;
+      }
+      async executeTelegramGenerationPrompt(msg, intent) {
+        const descriptor = this.telegramModelDescriptor(intent.generation, intent.model) ?? {
+          generation: intent.generation,
+          id: intent.model,
+          label: intent.label,
+          backend: intent.backend || "auto",
+          category: "",
+          sizeClass: "",
+          quality: "",
+          note: "",
+          cachedBytes: 0,
+          dependencies: [intent.model]
+        };
+        const root = this.telegramCreativeRootForChat(msg.chatId);
+        const { tool, args } = this.buildTelegramGenerationTool(root, descriptor);
+        this.installTelegramPromptExpander(tool, intent);
+        const liveId = await this.sendMessageHTML(
+          msg.chatId,
+          [
+            `<b>${escapeTelegramHTML(this.telegramGenerationLabel(intent.generation))} generation</b>`,
+            `Model: <code>${escapeTelegramHTML(intent.model)}</code>`,
+            "Expanding prompt and preparing runtime..."
+          ].join("\n"),
+          msg.messageId
+        );
+        this.attachTelegramGenerationProgress(msg.chatId, liveId, `${this.telegramGenerationLabel(intent.generation)} generation`, descriptor, tool);
+        const rawPrompt = msg.text.trim();
+        const prompt = intent.generation === "image" || intent.generation === "video" ? rawPrompt : await this.expandTelegramGenerationPrompt(intent, rawPrompt, descriptor.id, descriptor.backend);
+        const result = await tool.execute({
+          ...args,
+          action: "generate",
+          prompt,
+          expand_prompt: true
+        });
+        const artifactCount = result.success ? await this.sendTelegramGenerationArtifacts(msg, root, result) : 0;
+        const summary = result.success ? [
+          `<b>Generation complete</b>`,
+          artifactCount > 0 ? `Sent ${artifactCount} artifact${artifactCount === 1 ? "" : "s"}.` : "No artifact file was detected in the tool result.",
+          `<blockquote expandable>${escapeTelegramHTML(result.output || result.llmContent || "Done.")}</blockquote>`
+        ].join("\n") : [
+          `<b>Generation failed</b>`,
+          `<blockquote expandable>${escapeTelegramHTML(result.error || result.output || "Unknown failure.")}</blockquote>`
+        ].join("\n");
+        if (liveId) await this.editLiveMessage(msg.chatId, liveId, summary).catch(() => false);
+        else await this.sendMessageHTML(msg.chatId, summary, msg.messageId);
+      }
+      async maybeHandleTelegramGenerationPrompt(msg) {
+        this.pruneTelegramGenerationPromptIntents();
+        const key = this.telegramGenerationIntentKey(msg.chatId, msg.fromUserId);
+        const intent = this.telegramGenerationPromptIntents.get(key);
+        if (!intent) return false;
+        if (msg.text.trim().toLowerCase() === "/cancel") {
+          this.telegramGenerationPromptIntents.delete(key);
+          await this.replyToTelegramMessage(msg, "Pending generation cleared.");
+          return true;
+        }
+        if (msg.text.trim().startsWith("/")) return false;
+        this.telegramGenerationPromptIntents.delete(key);
+        await this.executeTelegramGenerationPrompt(msg, intent);
+        return true;
+      }
+      telegramSlashGenerationKind(name10) {
+        if (name10 === "image") return "image";
+        if (name10 === "sound") return "sound";
+        if (name10 === "music") return "music";
+        if (name10 === "video") return "video";
+        return null;
+      }
+      async replyWithTelegramGenerationSetup(msg, generation) {
+        const root = this.telegramCreativeRootForChat(msg.chatId);
+        const settings = resolveSettings(this.repoRoot || process.cwd());
+        let tool;
+        let args;
+        if (generation === "image") {
+          tool = new ImageGenerateTool(root, this.agentConfig?.backendUrl, this.imageGenerationDefaultsForRepo(this.repoRoot || process.cwd()));
+          args = { action: "setup", model: settings.imageModel, backend: settings.imageBackend };
+        } else if (generation === "sound" || generation === "music") {
+          tool = new AudioGenerateTool(root, this.audioGenerationDefaultsForRepo(this.repoRoot || process.cwd()));
+          args = {
+            action: "setup",
+            kind: generation,
+            model: generation === "music" ? settings.musicModel : settings.soundModel,
+            backend: generation === "music" ? settings.musicBackend : settings.soundBackend
+          };
+        } else if (generation === "video") {
+          tool = new VideoGenerateTool(root, this.videoGenerationDefaultsForRepo(this.repoRoot || process.cwd()));
+          args = { action: "setup", model: settings.videoModel, backend: settings.videoBackend };
+        } else {
+          tool = new ModelGenerateTool(root, this.modelGenerationDefaultsForRepo(this.repoRoot || process.cwd()));
+          args = { action: "list_models", kind: generation === "cad" ? "cad" : "3d" };
+        }
+        const result = await tool.execute(args);
+        const html = result.success ? `<b>${escapeTelegramHTML(this.telegramGenerationLabel(generation))} setup</b>
+<blockquote expandable>${escapeTelegramHTML(result.output || "No setup output.")}</blockquote>` : `<b>${escapeTelegramHTML(this.telegramGenerationLabel(generation))} setup failed</b>
+<blockquote expandable>${escapeTelegramHTML(result.error || result.output || "Unknown failure.")}</blockquote>`;
+        await this.replyToTelegramMessage(msg, html, { html: true });
+      }
+      async handleTelegramGenerationSlashCommand(msg, isAdmin, normalizedCommandText) {
+        const trimmed = normalizedCommandText.trim();
+        if (!trimmed.startsWith("/")) return false;
+        const [rawName = "", rawSub = ""] = trimmed.split(/\s+/);
+        const name10 = rawName.slice(1).split("@")[0]?.toLowerCase() ?? "";
+        const sub = rawSub.toLowerCase();
+        if (name10 === "models") {
+          if (!sub) {
+            await this.replyWithTelegramCommandMenu(msg, isAdmin, "generative", "models");
+            return true;
+          }
+          if (sub === "3d" || sub === "cad") {
+            await this.replyWithTelegramModelBrowser(msg, isAdmin, sub === "cad" ? "cad" : "model3d");
+            return true;
+          }
+          return false;
+        }
+        const generation = this.telegramSlashGenerationKind(name10);
+        if (!generation) return false;
+        if (!sub) {
+          await this.replyWithTelegramCommandMenu(msg, isAdmin, "generative", name10);
+          return true;
+        }
+        if (sub === "list" || sub === "models" || sub === "menu") {
+          await this.replyWithTelegramModelBrowser(msg, isAdmin, generation);
+          return true;
+        }
+        if (sub === "setup") {
+          if (!isAdmin) {
+            await this.replyToTelegramMessage(msg, "Generation setup requires Telegram admin authentication.");
+            return true;
+          }
+          await this.replyWithTelegramGenerationSetup(msg, generation);
+          return true;
+        }
+        return false;
+      }
       collectSessionMetricsSnapshot() {
         if (this._metricsProvider) {
           try {
@@ -643619,6 +644345,9 @@ ${summary}` : ""
           return;
         }
         const isAdmin = this.isAdminUser(msg);
+        if (await this.maybeHandleTelegramGenerationPrompt(msg)) {
+          return;
+        }
         if (msg.text.trim().startsWith("/") && this.isTelegramCommandsMenuCommand(normalizedCommandText)) {
           await this.replyWithTelegramCommandMenu(msg, isAdmin, "commands");
           return;
@@ -643632,6 +644361,9 @@ ${summary}` : ""
           return;
         }
         const telegramSlash = this.telegramSlashName(normalizedCommandText);
+        if (msg.text.trim().startsWith("/") && await this.handleTelegramGenerationSlashCommand(msg, isAdmin, normalizedCommandText)) {
+          return;
+        }
         if (msg.text.trim().startsWith("/") && TELEGRAM_REFLECTION_SLASH_COMMANDS.has(telegramSlash)) {
           await this.handleTelegramReflectionSlash(msg, normalizedCommandText);
           return;
@@ -646495,6 +647227,15 @@ Scoped workspace: ${scopedRoot}`,
               });
               return;
             }
+            if (result.item?.action && result.item.action.type !== "command") {
+              const actionResult = await this.handleTelegramCommandMenuAction(callback, menuState, result.item.action);
+              if (actionResult.handled) {
+                if (actionResult.answered) answered = true;
+                if (actionResult.answerText) answerText2 = actionResult.answerText;
+                if (actionResult.alert) alert2 = true;
+                return;
+              }
+            }
             if (result.command) {
               if (!this.commandHandler) {
                 answerText2 = "No command handler is available.";

package/npm-shrinkwrap.json

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

package/package.json

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