omnius 1.0.467 → 1.0.468

package/dist/index.js

@@ -14235,6 +14235,65 @@ function findMatchOffsets(haystack, needle) {
   }
   return offsets;
 }
+function lineNumberAtOffset(haystack, offset) {
+  return haystack.slice(0, offset).split("\n").length;
+}
+function findLineEndWhitespaceEquivalentSpans(haystack, needle) {
+  const normalizedNeedle = normalizeLineEndWhitespaceWithMap(needle).text;
+  if (normalizedNeedle.length === 0)
+    return [];
+  const normalizedHaystack = normalizeLineEndWhitespaceWithMap(haystack);
+  const spans = [];
+  let pos = 0;
+  while ((pos = normalizedHaystack.text.indexOf(normalizedNeedle, pos)) !== -1) {
+    const normalizedEnd = pos + normalizedNeedle.length;
+    const start2 = normalizedHaystack.map[pos];
+    const end = normalizedEnd < normalizedHaystack.map.length ? normalizedHaystack.map[normalizedEnd] : haystack.length;
+    if (start2 !== void 0 && end >= start2) {
+      const text2 = haystack.slice(start2, end);
+      if (text2 !== needle) {
+        spans.push({ start: start2, end, text: text2 });
+      }
+    }
+    pos += Math.max(1, normalizedNeedle.length);
+  }
+  return spans;
+}
+function normalizeLineEndWhitespaceWithMap(value2) {
+  const chars = [];
+  const map2 = [];
+  for (let i2 = 0; i2 < value2.length; ) {
+    const ch = value2[i2];
+    if (ch === " " || ch === "	") {
+      let j = i2 + 1;
+      while (j < value2.length && (value2[j] === " " || value2[j] === "	")) {
+        j++;
+      }
+      const next = value2[j];
+      if (j >= value2.length || next === "\n" || next === "\r") {
+        i2 = j;
+        continue;
+      }
+      for (let k = i2; k < j; k++) {
+        chars.push(value2[k]);
+        map2.push(k);
+      }
+      i2 = j;
+      continue;
+    }
+    chars.push(ch);
+    map2.push(i2);
+    i2++;
+  }
+  return { text: chars.join(""), map: map2 };
+}
+function replaceSpans(content, spans, replacement) {
+  let updated = content;
+  for (const span of [...spans].sort((a2, b) => b.start - a2.start)) {
+    updated = updated.slice(0, span.start) + replacement + updated.slice(span.end);
+  }
+  return updated;
+}
 function replaceAllOccurrences(haystack, needle, replacement) {
   return haystack.split(needle).join(replacement);
 }
@@ -14419,7 +14478,17 @@ var init_file_edit = __esm({
               afterHash: beforeHash
             };
           }
-          const occurrences = countOccurrences(content, oldString);
+          let occurrences = countOccurrences(content, oldString);
+          let whitespaceAdjustedMatches = null;
+          let diffOldString = oldString;
+          if (occurrences === 0 && expectedHash) {
+            const matches = findLineEndWhitespaceEquivalentSpans(content, oldString);
+            if (matches.length > 0) {
+              occurrences = matches.length;
+              whitespaceAdjustedMatches = matches;
+              diffOldString = matches[0]?.text ?? oldString;
+            }
+          }
           if (occurrences === 0) {
             const alreadyAppliedLines = newString.length > 0 ? findMatchLines(content, newString) : [];
             if (alreadyAppliedLines.length > 0) {
@@ -14471,18 +14540,19 @@ Use the EXACT current content above to construct a working old_string. Do not re
             };
           }
           if (!replaceAll && occurrences > 1) {
-            const matchLines = findMatchLines(content, oldString);
-            const offsets = findMatchOffsets(content, oldString);
+            const matchLines = whitespaceAdjustedMatches ? whitespaceAdjustedMatches.map((match) => lineNumberAtOffset(content, match.start)) : findMatchLines(content, oldString);
+            const offsets = whitespaceAdjustedMatches ? whitespaceAdjustedMatches.map((match) => match.start) : findMatchOffsets(content, oldString);
             const snippets = offsets.slice(0, 4).map((off) => {
               const s2 = snippetAtOffset(content, off, 3);
               return `
 --- match at line ${s2.lineNumber} ---
 ${s2.content}`;
             }).join("\n");
+            const reason = whitespaceAdjustedMatches ? `old_string is not unique after ignoring trailing spaces/tabs at line ends — found ${occurrences} occurrences at lines ${matchLines.join(", ")}.` : `old_string is not unique — found ${occurrences} occurrences at lines ${matchLines.join(", ")}.`;
             return {
               success: false,
               output: "",
-              error: `old_string is not unique — found ${occurrences} occurrences at lines ${matchLines.join(", ")}.
+              error: `${reason}
 ${snippets}
 
 Add UNIQUE surrounding context (a function name, distinctive comment, or unique line above/below) to disambiguate. Or set replace_all=true if you want all ${occurrences} occurrences replaced identically.`,
@@ -14504,16 +14574,27 @@ Add UNIQUE surrounding context (a function name, distinctive comment, or unique
           let updated;
           let editedLines;
           if (replaceAll) {
-            editedLines = findMatchLines(content, oldString);
-            updated = replaceAllOccurrences(content, oldString, newString);
+            if (whitespaceAdjustedMatches) {
+              editedLines = whitespaceAdjustedMatches.map((match) => lineNumberAtOffset(content, match.start));
+              updated = replaceSpans(content, whitespaceAdjustedMatches, newString);
+            } else {
+              editedLines = findMatchLines(content, oldString);
+              updated = replaceAllOccurrences(content, oldString, newString);
+            }
           } else {
-            const index = content.indexOf(oldString);
-            const lineNumber = content.slice(0, index).split("\n").length;
-            editedLines = [lineNumber];
-            updated = content.slice(0, index) + newString + content.slice(index + oldString.length);
+            if (whitespaceAdjustedMatches) {
+              const match = whitespaceAdjustedMatches[0];
+              editedLines = [lineNumberAtOffset(content, match.start)];
+              updated = content.slice(0, match.start) + newString + content.slice(match.end);
+            } else {
+              const index = content.indexOf(oldString);
+              const lineNumber = content.slice(0, index).split("\n").length;
+              editedLines = [lineNumber];
+              updated = content.slice(0, index) + newString + content.slice(index + oldString.length);
+            }
           }
           const afterHash = contentHash(updated);
-          const diff = buildCompactDiff(oldString, newString);
+          const diff = buildCompactDiff(diffOldString, newString);
           if (afterHash === beforeHash) {
             return {
               success: true,
@@ -14529,9 +14610,10 @@ Add UNIQUE surrounding context (a function name, distinctive comment, or unique
           }
           if (dryRun) {
             const linesInfo2 = editedLines.length === 1 ? `line ${editedLines[0]}` : `${editedLines.length} locations (lines ${editedLines.join(", ")})`;
+            const matchNote2 = whitespaceAdjustedMatches ? " Matched by verified line-ending whitespace normalization." : "";
             return {
               success: true,
-              output: `[DRY RUN] file_edit validated for ${filePath} at ${linesInfo2}. File NOT modified. Call again with dry_run=false to apply.
+              output: `[DRY RUN] file_edit validated for ${filePath} at ${linesInfo2}. File NOT modified. Call again with dry_run=false to apply.${matchNote2}
 
 ${diff}`,
               durationMs: performance.now() - start2,
@@ -14552,10 +14634,11 @@ ${diff}`,
             diff
           });
           const linesInfo = editedLines.length === 1 ? `line ${editedLines[0]}` : `${editedLines.length} locations (lines ${editedLines.join(", ")})`;
-          const lineNumberedDiff = buildLineNumberedDiff(oldString, newString, editedLines[0] ?? 1);
+          const lineNumberedDiff = buildLineNumberedDiff(diffOldString, newString, editedLines[0] ?? 1);
+          const matchNote = whitespaceAdjustedMatches ? " (matched by verified line-ending whitespace normalization)" : "";
           return {
             success: true,
-            output: `Edited ${filePath} at ${linesInfo} (sha256 ${beforeHash} → ${afterHash})
+            output: `Edited ${filePath} at ${linesInfo}${matchNote} (sha256 ${beforeHash} → ${afterHash})
 ${lineNumberedDiff}`,
             durationMs: performance.now() - start2,
             mutated: true,
@@ -28885,12 +28968,82 @@ var init_file_patch = __esm({
             description: "Preview the diff without writing. Returns what would change. Default: false"
           }
         },
-        required: ["path", "start_line"]
+        required: ["path"],
+        allOf: [
+          {
+            if: { properties: { mode: { const: "delete" } }, required: ["mode"] },
+            then: { required: ["start_line", "end_line"] }
+          },
+          {
+            if: { properties: { mode: { const: "replace" } }, required: ["mode"] },
+            then: { required: ["start_line", "end_line"] }
+          },
+          {
+            if: { properties: { mode: { const: "insert_before" } }, required: ["mode"] },
+            then: { required: ["start_line"] }
+          },
+          {
+            if: { properties: { mode: { const: "insert_after" } }, required: ["mode"] },
+            then: { required: ["start_line"] }
+          }
+        ]
       };
       workingDir;
       constructor(workingDir) {
         this.workingDir = workingDir;
       }
+      validateInput(args) {
+        if (args["operations"] !== void 0) {
+          return {
+            result: false,
+            message: `file_patch accepts one line operation per call; do not pass operations. For deletion use: {"path":"...","mode":"delete","start_line":8,"end_line":13,"expected_hash":"..."}. For replacement use: {"path":"...","mode":"replace","start_line":8,"end_line":13,"new_content":"...","expected_hash":"..."}.`
+          };
+        }
+        if (typeof args["path"] !== "string" || !args["path"].trim()) {
+          return { result: false, message: "file_patch requires non-empty path." };
+        }
+        const mode = typeof args["mode"] === "string" ? args["mode"] : "replace";
+        if (!["replace", "insert_before", "insert_after", "delete"].includes(mode)) {
+          return {
+            result: false,
+            message: `file_patch mode="${String(args["mode"])}" is invalid. Use replace, insert_before, insert_after, or delete.`
+          };
+        }
+        if (!Number.isInteger(args["start_line"]) || Number(args["start_line"]) < 1) {
+          return {
+            result: false,
+            message: `file_patch requires start_line as a positive 1-based integer. For deleting lines, include mode="delete", start_line, end_line, and expected_hash.`
+          };
+        }
+        const hasEndLine = args["end_line"] !== void 0 && args["end_line"] !== null;
+        const hasNewContent = args["new_content"] !== void 0 || args["newContent"] !== void 0 || args["new_content_base64"] !== void 0 || args["newContentBase64"] !== void 0;
+        const hasExpectedTarget = args["expected_hash"] !== void 0 || args["expectedHash"] !== void 0 || args["expected_old_content"] !== void 0;
+        if ((mode === "replace" || mode === "delete") && !hasEndLine) {
+          return {
+            result: false,
+            message: `file_patch mode=${mode} requires end_line. For deletion use mode="delete" with start_line and end_line; for replacement include end_line and new_content.`
+          };
+        }
+        if ((mode === "replace" || mode === "insert_before" || mode === "insert_after") && !hasNewContent && args["allow_empty_content"] !== true) {
+          return {
+            result: false,
+            message: `file_patch mode=${mode} requires new_content or new_content_base64. If the intended action is removal, use mode="delete" with start_line and end_line instead.`
+          };
+        }
+        if ((mode === "replace" || mode === "delete") && !hasExpectedTarget) {
+          return {
+            result: false,
+            message: `file_patch mode=${mode} requires expected_hash from file_read or expected_old_content copied from the target lines.`
+          };
+        }
+        if ((mode === "insert_before" || mode === "insert_after") && args["expected_hash"] === void 0 && args["expectedHash"] === void 0) {
+          return {
+            result: false,
+            message: `file_patch mode=${mode} requires expected_hash from the most recent file_read so line numbers are versioned.`
+          };
+        }
+        return { result: true };
+      }
       async execute(args) {
         const filePath = args["path"];
         const startLine = args["start_line"];
@@ -577921,6 +578074,9 @@ import { join as _pathJoin, relative as _pathRelative, resolve as _pathResolve }
 import { tmpdir as _osTmpdir } from "node:os";
 import { homedir as _osHomedir } from "node:os";
 import { z as z17 } from "zod";
+function cleanToolActionReasonField(value2) {
+  return String(value2 ?? "").replace(/\s+/g, " ").trim();
+}
 function parsePersistentMemoryMode(value2) {
   if (value2 === "full" || value2 === "deferred" || value2 === "off")
     return value2;
@@ -594031,7 +594187,7 @@ ${marker}` : marker);
           try {
             raw = JSON.parse(trimmed);
           } catch {
-            return null;
+            return { intent: trimmed };
           }
         }
         if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -594048,8 +594204,9 @@ ${marker}` : marker);
       }
       _toolActionReasonForCall(toolName, args) {
         const explicit = this._extractToolActionReason(args);
-        if (explicit)
-          return explicit;
+        if (explicit) {
+          return this._completeToolActionReason(toolName, args, explicit);
+        }
         if (this._shouldSynthesizeMissingToolActionReason(toolName, args)) {
           return this._synthesizeStateUpdateToolActionReason(toolName, args);
         }
@@ -594057,6 +594214,48 @@ ${marker}` : marker);
           return null;
         return this._synthesizeReadOnlyToolActionReason(toolName, args);
       }
+      _completeToolActionReason(toolName, args, partial) {
+        const canonical = this.lookupRegisteredTool(toolName)?.name ?? toolName;
+        const goal = this._taskState.currentStep || this._taskState.nextAction || this._taskState.goal || this._taskState.originalGoal || "current task";
+        const targetPaths = this._extractToolTargetPaths(canonical, args).slice(0, 3);
+        const targetText = targetPaths.length > 0 ? ` for ${targetPaths.join(", ")}` : "";
+        const scope = TOOL_ACTION_REASON_SCOPES.has(String(partial.scope ?? "")) ? String(partial.scope) : this._defaultToolActionReasonScope(canonical);
+        return {
+          task_anchor: cleanToolActionReasonField(partial.task_anchor) || String(goal).replace(/\s+/g, " ").trim().slice(0, 160),
+          intent: cleanToolActionReasonField(partial.intent) || `Run ${canonical}${targetText} for the active task.`,
+          evidence: cleanToolActionReasonField(partial.evidence) || "Runtime completed partial public action metadata from the tool call contract before execution.",
+          expected_result: cleanToolActionReasonField(partial.expected_result) || this._defaultToolActionExpectedResult(canonical, targetText),
+          scope
+        };
+      }
+      _defaultToolActionReasonScope(toolName) {
+        if (toolName === "file_edit" || toolName === "file_patch" || toolName === "batch_edit") {
+          return "targeted_patch";
+        }
+        if (toolName === "create_structured_file")
+          return "new_file";
+        if (toolName === "task_complete")
+          return "completion";
+        if (READ_ONLY_ACTION_REASON_OPTIONAL_TOOLS.has(toolName))
+          return "discovery";
+        return "other";
+      }
+      _defaultToolActionExpectedResult(toolName, targetText) {
+        switch (toolName) {
+          case "file_edit":
+            return `Requested exact edit is applied${targetText}, or a precise edit error is returned.`;
+          case "file_patch":
+            return `Requested line patch is applied${targetText}, or a precise patch error is returned.`;
+          case "batch_edit":
+            return `Requested edit batch is applied${targetText}, or per-edit failure evidence is returned.`;
+          case "file_write":
+            return `Requested file content is written${targetText}, or a precise write error is returned.`;
+          case "shell":
+            return "Command exits with output evidence for the next decision.";
+          default:
+            return `${toolName} completes and returns success or failure evidence.`;
+        }
+      }
       _shouldSynthesizeMissingToolActionReason(toolName, _args) {
         if (this._toolActionReasonPolicy(toolName, _args) === "disabled") {
           return false;
@@ -594107,24 +594306,13 @@ ${marker}` : marker);
             `scope must be one of: ${Array.from(TOOL_ACTION_REASON_SCOPES).join(", ")}.`
           ].join("\n");
         }
-        const reason = this._extractToolActionReason(args);
-        if (!reason) {
+        const partialReason = this._extractToolActionReason(args);
+        if (!partialReason) {
           if (policy === "optional")
             return null;
           return "[TOOL ACTION REASON CONTRACT] action_reason must be an object with compact public task-state fields.";
         }
-        const missing = [
-          "task_anchor",
-          "intent",
-          "evidence",
-          "expected_result",
-          "scope"
-        ].filter((key) => reason[key].length < 3);
-        if (missing.length > 0) {
-          if (policy === "optional")
-            return null;
-          return `[TOOL ACTION REASON CONTRACT] action_reason missing non-empty field(s): ${missing.join(", ")}.`;
-        }
+        const reason = this._completeToolActionReason(toolName, args, partialReason);
         if (!TOOL_ACTION_REASON_SCOPES.has(reason.scope)) {
           if (policy === "optional")
             return null;
@@ -688075,7 +688263,7 @@ function renderTelegramSubAgentError(username, error) {
     `${c3.red("✘")} ${c3.bold(`@${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, TELEGRAM_EVIDENCE_SUFFICIENCY_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_LINK_INTEGRITY_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA, TELEGRAM_INTERACTION_DECISION_REPAIR_SCHEMA, TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT, TELEGRAM_SPACED_URL_RE, TELEGRAM_HTTP_URL_RE, 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_FAST_OPTIONS, TELEGRAM_ADMIN_EVIDENCE_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT, TELEGRAM_ADMIN_LIVE_PANEL_PAGES, TELEGRAM_ADMIN_LIVE_MUTATION_TOOLS, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_DEFAULT_LONG_POLL_TIMEOUT_SECONDS, TELEGRAM_ROUTER_AUTO_MIN_PARAMETERS_B, 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, TELEGRAM_EVIDENCE_SUFFICIENCY_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_LINK_INTEGRITY_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_INTERACTION_DECISION_MINIMAL_SCHEMA, TELEGRAM_INTERACTION_DECISION_REPAIR_SCHEMA, TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT, TELEGRAM_SPACED_URL_RE, TELEGRAM_HTTP_URL_RE, 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_FAST_OPTIONS, TELEGRAM_ADMIN_EVIDENCE_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT, TELEGRAM_ADMIN_LIVE_PANEL_PAGES, TELEGRAM_ADMIN_LIVE_MUTATION_TOOLS, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_DEFAULT_LONG_POLL_TIMEOUT_SECONDS, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -688603,7 +688791,6 @@ Telegram link integrity contract:
       "message_reaction_count"
     ];
     TELEGRAM_DEFAULT_LONG_POLL_TIMEOUT_SECONDS = 50;
-    TELEGRAM_ROUTER_AUTO_MIN_PARAMETERS_B = 8;
     TELEGRAM_PUBLIC_TOOL_QUOTAS = {
       web: { limit: 20, windowMs: 60 * 6e4 },
       media: { limit: 30, windowMs: 60 * 6e4 },
@@ -688658,7 +688845,6 @@ Telegram link integrity contract:
       pollLoopPromise = null;
       pollFatalNotified = false;
       lastUpdateId = 0;
-      telegramRouterModelCache = null;
       /**
        * Snapshot of the main agent inference config captured at construction. The
        * effective `agentConfig` is this base overlaid with the Telegram-isolated
@@ -688909,7 +689095,6 @@ Telegram link integrity contract:
           ...next.backendUrl !== void 0 ? { apiKey: next.apiKey ?? "" } : {}
         };
         this.agentConfig = effective;
-        this.telegramRouterModelCache = null;
         return effective;
       }
       /** The Telegram-isolated inference override currently in effect (if any). */
@@ -689703,9 +689888,17 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
         this.refreshActiveTelegramInteractionCount();
         return queued;
       }
+      telegramMessageExplicitlyAddressesBot(msg) {
+        if (this.telegramMessageRepliesToBot(msg)) return true;
+        const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
+        if (!bot) return false;
+        return (msg.mentionedUsernames ?? []).some(
+          (name10) => name10.trim().replace(/^@/, "").toLowerCase() === bot
+        );
+      }
       shouldFailOpenTelegramRouterUnavailable(msg, toolContext) {
         if (msg.isBot) return false;
-        return toolContext === "telegram-admin-dm" || msg.chatType === "private";
+        return toolContext === "telegram-admin-dm" || msg.chatType === "private" || this.telegramMessageExplicitlyAddressesBot(msg);
       }
       buildTelegramRouterUnavailableDecision(msg, toolContext, params) {
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
@@ -689718,9 +689911,9 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           route,
           shouldReply: failOpen,
           confidence: failOpen ? 0.55 : 0,
-          reason: failOpen ? `${params.reason}; direct private/admin delivery uses degraded visible reply instead of silent halt` : params.reason,
+          reason: failOpen ? `${params.reason}; direct/high-salience delivery uses degraded visible reply instead of silent halt` : params.reason,
           source: "inference-unavailable",
-          silentDisposition: failOpen ? "router unavailable; attempting a visible degraded reply for a direct private/admin message" : params.silentDisposition ?? "retained as context without replying because the router decision could not be derived",
+          silentDisposition: failOpen ? "router unavailable; attempting a visible degraded reply for a direct/high-salience message" : params.silentDisposition ?? "retained as context without replying because the router decision could not be derived",
           diagnosticNote: params.diagnosticNote,
           raw: params.raw
         };
@@ -695319,90 +695512,9 @@ ${retryText}`,
           this.dispatchQueuedTelegramSessionWorkSoon();
         }
       }
-      telegramRouterAutoModelEnabled() {
-        const raw = (process.env["OMNIUS_TG_ROUTER_AUTO_MODEL"] ?? "").trim().toLowerCase();
-        return raw === "1" || raw === "true" || raw === "on";
-      }
-      telegramRouterCandidateModels() {
-        const raw = (process.env["OMNIUS_TG_ROUTER_MODEL_CANDIDATES"] ?? "").trim();
-        const candidates = raw ? raw.split(/[,\s]+/).map((part) => part.trim()).filter(Boolean) : [];
-        return Array.from(new Set(candidates));
-      }
-      telegramRouterAllowThinkHeavyAutoModels() {
-        const raw = (process.env["OMNIUS_TG_ROUTER_ALLOW_THINK_MODELS"] ?? "").trim().toLowerCase();
-        return raw === "1" || raw === "true" || raw === "on";
-      }
-      telegramRouterModelLooksThinkHeavy(name10) {
-        return /\b(?:qwen3|qwq|deepseek-r1|r1-|reasoning)\b/i.test(name10);
-      }
-      normalizeOllamaModelNameForMatch(name10) {
-        return name10.trim().toLowerCase().replace(/:latest$/, "");
-      }
-      async fetchOllamaInstalledModels(baseUrl2) {
-        const url = `${baseUrl2.replace(/\/+$/, "")}/api/tags`;
-        const timeoutFn = AbortSignal.timeout;
-        const res = await fetch(url, {
-          signal: typeof timeoutFn === "function" ? timeoutFn(2e3) : void 0
-        });
-        if (!res.ok)
-          throw new Error(`ollama /api/tags returned HTTP ${res.status}`);
-        const data = await res.json();
-        return Array.isArray(data.models) ? data.models.map((model) => ({
-          name: typeof model.name === "string" ? model.name : "",
-          sizeBytes: typeof model.size === "number" ? model.size : void 0,
-          parameterSize: typeof model.details?.parameter_size === "string" ? model.details.parameter_size : void 0
-        })).filter((model) => Boolean(model.name)) : [];
-      }
-      telegramModelParameterBillions(model) {
-        const haystack = `${model.name} ${model.parameterSize ?? ""}`.toLowerCase();
-        const billion = haystack.match(/(\d+(?:\.\d+)?)\s*(?:b|bn)\b/);
-        if (billion) return Number(billion[1]);
-        const million = haystack.match(/(\d+(?:\.\d+)?)\s*m\b/);
-        if (million) return Number(million[1]) / 1e3;
-        return null;
-      }
-      scoreTelegramInstalledRouterModel(model) {
-        const name10 = model.name.toLowerCase();
-        if (/(?:embed|embedding|nomic|bge|e5-|clip|rerank|moondream|llava|vision|vl\b|minicpm|whisper|tts|sdxl|diffusion)/i.test(
-          name10
-        )) {
-          return Number.NEGATIVE_INFINITY;
-        }
-        const paramsB = this.telegramModelParameterBillions(model);
-        if (paramsB !== null && paramsB < TELEGRAM_ROUTER_AUTO_MIN_PARAMETERS_B) {
-          return Number.NEGATIVE_INFINITY;
-        }
-        if (paramsB === null && (model.sizeBytes ?? 0) < 5e9) {
-          return Number.NEGATIVE_INFINITY;
-        }
-        let score = 0;
-        if (paramsB !== null) score += paramsB * 10;
-        else score += Math.min(80, (model.sizeBytes ?? 0) / 1e9);
-        if (/qwen|huihui|qwq/i.test(name10)) score += 80;
-        else if (/deepseek|nemotron|llama|mistral|mixtral|command-r|devstral/i.test(name10))
-          score += 50;
-        else if (/gemma/i.test(name10)) score += 20;
-        if (/:latest$/i.test(model.name)) score += 1;
-        if (this.telegramRouterModelLooksThinkHeavy(model.name) && !this.telegramRouterAllowThinkHeavyAutoModels()) {
-          score -= 15;
-        }
-        return score;
-      }
       async resolveTelegramRouterBackend(config) {
         const explicit = (process.env["OMNIUS_TG_ROUTER_MODEL"] ?? "").trim();
-        if (explicit && !/^(?:0|false|off|same|main)$/i.test(explicit)) {
-          return {
-            backend: new OllamaAgenticBackend(
-              config.backendUrl,
-              explicit,
-              config.apiKey
-            ),
-            model: explicit,
-            source: "env",
-            detail: "OMNIUS_TG_ROUTER_MODEL"
-          };
-        }
-        if (config.backendType !== "ollama") {
+        if (/^(?:same|main)$/i.test(explicit)) {
           return {
             backend: new OllamaAgenticBackend(
               config.backendUrl,
@@ -695410,128 +695522,23 @@ ${retryText}`,
               config.apiKey
             ),
             model: config.model,
-            source: "main"
-          };
-        }
-        const autoModelEnabled = this.telegramRouterAutoModelEnabled();
-        const candidateFilter = this.telegramRouterCandidateModels();
-        const candidates = new Set(
-          candidateFilter.map(
-            (candidate) => this.normalizeOllamaModelNameForMatch(candidate)
-          )
-        );
-        const cacheKey = `${config.backendUrl}
-${config.model}
-auto=${autoModelEnabled ? "1" : "0"}
-${candidateFilter.join(",")}`;
-        const now2 = Date.now();
-        if (this.telegramRouterModelCache && this.telegramRouterModelCache.cacheKey === cacheKey && now2 - this.telegramRouterModelCache.atMs < 6e4) {
-          const cached = this.telegramRouterModelCache;
-          return {
-            backend: new OllamaAgenticBackend(
-              config.backendUrl,
-              cached.model,
-              config.apiKey
-            ),
-            model: cached.model,
-            source: cached.source,
-            detail: cached.detail
-          };
-        }
-        if (!autoModelEnabled) {
-          const detail2 = "Telegram router auto-model selection is disabled by default; using main model";
-          this.telegramRouterModelCache = {
-            cacheKey,
-            atMs: now2,
-            model: config.model,
             source: "main",
-            detail: detail2
+            detail: `OMNIUS_TG_ROUTER_MODEL=${explicit}`
           };
+        }
+        if (explicit && !/^(?:0|false|off)$/i.test(explicit)) {
           return {
             backend: new OllamaAgenticBackend(
               config.backendUrl,
-              config.model,
+              explicit,
               config.apiKey
             ),
-            model: config.model,
-            source: "main",
-            detail: detail2
+            model: explicit,
+            source: "env",
+            detail: "OMNIUS_TG_ROUTER_MODEL"
           };
         }
-        try {
-          const installed = await this.fetchOllamaInstalledModels(
-            config.backendUrl
-          );
-          const installedByNormalized = /* @__PURE__ */ new Map();
-          for (const model of installed) {
-            installedByNormalized.set(
-              this.normalizeOllamaModelNameForMatch(model.name),
-              model
-            );
-          }
-          const installedMain = installedByNormalized.get(
-            this.normalizeOllamaModelNameForMatch(config.model)
-          );
-          if (installedMain) {
-            const resolved = {
-              cacheKey,
-              atMs: now2,
-              model: installedMain.name,
-              source: "main",
-              detail: "main Telegram router model is installed in Ollama /api/tags; using main model by policy"
-            };
-            this.telegramRouterModelCache = resolved;
-            return {
-              backend: new OllamaAgenticBackend(
-                config.backendUrl,
-                installedMain.name,
-                config.apiKey
-              ),
-              model: installedMain.name,
-              source: "main",
-              detail: resolved.detail
-            };
-          }
-          if (autoModelEnabled) {
-            const pool3 = candidateFilter.length > 0 ? installed.filter(
-              (model) => candidates.has(
-                this.normalizeOllamaModelNameForMatch(model.name)
-              )
-            ) : installed;
-            const selected = pool3.map((model) => ({
-              model,
-              score: this.scoreTelegramInstalledRouterModel(model)
-            })).filter((entry) => Number.isFinite(entry.score)).sort((a2, b) => b.score - a2.score)[0]?.model;
-            if (selected) {
-              const resolved = {
-                cacheKey,
-                atMs: now2,
-                model: selected.name,
-                source: "auto-installed",
-                detail: `main Telegram router model ${JSON.stringify(config.model)} was not found in Ollama /api/tags; selected best installed capable router model dynamically (minimum ${TELEGRAM_ROUTER_AUTO_MIN_PARAMETERS_B}B, excludes embeddings/vision/tiny models)`
-              };
-              this.telegramRouterModelCache = resolved;
-              return {
-                backend: new OllamaAgenticBackend(
-                  config.backendUrl,
-                  selected.name,
-                  config.apiKey
-                ),
-                model: selected.name,
-                source: "auto-installed",
-                detail: resolved.detail
-              };
-            }
-          }
-        } catch (err) {
-          const detail2 = `router model auto-detect failed: ${err instanceof Error ? err.message : String(err)}`;
-          this.telegramRouterModelCache = {
-            cacheKey,
-            atMs: now2,
-            model: config.model,
-            source: "main",
-            detail: detail2
-          };
+        if (config.backendType !== "ollama") {
           return {
             backend: new OllamaAgenticBackend(
               config.backendUrl,
@@ -695539,18 +695546,9 @@ ${candidateFilter.join(",")}`;
               config.apiKey
             ),
             model: config.model,
-            source: "main",
-            detail: detail2
+            source: "main"
           };
         }
-        const detail = `no installed capable Telegram router model met the dynamic minimum (${TELEGRAM_ROUTER_AUTO_MIN_PARAMETERS_B}B); using main model`;
-        this.telegramRouterModelCache = {
-          cacheKey,
-          atMs: now2,
-          model: config.model,
-          source: "main",
-          detail
-        };
         return {
           backend: new OllamaAgenticBackend(
             config.backendUrl,
@@ -695559,7 +695557,7 @@ ${candidateFilter.join(",")}`;
           ),
           model: config.model,
           source: "main",
-          detail
+          detail: "using selected Telegram model; automatic router model fallback is disabled"
         };
       }
       async inferTelegramInteractionDecision(msg, toolContext) {
@@ -695818,7 +695816,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
                 diagnosticNote: this.composeTelegramRouterDiagnosticNote(
                   void 0,
                   failureNarrative2,
-                  "router produced no visible attention decision content; repair/strict retry skipped for direct private/admin fail-open",
+                  "router produced no visible attention decision content; repair/strict retry skipped for direct/high-salience fail-open",
                   diagnostics
                 ),
                 raw: text2

package/npm-shrinkwrap.json

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

package/package.json

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