omnius 1.0.130 → 1.0.132

package/dist/index.js

@@ -564387,6 +564387,7 @@ var init_command_registry = __esm({
       ["/telegram status", "Show Telegram bridge status"],
       ["/telegram stop", "Disconnect Telegram bridge"],
       ["/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 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"],
@@ -597970,6 +597971,31 @@ sleep 1
         renderInfo(`Telegram interaction mode set to ${c3.bold(requested)}${wantsLocalMode ? " (project)" : " (global)"}.`);
         return "handled";
       }
+      if (parts[0] === "subagents" || parts[0] === "sub-agents" || parts[0] === "agents") {
+        const requested = parts.slice(1).find((part) => !part.startsWith("--"));
+        if (!requested) {
+          const settings = ctx3.getTelegramSettings?.() ?? {};
+          renderInfo(`Telegram sub-agent slots: ${c3.bold(String(settings.subAgents ?? 2))} global max (cap 5).`);
+          renderInfo("Use /telegram subagents 1, /telegram subagents 2, ... up to 5.");
+          return "handled";
+        }
+        const parsed = Number(requested);
+        if (!Number.isFinite(parsed) || parsed < 1) {
+          renderWarning("Usage: /telegram subagents <1-5> [--global]");
+          return "handled";
+        }
+        const limit = Math.max(1, Math.min(5, Math.floor(parsed)));
+        const hasGlobalFlagSubAgents = parts.includes("--global");
+        const projectRootSubAgents = ctx3.repoRoot || process.cwd();
+        const projectHasOmniusSubAgents = existsSync104(join117(projectRootSubAgents, ".omnius"));
+        const wantsLocalSubAgents = hasGlobalFlagSubAgents ? false : isLocal || projectHasOmniusSubAgents;
+        ctx3.saveTelegramSettings?.({ subAgents: limit, local: wantsLocalSubAgents });
+        const activeLimit = ctx3.telegramSetSubAgentLimit?.(limit) ?? limit;
+        renderInfo(
+          `Telegram sub-agent slots set to ${c3.bold(String(activeLimit))} global max${parsed > 5 ? " (requested value capped at 5)" : ""}${wantsLocalSubAgents ? " (project)" : " (global)"}.`
+        );
+        return "handled";
+      }
       if (parts[0] === "auth" || parts[0] === "authenticate") {
         if (parts[1] === "cancel") {
           const cancelled = ctx3.telegramCancelAdminAuth?.() ?? false;
@@ -598339,6 +598365,7 @@ sleep 1
       renderInfo("  /telegram stop            Stop bridge");
       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 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");
@@ -616665,6 +616692,11 @@ function buildTelegramRuntimeContext(now = /* @__PURE__ */ new Date(), repoRoot)
 function telegramSessionIdFromKey(sessionKey) {
   return `telegram-${createHash25("sha1").update(sessionKey).digest("hex").slice(0, 16)}`;
 }
+function normalizeTelegramSubAgentLimit(value2) {
+  const parsed = typeof value2 === "number" ? value2 : typeof value2 === "string" && value2.trim() ? Number(value2.trim()) : TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
+  if (!Number.isFinite(parsed)) return TELEGRAM_SUB_AGENT_DEFAULT_LIMIT;
+  return Math.max(1, Math.min(TELEGRAM_SUB_AGENT_MAX_LIMIT, Math.floor(parsed)));
+}
 function selectTelegramFinalResponse(args) {
   const committedVisibleReply = cleanTelegramVisibleReply(args.visibleReplyText || "");
   if (committedVisibleReply) return committedVisibleReply;
@@ -617361,11 +617393,13 @@ function normalizeTelegramSendKind(rawKind, path12) {
   }
   return classifyMedia(path12) ?? "document";
 }
-function renderTelegramStart(botUsername, adminId, mode = "auto", canReadAllGroupMessages) {
+function renderTelegramStart(botUsername, adminId, mode = "auto", canReadAllGroupMessages, maxSubAgents = TELEGRAM_SUB_AGENT_DEFAULT_LIMIT) {
   process.stdout.write(`
   ${c3.cyan("✈")} ${c3.bold("Telegram Bridge")} connected as @${botUsername}
 `);
   process.stdout.write(`    ${c3.dim(`Interaction mode: ${mode}`)}
+`);
+  process.stdout.write(`    ${c3.dim(`Telegram work slots: ${maxSubAgents} global max (use /telegram subagents 1-${TELEGRAM_SUB_AGENT_MAX_LIMIT})`)}
 `);
   process.stdout.write(`    ${c3.dim("Auto mode uses quick chat for conversational turns and sub-agents for action requests")}
 `);
@@ -617390,12 +617424,14 @@ function renderTelegramStart(botUsername, adminId, mode = "auto", canReadAllGrou
 
 `);
 }
-function renderTelegramStatus(active, botUsername, adminId, activeSubAgents, mode = "auto", canReadAllGroupMessages) {
+function renderTelegramStatus(active, botUsername, adminId, activeSubAgents, mode = "auto", canReadAllGroupMessages, maxSubAgents = TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, queuedSubAgentSessions = 0) {
   if (active) {
     process.stdout.write(`
   ${c3.green("●")} Telegram bridge: ${c3.bold("active")} (@${botUsername ?? "?"})
 `);
     process.stdout.write(`    Mode: ${mode}
+`);
+    process.stdout.write(`    Telegram work slots: ${activeSubAgents ?? 0}/${maxSubAgents} active${queuedSubAgentSessions > 0 ? `, ${queuedSubAgentSessions} queued` : ""}
 `);
     process.stdout.write(`    Group ingest: ${canReadAllGroupMessages ? "all delivered group messages" : "privacy-limited by Telegram/BotFather"}
 `);
@@ -617471,7 +617507,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("│")} ${c3.magenta("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -617850,6 +617886,8 @@ External acquisition contract:
       bruteForceMaxCycles: 0,
       allowTurnExtension: false
     };
+    TELEGRAM_SUB_AGENT_DEFAULT_LIMIT = 2;
+    TELEGRAM_SUB_AGENT_MAX_LIMIT = 5;
     TELEGRAM_PUBLIC_HELP_COMMANDS2 = /* @__PURE__ */ new Set(["help", "start", "auth", "call"]);
     TELEGRAM_REMINDER_SLASH_COMMANDS = /* @__PURE__ */ new Set(["remind", "reminder", "reminders"]);
     TELEGRAM_REFLECTION_SLASH_COMMANDS = /* @__PURE__ */ new Set(["reflect", "reflection", "daydream", "dream"]);
@@ -617884,6 +617922,7 @@ External acquisition contract:
         this.telegramConversationDir = resolve45(repoRoot || ".", ".omnius", "telegram-conversations");
         this.telegramSqlitePath = resolve45(repoRoot || ".", ".omnius", "telegram.sqlite");
         this.telegramToolButtonDir = resolve45(repoRoot || ".", ".omnius", "telegram-tool-buttons");
+        this.state.maxSubAgents = normalizeTelegramSubAgentLimit(resolveSettings(repoRoot || ".").telegramSubAgents);
         this.hydrateTelegramCommandMap(buildTelegramBotCommands({ scope: "admin" }));
       }
       botToken;
@@ -617906,14 +617945,28 @@ External acquisition contract:
         startedAt: "",
         messagesReceived: 0,
         messagesSent: 0,
-        activeSubAgents: 0
+        activeSubAgents: 0,
+        maxSubAgents: TELEGRAM_SUB_AGENT_DEFAULT_LIMIT,
+        queuedSubAgentSessions: 0
       };
       /** Admin user ID — if set, messages from this user get full memory access */
       adminUserId = null;
       /** Active sub-agents by chat/guest session key */
       subAgents = /* @__PURE__ */ new Map();
+      /** Debounced live-context packets for messages arriving during a runner. */
+      telegramSubAgentContextBuffers = /* @__PURE__ */ new Map();
       /** Active direct chat completions, counted with Telegram activity in the TUI */
       activeChatViews = /* @__PURE__ */ new Set();
+      /**
+       * Global Telegram work admission. This is intentionally broader than
+       * this.subAgents: router inference, fast-chat completions, and action
+       * runners all consume a slot because all of them can block local model
+       * capacity and flood the TUI.
+       */
+      telegramActiveWorkSessions = /* @__PURE__ */ new Set();
+      /** Queued Telegram sessions waiting for a global work slot. */
+      telegramQueuedSessionWork = /* @__PURE__ */ new Map();
+      telegramDispatchQueuedTimer = null;
       /** Lightweight chat history by chat/guest session key */
       chatHistory = /* @__PURE__ */ new Map();
       /** Participant and tone state by chat/guest session key */
@@ -617963,7 +618016,7 @@ External acquisition contract:
        * Live telemetry of every in-flight Ollama call originating from the
        * bridge. Lets the operator see WHY multiple GPUs are spun up at once
        * and HOW each call is progressing — which is the only way to debug a
-       * 180s hard-deadline firing event without grepping logs.
+       * router hard-deadline firing event without grepping logs.
        *
        * Each entry tracks:
        *   - kind: router | chat-fast-path | followup | sub-agent
@@ -618017,6 +618070,7 @@ External acquisition contract:
       ]);
       /** TUI agent-view callbacks for Telegram sub-agent registration. */
       subAgentViewCallbacks = null;
+      rawSubAgentViewCallbacks = null;
       /** Callback to get active call session URL (wired from interactive.ts) */
       callUrlGetter = null;
       /** Callback to start a call session and return the URL (wired from interactive.ts) */
@@ -618027,6 +618081,10 @@ External acquisition contract:
       callStartInProgress = false;
       /** Callback to write content into the scrollable TUI waterfall area (wired from interactive.ts) */
       writeContent = null;
+      pendingTuiWrites = [];
+      pendingTuiWriteTimer = null;
+      pendingSubAgentViewWrites = /* @__PURE__ */ new Map();
+      pendingSubAgentViewWriteTimer = null;
       /** Media cache — fileUniqueId → cache entry */
       mediaCache = /* @__PURE__ */ new Map();
       /** Media cache directory */
@@ -618074,6 +618132,15 @@ External acquisition contract:
       getInteractionMode() {
         return this.interactionMode;
       }
+      setSubAgentLimit(limit) {
+        const normalized = normalizeTelegramSubAgentLimit(limit);
+        this.state.maxSubAgents = normalized;
+        this.dispatchQueuedTelegramSessionWorkSoon();
+        return normalized;
+      }
+      getSubAgentLimit() {
+        return normalizeTelegramSubAgentLimit(this.state.maxSubAgents);
+      }
       setContextWindowSize(size) {
         this.contextWindowSize = Number.isFinite(size) && size > 0 ? Math.trunc(size) : 0;
       }
@@ -618104,7 +618171,19 @@ External acquisition contract:
         this.adminAuthHandler = handler;
       }
       setSubAgentViewCallbacks(callbacks) {
-        this.subAgentViewCallbacks = callbacks;
+        this.rawSubAgentViewCallbacks = callbacks;
+        this.subAgentViewCallbacks = {
+          onRegister: (...args) => callbacks.onRegister(...args),
+          onWrite: (id, text) => this.telegramViewWrite(id, text),
+          onStatus: (...args) => {
+            this.flushTelegramViewWrites();
+            callbacks.onStatus(...args);
+          },
+          onComplete: (...args) => {
+            this.flushTelegramViewWrites();
+            callbacks.onComplete(...args);
+          }
+        };
       }
       /** Register callback to get active call URL for /call button forwarding */
       setCallUrlGetter(getter) {
@@ -618130,7 +618209,12 @@ External acquisition contract:
         return this.polling;
       }
       get stats() {
-        return { ...this.state, activeSubAgents: this.activeTelegramInteractionCount() };
+        return {
+          ...this.state,
+          activeSubAgents: this.activeTelegramInteractionCount(),
+          maxSubAgents: this.getSubAgentLimit(),
+          queuedSubAgentSessions: this.telegramQueuedSessionWork.size
+        };
       }
       get botUsername() {
         return this.state.botUsername;
@@ -618412,10 +618496,61 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
       }
       /** Write to the scrollable TUI waterfall area (respects status bar scroll region) */
       tuiWrite(fn) {
+        this.pendingTuiWrites.push(fn);
+        if (this.pendingTuiWriteTimer) return;
+        this.pendingTuiWriteTimer = setTimeout(() => this.flushTelegramTuiWrites(), 0);
+        if (typeof this.pendingTuiWriteTimer.unref === "function") {
+          this.pendingTuiWriteTimer.unref();
+        }
+      }
+      flushTelegramTuiWrites() {
+        if (this.pendingTuiWriteTimer) {
+          clearTimeout(this.pendingTuiWriteTimer);
+          this.pendingTuiWriteTimer = null;
+        }
+        const batch2 = this.pendingTuiWrites.splice(0);
+        if (batch2.length === 0) return;
+        const runBatch = () => {
+          for (const fn of batch2) {
+            try {
+              fn();
+            } catch {
+            }
+          }
+        };
         if (this.writeContent) {
-          this.writeContent(fn);
+          this.writeContent(runBatch);
         } else {
-          fn();
+          runBatch();
+        }
+      }
+      telegramViewWrite(id, text) {
+        const callbacks = this.rawSubAgentViewCallbacks;
+        if (!callbacks) return;
+        const queue = this.pendingSubAgentViewWrites.get(id) ?? [];
+        queue.push(text);
+        this.pendingSubAgentViewWrites.set(id, queue);
+        if (this.pendingSubAgentViewWriteTimer) return;
+        this.pendingSubAgentViewWriteTimer = setTimeout(() => this.flushTelegramViewWrites(), 100);
+        if (typeof this.pendingSubAgentViewWriteTimer.unref === "function") {
+          this.pendingSubAgentViewWriteTimer.unref();
+        }
+      }
+      flushTelegramViewWrites() {
+        if (this.pendingSubAgentViewWriteTimer) {
+          clearTimeout(this.pendingSubAgentViewWriteTimer);
+          this.pendingSubAgentViewWriteTimer = null;
+        }
+        const callbacks = this.rawSubAgentViewCallbacks;
+        if (!callbacks || this.pendingSubAgentViewWrites.size === 0) {
+          this.pendingSubAgentViewWrites.clear();
+          return;
+        }
+        const batch2 = this.pendingSubAgentViewWrites;
+        this.pendingSubAgentViewWrites = /* @__PURE__ */ new Map();
+        for (const [id, lines] of batch2) {
+          if (lines.length === 0) continue;
+          callbacks.onWrite(id, lines.join("\n"));
         }
       }
       sessionKeyForMessage(msg) {
@@ -618423,14 +618558,198 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         return `chat:${String(msg.chatId)}`;
       }
       activeTelegramInteractionCount() {
-        return this.subAgents.size + this.activeChatViews.size;
+        return Math.max(
+          this.telegramActiveWorkSessions.size,
+          this.subAgents.size + this.activeChatViews.size
+        );
       }
       refreshActiveTelegramInteractionCount() {
         this.state.activeSubAgents = this.activeTelegramInteractionCount();
+        this.state.maxSubAgents = this.getSubAgentLimit();
+        this.state.queuedSubAgentSessions = this.telegramQueuedSessionWork.size;
+      }
+      telegramWorkCapacityAvailable() {
+        return this.telegramActiveWorkSessions.size < this.getSubAgentLimit();
+      }
+      dispatchQueuedTelegramSessionWorkSoon() {
+        if (this.telegramDispatchQueuedTimer) return;
+        this.telegramDispatchQueuedTimer = setTimeout(() => this.dispatchQueuedTelegramSessionWork(), 0);
+        if (typeof this.telegramDispatchQueuedTimer.unref === "function") {
+          this.telegramDispatchQueuedTimer.unref();
+        }
+      }
+      dispatchQueuedTelegramSessionWork() {
+        if (this.telegramDispatchQueuedTimer) {
+          clearTimeout(this.telegramDispatchQueuedTimer);
+          this.telegramDispatchQueuedTimer = null;
+        }
+        while (this.telegramWorkCapacityAvailable()) {
+          const next = [...this.telegramQueuedSessionWork.values()].filter((work) => !this.telegramActiveWorkSessions.has(work.sessionKey)).sort((a2, b) => a2.lastSpokenAtMs - b.lastSpokenAtMs || a2.enqueuedAtMs - b.enqueuedAtMs)[0];
+          if (!next) break;
+          this.telegramQueuedSessionWork.delete(next.sessionKey);
+          this.startTelegramSessionWork(next);
+        }
+        this.refreshActiveTelegramInteractionCount();
+      }
+      scheduleTelegramSessionWork(msg, toolContext) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const now = Date.now();
+        const existing = this.telegramQueuedSessionWork.get(sessionKey);
+        if (this.telegramWorkCapacityAvailable() && !this.telegramActiveWorkSessions.has(sessionKey)) {
+          if (existing) this.telegramQueuedSessionWork.delete(sessionKey);
+          this.startTelegramSessionWork({
+            sessionKey,
+            msg,
+            toolContext,
+            enqueuedAtMs: existing?.enqueuedAtMs ?? now,
+            lastSpokenAtMs: now,
+            messageCount: (existing?.messageCount ?? 0) + 1
+          });
+          return;
+        }
+        this.telegramQueuedSessionWork.set(sessionKey, {
+          sessionKey,
+          msg,
+          toolContext,
+          enqueuedAtMs: existing?.enqueuedAtMs ?? now,
+          lastSpokenAtMs: now,
+          messageCount: (existing?.messageCount ?? 0) + 1
+        });
+        this.refreshActiveTelegramInteractionCount();
+        this.tuiWrite(() => renderTelegramSubAgentEvent(
+          msg.username,
+          `queued Telegram work for ${msg.chatTitle || msg.chatType}; active ${this.telegramActiveWorkSessions.size}/${this.getSubAgentLimit()}, queued ${this.telegramQueuedSessionWork.size}`
+        ));
+      }
+      startTelegramSessionWork(work) {
+        this.telegramActiveWorkSessions.add(work.sessionKey);
+        this.refreshActiveTelegramInteractionCount();
+        void this.processTelegramMessageWork(work.msg, work.toolContext).catch((err) => {
+          this.tuiWrite(() => renderWarning(`Telegram sub-agent error: ${err instanceof Error ? err.message : String(err)}`));
+        }).finally(() => {
+          this.telegramActiveWorkSessions.delete(work.sessionKey);
+          this.refreshActiveTelegramInteractionCount();
+          this.dispatchQueuedTelegramSessionWorkSoon();
+        });
+      }
+      takeQueuedTelegramSessionWork(sessionKey) {
+        const queued = this.telegramQueuedSessionWork.get(sessionKey);
+        if (!queued) return void 0;
+        this.telegramQueuedSessionWork.delete(sessionKey);
+        this.refreshActiveTelegramInteractionCount();
+        return queued;
+      }
+      fallbackTelegramRouterDecision(msg, toolContext, err) {
+        const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
+        const errMsg = err instanceof Error ? err.message : String(err);
+        return {
+          route: forcedRoute ?? (msg.chatType === "private" ? "chat" : "action"),
+          shouldReply: false,
+          confidence: 0,
+          reason: `router unavailable; retained as context without replying (${errMsg.slice(0, 160)})`,
+          source: "inference-unavailable",
+          silentDisposition: "retained as context without replying because the router did not settle",
+          diagnosticNote: `router failure after queue admission: ${errMsg.slice(0, 240)}; tool_context=${toolContext}`
+        };
       }
       canUseChatActions(msg) {
         return !msg.guestQueryId && (typeof msg.chatId === "number" || String(msg.chatId).startsWith("@"));
       }
+      telegramSubAgentContextFlushMs() {
+        const raw = process.env["OMNIUS_TG_SUBAGENT_CONTEXT_FLUSH_MS"];
+        if (raw === "off") return 0;
+        const parsed = raw !== void 0 ? Number(raw) : 650;
+        if (!Number.isFinite(parsed)) return 650;
+        return Math.max(0, Math.min(5e3, Math.floor(parsed)));
+      }
+      clearTelegramSubAgentContextBuffer(sessionKey) {
+        const buffer2 = this.telegramSubAgentContextBuffers.get(sessionKey);
+        if (buffer2?.timer) clearTimeout(buffer2.timer);
+        this.telegramSubAgentContextBuffers.delete(sessionKey);
+      }
+      clearAllTelegramSubAgentContextBuffers() {
+        for (const key of this.telegramSubAgentContextBuffers.keys()) {
+          this.clearTelegramSubAgentContextBuffer(key);
+        }
+      }
+      formatTelegramSubAgentContextPacket(messages2) {
+        const recent = messages2.slice(-12);
+        const dropped = messages2.length - recent.length;
+        return [
+          "[Telegram live context update]",
+          "These Telegram messages arrived while this runner was already active. Treat them as added context, not a new task. Continue the current work and only adjust the reply if the update is directly relevant.",
+          dropped > 0 ? `Older buffered updates omitted from this packet: ${dropped}.` : "",
+          ...recent.map((message2, index) => `### Update ${index + 1}
+${message2}`)
+        ].filter(Boolean).join("\n\n");
+      }
+      enqueueTelegramSubAgentContext(sessionKey, subAgent, context2, username) {
+        let buffer2 = this.telegramSubAgentContextBuffers.get(sessionKey);
+        if (!buffer2) {
+          buffer2 = { messages: [], timer: null };
+          this.telegramSubAgentContextBuffers.set(sessionKey, buffer2);
+        }
+        buffer2.messages.push(context2);
+        const flushMs = this.telegramSubAgentContextFlushMs();
+        if (buffer2.timer) return;
+        buffer2.timer = setTimeout(() => {
+          this.flushTelegramSubAgentContextBuffer(sessionKey, username);
+        }, flushMs);
+        if (typeof buffer2.timer.unref === "function") buffer2.timer.unref();
+        this.subAgentViewCallbacks?.onWrite(
+          subAgent.viewId,
+          `live context queued (${buffer2.messages.length} buffered)`
+        );
+      }
+      flushTelegramSubAgentContextBuffer(sessionKey, username = "telegram") {
+        const buffer2 = this.telegramSubAgentContextBuffers.get(sessionKey);
+        if (!buffer2) return;
+        if (buffer2.timer) clearTimeout(buffer2.timer);
+        this.telegramSubAgentContextBuffers.delete(sessionKey);
+        if (buffer2.messages.length === 0) return;
+        const subAgent = this.subAgents.get(sessionKey);
+        if (!subAgent || subAgent.aborted) return;
+        const packet = this.formatTelegramSubAgentContextPacket(buffer2.messages);
+        if (subAgent.runner) {
+          subAgent.runner.injectUserMessage(packet);
+          this.tuiWrite(() => renderTelegramSubAgentEvent(
+            username,
+            `live context consolidated (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
+          ));
+          this.subAgentViewCallbacks?.onWrite(
+            subAgent.viewId,
+            `live context injected (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
+          );
+        } else {
+          subAgent.pendingMessages.push(packet);
+          this.subAgentViewCallbacks?.onWrite(
+            subAgent.viewId,
+            `live context staged (${buffer2.messages.length} message${buffer2.messages.length === 1 ? "" : "s"})`
+          );
+        }
+      }
+      async enqueueTelegramMessageForExistingSubAgent(msg, subAgent) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        let mediaContext = "";
+        if (msg.media || msg.replyToMedia) {
+          mediaContext = await this.processMediaContextForMessage(msg);
+        }
+        const isGroup = msg.chatType !== "private";
+        const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
+        const context2 = this.formatTelegramCurrentMessageForPrompt(
+          sessionKey,
+          msg,
+          `Telegram live context from @${msg.username}${chatLabel}`,
+          mediaContext
+        );
+        if (isGroup) {
+          this.markLastTelegramUserMessageMode(msg, "steering");
+        } else {
+          this.recordTelegramUserMessage(msg, "steering", context2);
+        }
+        this.enqueueTelegramSubAgentContext(sessionKey, subAgent, context2, msg.username);
+        this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, "live context queued for active Telegram runner"));
+      }
       async replyWithTelegramHelp(msg, isAdmin) {
         const scope = isAdmin ? "admin" : "public";
         const menu = renderHelpMenu(scope);
@@ -619471,7 +619790,7 @@ ${mediaContext}` : ""
       async runTelegramChannelDmnForSession(sessionKey, reason = "idle", nowMs = Date.now(), force = false) {
         if (!this.repoRoot) return null;
         if (this.channelDmnRunning.has(sessionKey)) return null;
-        if (this.subAgents.has(sessionKey)) return null;
+        if (this.subAgents.has(sessionKey) || this.telegramActiveWorkSessions.has(sessionKey)) return null;
         const input = this.buildTelegramChannelDaydreamInput(sessionKey, nowMs);
         if (!input) return null;
         if (input.chatType === "private" && !force) return null;
@@ -621295,7 +621614,7 @@ ${lines.join("\n")}`);
       // ─────────────────────────────────────────────────────────────────
       // Observable inference — streams chatCompletion-shaped calls so the
       // operator can SEE what's happening during a long-running router or
-      // chat-fast-path call instead of waiting 180s for a hard-deadline.
+      // chat-fast-path call instead of waiting for a router hard-deadline.
       // ─────────────────────────────────────────────────────────────────
       /**
        * Wrap a chatCompletion-shaped call so the bridge can observe its token
@@ -621699,14 +622018,14 @@ ${retryText}`,
        * in-flight promise, and on completion fire any queued trailing call.
        */
       startCoalescedTelegramRouterCall(sessionKey, msg, toolContext) {
-        const HARD_DEADLINE_MS = 18e4;
+        const HARD_DEADLINE_MS = this.telegramRouterHardDeadlineMs();
         const inner = this.inferTelegramInteractionDecision(msg, toolContext);
         const promise = new Promise((resolve54, 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"));
+            reject(new Error(`router-coalescer: hard deadline exceeded (${Math.round(HARD_DEADLINE_MS / 1e3)}s); inner inference did not settle`));
           }, HARD_DEADLINE_MS);
           if (typeof guard.unref === "function") guard.unref();
           inner.then(
@@ -621744,6 +622063,11 @@ ${retryText}`,
         promise.then(onSettled, onSettled);
         return promise;
       }
+      telegramRouterHardDeadlineMs() {
+        const raw = Number.parseInt(process.env["OMNIUS_TG_ROUTER_HARD_DEADLINE_MS"] ?? "", 10);
+        if (Number.isFinite(raw) && raw >= 5e3 && raw <= 18e4) return raw;
+        return 6e4;
+      }
       /**
        * Forcibly cancel every in-flight + trailing router-coalescer entry.
        * Used on bridge stop() and by the watchdog if it detects the coalescer
@@ -621792,11 +622116,11 @@ ${retryText}`,
        * the iterator, and telegramObservableInference falls back to the
        * non-streaming chatCompletion path. This gives operators a clean
        * "stream silent for 60s, falling back" signal instead of the opaque
-       * 180s coalescer hard-deadline.
+       * coalescer hard-deadline.
        *
        * Default 60s — comfortably longer than a healthy cold-load of a 35B
        * model on a warm VRAM cache (typically <30s) but short enough to
-       * surface a real wedge before the 180s coalescer fires. Override via
+       * surface a real wedge before the coalescer fires. Override via
        * OMNIUS_TG_STREAM_INACTIVITY_MS (clamped to [10s, 5min]).
        */
       telegramStreamInactivityMs() {
@@ -621866,7 +622190,9 @@ ${retryText}`,
           } catch {
           }
           this.subAgents.delete(sessionKey);
+          this.telegramActiveWorkSessions.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
+          this.dispatchQueuedTelegramSessionWorkSoon();
           this.tuiWrite(() => renderTelegramSubAgentEvent(
             agent.username,
             `watchdog: aborted stale sub-agent (idle ${Math.round((now - agent.lastEditMs) / 1e3)}s without completion)`
@@ -621892,7 +622218,7 @@ ${retryText}`,
           privateChannel: !isGroup,
           directSignal: addressesBot,
           replyToAgent: this.telegramMessageRepliesToBot(msg),
-          activeAgent: this.subAgents.has(sessionKey),
+          activeAgent: this.subAgents.has(sessionKey) || this.telegramActiveWorkSessions.has(sessionKey),
           forceAnalyze: daydreamForceCheck
         });
         if (!config) {
@@ -622470,7 +622796,9 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
             startedAt: (/* @__PURE__ */ new Date()).toISOString(),
             messagesReceived: 0,
             messagesSent: 0,
-            activeSubAgents: 0
+            activeSubAgents: 0,
+            maxSubAgents: this.getSubAgentLimit(),
+            queuedSubAgentSessions: 0
           };
           this.botUserId = typeof me.result?.id === "number" ? me.result.id : this.botUserId;
           this.polling = true;
@@ -622559,6 +622887,15 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         }
         this.stopTelegramSubAgentWatchdog();
         this.cancelTelegramRouterSessionState("bridge stop");
+        this.clearAllTelegramSubAgentContextBuffers();
+        if (this.telegramDispatchQueuedTimer) {
+          clearTimeout(this.telegramDispatchQueuedTimer);
+          this.telegramDispatchQueuedTimer = null;
+        }
+        this.telegramQueuedSessionWork.clear();
+        this.telegramActiveWorkSessions.clear();
+        this.flushTelegramViewWrites();
+        this.flushTelegramTuiWrites();
         this.telegramActiveInferences.clear();
         if (this.telegramSqliteDb && this.telegramSqliteDb !== false) {
           try {
@@ -622887,54 +623224,26 @@ Join: ${newUrl}`);
         }
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
-          const isGroup = msg.chatType !== "private";
-          if (isGroup) {
-            const attentionViewId2 = this.registerTelegramAttentionView(msg, existing.toolContext || toolContext, "active Telegram thread");
-            const decision3 = await this.inferTelegramInteractionDecisionCoalesced(msg, existing.toolContext || toolContext);
-            this.deliverTelegramAttentionDecision(
-              sessionKey,
-              msg,
-              attentionViewId2,
-              decision3,
-              this.telegramMessageIdentitySalienceSignals(msg),
-              this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
-            );
-            this.markLastTelegramUserMessageMode(msg, decision3.shouldReply ? "steering" : "ambient");
-            this.subAgentViewCallbacks?.onWrite(
-              existing.viewId,
-              `live steering: ${decision3.shouldReply ? decision3.route : "no_reply"} (${decision3.source}, confidence ${decision3.confidence.toFixed(2)}): ${decision3.reason}`
-            );
-            if (!decision3.shouldReply) {
-              this.maybeLogTelegramGroupSkip(msg, `live inference: no steering — ${decision3.reason}`);
-              return;
-            }
-          }
-          let mediaContext = "";
-          if (msg.media || msg.replyToMedia) {
-            mediaContext = await this.processMediaContextForMessage(msg);
-          }
-          const steeringText = this.formatTelegramCurrentMessageForPrompt(
-            sessionKey,
-            msg,
-            `Telegram steering message from @${msg.username}`,
-            mediaContext
-          );
-          if (isGroup) {
-            this.markLastTelegramUserMessageMode(msg, "steering");
-          } else {
-            this.recordTelegramUserMessage(msg, "steering", steeringText);
-          }
-          if (existing.runner) {
-            existing.runner.injectUserMessage(steeringText);
-            this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, "mid-conversation steering injected"));
-          } else {
-            existing.pendingMessages.push(steeringText);
-            this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `queued (${existing.pendingMessages.length} pending)`));
-          }
+          await this.enqueueTelegramMessageForExistingSubAgent(msg, existing);
+          return;
+        }
+        this.scheduleTelegramSessionWork(msg, toolContext);
+      }
+      async processTelegramMessageWork(msg, toolContext) {
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const isAdminDM = toolContext === "telegram-admin-dm";
+        const existing = this.subAgents.get(sessionKey);
+        if (existing && !existing.aborted) {
+          await this.enqueueTelegramMessageForExistingSubAgent(msg, existing);
           return;
         }
         const attentionViewId = this.registerTelegramAttentionView(msg, toolContext);
-        const decision2 = await this.inferTelegramInteractionDecisionCoalesced(msg, toolContext);
+        let decision2;
+        try {
+          decision2 = await this.inferTelegramInteractionDecisionCoalesced(msg, toolContext);
+        } catch (err) {
+          decision2 = this.fallbackTelegramRouterDecision(msg, toolContext, err);
+        }
         this.deliverTelegramAttentionDecision(
           sessionKey,
           msg,
@@ -622952,7 +623261,20 @@ Join: ${newUrl}`);
           this.maybeLogTelegramGroupSkip(msg, `live inference: no reply — ${decision2.reason}`);
           return;
         }
-        if (decision2.route === "chat") {
+        const existingAfterDecision = this.subAgents.get(sessionKey);
+        if (existingAfterDecision && !existingAfterDecision.aborted) {
+          this.subAgentViewCallbacks?.onWrite(
+            existingAfterDecision.viewId,
+            `live route consolidated: ${decision2.route} (${decision2.source}, confidence ${decision2.confidence.toFixed(2)}): ${decision2.reason}`
+          );
+          await this.enqueueTelegramMessageForExistingSubAgent(
+            msg,
+            existingAfterDecision
+          );
+          return;
+        }
+        const subAgentProfile = decision2.route === "chat" ? "chat" : "action";
+        if (decision2.route === "chat" && msg.chatType === "private") {
           await this.handleTelegramChatCompletion(msg, toolContext);
           return;
         }
@@ -622993,6 +623315,14 @@ Join: ${newUrl}`);
           this.subAgentViewCallbacks?.onWrite(subAgent.viewId, replyEdge);
         }
         this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `✈ Telegram message from @${msg.username}: ${msg.text}`);
+        const queuedForSameSession = this.takeQueuedTelegramSessionWork(sessionKey);
+        if (queuedForSameSession) {
+          await this.enqueueTelegramMessageForExistingSubAgent(queuedForSameSession.msg, subAgent);
+          this.subAgentViewCallbacks?.onWrite(
+            subAgent.viewId,
+            `merged queued session work (${queuedForSameSession.messageCount} message${queuedForSameSession.messageCount === 1 ? "" : "s"}) before runner start`
+          );
+        }
         if (this.canUseChatActions(msg)) {
           subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
         }
@@ -623005,7 +623335,7 @@ Join: ${newUrl}`);
           if (msg.media || msg.replyToMedia) {
             mediaContext = await this.processMediaContextForMessage(msg);
           }
-          const result = await this.runSubAgent(msg, subAgent, mediaContext);
+          const result = await this.runSubAgent(msg, subAgent, mediaContext, subAgentProfile);
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
             subAgent.typingInterval = null;
@@ -623031,7 +623361,7 @@ Join: ${newUrl}`);
           }
           const finalHtml = convertMarkdownToTelegramHTML(finalText);
           const sentMessageId = await this.sendOrEditFinalTelegramHTML(msg, finalHtml, subAgent.liveMessageId);
-          this.recordTelegramAssistantMessage(msg, finalText, "action", {
+          this.recordTelegramAssistantMessage(msg, finalText, subAgentProfile, {
             messageId: sentMessageId,
             replyToMessageId: msg.chatType !== "private" ? msg.messageId : void 0
           });
@@ -623062,6 +623392,7 @@ Join: ${newUrl}`);
             });
           }
         } finally {
+          this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
           this.subAgentViewCallbacks?.onComplete(subAgent.viewId);
@@ -623172,6 +623503,7 @@ Join: ${newUrl}`);
             });
           }
         } finally {
+          this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
           this.subAgentViewCallbacks?.onComplete(subAgent.viewId);
@@ -657259,10 +657591,12 @@ Log: ${nexusLogPath}`)
     }
     const source = scope === "global" ? globalSettings : projectSettings;
     const mode = source.telegramMode ?? savedSettings.telegramMode ?? "auto";
+    const subAgents = typeof source.telegramSubAgents === "number" ? source.telegramSubAgents : typeof savedSettings.telegramSubAgents === "number" ? savedSettings.telegramSubAgents : 2;
     return {
       key: nonEmptyTelegramSetting(source.telegramKey),
       admin: nonEmptyTelegramSetting(source.telegramAdmin),
       mode,
+      subAgents,
       keyScope: scope
     };
   };
@@ -657872,6 +658206,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
         telegramBridge.setContextWindowSize(resolvedContextWindowSize);
       }
       telegramBridge.setInteractionMode(savedSettings.telegramMode ?? "auto");
+      telegramBridge.setSubAgentLimit(telegramSettingsForScope(scope).subAgents ?? 2);
       telegramBridge.setTelegramToolPolicy(savedSettings.telegramToolPolicy);
       telegramBridge.setMetricsProvider(() => statusBar?.getMetricsSnapshot());
       if (adminId) {
@@ -658006,7 +658341,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           telegramBridge.botUsername,
           adminId,
           savedSettings.telegramMode ?? "auto",
-          telegramBridge.stats.canReadAllGroupMessages
+          telegramBridge.stats.canReadAllGroupMessages,
+          telegramBridge.stats.maxSubAgents
         )
       );
       showPrompt();
@@ -658039,10 +658375,14 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       if (settings.mode !== void 0) {
         target.telegramMode = settings.mode;
       }
+      if (settings.subAgents !== void 0) {
+        target.telegramSubAgents = settings.subAgents;
+      }
       const payload = {
         ...settings.key !== void 0 ? { telegramKey: settings.key } : {},
         ...settings.admin !== void 0 ? { telegramAdmin: settings.admin === null ? "" : settings.admin } : {},
-        ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {}
+        ...settings.mode !== void 0 ? { telegramMode: settings.mode } : {},
+        ...settings.subAgents !== void 0 ? { telegramSubAgents: settings.subAgents } : {}
       };
       if (targetScope === "project") {
         saveProjectSettings(repoRoot, payload);
@@ -658072,10 +658412,16 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       savedSettings.telegramMode = mode;
       telegramBridge?.setInteractionMode(mode);
     },
+    telegramSetSubAgentLimit(limit) {
+      savedSettings.telegramSubAgents = limit;
+      return telegramBridge?.setSubAgentLimit(limit) ?? Math.max(1, Math.min(5, Math.floor(limit)));
+    },
     telegramStatus() {
       const active = telegramBridge?.isActive ?? false;
       const botUser = active ? telegramBridge?.botUsername : void 0;
       const subAgents = active ? telegramBridge?.stats.activeSubAgents : void 0;
+      const maxSubAgents = active ? telegramBridge?.stats.maxSubAgents : telegramSettingsForScope(activeTelegramSettingsScope ?? "project").subAgents ?? 2;
+      const queuedSubAgents = active ? telegramBridge?.stats.queuedSubAgentSessions : 0;
       writeContent(
         () => renderTelegramStatus(
           active,
@@ -658083,7 +658429,9 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           telegramSettingsForScope(activeTelegramSettingsScope ?? "project").admin,
           subAgents,
           savedSettings.telegramMode ?? "auto",
-          active ? telegramBridge?.stats.canReadAllGroupMessages : void 0
+          active ? telegramBridge?.stats.canReadAllGroupMessages : void 0,
+          maxSubAgents,
+          queuedSubAgents
         )
       );
     },

package/npm-shrinkwrap.json

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

package/package.json

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