omnius 1.0.344 → 1.0.346

package/dist/index.js

@@ -568855,7 +568855,7 @@ RECOVERY: cd to the directory containing '${file}', run a plain install with no
 });
 
 // packages/orchestrator/dist/agenticRunner.js
-import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, appendFileSync as _fsAppendFileSync, unlinkSync as _fsUnlinkSync, mkdirSync as _fsMkdirSync } from "node:fs";
+import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync, writeFileSync as _fsWriteFileSync, appendFileSync as _fsAppendFileSync, unlinkSync as _fsUnlinkSync, mkdirSync as _fsMkdirSync, statSync as _fsStatSync } from "node:fs";
 import { execFile as _execFile, spawn as _spawn } from "node:child_process";
 import { createHash as _createHash } from "node:crypto";
 import { join as _pathJoin, resolve as _pathResolve } from "node:path";
@@ -570582,6 +570582,91 @@ Your hypotheses MUST address this specific error, not generic causes.
           return null;
         }
       }
+      // ── Failing-approach detector (the "stop retrying variants" reflex) ───────
+      // Encodes the behavior an effective agent uses and the dropbear 27× loop
+      // lacked: when the SAME error recurs ~3× — especially while the same target
+      // is edited again and again — the error is telling you the CHANGE is wrong
+      // (an unsupported attribute, a wrong API/signature, a missing dep), not that
+      // you haven't found the right value yet. Stop, diagnose the root cause from
+      // the full error, verify the correct contract, then act — do NOT re-apply a
+      // variant. Distinct from REG-58/60 (no-write / slow-write): this fires while
+      // edits ARE landing but verification keeps failing the same way.
+      _failingApproachCooldownUntil = -1;
+      /**
+       * Most-common normalized failure signature in the recent window, or null if
+       * no signature recurs ≥3×. Normalization drops the VARYING tokens (quoted
+       * names, paths, numbers) so "unrecognized attribute: 'nstack'" and
+       * "...: 'narena'" collapse to one signature. Transient/network failures are
+       * excluded — retrying those is legitimate, not a failing approach.
+       */
+      _recurringFailureSignature(turn, window2 = 10) {
+        const recent = this._recentFailures.filter((f2) => turn - f2.turn <= window2);
+        if (recent.length < 3)
+          return null;
+        const TRANSIENT = /timed? ?out|timeout|econnreset|econnrefused|etimedout|rate.?limit|503|502|temporarily|try again|socket hang|network|fetch failed/i;
+        const norm = (s2) => s2.toLowerCase().replace(/['"`][^'"`]*['"`]/g, " ").replace(/\/[^\s:]+/g, " ").replace(/\d+/g, " ").replace(/\s+/g, " ").trim().slice(0, 80);
+        const groups = /* @__PURE__ */ new Map();
+        for (const f2 of recent) {
+          const raw = (f2.error || f2.output || "").slice(0, 200);
+          if (!raw || TRANSIENT.test(raw))
+            continue;
+          const sig = norm(raw);
+          if (!sig)
+            continue;
+          const g = groups.get(sig) ?? { count: 0, sample: raw };
+          g.count++;
+          groups.set(sig, g);
+        }
+        let best = null;
+        for (const [signature, g] of groups) {
+          if (!best || g.count > best.count)
+            best = { signature, count: g.count, sample: g.sample };
+        }
+        return best && best.count >= 3 ? best : null;
+      }
+      /**
+       * Detect a failing approach and return a decisive root-cause directive, or
+       * null. Fires when a non-transient error recurs ≥3× in the recent window
+       * (optionally corroborated by the error-cluster tracker), self-cooldown 8
+       * turns. OMNIUS_DISABLE_FAILING_APPROACH=1 disables.
+       */
+      _detectFailingApproach(turn) {
+        if (process.env["OMNIUS_DISABLE_FAILING_APPROACH"] === "1")
+          return null;
+        if (turn <= this._failingApproachCooldownUntil)
+          return null;
+        const recurring = this._recurringFailureSignature(turn);
+        if (!recurring)
+          return null;
+        let churnPath = null;
+        let churnWrites = 0;
+        const wf = this._worldFacts;
+        if (wf) {
+          for (const [p2, info] of wf.files) {
+            const writes = info.writeCount ?? 0;
+            const age = turn - (info.lastWriteTurn ?? -999);
+            if (writes >= 3 && age <= 8 && writes > churnWrites) {
+              churnWrites = writes;
+              churnPath = p2;
+            }
+          }
+        }
+        this._failingApproachCooldownUntil = turn + 8;
+        const target = churnPath ? `${churnPath} (edited ${churnWrites}× recently)` : "the same target";
+        return [
+          `[FAILING APPROACH DETECTED — stop retrying variants]`,
+          `The SAME error has recurred ${recurring.count}× in your recent attempts while you keep changing ${target}:`,
+          `  ${recurring.sample}`,
+          ``,
+          `Trying another variant of the same change is not converging. A repeating error means the CHANGE ITSELF is wrong — an unsupported attribute/option, a wrong API or signature, or a missing prerequisite — not that you haven't hit the right value yet.`,
+          `MANDATORY before your next edit:`,
+          `  1. Re-read the FULL error above and name the EXACT token it rejects (attribute / symbol / flag / path).`,
+          `  2. VERIFY the correct contract for that token from an authoritative source — read the defining file, the schema, or the API/docs. Do NOT guess.`,
+          `  3. State the root cause in one sentence: "<token> fails because <reason>."`,
+          `  4. Then make ONE change that step 2 supports. If the thing you want is genuinely unsupported, REMOVE it and choose a supported alternative — do not re-add a variant.`,
+          `Do NOT re-apply another variant of the rejected change.`
+        ].join("\n");
+      }
       /**
        * REG-61 sliding-window first-edit / sustained-edit nudge.
        *
@@ -575516,6 +575601,28 @@ TASK: ${scrubbedTask}` : scrubbedTask;
             });
           }
           this._runReg61Check(turn, toolCallLog, messages2);
+          if (turn > stagnationCooldownUntilTurn) {
+            const failingApproach = this._detectFailingApproach(turn);
+            if (failingApproach) {
+              messages2.push({ role: "system", content: failingApproach });
+              stagnationCooldownUntilTurn = turn + 4;
+              this.emit({
+                type: "adversary_reaction",
+                adversary: {
+                  class: "guidance",
+                  shortText: "Failing approach — same error recurring; diagnose root cause",
+                  confidence: 0.9,
+                  details: failingApproach
+                },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              this.emit({
+                type: "status",
+                content: `FAILING-APPROACH detected at turn ${turn} — injected root-cause directive`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
           const REG58_NO_WRITE_BUDGET = 30;
           if (turn > stagnationCooldownUntilTurn && this._lastFileWriteTurn >= 0 && turn - this._lastFileWriteTurn >= REG58_NO_WRITE_BUDGET && process.env["OMNIUS_DISABLE_REG58"] !== "1") {
             const gap = turn - this._lastFileWriteTurn;
@@ -578723,41 +578830,63 @@ Respond with EXACTLY this structure before your next tool call:
                 result = await this.offloadEmbeddedImageResult(result, tc.name, turn);
               }
               let output = this.normalizeToolOutput(result, tc.name, tc.arguments, turn);
-              if (process.env["OMNIUS_DISABLE_BRANCH_EXTRACT"] !== "1" && this.lookupRegisteredTool(tc.name)?.name === "file_read" && result.success && typeof result.output === "string" && this.backend && typeof this.backend.chatCompletion === "function") {
+              if (process.env["OMNIUS_DISABLE_BRANCH_EXTRACT"] !== "1" && this.lookupRegisteredTool(tc.name)?.name === "file_read" && result.success && this.backend && typeof this.backend.chatCompletion === "function") {
                 const a2 = tc.arguments ?? {};
-                const hasSmallRange = typeof a2["limit"] === "number" && a2["limit"] <= 80;
-                const lineCount = result.output.split("\n").length;
-                if (shouldBranchRead(result.output.length, lineCount, hasSmallRange)) {
-                  const p2 = String(a2["path"] ?? a2["file"] ?? a2["file_path"] ?? "");
-                  const lastAssistant = [...messages2].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
-                  const query = [
-                    this._taskState.goal ?? "",
-                    typeof lastAssistant?.content === "string" ? lastAssistant.content : ""
-                  ].join(" ").trim().slice(0, 400) || "key facts, configuration, and structure";
-                  try {
-                    const ev = await extractEvidence({
-                      path: p2,
-                      query,
-                      content: result.output,
-                      fileVersion: this._worldFacts.files.get(p2)?.writeCount ?? 0,
-                      backend: this.backend,
-                      timeoutMs: 3e4
-                    });
-                    output = [
-                      `[BRANCH-EXTRACT] ${p2} is large (${lineCount} lines, ${result.output.length} chars) — read in an isolated branch so it does not flood your context.`,
-                      `Distilled for: "${query.slice(0, 160)}"`,
-                      `Relevant evidence (lines ${ev.sourceStart ?? "?"}-${ev.sourceEnd ?? "?"}, confidence ${ev.confidence.toFixed(2)}):`,
-                      ev.claim,
-                      `If you need a different region, call file_read with a specific offset+limit, or extract_evidence(path, query) with a sharper question.`
-                    ].join("\n");
-                    this.emit({
-                      type: "status",
-                      toolName: tc.name,
-                      content: `Branch-extract: ${p2} (${lineCount} lines) → ${ev.injectedChars} chars to context (${(result.output.length / Math.max(1, ev.injectedChars)).toFixed(0)}× smaller)`,
-                      turn,
-                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                    });
-                  } catch {
+                const hasExplicitRange = typeof a2["offset"] === "number" || typeof a2["limit"] === "number";
+                const pRaw = String(a2["path"] ?? a2["file"] ?? a2["file_path"] ?? "");
+                if (!hasExplicitRange && pRaw) {
+                  let fullContent = null;
+                  let trueLines = 0;
+                  let trueBytes = 0;
+                  for (const cand of [
+                    pRaw,
+                    _pathResolve(this._workingDirectory || process.cwd(), pRaw)
+                  ]) {
+                    try {
+                      const st = _fsStatSync(cand);
+                      if (st.isFile()) {
+                        trueBytes = st.size;
+                        if (trueBytes > 8e3) {
+                          fullContent = _fsReadFileSync(cand, "utf-8");
+                          trueLines = fullContent.split("\n").length;
+                        }
+                        break;
+                      }
+                    } catch {
+                    }
+                  }
+                  if (fullContent && shouldBranchRead(trueBytes, trueLines, false)) {
+                    const lastAssistant = [...messages2].reverse().find((m2) => m2.role === "assistant" && typeof m2.content === "string");
+                    const query = [
+                      this._taskState.goal ?? "",
+                      typeof lastAssistant?.content === "string" ? lastAssistant.content : ""
+                    ].join(" ").trim().slice(0, 400) || "key facts, configuration, and structure";
+                    try {
+                      const ev = await extractEvidence({
+                        path: pRaw,
+                        query,
+                        content: fullContent,
+                        // the REAL body, not the preview
+                        fileVersion: this._worldFacts.files.get(pRaw)?.writeCount ?? 0,
+                        backend: this.backend,
+                        timeoutMs: 3e4
+                      });
+                      output = [
+                        `[BRANCH-EXTRACT] ${pRaw} is large (${trueLines} lines, ${trueBytes} bytes); a whole-file read only returns a preview, so it was read in an isolated branch and distilled.`,
+                        `Distilled for: "${query.slice(0, 160)}"`,
+                        `Relevant evidence (lines ${ev.sourceStart ?? "?"}-${ev.sourceEnd ?? "?"}, confidence ${ev.confidence.toFixed(2)}):`,
+                        ev.claim,
+                        `If you need a different region, call file_read with a specific offset+limit. Do NOT re-read the whole file — you already have the relevant content above.`
+                      ].join("\n");
+                      this.emit({
+                        type: "status",
+                        toolName: tc.name,
+                        content: `Branch-extract: ${pRaw} (${trueLines} lines / ${trueBytes}B) → ${ev.injectedChars} chars to context (${(trueBytes / Math.max(1, ev.injectedChars)).toFixed(0)}× smaller)`,
+                        turn,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    } catch {
+                    }
                   }
                 }
               }
@@ -584252,6 +584381,8 @@ ${result}`
           return true;
         if (/fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EPIPE|socket hang up|UND_ERR|other side closed/i.test(msg))
           return true;
+        if (/stream timeout|no response or chunk within|no response within \d+\s*s|stream stalled/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))
@@ -584495,7 +584626,7 @@ ${description}`
         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/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/i.test(errMsg);
         const isAuthError = this.isRecoverableAuthError(initialErr);
         const isGpuSlotUnavailable = this.isGpuSlotUnavailableError(initialErr);
         const maxRetries = isNetworkError2 || isGpuSlotUnavailable || isAuthError ? Infinity : 3;

package/npm-shrinkwrap.json

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

package/package.json

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