omnius 1.0.347 → 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;
@@ -567686,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);
@@ -569449,6 +569607,7 @@ var init_agenticRunner = __esm({
     init_evidenceLedger();
     init_adversaryStream();
     init_evidenceBranch();
+    init_resolution_memory();
     init_contextEngine();
     init_prompt_cache();
     TOOL_SUBSETS = {
@@ -569950,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;
@@ -570673,6 +570838,46 @@ Your hypotheses MUST address this specific error, not generic causes.
           }
         };
       }
+      /** 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
@@ -574799,6 +575004,7 @@ Respond with your assessment, then take action.`;
           }
         } catch {
         }
+        this._loadResolutionMemory();
         this._pauseResolve = null;
         this.pendingUserMessages.length = 0;
         this._taskState = {
@@ -577374,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)) {
@@ -578480,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";

package/npm-shrinkwrap.json

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

package/package.json

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