omnius 1.0.354 → 1.0.356

package/dist/index.js

@@ -567216,10 +567216,13 @@ function adversarySystemPrompt() {
     "  • simulation / mock / placeholder ≠ real.",
     "  • partial progress ≠ done.",
     "Mixed results are the norm: do NOT let one success excuse an unproven completion claim.",
+    "  • a repeating IDENTICAL error while the agent keeps editing the same target = a FAILING",
+    "    APPROACH: the change itself is wrong (an unsupported token / wrong API / missing",
+    '    prerequisite), not a value to retry. Class "failing_approach".',
     "",
     "Given the agent's latest message and recent tool outcomes, decide whether the claim is proven.",
     "Respond with ONLY a JSON object, no prose, no code fences:",
-    '{"class":"false_success|unproven_claim|weak_evidence|false_failure|repeated_action|ok",',
+    '{"class":"false_success|unproven_claim|weak_evidence|false_failure|repeated_action|failing_approach|ok",',
     ' "shortText":"<=12 word headline",',
     ' "confidence":0.0-1.0,  // how strongly the claim is NOT proven',
     ' "details":"2-4 sentence skeptical critique citing the specific gap",',
@@ -567250,6 +567253,26 @@ ${ls2.alreadyHave.slice(0, 900)}` : `(No cached result available for the repeate
       "Return ONLY the JSON object."
     ].join("\n");
   }
+  if (obs.failingApproach) {
+    const fa = obs.failingApproach;
+    const target = fa.churnTarget ? `${fa.churnTarget} (edited ${fa.churnWrites ?? "several"}× recently)` : "the same target";
+    return [
+      `The agent is in a FAILING APPROACH: the SAME error has recurred ${fa.count}× while it keeps changing ${target}.`,
+      `The recurring error:`,
+      `  ${fa.sample.slice(0, 400)}`,
+      "",
+      "A repeating identical error means the CHANGE ITSELF is wrong — an unsupported attribute/option, a wrong API/signature, or a missing prerequisite — NOT a value the agent hasn't guessed yet.",
+      "",
+      "Agent's latest message:",
+      obs.assistantText.slice(0, 900) || "(empty)",
+      "",
+      "Recent tool outcomes:",
+      outcomes || "  (none)",
+      "",
+      `Reason about THIS specific error. Identify the EXACT token it rejects (attribute/symbol/flag/path) and the root cause. Return class "failing_approach" with a "demand" that names the ONE authoritative source to verify the correct contract (the defining file / schema / API doc) and the supported alternative to use — or, if the feature is genuinely unsupported, to REMOVE it. If the error is actually transient or unrelated, class "ok".`,
+      "Return ONLY the JSON object."
+    ].join("\n");
+  }
   return [
     obs.claimsCompletion ? "The agent is asserting COMPLETION this turn." : "The agent produced a progress/success-flavored claim this turn.",
     "",
@@ -567286,6 +567309,7 @@ function parseAdversaryCritique(raw) {
     "unproven_claim",
     "weak_evidence",
     "false_failure",
+    "failing_approach",
     "ok"
   ];
   const klass = valid.includes(cls) ? cls : "unproven_claim";
@@ -567337,13 +567361,15 @@ var init_adversaryStream = __esm({
           return true;
         if (obs.loopSignal)
           return true;
+        if (obs.failingApproach)
+          return true;
         return SUCCESS_LANGUAGE.test(obs.assistantText);
       }
       /** Ingest an observation. Replaces any prior un-audited pending observation. */
       observe(obs) {
         if (!this.shouldAudit(obs))
           return;
-        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : "";
+        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : obs.failingApproach ? `fail:${obs.failingApproach.count}:${obs.failingApproach.sample.slice(0, 60)}` : "";
         const sig = `${obs.turn}:${loopKey}:${obs.assistantText.slice(0, 200)}`;
         if (sig === this.lastAuditedSignature)
           return;
@@ -570895,25 +570921,24 @@ Your hypotheses MUST address this specific error, not generic causes.
         return best && best.count >= 3 ? best : null;
       }
       /**
-       * Backend adapter for AUXILIARY inference (adversary critiques, branch
-       * extraction) — tool-less, think-off, JSON-shaped calls. The main backend's
-       * chatCompletion routes to Ollama's /v1/chat/completions, where qwen3-family
-       * models IGNORE think:false and /no_think and (with no tools to anchor
-       * output) emit a reasoning-only response that gets stripped to EMPTY. The
-       * native /api/chat path honors think:false. This adapter prefers it and sets
-       * a responseFormat so the native path enforces JSON mode. Falls back to
-       * chatCompletion for non-Ollama backends.
+       * Backend adapter for AUXILIARY inference (adversary critiques, resolution
+       * gate, branch extraction) — tool-less, think-off, JSON-shaped calls. Uses the
+       * SAME inference backend the main agent loop uses — whatever provider the user
+       * selected — and only ensures a JSON responseFormat for these structured
+       * calls. Provider-specific quirks (e.g. Ollama /v1 + qwen3 returning an empty
+       * reasoning-only response for tool-less think-off calls) are recovered INSIDE
+       * the backend's own chatCompletion (empty-recovery → native /api/chat
+       * fallback), so no caller here is Ollama-aware.
        */
       _auxInferenceBackend() {
         const b = this.backend;
-        const useNative = typeof b.nativeOllamaChatCompletion === "function";
         return {
           chatCompletion: (req3) => {
             const r2 = {
               ...req3,
               responseFormat: req3.responseFormat ?? { type: "json_object" }
             };
-            return useNative ? b.nativeOllamaChatCompletion(r2) : b.chatCompletion(r2);
+            return b.chatCompletion(r2);
           }
         };
       }
@@ -570963,7 +570988,15 @@ Your hypotheses MUST address this specific error, not generic causes.
        * (optionally corroborated by the error-cluster tracker), self-cooldown 8
        * turns. OMNIUS_DISABLE_FAILING_APPROACH=1 disables.
        */
-      _detectFailingApproach(turn) {
+      /**
+       * Detect a FAILING APPROACH (same error recurring ≥N× while churning the same
+       * target) and return the STRUCTURED signal. The runtime routes this signal
+       * through the generative AdversaryStream (real per-case inference) rather than
+       * emitting a canned directive; `_failingApproachDirective` builds the templated
+       * fallback used ONLY when the adversary is disabled. Sets the cooldown so a
+       * detection (via either path) does not re-fire immediately.
+       */
+      _detectFailingApproachSignal(turn) {
         if (process.env["OMNIUS_DISABLE_FAILING_APPROACH"] === "1")
           return null;
         if (turn <= this._failingApproachCooldownUntil)
@@ -570971,7 +571004,7 @@ Your hypotheses MUST address this specific error, not generic causes.
         const recurring = this._recurringFailureSignature(turn);
         if (!recurring)
           return null;
-        let churnPath = null;
+        let churnPath;
         let churnWrites = 0;
         const wf = this._worldFacts;
         if (wf) {
@@ -570985,11 +571018,25 @@ Your hypotheses MUST address this specific error, not generic causes.
           }
         }
         this._failingApproachCooldownUntil = turn + 8;
-        const target = churnPath ? `${churnPath} (edited ${churnWrites}× recently)` : "the same target";
+        return {
+          count: recurring.count,
+          sample: recurring.sample,
+          churnTarget: churnPath,
+          churnWrites: churnWrites || void 0
+        };
+      }
+      /**
+       * Deterministic templated directive built from a failing-approach signal.
+       * Used ONLY as a fallback when the generative adversary is disabled
+       * (disableAdversaryCritic). Normally the signal is routed through real
+       * inference so the wording is reasoned per-case, not canned.
+       */
+      _failingApproachDirective(fa) {
+        const target = fa.churnTarget ? `${fa.churnTarget} (edited ${fa.churnWrites ?? "several"}× 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}`,
+          `The SAME error has recurred ${fa.count}× in your recent attempts while you keep changing ${target}:`,
+          `  ${fa.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:`,
@@ -571000,6 +571047,11 @@ Your hypotheses MUST address this specific error, not generic causes.
           `Do NOT re-apply another variant of the rejected change.`
         ].join("\n");
       }
+      /** Back-compat wrapper: structured detection → templated directive. */
+      _detectFailingApproach(turn) {
+        const fa = this._detectFailingApproachSignal(turn);
+        return fa ? this._failingApproachDirective(fa) : null;
+      }
       /**
        * REG-61 sliding-window first-edit / sustained-edit nudge.
        *
@@ -576114,25 +576166,52 @@ TASK: ${scrubbedTask}` : scrubbedTask;
           }
           this._runReg61Check(turn, toolCallLog, messages2);
           if (turn > stagnationCooldownUntilTurn) {
-            const failingApproach = this._detectFailingApproach(turn);
-            if (failingApproach) {
-              messages2.push({ role: "system", content: failingApproach });
+            const faSignal = this._detectFailingApproachSignal(turn);
+            if (faSignal) {
               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()
-              });
+              if (this._adversaryStream) {
+                this._adversaryStream.observe({
+                  turn,
+                  assistantText: "",
+                  recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({
+                    tool: o2.tool,
+                    succeeded: o2.succeeded,
+                    preview: o2.preview
+                  })),
+                  claimsCompletion: false,
+                  failingApproach: {
+                    count: faSignal.count,
+                    sample: faSignal.sample,
+                    churnTarget: faSignal.churnTarget,
+                    churnWrites: faSignal.churnWrites
+                  }
+                });
+                void this._adversaryStream.tick().catch(() => {
+                });
+                this.emit({
+                  type: "status",
+                  content: `FAILING-APPROACH detected at turn ${turn} — routed to adversary inference`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              } else {
+                const directive = this._failingApproachDirective(faSignal);
+                messages2.push({ role: "system", content: directive });
+                this.emit({
+                  type: "adversary_reaction",
+                  adversary: {
+                    class: "guidance",
+                    shortText: "Failing approach — same error recurring; diagnose root cause",
+                    confidence: 0.9,
+                    details: directive
+                  },
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this.emit({
+                  type: "status",
+                  content: `FAILING-APPROACH detected at turn ${turn} — injected root-cause directive (deterministic fallback; adversary disabled)`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
             }
           }
           const REG58_NO_WRITE_BUDGET = 30;
@@ -585983,6 +586062,15 @@ ${description}`
           const justSuppressed = this._thinkSuppressed && this._thinkFailStreak === _OllamaAgenticBackend._thinkFailThreshold;
           const shouldRetryThinkGuard = outcome !== null && effectiveThink === true && (justSuppressed || outcome === "empty_after_strip" || outcome === "unclosed_think");
           if (shouldRetryThinkGuard || shouldRecoverFromEmpty) {
+            if (shouldRecoverFromEmpty) {
+              try {
+                const _native = await this.nativeOllamaChatCompletion(request);
+                const _nText = String(_native.choices?.[0]?.message?.content ?? "");
+                if (_nText.trim().length >= 2)
+                  return _native;
+              } catch {
+              }
+            }
             const retryMessages = injectNoThinkDirective(requestMessages);
             const retryBody = {
               model: this.model,

package/npm-shrinkwrap.json

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

package/package.json

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