omnius 1.0.223 → 1.0.225

package/dist/index.js

@@ -560040,6 +560040,15 @@ var init_agenticRunner = __esm({
       _fileWritesThisRun = 0;
       _backwardPassCyclesUsed = 0;
       _lastBackwardPassVerdict = null;
+      // REG-54: completion-gate anti-collapse circuit breaker. The no-progress and
+      // completion-provenance gates can hold task_complete indefinitely. When a
+      // collapsed/weak model resubmits the same (or a similar) completion summary,
+      // the gate rejects it every turn and the model re-emits the identical
+      // task_complete forever — a mode-collapse loop. Unlike the backward-pass
+      // critic (REG-47), these gates had no cycle bound. We track consecutive holds
+      // of the same summary and fail open after a small threshold so the run
+      // terminates instead of spinning. Reset whenever a completion is allowed.
+      _completionHoldState = { count: 0, lastKey: "" };
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -564982,6 +564991,52 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           });
           return true;
         };
+        const completionHoldEscapeMax = (() => {
+          const raw = Number(process.env["OMNIUS_COMPLETION_HOLD_MAX"]);
+          return Number.isFinite(raw) && raw >= 1 ? Math.floor(raw) : 3;
+        })();
+        const holdTaskCompleteGates = (args, turn) => {
+          const held = holdNoProgressTaskComplete(args, turn) || holdProvenanceTaskComplete(args, turn);
+          if (!held) {
+            this._completionHoldState.count = 0;
+            this._completionHoldState.lastKey = "";
+            return false;
+          }
+          const key = (extractTaskCompleteSummary(args) || "").trim().slice(0, 200);
+          if (key && key === this._completionHoldState.lastKey) {
+            this._completionHoldState.count += 1;
+          } else {
+            this._completionHoldState.lastKey = key;
+            this._completionHoldState.count = 1;
+          }
+          if (this._completionHoldState.count >= completionHoldEscapeMax) {
+            messages2.push({
+              role: "system",
+              content: `[COMPLETION GATE ESCAPE] task_complete was held ${this._completionHoldState.count} times for the same summary without new progress. The gate feedback above is not being acted on, so completion is now ALLOWED to avoid a stall/mode-collapse loop. If the summary lacks evidence, that limitation stands in the final result.`
+            });
+            this.emit({
+              type: "status",
+              content: `completion gates yielding after ${this._completionHoldState.count} repeated holds to prevent a mode-collapse loop`,
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            this.emit({
+              type: "adversary_reaction",
+              adversary: {
+                class: "guidance",
+                shortText: "Completion gate escape (anti-loop)",
+                confidence: 0.9,
+                details: `Same task_complete summary held ${this._completionHoldState.count}× — failing open to terminate the run.`
+              },
+              turn,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            this._completionHoldState.count = 0;
+            this._completionHoldState.lastKey = "";
+            return false;
+          }
+          return true;
+        };
         const emitBackwardPassAdvisory = (feedback, turn) => {
           messages2.push({
             role: "system",
@@ -568543,7 +568598,7 @@ ${sr.result.output}`;
                         timestamp: (/* @__PURE__ */ new Date()).toISOString()
                       });
                     } else {
-                      if (holdNoProgressTaskComplete(matchTc.arguments, turn) || holdProvenanceTaskComplete(matchTc.arguments, turn)) {
+                      if (holdTaskCompleteGates(matchTc.arguments, turn)) {
                         continue;
                       }
                       const _bp1 = await this._runBackwardPassReview(turn);
@@ -568598,7 +568653,7 @@ ${sr.result.output}`;
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
                         });
                       } else {
-                        if (holdNoProgressTaskComplete(r2.tc.arguments, turn) || holdProvenanceTaskComplete(r2.tc.arguments, turn)) {
+                        if (holdTaskCompleteGates(r2.tc.arguments, turn)) {
                           continue;
                         }
                         const _bp2 = await this._runBackwardPassReview(turn);
@@ -568690,7 +568745,7 @@ ${sr.result.output}`;
                           timestamp: (/* @__PURE__ */ new Date()).toISOString()
                         });
                       } else {
-                        if (holdNoProgressTaskComplete(r2.tc.arguments, turn) || holdProvenanceTaskComplete(r2.tc.arguments, turn)) {
+                        if (holdTaskCompleteGates(r2.tc.arguments, turn)) {
                           continue;
                         }
                         const _bp3 = await this._runBackwardPassReview(turn);
@@ -568911,7 +568966,7 @@ Call task_complete(summary="...") NOW with whatever you have.`
             const adversaryAddedGuidance = this.pendingUserMessages.length > pendingBeforeAdversary;
             if (/task.?complete|all tests pass/i.test(content)) {
               const completionArgs = { summary: content };
-              if (holdNoProgressTaskComplete(completionArgs, turn) || holdProvenanceTaskComplete(completionArgs, turn)) {
+              if (holdTaskCompleteGates(completionArgs, turn)) {
                 continue;
               }
               completed = true;
@@ -569482,7 +569537,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                       timestamp: (/* @__PURE__ */ new Date()).toISOString()
                     });
                   } else {
-                    if (holdNoProgressTaskComplete(tc.arguments, turn) || holdProvenanceTaskComplete(tc.arguments, turn)) {
+                    if (holdTaskCompleteGates(tc.arguments, turn)) {
                       continue;
                     }
                     const _bp4 = await this._runBackwardPassReview(turn);
@@ -569535,7 +569590,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                   });
                 } else {
                   const completionArgs = { summary: content };
-                  if (holdNoProgressTaskComplete(completionArgs, turn) || holdProvenanceTaskComplete(completionArgs, turn)) {
+                  if (holdTaskCompleteGates(completionArgs, turn)) {
                     continue;
                   }
                   completed = true;
@@ -585609,6 +585664,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 +611627,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 +622003,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 +622406,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 +644997,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 +645010,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 +645221,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 +688802,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 +689470,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 +689655,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 +689710,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 +689741,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.225",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.223",
+      "version": "1.0.225",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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