omnius 1.0.345 → 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({
@@ -568855,7 +568881,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";
@@ -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) {
@@ -578830,41 +578899,65 @@ 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,
+                        // Native /api/chat so the extractor LLM fallback isn't
+                        // silently empty on qwen3-family models.
+                        backend: this._auxInferenceBackend(),
+                        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 {
+                    }
                   }
                 }
               }
@@ -584359,6 +584452,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))
@@ -584602,7 +584697,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.345",
+  "version": "1.0.347",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.345",
+      "version": "1.0.347",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.345",
+  "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",