omnius 1.0.346 → 1.0.347

package/dist/index.js

@@ -567219,7 +567219,7 @@ function adversarySystemPrompt() {
     "",
     "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|ok",',
+    '{"class":"false_success|unproven_claim|weak_evidence|false_failure|repeated_action|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",',
@@ -567232,6 +567232,24 @@ function adversarySystemPrompt() {
 function buildObservationPrompt(obs, recentLedger) {
   const outcomes = obs.recentToolOutcomes.slice(-8).map((o2) => `  - ${o2.tool}: ${o2.succeeded ? "OK" : "FAIL"} — ${o2.preview.slice(0, 120)}`).join("\n");
   const priorDoubts = recentLedger.slice(-3).filter((e2) => e2.verdict !== "ok").map((e2) => `  - turn ${e2.turn}: ${e2.verdict} — demanded: ${e2.demand}`).join("\n");
+  if (obs.loopSignal) {
+    const ls2 = obs.loopSignal;
+    return [
+      `The agent has repeated the SAME action ${ls2.count}× this run: ${ls2.tool} on ${ls2.target}.`,
+      `This is a loop. Reason about WHY — for THIS specific call, not generically.`,
+      ls2.alreadyHave ? `Evidence the agent ALREADY obtained from a prior identical call:
+${ls2.alreadyHave.slice(0, 900)}` : `(No cached result available for the repeated call.)`,
+      "",
+      "Agent's latest message:",
+      obs.assistantText.slice(0, 1200) || "(empty)",
+      "",
+      "Recent tool outcomes:",
+      outcomes || "  (none)",
+      "",
+      `Decide: does the agent already HAVE what this repeated call would return (class "repeated_action"), and if so what should it do INSTEAD? Be concrete — cite the specific content above, name the next action. If the repeat is actually justified (state genuinely changed), say 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.",
     "",
@@ -567263,6 +567281,7 @@ function parseAdversaryCritique(raw) {
   }
   const cls = String(obj["class"] ?? "").toLowerCase();
   const valid = [
+    "repeated_action",
     "false_success",
     "unproven_claim",
     "weak_evidence",
@@ -567316,17 +567335,22 @@ var init_adversaryStream = __esm({
       shouldAudit(obs) {
         if (obs.claimsCompletion)
           return true;
+        if (obs.loopSignal)
+          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 sig = `${obs.turn}:${obs.assistantText.slice(0, 200)}`;
+        const loopKey = obs.loopSignal ? `loop:${obs.loopSignal.tool}:${obs.loopSignal.target}:${obs.loopSignal.count}` : "";
+        const sig = `${obs.turn}:${loopKey}:${obs.assistantText.slice(0, 200)}`;
         if (sig === this.lastAuditedSignature)
           return;
         this.pending = obs;
+        this._pendingSig = sig;
       }
+      _pendingSig = "";
       /**
        * Fire the adversary inference if there is a pending observation and no call
        * in flight. Detached/non-blocking — resolves when (or if) a critique lands.
@@ -567337,21 +567361,23 @@ var init_adversaryStream = __esm({
           return null;
         const obs = this.pending;
         this.pending = null;
-        this.lastAuditedSignature = `${obs.turn}:${obs.assistantText.slice(0, 200)}`;
+        this.lastAuditedSignature = this._pendingSig || `${obs.turn}:${obs.assistantText.slice(0, 200)}`;
         this.inFlight = true;
         try {
-          const resp = await this.backend.chatCompletion({
-            messages: [
-              { role: "system", content: adversarySystemPrompt() },
-              { role: "user", content: buildObservationPrompt(obs, this.ledger) }
-            ],
-            tools: [],
-            temperature: 0,
-            maxTokens: 400,
-            timeoutMs: this.timeoutMs
-          });
-          const content = resp.choices?.[0]?.message?.content ?? "";
-          const critique2 = parseAdversaryCritique(content);
+          let critique2 = null;
+          for (let attempt = 0; attempt < 2 && !critique2; attempt++) {
+            const resp = await this.backend.chatCompletion({
+              messages: [
+                { role: "system", content: adversarySystemPrompt() },
+                { role: "user", content: buildObservationPrompt(obs, this.ledger) }
+              ],
+              tools: [],
+              temperature: 0,
+              maxTokens: 900,
+              timeoutMs: this.timeoutMs
+            });
+            critique2 = parseAdversaryCritique(resp.choices?.[0]?.message?.content ?? "");
+          }
           if (!critique2)
             return null;
           this.ledger.push({
@@ -570624,6 +570650,29 @@ 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.
+       */
+      _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);
+          }
+        };
+      }
       /**
        * 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
@@ -575187,7 +575236,9 @@ TASK: ${scrubbedTask}` : scrubbedTask;
         if (this.options.disableAdversaryCritic !== true && this.backend && typeof this.backend.chatCompletion === "function") {
           const persistPath = this._workingDirectory ? _pathJoin(this._workingDirectory, ".omnius", "memory", "adversary-stream.json") : null;
           this._adversaryStream = new AdversaryStream({
-            backend: this.backend,
+            // Native /api/chat (think:false honored) — NOT /v1, which returns empty
+            // for tool-less think-off calls on qwen3-family models.
+            backend: this._auxInferenceBackend(),
             persistPath,
             onCritique: (critique2, sourceTurn) => {
               if (this._adversaryMode === "skillcoach" || this._adversaryMode === "both") {
@@ -577755,6 +577806,24 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   },
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
+                if (this._adversaryStream && criticDecision.hitNumber >= 2) {
+                  const _args = tc.arguments;
+                  const _target = String(_args?.["path"] ?? _args?.["file"] ?? _args?.["command"] ?? JSON.stringify(_args ?? {}).slice(0, 80));
+                  this._adversaryStream.observe({
+                    turn,
+                    assistantText: "",
+                    recentToolOutcomes: this._adversaryToolOutcomes.slice(-8).map((o2) => ({ tool: o2.tool, succeeded: o2.succeeded, preview: o2.preview })),
+                    claimsCompletion: false,
+                    loopSignal: {
+                      tool: tc.name,
+                      target: _target,
+                      count: criticDecision.hitNumber,
+                      alreadyHave: _existingFp?.result
+                    }
+                  });
+                  void this._adversaryStream.tick().catch(() => {
+                  });
+                }
                 const _repeatGateMax = this._resolveRepeatGateMax();
                 const repeatGateEligible = isReadLike || tc.name === "memory_write";
                 if (repeatGateEligible && _existingFp !== void 0 && _repeatGateMax > 0) {
@@ -578868,7 +578937,9 @@ Respond with EXACTLY this structure before your next tool call:
                         content: fullContent,
                         // the REAL body, not the preview
                         fileVersion: this._worldFacts.files.get(pRaw)?.writeCount ?? 0,
-                        backend: this.backend,
+                        // Native /api/chat so the extractor LLM fallback isn't
+                        // silently empty on qwen3-family models.
+                        backend: this._auxInferenceBackend(),
                         timeoutMs: 3e4
                       });
                       output = [

package/npm-shrinkwrap.json

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

package/package.json

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