omnius 1.0.80 → 1.0.82

package/dist/index.js

@@ -539007,6 +539007,18 @@ function injectNoThinkDirective(messages2) {
 /no_think`;
   return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: annotated } : m2);
 }
+function backendHttpErrorDetail(text) {
+  const trimmed = text.trimStart();
+  const isHtml = trimmed.startsWith("<!") || trimmed.startsWith("<html");
+  return isHtml ? `(received HTML error page — backend may be behind a proxy/CDN that is timing out)` : text.slice(0, 200);
+}
+function isOllamaModelNotFoundResponse(status, text, model) {
+  if (status !== 404)
+    return false;
+  const lower = text.toLowerCase();
+  const modelLower = model.toLowerCase();
+  return lower.includes("model") && lower.includes("not found") || lower.includes("not_found_error") || modelLower.length > 0 && lower.includes(modelLower) && lower.includes("not found");
+}
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
     return false;
@@ -551452,11 +551464,17 @@ ${description}`
         if (responseFormat !== void 0) {
           body["response_format"] = responseFormat;
         }
-        const poolSlot = shouldUseOllamaPoolForBaseUrl(this.baseUrl) ? await getOllamaPool({ baseInstanceUrl: this.baseUrl }).acquire({
+        let poolSlot = shouldUseOllamaPoolForBaseUrl(this.baseUrl) ? await getOllamaPool({ baseInstanceUrl: this.baseUrl }).acquire({
           model: this.model
         }) : null;
-        const requestBaseUrl = poolSlot?.baseUrl ?? this.baseUrl;
+        let requestBaseUrl = poolSlot?.baseUrl ?? this.baseUrl;
         let poolSuccess = false;
+        const releasePoolSlot = (success) => {
+          if (!poolSlot)
+            return;
+          poolSlot.release(success);
+          poolSlot = null;
+        };
         const combineAbortSignals = (signals) => {
           const filtered = signals.filter((s2) => s2 instanceof AbortSignal);
           if (filtered.length === 0)
@@ -551491,11 +551509,26 @@ ${description}`
           };
           if (combinedAbortSignal)
             fetchOpts.signal = combinedAbortSignal;
-          const resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, fetchOpts);
+          let resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, fetchOpts);
+          if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            if (poolSlot?.poolOwned && isOllamaModelNotFoundResponse(resp.status, text, this.model)) {
+              releasePoolSlot(false);
+              requestBaseUrl = this.baseUrl;
+              resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, fetchOpts);
+              if (resp.ok) {
+              } else {
+                const retryText = await resp.text().catch(() => "");
+                throw new Error(`Backend HTTP ${resp.status}: ${backendHttpErrorDetail(retryText)}`);
+              }
+            } else {
+              const detail = backendHttpErrorDetail(text);
+              throw new Error(`Backend HTTP ${resp.status}: ${detail}`);
+            }
+          }
           if (!resp.ok) {
             const text = await resp.text().catch(() => "");
-            const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
-            const detail = isHtml ? `(received HTML error page — backend may be behind a proxy/CDN that is timing out)` : text.slice(0, 200);
+            const detail = backendHttpErrorDetail(text);
             throw new Error(`Backend HTTP ${resp.status}: ${detail}`);
           }
           const data = await resp.json();
@@ -551577,7 +551610,7 @@ ${description}`
             } : void 0
           };
         } finally {
-          poolSlot?.release(poolSuccess);
+          releasePoolSlot(poolSuccess);
         }
       }
       /** Anthropic Messages API translation — converts our standard format to/from Anthropic's. */
@@ -551686,8 +551719,8 @@ ${description}`
       }
       /**
        * SSE streaming variant — yields StreamChunks as tokens arrive.
-       * Uses `stream: true` and the current thinking setting.
-       * The existing chatCompletion() method is completely unmodified.
+       * Uses `stream: true`, the current thinking setting, and the same
+       * 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));
@@ -551715,100 +551748,125 @@ ${description}`
           stream_options: { include_usage: true },
           think: effectiveThink
         };
-        const streamFetchOpts = {
-          method: "POST",
-          headers: this.authHeaders(),
-          body: JSON.stringify(body)
+        let poolSlot = shouldUseOllamaPoolForBaseUrl(this.baseUrl) ? await getOllamaPool({ baseInstanceUrl: this.baseUrl }).acquire({
+          model: this.model
+        }) : null;
+        let requestBaseUrl = poolSlot?.baseUrl ?? this.baseUrl;
+        let poolSuccess = false;
+        const releasePoolSlot = (success) => {
+          if (!poolSlot)
+            return;
+          poolSlot.release(success);
+          poolSlot = null;
         };
-        if (this._abortSignal)
-          streamFetchOpts.signal = this._abortSignal;
-        const resp = await fetch(`${this.baseUrl}/v1/chat/completions`, streamFetchOpts);
-        if (!resp.ok) {
-          const text = await resp.text().catch(() => "");
-          const isHtml = text.trimStart().startsWith("<!") || text.trimStart().startsWith("<html");
-          const detail = isHtml ? `(received HTML error page — backend may be behind a proxy/CDN that is timing out)` : text.slice(0, 200);
-          throw new Error(`Backend HTTP ${resp.status}: ${detail}`);
-        }
-        let sseBuffer = "";
-        const decoder = new TextDecoder();
-        let accumulatedContent = "";
-        let accumulatedThinking = "";
-        let sawReasoningTokens = false;
-        for await (const rawChunk of resp.body) {
-          sseBuffer += decoder.decode(rawChunk, { stream: true });
-          const parts = sseBuffer.split("\n\n");
-          sseBuffer = parts.pop();
-          for (const part of parts) {
-            const line = part.trim();
-            if (!line)
-              continue;
-            if (line === "data: [DONE]") {
-              this._finalizeStreamGuard(effectiveThink, accumulatedContent, accumulatedThinking, sawReasoningTokens);
-              return;
+        try {
+          const streamFetchOpts = {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify(body)
+          };
+          if (this._abortSignal)
+            streamFetchOpts.signal = this._abortSignal;
+          let resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, streamFetchOpts);
+          if (!resp.ok) {
+            const text = await resp.text().catch(() => "");
+            if (poolSlot?.poolOwned && isOllamaModelNotFoundResponse(resp.status, text, this.model)) {
+              releasePoolSlot(false);
+              requestBaseUrl = this.baseUrl;
+              resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, streamFetchOpts);
+              if (!resp.ok) {
+                const retryText = await resp.text().catch(() => "");
+                throw new Error(`Backend HTTP ${resp.status}: ${backendHttpErrorDetail(retryText)}`);
+              }
+            } else {
+              throw new Error(`Backend HTTP ${resp.status}: ${backendHttpErrorDetail(text)}`);
             }
-            if (!line.startsWith("data: "))
-              continue;
-            try {
-              const data = JSON.parse(line.slice(6));
-              const choices = data.choices ?? [];
-              const chunkUsageEarly = data.usage;
-              if (chunkUsageEarly) {
-                yield {
-                  type: "usage",
-                  usage: {
-                    promptTokens: chunkUsageEarly.prompt_tokens ?? 0,
-                    completionTokens: chunkUsageEarly.completion_tokens ?? 0,
-                    totalTokens: chunkUsageEarly.total_tokens ?? 0
-                  }
-                };
+          }
+          let sseBuffer = "";
+          const decoder = new TextDecoder();
+          let accumulatedContent = "";
+          let accumulatedThinking = "";
+          let sawReasoningTokens = false;
+          for await (const rawChunk of resp.body) {
+            sseBuffer += decoder.decode(rawChunk, { stream: true });
+            const parts = sseBuffer.split("\n\n");
+            sseBuffer = parts.pop();
+            for (const part of parts) {
+              const line = part.trim();
+              if (!line)
+                continue;
+              if (line === "data: [DONE]") {
+                this._finalizeStreamGuard(effectiveThink, accumulatedContent, accumulatedThinking, sawReasoningTokens);
+                poolSuccess = true;
+                return;
               }
-              const choice = choices[0];
-              if (!choice)
+              if (!line.startsWith("data: "))
                 continue;
-              const delta = choice.delta;
-              const finishReason = choice.finish_reason;
-              const reasoningToken = delta?.reasoning ?? delta?.reasoning_content;
-              if (reasoningToken && effectiveThink) {
-                sawReasoningTokens = true;
-                accumulatedThinking += reasoningToken;
-                yield { type: "content", content: reasoningToken, thinking: true };
-              }
-              if (delta?.content) {
-                accumulatedContent += delta.content;
-                yield { type: "content", content: delta.content };
-              }
-              const tcDeltas = delta?.tool_calls;
-              if (tcDeltas) {
-                for (const tcd of tcDeltas) {
-                  const fn = tcd.function;
+              try {
+                const data = JSON.parse(line.slice(6));
+                const choices = data.choices ?? [];
+                const chunkUsageEarly = data.usage;
+                if (chunkUsageEarly) {
                   yield {
-                    type: "tool_call_delta",
-                    toolCallIndex: tcd.index ?? 0,
-                    toolCallId: tcd.id || void 0,
-                    toolCallName: fn?.name || void 0,
-                    toolCallArgs: fn?.arguments || void 0
+                    type: "usage",
+                    usage: {
+                      promptTokens: chunkUsageEarly.prompt_tokens ?? 0,
+                      completionTokens: chunkUsageEarly.completion_tokens ?? 0,
+                      totalTokens: chunkUsageEarly.total_tokens ?? 0
+                    }
                   };
                 }
-              }
-              const chunkUsage = data.usage;
-              if (chunkUsage) {
-                yield {
-                  type: "usage",
-                  usage: {
-                    promptTokens: chunkUsage.prompt_tokens ?? 0,
-                    completionTokens: chunkUsage.completion_tokens ?? 0,
-                    totalTokens: chunkUsage.total_tokens ?? 0
+                const choice = choices[0];
+                if (!choice)
+                  continue;
+                const delta = choice.delta;
+                const finishReason = choice.finish_reason;
+                const reasoningToken = delta?.reasoning ?? delta?.reasoning_content;
+                if (reasoningToken && effectiveThink) {
+                  sawReasoningTokens = true;
+                  accumulatedThinking += reasoningToken;
+                  yield { type: "content", content: reasoningToken, thinking: true };
+                }
+                if (delta?.content) {
+                  accumulatedContent += delta.content;
+                  yield { type: "content", content: delta.content };
+                }
+                const tcDeltas = delta?.tool_calls;
+                if (tcDeltas) {
+                  for (const tcd of tcDeltas) {
+                    const fn = tcd.function;
+                    yield {
+                      type: "tool_call_delta",
+                      toolCallIndex: tcd.index ?? 0,
+                      toolCallId: tcd.id || void 0,
+                      toolCallName: fn?.name || void 0,
+                      toolCallArgs: fn?.arguments || void 0
+                    };
                   }
-                };
-              }
-              if (finishReason) {
-                yield { type: "finish", finishReason };
+                }
+                const chunkUsage = data.usage;
+                if (chunkUsage) {
+                  yield {
+                    type: "usage",
+                    usage: {
+                      promptTokens: chunkUsage.prompt_tokens ?? 0,
+                      completionTokens: chunkUsage.completion_tokens ?? 0,
+                      totalTokens: chunkUsage.total_tokens ?? 0
+                    }
+                  };
+                }
+                if (finishReason) {
+                  yield { type: "finish", finishReason };
+                }
+              } catch {
               }
-            } catch {
             }
           }
+          this._finalizeStreamGuard(effectiveThink, accumulatedContent, accumulatedThinking, sawReasoningTokens);
+          poolSuccess = true;
+        } finally {
+          releasePoolSlot(poolSuccess);
         }
-        this._finalizeStreamGuard(effectiveThink, accumulatedContent, accumulatedThinking, sawReasoningTokens);
       }
       /** Reconstruct a raw-looking assistant response from the streamed
        *  parts, then feed it into the loop-guard. Used at stream end (both
@@ -608034,7 +608092,7 @@ function phaseFromAttention(attention) {
 function parseStimulationPhase(value2) {
   return normalizePhase(value2);
 }
-var DEFAULT_STATE, PHASE_DEFAULTS, PHASE_FLOORS, StimulationController;
+var DEFAULT_STATE, PHASE_MESSAGE_BUDGETS, PHASE_FLOORS, StimulationController;
 var init_stimulation = __esm({
   "packages/cli/src/tui/stimulation.ts"() {
     "use strict";
@@ -608047,11 +608105,11 @@ var init_stimulation = __esm({
       consecutiveNoReply: 0,
       updatedAtMs: 0
     };
-    PHASE_DEFAULTS = {
-      idle: { messages: 6, ms: 10 * 6e4 },
-      cooldown: { messages: 4, ms: 5 * 6e4 },
-      observing: { messages: 2, ms: 2 * 6e4 },
-      engaged: { messages: 1, ms: 45e3 }
+    PHASE_MESSAGE_BUDGETS = {
+      idle: 6,
+      cooldown: 4,
+      observing: 2,
+      engaged: 1
     };
     PHASE_FLOORS = {
       idle: 0,
@@ -608082,7 +608140,6 @@ var init_stimulation = __esm({
       observe(input) {
         const now = input.nowMs ?? Date.now();
         const state = this.stateFor(input.channelId, now);
-        this.applyTimeDecay(state, now);
         state.lastStimulusAtMs = now;
         state.updatedAtMs = now;
         state.messagesSinceAnalysis += 1;
@@ -608093,22 +608150,15 @@ var init_stimulation = __esm({
         if (input.replyToAgent) state.attention = Math.max(state.attention, 0.84);
         if (input.activeAgent) state.attention = Math.max(state.attention, 0.68);
         state.phase = phaseFromAttention(state.attention);
-        const cadence = PHASE_DEFAULTS[state.phase];
-        const messageBudget = state.nextAnalysisAfterMessages ?? cadence.messages;
-        const timeDue = state.nextAnalysisAtMs !== void 0 ? now >= state.nextAnalysisAtMs : state.lastAnalysisAtMs !== void 0 && now - state.lastAnalysisAtMs >= cadence.ms;
-        const shouldAnalyze = !state.lastAnalysisAtMs || metadataStimulus || state.messagesSinceAnalysis >= messageBudget || timeDue;
+        const messageBudget = state.nextAnalysisAfterMessages ?? PHASE_MESSAGE_BUDGETS[state.phase];
+        const shouldAnalyze = !state.lastAnalysisAtMs || metadataStimulus || state.messagesSinceAnalysis >= messageBudget;
         let reason = "cadence-hold";
         if (!state.lastAnalysisAtMs) reason = "initial-analysis";
         else if (input.privateChannel) reason = "private-channel";
         else if (input.replyToAgent) reason = "reply-to-agent";
         else if (input.directSignal) reason = "direct-platform-signal";
         else if (input.activeAgent) reason = "active-agent-thread";
-        else if (state.messagesSinceAnalysis >= messageBudget) reason = "chronological-sample";
-        else if (timeDue) reason = "time-sample";
-        if (shouldAnalyze) {
-          state.lastAnalysisAtMs = now;
-          state.messagesSinceAnalysis = 0;
-        }
+        else if (state.messagesSinceAnalysis >= messageBudget) reason = "message-sample";
         this.states.set(input.channelId, cloneState(state));
         return {
           shouldAnalyze,
@@ -608119,7 +608169,6 @@ var init_stimulation = __esm({
       }
       applyAgentDecision(channelId, decision, nowMs = Date.now()) {
         const state = this.stateFor(channelId, nowMs);
-        this.applyTimeDecay(state, nowMs);
         if (Number.isFinite(decision.attentionScore)) {
           state.attention = clamp017(Number(decision.attentionScore));
         } else if (Number.isFinite(decision.attentionDelta)) {
@@ -608135,14 +608184,14 @@ var init_stimulation = __esm({
         }
         state.consecutiveNoReply = decision.shouldReply ? 0 : state.consecutiveNoReply + 1;
         state.nextAnalysisAfterMessages = Number.isFinite(decision.nextAnalysisAfterMessages) ? Math.max(1, Math.floor(Number(decision.nextAnalysisAfterMessages))) : void 0;
-        state.nextAnalysisAtMs = Number.isFinite(decision.nextAnalysisAfterMs) ? nowMs + Math.max(0, Number(decision.nextAnalysisAfterMs)) : void 0;
+        state.lastAnalysisAtMs = nowMs;
+        state.messagesSinceAnalysis = 0;
         state.updatedAtMs = nowMs;
         this.states.set(channelId, cloneState(state));
         return cloneState(state);
       }
       recordAgentOutput(channelId, nowMs = Date.now()) {
         const state = this.stateFor(channelId, nowMs);
-        this.applyTimeDecay(state, nowMs);
         state.phase = "engaged";
         state.attention = Math.max(state.attention, 0.78);
         state.lastAgentOutputAtMs = nowMs;
@@ -608164,8 +608213,7 @@ var init_stimulation = __esm({
           `Consecutive no-reply decisions: ${state.consecutiveNoReply}`,
           `Last analysis: ${sinceAnalysis}`,
           `Last agent output: ${sinceAgent}`,
-          state.nextAnalysisAfterMessages ? `Agent-requested next check after messages: ${state.nextAnalysisAfterMessages}` : "",
-          state.nextAnalysisAtMs ? `Agent-requested next check at: ${new Date(state.nextAnalysisAtMs).toISOString()}` : ""
+          state.nextAnalysisAfterMessages ? `Agent-requested next check after messages: ${state.nextAnalysisAfterMessages}` : ""
         ].filter(Boolean).join("\n");
       }
       stateFor(channelId, nowMs) {
@@ -608177,15 +608225,6 @@ var init_stimulation = __esm({
           updatedAtMs: nowMs
         };
       }
-      applyTimeDecay(state, nowMs) {
-        const elapsedMs2 = Math.max(0, nowMs - (state.updatedAtMs || nowMs));
-        if (elapsedMs2 <= 0) return;
-        const halfLives = elapsedMs2 / (12 * 6e4);
-        state.attention = clamp017(state.attention * Math.pow(0.5, halfLives));
-        if (state.phase !== "engaged" || elapsedMs2 > 4 * 6e4) {
-          state.phase = phaseFromAttention(state.attention);
-        }
-      }
     };
   }
 });
@@ -610420,6 +610459,10 @@ function telegramDecisionRecoverableFlag(text) {
   }
   return void 0;
 }
+function telegramRouterTimeoutMs(configTimeoutMs, minMs = 15e3, _legacyMaxMs) {
+  const configured = Number.isFinite(configTimeoutMs) && (configTimeoutMs ?? 0) > 0 ? configTimeoutMs : 3e5;
+  return Math.max(configured, minMs);
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   for (const jsonText of telegramDecisionJsonCandidates(text)) {
     try {
@@ -610436,7 +610479,6 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
       const attentionDeltaRaw = Number(parsed["attention_delta"] ?? parsed["attentionDelta"]);
       const attentionScoreRaw = Number(parsed["attention_score"] ?? parsed["attentionScore"]);
       const nextMessagesRaw = Number(parsed["next_check_after_messages"] ?? parsed["nextCheckAfterMessages"]);
-      const nextMsRaw = Number(parsed["next_check_after_ms"] ?? parsed["nextCheckAfterMs"]);
       return {
         route,
         shouldReply,
@@ -610448,7 +610490,6 @@ function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
         attentionDelta: Number.isFinite(attentionDeltaRaw) ? Math.max(-1, Math.min(1, attentionDeltaRaw)) : void 0,
         attentionScore: Number.isFinite(attentionScoreRaw) ? Math.max(0, Math.min(1, attentionScoreRaw)) : void 0,
         nextCheckAfterMessages: Number.isFinite(nextMessagesRaw) ? Math.max(1, Math.floor(nextMessagesRaw)) : void 0,
-        nextCheckAfterMs: Number.isFinite(nextMsRaw) ? Math.max(0, Math.floor(nextMsRaw)) : void 0,
         silentDisposition: telegramDecisionNote(parsed, ["silent_disposition", "silentDisposition", "disposition"]),
         mentalNote: telegramDecisionNote(parsed, ["mental_note", "mentalNote", "observation", "insight"]),
         memoryNote: telegramDecisionNote(parsed, ["memory_note", "memoryNote", "memory"]),
@@ -610758,6 +610799,21 @@ function cleanTelegramVisibleReply(text, options2 = {}) {
   if (!filtered) return "";
   return dedupeTelegramVisibleReply(filtered);
 }
+function summarizeTelegramInferenceError(message2) {
+  if (/aborted due to timeout|aborterror|timed? out/i.test(message2)) {
+    return "backend inference timed out before a reply was delivered";
+  }
+  if (/model ['"]?[^'"]+['"]? not found|not_found_error/i.test(message2)) {
+    return "the configured model was not available on the selected Ollama runner";
+  }
+  if (/Backend HTTP 5\d\d/i.test(message2)) {
+    return "the backend returned a transient server error";
+  }
+  if (/Backend HTTP 4\d\d/i.test(message2)) {
+    return message2.slice(0, 180);
+  }
+  return message2.slice(0, 180) || "unknown backend failure";
+}
 function dedupeTelegramVisibleReply(text) {
   const paragraphs = text.split(/\n{2,}/);
   const seenParagraphs = /* @__PURE__ */ new Set();
@@ -612267,7 +612323,7 @@ External acquisition contract:
       chatAssociativeMemory = /* @__PURE__ */ new Map();
       /** Durable social cognition state by scoped Telegram chat key. */
       chatSocialState = /* @__PURE__ */ new Map();
-      /** Generic chronological attention cadence shared by live surfaces. */
+      /** Generic deliverable/message attention cadence shared by live surfaces. */
       stimulation = new StimulationController();
       /** Throttles noisy "skipped group chatter" waterfall logs */
       groupSkipLogAt = /* @__PURE__ */ new Map();
@@ -612505,13 +612561,13 @@ External acquisition contract:
           decision.attentionScore !== void 0 ? `score=${decision.attentionScore.toFixed(2)}` : ""
         ].filter(Boolean).join(", ");
         const cadence = [
-          decision.nextCheckAfterMessages !== void 0 ? `after ${decision.nextCheckAfterMessages} message(s)` : "",
-          decision.nextCheckAfterMs !== void 0 ? `after ${Math.round(decision.nextCheckAfterMs / 1e3)}s` : ""
+          decision.nextCheckAfterMessages !== void 0 ? `after ${decision.nextCheckAfterMessages} message(s)` : ""
         ].filter(Boolean).join(" or ");
         const lines = [
           `decision: ${route} (${decision.source}, confidence ${decision.confidence.toFixed(2)})`,
           attention ? `attention: ${attention}` : "",
           `reason: ${decision.reason}`,
+          decision.diagnosticNote ? `router diagnostic: ${decision.diagnosticNote}` : "",
           decision.silentDisposition ? `silent disposition: ${decision.silentDisposition}` : "",
           decision.mentalNote ? `mental note: ${decision.mentalNote}` : "",
           decision.memoryNote ? `memory note: ${decision.memoryNote}` : "",
@@ -612528,6 +612584,7 @@ External acquisition contract:
         const route = decision.shouldReply ? `reply via ${decision.route}` : "silent";
         const primary = `attention decision: ${route} (${decision.source}, confidence ${decision.confidence.toFixed(2)}) - ${decision.reason}`;
         const notes2 = [
+          decision.diagnosticNote ? `router diagnostic: ${decision.diagnosticNote}` : "",
           decision.silentDisposition ? `silent reflection: ${decision.silentDisposition}` : "",
           decision.mentalNote ? `mental note: ${decision.mentalNote}` : "",
           decision.memoryNote ? `memory note: ${decision.memoryNote}` : "",
@@ -612535,11 +612592,23 @@ External acquisition contract:
         ].filter(Boolean);
         this.tuiWrite(() => {
           renderTelegramSubAgentEvent(msg.username, primary);
-          for (const note of notes2.slice(0, 4)) {
+          for (const note of notes2.slice(0, 5)) {
             renderTelegramSubAgentEvent(msg.username, note);
           }
         });
       }
+      deliverTelegramAttentionDecision(sessionKey, msg, viewId, decision, salienceSignals, daydreamOpportunities = this.latestTelegramDaydreamOpportunityInputs(sessionKey)) {
+        this.writeTelegramAttentionDecision(viewId, decision);
+        this.mirrorTelegramAttentionDecision(msg, decision);
+        this.commitTelegramSocialDecision(
+          sessionKey,
+          msg,
+          decision,
+          salienceSignals,
+          daydreamOpportunities
+        );
+        this.applyTelegramStimulationDecision(sessionKey, decision);
+      }
       normalizeTelegramCommandText(input) {
         const trimmed = input.trim();
         if (!trimmed.startsWith("/")) return input;
@@ -615408,8 +615477,7 @@ ${lines.join("\n")}`);
           phase: decision.attentionState,
           attentionDelta: decision.attentionDelta,
           attentionScore: decision.attentionScore,
-          nextAnalysisAfterMessages: decision.nextCheckAfterMessages,
-          nextAnalysisAfterMs: decision.nextCheckAfterMs
+          nextAnalysisAfterMessages: decision.nextCheckAfterMessages
         });
       }
       async telegramRouterJsonCompletion(backend, request, diagnostics) {
@@ -615489,7 +615557,7 @@ ${lines.join("\n")}`);
             tools: [],
             temperature: 0,
             maxTokens: 500,
-            timeoutMs: Math.min(Math.max(timeoutMs, 3e3), 8e3),
+            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 2e4),
             think: false
           });
           const repairedText = result.choices[0]?.message?.content ?? "";
@@ -615512,8 +615580,8 @@ ${lines.join("\n")}`);
 
 [repaired router decision]
 ${repairedText}`,
-            mentalNote: parsed.mentalNote ?? "router decision recovered from non-JSON model output",
-            memoryNote: parsed.memoryNote ?? "router repair preserved the model-derived attention decision"
+            mentalNote: parsed.mentalNote,
+            memoryNote: parsed.memoryNote
           };
         } catch (err) {
           if (diagnostics) {
@@ -615556,7 +615624,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
             tools: [],
             temperature: 0,
             maxTokens: 1200,
-            timeoutMs: Math.min(Math.max(timeoutMs, 5e3), 15e3),
+            timeoutMs: telegramRouterTimeoutMs(timeoutMs, 1e4, 3e4),
             think: false
           });
           const retryText = result.choices[0]?.message?.content ?? "";
@@ -615579,7 +615647,7 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
 
 [strict router retry]
 ${retryText}`,
-            mentalNote: parsed.mentalNote ?? "strict router retry produced a valid attention decision"
+            mentalNote: parsed.mentalNote
           };
         } catch (err) {
           if (diagnostics) {
@@ -615613,9 +615681,8 @@ ${retryText}`,
             reason: "router inference unavailable; no model-derived reply decision",
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying",
-            mentalNote: "router unavailable, so no model-derived attention note was produced"
+            diagnosticNote: "router unavailable; live mental, memory, and relationship notes were not generated"
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback);
           return fallback;
         }
         const backend = new OllamaAgenticBackend(
@@ -615647,7 +615714,7 @@ ${retryText}`,
           `Ingress discipline: this Telegram message has already been retained as chat context. should_reply controls only whether to emit a visible reply.`,
           `Memory discipline: use durable associative user memory, relationships, prior actions, and recent context to infer whether this speaker is continuing a bot-related thread. A mention is not required when the semantic target is clearly the bot or an ongoing bot-mediated discussion.`,
           `Channel daydream discipline: a daydream artifact may highlight relationship signals, unresolved questions, or possible reply opportunities from idle reflection. It can justify analyzing this turn, but it does not force a reply. Reply only if the current user entry makes the intervention timely and socially appropriate.`,
-          `Stimulation discipline: also set attention_state, attention_delta, and optional next_check_after_messages/next_check_after_ms. These control future analysis cadence only; they do not force a reply. Use engaged for active back-and-forth, observing for likely relevant context, cooldown for recently irrelevant context, and idle for ambient chatter.`,
+          `Stimulation discipline: also set attention_state, attention_delta, and optional next_check_after_messages. This is a message-deliverable cadence only; do not use elapsed time as an analysis trigger. Use engaged for active back-and-forth, observing for likely relevant context, cooldown for recently irrelevant context, and idle for ambient chatter.`,
           forcedLine,
           ``,
           `Tool context: ${toolContext}`,
@@ -615683,8 +615750,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 700,
-            timeoutMs: Math.min(Math.max(config.timeoutMs ?? 3e4, 5e3), 15e3),
+            maxTokens: 1e3,
+            timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
             think: false
           }, diagnostics);
           const text = result.choices[0]?.message?.content ?? "";
@@ -615692,7 +615759,6 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             defaultShouldReply: false
           });
           if (parsed) {
-            this.applyTelegramStimulationDecision(sessionKey, parsed);
             return parsed;
           }
           const repaired = await this.repairTelegramInteractionDecision(
@@ -615703,7 +615769,6 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             diagnostics
           );
           if (repaired) {
-            this.applyTelegramStimulationDecision(sessionKey, repaired);
             return repaired;
           }
           const strictRetry = await this.retryTelegramInteractionDecisionStrict(
@@ -615715,7 +615780,6 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             diagnostics
           );
           if (strictRetry) {
-            this.applyTelegramStimulationDecision(sessionKey, strictRetry);
             return strictRetry;
           }
           const invalidRouterPreview = telegramRouterRawPreview(text);
@@ -615727,15 +615791,13 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             reason: "router output was not valid decision JSON after repair/retry; no model-derived reply decision",
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying because the router decision could not be parsed",
-            // Preserve the well-known mental-note strings (existing tests rely
-            // on them) but append the per-step diagnostic so operators get a
-            // real explanation of what actually failed.
-            mentalNote: (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") + (failureNarrative.summary ? ` — ${failureNarrative.summary}` : ""),
-            memoryNote: this.composeTelegramRouterMemoryNote(invalidRouterPreview, failureNarrative.detail),
-            relationshipNote: failureNarrative.relationshipHint,
+            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"
+            ),
             raw: text
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback);
           return fallback;
         } catch (err) {
           const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
@@ -615747,19 +615809,20 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             reason: `router inference failed; no model-derived reply decision (${errMsg.slice(0, 160)})`,
             source: "inference-unavailable",
             silentDisposition: "retained as context without replying",
-            mentalNote: `router failed, so no model-derived attention note was produced` + (failureNarrative.summary ? ` — ${failureNarrative.summary}` : ` — ${errMsg.slice(0, 160)}`),
-            memoryNote: failureNarrative.detail ? `router-failure trace: ${failureNarrative.detail}` : `router-failure trace: ${errMsg.slice(0, 240)}`,
-            relationshipNote: failureNarrative.relationshipHint
+            diagnosticNote: this.composeTelegramRouterDiagnosticNote(
+              void 0,
+              failureNarrative,
+              `router failed before live notes were generated: ${errMsg.slice(0, 160)}`
+            )
           };
-          this.applyTelegramStimulationDecision(sessionKey, fallback);
           return fallback;
         }
       }
       /**
        * Reduce captured per-step diagnostics into:
-       *   - `summary`: a short outcome-level line for the mental note
-       *   - `detail`: a longer ordered trace for the memory note
-       *   - `relationshipHint`: an operational hint (e.g. "ollama backend appears to be injecting <think> tags despite think:false")
+       *   - `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")
        */
       summarizeTelegramRouterFailure(diag) {
         const parts = [];
@@ -615809,24 +615872,26 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         } else if (diag.strictRetryStatus === "recovered") {
           detailParts.push(`strict-retry: recovered`);
         }
-        let relationshipHint;
+        let operatorHint;
         if (networkErrorSeen) {
-          relationshipHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
+          operatorHint = "router backend appears unreachable or rate-limited; continued conversation depends on recovery";
         } else if (thinkInjectionSuspected) {
-          relationshipHint = "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; conversation continuity preserved but inference is degraded";
         }
         return {
           summary: parts.join("; "),
           detail: detailParts.join("; "),
-          relationshipHint
+          operatorHint
         };
       }
-      composeTelegramRouterMemoryNote(invalidRouterPreview, detail) {
+      composeTelegramRouterDiagnosticNote(invalidRouterPreview, failureNarrative, headline) {
         const segments = [];
+        segments.push(headline);
+        if (failureNarrative.summary) segments.push(failureNarrative.summary);
         if (invalidRouterPreview) segments.push(`invalid router output preview: ${invalidRouterPreview}`);
-        if (detail) segments.push(`router-failure trace: ${detail}`);
-        if (segments.length === 0) return void 0;
-        return segments.join(" | ");
+        if (failureNarrative.detail) segments.push(`router-failure trace: ${failureNarrative.detail}`);
+        if (failureNarrative.operatorHint) segments.push(failureNarrative.operatorHint);
+        return segments.join(" | ").slice(0, 900);
       }
       buildTelegramWorkspaceContext(modelTier, budget = 14e3) {
         if (!this.repoRoot) return "";
@@ -616592,11 +616657,10 @@ Join: ${newUrl}`);
           if (isGroup) {
             const attentionViewId2 = this.registerTelegramAttentionView(msg, existing.toolContext || toolContext, "active Telegram thread");
             const decision2 = await this.inferTelegramInteractionDecision(msg, existing.toolContext || toolContext);
-            this.writeTelegramAttentionDecision(attentionViewId2, decision2);
-            this.mirrorTelegramAttentionDecision(msg, decision2);
-            this.commitTelegramSocialDecision(
+            this.deliverTelegramAttentionDecision(
               sessionKey,
               msg,
+              attentionViewId2,
               decision2,
               this.telegramMessageIdentitySalienceSignals(msg),
               this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
@@ -616637,11 +616701,10 @@ Join: ${newUrl}`);
         }
         const attentionViewId = this.registerTelegramAttentionView(msg, toolContext);
         const decision = await this.inferTelegramInteractionDecision(msg, toolContext);
-        this.writeTelegramAttentionDecision(attentionViewId, decision);
-        this.mirrorTelegramAttentionDecision(msg, decision);
-        this.commitTelegramSocialDecision(
+        this.deliverTelegramAttentionDecision(
           sessionKey,
           msg,
+          attentionViewId,
           decision,
           this.telegramMessageIdentitySalienceSignals(msg),
           this.markLatestTelegramDaydreamOpportunitiesConsidered(sessionKey, msg)
@@ -616993,7 +617056,8 @@ Join: ${newUrl}`);
             await this.editLiveMessage(msg.chatId, liveMessageId, `Error: ${escapeTelegramHTML(errMsg)}`).catch(() => {
             });
           } else {
-            await this.replyToTelegramMessage(msg, "Sorry, I couldn't process that quick chat message.").catch(() => {
+            const summary = summarizeTelegramInferenceError(errMsg);
+            await this.replyToTelegramMessage(msg, `Sorry, quick chat inference failed: ${summary}.`).catch(() => {
             });
           }
         } finally {
@@ -617071,10 +617135,11 @@ ${conversationStream}`
           tools: [],
           temperature: 0.4,
           maxTokens: 700,
-          timeoutMs: Math.min(config.timeoutMs ?? 3e4, 3e4),
+          timeoutMs: Math.max(config.timeoutMs ?? 3e5, 6e4),
           think: false
         };
         let accumulated = "";
+        let streamError;
         const streamable = backend;
         const stream = typeof streamable.chatCompletionStream === "function" ? streamable.chatCompletionStream(request) : null;
         if (stream && typeof stream[Symbol.asyncIterator] === "function") {
@@ -617085,12 +617150,23 @@ ${conversationStream}`
                 await onToken(accumulated);
               }
             }
-          } catch {
+          } catch (err) {
+            streamError = err;
             accumulated = "";
           }
         }
         if (!accumulated.trim()) {
-          const result = await backend.chatCompletion(request);
+          let result;
+          try {
+            result = await backend.chatCompletion(request);
+          } catch (err) {
+            if (streamError) {
+              const streamMsg = streamError instanceof Error ? streamError.message : String(streamError);
+              const retryMsg = err instanceof Error ? err.message : String(err);
+              throw new Error(`streaming failed (${streamMsg}); non-stream retry failed (${retryMsg})`);
+            }
+            throw err;
+          }
           accumulated = result.choices[0]?.message?.content ?? "";
           if (accumulated) await onToken(accumulated);
         }

package/npm-shrinkwrap.json

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

package/package.json

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