omnius 1.0.181 → 1.0.183

package/dist/index.js

@@ -550132,11 +550132,17 @@ function injectNoThinkDirective(messages2) {
   const target = messages2[lastUserIdx];
   if (!target || typeof target.content !== "string")
     return messages2;
-  if (/\/no_think\b/i.test(target.content))
+  const hasOllamaNoThink = /\/nothink\b/i.test(target.content);
+  const hasQwenNoThink = /\/no[_-]think\b/i.test(target.content);
+  if (hasOllamaNoThink && hasQwenNoThink)
     return messages2;
+  const suffix = [
+    hasOllamaNoThink ? null : "/nothink",
+    hasQwenNoThink ? null : "/no_think"
+  ].filter(Boolean).join("\n");
   const annotated = `${target.content}
 
-/no_think`;
+${suffix}`;
   return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: annotated } : m2);
 }
 function backendHttpErrorDetail(text) {
@@ -550154,6 +550160,8 @@ function isOllamaModelNotFoundResponse(status, text, model) {
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
     return false;
+  if (process.env["OMNIUS_ENABLE_THINKING"] !== "1")
+    return false;
   if (params.suppressed)
     return false;
   if (params.hasTools)
@@ -550172,18 +550180,9 @@ function computeEffectiveThink(params) {
   return params.defaultThink;
 }
 function sanitizeHistoryThink(messages2) {
-  let lastAsstIdx = -1;
-  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
-    if (messages2[i2]?.role === "assistant") {
-      lastAsstIdx = i2;
-      break;
-    }
-  }
-  return messages2.map((m2, i2) => {
+  return messages2.map((m2) => {
     if (m2.role !== "assistant" || typeof m2.content !== "string")
       return m2;
-    if (i2 === lastAsstIdx)
-      return m2;
     return { ...m2, content: stripThinkBlocks(m2.content) };
   });
 }
@@ -563608,10 +563607,11 @@ ${description}`
         if (effectiveThink === true && (effectiveMaxTokens ?? 0) < 4096) {
           effectiveMaxTokens = 4096;
         }
+        const requestMessages = effectiveThink ? cleanedMessages : injectNoThinkDirective(cleanedMessages);
         const responseFormat = request.responseFormat ?? request.response_format;
         const body = {
           model: this.model,
-          messages: cleanedMessages,
+          messages: requestMessages,
           tools: request.tools,
           temperature: request.temperature,
           max_tokens: effectiveMaxTokens,
@@ -563620,7 +563620,7 @@ ${description}`
         if (responseFormat !== void 0) {
           body["response_format"] = responseFormat;
         }
-        const reqNumCtx = request.numCtx;
+        const reqNumCtx = request.numCtx ?? request.num_ctx;
         if (Number.isFinite(reqNumCtx) && (reqNumCtx ?? 0) > 0) {
           const opts = body["options"] ?? {};
           opts["num_ctx"] = reqNumCtx;
@@ -563701,11 +563701,11 @@ ${description}`
           const responseText = firstChoice ? String(firstChoice.message?.content ?? "") : "";
           const outcome = this.recordThinkOutcome(responseText, effectiveThink === true);
           const independentOutcome = effectiveThink !== true ? classifyThinkOutcome(responseText) : null;
-          const shouldRecoverFromEmpty = responseFormat !== void 0 && independentOutcome !== null && (independentOutcome === "empty_after_strip" || independentOutcome === "unclosed_think");
+          const shouldRecoverFromEmpty = request.disableEmptyContentRecovery !== true && responseFormat !== void 0 && independentOutcome !== null && (independentOutcome === "empty_after_strip" || independentOutcome === "unclosed_think");
           const justSuppressed = this._thinkSuppressed && this._thinkFailStreak === _OllamaAgenticBackend._thinkFailThreshold;
           const shouldRetryThinkGuard = outcome !== null && effectiveThink === true && (justSuppressed || outcome === "empty_after_strip" || outcome === "unclosed_think");
           if (shouldRetryThinkGuard || shouldRecoverFromEmpty) {
-            const retryMessages = injectNoThinkDirective(cleanedMessages);
+            const retryMessages = injectNoThinkDirective(requestMessages);
             const retryBody = {
               model: this.model,
               messages: retryMessages,
@@ -563892,7 +563892,7 @@ ${description}`
        * Ollama pool routing as non-stream completions.
        */
       async *chatCompletionStream(request) {
-        const cleanedMessages = normalizeMessagesForStrictOpenAI(request.messages.map((m2) => m2.role === "assistant" && typeof m2.content === "string" ? { ...m2, content: stripThinkBlocks(m2.content) } : m2));
+        const cleanedMessages = normalizeMessagesForStrictOpenAI(sanitizeHistoryThink(request.messages));
         let effectiveThink = computeEffectiveThink({
           requestThink: request.think,
           defaultThink: this.thinking,
@@ -563907,10 +563907,11 @@ ${description}`
         if (effectiveThink === true && (effectiveMaxTokens ?? 0) < 4096) {
           effectiveMaxTokens = 4096;
         }
+        const requestMessages = effectiveThink ? cleanedMessages : injectNoThinkDirective(cleanedMessages);
         const responseFormat = request.responseFormat ?? request.response_format;
         const body = {
           model: this.model,
-          messages: cleanedMessages,
+          messages: requestMessages,
           tools: request.tools,
           temperature: request.temperature,
           max_tokens: effectiveMaxTokens,
@@ -563921,7 +563922,7 @@ ${description}`
         if (responseFormat !== void 0) {
           body["response_format"] = responseFormat;
         }
-        const reqNumCtx = request.numCtx;
+        const reqNumCtx = request.numCtx ?? request.num_ctx;
         if (Number.isFinite(reqNumCtx) && (reqNumCtx ?? 0) > 0) {
           const opts = body["options"] ?? {};
           opts["num_ctx"] = reqNumCtx;
@@ -564176,6 +564177,57 @@ var init_nexusBackend = __esm({
         this.authKey = authKey || "";
         this.thinking = thinking ?? false;
       }
+      effectiveThink(request) {
+        if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
+          return false;
+        if (process.env["OMNIUS_ENABLE_THINKING"] !== "1")
+          return false;
+        if (Array.isArray(request.tools) && request.tools.length > 0)
+          return false;
+        if (request.think === true)
+          return true;
+        if (request.think === false)
+          return false;
+        return this.thinking === true;
+      }
+      noThinkMessages(messages2) {
+        let lastUserIdx = -1;
+        for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
+          if (messages2[i2]?.role === "user") {
+            lastUserIdx = i2;
+            break;
+          }
+        }
+        if (lastUserIdx < 0)
+          return messages2;
+        const target = messages2[lastUserIdx];
+        if (!target || typeof target.content !== "string")
+          return messages2;
+        const hasOllamaNoThink = /\/nothink\b/i.test(target.content);
+        const hasQwenNoThink = /\/no[_-]think\b/i.test(target.content);
+        if (hasOllamaNoThink && hasQwenNoThink)
+          return messages2;
+        const suffix = [
+          hasOllamaNoThink ? null : "/nothink",
+          hasQwenNoThink ? null : "/no_think"
+        ].filter(Boolean).join("\n");
+        return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: `${target.content}
+
+${suffix}` } : m2);
+      }
+      requestMessages(request, effectiveThink) {
+        return effectiveThink ? request.messages : this.noThinkMessages(request.messages);
+      }
+      applyOptionalRequestFields(daemonArgs, request) {
+        const responseFormat = request.responseFormat ?? request.response_format;
+        if (responseFormat !== void 0) {
+          daemonArgs.response_format = JSON.stringify(responseFormat);
+        }
+        const numCtx = request.numCtx ?? request.num_ctx;
+        if (Number.isFinite(numCtx) && (numCtx ?? 0) > 0) {
+          daemonArgs.num_ctx = String(numCtx);
+        }
+      }
       /** Reset the consecutive failure counter (called on endpoint switch / reconnect) */
       resetFailures() {
         this.consecutiveFailures = 0;
@@ -564191,9 +564243,10 @@ var init_nexusBackend = __esm({
           err.fatal = true;
           throw err;
         }
+        const effectiveThink = this.effectiveThink(request);
         const daemonArgs = {
           model: this.model,
-          messages: JSON.stringify(request.messages),
+          messages: JSON.stringify(this.requestMessages(request, effectiveThink)),
           tools: JSON.stringify(request.tools),
           temperature: String(request.temperature),
           max_tokens: String(request.maxTokens)
@@ -564204,7 +564257,8 @@ var init_nexusBackend = __esm({
         if (this.authKey) {
           daemonArgs.auth_key = this.authKey;
         }
-        daemonArgs.think = String(this.thinking);
+        daemonArgs.think = String(effectiveThink);
+        this.applyOptionalRequestFields(daemonArgs, request);
         let rawResult;
         try {
           rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
@@ -564303,9 +564357,10 @@ var init_nexusBackend = __esm({
       async *chatCompletionStream(request) {
         const streamFile = join97(tmpdir18(), `nexus-stream-${randomBytes19(6).toString("hex")}.jsonl`);
         writeFileSync38(streamFile, "", "utf8");
+        const effectiveThink = this.effectiveThink(request);
         const daemonArgs = {
           model: this.model,
-          messages: JSON.stringify(request.messages),
+          messages: JSON.stringify(this.requestMessages(request, effectiveThink)),
           tools: JSON.stringify(request.tools),
           temperature: String(request.temperature),
           max_tokens: String(request.maxTokens),
@@ -564315,7 +564370,8 @@ var init_nexusBackend = __esm({
           daemonArgs.target_peer = this.targetPeer;
         if (this.authKey)
           daemonArgs.auth_key = this.authKey;
-        daemonArgs.think = String(this.thinking);
+        daemonArgs.think = String(effectiveThink);
+        this.applyOptionalRequestFields(daemonArgs, request);
         let rawResult;
         try {
           rawResult = await this.sendFn("remote_infer", daemonArgs, request.timeoutMs || 12e4);
@@ -629145,12 +629201,36 @@ function telegramRouterTimeoutMs(configTimeoutMs, minMs = 1e4, maxMs) {
     10
   );
   const floor = Number.isFinite(minMs) && minMs > 0 ? minMs : 1e4;
-  const configuredCap = Number.isFinite(envRaw) && envRaw >= floor ? envRaw : 9e4;
+  const configuredCap = Number.isFinite(envRaw) && envRaw >= floor ? envRaw : 3e4;
   const callerCap = Number.isFinite(maxMs) && (maxMs ?? 0) >= floor ? maxMs : configuredCap;
   const cap = Math.max(floor, Math.min(configuredCap, callerCap));
   const requested = Number.isFinite(configTimeoutMs) && (configTimeoutMs ?? 0) > 0 ? configTimeoutMs : cap;
   return Math.max(floor, Math.min(requested, cap));
 }
+function telegramRouterErrorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function compactTelegramRouterDiagnosticText(text, maxLength = 220) {
+  const compact3 = text.replace(/\s+/g, " ").trim();
+  return compact3.length > maxLength ? `${compact3.slice(0, Math.max(0, maxLength - 3))}...` : compact3;
+}
+function telegramRouterErrorLooksLikeTimeout(err) {
+  const text = telegramRouterErrorText(err);
+  return /\b(timeout|timed out|ETIMEDOUT)\b|aborted due to timeout|stream timeout/i.test(text);
+}
+function telegramRouterErrorLooksLikeBackendLiveness(err) {
+  const text = telegramRouterErrorText(err);
+  return telegramRouterErrorLooksLikeTimeout(err) || /fetch failed|ECONNREFUSED|ECONNRESET|EHOSTUNREACH|ENETUNREACH|ECONNABORTED|socket hang up|terminated|network error/i.test(text);
+}
+function telegramRouterDiagnosticAttemptLooksLikeTimeout(attempt) {
+  return attempt.status === "threw" && telegramRouterErrorLooksLikeTimeout(attempt.error ?? "");
+}
+function telegramRouterDiagnosticAttemptLooksLikeBackendLiveness(attempt) {
+  return attempt.status === "threw" && telegramRouterErrorLooksLikeBackendLiveness(attempt.error ?? "");
+}
+function telegramRouterDiagnosticIsDualEmptyVisible(diag) {
+  return diag.jsonModeStatus === "empty-after-strip" && diag.plainStatus === "empty-after-strip";
+}
 function telegramThinkSuppressedRequest(request) {
   const messages2 = Array.isArray(request.messages) ? request.messages.slice() : [];
   let appended = false;
@@ -629158,18 +629238,24 @@ function telegramThinkSuppressedRequest(request) {
     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)) {
+    const hasOllamaNoThink = /\/nothink\b/i.test(content);
+    const hasQwenNoThink = /\/no[_-]think\b/i.test(content);
+    if (hasOllamaNoThink && hasQwenNoThink) {
       appended = true;
       break;
     }
-    messages2[i2] = { ...m2, content: content.endsWith("\n") ? `${content}/no_think` : `${content}
+    const suffix = [
+      hasOllamaNoThink ? null : "/nothink",
+      hasQwenNoThink ? null : "/no_think"
+    ].filter(Boolean).join("\n");
+    messages2[i2] = { ...m2, content: content.endsWith("\n") ? `${content}${suffix}` : `${content}
 
-/no_think` };
+${suffix}` };
     appended = true;
     break;
   }
   if (!appended) {
-    messages2.push({ role: "user", content: "/no_think" });
+    messages2.push({ role: "user", content: "/nothink\n/no_think" });
   }
   return { ...request, messages: messages2, think: false };
 }
@@ -631267,10 +631353,14 @@ Telegram link integrity contract:
        * capacity and flood the TUI.
        */
       telegramActiveWorkSessions = /* @__PURE__ */ new Set();
+      telegramActiveWorkGenerations = /* @__PURE__ */ new Map();
+      telegramActiveWorkStartedAtMs = /* @__PURE__ */ new Map();
       /** Queued Telegram sessions waiting for a global work slot. */
       telegramQueuedSessionWork = /* @__PURE__ */ new Map();
       telegramDispatchQueuedTimer = null;
       telegramDispatchQueuedAtMs = 0;
+      telegramQueueDiagnosticLastAtMs = 0;
+      telegramPollWarningLastAtMs = 0;
       /** Lightweight chat history by chat/guest session key */
       chatHistory = /* @__PURE__ */ new Map();
       /** Participant and tone state by chat/guest session key */
@@ -631906,6 +631996,63 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         if (!Number.isFinite(parsed)) return 350;
         return Math.max(0, Math.min(2e3, Math.floor(parsed)));
       }
+      telegramQueueDiagnosticIntervalMs() {
+        const raw = Number.parseInt(process.env["OMNIUS_TG_QUEUE_DIAGNOSTIC_MS"] ?? "", 10);
+        if (Number.isFinite(raw) && raw >= 5e3 && raw <= 3e5) return raw;
+        return 3e4;
+      }
+      maybeLogTelegramQueueDiagnostic(reason) {
+        if (this.telegramQueuedSessionWork.size === 0) return;
+        const now = Date.now();
+        const interval = this.telegramQueueDiagnosticIntervalMs();
+        if (now - this.telegramQueueDiagnosticLastAtMs < interval) return;
+        this.telegramQueueDiagnosticLastAtMs = now;
+        const queued = [...this.telegramQueuedSessionWork.values()].sort((a2, b) => a2.enqueuedAtMs - b.enqueuedAtMs).slice(0, 4).map((work) => {
+          const age = formatTelegramPipelineDuration(now - work.enqueuedAtMs);
+          const live = this.telegramSessionIsLive(work.sessionKey) ? "blocked:same-session-live" : "ready";
+          return `${work.sessionKey} age=${age} bundled=${work.messageCount} ${live}`;
+        });
+        const active = [...this.activeTelegramInteractionSessionKeys()].slice(0, 6);
+        const inferences = this.getTelegramActiveInferences().slice(0, 4).map((inf) => `${inf.id}/${inf.kind}/${inf.model} elapsed=${inf.elapsedSec.toFixed(1)}s ttfb=${inf.ttfbSec === void 0 ? "waiting" : `${inf.ttfbSec.toFixed(1)}s`}`);
+        this.tuiWrite(() => renderTelegramSubAgentEvent(
+          "queue",
+          `queue diagnostic (${reason}): active ${this.activeTelegramInteractionCount()}/${this.getSubAgentLimit()} [${active.join(", ") || "none"}]; queued ${this.telegramQueuedSessionWork.size} [${queued.join(" | ")}]; inferences [${inferences.join(" | ") || "none"}]`
+        ));
+      }
+      nextTelegramWorkGeneration(sessionKey) {
+        const generation = (this.telegramActiveWorkGenerations.get(sessionKey) ?? 0) + 1;
+        this.telegramActiveWorkGenerations.set(sessionKey, generation);
+        return generation;
+      }
+      telegramWorkGenerationIsCurrent(sessionKey, generation) {
+        return this.telegramActiveWorkGenerations.get(sessionKey) === generation;
+      }
+      telegramPreAgentWorkMaxIdleMs() {
+        const routerMs = telegramRouterTimeoutMs(this.agentConfig?.timeoutMs);
+        const raw = Number.parseInt(process.env["OMNIUS_TG_PRE_AGENT_MAX_IDLE_MS"] ?? "", 10);
+        if (Number.isFinite(raw) && raw >= 3e4 && raw <= 9e5) return raw;
+        return Math.max(12e4, routerMs + 3e4);
+      }
+      reapStaleTelegramPreAgentWork() {
+        const now = Date.now();
+        const maxIdleMs = this.telegramPreAgentWorkMaxIdleMs();
+        for (const sessionKey of [...this.telegramActiveWorkSessions]) {
+          if (this.subAgents.has(sessionKey) || this.activeChatSessions.has(sessionKey)) continue;
+          const startedAt2 = this.telegramActiveWorkStartedAtMs.get(sessionKey);
+          if (!startedAt2) continue;
+          const idleMs = now - startedAt2;
+          if (idleMs <= maxIdleMs) continue;
+          const generation = this.telegramActiveWorkGenerations.get(sessionKey) ?? 0;
+          this.telegramActiveWorkGenerations.set(sessionKey, generation + 1);
+          this.telegramActiveWorkSessions.delete(sessionKey);
+          this.telegramActiveWorkStartedAtMs.delete(sessionKey);
+          this.refreshActiveTelegramInteractionCount();
+          this.tuiWrite(() => renderTelegramSubAgentEvent(
+            "queue",
+            `watchdog: released stale pre-agent Telegram work pin for ${sessionKey} after ${Math.round(idleMs / 1e3)}s; queued messages may dispatch now`
+          ));
+        }
+      }
       dispatchQueuedTelegramSessionWorkSoon(delayMs = 0) {
         const dueAt = Date.now() + Math.max(0, delayMs);
         if (this.telegramDispatchQueuedTimer && this.telegramDispatchQueuedAtMs <= dueAt) return;
@@ -631935,6 +632082,9 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
             this.dispatchQueuedTelegramSessionWorkSoon(Math.max(0, nextDue - Date.now()));
           }
         }
+        if (this.telegramQueuedSessionWork.size > 0) {
+          this.maybeLogTelegramQueueDiagnostic("dispatch");
+        }
         this.refreshActiveTelegramInteractionCount();
       }
       buildTelegramQueuedSessionWork(sessionKey, msg, toolContext, now) {
@@ -631978,11 +632128,16 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           return;
         }
         this.telegramActiveWorkSessions.add(work.sessionKey);
+        this.telegramActiveWorkStartedAtMs.set(work.sessionKey, Date.now());
+        const generation = this.nextTelegramWorkGeneration(work.sessionKey);
         this.refreshActiveTelegramInteractionCount();
-        void this.processTelegramMessageWork(work).catch((err) => {
+        void this.processTelegramMessageWork(work, generation).catch((err) => {
           this.tuiWrite(() => renderWarning(`Telegram sub-agent error: ${err instanceof Error ? err.message : String(err)}`));
         }).finally(() => {
-          this.telegramActiveWorkSessions.delete(work.sessionKey);
+          if (this.telegramWorkGenerationIsCurrent(work.sessionKey, generation)) {
+            this.telegramActiveWorkSessions.delete(work.sessionKey);
+            this.telegramActiveWorkStartedAtMs.delete(work.sessionKey);
+          }
           this.refreshActiveTelegramInteractionCount();
           this.dispatchQueuedTelegramSessionWorkSoon();
         });
@@ -635217,7 +635372,7 @@ ${lines.join("\n")}`);
           `Current Telegram message text (untrusted user data):
 ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           "",
-          "/no_think"
+          "/nothink\n/no_think"
         ].filter(Boolean).join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(
@@ -635251,11 +635406,25 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
       async telegramRouterJsonCompletion(backend, request, diagnostics, inferenceKind = "router", sessionKey = "__router__") {
         let jsonModeResult;
         let jsonModeError;
+        const recordAttempt = (attempt) => {
+          if (!diagnostics) return;
+          diagnostics.attempts ??= [];
+          diagnostics.attempts.push({
+            stage: inferenceKind,
+            ...attempt
+          });
+        };
         const suppressed = telegramThinkSuppressedRequest(request);
+        const requestTimeoutMs = Number.isFinite(suppressed.timeoutMs) && (suppressed.timeoutMs ?? 0) > 0 ? suppressed.timeoutMs : void 0;
+        const jsonStartMs = Date.now();
         try {
           jsonModeResult = await this.telegramObservableInference(
             backend,
-            { ...suppressed, responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT },
+            {
+              ...suppressed,
+              responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT,
+              disableEmptyContentRecovery: true
+            },
             inferenceKind,
             sessionKey,
             { stream: false, reason: "router-json" }
@@ -635265,16 +635434,49 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           );
           if (visible) {
             if (diagnostics) diagnostics.jsonModeStatus = "visible";
+            recordAttempt({
+              mode: "json-mode",
+              status: "visible",
+              elapsedMs: Date.now() - jsonStartMs,
+              timeoutMs: requestTimeoutMs
+            });
             return jsonModeResult;
           }
           if (diagnostics) diagnostics.jsonModeStatus = "empty-after-strip";
+          recordAttempt({
+            mode: "json-mode",
+            status: "empty-after-strip",
+            elapsedMs: Date.now() - jsonStartMs,
+            timeoutMs: requestTimeoutMs
+          });
         } catch (err) {
           jsonModeError = err;
           if (diagnostics) {
             diagnostics.jsonModeStatus = "threw";
-            diagnostics.jsonModeError = err instanceof Error ? err.message : String(err);
+            diagnostics.jsonModeError = telegramRouterErrorText(err);
+          }
+          recordAttempt({
+            mode: "json-mode",
+            status: "threw",
+            error: telegramRouterErrorText(err),
+            elapsedMs: Date.now() - jsonStartMs,
+            timeoutMs: requestTimeoutMs
+          });
+          if (telegramRouterErrorLooksLikeBackendLiveness(err)) {
+            if (diagnostics) {
+              diagnostics.plainStatus = "skipped";
+              diagnostics.plainError = "skipped because json-mode backend liveness failed";
+            }
+            recordAttempt({
+              mode: "plain-retry",
+              status: "skipped",
+              error: "skipped because json-mode backend liveness failed",
+              timeoutMs: requestTimeoutMs
+            });
+            throw err;
           }
         }
+        const plainStartMs = Date.now();
         try {
           const plainResult = await this.telegramObservableInference(
             backend,
@@ -635288,13 +635490,26 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
               (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
             );
             diagnostics.plainStatus = plainVisible ? "visible" : "empty-after-strip";
+            recordAttempt({
+              mode: "plain-retry",
+              status: plainVisible ? "visible" : "empty-after-strip",
+              elapsedMs: Date.now() - plainStartMs,
+              timeoutMs: requestTimeoutMs
+            });
           }
           return plainResult;
         } catch (err) {
           if (diagnostics) {
             diagnostics.plainStatus = "threw";
-            diagnostics.plainError = err instanceof Error ? err.message : String(err);
+            diagnostics.plainError = telegramRouterErrorText(err);
           }
+          recordAttempt({
+            mode: "plain-retry",
+            status: "threw",
+            error: telegramRouterErrorText(err),
+            elapsedMs: Date.now() - plainStartMs,
+            timeoutMs: requestTimeoutMs
+          });
           if (jsonModeError instanceof Error && !(err instanceof Error)) throw jsonModeError;
           throw err;
         }
@@ -635624,7 +635839,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           `Original router output:`,
           rawPreview,
           ``,
-          `/no_think`
+          `/nothink
+/no_think`
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
@@ -635637,8 +635853,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 800,
-            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 2e4),
+            maxTokens: 500,
+            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 15e3),
             think: false
           }, diagnostics, "router-repair", sessionKey);
           const repairedText = result.choices[0]?.message?.content ?? "";
@@ -635667,7 +635883,7 @@ ${repairedText}`,
         } catch (err) {
           if (diagnostics) {
             diagnostics.repairStatus = "threw";
-            diagnostics.repairError = err instanceof Error ? err.message : String(err);
+            diagnostics.repairError = telegramRouterErrorText(err);
           }
           return null;
         }
@@ -635691,7 +635907,8 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
           `Router context (trailing-window):`,
           trimmedUserPrompt,
           ``,
-          `/no_think`
+          `/nothink
+/no_think`
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
@@ -635704,8 +635921,8 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 1e3,
-            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 1e4, 3e4),
+            maxTokens: 500,
+            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 15e3),
             think: false
           }, diagnostics, "router-strict-retry", sessionKey);
           const retryText = result.choices[0]?.message?.content ?? "";
@@ -635733,7 +635950,7 @@ ${retryText}`,
         } catch (err) {
           if (diagnostics) {
             diagnostics.strictRetryStatus = "threw";
-            diagnostics.strictRetryError = err instanceof Error ? err.message : String(err);
+            diagnostics.strictRetryError = telegramRouterErrorText(err);
           }
           return null;
         }
@@ -635899,6 +636116,7 @@ ${retryText}`,
        * never fires.
        */
       reapStaleTelegramSubAgents() {
+        this.reapStaleTelegramPreAgentWork();
         const maxIdleMs = this.telegramSubAgentMaxIdleMs();
         const now = Date.now();
         const stale = [];
@@ -635919,6 +636137,7 @@ ${retryText}`,
             clearInterval(agent.typingInterval);
             agent.typingInterval = null;
           }
+          this.stopTelegramPublicProgressMessage(agent);
           try {
             agent.runner?.abort?.();
           } catch {
@@ -635938,6 +636157,10 @@ ${retryText}`,
           this.subAgentViewCallbacks?.onStatus(agent.viewId, "failed");
           this.subAgentViewCallbacks?.onComplete(agent.viewId);
         }
+        if (this.telegramQueuedSessionWork.size > 0) {
+          this.maybeLogTelegramQueueDiagnostic("watchdog");
+          this.dispatchQueuedTelegramSessionWorkSoon();
+        }
       }
       async inferTelegramInteractionDecision(msg, toolContext) {
         const config = this.agentConfig;
@@ -636124,10 +636347,10 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             ],
             tools: [],
             temperature: 0,
-            // Minimal route JSON should fit comfortably; keeping this small avoids
-            // reintroducing truncated-note repair cascades.
-            maxTokens: 900,
-            timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
+            // Router JSON is tiny. Keep the answer budget tight so Qwen-class
+            // models cannot spend a minute producing hidden <think>-only output.
+            maxTokens: 360,
+            timeoutMs: telegramRouterTimeoutMs(config.timeoutMs, 8e3, 3e4),
             think: false
           }, diagnostics, "router", sessionKey);
           const text = result.choices[0]?.message?.content ?? "";
@@ -636182,8 +636405,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
                 ],
                 tools: [],
                 temperature: 0,
-                maxTokens: 1400,
-                timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
+                maxTokens: 700,
+                timeoutMs: telegramRouterTimeoutMs(config.timeoutMs, 8e3, 3e4),
                 think: false
               }, diagnostics, "router", sessionKey);
               const reissuedText = reissued.choices[0]?.message?.content ?? "";
@@ -636196,7 +636419,14 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             } catch {
             }
           }
-          const repaired = await this.repairTelegramInteractionDecision(
+          const dualEmptyVisible = telegramRouterDiagnosticIsDualEmptyVisible(diagnostics) && !telegramRouterRawPreview(text);
+          if (dualEmptyVisible) {
+            if (diagnostics.repairStatus === void 0) {
+              diagnostics.repairStatus = "skipped";
+              diagnostics.repairError = "router returned no visible text in json-mode or plain retry; repair/strict retry would only burn more inference";
+            }
+          }
+          const repaired = dualEmptyVisible ? null : await this.repairTelegramInteractionDecision(
             backend,
             text,
             forcedRoute,
@@ -636207,7 +636437,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           if (repaired) {
             return withRouterTelemetry(this.applyTelegramSilentReflectionNotes(repaired, reflectionNotes));
           }
-          const strictRetry = await this.retryTelegramInteractionDecisionStrict(
+          const strictRetry = dualEmptyVisible ? null : await this.retryTelegramInteractionDecisionStrict(
             backend,
             userPrompt,
             text,
@@ -636221,20 +636451,21 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           }
           const invalidRouterPreview = telegramRouterRawPreview(text);
           const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
+          const backendLivenessFailure = (diagnostics.attempts ?? []).some(telegramRouterDiagnosticAttemptLooksLikeBackendLiveness) || telegramRouterErrorLooksLikeBackendLiveness(diagnostics.repairError ?? "") || telegramRouterErrorLooksLikeBackendLiveness(diagnostics.strictRetryError ?? "");
           const fallback = this.applyTelegramSilentReflectionNotes(this.buildTelegramRouterUnavailableDecision(msg, toolContext, {
-            reason: "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
+            reason: backendLivenessFailure ? "router recovery hit a backend liveness failure; no model-derived reply decision" : dualEmptyVisible ? "router returned no visible decision content in JSON or plain mode; no model-derived reply decision" : "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
             silentDisposition: reflectionNotes.silentDisposition,
             diagnosticNote: this.composeTelegramRouterDiagnosticNote(
               invalidRouterPreview,
               failureNarrative,
-              invalidRouterPreview ? "router produced an invalid attention decision payload; repair and strict retry did not recover it" : "router produced an empty attention decision payload; strict retry did not recover it"
+              backendLivenessFailure ? "router backend failed during attention-decision recovery; no usable router decision was available" : dualEmptyVisible ? "router returned no visible decision content in JSON or plain mode; repair/strict retry skipped" : invalidRouterPreview ? "router produced an invalid attention decision payload; repair and strict retry did not recover it" : "router produced an empty attention decision payload; strict retry did not recover it"
             ),
             raw: text
           }), reflectionNotes);
           return withRouterTelemetry(fallback);
         } catch (err) {
           const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
-          const errMsg = err instanceof Error ? err.message : String(err);
+          const errMsg = telegramRouterErrorText(err);
           const fallback = this.applyTelegramSilentReflectionNotes(this.buildTelegramRouterUnavailableDecision(msg, toolContext, {
             reason: `router inference failed; no model-derived reply decision (${errMsg.slice(0, 160)})`,
             silentDisposition: reflectionNotes.silentDisposition,
@@ -636247,46 +636478,93 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
           return withRouterTelemetry(fallback);
         }
       }
+      formatTelegramRouterAttemptTrace(attempt) {
+        const elapsed = Number.isFinite(attempt.elapsedMs) ? ` elapsedMs=${Math.max(0, Math.round(attempt.elapsedMs ?? 0))}` : "";
+        const timeout2 = Number.isFinite(attempt.timeoutMs) ? ` timeoutMs=${Math.max(0, Math.round(attempt.timeoutMs ?? 0))}` : "";
+        const error = attempt.error ? ` (${compactTelegramRouterDiagnosticText(attempt.error, 180)})` : "";
+        return `${attempt.stage}/${attempt.mode}: ${attempt.status}${error}${elapsed}${timeout2}`;
+      }
+      telegramRouterBackendLivenessHint(timeoutSeen) {
+        const backendType = this.agentConfig?.backendType ?? "backend";
+        if (backendType === "ollama") {
+          return timeoutSeen ? "local Ollama did not return router tokens within the liveness window; likely queue backlog, cold model load, GPU/RAM contention, or a wedged runner. JSON repair cannot recover until the backend responds" : "local Ollama request failed before router content was available; check Ollama reachability, model availability, and runner health";
+        }
+        return timeoutSeen ? `${backendType} backend did not return router tokens within the liveness window; check provider latency, rate limits, and request queue depth` : `${backendType} backend request failed before router content was available; check provider reachability and rate limits`;
+      }
       /**
        * Reduce captured per-step diagnostics into:
        *   - `summary`: a short outcome-level diagnostic
        *   - `detail`: a longer ordered trace for operator debugging
-       *   - `operatorHint`: an operational hint (e.g. "ollama backend appears to be injecting <think> tags despite think:false")
+       *   - `operatorHint`: an operational hint with backend/model context
        */
       summarizeTelegramRouterFailure(diag) {
         const parts = [];
         const detailParts = [];
         let thinkInjectionSuspected = false;
         let networkErrorSeen = false;
-        if (diag.jsonModeStatus === "threw") {
-          parts.push(`json-mode call threw`);
-          detailParts.push(`json-mode: threw (${diag.jsonModeError ?? "no detail"})`);
-          networkErrorSeen = true;
-        } else if (diag.jsonModeStatus === "empty-after-strip") {
-          parts.push(`json-mode returned empty content (likely <think>-only)`);
-          detailParts.push(`json-mode: empty-after-strip`);
-          thinkInjectionSuspected = true;
-        } else if (diag.jsonModeStatus === "visible") {
-          detailParts.push(`json-mode: visible`);
-        }
-        if (diag.plainStatus === "threw") {
-          parts.push(`plain call threw`);
-          detailParts.push(`plain: threw (${diag.plainError ?? "no detail"})`);
-          networkErrorSeen = true;
-        } else if (diag.plainStatus === "empty-after-strip") {
-          parts.push(`plain call returned empty content`);
-          detailParts.push(`plain: empty-after-strip`);
-          thinkInjectionSuspected = true;
-        } else if (diag.plainStatus === "visible") {
-          detailParts.push(`plain: visible-but-unparseable`);
+        let timeoutSeen = false;
+        const attempts = diag.attempts ?? [];
+        if (attempts.length > 0) {
+          const livenessAttempts = attempts.filter(telegramRouterDiagnosticAttemptLooksLikeBackendLiveness);
+          const timeoutAttempts = attempts.filter(telegramRouterDiagnosticAttemptLooksLikeTimeout);
+          const emptyAttempts = attempts.filter((attempt) => attempt.status === "empty-after-strip");
+          const visibleAttempts = attempts.filter((attempt) => attempt.status === "visible");
+          const skippedAttempts = attempts.filter((attempt) => attempt.status === "skipped");
+          networkErrorSeen = livenessAttempts.length > 0;
+          timeoutSeen = timeoutAttempts.length > 0;
+          thinkInjectionSuspected = emptyAttempts.length > 0;
+          if (livenessAttempts.length > 0) {
+            const affected = livenessAttempts.map((attempt) => `${attempt.stage}/${attempt.mode}`).join(", ");
+            parts.push(timeoutSeen ? `backend timeout/liveness failure during ${affected}` : `backend liveness failure during ${affected}`);
+          }
+          if (emptyAttempts.length > 0) {
+            const affected = emptyAttempts.map((attempt) => `${attempt.stage}/${attempt.mode}`).join(", ");
+            parts.push(`empty visible content after <think> strip during ${affected}`);
+          }
+          if (visibleAttempts.length > 0 && diag.repairStatus !== "recovered" && diag.strictRetryStatus !== "recovered") {
+            parts.push(`visible router text remained unparseable`);
+          }
+          if (skippedAttempts.length > 0) {
+            const affected = skippedAttempts.map((attempt) => `${attempt.stage}/${attempt.mode}`).join(", ");
+            parts.push(`fallback attempt skipped during ${affected}`);
+          }
+          detailParts.push(...attempts.map((attempt) => this.formatTelegramRouterAttemptTrace(attempt)));
+        } else {
+          if (diag.jsonModeStatus === "threw") {
+            parts.push(`json-mode call threw`);
+            detailParts.push(`json-mode: threw (${diag.jsonModeError ?? "no detail"})`);
+            networkErrorSeen = true;
+            timeoutSeen = telegramRouterErrorLooksLikeTimeout(diag.jsonModeError ?? "");
+          } else if (diag.jsonModeStatus === "empty-after-strip") {
+            parts.push(`json-mode returned empty content (likely <think>-only)`);
+            detailParts.push(`json-mode: empty-after-strip`);
+            thinkInjectionSuspected = true;
+          } else if (diag.jsonModeStatus === "visible") {
+            detailParts.push(`json-mode: visible`);
+          }
+          if (diag.plainStatus === "threw") {
+            parts.push(`plain call threw`);
+            detailParts.push(`plain: threw (${diag.plainError ?? "no detail"})`);
+            networkErrorSeen = true;
+            timeoutSeen ||= telegramRouterErrorLooksLikeTimeout(diag.plainError ?? "");
+          } else if (diag.plainStatus === "empty-after-strip") {
+            parts.push(`plain call returned empty content`);
+            detailParts.push(`plain: empty-after-strip`);
+            thinkInjectionSuspected = true;
+          } else if (diag.plainStatus === "visible") {
+            detailParts.push(`plain: visible-but-unparseable`);
+          }
         }
         if (diag.repairStatus === "skipped") {
           detailParts.push(`repair: skipped (${diag.repairError ?? "no recoverable input"})`);
+        } else if (diag.repairStatus === "skipped-truncation-rerun") {
+          detailParts.push(`repair: skipped for truncation rerun`);
         } else if (diag.repairStatus === "no-recoverable-output") {
           detailParts.push(`repair: returned non-recoverable JSON`);
         } else if (diag.repairStatus === "threw") {
           detailParts.push(`repair: threw (${diag.repairError ?? "no detail"})`);
           networkErrorSeen = true;
+          timeoutSeen ||= telegramRouterErrorLooksLikeTimeout(diag.repairError ?? "");
         } else if (diag.repairStatus === "recovered") {
           detailParts.push(`repair: recovered`);
         }
@@ -636298,14 +636576,15 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         } else if (diag.strictRetryStatus === "threw") {
           detailParts.push(`strict-retry: threw (${diag.strictRetryError ?? "no detail"})`);
           networkErrorSeen = true;
+          timeoutSeen ||= telegramRouterErrorLooksLikeTimeout(diag.strictRetryError ?? "");
         } else if (diag.strictRetryStatus === "recovered") {
           detailParts.push(`strict-retry: recovered`);
         }
         let operatorHint;
         if (networkErrorSeen) {
-          operatorHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
+          operatorHint = this.telegramRouterBackendLivenessHint(timeoutSeen);
         } else if (thinkInjectionSuspected) {
-          operatorHint = "router model emitted <think>-only or unclosed-think output; conversation continuity preserved but inference is degraded";
+          operatorHint = "router model emitted <think>-only or unclosed-think output despite think suppression; visible decision content was empty after stripping hidden reasoning";
         }
         return {
           summary: parts.join("; "),
@@ -636321,7 +636600,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         if (invalidRouterPreview) segments.push(`invalid router output preview: ${invalidRouterPreview}`);
         if (failureNarrative.detail) segments.push(`router-failure trace: ${failureNarrative.detail}`);
         if (failureNarrative.operatorHint) segments.push(failureNarrative.operatorHint);
-        return segments.join(" | ").slice(0, 900);
+        return segments.join(" | ").slice(0, 1400);
       }
       buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
         if (!this.repoRoot) return "";
@@ -636754,6 +637033,7 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         for (const [, agent] of this.subAgents) {
           agent.aborted = true;
           if (agent.typingInterval) clearInterval(agent.typingInterval);
+          this.stopTelegramPublicProgressMessage(agent);
           try {
             agent.runner?.abort?.();
           } catch {
@@ -636769,6 +637049,8 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
         }
         this.telegramQueuedSessionWork.clear();
         this.telegramActiveWorkSessions.clear();
+        this.telegramActiveWorkGenerations.clear();
+        this.telegramActiveWorkStartedAtMs.clear();
         this.telegramAdminLivePanels.clear();
         this.flushTelegramViewWrites();
         this.flushTelegramTuiWrites();
@@ -636955,6 +637237,62 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           }
         }
       }
+      shouldUseTelegramPublicProgressMessage(msg, toolContext) {
+        return toolContext === "telegram-public" && msg.chatType !== "private" && !msg.guestQueryId;
+      }
+      renderTelegramPublicProgressHTML(subAgent, msg, phase) {
+        const elapsedSec = Math.max(0, Math.floor((Date.now() - subAgent.startedAtMs) / 1e3));
+        const sessionKey = this.sessionKeyForMessage(msg);
+        const activeInference = this.getTelegramActiveInferences().find((inf) => inf.sessionKey === sessionKey);
+        const status = activeInference ? activeInference.ttfbSec === void 0 ? `model request active; waiting for first token (${activeInference.kind}, ${activeInference.elapsedSec.toFixed(1)}s)` : `streaming ${activeInference.kind}; content=${activeInference.contentTokens}t thinking=${activeInference.thinkingTokens}t` : phase;
+        const width = 12;
+        const filled = Math.min(width, Math.floor(elapsedSec % 60 / 60 * width));
+        const bar = `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
+        return [
+          `<b>Working</b>`,
+          `<code>${bar}</code> ${elapsedSec}s`,
+          `<i>${escapeTelegramHTML(status)}</i>`
+        ].join("\n");
+      }
+      startTelegramPublicProgressMessage(subAgent, msg, phase) {
+        if (!this.shouldUseTelegramPublicProgressMessage(msg, subAgent.toolContext)) return;
+        if (subAgent.publicProgressTimer) return;
+        const update2 = () => {
+          if (subAgent.aborted) return;
+          if (!this.subAgents.has(this.sessionKeyForMessage(msg))) return;
+          const html = this.renderTelegramPublicProgressHTML(subAgent, msg, phase);
+          if (subAgent.liveMessageId) {
+            const now = Date.now();
+            if (now - subAgent.lastEditMs < 3e3) return;
+            subAgent.lastEditMs = now;
+            void this.editLiveMessage(msg.chatId, subAgent.liveMessageId, html).catch(() => {
+            });
+            return;
+          }
+          if (subAgent.liveMessagePromise) return;
+          subAgent.liveMessagePromise = this.sendLiveMessage(
+            msg.chatId,
+            html,
+            msg.chatType !== "private" ? msg.messageId : void 0
+          ).then((id) => {
+            subAgent.liveMessageId = id;
+            subAgent.lastEditMs = Date.now();
+          }).catch(() => {
+          }).finally(() => {
+            subAgent.liveMessagePromise = null;
+          });
+        };
+        update2();
+        subAgent.publicProgressTimer = setInterval(update2, 5e3);
+        if (typeof subAgent.publicProgressTimer.unref === "function") {
+          subAgent.publicProgressTimer.unref();
+        }
+      }
+      stopTelegramPublicProgressMessage(subAgent) {
+        if (!subAgent.publicProgressTimer) return;
+        clearInterval(subAgent.publicProgressTimer);
+        subAgent.publicProgressTimer = null;
+      }
       ensureTelegramAdminLivePanel(subAgent, msg) {
         const existing = subAgent.adminLivePanelNonce ? this.telegramAdminLivePanels.get(subAgent.adminLivePanelNonce) : void 0;
         if (existing) return existing;
@@ -637213,11 +637551,12 @@ Join: ${newUrl}`);
         }
         this.scheduleTelegramSessionWork(msg, toolContext);
       }
-      async processTelegramMessageWork(work) {
+      async processTelegramMessageWork(work, workGeneration) {
         const msg = work.msg;
         const toolContext = work.toolContext;
         const sessionKey = this.sessionKeyForMessage(msg);
         const isAdminDM = toolContext === "telegram-admin-dm";
+        if (!this.telegramWorkGenerationIsCurrent(sessionKey, workGeneration)) return;
         const existing = this.subAgents.get(sessionKey);
         if (existing && !existing.aborted) {
           await this.enqueueTelegramQueuedSessionWorkForExistingSubAgent(work, existing);
@@ -637235,6 +637574,13 @@ Join: ${newUrl}`);
         } catch (err) {
           decision2 = this.fallbackTelegramRouterDecision(msg, toolContext, err);
         }
+        if (!this.telegramWorkGenerationIsCurrent(sessionKey, workGeneration)) {
+          this.tuiWrite(() => renderTelegramSubAgentEvent(
+            msg.username,
+            `discarded stale Telegram work result after queue pin release for ${sessionKey}`
+          ));
+          return;
+        }
         const storedPreference = this.applyTelegramReplyPreferenceUpdate(
           sessionKey,
           msg,
@@ -637352,6 +637698,7 @@ Join: ${newUrl}`);
         if (replyEdge) {
           this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, replyEdge));
         }
+        this.startTelegramPublicProgressMessage(subAgent, msg, "taking notes and preparing tools");
         try {
           let mediaContext = "";
           if (msg.media || msg.replyToMedia) {
@@ -637368,6 +637715,7 @@ Join: ${newUrl}`);
             clearInterval(subAgent.typingInterval);
             subAgent.typingInterval = null;
           }
+          this.stopTelegramPublicProgressMessage(subAgent);
           const finalText = cleanTelegramVisibleReply(result || "");
           if (isAdminDM && !this.telegramAdminRunCompleted(subAgent)) {
             const incompleteText = this.telegramAdminIncompleteRunText(subAgent, finalText);
@@ -637436,6 +637784,7 @@ Join: ${newUrl}`);
             clearInterval(subAgent.typingInterval);
             subAgent.typingInterval = null;
           }
+          this.stopTelegramPublicProgressMessage(subAgent);
           const errMsg = err instanceof Error ? err.message : String(err);
           this.tuiWrite(() => renderTelegramSubAgentError(msg.username, errMsg));
           this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `error: ${errMsg}`);
@@ -637452,6 +637801,7 @@ Join: ${newUrl}`);
             });
           }
         } finally {
+          this.stopTelegramPublicProgressMessage(subAgent);
           this.clearTelegramSubAgentContextBuffer(sessionKey);
           this.subAgents.delete(sessionKey);
           this.refreshActiveTelegramInteractionCount();
@@ -637625,6 +637975,24 @@ Join: ${newUrl}`);
           typingInterval = this.startTypingIndicator(msg.chatId);
         }
         this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `live inference: chat reply (${this.interactionMode})`));
+        if (this.shouldUseTelegramPublicProgressMessage(msg, toolContext)) {
+          const initialHtml = [
+            `<b>Working</b>`,
+            `<code>[------------]</code> 0s`,
+            `<i>preparing a concise reply</i>`
+          ].join("\n");
+          liveMessagePromise = this.sendLiveMessage(
+            msg.chatId,
+            initialHtml,
+            msg.chatType !== "private" ? msg.messageId : void 0
+          ).then((id) => {
+            liveMessageId = id;
+            lastEditMs = Date.now();
+          }).catch(() => {
+          }).finally(() => {
+            liveMessagePromise = null;
+          });
+        }
         try {
           const mediaContext = msg.media || msg.replyToMedia || msg.livePhoto ? await this.processMediaContextForMessage(msg) : "";
           const contextualPayload = [mediaContext, additionalContext].filter(Boolean).join("\n\n");
@@ -641503,11 +641871,23 @@ ${caption}\r
             }
           } catch (err) {
             if (this.polling) {
+              const now = Date.now();
+              if (now - this.telegramPollWarningLastAtMs > 3e4) {
+                this.telegramPollWarningLastAtMs = now;
+                this.tuiWrite(() => renderWarning(
+                  `Telegram polling warning: getUpdates failed (${err instanceof Error ? err.message : String(err)}); retrying`
+                ));
+              }
               await new Promise((r2) => setTimeout(r2, 5e3));
             }
           }
         }
       }
+      telegramLongPollClientTimeoutMs() {
+        const raw = Number.parseInt(process.env["OMNIUS_TG_LONG_POLL_CLIENT_TIMEOUT_MS"] ?? "", 10);
+        if (Number.isFinite(raw) && raw >= 35e3 && raw <= 3e5) return raw;
+        return 45e3;
+      }
       /** Make a Telegram Bot API call with rate-limit retry */
       async apiCall(method, body, _retryDepth = 0) {
         const url = `https://api.telegram.org/bot${this.botToken}/${method}`;
@@ -641520,7 +641900,13 @@ ${caption}\r
         }
         const isLongPoll = method === "getUpdates";
         if (isLongPoll && this.abortController) {
-          options2.signal = this.abortController.signal;
+          const timeoutFn = AbortSignal.timeout;
+          const anyFn = AbortSignal.any;
+          const signals = [
+            this.abortController.signal,
+            typeof timeoutFn === "function" ? timeoutFn(this.telegramLongPollClientTimeoutMs()) : void 0
+          ].filter((signal) => signal instanceof AbortSignal);
+          options2.signal = typeof anyFn === "function" && signals.length > 1 ? anyFn(signals) : signals[0];
         } else if (!isLongPoll) {
           options2.signal = AbortSignal.timeout(3e4);
         }
@@ -659477,6 +659863,30 @@ function sanitizeChatContent(raw) {
   }
   return cleaned.join("\n").trim();
 }
+function appendNoThinkDirectivesToMessages(messages2) {
+  let lastUserIdx = -1;
+  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
+    if (messages2[i2]?.role === "user") {
+      lastUserIdx = i2;
+      break;
+    }
+  }
+  if (lastUserIdx < 0) return messages2;
+  const target = messages2[lastUserIdx];
+  if (!target || typeof target.content !== "string") return messages2;
+  const hasOllamaNoThink = /\/nothink\b/i.test(target.content);
+  const hasQwenNoThink = /\/no[_-]think\b/i.test(target.content);
+  if (hasOllamaNoThink && hasQwenNoThink) return messages2;
+  const suffix = [
+    hasOllamaNoThink ? null : "/nothink",
+    hasQwenNoThink ? null : "/no_think"
+  ].filter(Boolean).join("\n");
+  return messages2.map(
+    (m2, i2) => i2 === lastUserIdx ? { ...m2, content: `${target.content}
+
+${suffix}` } : m2
+  );
+}
 async function directChatBackend(opts) {
   const { model, messages: messages2, stream, res, sessionId, ollamaUrl, extraFields } = opts;
   const cfg = loadConfig();
@@ -659565,13 +659975,12 @@ async function directChatBackend(opts) {
     if (Array.isArray(ef["stop"]) || typeof ef["stop"] === "string") ollamaOpts["stop"] = ef["stop"];
     const hasTools = Array.isArray(ef["tools"]) && ef["tools"].length > 0;
     const ollamaFormat = ollamaFormatFromOpenAIResponseFormat(ef["response_format"]);
+    const ollamaMessages = appendNoThinkDirectivesToMessages(messages2);
     const reqBody = JSON.stringify({
       model: cleanModel,
-      messages: messages2,
+      messages: ollamaMessages,
       stream,
-      // Don't force think:false when the caller is using tool calling —
-      // thinking models often need their reasoning chain to choose a tool.
-      ...hasTools ? {} : { think: false },
+      think: false,
       ...hasTools ? { tools: ef["tools"] } : {},
       ...ef["tool_choice"] !== void 0 ? { tool_choice: ef["tool_choice"] } : {},
       ...ollamaFormat !== void 0 ? { format: ollamaFormat } : {},
@@ -659801,13 +660210,18 @@ async function completeRealtimeTextOnly(opts) {
   if (!requestedModel) {
     originalModel = realtimeOllamaFallbackCache.get(realtimeFallbackCacheKey(targetUrl, originalModel)) ?? originalModel;
   }
-  const makeOllamaChatBody = (modelName) => JSON.stringify({
-    model: modelName,
-    messages: requestBody["messages"],
-    stream: false,
-    think: false,
-    options: { temperature, num_predict: maxTokens }
-  });
+  const makeOllamaChatBody = (modelName) => {
+    const rtMessages = Array.isArray(requestBody["messages"]) ? appendNoThinkDirectivesToMessages(
+      requestBody["messages"]
+    ) : requestBody["messages"];
+    return JSON.stringify({
+      model: modelName,
+      messages: rtMessages,
+      stream: false,
+      think: false,
+      options: { temperature, num_predict: maxTokens }
+    });
+  };
   let result = await ollamaRequest(targetUrl, "/api/chat", "POST", makeOllamaChatBody(originalModel), timeoutMs, route?.endpoint);
   if (result.status >= 400 && !requestedModel && isOllamaMissingModelError(result.body)) {
     const fallbackModel = await resolveRealtimeOllamaFallbackModel(targetUrl, timeoutMs, originalModel);

package/npm-shrinkwrap.json

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

package/package.json

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