omnius 1.0.79 → 1.0.81

package/dist/index.js

@@ -538985,6 +538985,28 @@ function stripThinkBlocks(s2) {
     return s2;
   return s2.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
+function injectNoThinkDirective(messages2) {
+  if (!Array.isArray(messages2) || messages2.length === 0)
+    return messages2;
+  let lastUserIdx = -1;
+  for (let i2 = messages2.length - 1; i2 >= 0; i2--) {
+    if (messages2[i2]?.role === "user") {
+      lastUserIdx = i2;
+      break;
+    }
+  }
+  if (lastUserIdx === -1)
+    return messages2;
+  const target = messages2[lastUserIdx];
+  if (!target || typeof target.content !== "string")
+    return messages2;
+  if (/\/no_think\b/i.test(target.content))
+    return messages2;
+  const annotated = `${target.content}
+
+/no_think`;
+  return messages2.map((m2, i2) => i2 === lastUserIdx ? { ...m2, content: annotated } : m2);
+}
 function computeEffectiveThink(params) {
   if (process.env["OMNIUS_FORCE_NO_THINK"] === "1")
     return false;
@@ -551435,14 +551457,40 @@ ${description}`
         }) : null;
         const requestBaseUrl = poolSlot?.baseUrl ?? this.baseUrl;
         let poolSuccess = false;
+        const combineAbortSignals = (signals) => {
+          const filtered = signals.filter((s2) => s2 instanceof AbortSignal);
+          if (filtered.length === 0)
+            return void 0;
+          if (filtered.length === 1)
+            return filtered[0];
+          const anyFn = AbortSignal.any;
+          if (typeof anyFn === "function")
+            return anyFn(filtered);
+          const controller = new AbortController();
+          for (const sig of filtered) {
+            if (sig.aborted) {
+              controller.abort(sig.reason);
+              break;
+            }
+            sig.addEventListener("abort", () => {
+              if (!controller.signal.aborted) {
+                controller.abort(sig.reason);
+              }
+            });
+          }
+          return controller.signal;
+        };
+        const effectiveTimeoutMs = Number.isFinite(request.timeoutMs) && request.timeoutMs > 0 ? request.timeoutMs : 0;
+        const timeoutSignal = effectiveTimeoutMs > 0 && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(effectiveTimeoutMs) : void 0;
+        const combinedAbortSignal = combineAbortSignals([this._abortSignal, timeoutSignal]);
         try {
           const fetchOpts = {
             method: "POST",
             headers: this.authHeaders(),
             body: JSON.stringify(body)
           };
-          if (this._abortSignal)
-            fetchOpts.signal = this._abortSignal;
+          if (combinedAbortSignal)
+            fetchOpts.signal = combinedAbortSignal;
           const resp = await fetch(`${requestBaseUrl}/v1/chat/completions`, fetchOpts);
           if (!resp.ok) {
             const text = await resp.text().catch(() => "");
@@ -551456,34 +551504,42 @@ ${description}`
           const firstChoice = choices[0];
           const responseText = firstChoice ? String(firstChoice.message?.content ?? "") : "";
           const outcome = this.recordThinkOutcome(responseText, effectiveThink === true);
-          if (outcome !== null && effectiveThink === true) {
-            const justSuppressed = this._thinkSuppressed && this._thinkFailStreak === _OllamaAgenticBackend._thinkFailThreshold;
-            if (justSuppressed || outcome === "empty_after_strip" || outcome === "unclosed_think") {
-              const retryBody = {
-                model: this.model,
-                messages: cleanedMessages,
-                tools: request.tools,
-                temperature: request.temperature,
-                max_tokens: request.maxTokens,
-                think: false
+          const independentOutcome = effectiveThink !== true ? classifyThinkOutcome(responseText) : null;
+          const shouldRecoverFromEmpty = 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 retryBody = {
+              model: this.model,
+              messages: retryMessages,
+              tools: request.tools,
+              temperature: request.temperature,
+              max_tokens: request.maxTokens,
+              think: false
+            };
+            if (responseFormat !== void 0 && shouldRetryThinkGuard && !shouldRecoverFromEmpty) {
+              retryBody["response_format"] = responseFormat;
+            }
+            try {
+              const retryOpts = {
+                method: "POST",
+                headers: this.authHeaders(),
+                body: JSON.stringify(retryBody)
               };
-              if (responseFormat !== void 0) {
-                retryBody["response_format"] = responseFormat;
-              }
-              try {
-                const retryOpts = {
-                  method: "POST",
-                  headers: this.authHeaders(),
-                  body: JSON.stringify(retryBody)
-                };
-                if (this._abortSignal)
-                  retryOpts.signal = this._abortSignal;
-                const retryResp = await fetch(`${requestBaseUrl}/v1/chat/completions`, retryOpts);
-                if (retryResp.ok) {
-                  const retryData = await retryResp.json();
-                  const retryChoices = retryData.choices ?? [];
-                  const retryUsage = retryData.usage;
-                  if (retryChoices.length > 0) {
+              if (combinedAbortSignal)
+                retryOpts.signal = combinedAbortSignal;
+              const retryResp = await fetch(`${requestBaseUrl}/v1/chat/completions`, retryOpts);
+              if (retryResp.ok) {
+                const retryData = await retryResp.json();
+                const retryChoices = retryData.choices ?? [];
+                const retryUsage = retryData.usage;
+                if (retryChoices.length > 0) {
+                  const retryFirst = retryChoices[0];
+                  const retryText = retryFirst ? String(retryFirst.message?.content ?? "") : "";
+                  const retryClass = classifyThinkOutcome(retryText);
+                  const retryUsable = retryClass !== "empty_after_strip" && retryClass !== "unclosed_think";
+                  if (retryUsable) {
                     poolSuccess = true;
                     return {
                       choices: retryChoices.map((c9) => {
@@ -551501,8 +551557,8 @@ ${description}`
                     };
                   }
                 }
-              } catch {
               }
+            } catch {
             }
           }
           poolSuccess = true;
@@ -607978,7 +608034,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";
@@ -607991,11 +608047,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,
@@ -608026,7 +608082,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;
@@ -608037,22 +608092,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,
@@ -608063,7 +608111,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)) {
@@ -608079,14 +608126,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;
@@ -608108,8 +608155,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) {
@@ -608121,15 +608167,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);
-        }
-      }
     };
   }
 });
@@ -610364,6 +610401,9 @@ function telegramDecisionRecoverableFlag(text) {
   }
   return void 0;
 }
+function telegramRouterTimeoutMs(configTimeoutMs, minMs = 15e3, maxMs = 6e4) {
+  return Math.min(Math.max(configTimeoutMs ?? 3e4, minMs), maxMs);
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
   for (const jsonText of telegramDecisionJsonCandidates(text)) {
     try {
@@ -610380,7 +610420,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,
@@ -610392,7 +610431,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"]),
@@ -612211,7 +612249,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();
@@ -612449,13 +612487,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}` : "",
@@ -612472,6 +612510,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}` : "",
@@ -612479,11 +612518,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;
@@ -615352,27 +615403,59 @@ ${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) {
+      async telegramRouterJsonCompletion(backend, request, diagnostics) {
+        let jsonModeResult;
+        let jsonModeError;
         try {
-          const result = await backend.chatCompletion({
+          jsonModeResult = await backend.chatCompletion({
             ...request,
             responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
           });
-          const visible = result.choices.some(
+          const visible = jsonModeResult.choices.some(
             (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
           );
-          if (visible) return result;
-        } catch {
+          if (visible) {
+            if (diagnostics) diagnostics.jsonModeStatus = "visible";
+            return jsonModeResult;
+          }
+          if (diagnostics) diagnostics.jsonModeStatus = "empty-after-strip";
+        } catch (err) {
+          jsonModeError = err;
+          if (diagnostics) {
+            diagnostics.jsonModeStatus = "threw";
+            diagnostics.jsonModeError = err instanceof Error ? err.message : String(err);
+          }
+        }
+        try {
+          const plainResult = await backend.chatCompletion(request);
+          if (diagnostics) {
+            const plainVisible = plainResult.choices.some(
+              (choice) => stripTelegramHiddenThinking(choice.message.content ?? "").trim().length > 0
+            );
+            diagnostics.plainStatus = plainVisible ? "visible" : "empty-after-strip";
+          }
+          return plainResult;
+        } catch (err) {
+          if (diagnostics) {
+            diagnostics.plainStatus = "threw";
+            diagnostics.plainError = err instanceof Error ? err.message : String(err);
+          }
+          if (jsonModeError instanceof Error && !(err instanceof Error)) throw jsonModeError;
+          throw err;
         }
-        return backend.chatCompletion(request);
       }
-      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs) {
+      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs, diagnostics) {
         const rawPreview = telegramRouterRawPreview(rawOutput, 4e3);
-        if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) return null;
+        if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) {
+          if (diagnostics) {
+            diagnostics.repairStatus = "skipped";
+            diagnostics.repairError = !rawPreview ? "no recoverable text in router output (empty after <think> strip)" : "router output was dangling JSON; repair would only re-produce a truncation";
+          }
+          return null;
+        }
         const routeInstruction = forcedRoute ? `The route is operator-forced and must be "${forcedRoute}".` : `Preserve the original route if present; otherwise choose chat or action only if the original output clearly implies one.`;
         const prompt = [
           `Repair this Telegram attention-router output into strict JSON.`,
@@ -615384,7 +615467,9 @@ ${lines.join("\n")}`);
           `{"recoverable":true|false,"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note"}`,
           ``,
           `Original router output:`,
-          rawPreview
+          rawPreview,
+          ``,
+          `/no_think`
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
@@ -615398,15 +615483,22 @@ ${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 ?? "";
-          if (telegramDecisionRecoverableFlag(repairedText) === false) return null;
+          if (telegramDecisionRecoverableFlag(repairedText) === false) {
+            if (diagnostics) diagnostics.repairStatus = "no-recoverable-output";
+            return null;
+          }
           const parsed = parseTelegramInteractionDecision(repairedText, forcedRoute, {
             defaultShouldReply: false
           });
-          if (!parsed) return null;
+          if (!parsed) {
+            if (diagnostics) diagnostics.repairStatus = "no-recoverable-output";
+            return null;
+          }
+          if (diagnostics) diagnostics.repairStatus = "recovered";
           return {
             ...parsed,
             reason: `recovered router decision: ${parsed.reason}`.slice(0, 240),
@@ -615414,20 +615506,26 @@ ${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 {
+        } catch (err) {
+          if (diagnostics) {
+            diagnostics.repairStatus = "threw";
+            diagnostics.repairError = err instanceof Error ? err.message : String(err);
+          }
           return null;
         }
       }
-      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs) {
+      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs, diagnostics) {
         const invalidPreview = telegramRouterRawPreview(rawOutput, 1200) ?? "(empty assistant content)";
         const routeInstruction = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field must be "${forcedRoute}", but should_reply must still be inferred from context.` : `Infer route live from context.`;
+        const trimmedUserPrompt = userPrompt.length > 4e3 ? `…
+${userPrompt.slice(-4e3)}` : userPrompt;
         const retryPrompt = [
           `The previous Telegram attention-router response was not usable JSON.`,
-          `Make a fresh model-derived attention decision from the full context below. Do not use hard-coded mention or keyword triggers.`,
-          `Return exactly one JSON object and no prose.`,
+          `Make a fresh model-derived attention decision from the context below. Do not use hard-coded mention or keyword triggers.`,
+          `Return exactly one JSON object and no prose. No <think> tags. No commentary.`,
           routeInstruction,
           ``,
           `Required schema: {"route":"chat"|"action","should_reply":true|false,"confidence":0.0-1.0,"reason":"short reason","attention_state":"idle"|"observing"|"engaged"|"cooldown","attention_delta":-1.0..1.0,"next_check_after_messages":1..12,"silent_disposition":"short outcome-level disposition","mental_note":"short outcome-level observation","memory_note":"short memory/summary update","relationship_note":"short relationship/thread note"}`,
@@ -615435,29 +615533,39 @@ ${repairedText}`,
           `Invalid previous output, for diagnostics only:`,
           invalidPreview,
           ``,
-          `Full router context:`,
-          userPrompt
+          `Router context (trailing-window):`,
+          trimmedUserPrompt,
+          ``,
+          `/no_think`
         ].join("\n");
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
             messages: [
               {
                 role: "system",
-                content: "You are a strict JSON Telegram attention router. Output one valid JSON object only."
+                content: "You are a strict JSON Telegram attention router. Output one valid JSON object only. Never emit <think> tags."
               },
               { role: "user", content: retryPrompt }
             ],
             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 ?? "";
+          if (diagnostics) diagnostics.strictRetryPreview = telegramRouterRawPreview(retryText, 320);
           const parsed = parseTelegramInteractionDecision(retryText, forcedRoute, {
             defaultShouldReply: false
           });
-          if (!parsed) return null;
+          if (!parsed) {
+            if (diagnostics) {
+              const cleaned = stripTelegramHiddenThinking(retryText).trim();
+              diagnostics.strictRetryStatus = cleaned ? "unparseable" : "empty";
+            }
+            return null;
+          }
+          if (diagnostics) diagnostics.strictRetryStatus = "recovered";
           return {
             ...parsed,
             reason: `strict router retry: ${parsed.reason}`.slice(0, 240),
@@ -615465,9 +615573,13 @@ ${repairedText}`,
 
 [strict router retry]
 ${retryText}`,
-            mentalNote: parsed.mentalNote ?? "strict router retry produced a valid attention decision"
+            mentalNote: parsed.mentalNote
           };
-        } catch {
+        } catch (err) {
+          if (diagnostics) {
+            diagnostics.strictRetryStatus = "threw";
+            diagnostics.strictRetryError = err instanceof Error ? err.message : String(err);
+          }
           return null;
         }
       }
@@ -615488,17 +615600,16 @@ ${retryText}`,
           forceAnalyze: daydreamForceCheck
         });
         if (!config) {
-          const fallback2 = {
+          const fallback = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
             shouldReply: false,
             confidence: 0,
             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, fallback2);
-          return fallback2;
+          return fallback;
         }
         const backend = new OllamaAgenticBackend(
           config.backendUrl,
@@ -615529,7 +615640,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}`,
@@ -615553,6 +615664,7 @@ ${stimulationProbe.context}`,
           `Current Telegram message text (untrusted user data):
 ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         ].filter(Boolean).join("\n");
+        const diagnostics = {};
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
             messages: [
@@ -615564,26 +615676,25 @@ ${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 ?? "";
           const parsed = parseTelegramInteractionDecision(text, forcedRoute, {
             defaultShouldReply: false
           });
           if (parsed) {
-            this.applyTelegramStimulationDecision(sessionKey, parsed);
             return parsed;
           }
           const repaired = await this.repairTelegramInteractionDecision(
             backend,
             text,
             forcedRoute,
-            config.timeoutMs ?? 3e4
+            config.timeoutMs ?? 3e4,
+            diagnostics
           );
           if (repaired) {
-            this.applyTelegramStimulationDecision(sessionKey, repaired);
             return repaired;
           }
           const strictRetry = await this.retryTelegramInteractionDecisionStrict(
@@ -615591,39 +615702,122 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             userPrompt,
             text,
             forcedRoute,
-            config.timeoutMs ?? 3e4
+            config.timeoutMs ?? 3e4,
+            diagnostics
           );
           if (strictRetry) {
-            this.applyTelegramStimulationDecision(sessionKey, strictRetry);
             return strictRetry;
           }
           const invalidRouterPreview = telegramRouterRawPreview(text);
-          const fallback2 = {
+          const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
+          const fallback = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
             shouldReply: false,
             confidence: 0,
             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",
-            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",
-            memoryNote: invalidRouterPreview ? `invalid router output preview: ${invalidRouterPreview}` : void 0,
+            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, fallback2);
-          return fallback2;
-        } catch {
+          return fallback;
+        } catch (err) {
+          const failureNarrative = this.summarizeTelegramRouterFailure(diagnostics);
+          const errMsg = err instanceof Error ? err.message : String(err);
+          const fallback = {
+            route: forcedRoute ?? (isGroup ? "action" : "chat"),
+            shouldReply: false,
+            confidence: 0,
+            reason: `router inference failed; no model-derived reply decision (${errMsg.slice(0, 160)})`,
+            source: "inference-unavailable",
+            silentDisposition: "retained as context without replying",
+            diagnosticNote: this.composeTelegramRouterDiagnosticNote(
+              void 0,
+              failureNarrative,
+              `router failed before live notes were generated: ${errMsg.slice(0, 160)}`
+            )
+          };
+          return fallback;
         }
-        const fallback = {
-          route: forcedRoute ?? (isGroup ? "action" : "chat"),
-          shouldReply: false,
-          confidence: 0,
-          reason: "router inference failed; no model-derived reply decision",
-          source: "inference-unavailable",
-          silentDisposition: "retained as context without replying",
-          mentalNote: "router failed, so no model-derived attention note was produced"
+      }
+      /**
+       * 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")
+       */
+      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`);
+        }
+        if (diag.repairStatus === "skipped") {
+          detailParts.push(`repair: skipped (${diag.repairError ?? "no recoverable input"})`);
+        } 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;
+        } else if (diag.repairStatus === "recovered") {
+          detailParts.push(`repair: recovered`);
+        }
+        if (diag.strictRetryStatus === "empty") {
+          detailParts.push(`strict-retry: empty`);
+          thinkInjectionSuspected = true;
+        } else if (diag.strictRetryStatus === "unparseable") {
+          detailParts.push(`strict-retry: unparseable (preview="${diag.strictRetryPreview ?? ""}")`);
+        } else if (diag.strictRetryStatus === "threw") {
+          detailParts.push(`strict-retry: threw (${diag.strictRetryError ?? "no detail"})`);
+          networkErrorSeen = true;
+        } 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";
+        } else if (thinkInjectionSuspected) {
+          operatorHint = "router model emitted <think>-only or unclosed-think output; conversation continuity preserved but inference is degraded";
+        }
+        return {
+          summary: parts.join("; "),
+          detail: detailParts.join("; "),
+          operatorHint
         };
-        this.applyTelegramStimulationDecision(sessionKey, fallback);
-        return fallback;
+      }
+      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 (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 "";
@@ -616389,11 +616583,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)
@@ -616434,11 +616627,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)

package/npm-shrinkwrap.json

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

package/package.json

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