omnius 1.0.113 → 1.0.115

package/dist/index.js

@@ -614455,6 +614455,28 @@ function telegramRouterTimeoutMs(configTimeoutMs, minMs = 12e4, _legacyMaxMs) {
   const configured = Number.isFinite(configTimeoutMs) && (configTimeoutMs ?? 0) > 0 ? configTimeoutMs : 3e5;
   return Math.max(configured, minMs, 12e4);
 }
+function telegramThinkSuppressedRequest(request) {
+  const messages2 = Array.isArray(request.messages) ? request.messages.slice() : [];
+  let appended = false;
+  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
+    const m2 = messages2[i2];
+    if (!m2 || m2.role !== "user") continue;
+    const content = typeof m2.content === "string" ? m2.content : "";
+    if (/\/no_think\b/i.test(content)) {
+      appended = true;
+      break;
+    }
+    messages2[i2] = { ...m2, content: content.endsWith("\n") ? `${content}/no_think` : `${content}
+
+/no_think` };
+    appended = true;
+    break;
+  }
+  if (!appended) {
+    messages2.push({ role: "user", content: "/no_think" });
+  }
+  return { ...request, messages: messages2, think: false };
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   for (const jsonText of telegramDecisionJsonCandidates(text)) {
     try {
@@ -616308,6 +616330,23 @@ External acquisition contract:
       stimulation = new StimulationController();
       /** Throttles noisy "skipped group chatter" waterfall logs */
       groupSkipLogAt = /* @__PURE__ */ new Map();
+      /**
+       * Per-chat router-call coalescing state. Bounds concurrent router (attention
+       * decision) inferences to at most 2 per sessionKey regardless of incoming
+       * message rate. Without this, a burst of N messages in a single chat fires
+       * N concurrent Ollama calls; over hours of bursts this saturates the GPU
+       * and produces the 10+ minute reply latencies observed after 24h uptime.
+       *
+       * Shape per sessionKey:
+       *   - inFlight: the currently-running router call for this chat
+       *   - trailing: a queued "next" call. If multiple messages arrive while
+       *     inFlight is running, they collapse into a single trailing call
+       *     that uses the most-recent message. All callers that arrived during
+       *     the in-flight window receive the trailing decision.
+       *
+       * Disabled with OMNIUS_TG_ROUTER_DEBOUNCE=off (emergency bypass).
+       */
+      telegramRouterSessionState = /* @__PURE__ */ new Map();
       /** Telegram interaction routing profile */
       interactionMode = "auto";
       /** Actual model context window discovered by the main TUI. */
@@ -617943,7 +617982,7 @@ ${mediaContext}` : ""
             this.agentConfig.model,
             this.agentConfig.apiKey
           );
-          const result = await backend.chatCompletion({
+          const result = await backend.chatCompletion(telegramThinkSuppressedRequest({
             messages: [
               { role: "system", content: "You are a Telegram public-follow-up discretion model. Output strict JSON only." },
               { role: "user", content: prompt }
@@ -617951,9 +617990,8 @@ ${mediaContext}` : ""
             tools: [],
             temperature: 0.2,
             maxTokens: 300,
-            timeoutMs: Math.min(Math.max(this.agentConfig.timeoutMs ?? 3e4, 5e3), 2e4),
-            think: false
-          });
+            timeoutMs: Math.min(Math.max(this.agentConfig.timeoutMs ?? 3e4, 5e3), 2e4)
+          }));
           const decision2 = parseTelegramReflectionFollowupDecision(result.choices[0]?.message?.content ?? "");
           state.lastFollowupArtifactAt = artifact.generatedAt;
           if (!decision2) {
@@ -619577,9 +619615,10 @@ ${lines.join("\n")}`);
       async telegramRouterJsonCompletion(backend, request, diagnostics) {
         let jsonModeResult;
         let jsonModeError;
+        const suppressed = telegramThinkSuppressedRequest(request);
         try {
           jsonModeResult = await backend.chatCompletion({
-            ...request,
+            ...suppressed,
             responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
           });
           const visible = jsonModeResult.choices.some(
@@ -619598,7 +619637,7 @@ ${lines.join("\n")}`);
           }
         }
         try {
-          const plainResult = await backend.chatCompletion(request);
+          const plainResult = await backend.chatCompletion(suppressed);
           if (diagnostics) {
             const plainVisible = plainResult.choices.some(
               (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
@@ -619751,6 +619790,202 @@ ${retryText}`,
           return null;
         }
       }
+      /**
+       * Coalesced wrapper around inferTelegramInteractionDecision. Bounds
+       * concurrent router calls per chat to 2: one in-flight plus one trailing
+       * that absorbs every message arriving during the in-flight window. The
+       * trailing call uses the most-recent message and serves all queued
+       * callers. Bypass with OMNIUS_TG_ROUTER_DEBOUNCE=off.
+       */
+      inferTelegramInteractionDecisionCoalesced(msg, toolContext) {
+        if (process.env["OMNIUS_TG_ROUTER_DEBOUNCE"] === "off") {
+          return this.inferTelegramInteractionDecision(msg, toolContext);
+        }
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const existing = this.telegramRouterSessionState.get(sessionKey);
+        if (!existing) {
+          return this.startCoalescedTelegramRouterCall(sessionKey, msg, toolContext);
+        }
+        if (existing.trailing) {
+          existing.trailing.msg = msg;
+          existing.trailing.toolContext = toolContext;
+          return existing.trailing.promise;
+        }
+        let resolve52;
+        let reject;
+        const promise = new Promise((res, rej) => {
+          resolve52 = res;
+          reject = rej;
+        });
+        existing.trailing = { msg, toolContext, promise, resolve: resolve52, reject };
+        return promise;
+      }
+      /**
+       * Internal: start an actual router inference for a sessionKey, store its
+       * in-flight promise, and on completion fire any queued trailing call.
+       */
+      startCoalescedTelegramRouterCall(sessionKey, msg, toolContext) {
+        const HARD_DEADLINE_MS = 18e4;
+        const inner = this.inferTelegramInteractionDecision(msg, toolContext);
+        const promise = new Promise((resolve52, reject) => {
+          let settled = false;
+          const guard = setTimeout(() => {
+            if (settled) return;
+            settled = true;
+            reject(new Error("router-coalescer: hard deadline exceeded (180s); inner inference did not settle"));
+          }, HARD_DEADLINE_MS);
+          if (typeof guard.unref === "function") guard.unref();
+          inner.then(
+            (v) => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(guard);
+              resolve52(v);
+            },
+            (e2) => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(guard);
+              reject(e2);
+            }
+          );
+        });
+        this.telegramRouterSessionState.set(sessionKey, { inFlight: promise });
+        const onSettled = () => {
+          let state;
+          try {
+            state = this.telegramRouterSessionState.get(sessionKey);
+            this.telegramRouterSessionState.delete(sessionKey);
+          } catch {
+            state = void 0;
+          }
+          if (!state?.trailing) return;
+          const { msg: nextMsg, toolContext: nextCtx, resolve: resolve52, reject } = state.trailing;
+          try {
+            this.startCoalescedTelegramRouterCall(sessionKey, nextMsg, nextCtx).then(resolve52, reject);
+          } catch (err) {
+            reject(err);
+          }
+        };
+        promise.then(onSettled, onSettled);
+        return promise;
+      }
+      /**
+       * Forcibly cancel every in-flight + trailing router-coalescer entry.
+       * Used on bridge stop() and by the watchdog if it detects the coalescer
+       * map has grown unboundedly. Rejects every queued caller cleanly so they
+       * surface the cancellation rather than waiting forever.
+       */
+      cancelTelegramRouterSessionState(reason) {
+        const err = new Error(`router-coalescer cancelled: ${reason}`);
+        for (const [, state] of this.telegramRouterSessionState) {
+          if (state.trailing) {
+            try {
+              state.trailing.reject(err);
+            } catch {
+            }
+          }
+        }
+        this.telegramRouterSessionState.clear();
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Sub-agent staleness watchdog
+      // ─────────────────────────────────────────────────────────────────
+      /** Interval handle for the periodic stale-sub-agent reaper. */
+      telegramSubAgentWatchdogTimer = null;
+      /**
+       * Maximum wall-clock time a sub-agent may go without a visible-edit
+       * progress event before the watchdog declares it stale and tears it
+       * down. Tuned to be comfortably longer than the slowest healthy turn
+       * (which is bounded by request_timeout = 5-15min per turn) but short
+       * enough that a wedged sub-agent doesn't pin a chat for an entire day.
+       *
+       * Override with env var OMNIUS_TG_SUBAGENT_MAX_IDLE_MS for ops tuning.
+       */
+      telegramSubAgentMaxIdleMs() {
+        const raw = Number.parseInt(process.env["OMNIUS_TG_SUBAGENT_MAX_IDLE_MS"] ?? "", 10);
+        if (Number.isFinite(raw) && raw >= 3e4 && raw <= 36e5) return raw;
+        return 6e5;
+      }
+      /** Watchdog tick period — checked every 30s. */
+      telegramSubAgentWatchdogIntervalMs() {
+        return 3e4;
+      }
+      /**
+       * Start the periodic stale-sub-agent reaper. Idempotent — safe to call
+       * multiple times (no-op if already running). Stopped by stop() and on
+       * SIGTERM via the cleanup chain.
+       */
+      startTelegramSubAgentWatchdog() {
+        if (this.telegramSubAgentWatchdogTimer) return;
+        const tick = () => {
+          try {
+            this.reapStaleTelegramSubAgents();
+          } catch (err) {
+            this.tuiWrite(() => renderTelegramSubAgentError(
+              "watchdog",
+              `tick failed: ${err instanceof Error ? err.message : String(err)}`
+            ));
+          }
+        };
+        this.telegramSubAgentWatchdogTimer = setInterval(tick, this.telegramSubAgentWatchdogIntervalMs());
+        if (typeof this.telegramSubAgentWatchdogTimer.unref === "function") {
+          this.telegramSubAgentWatchdogTimer.unref();
+        }
+      }
+      /** Stop the periodic stale-sub-agent reaper. */
+      stopTelegramSubAgentWatchdog() {
+        if (this.telegramSubAgentWatchdogTimer) {
+          clearInterval(this.telegramSubAgentWatchdogTimer);
+          this.telegramSubAgentWatchdogTimer = null;
+        }
+      }
+      /**
+       * One watchdog pass: walk the sub-agent map; for each entry where the
+       * last visible-edit progress event is older than maxIdle AND no completion
+       * boundary has been seen, abort the runner and remove the entry. This is
+       * the load-bearing fix for the runaway-sub-agent steady-state leak: a
+       * runner that hangs (qwen3 think-stall, Ollama TCP wedge, lost stream)
+       * otherwise pins the chat forever, because the finally{} in runSubAgent
+       * never fires.
+       */
+      reapStaleTelegramSubAgents() {
+        const maxIdleMs = this.telegramSubAgentMaxIdleMs();
+        const now = Date.now();
+        const stale = [];
+        for (const [sessionKey, agent] of this.subAgents) {
+          if (agent.aborted) continue;
+          const idle = agent.lastEditMs > 0 ? now - agent.lastEditMs : 0;
+          if (idle <= maxIdleMs) continue;
+          if (agent.completionBoundarySeen) continue;
+          stale.push(sessionKey);
+        }
+        for (const sessionKey of stale) {
+          const agent = this.subAgents.get(sessionKey);
+          if (!agent) continue;
+          agent.aborted = true;
+          if (agent.typingInterval) {
+            clearInterval(agent.typingInterval);
+            agent.typingInterval = null;
+          }
+          try {
+            agent.runner?.abort?.();
+          } catch {
+          }
+          this.subAgents.delete(sessionKey);
+          this.refreshActiveTelegramInteractionCount();
+          this.tuiWrite(() => renderTelegramSubAgentEvent(
+            agent.username,
+            `watchdog: aborted stale sub-agent (idle ${Math.round((now - agent.lastEditMs) / 1e3)}s without completion)`
+          ));
+          this.subAgentViewCallbacks?.onWrite(
+            agent.viewId,
+            `watchdog: sub-agent retired after ${Math.round((now - agent.lastEditMs) / 1e3)}s without a progress event`
+          );
+          this.subAgentViewCallbacks?.onStatus(agent.viewId, "failed");
+          this.subAgentViewCallbacks?.onComplete(agent.viewId);
+        }
+      }
       async inferTelegramInteractionDecision(msg, toolContext) {
         const config = this.agentConfig;
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
@@ -620348,6 +620583,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           this.polling = true;
           this.pollFatalNotified = false;
           this.abortController = new AbortController();
+          this.startTelegramSubAgentWatchdog();
           await this.prepareTelegramLongPolling();
           try {
             mkdirSync66(this.mediaCacheDir, { recursive: true });
@@ -620423,7 +620659,13 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         for (const [, agent] of this.subAgents) {
           agent.aborted = true;
           if (agent.typingInterval) clearInterval(agent.typingInterval);
+          try {
+            agent.runner?.abort?.();
+          } catch {
+          }
         }
+        this.stopTelegramSubAgentWatchdog();
+        this.cancelTelegramRouterSessionState("bridge stop");
         if (this.telegramSqliteDb && this.telegramSqliteDb !== false) {
           try {
             this.telegramSqliteDb.close();
@@ -620754,7 +620996,7 @@ Join: ${newUrl}`);
           const isGroup = msg.chatType !== "private";
           if (isGroup) {
             const attentionViewId2 = this.registerTelegramAttentionView(msg, existing.toolContext || toolContext, "active Telegram thread");
-            const decision3 = await this.inferTelegramInteractionDecision(msg, existing.toolContext || toolContext);
+            const decision3 = await this.inferTelegramInteractionDecisionCoalesced(msg, existing.toolContext || toolContext);
             this.deliverTelegramAttentionDecision(
               sessionKey,
               msg,
@@ -620798,7 +621040,7 @@ Join: ${newUrl}`);
           return;
         }
         const attentionViewId = this.registerTelegramAttentionView(msg, toolContext);
-        const decision2 = await this.inferTelegramInteractionDecision(msg, toolContext);
+        const decision2 = await this.inferTelegramInteractionDecisionCoalesced(msg, toolContext);
         this.deliverTelegramAttentionDecision(
           sessionKey,
           msg,
@@ -621231,14 +621473,13 @@ ${conversationStream}`
           config.model,
           config.apiKey
         );
-        const request = {
+        const request = telegramThinkSuppressedRequest({
           messages: this.buildTelegramChatMessages(msg, toolContext, mediaContext),
           tools: [],
           temperature: 0.4,
           maxTokens: 700,
-          timeoutMs: Math.max(config.timeoutMs ?? 3e5, 12e4),
-          think: false
-        };
+          timeoutMs: Math.max(config.timeoutMs ?? 3e5, 12e4)
+        });
         let accumulated = "";
         let streamError;
         const streamable = backend;
@@ -621331,6 +621572,15 @@ ${conversationStream}`
           disablePersistentMemory: false,
           disableCodebaseMap: !isAdminDM,
           subAgent: !isAdminDM,
+          // Telegram sub-agents run tool-heavy workflows where qwen3 <think>
+          // reasoning is notorious for stalling: the model burns its token
+          // budget inside <think>...</think> and never closes the tag, producing
+          // empty content or 10+ minute replies after 24h. The runner's
+          // computeEffectiveThink() already kills thinking when hasTools=true,
+          // but we set it explicitly here as well so a future no-tools turn
+          // (compaction window, recovery prompt, watchdog probe) inherits the
+          // off default rather than the global config's value.
+          thinking: false,
           // Telegram sub-agent runs must be bounded. Brute-force re-engagement and
           // the Littleman near-cap turn extension are appropriate for the full TUI
           // session but cause Telegram to silently outgrow its nominal maxTurns,

package/npm-shrinkwrap.json

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

package/package.json

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