why `execv` can't use implicit convert from char** to char* const*?

Consider the following code:

#include <stdio.h>
#include <unistd.h>

void foo(char * const arg[]) {
    printf("success\n");
}

int main() {
    char myargs[2][64] = { "/bin/ls", NULL };

    foo(myargs);
    execv(myargs[0], myargs);
    return 0;
}

Both foo and execv require char * const * argument, but while my foo works (I get success in the output) the system call execv fails.

I would like to know why. Does this have something to do with the implementation of execv?

Also, assuming I have a char** variable - how can I send it to execv?

Both foo and execv require char * const * argument,

Yes.

but while my foo works (I get success in the output) the system call execv fails.

Getting the output you expect does not prove that your code is correct. The call exhibits undefined behavior because its argument does not match the parameter type, but it is plausible that that has little practical effect because the implementation of foo() does not use the parameter in any way. More generally, your code could, in principle, exhibit absolutely any behavior at all, because that's what "undefined" means.

I would like to know why. Does this have something to do with the implementation of execv?

From the standard's perspective, both calls exhibit equally undefined behavior. As a practical matter, however, we know that execv does use its arguments, so it would be much more surprising for that call to produce the behavior you expected than it is for the call to foo to produce the behavior you expected.

The main problem is that 2D arrays are arrays of arrays, and arrays are not pointers. Thus, your 2D array myargs does not at all have the correct type for an argument to either function.

Also, assuming I have a char** variable - how can I send it to execv?

You do not have such a variable in your code, but if you did have, you could cast it to the appropriate type:

char *some_args[] = { "/bin/ls", NULL };
execv((char * const *) some_args);

In practice, most compilers would probably accept it if you omitted the cast, too, although the standard does require it. Best would be to declare a variable that has the correct type in the first place:

char * const correct_args[] = { "/bin/ls", NULL };
execv(correct_args);

Note also that although arrays are not pointers, they are converted to pointers in most contexts -- which I use in the example code -- but only the top level. An array of arrays thus "decays" to a pointer to an array, not a pointer to a pointer.