omnius 1.0.467 → 1.0.469

package/dist/index.js

@@ -14235,31 +14235,125 @@ 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);
 }
 function buildMissingOldStringLlmContent(input) {
+  const attemptedLineCount = input.attemptedOldString.split("\n").length;
+  const attemptedCharCount = input.attemptedOldString.length;
   const lines = [
     "[FILE_EDIT_OLD_STRING_NOT_FOUND]",
     `path=${input.path}`,
     "The attempted old_string was absent from the current file.",
+    `attempted_old_string_lines=${attemptedLineCount}`,
+    `attempted_old_string_chars=${attemptedCharCount}`,
+    "repair_state=needs_current_range",
+    "patch_ready=false",
+    "read_required=true unless current path+start_line+end_line+expected_hash are already present in active evidence",
     "Do not copy diagnostic gutters into old_string. Ignore line numbers, leading '>' markers, and the '|' separator.",
+    "Transport rule: file_edit is for exact unique current text. If the intended edit is a contiguous line-range delete/replace/insert, use file_patch with start_line/end_line from file_read and expected_hash or expected_old_content.",
+    "Range patch contract: if patch_ready=true or current target line range plus expected_hash are known, call file_patch. If the range/hash is missing after stale exact edit failure, file_read the target once.",
     "",
-    "attempted_old_string:",
-    fencedText(input.attemptedOldString)
+    ...diagnosticTextBlock("attempted_old_string", input.attemptedOldString)
   ];
   if (input.snippetContent) {
     const range = input.snippetStartLine && input.snippetEndLine && input.totalLines ? `lines ${input.snippetStartLine}-${input.snippetEndLine} of ${input.totalLines}` : "closest current text";
-    lines.push("", `copyable_current_text_without_gutters (${range}):`, fencedText(stripDiagnosticGutters(input.snippetContent)), "", "Next action: build a new file_edit old_string only from the copyable_current_text_without_gutters block, or file_read the target if more context is needed.");
+    lines.push("", `current_anchor_range=${range}`, "target_range_status=anchor_only_not_patch_ready", `copyable_current_text_without_gutters (${range}):`, fencedText(stripDiagnosticGutters(input.snippetContent)), "", "Next action: build a new file_edit old_string only from the copyable_current_text_without_gutters block, or use file_patch from fresh file_read line numbers when the target is a block/range.");
   } else {
-    lines.push("", "Next action: file_read the target, then build old_string from exact current file content.");
+    lines.push("", "Next action: file_read the target, then either build old_string from exact current file content or use file_patch for a line-range edit.");
   }
   lines.push("", "Do not use shell text-rewrite commands as a workaround for this edit failure; keep the change tracked through file_edit, batch_edit, file_patch, or file_write.");
   if (input.newString.length > 0) {
-    lines.push("", "desired_new_string:", fencedText(input.newString));
+    lines.push("", ...diagnosticTextBlock("desired_new_string", input.newString));
   }
   return lines.join("\n");
 }
+function diagnosticTextBlock(label, text2) {
+  const maxChars = 700;
+  const maxLines = 12;
+  const lineCount = text2.split("\n").length;
+  if (text2.length <= maxChars && lineCount <= maxLines) {
+    return [`${label}:`, fencedText(text2)];
+  }
+  return [
+    `${label}_preview:`,
+    fencedText(previewText(text2, maxChars)),
+    `${label}_omitted=true`,
+    `${label}_omitted_reason=stale failed edit payload is not authoritative current file evidence`
+  ];
+}
+function previewText(text2, maxChars) {
+  if (text2.length <= maxChars)
+    return text2;
+  const headSize = Math.floor(maxChars * 0.65);
+  const tailSize = Math.max(80, maxChars - headSize - 64);
+  const head = text2.slice(0, headSize).trimEnd();
+  const tail = text2.slice(-tailSize).trimStart();
+  return `${head}
+...
+[omitted ${text2.length - head.length - tail.length} chars]
+...
+${tail}`;
+}
 function buildAmbiguousOldStringLlmContent(input) {
   const replaceAllArgs = {
     path: input.path,
@@ -14308,7 +14402,7 @@ var init_file_edit = __esm({
     init_text_encoding();
     FileEditTool = class {
       name = "file_edit";
-      description = "Make a precise edit to a file by replacing an exact string match. The old_string must be unique in the file unless replace_all is true. Use replace_all to rename variables or change repeated patterns throughout the file.";
+      description = "Make a precise edit to a file by replacing an exact string match. The old_string must be unique in the file unless replace_all is true. Use replace_all to rename variables or change repeated patterns throughout the file. Use file_patch instead when file_read line numbers identify a contiguous block to delete, replace, or insert around.";
       parameters = {
         type: "object",
         properties: {
@@ -14419,8 +14513,20 @@ 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 attemptedOldStringLines = oldString.split("\n").length;
+            const attemptedOldStringChars = oldString.length;
             const alreadyAppliedLines = newString.length > 0 ? findMatchLines(content, newString) : [];
             if (alreadyAppliedLines.length > 0) {
               const lineInfo = alreadyAppliedLines.length === 1 ? `line ${alreadyAppliedLines[0]}` : `${alreadyAppliedLines.length} locations (lines ${alreadyAppliedLines.join(", ")})`;
@@ -14443,10 +14549,12 @@ var init_file_edit = __esm({
               const pct = Math.round(snippet.similarity * 100);
               errorMsg += `
 
-Current file content (closest match, ${pct}% similarity, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
+Attempted old_string spans ${attemptedOldStringLines} line(s), ${attemptedOldStringChars} chars. The diagnostic below is the closest anchor-line match, not proof that the whole old_string exists.
+
+Current file content (closest anchor-line match, ${pct}% line similarity, lines ${snippet.startLine}–${snippet.endLine} of ${snippet.totalLines}):
 ${snippet.content}
 
-Use the EXACT current content above to construct a working old_string. Do not retry with a different guess — the file on disk has changed since you last read it.`;
+Use the EXACT current content above to construct a working old_string. If the intended change is a contiguous line range, use file_patch with start_line/end_line from a fresh file_read. Do not retry with a different guess — the file on disk has changed since you last read it.`;
             } else {
               errorMsg += ` The file is empty or binary. Use file_read to inspect.`;
             }
@@ -14471,18 +14579,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 +14613,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 +14649,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 +14673,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,
@@ -28834,7 +28956,7 @@ var init_file_patch = __esm({
     init_text_encoding();
     FilePatchTool = class {
       name = "file_patch";
-      description = "Edit specific line ranges in a file. More precise than string matching for large files. Modes: 'replace' replaces lines start_line..end_line with new_content, 'insert_before' inserts before start_line, 'insert_after' inserts after start_line, 'delete' removes lines start_line..end_line. Use dry_run to preview changes.";
+      description = "Edit specific line ranges in a file. More precise than string matching for large files. Modes: 'replace' replaces lines start_line..end_line with new_content, 'insert_before' inserts before start_line, 'insert_after' inserts after start_line, 'delete' removes lines start_line..end_line. Use this instead of file_edit when file_read line numbers identify the contiguous block to change. Use dry_run to preview changes.";
       parameters = {
         type: "object",
         properties: {
@@ -28885,12 +29007,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 +578113,46 @@ 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 stripShellQuotedSegments(command) {
+  let out = "";
+  let quote2 = null;
+  let escaped = false;
+  for (let i2 = 0; i2 < command.length; i2++) {
+    const ch = command[i2];
+    if (quote2 === "'") {
+      if (ch === "'")
+        quote2 = null;
+      out += " ";
+      continue;
+    }
+    if (quote2 === '"') {
+      if (escaped) {
+        escaped = false;
+        out += " ";
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        out += " ";
+        continue;
+      }
+      if (ch === '"')
+        quote2 = null;
+      out += " ";
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote2 = ch;
+      out += " ";
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
 function parsePersistentMemoryMode(value2) {
   if (value2 === "full" || value2 === "deferred" || value2 === "off")
     return value2;
@@ -579670,6 +579902,8 @@ ${parts.join("\n")}
           lines.push(`recent_failed_approaches=${ts.failedApproaches.slice(-3).join(" | ").replace(/\s+/g, " ").slice(0, 420)}`);
         }
         lines.push("tool_call_contract=Mutating/side-effectful tool calls require action_reason {task_anchor,intent,evidence,expected_result,scope}; read-only evidence tools may include it but must never be blocked only for missing metadata. Compact public facts only, no hidden chain-of-thought.");
+        lines.push("edit_transport_contract=file_edit is for exact unique current text copied from file_read; file_patch is for line-range delete/replace/insert using file_read line numbers and expected_hash/current target evidence. A failed file_edit invalidates the edit premise; rebuild from current evidence instead of broadening into file_write unless the task is truly whole-file replacement.");
+        lines.push("range_patch_contract=If patch_ready=true or current path+start_line+end_line+expected_hash are known, call file_patch. If read_required=true or a stale exact edit lacks current range/hash, call file_read once. Do not call file_read when patch_ready=true.");
         lines.push(`scope_contract=${Array.from(TOOL_ACTION_REASON_SCOPES).join("|")}; use targeted_patch for constrained code edits and full_file_rewrite only for deliberate whole-file replacement.`);
         const focus = this._focusSupervisor?.snapshot().directive ?? null;
         if (focus) {
@@ -579879,7 +580113,7 @@ ${parts.join("\n")}
           temperature: options2?.temperature ?? 0,
           requestTimeoutMs: options2?.requestTimeoutMs ?? 3e5,
           taskTimeoutMs: options2?.taskTimeoutMs ?? 0,
-          // 0 = no hard timeout (turn budget is the loop breaker)
+          // legacy health-check interval only; never a hard timeout
           compactionThreshold: options2?.compactionThreshold ?? 4e4,
           deepContext: options2?.deepContext ?? false,
           dynamicContext: options2?.dynamicContext ?? "",
@@ -583601,17 +583835,18 @@ ${contentPreview}
         const cmd = rawCmd.trim();
         if (!cmd)
           return false;
-        if (/(^|[^&\d])(>|>>)\s*\S/.test(cmd))
+        const unquoted = stripShellQuotedSegments(cmd);
+        if (/(^|[^&\d])(>|>>)\s*\S/.test(unquoted))
           return true;
-        if (/\|\s*(?:tee|dd)\b/i.test(cmd))
+        if (/\|\s*(?:tee|dd)\b/i.test(unquoted))
           return true;
-        if (/\b(?:sed|gsed)\s+(?:[^\n;&|]*\s)?(?:-i|--in-place)\b/i.test(cmd))
+        if (/\b(?:sed|gsed)\s+(?:[^\n;&|]*\s)?(?:-i|--in-place)\b/i.test(unquoted))
           return true;
-        if (/\bperl\s+-[A-Za-z]*i[A-Za-z]*\b/.test(cmd))
+        if (/\bperl\s+-[A-Za-z]*i[A-Za-z]*\b/.test(unquoted))
           return true;
-        if (/\b(?:cp|mv|rm|mkdir|rmdir|touch|truncate|ln|install|chmod|chown|chgrp|setfacl)\b/i.test(cmd))
+        if (/\b(?:cp|mv|rm|mkdir|rmdir|touch|truncate|ln|install|chmod|chown|chgrp|setfacl)\b/i.test(unquoted))
           return true;
-        if (/\b(?:udevadm|mount|umount|modprobe|insmod)\b/i.test(cmd))
+        if (/\b(?:udevadm|mount|umount|modprobe|insmod)\b/i.test(unquoted))
           return true;
         if (/\b(?:python3?|node|ruby|deno|bun)\b[\s\S]{0,240}\b(?:writeFile|writeFileSync|openSync|mkdirSync|renameSync|unlinkSync|rmSync)\b/i.test(cmd))
           return true;
@@ -585870,44 +586105,13 @@ Respond with your assessment, then take action.`;
         }
         const cleanedTask = cleanForStorage(task) || task.slice(0, 500);
         const start2 = Date.now();
-        const taskTimeoutMs = this.options.taskTimeoutMs;
-        const hardDeadlineMs = Number.isFinite(taskTimeoutMs) && taskTimeoutMs > 0 ? start2 + taskTimeoutMs : Number.POSITIVE_INFINITY;
-        let timedOut = false;
-        let timeoutSummary = "";
-        const remainingTaskMs = () => Number.isFinite(hardDeadlineMs) ? Math.max(0, hardDeadlineMs - Date.now()) : Number.POSITIVE_INFINITY;
+        const taskTimeoutMs = Number.isFinite(this.options.taskTimeoutMs) && this.options.taskTimeoutMs > 0 ? this.options.taskTimeoutMs : Number.POSITIVE_INFINITY;
         const boundedRequestTimeoutMs = () => {
           const configured = Number.isFinite(this.options.requestTimeoutMs) && this.options.requestTimeoutMs > 0 ? this.options.requestTimeoutMs : 3e5;
-          const remaining = remainingTaskMs();
-          return Number.isFinite(remaining) ? Math.max(1, Math.min(configured, remaining)) : configured;
-        };
-        const markTaskTimedOut = (phase, turn) => {
-          if (timedOut)
-            return;
-          timedOut = true;
-          timeoutSummary = `Incomplete: task timed out after ${taskTimeoutMs}ms during ${phase}.`;
-          this.emit({
-            type: "error",
-            content: timeoutSummary,
-            ...typeof turn === "number" ? { turn } : {},
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          this._onTypedEvent?.({
-            type: "run_failed",
-            runId: this._sessionId ?? "unknown",
-            error: timeoutSummary,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        };
-        const checkTaskTimeout = (phase, turn) => {
-          if (!Number.isFinite(hardDeadlineMs))
-            return false;
-          if (Date.now() < hardDeadlineMs)
-            return false;
-          markTaskTimedOut(phase, turn);
-          return true;
+          return configured;
         };
         const selfEvalInterval = taskTimeoutMs;
-        let nextSelfEval = start2 + selfEvalInterval;
+        let nextSelfEval = Number.isFinite(selfEvalInterval) ? start2 + selfEvalInterval : Number.POSITIVE_INFINITY;
         let selfEvalCount = 0;
         const toolCallLog = [];
         this.aborted = false;
@@ -586774,8 +586978,6 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         };
         const turnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
         for (let turn = 0; turn < turnCap; turn++) {
-          if (checkTaskTimeout("primary turn", turn))
-            break;
           clearTurnState(this._appState);
           this._maybeApplyThinkGuard();
           if (this._paused) {
@@ -588448,10 +588650,8 @@ ${memoryLines.join("\n")}`
                 break;
               }
             } else {
-              const recovered = await this.retryOnTransient(reqErr, chatRequest, turn, hardDeadlineMs);
+              const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
               if (!recovered) {
-                if (checkTaskTimeout("backend request", turn))
-                  break;
                 const errMsg = reqErr instanceof Error ? reqErr.message : String(reqErr);
                 const cause = reqErr instanceof Error && reqErr.cause ? ` (${reqErr.cause.message ?? ""} ${reqErr.cause?.code ?? ""})` : "";
                 this.emit({
@@ -592131,9 +592331,7 @@ Your most recent tool calls SUCCEEDED. If the task is complete, call task_comple
           }
         }
         let prevCycleToolCalls = toolCallCount;
-        while (!completed && !this.aborted && !this._completionIncompleteVerification && !timedOut && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
-          if (checkTaskTimeout("brute-force re-engagement"))
-            break;
+        while (!completed && !this.aborted && !this._completionIncompleteVerification && this.options.bruteForce && bruteForceCycle < this.options.bruteForceMaxCycles) {
           bruteForceCycle++;
           const totalTurns = messages2.filter((m2) => m2.role === "assistant").length;
           if (bruteForceCycle > 1 && toolCallCount === prevCycleToolCalls) {
@@ -592197,8 +592395,6 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
           }
           const restartTurnCap = this.options.maxTurns && this.options.maxTurns > 0 ? this.options.maxTurns : Number.MAX_SAFE_INTEGER;
           for (let turn = 0; turn < restartTurnCap; turn++) {
-            if (checkTaskTimeout("brute-force turn", turn))
-              break;
             if (this._completionIncompleteVerification)
               break;
             this._maybeApplyThinkGuard();
@@ -592327,10 +592523,8 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
                   break;
                 }
               } else {
-                const recovered = await this.retryOnTransient(reqErr, chatRequest, turn, hardDeadlineMs);
+                const recovered = await this.retryOnTransient(reqErr, chatRequest, turn);
                 if (!recovered) {
-                  if (checkTaskTimeout("brute-force backend request", turn))
-                    break;
                   const errMsg2 = reqErr instanceof Error ? reqErr.message : String(reqErr);
                   const cause2 = reqErr instanceof Error && reqErr.cause ? ` (${reqErr.cause.message ?? ""} ${reqErr.cause?.code ?? ""})` : "";
                   this.emit({
@@ -592807,9 +593001,6 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
         }
         const durationMs = Date.now() - start2;
         const incompleteVerification = this._completionIncompleteVerification;
-        if (timedOut && !summary) {
-          summary = timeoutSummary || `Incomplete: task timed out after ${taskTimeoutMs}ms.`;
-        }
         if (incompleteVerification && !summary) {
           summary = incompleteVerification.summary;
         }
@@ -594031,7 +594222,7 @@ ${marker}` : marker);
           try {
             raw = JSON.parse(trimmed);
           } catch {
-            return null;
+            return { intent: trimmed };
           }
         }
         if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -594048,8 +594239,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 +594249,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 +594341,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;
@@ -594324,10 +594547,11 @@ ${marker}` : marker);
           return null;
         if (process.env["OMNIUS_ALLOW_STALE_REPAIR_OVERWRITE"] === "1")
           return null;
-        if (this.options.modelTier !== "small" && this.options.modelTier !== "medium")
-          return null;
         if (args?.["dry_run"] === true || args?.["dryRun"] === true)
           return null;
+        const tier = this.options.modelTier ?? "large";
+        if (tier !== "small" && tier !== "medium")
+          return null;
         const path12 = this.extractPrimaryToolPath(args);
         if (!path12)
           return null;
@@ -594341,7 +594565,7 @@ ${marker}` : marker);
           return null;
         return [
           `[EDIT REPAIR LOCK] A recent narrow edit to ${active.path} failed because the model-visible target diverged from disk (${active.errorKind}; latest_file_hash=${active.latestFileHash || "unknown"}).`,
-          `This full-file overwrite was NOT executed. A stale narrow edit must not be repaired by broad file regeneration on ${this.options.modelTier ?? "unknown"} tier models.`,
+          `This full-file overwrite was NOT executed. A stale narrow edit must not be repaired by broad file regeneration; preserve a constrained edit path until fresh target evidence is used.`,
           ``,
           `Allowed next actions:`,
           `1. file_read ${active.path} once and construct file_edit from exact current text.`,
@@ -597663,6 +597887,8 @@ ${result}`
           return true;
         if (/stream timeout|no response or chunk within|no response within \d+\s*s|stream stalled/i.test(msg))
           return true;
+        if (/AbortError|operation was aborted|aborted due to timeout|signal timed out|timeout.*aborted/i.test(msg))
+          return true;
         if (/received HTML error page/i.test(msg))
           return true;
         if (/model is loading|server busy|overloaded/i.test(msg))
@@ -597943,11 +598169,13 @@ ${description}`
        * until recovery; other transient backend errors use bounded backoff.
        * Returns the response on success, or null if recovery did not apply.
        */
-      async retryOnTransient(initialErr, chatRequest, turn, hardDeadlineMs) {
+      async retryOnTransient(initialErr, chatRequest, turn) {
+        if (this.aborted)
+          return null;
         if (!this.isTransientError(initialErr))
           return null;
         const errMsg = flattenErrorText(initialErr);
-        const isNetworkError2 = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|socket hang up|UND_ERR|other side closed|stream timeout|no response or chunk within|no response within \d+\s*s|stream stalled/i.test(errMsg);
+        const isNetworkError2 = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|socket hang up|UND_ERR|other side closed|stream timeout|no response or chunk within|no response within \d+\s*s|stream stalled|AbortError|operation was aborted|aborted due to timeout|signal timed out|timeout.*aborted/i.test(errMsg);
         const isAuthError = this.isRecoverableAuthError(initialErr);
         const isGpuSlotUnavailable = this.isGpuSlotUnavailableError(initialErr);
         const maxRetries = isNetworkError2 || isGpuSlotUnavailable || isAuthError ? Infinity : 3;
@@ -597958,15 +598186,6 @@ ${description}`
         while (attempt <= (maxRetries === Infinity ? Number.MAX_SAFE_INTEGER : maxRetries)) {
           if (this.aborted)
             return null;
-          if (Number.isFinite(hardDeadlineMs) && Date.now() >= hardDeadlineMs) {
-            this.emit({
-              type: "error",
-              content: "Task timeout reached during backend retry",
-              turn,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            return null;
-          }
           if (this.isPaymentRequiredError(initialErr) && typeof backend.rotateKey === "function") {
             const rotated = backend.rotateKey();
             if (rotated) {
@@ -598016,7 +598235,7 @@ ${description}`
             }
           }
           const delay4 = isGpuSlotUnavailable ? baseDelayMs : Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
-          const effectiveDelay = Number.isFinite(hardDeadlineMs) ? Math.max(0, Math.min(delay4, hardDeadlineMs - Date.now())) : delay4;
+          const effectiveDelay = delay4;
           const attemptLabel = maxRetries === Infinity ? `${attempt}` : `${attempt}/${maxRetries}`;
           if (isGpuSlotUnavailable) {
             this.emit({
@@ -598034,15 +598253,6 @@ ${description}`
           await new Promise((r2) => setTimeout(r2, effectiveDelay));
           if (this.aborted)
             return null;
-          if (Number.isFinite(hardDeadlineMs) && Date.now() >= hardDeadlineMs) {
-            this.emit({
-              type: "error",
-              content: "Task timeout reached before backend retry could resume",
-              turn,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            return null;
-          }
           try {
             this._recordContextWindowDump("agent_turn_transient_retry", chatRequest, turn, attempt);
             const response = this.options.streamEnabled && this.hasStreamingSupport() ? await this.streamingRequest(chatRequest, turn) : await this.backend.chatCompletion(chatRequest);
@@ -688075,7 +688285,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 +688813,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 +688867,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 +689117,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 +689910,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 +689933,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 +695534,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 +695544,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 +695568,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 +695579,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 +695838,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
@@ -728318,8 +728338,9 @@ function adoptHandoffRuns() {
       } catch {
       }
     }
-    if (r2.deadlineAtMs && r2.deadlineAtMs > 0 && process.env["OMNIUS_DISABLE_DAEMON_TIMEOUT_KILL"] !== "1") {
-      const remainingMs = r2.deadlineAtMs - Date.now();
+    const adoptedDeadlineAtMs = typeof r2.deadlineAtMs === "number" && r2.deadlineAtMs > 0 ? r2.deadlineAtMs : 0;
+    if (false) {
+      const remainingMs = adoptedDeadlineAtMs - Date.now();
       const adoptedPid = r2.pid;
       const adoptedJobId = r2.jobId;
       const fireTimeout = () => {
@@ -728805,13 +728826,13 @@ function handleHelp(req3, res) {
         enable: "POST /v1/chat/completions with body {agent_loop: true} runs an N-turn server-side loop. Daemon executes any tool_calls matching daemon-resident tools and re-prompts; client-side tool_calls cause the loop to yield back so caller can execute them.",
         merge_daemon_tools: "Body field include_daemon_tools: ['read'] (or ['read','run']) merges the daemon's matching tools into the offered tools[] array automatically — no need to hand-list web_search/web_fetch/file_read/etc.",
         max_turns: "Body field max_turns (default 8, max 64).",
-        timeout: "Body field timeout_s caps the whole loop (default 30 min, max 1 hour). Per-backend-call timeout is separate (see OMNIUS_BACKEND_TIMEOUT_S).",
+        timeout: "Body field timeout_s is treated as a backend/request liveness hint only; it must not kill an active agent loop.",
         prompt_template: "Body field prompt_template: 'factual-first' prepends a system message instructing the model to call web_search FIRST for any factual question.",
         response_envelope: "Standard OpenAI chat.completion shape PLUS a _agent_loop: {turns, log:[], done, reason} field. Reason is one of: model_returned_content, client_tools_pending, max_turns_exhausted."
       },
       backend_timeout: {
         env: "OMNIUS_BACKEND_TIMEOUT_S — default 120 seconds, max 3600 (1 hour).",
-        per_request: "Body field timeout_s on /v1/chat/completions, /v1/run, agent_loop. Caps to 1h.",
+        per_request: "Body field timeout_s on /v1/chat/completions, /v1/run, agent_loop is request/backend liveness only, not a task deadline.",
         rationale: "Q1 (Cody/SA) — was hardcoded 120s, broke cold-start tool-calling thinks on large models."
       },
       run_lifecycle: {
@@ -730113,32 +730134,6 @@ ${task}` : task;
         }
       };
       onChildClose(child, finish);
-      const deadline = setTimeout(
-        () => {
-          if (done) return;
-          try {
-            if (child.pid) process.kill(-child.pid, "SIGTERM");
-          } catch {
-          }
-          try {
-            if (child.pid) process.kill(child.pid, "SIGTERM");
-          } catch {
-          }
-          setTimeout(() => {
-            try {
-              if (child.pid) process.kill(-child.pid, "SIGKILL");
-            } catch {
-            }
-            try {
-              if (child.pid) process.kill(child.pid, "SIGKILL");
-            } catch {
-            }
-            finish();
-          }, 3e3).unref();
-        },
-        (generateTimeoutS + 30) * 1e3
-      );
-      deadline.unref();
     });
     if (buf.trim()) finalLines.push(buf);
     const rawFinal = finalLines.join("\n").trim();
@@ -730205,33 +730200,6 @@ ${task}` : task;
       }
     };
     onChildClose(child, finish);
-    const deadline = setTimeout(
-      () => {
-        if (done) return;
-        killedByDeadline = true;
-        try {
-          if (child.pid) process.kill(-child.pid, "SIGTERM");
-        } catch {
-        }
-        try {
-          if (child.pid) process.kill(child.pid, "SIGTERM");
-        } catch {
-        }
-        setTimeout(() => {
-          try {
-            if (child.pid) process.kill(-child.pid, "SIGKILL");
-          } catch {
-          }
-          try {
-            if (child.pid) process.kill(child.pid, "SIGKILL");
-          } catch {
-          }
-          finish();
-        }, 3e3).unref();
-      },
-      (generateTimeoutS + 30) * 1e3
-    );
-    deadline.unref();
   });
   if (nonStreamBuf.trim()) nonStreamLines.push(nonStreamBuf);
   const rawNonStream = nonStreamLines.join("\n").trim();
@@ -730255,7 +730223,7 @@ ${task}` : task;
   } catch {
   }
   if (!content) {
-    const errMsg = killedByDeadline ? `Agent exceeded ${generateTimeoutS}s timeout and was killed.` : backendError ? `Backend error: ${backendError}` : "Agent produced no response.";
+    const errMsg = backendError ? `Backend error: ${backendError}` : "Agent produced no response.";
     jsonResponse(res, 200, {
       model: model.replace(/^[a-z]+\//, ""),
       created_at: createdAt,
@@ -730844,9 +730812,7 @@ async function handleV1Run(req3, res) {
   } catch {
   }
   let _rca1DeadlineFired = false;
-  const _rca1KillSwitch = process.env["OMNIUS_DISABLE_DAEMON_TIMEOUT_KILL"] === "1";
-  const _rca1EffectiveTimeoutS = timeout2 && timeout2 > 0 ? timeout2 : activeProfile?.limits?.timeout_s && activeProfile.limits.timeout_s > 0 ? activeProfile.limits.timeout_s : 1800;
-  const _rca1DeadlineAtMs = Date.now() + (_rca1EffectiveTimeoutS + 60) * 1e3;
+  const _rca1Deadline = null;
   if (job.pid > 0) {
     const runCtx = getOmniusRunContext();
     registerProcessLease({
@@ -730861,50 +730827,9 @@ async function handleV1Run(req3, res) {
       reason: `API run: ${task.slice(0, 240)}`,
       command: sandbox === "container" ? `container:${`omnius-${id2}`}` : [process.execPath, omniusBin, ...args].join(" "),
       cwd: cwd4,
-      hardDeadlineAt: _rca1DeadlineAtMs
+      hardDeadlineAt: void 0
     });
   }
-  if (!_rca1KillSwitch) {
-    job.deadlineAtMs = _rca1DeadlineAtMs;
-    atomicJobWrite(dir, id2, job);
-  }
-  const _rca1Deadline = _rca1KillSwitch ? null : setTimeout(
-    () => {
-      if (job.status !== "running") return;
-      _rca1DeadlineFired = true;
-      job.status = "timeout";
-      job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-      atomicJobWrite(dir, id2, job);
-      try {
-        if (child.pid) process.kill(-child.pid, "SIGTERM");
-      } catch {
-      }
-      try {
-        if (child.pid) process.kill(child.pid, "SIGTERM");
-      } catch {
-      }
-      setTimeout(() => {
-        try {
-          if (child.pid) process.kill(-child.pid, "SIGKILL");
-        } catch {
-        }
-        try {
-          if (child.pid) process.kill(child.pid, "SIGKILL");
-        } catch {
-        }
-      }, 3e4).unref();
-      try {
-        publishEvent(
-          "run.timeout",
-          { run_id: id2, deadline_s: _rca1EffectiveTimeoutS },
-          { subject: authUser, aimsControl: "A.6.2.6" }
-        );
-      } catch {
-      }
-    },
-    (_rca1EffectiveTimeoutS + 60) * 1e3
-  );
-  if (_rca1Deadline) _rca1Deadline.unref();
   if (streamMode) {
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -733990,7 +733915,7 @@ ${historyLines}
           reason: `chat run ${session.id}`,
           command: [process.execPath, omniusBin, ...args].join(" "),
           cwd: cwdPath,
-          hardDeadlineAt: Date.now() + chatTimeoutS * 1e3 + 3e4
+          hardDeadlineAt: void 0
         });
       }
       const releaseChatLease = (status2, reason) => {
@@ -734214,7 +734139,6 @@ ${historyLines}
         });
         child.stderr?.on("data", () => {
         });
-        const killDeadlineMs = chatTimeoutS * 1e3 + 3e4;
         let killedByDeadline = false;
         await new Promise((resolve77) => {
           let done = false;
@@ -734225,30 +734149,6 @@ ${historyLines}
             }
           };
           onChildClose(child, finish);
-          const deadline = setTimeout(() => {
-            if (done) return;
-            killedByDeadline = true;
-            try {
-              if (child.pid) process.kill(-child.pid, "SIGTERM");
-            } catch {
-            }
-            try {
-              if (child.pid) process.kill(child.pid, "SIGTERM");
-            } catch {
-            }
-            setTimeout(() => {
-              try {
-                if (child.pid) process.kill(-child.pid, "SIGKILL");
-              } catch {
-              }
-              try {
-                if (child.pid) process.kill(child.pid, "SIGKILL");
-              } catch {
-              }
-              finish();
-            }, 3e3).unref();
-          }, killDeadlineMs);
-          deadline.unref();
         });
         if (nonStreamBuf.trim()) nonStreamLines.push(nonStreamBuf);
         const rawNonStream = nonStreamLines.join("\n").trim();
@@ -734290,7 +734190,7 @@ ${historyLines}
           "X-Session-ID, X-Request-ID, X-API-Version, ETag"
         );
         if (!content) {
-          const errMsg = killedByDeadline ? `Agent exceeded ${chatTimeoutS}s timeout and was killed. Try a simpler prompt or increase timeout_s in the request body.` : backendError ? `Backend error: ${backendError}` : "Agent produced no response. The model may have failed to load (try a smaller model or check 'ollama ps' for VRAM contention).";
+          const errMsg = backendError ? `Backend error: ${backendError}` : "Agent produced no response. The model may have failed to load (try a smaller model or check 'ollama ps' for VRAM contention).";
           try {
             finishInFlightChat(
               session.id,
@@ -739713,8 +739613,6 @@ Only tools allowed by this profile are visible and executable.`
     maxTokens: realtimeEnabled ? 512 : 16384,
     temperature: realtimeEnabled ? 0.6 : 0,
     requestTimeoutMs: config.timeoutMs,
-    taskTimeoutMs: 36e5,
-    // 60 minutes — never give up prematurely
     compactionThreshold,
     deepContext: deepContext ?? false,
     dynamicContext,

package/npm-shrinkwrap.json

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

package/package.json

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