omnius 1.0.114 → 1.0.115

package/dist/index.js

@@ -619825,18 +619825,167 @@ ${retryText}`,
        * in-flight promise, and on completion fire any queued trailing call.
        */
       startCoalescedTelegramRouterCall(sessionKey, msg, toolContext) {
-        const promise = this.inferTelegramInteractionDecision(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 = () => {
-          const state = this.telegramRouterSessionState.get(sessionKey);
-          this.telegramRouterSessionState.delete(sessionKey);
+          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;
-          this.startCoalescedTelegramRouterCall(sessionKey, nextMsg, nextCtx).then(resolve52, reject);
+          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;
@@ -620434,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 });
@@ -620509,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();

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.114",
+  "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",