omnius 1.0.346 → 1.0.348

package/dist/index.js

@@ -547778,9 +547778,9 @@ function _findNemotronScript() {
   return null;
 }
 function _wordSimilarity(a2, b) {
-  const tokenize6 = (s2) => new Set(s2.toLowerCase().replace(/[^a-z0-9\s']/g, " ").split(/\s+/).filter(Boolean));
-  const sa = tokenize6(a2);
-  const sb = tokenize6(b);
+  const tokenize7 = (s2) => new Set(s2.toLowerCase().replace(/[^a-z0-9\s']/g, " ").split(/\s+/).filter(Boolean));
+  const sa = tokenize7(a2);
+  const sb = tokenize7(b);
   if (sa.size === 0 && sb.size === 0)
     return 1;
   let inter = 0;
@@ -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({
@@ -567660,6 +567686,164 @@ var init_evidenceBranch = __esm({
   }
 });
 
+// packages/orchestrator/dist/resolution-memory.js
+function tokenize6(command) {
+  return command.replace(/[|&;]+/g, " ").split(/\s+/).map((t2) => t2.trim()).filter((t2) => t2.length > 0);
+}
+function normalizeErrorKey(error) {
+  const e2 = error.toLowerCase();
+  if (/command not found|not found|no such file|enoent/.test(e2))
+    return "not found";
+  if (/permission denied|eacces/.test(e2))
+    return "permission denied";
+  if (/unrecognized|unknown option|invalid option|no such option/.test(e2))
+    return "bad option";
+  if (/unexpected keyword|got an unexpected/.test(e2))
+    return "bad argument";
+  if (/syntax error|invalid syntax/.test(e2))
+    return "syntax error";
+  if (/module|importerror|modulenotfound/.test(e2))
+    return "missing module";
+  return e2.replace(/['"`].*?['"`]/g, "").replace(/\d+/g, "").replace(/\s+/g, " ").trim().split(" ").slice(0, 6).join(" ");
+}
+function isNearVariant(a2, b) {
+  if (a2.length === 0 || b.length === 0)
+    return false;
+  const setA = new Set(a2);
+  const setB = new Set(b);
+  const shared = [...setA].filter((t2) => setB.has(t2));
+  const sharedOperative = shared.some((t2) => t2.length >= 3 && !t2.startsWith("-"));
+  if (!sharedOperative)
+    return false;
+  const onlyA = [...setA].filter((t2) => !setB.has(t2));
+  const onlyB = [...setB].filter((t2) => !setA.has(t2));
+  return onlyA.length > 0 && onlyA.length <= MAX_DELTA_TOKENS && onlyB.length <= MAX_DELTA_TOKENS;
+}
+function computeDelta(failed, worked) {
+  const setF = new Set(failed);
+  const setW = new Set(worked);
+  const from3 = failed.filter((t2) => !setW.has(t2));
+  const to = worked.filter((t2) => !setF.has(t2));
+  if (from3.length === 0 || from3.length > MAX_DELTA_TOKENS || to.length > MAX_DELTA_TOKENS) {
+    return null;
+  }
+  return { from: from3, to };
+}
+function sameFix(a2, from3, to, errorKey) {
+  return a2.errorKey === errorKey && a2.from.join(" ") === from3.join(" ") && a2.to.join(" ") === to.join(" ");
+}
+var WINDOW_TURNS, MAX_DELTA_TOKENS, MAX_FIXES, ResolutionMemory;
+var init_resolution_memory = __esm({
+  "packages/orchestrator/dist/resolution-memory.js"() {
+    "use strict";
+    WINDOW_TURNS = 6;
+    MAX_DELTA_TOKENS = 3;
+    MAX_FIXES = 200;
+    ResolutionMemory = class {
+      fixes = [];
+      recentFailures = [];
+      /** Load prior fixes (cross-session). */
+      loadFixes(fixes) {
+        for (const f2 of fixes) {
+          if (Array.isArray(f2.from) && Array.isArray(f2.to) && f2.from.length > 0) {
+            this.fixes.push(f2);
+          }
+        }
+        this.fixes.sort((a2, b) => b.count - a2.count);
+        if (this.fixes.length > MAX_FIXES)
+          this.fixes = this.fixes.slice(0, MAX_FIXES);
+      }
+      exportFixes() {
+        return this.fixes;
+      }
+      get size() {
+        return this.fixes.length;
+      }
+      /** Record a failed command (buffered until a resolving success is seen). */
+      recordFailure(input) {
+        if (!input.command)
+          return;
+        this.recentFailures.push({
+          tool: input.tool,
+          command: input.command,
+          tokens: tokenize6(input.command),
+          errorKey: normalizeErrorKey(input.error || ""),
+          turn: input.turn
+        });
+        this.recentFailures = this.recentFailures.filter((f2) => input.turn - f2.turn <= WINDOW_TURNS).slice(-12);
+      }
+      /**
+       * Record a successful command. If it is a near-variant of a recent failure
+       * of the same tool, learn the fix. Returns the learned fix, if any.
+       */
+      recordSuccess(input) {
+        if (!input.command)
+          return null;
+        const workedTokens = tokenize6(input.command);
+        let learned = null;
+        for (let i2 = this.recentFailures.length - 1; i2 >= 0; i2--) {
+          const fail3 = this.recentFailures[i2];
+          if (fail3.tool !== input.tool)
+            continue;
+          if (input.turn - fail3.turn > WINDOW_TURNS)
+            continue;
+          if (fail3.command === input.command)
+            continue;
+          if (!isNearVariant(fail3.tokens, workedTokens))
+            continue;
+          const delta = computeDelta(fail3.tokens, workedTokens);
+          if (!delta)
+            continue;
+          const existing = this.fixes.find((f2) => sameFix(f2, delta.from, delta.to, fail3.errorKey));
+          if (existing) {
+            existing.count++;
+            existing.lastSeen = Date.now();
+            existing.example = { failed: fail3.command, worked: input.command };
+            learned = existing;
+          } else {
+            learned = {
+              from: delta.from,
+              to: delta.to,
+              errorKey: fail3.errorKey,
+              example: { failed: fail3.command, worked: input.command },
+              count: 1,
+              lastSeen: Date.now()
+            };
+            this.fixes.push(learned);
+          }
+          this.recentFailures.splice(i2, 1);
+          break;
+        }
+        if (this.fixes.length > MAX_FIXES) {
+          this.fixes.sort((a2, b) => b.count - a2.count);
+          this.fixes = this.fixes.slice(0, MAX_FIXES);
+        }
+        return learned;
+      }
+      /**
+       * Suggest a learned fix for a command about to run, or null. Matches when the
+       * command contains the fix's `from` token sequence.
+       */
+      suggest(command) {
+        if (!command)
+          return null;
+        const tokens = new Set(tokenize6(command));
+        let best = null;
+        for (const f2 of this.fixes) {
+          if (f2.from.every((t2) => tokens.has(t2))) {
+            if (!best || f2.count > best.count)
+              best = f2;
+          }
+        }
+        if (!best)
+          return null;
+        const message2 = `[LEARNED FIX — from a prior session] A command using \`${best.from.join(" ")}\` failed with "${best.errorKey}"; the working form replaced it with \`${best.to.join(" ")}\` (confirmed ${best.count}× — e.g. \`${best.example.worked}\`). Apply that change here before running, instead of re-discovering it.`;
+        return { fix: best, message: message2 };
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/contextEngine.js
 function estimateTokens3(messages2) {
   const chars = messages2.reduce((sum, message2) => sum + message2.content.length + message2.role.length + (message2.name?.length ?? 0), 0);
@@ -569423,6 +569607,7 @@ var init_agenticRunner = __esm({
     init_evidenceLedger();
     init_adversaryStream();
     init_evidenceBranch();
+    init_resolution_memory();
     init_contextEngine();
     init_prompt_cache();
     TOOL_SUBSETS = {
@@ -569924,6 +570109,12 @@ var init_agenticRunner = __esm({
       // adjacent to the main loop. Initialized per run when the step critic is
       // enabled and a backend is available. See adversaryStream.ts.
       _adversaryStream = null;
+      // Generic, cross-session failure→resolution learning: learns the token-level
+      // change that turned a failed command into a working one (e.g. python→python3)
+      // from observed pairs, and surfaces it before a matching command runs — so
+      // the loop stops re-discovering the same fix every session. See
+      // resolution-memory.ts. Persisted to ~/.omnius/resolution-memory.json.
+      _resolutionMemory = new ResolutionMemory();
       _lastContextFrameDiagnostics = null;
       _lastContextPressureSnapshot = null;
       _lastActiveForgettingReport = null;
@@ -570624,6 +570815,69 @@ 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);
+          }
+        };
+      }
+      /** Cross-session resolution-memory stores: global (machine-wide) + local. */
+      _resolutionMemoryPaths() {
+        const global2 = _pathJoin(_osHomedir(), ".omnius", "resolution-memory.json");
+        const local = _pathJoin(this.omniusStateDir(), "resolution-memory.json");
+        return [global2, local];
+      }
+      _loadResolutionMemory() {
+        const seen = /* @__PURE__ */ new Set();
+        const merged = [];
+        for (const p2 of this._resolutionMemoryPaths()) {
+          try {
+            if (!_fsExistsSync(p2))
+              continue;
+            const data = JSON.parse(_fsReadFileSync(p2, "utf-8"));
+            const arr = Array.isArray(data) ? data : Array.isArray(data?.fixes) ? data.fixes : [];
+            for (const f2 of arr) {
+              const key = `${(f2.from ?? []).join(" ")}=>${(f2.to ?? []).join(" ")}|${f2.errorKey ?? ""}`;
+              if (seen.has(key))
+                continue;
+              seen.add(key);
+              merged.push(f2);
+            }
+          } catch {
+          }
+        }
+        if (merged.length > 0)
+          this._resolutionMemory.loadFixes(merged);
+      }
+      _persistResolutionMemory() {
+        const fixes = this._resolutionMemory.exportFixes();
+        if (fixes.length === 0)
+          return;
+        for (const p2 of this._resolutionMemoryPaths()) {
+          try {
+            _fsMkdirSync(_pathJoin(p2, ".."), { recursive: true });
+            _fsWriteFileSync(p2, JSON.stringify(fixes, null, 2), { mode: 384 });
+          } catch {
+          }
+        }
+      }
       /**
        * 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
@@ -574750,6 +575004,7 @@ Respond with your assessment, then take action.`;
           }
         } catch {
         }
+        this._loadResolutionMemory();
         this._pauseResolve = null;
         this.pendingUserMessages.length = 0;
         this._taskState = {
@@ -575187,7 +575442,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") {
@@ -577323,6 +577580,23 @@ Root cause hypothesis: the argument family may be wrong, a prerequisite may be m
 Corrective action: try a different approach first: read relevant files, adjust arguments, or verify prerequisites.`);
                 }
               }
+              if (tc.name === "shell") {
+                const _cmd = typeof tc.arguments?.["command"] === "string" ? tc.arguments["command"] : typeof tc.arguments?.["cmd"] === "string" ? tc.arguments["cmd"] : "";
+                const _sug = _cmd ? this._resolutionMemory.suggest(_cmd) : null;
+                if (_sug) {
+                  const _injKey = `resfix:${_sug.fix.from.join(" ")}=>${_sug.fix.to.join(" ")}`;
+                  if (!this._errorGuidanceInjected.has(_injKey)) {
+                    this._errorGuidanceInjected.add(_injKey);
+                    this.pendingUserMessages.push(_sug.message);
+                    this.emit({
+                      type: "status",
+                      content: `Resolution memory: suggested \`${_sug.fix.from.join(" ")}\`→\`${_sug.fix.to.join(" ")}\` before shell call`,
+                      turn,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                }
+              }
               if (this._errorPatterns.size > 0) {
                 for (const [sig, pattern] of this._errorPatterns) {
                   if (pattern.tool === tc.name && pattern.count >= 2 && !this._errorGuidanceInjected.has(sig)) {
@@ -577755,6 +578029,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) {
@@ -578411,6 +578703,34 @@ Respond with EXACTLY this structure before your next tool call:
                 } catch {
                 }
               }
+              {
+                const _cmd = typeof tc.arguments?.["command"] === "string" ? tc.arguments["command"] : typeof tc.arguments?.["cmd"] === "string" ? tc.arguments["cmd"] : "";
+                if (_cmd && tc.name === "shell") {
+                  if (!result.success) {
+                    this._resolutionMemory.recordFailure({
+                      tool: tc.name,
+                      command: _cmd,
+                      error: result.error ?? result.output ?? "",
+                      turn
+                    });
+                  } else {
+                    const _learned = this._resolutionMemory.recordSuccess({
+                      tool: tc.name,
+                      command: _cmd,
+                      turn
+                    });
+                    if (_learned) {
+                      this._persistResolutionMemory();
+                      this.emit({
+                        type: "status",
+                        content: `Learned fix: \`${_learned.from.join(" ")}\` → \`${_learned.to.join(" ")}\` (after "${_learned.errorKey}") — saved for future sessions`,
+                        turn,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                  }
+                }
+              }
               if (!result.success && result.error) {
                 const errorText = result.error;
                 let errorType = "unknown";
@@ -578868,7 +579188,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.348",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.346",
+      "version": "1.0.348",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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