omnius 1.0.344 → 1.0.345

package/dist/index.js

@@ -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;

package/npm-shrinkwrap.json

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

package/package.json

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