omnius 1.0.76 → 1.0.78

package/dist/index.js

@@ -551418,6 +551418,7 @@ ${description}`
         if (effectiveThink === true && (effectiveMaxTokens ?? 0) < 4096) {
           effectiveMaxTokens = 4096;
         }
+        const responseFormat = request.responseFormat ?? request.response_format;
         const body = {
           model: this.model,
           messages: cleanedMessages,
@@ -551426,6 +551427,9 @@ ${description}`
           max_tokens: effectiveMaxTokens,
           think: effectiveThink
         };
+        if (responseFormat !== void 0) {
+          body["response_format"] = responseFormat;
+        }
         const poolSlot = shouldUseOllamaPoolForBaseUrl(this.baseUrl) ? await getOllamaPool({ baseInstanceUrl: this.baseUrl }).acquire({
           model: this.model
         }) : null;
@@ -551463,6 +551467,9 @@ ${description}`
                 max_tokens: request.maxTokens,
                 think: false
               };
+              if (responseFormat !== void 0) {
+                retryBody["response_format"] = responseFormat;
+              }
               try {
                 const retryOpts = {
                   method: "POST",
@@ -610245,44 +610252,157 @@ function telegramDecisionNote(parsed, keys, nestedKeys = ["internal_notes", "int
   }
   return void 0;
 }
+function uniqueTelegramJsonCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const candidate of candidates) {
+    const clean5 = candidate.trim();
+    if (!clean5 || seen.has(clean5)) continue;
+    seen.add(clean5);
+    unique.push(clean5);
+  }
+  return unique;
+}
+function extractBalancedTelegramJsonObjects(text) {
+  const objects = [];
+  let start2 = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let idx = 0; idx < text.length; idx++) {
+    const ch = text[idx];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0) start2 = idx;
+      depth += 1;
+      continue;
+    }
+    if (ch === "}" && depth > 0) {
+      depth -= 1;
+      if (depth === 0 && start2 >= 0) {
+        objects.push(text.slice(start2, idx + 1));
+        start2 = -1;
+      }
+    }
+  }
+  return objects;
+}
+function telegramDecisionJsonCandidates(text) {
+  const cleaned = stripTelegramHiddenThinking(text).trim();
+  if (!cleaned) return [];
+  const candidates = [];
+  const fenced = cleaned.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi);
+  for (const match of fenced) {
+    if (match[1]) candidates.push(match[1]);
+  }
+  candidates.push(cleaned);
+  candidates.push(cleaned.replace(/```(?:json)?/gi, "").replace(/```/g, "").trim());
+  candidates.push(cleaned.replace(/^\s*(?:json|decision|router decision)\s*:?\s*/i, "").trim());
+  const expanded = [];
+  for (const candidate of candidates) {
+    if (!candidate.trim()) continue;
+    expanded.push(candidate);
+    expanded.push(...extractBalancedTelegramJsonObjects(candidate));
+  }
+  return uniqueTelegramJsonCandidates(expanded);
+}
+function telegramDecisionOutputHasDanglingJson(text) {
+  const cleaned = stripTelegramHiddenThinking(text).trim();
+  if (!cleaned || extractBalancedTelegramJsonObjects(cleaned).length > 0) return false;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let idx = 0; idx < cleaned.length; idx++) {
+    const ch = cleaned[idx];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") depth += 1;
+    if (ch === "}" && depth > 0) depth -= 1;
+  }
+  return depth > 0;
+}
+function telegramRouterRawPreview(text, maxLength = 320) {
+  const clean5 = stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
+  if (!clean5) return void 0;
+  return clean5.length > maxLength ? `${clean5.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...` : clean5;
+}
+function telegramDecisionRecoverableFlag(text) {
+  for (const jsonText of telegramDecisionJsonCandidates(text)) {
+    try {
+      const parsed = JSON.parse(jsonText);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      const recoverable = parsed["recoverable"];
+      if (typeof recoverable === "boolean") return recoverable;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
 function parseTelegramInteractionDecision(text, forcedRoute, options2 = {}) {
-  const cleaned = stripTelegramHiddenThinking(text).replace(/```(?:json)?/gi, "").replace(/```/g, "").trim();
-  const jsonText = cleaned.startsWith("{") ? cleaned : cleaned.match(/\{[\s\S]*\}/)?.[0] ?? "";
-  if (!jsonText) return null;
-  try {
-    const parsed = JSON.parse(jsonText);
-    const parsedRoute = parsed["route"] === "chat" || parsed["route"] === "action" ? parsed["route"] : null;
-    const route = forcedRoute ?? parsedRoute;
-    if (!route) return null;
-    const shouldReplyRaw = parsed["should_reply"] ?? parsed["shouldReply"];
-    const shouldReply = typeof shouldReplyRaw === "boolean" ? shouldReplyRaw : options2.defaultShouldReply ?? true;
-    const confidenceRaw = Number(parsed["confidence"]);
-    const confidence2 = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
-    const reason = String(parsed["reason"] ?? "live inference decision").slice(0, 240);
-    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,
-      confidence: confidence2,
-      reason,
-      source: forcedRoute ? "forced-mode" : "live-inference",
-      raw: text,
-      attentionState: parseStimulationPhase(parsed["attention_state"] ?? parsed["attentionState"]),
-      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"]),
-      relationshipNote: telegramDecisionNote(parsed, ["relationship_note", "relationshipNote", "relationship"])
-    };
-  } catch {
-    return null;
+  for (const jsonText of telegramDecisionJsonCandidates(text)) {
+    try {
+      const parsed = JSON.parse(jsonText);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      const parsedRoute = parsed["route"] === "chat" || parsed["route"] === "action" ? parsed["route"] : null;
+      const route = forcedRoute ?? parsedRoute;
+      if (!route) continue;
+      const shouldReplyRaw = parsed["should_reply"] ?? parsed["shouldReply"];
+      const shouldReply = typeof shouldReplyRaw === "boolean" ? shouldReplyRaw : options2.defaultShouldReply ?? true;
+      const confidenceRaw = Number(parsed["confidence"]);
+      const confidence2 = Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : 0;
+      const reason = String(parsed["reason"] ?? "live inference decision").slice(0, 240);
+      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,
+        confidence: confidence2,
+        reason,
+        source: forcedRoute ? "forced-mode" : "live-inference",
+        raw: text,
+        attentionState: parseStimulationPhase(parsed["attention_state"] ?? parsed["attentionState"]),
+        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"]),
+        relationshipNote: telegramDecisionNote(parsed, ["relationship_note", "relationshipNote", "relationship"])
+      };
+    } catch {
+      continue;
+    }
   }
+  return null;
 }
 function parseTelegramTimeRangeQuery(query, now = /* @__PURE__ */ new Date()) {
   const original = String(query || "");
@@ -611640,7 +611760,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("│")} ${c3.red("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_PUBLIC_HELP_COMMANDS, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -611897,6 +612017,9 @@ External acquisition contract:
 - The browser tool is for interactive web work; it does not save arbitrary rendered files to disk. For file acquisition, use the download/file tool and verify content-type + size before reporting success.
 - Report the exact blocker concisely and offer lawful alternatives (library hold, official store, summary/discussion if the user supplies an authorized copy).
 `.trim();
+    TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT = {
+      type: "json_object"
+    };
     TELEGRAM_STUCK_SELF_TALK_PREFIXES = [
       /^i'?ve been stuck for\b/i,
       /^i am (still |currently )?stuck\b/i,
@@ -615233,6 +615356,117 @@ ${lines.join("\n")}`);
           nextAnalysisAfterMs: decision.nextCheckAfterMs
         });
       }
+      async telegramRouterJsonCompletion(backend, request) {
+        try {
+          return await backend.chatCompletion({
+            ...request,
+            responseFormat: TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT
+          });
+        } catch {
+          return backend.chatCompletion(request);
+        }
+      }
+      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs) {
+        const rawPreview = telegramRouterRawPreview(rawOutput, 4e3);
+        if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) 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.`,
+          `Do not make a new social decision from the Telegram message. Only preserve the decision already present in the router output.`,
+          `If the original output does not contain a recoverable route and should_reply decision, return recoverable=false with should_reply=false and confidence=0.`,
+          routeInstruction,
+          ``,
+          `Return JSON only with this schema:`,
+          `{"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
+        ].join("\n");
+        try {
+          const result = await this.telegramRouterJsonCompletion(backend, {
+            messages: [
+              {
+                role: "system",
+                content: "You repair a Telegram router response into strict JSON without changing the underlying decision."
+              },
+              { role: "user", content: prompt }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 500,
+            timeoutMs: Math.min(Math.max(timeoutMs, 3e3), 8e3),
+            think: false
+          });
+          const repairedText = result.choices[0]?.message?.content ?? "";
+          if (telegramDecisionRecoverableFlag(repairedText) === false) return null;
+          const parsed = parseTelegramInteractionDecision(repairedText, forcedRoute, {
+            defaultShouldReply: false
+          });
+          if (!parsed) return null;
+          return {
+            ...parsed,
+            reason: `recovered router decision: ${parsed.reason}`.slice(0, 240),
+            raw: `${rawOutput}
+
+[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"
+          };
+        } catch {
+          return null;
+        }
+      }
+      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs) {
+        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 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.`,
+          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"}`,
+          ``,
+          `Invalid previous output, for diagnostics only:`,
+          invalidPreview,
+          ``,
+          `Full router context:`,
+          userPrompt
+        ].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."
+              },
+              { role: "user", content: retryPrompt }
+            ],
+            tools: [],
+            temperature: 0,
+            maxTokens: 1200,
+            timeoutMs: Math.min(Math.max(timeoutMs, 5e3), 15e3),
+            think: false
+          });
+          const retryText = result.choices[0]?.message?.content ?? "";
+          const parsed = parseTelegramInteractionDecision(retryText, forcedRoute, {
+            defaultShouldReply: false
+          });
+          if (!parsed) return null;
+          return {
+            ...parsed,
+            reason: `strict router retry: ${parsed.reason}`.slice(0, 240),
+            raw: `${rawOutput}
+
+[strict router retry]
+${retryText}`,
+            mentalNote: parsed.mentalNote ?? "strict router retry produced a valid attention decision"
+          };
+        } catch {
+          return null;
+        }
+      }
       async inferTelegramInteractionDecision(msg, toolContext) {
         const config = this.agentConfig;
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
@@ -615316,7 +615550,7 @@ ${stimulationProbe.context}`,
 ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         ].filter(Boolean).join("\n");
         try {
-          const result = await backend.chatCompletion({
+          const result = await this.telegramRouterJsonCompletion(backend, {
             messages: [
               {
                 role: "system",
@@ -615338,14 +615572,37 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             this.applyTelegramStimulationDecision(sessionKey, parsed);
             return parsed;
           }
+          const repaired = await this.repairTelegramInteractionDecision(
+            backend,
+            text,
+            forcedRoute,
+            config.timeoutMs ?? 3e4
+          );
+          if (repaired) {
+            this.applyTelegramStimulationDecision(sessionKey, repaired);
+            return repaired;
+          }
+          const strictRetry = await this.retryTelegramInteractionDecisionStrict(
+            backend,
+            userPrompt,
+            text,
+            forcedRoute,
+            config.timeoutMs ?? 3e4
+          );
+          if (strictRetry) {
+            this.applyTelegramStimulationDecision(sessionKey, strictRetry);
+            return strictRetry;
+          }
+          const invalidRouterPreview = telegramRouterRawPreview(text);
           const fallback2 = {
             route: forcedRoute ?? (isGroup ? "action" : "chat"),
             shouldReply: false,
             confidence: 0,
-            reason: "router output was not valid decision JSON; no model-derived reply decision",
+            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: "router produced an invalid attention decision payload",
+            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,
             raw: text
           };
           this.applyTelegramStimulationDecision(sessionKey, fallback2);

package/npm-shrinkwrap.json

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

package/package.json

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