omnius 1.0.223 → 1.0.224

package/dist/index.js

@@ -585609,6 +585609,10 @@ var init_command_registry = __esm({
       ["/telegram enable", "Re-enable Telegram long polling"],
       ["/telegram mode auto|chat|action", "Set Telegram interaction routing: auto, fast chat, or action sub-agent"],
       ["/telegram subagents <1-5>", "Set global Telegram work-slot limit across all chats/groups"],
+      ["/telegram model", "Pick the Telegram-isolated model (model list from the Telegram endpoint)"],
+      ["/telegram model <name|reset>", "Set or clear the Telegram-isolated model (separate from main agent)"],
+      ["/telegram endpoint", "Pick the Telegram-isolated backend endpoint (same menu as /endpoint, bot-scoped)"],
+      ["/telegram endpoint <url|reset> [--auth <t>]", "Set or clear the Telegram-isolated endpoint"],
       ["/telegram auth", "Show a TUI-only one-time code for Telegram admin authentication"],
       ["/telegram auth cancel", "Cancel the pending Telegram admin authentication code"],
       ["/telegram bot <username> <text>", "Send a Bot API bot-to-bot message by @username"],
@@ -611568,6 +611572,298 @@ var init_sponsor_wizard = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-inference.ts
+var telegram_inference_exports = {};
+__export(telegram_inference_exports, {
+  handleTelegramEndpoint: () => handleTelegramEndpoint,
+  showTelegramModelPicker: () => showTelegramModelPicker
+});
+function effectiveConfig(ctx3) {
+  return ctx3.telegramGetEffectiveConfig?.();
+}
+async function showTelegramModelPicker(arg, ctx3, local = false) {
+  const trimmed = arg.trim();
+  if (/^(reset|main|default|clear|off)$/i.test(trimmed)) {
+    ctx3.telegramApplyInference?.({ model: "" });
+    ctx3.telegramSaveInference?.({ model: null, local });
+    renderInfo("Telegram model override cleared — using the main agent model.");
+    return;
+  }
+  const config = effectiveConfig(ctx3);
+  if (!config) {
+    renderError("Telegram inference context unavailable.");
+    return;
+  }
+  if (trimmed) {
+    await switchTelegramModel(trimmed, config, ctx3, local);
+    return;
+  }
+  renderInfo(`Loading models from Telegram endpoint ${c3.dim(config.backendUrl)}...`);
+  try {
+    const fetchPromise = fetchModels(config.backendUrl, config.apiKey);
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(
+        () => reject(
+          new Error(
+            `Timed out fetching models from ${config.backendUrl} (10s). The Telegram endpoint may be down. Use /telegram endpoint to switch.`
+          )
+        ),
+        1e4
+      )
+    );
+    const models = await Promise.race([fetchPromise, timeoutPromise]);
+    if (models.length === 0) {
+      renderWarning("No models found on the Telegram endpoint.");
+      return;
+    }
+    const items = [];
+    const override = ctx3.telegramGetInferenceOverride?.() ?? {};
+    if (!override.model) {
+      items.push({
+        key: "__use_main__",
+        label: `${c3.cyan("↺")} Use main agent model`,
+        detail: `Currently inheriting ${c3.dim(config.model)}`
+      });
+    } else {
+      items.push({
+        key: "__use_main__",
+        label: `${c3.cyan("↺")} Use main agent model`,
+        detail: "Clear the Telegram model override"
+      });
+    }
+    for (const m2 of models) {
+      const ctxLabel = m2.contextLength ? formatContextLength(m2.contextLength) : "";
+      const capStr = m2.caps ? formatCaps(m2.caps) : "";
+      items.push({
+        key: m2.name,
+        label: m2.name,
+        detail: [m2.parameterSize, ctxLabel, capStr, m2.modified].filter(Boolean).join("  ")
+      });
+    }
+    const result = await tuiSelect({
+      items,
+      activeKey: override.model ? stripLatest(override.model) : "__use_main__",
+      title: "Select Telegram Model",
+      rl: ctx3.rl,
+      skipKeys: [],
+      availableRows: ctx3.availableContentRows?.()
+    });
+    if (!result.confirmed || !result.key) {
+      renderInfo("Telegram model selection cancelled.");
+      return;
+    }
+    if (result.key === "__use_main__") {
+      ctx3.telegramApplyInference?.({ model: "" });
+      ctx3.telegramSaveInference?.({ model: null, local });
+      renderInfo("Telegram model override cleared — using the main agent model.");
+      return;
+    }
+    await switchTelegramModel(stripLatest(result.key), config, ctx3, local);
+  } catch (err) {
+    renderError(`Failed to fetch Telegram models: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function switchTelegramModel(query, config, ctx3, local) {
+  let finalModel = query;
+  try {
+    const models = await fetchModels(config.backendUrl, config.apiKey);
+    const match = findModel(models, query);
+    if (match) {
+      finalModel = match.name;
+    } else {
+      renderWarning(`Model "${query}" not found on the Telegram endpoint — setting it anyway.`);
+      renderInfo("It may be pulled/available later, or pull it on that backend first.");
+    }
+  } catch {
+    renderWarning("Could not verify the model against the Telegram endpoint — setting it anyway.");
+  }
+  ctx3.telegramApplyInference?.({ model: finalModel });
+  ctx3.telegramSaveInference?.({ model: finalModel, local });
+  recordUsage("model", finalModel, {
+    repoRoot: local ? ctx3.repoRoot : void 0,
+    local,
+    meta: { endpoint: config.backendUrl }
+  });
+  renderInfo(
+    `Telegram model set to ${c3.bold(finalModel)}${local ? " (project)" : ""} — isolated from the main agent.`
+  );
+}
+async function handleTelegramEndpoint(arg, ctx3, local = false) {
+  const trimmed = arg.trim();
+  if (/^(reset|main|default|clear|stop|off)$/i.test(trimmed)) {
+    ctx3.telegramApplyInference?.({ backendUrl: "", backendType: void 0, apiKey: "" });
+    ctx3.telegramSaveInference?.({ backendUrl: null, backendType: null, apiKey: null, local });
+    renderInfo("Telegram endpoint override cleared — using the main agent endpoint.");
+    return;
+  }
+  if (!trimmed) {
+    await showTelegramEndpointMenu(ctx3, local);
+    return;
+  }
+  await setTelegramEndpoint(trimmed, ctx3, local);
+}
+async function showTelegramEndpointMenu(ctx3, local) {
+  const config = effectiveConfig(ctx3);
+  if (!config) {
+    renderError("Telegram inference context unavailable.");
+    return;
+  }
+  const override = ctx3.telegramGetInferenceOverride?.() ?? {};
+  const history = loadUsageHistory("endpoint", ctx3.repoRoot);
+  const items = [
+    {
+      key: "__use_main__",
+      label: `${c3.cyan("↺")} Use main agent endpoint`,
+      detail: override.backendUrl ? "Clear the Telegram endpoint override" : "Currently inheriting the main endpoint"
+    }
+  ];
+  for (const h of history) {
+    const provider = h.meta?.provider ?? detectProvider(h.value).label;
+    const uses = h.localUses > 0 ? `${h.useCount} uses (${h.localUses} local)` : `${h.useCount} uses`;
+    const auth = h.meta?.authHint ? `  Auth: ${h.meta.authHint}` : "";
+    items.push({ key: h.value, label: h.value, detail: `${provider}  ${uses}${auth}` });
+  }
+  items.push({
+    key: "__add__",
+    label: `${c3.green("+")} Add endpoint`,
+    detail: "Type a URL to add a new Telegram endpoint"
+  });
+  let addedEndpoint = null;
+  const result = await tuiSelect({
+    items,
+    activeKey: override.backendUrl ? override.backendUrl : "__use_main__",
+    title: "Select Telegram Endpoint",
+    rl: ctx3.rl,
+    availableRows: ctx3.availableContentRows?.(),
+    onDelete: (item, done) => {
+      if (item.key.startsWith("__")) {
+        done(false);
+        return;
+      }
+      deleteUsageRecord("endpoint", item.key, ctx3.repoRoot);
+      done(true);
+    },
+    onEnter: (item, { getInput, resolve: resolve64 }) => {
+      if (item.key === "__add__") {
+        getInput("URL", "http://").then(async (url) => {
+          if (!url || !url.trim()) return;
+          const authKey = await getInput("Auth key (optional)", "");
+          const authArg = authKey?.trim() ? ` --auth ${authKey.trim()}` : "";
+          addedEndpoint = `${url.trim()}${authArg}`;
+          resolve64({ confirmed: true, key: "__add__", index: -1 });
+        });
+        return true;
+      }
+      return false;
+    }
+  });
+  if (!result.confirmed || !result.key) {
+    renderInfo("Telegram endpoint selection cancelled.");
+    return;
+  }
+  if (result.key === "__use_main__") {
+    ctx3.telegramApplyInference?.({ backendUrl: "", backendType: void 0, apiKey: "" });
+    ctx3.telegramSaveInference?.({ backendUrl: null, backendType: null, apiKey: null, local });
+    renderInfo("Telegram endpoint override cleared — using the main agent endpoint.");
+    return;
+  }
+  if (result.key === "__add__" && addedEndpoint) {
+    await setTelegramEndpoint(addedEndpoint, ctx3, local);
+    return;
+  }
+  const record = history.find((h) => h.value === result.key);
+  const savedAuth = record?.meta?.authKey;
+  await setTelegramEndpoint(savedAuth ? `${result.key} --auth ${savedAuth}` : result.key, ctx3, local);
+}
+async function setTelegramEndpoint(arg, ctx3, local) {
+  const normalizedArg = arg.replace(/—/g, "--").replace(/–/g, "--");
+  const parts = normalizedArg.split(/\s+/);
+  const url = parts[0];
+  let apiKey;
+  const authIdx = parts.indexOf("--auth") !== -1 ? parts.indexOf("--auth") : parts.indexOf("-auth");
+  if (authIdx !== -1 && parts[authIdx + 1]) apiKey = parts[authIdx + 1];
+  try {
+    new URL(url);
+  } catch {
+    renderError(`Invalid URL: "${url}"`);
+    return;
+  }
+  const normalizedUrl = normalizeBaseUrl(url);
+  const provider = detectProvider(url);
+  const backendType = provider.id === "ollama" ? "ollama" : "vllm";
+  process.stdout.write(`
+  ${c3.dim("Detected:")} ${c3.bold(provider.label)}
+`);
+  process.stdout.write(`  ${c3.dim("Testing connection...")} `);
+  try {
+    const headers = {};
+    if (apiKey) {
+      if (provider.id === "anthropic") {
+        headers["x-api-key"] = apiKey;
+        headers["anthropic-version"] = "2023-06-01";
+      } else {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+    }
+    const resp = await fetch(`${normalizedUrl}${provider.modelsPath}`, {
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    process.stdout.write(`${c3.green("✔")} Connected
+`);
+  } catch (err) {
+    process.stdout.write(`${c3.yellow("⚠")} Could not verify
+`);
+    renderWarning(`Endpoint may not be reachable: ${err instanceof Error ? err.message : String(err)}`);
+    renderInfo("Setting the Telegram endpoint anyway — it may come online later.");
+  }
+  ctx3.telegramApplyInference?.({ backendUrl: normalizedUrl, backendType, apiKey: apiKey ?? "" });
+  ctx3.telegramSaveInference?.({
+    backendUrl: normalizedUrl,
+    backendType,
+    apiKey: apiKey ?? "",
+    local
+  });
+  recordUsage("endpoint", normalizedUrl, {
+    repoRoot: local ? ctx3.repoRoot : void 0,
+    local,
+    meta: {
+      provider: provider.label,
+      backendType,
+      ...apiKey ? { authHint: apiKey.slice(0, 4) + "...", authKey: apiKey } : {}
+    }
+  });
+  process.stdout.write(`
+  ${c3.green("✔")} Telegram endpoint updated${local ? " (project)" : ""}:
+`);
+  process.stdout.write(`    ${c3.cyan("Provider".padEnd(12))} ${provider.label}
+`);
+  process.stdout.write(`    ${c3.cyan("URL".padEnd(12))} ${normalizedUrl}
+`);
+  process.stdout.write(`    ${c3.cyan("Type".padEnd(12))} ${backendType}
+`);
+  process.stdout.write(
+    `    ${c3.cyan("Auth".padEnd(12))} ${apiKey ? `Bearer ${apiKey.slice(0, 4)}...` : "none"}
+`
+  );
+  process.stdout.write(
+    `  ${c3.dim("Isolated from the main agent. Set the model with /telegram model.")}
+
+`
+  );
+}
+var init_telegram_inference = __esm({
+  "packages/cli/src/tui/telegram-inference.ts"() {
+    "use strict";
+    init_render();
+    init_tui_select();
+    init_model_picker();
+    init_omnius_directory();
+    init_dist();
+  }
+});
+
 // packages/cli/src/tui/image-ascii-preview.ts
 var image_ascii_preview_exports = {};
 __export(image_ascii_preview_exports, {
@@ -621652,6 +621948,26 @@ sleep 1
         );
         return "handled";
       }
+      if (parts[0] === "model" || parts[0] === "models") {
+        const hasGlobalFlagModel = parts.includes("--global");
+        const projectRootTgModel = ctx3.repoRoot || process.cwd();
+        const projectHasOmniusTgModel = existsSync117(join129(projectRootTgModel, ".omnius"));
+        const wantsLocalTgModel = hasGlobalFlagModel ? false : isLocal || projectHasOmniusTgModel;
+        const modelArg = parts.slice(1).filter((p2) => p2 !== "--global").join(" ");
+        const { showTelegramModelPicker: showTelegramModelPicker2 } = await Promise.resolve().then(() => (init_telegram_inference(), telegram_inference_exports));
+        await showTelegramModelPicker2(modelArg, ctx3, wantsLocalTgModel);
+        return "handled";
+      }
+      if (parts[0] === "endpoint" || parts[0] === "ep") {
+        const hasGlobalFlagEp = parts.includes("--global");
+        const projectRootTgEp = ctx3.repoRoot || process.cwd();
+        const projectHasOmniusTgEp = existsSync117(join129(projectRootTgEp, ".omnius"));
+        const wantsLocalTgEp = hasGlobalFlagEp ? false : isLocal || projectHasOmniusTgEp;
+        const epArg = parts.slice(1).filter((p2) => p2 !== "--global").join(" ");
+        const { handleTelegramEndpoint: handleTelegramEndpoint2 } = await Promise.resolve().then(() => (init_telegram_inference(), telegram_inference_exports));
+        await handleTelegramEndpoint2(epArg, ctx3, wantsLocalTgEp);
+        return "handled";
+      }
       if (parts[0] === "auth" || parts[0] === "authenticate") {
         if (parts[1] === "cancel") {
           const cancelled = ctx3.telegramCancelAdminAuth?.() ?? false;
@@ -622035,6 +622351,8 @@ sleep 1
       renderInfo("  /telegram status          Show status");
       renderInfo("  /telegram mode auto|chat|action  Set interaction routing profile");
       renderInfo("  /telegram subagents <1-5>  Set global Telegram work-slot limit");
+      renderInfo("  /telegram model [name|reset]  Pick the Telegram-isolated model (separate from main agent)");
+      renderInfo("  /telegram endpoint [url|reset] [--auth <key>]  Pick the Telegram-isolated backend endpoint");
       renderInfo("  /telegram auth            Show one-time admin auth code");
       renderInfo("  /telegram auth cancel     Cancel pending admin auth code");
       renderInfo("  /telegram bot <username> <text>  Send bot-to-bot message");
@@ -644624,6 +644942,7 @@ Telegram link integrity contract:
         this.telegramSqlitePath = resolve55(repoRoot || ".", ".omnius", "telegram.sqlite");
         this.telegramToolButtonDir = resolve55(repoRoot || ".", ".omnius", "telegram-tool-buttons");
         this.state.maxSubAgents = normalizeTelegramSubAgentLimit(resolveSettings(repoRoot || ".").telegramSubAgents);
+        this.telegramBaseInferenceConfig = agentConfig ? { ...agentConfig } : void 0;
         this.hydrateTelegramCommandMap(buildTelegramBotCommands({ scope: "admin" }));
       }
       botToken;
@@ -644636,6 +644955,15 @@ Telegram link integrity contract:
       pollFatalNotified = false;
       lastUpdateId = 0;
       telegramRouterModelCache = null;
+      /**
+       * Snapshot of the main agent inference config captured at construction. The
+       * effective `agentConfig` is this base overlaid with the Telegram-isolated
+       * inference override (see {@link applyInferenceOverride}). Keeping the base
+       * separate lets a later override that clears a field fall back to the main
+       * value rather than to whatever the previous override left behind.
+       */
+      telegramBaseInferenceConfig;
+      telegramInferenceOverride = {};
       state = {
         active: false,
         botUserId: void 0,
@@ -644838,6 +645166,45 @@ Telegram link integrity contract:
       channelReflectionState = /* @__PURE__ */ new Map();
       /** Public/group Telegram per-user quota buckets for expensive tools. */
       telegramPublicQuotaBuckets = /* @__PURE__ */ new Map();
+      /**
+       * Apply a Telegram-isolated inference override on top of the main agent
+       * config. The router, fast-chat completions, and action sub-agents spawned by
+       * the bridge all read `this.agentConfig`, so overlaying here isolates the
+       * Telegram bot's model/endpoint from the main TUI agent.
+       *
+       * Pass an empty string (or undefined) for a field to clear that override and
+       * fall back to the main agent value. Returns the resulting effective config.
+       */
+      applyInferenceOverride(override) {
+        const next = { ...this.telegramInferenceOverride };
+        for (const key of ["model", "backendUrl", "backendType", "apiKey"]) {
+          if (key in override) {
+            const value2 = override[key];
+            if (value2 === void 0 || value2 === "") delete next[key];
+            else next[key] = value2;
+          }
+        }
+        this.telegramInferenceOverride = next;
+        const base3 = this.telegramBaseInferenceConfig ?? this.agentConfig;
+        if (!base3) return void 0;
+        const effective = {
+          ...base3,
+          ...next.model ? { model: next.model } : {},
+          ...next.backendUrl ? { backendUrl: next.backendUrl } : {},
+          ...next.backendType ? { backendType: next.backendType } : {},
+          // apiKey can legitimately be empty (no-auth endpoint). When the endpoint
+          // is overridden we always take the override's apiKey (possibly "") so we
+          // never leak the main endpoint's key to a different backend.
+          ...next.backendUrl !== void 0 ? { apiKey: next.apiKey ?? "" } : {}
+        };
+        this.agentConfig = effective;
+        this.telegramRouterModelCache = null;
+        return effective;
+      }
+      /** The Telegram-isolated inference override currently in effect (if any). */
+      getInferenceOverride() {
+        return { ...this.telegramInferenceOverride };
+      }
       /** Set admin user ID filter */
       setAdmin(userId) {
         this.adminUserId = userId;
@@ -688380,9 +688747,39 @@ Log: ${nexusLogPath}`)
       admin: nonEmptyTelegramSetting(source.telegramAdmin),
       mode,
       subAgents,
+      // Telegram-isolated inference override (falls back to main config when unset).
+      model: nonEmptyTelegramSetting(source.telegramModel),
+      backendUrl: nonEmptyTelegramSetting(source.telegramBackendUrl),
+      backendType: nonEmptyTelegramSetting(source.telegramBackendType),
+      apiKey: typeof source.telegramApiKey === "string" ? source.telegramApiKey : void 0,
       keyScope: scope
     };
   };
+  const telegramInferenceOverrideFromSettings = () => {
+    const project = telegramSettingsForScope("project");
+    const global2 = telegramSettingsForScope("global");
+    const model = project.model ?? global2.model;
+    const backendUrl2 = project.backendUrl ?? global2.backendUrl;
+    const backendTypeRaw = project.backendType ?? global2.backendType;
+    const apiKey = project.backendUrl ? project.apiKey : global2.backendUrl ? global2.apiKey : void 0;
+    const backendType = backendTypeRaw === "ollama" || backendTypeRaw === "vllm" || backendTypeRaw === "fake" || backendTypeRaw === "nexus" ? backendTypeRaw : void 0;
+    return {
+      ...model ? { model } : {},
+      ...backendUrl2 ? { backendUrl: backendUrl2 } : {},
+      ...backendType ? { backendType } : {},
+      ...backendUrl2 ? { apiKey: apiKey ?? "" } : {}
+    };
+  };
+  const telegramEffectiveConfig = () => {
+    const override = telegramInferenceOverrideFromSettings();
+    return {
+      ...currentConfig,
+      ...override.model ? { model: override.model } : {},
+      ...override.backendUrl ? { backendUrl: override.backendUrl } : {},
+      ...override.backendType ? { backendType: override.backendType } : {},
+      ...override.backendUrl !== void 0 ? { apiKey: override.apiKey ?? "" } : {}
+    };
+  };
   const commandCtx = {
     get config() {
       return currentConfig;
@@ -689018,6 +689415,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       telegramBridge.setInteractionMode(savedSettings.telegramMode ?? "auto");
       telegramBridge.setSubAgentLimit(telegramSettingsForScope(scope).subAgents ?? 2);
       telegramBridge.setTelegramToolPolicy(savedSettings.telegramToolPolicy);
+      telegramBridge.applyInferenceOverride(telegramInferenceOverrideFromSettings());
       telegramBridge.setMetricsProvider(() => statusBar?.getMetricsSnapshot());
       if (adminId) {
         telegramBridge.setAdmin(adminId);
@@ -689202,12 +689600,28 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (settings.subAgents !== void 0) {
         target.telegramSubAgents = settings.subAgents;
       }
+      if (settings.model !== void 0) {
+        target.telegramModel = settings.model === null ? "" : settings.model;
+      }
+      if (settings.backendUrl !== void 0) {
+        target.telegramBackendUrl = settings.backendUrl === null ? "" : settings.backendUrl;
+      }
+      if (settings.backendType !== void 0) {
+        target.telegramBackendType = settings.backendType === null ? "" : settings.backendType;
+      }
+      if (settings.apiKey !== void 0) {
+        target.telegramApiKey = settings.apiKey === null ? "" : settings.apiKey;
+      }
       const payload = {
         ...settings.key !== void 0 ? { telegramKey: settings.key } : {},
         ...settings.enabled !== void 0 ? { telegramEnabled: settings.enabled } : {},
         ...settings.admin !== void 0 ? { telegramAdmin: settings.admin === null ? "" : settings.admin } : {},
         ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {},
-        ...settings.subAgents !== void 0 ? { telegramSubAgents: settings.subAgents } : {}
+        ...settings.subAgents !== void 0 ? { telegramSubAgents: settings.subAgents } : {},
+        ...settings.model !== void 0 ? { telegramModel: settings.model === null ? "" : settings.model } : {},
+        ...settings.backendUrl !== void 0 ? { telegramBackendUrl: settings.backendUrl === null ? "" : settings.backendUrl } : {},
+        ...settings.backendType !== void 0 ? { telegramBackendType: settings.backendType === null ? "" : settings.backendType } : {},
+        ...settings.apiKey !== void 0 ? { telegramApiKey: settings.apiKey === null ? "" : settings.apiKey } : {}
       };
       if (targetScope === "project") {
         saveProjectSettings(repoRoot, payload);
@@ -689241,6 +689655,18 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       savedSettings.telegramSubAgents = limit;
       return telegramBridge?.setSubAgentLimit(limit) ?? Math.max(1, Math.min(5, Math.floor(limit)));
     },
+    telegramGetEffectiveConfig() {
+      return telegramEffectiveConfig();
+    },
+    telegramGetInferenceOverride() {
+      return telegramInferenceOverrideFromSettings();
+    },
+    telegramApplyInference(override) {
+      telegramBridge?.applyInferenceOverride(override);
+    },
+    telegramSaveInference(override) {
+      commandCtx.saveTelegramSettings?.(override);
+    },
     telegramStatus() {
       const active = telegramBridge?.isActive ?? false;
       const botUser = active ? telegramBridge?.botUsername : void 0;
@@ -689260,6 +689686,22 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         )
       );
       const effectiveTelegramSettings = telegramSettingsForScope(activeTelegramSettingsScope ?? "project");
+      const tgOverride = telegramInferenceOverrideFromSettings();
+      const tgEffective = telegramEffectiveConfig();
+      if (tgOverride.model || tgOverride.backendUrl) {
+        writeContent(() => {
+          renderInfo(
+            `Telegram model: ${tgOverride.model ?? `${tgEffective.model} (inherited)`}` + (tgOverride.model ? " (isolated)" : "")
+          );
+          renderInfo(
+            `Telegram endpoint: ${tgOverride.backendUrl ?? `${tgEffective.backendUrl} (inherited)`}` + (tgOverride.backendUrl ? " (isolated)" : "")
+          );
+        });
+      } else {
+        writeContent(
+          () => renderInfo("Telegram inference: inheriting main agent model/endpoint (set with /telegram model | /telegram endpoint).")
+        );
+      }
       if (effectiveTelegramSettings.enabled === false || process.env["OMNIUS_TELEGRAM_DISABLED"] === "1") {
         writeContent(() => renderInfo("Telegram polling is disabled; auto-start and manual start are blocked."));
       }

package/npm-shrinkwrap.json

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

package/package.json

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