omnius 1.0.437 → 1.0.439

package/dist/index.js

@@ -573657,7 +573657,7 @@ function resolveFocusSupervisorMode(configured, envValue = process.env["OMNIUS_F
 }
 function violatesDirective(directive, input) {
   if (input.toolName === "task_complete") {
-    return directive.requiredNextAction !== "report_blocked" && directive.requiredNextAction !== "report_incomplete";
+    return directive.requiredNextAction !== "report_blocked" && directive.requiredNextAction !== "report_incomplete" && directive.requiredNextAction !== "use_cached_evidence";
   }
   if (input.toolName === "ask_user")
     return false;
@@ -603396,30 +603396,114 @@ function cudaHardwarePresent() {
   if (existsSync110("/usr/local/cuda")) return true;
   return isJetsonHost2();
 }
-function jetsonPytorchIndex() {
-  let jpVer = "v60";
+function detectCudaToolkitVersion() {
+  for (const path12 of ["/usr/local/cuda/version.json", "/usr/local/cuda/version.txt"]) {
+    if (!existsSync110(path12)) continue;
+    try {
+      const raw = readFileSync90(path12, "utf8");
+      const match2 = raw.match(/CUDA(?: Toolkit)?[^0-9]*(\d+\.\d+)/i) || raw.match(/"cuda"\s*:\s*"(\d+\.\d+)/i);
+      if (match2?.[1]) return match2[1];
+    } catch {
+    }
+  }
+  const nvcc = spawnSync8("nvcc", ["--version"], { encoding: "utf8", timeout: 5e3 });
+  const match = `${nvcc.stdout || ""}${nvcc.stderr || ""}`.match(/release\s+(\d+\.\d+)/i);
+  return match?.[1] ?? "";
+}
+function jetsonPytorchDirs() {
+  let primary = "v60";
   try {
     const tegra = existsSync110("/etc/nv_tegra_release") ? readFileSync90("/etc/nv_tegra_release", "utf8") : "";
     const env2 = process.env["JETSON_L4T_VERSION"] || "";
-    if (env2.startsWith("5.") || tegra.includes("R35") || tegra.includes("R34")) jpVer = "v51";
-    else if (env2.startsWith("6.1") || tegra.includes("R36.4")) jpVer = "v61";
-    else if (env2.startsWith("6.") || tegra.includes("R36")) jpVer = "v60";
+    const cuda = detectCudaToolkitVersion();
+    if (env2.startsWith("5.") || tegra.includes("R35") || tegra.includes("R34")) primary = "v51";
+    else if (env2.startsWith("6.2")) primary = "v62";
+    else if (env2.startsWith("6.1") || tegra.includes("R36.4")) primary = cuda.startsWith("12.2") ? "v60" : "v61";
+    else if (env2.startsWith("6.") || tegra.includes("R36") || cuda.startsWith("12.2")) primary = "v60";
   } catch {
   }
+  const fallbacks = primary === "v51" ? ["v51", "v511"] : primary === "v62" ? ["v62", "v61", "v60"] : primary === "v61" ? ["v61", "v60"] : ["v60", "v60dp", "v61"];
+  return [...new Set(fallbacks)];
+}
+function jetsonPytorchIndex() {
+  const jpVer = jetsonPytorchDirs()[0] ?? "v60";
   return `https://developer.download.nvidia.com/compute/redist/jp/${jpVer}/pytorch/`;
 }
-function jetsonTorchInstallSource() {
-  const wheel = String(process.env["OMNIUS_JETSON_TORCH_WHEEL"] || process.env["JETSON_TORCH_WHEEL"] || "").trim();
+function pythonAbiTag(py = getVenvPython()) {
+  const probe = spawnSync8(
+    py,
+    ["-c", "import sys; print(f'cp{sys.version_info.major}{sys.version_info.minor}')"],
+    { encoding: "utf8", timeout: 5e3 }
+  );
+  const tag = String(probe.stdout || "").trim();
+  return /^cp\d+$/.test(tag) ? tag : "cp310";
+}
+function discoverJetsonTorchWheel(py = getVenvPython()) {
+  const envWheel = String(process.env["OMNIUS_JETSON_TORCH_WHEEL"] || process.env["JETSON_TORCH_WHEEL"] || "").trim();
+  if (envWheel) return envWheel;
+  const abi = pythonAbiTag(py);
+  const dirs = jetsonPytorchDirs();
+  const urls = dirs.flatMap((dir) => [
+    `https://developer.download.nvidia.com/compute/redist/jp/${dir}/pytorch/`,
+    `https://developer.download.nvidia.cn/compute/redist/jp/${dir}/pytorch/`
+  ]);
+  const probe = spawnSync8(
+    "python3",
+    [
+      "-c",
+      [
+        "import json, re, sys, urllib.parse, urllib.request",
+        "abi = sys.argv[1]",
+        "urls = sys.argv[2:]",
+        "for url in urls:",
+        "    try:",
+        "        html = urllib.request.urlopen(url, timeout=20).read().decode('utf-8', 'ignore')",
+        "    except Exception:",
+        "        continue",
+        "    wheels = []",
+        `    for href in re.findall("href=[\\\\\\"']([^\\\\\\"']+\\\\.whl)[\\\\\\"']", html, flags=re.I):`,
+        "        name = urllib.parse.unquote(href.rsplit('/', 1)[-1])",
+        "        if not name.startswith('torch-'):",
+        "            continue",
+        "        if 'linux_aarch64' not in name or abi not in name:",
+        "            continue",
+        "        wheels.append(urllib.parse.urljoin(url, href))",
+        "    if wheels:",
+        "        print(json.dumps(sorted(wheels)[-1]))",
+        "        raise SystemExit(0)",
+        "print(json.dumps(''))"
+      ].join("\n"),
+      abi,
+      ...urls
+    ],
+    { encoding: "utf8", timeout: 9e4 }
+  );
+  try {
+    return String(JSON.parse(probe.stdout || '""') || "");
+  } catch {
+    return "";
+  }
+}
+function purgeVenvTorch(pip) {
+  const purge = spawnSync8(
+    pip,
+    ["uninstall", "-y", "torch", "torchvision", "torchaudio", "triton"],
+    { encoding: "utf8", timeout: 3e5 }
+  );
+  return `${purge.stdout || ""}${purge.stderr || ""}`;
+}
+function jetsonTorchInstallSource(py = getVenvPython()) {
+  const wheel = discoverJetsonTorchWheel(py);
   if (wheel) {
     return {
       source: wheel,
-      args: ["install", "--upgrade", "--force-reinstall", "--no-deps", wheel]
+      args: ["install", "--upgrade", "--force-reinstall", "--no-deps", "--no-cache-dir", wheel]
     };
   }
   const indexUrl = jetsonPytorchIndex();
   return {
     source: indexUrl,
-    args: ["install", "--upgrade", "--force-reinstall", "--no-deps", "--index-url", indexUrl, "torch"]
+    args: ["install", "--upgrade", "--force-reinstall", "--no-deps", "--no-cache-dir", "--index-url", indexUrl, "torch"]
   };
 }
 function torchCudaProbe(py = getVenvPython()) {
@@ -603442,11 +603526,16 @@ function torchCudaProbe(py = getVenvPython()) {
     { encoding: "utf8", timeout: 3e4 }
   );
   const log22 = `${probe.stdout || ""}${probe.stderr || ""}`.trim();
-  return { ok: probe.status === 0, log: log22 };
+  try {
+    return { ok: probe.status === 0, log: log22, json: JSON.parse(probe.stdout || "{}") };
+  } catch {
+    return { ok: probe.status === 0, log: log22 };
+  }
 }
 function ensureEmbedDeps() {
   const venv = getVenvDir();
   let log22 = "";
+  const diagnostics = [];
   try {
     mkdirSync67(venv, { recursive: true });
   } catch {
@@ -603458,6 +603547,7 @@ function ensureEmbedDeps() {
   }
   if (isJetsonHost2() && cudaHardwarePresent() && !asrCpuAllowed()) {
     enableVenvSystemSitePackages(venv);
+    diagnostics.push(`Jetson ASR CUDA repair: python=${getVenvPython()} abi=${pythonAbiTag()} cuda=${detectCudaToolkitVersion() || "unknown"} jp_dirs=${jetsonPytorchDirs().join(",")}`);
   }
   if (venvExisted && !(process.env["OMNIUS_INSTALL_FULL_EMBED_DEPS"] === "1")) {
     const check = spawnSync8(
@@ -603473,6 +603563,7 @@ function ensureEmbedDeps() {
       if (cudaProbe.ok) {
         return { ok: true, log: `embed deps already satisfied; torch CUDA OK ${cudaProbe.log}` };
       }
+      diagnostics.push(`Initial venv torch CUDA failed: ${cudaProbe.log}`);
       log22 += `embed deps import OK but torch CUDA probe failed; repairing ASR torch. ${cudaProbe.log}
 `;
     }
@@ -603484,8 +603575,10 @@ function ensureEmbedDeps() {
   if (cudaHardwarePresent() && !asrCpuAllowed()) {
     const before = torchCudaProbe();
     torchOk = before.ok;
+    if (!torchOk) diagnostics.push(`Pre-repair torch probe: ${before.log}`);
     if (!torchOk && isJetsonHost2()) {
       const systemTorch = torchCudaProbe("python3");
+      diagnostics.push(`System python torch probe: ${systemTorch.log || "unavailable"}`);
       if (systemTorch.ok) {
         log22 += `Venv torch CUDA probe failed, but system Jetson torch CUDA works; enabling system site packages and removing venv-local torch.
 venv=${before.log}
@@ -603505,26 +603598,33 @@ system=${systemTorch.log}
       }
     }
     if (!torchOk && isJetsonHost2()) {
+      log22 += purgeVenvTorch(pip);
       const torchDeps = spawnSync8(
         pip,
-        ["install", "--upgrade", "filelock", "typing-extensions", "networkx", "jinja2", "fsspec", "sympy"],
+        ["install", "--upgrade", "numpy==1.26.4", "filelock", "typing-extensions", "networkx", "jinja2", "fsspec", "sympy"],
         { encoding: "utf8", timeout: 3e5 }
       );
       log22 += torchDeps.stdout + torchDeps.stderr;
       const torchSource = jetsonTorchInstallSource();
+      diagnostics.push(`Jetson torch install source: ${torchSource.source || "not found"}`);
       log22 += `Torch CUDA probe failed on Jetson; installing JetPack-compatible PyTorch from ${torchSource.source}
 ${before.log}
 `;
-      const torchInstall = spawnSync8(
-        pip,
-        torchSource.args,
-        { encoding: "utf8", timeout: 9e5 }
-      );
-      log22 += torchInstall.stdout + torchInstall.stderr;
-      const after = torchCudaProbe();
-      torchOk = after.ok;
-      log22 += `Torch CUDA probe after Jetson install: ${after.log}
+      if (!torchSource.source) {
+        torchOk = false;
+      } else {
+        const torchInstall = spawnSync8(
+          pip,
+          torchSource.args,
+          { encoding: "utf8", timeout: 9e5 }
+        );
+        log22 += torchInstall.stdout + torchInstall.stderr;
+        const after = torchCudaProbe();
+        torchOk = after.ok;
+        diagnostics.push(`Post Jetson torch install probe: ${after.log}`);
+        log22 += `Torch CUDA probe after Jetson install: ${after.log}
 `;
+      }
     } else if (!torchOk) {
       log22 += `Torch CUDA probe failed on CUDA host; not allowing ASR CPU fallback. ${before.log}
 `;
@@ -603564,6 +603664,28 @@ ${before.log}
     if (!torchOk) {
       log22 += `Torch CUDA probe still failed after ASR dependency install. ${finalTorch.log}
 `;
+      diagnostics.push(`Post ASR dependency torch probe: ${finalTorch.log}`);
+      if (isJetsonHost2()) {
+        log22 += "Retrying Jetson torch repair after ASR dependency install to remove any incompatible torch resolver side effects.\n";
+        log22 += purgeVenvTorch(pip);
+        const torchSource = jetsonTorchInstallSource();
+        diagnostics.push(`Final Jetson torch repair source: ${torchSource.source || "not found"}`);
+        if (!torchSource.source) {
+          torchOk = false;
+        } else {
+          const retry = spawnSync8(
+            pip,
+            torchSource.args,
+            { encoding: "utf8", timeout: 9e5 }
+          );
+          log22 += retry.stdout + retry.stderr;
+          const repaired = torchCudaProbe();
+          torchOk = repaired.ok;
+          diagnostics.push(`Final repaired torch probe: ${repaired.log}`);
+          log22 += `Torch CUDA probe after final Jetson repair from ${torchSource.source}: ${repaired.log}
+`;
+        }
+      }
     }
   }
   let fullOk = true;
@@ -603582,6 +603704,21 @@ ${before.log}
     fullOk = full.status === 0;
   }
   const ok3 = asrDepsOk && up.status === 0 && fullOk && torchOk;
+  if (!ok3) {
+    const compact4 = [
+      "ASR dependency setup failed.",
+      ...diagnostics,
+      `pip_base_ok=${up.status === 0}`,
+      `asr_deps_ok=${asrDepsOk}`,
+      `full_embed_deps_ok=${fullOk}`,
+      `torch_cuda_ok=${torchOk}`,
+      "Set OMNIUS_JETSON_TORCH_WHEEL=/path/or/url/to/torch-*-linux_aarch64.whl to override auto-discovery."
+    ].join("\n");
+    return { ok: ok3, log: `${compact4}
+
+--- raw pip tail ---
+${log22.slice(-2e3)}` };
+  }
   return { ok: ok3, log: log22 };
 }
 function runEmbedImage(input) {
@@ -604198,7 +604335,7 @@ var init_listen = __esm({
             const res = ensure();
             if (res?.log) this.emit("status", res.log.slice(-500));
             if (res && res.ok === false) {
-              throw new Error(`ASR Python dependency setup failed: ${String(res.log ?? "").slice(-1200)}`);
+              throw new Error(String(res.log ?? "ASR Python dependency setup failed").slice(0, 2400));
             }
           }
           if (typeof getPy === "function") {

package/npm-shrinkwrap.json

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

package/package.json

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