Minimal Power Root

Perl 6, 49 bytes

{grep {($_,{$_**.comb.min}...*==*).tail>$_},1..*}

Try it online!

Returns an infinite sequence. I suppose that the following 45 byte version works, too, but I can't prove that the fixed point is always found after n iterations.

{grep {($_,{$_**.comb.min}...*)[$_]>$_},3..*}

05AB1E, 8 bytes

Generates the nth number 1-indexed

µNÐΔWm}‹

Try it online!

Explanation

µ          # run until counter equals input
 NÐ        # push 3 copies of the current iteration index (1-based)
   Δ  }    # run this code until the result no longer changes     
    Wm     # raise the number to the power of its minimum digit
       ‹   # check if greater than the index

Optionally as an infinite list at the same byte count:

∞ʒDΔWm}‹

Try it online!

J, _{41 39} 37 bytes

(>:[echo^:(<(^0".@{/:~@":)^:_))^:_]1x

Try it online!

This one is a full program printing the infinite sequence. A very rare occasion where a full program beats a verb in J.

How it works

(>:[echo^:(<mpi_fix))^:_]1x    Using the mpi_fix below; it finds the MPI fixpoint
          (<mpi_fix)           Is mpi_fix greater than the input?
    echo^:                     If so, apply echo; do nothing otherwise
                               echo returns an empty array
 >:[                           Discard the above and return input+1
(                   )^:_       Repeat the above infinitely (increment has no fixpoint)
                        ]1x    starting from arbitrary-precision number 1

---

J, ₄₁ 39 bytes

>:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x

Try it online!

A monadic verb. Given a 1-based index, returns the number at that index. The footer checks that first 20 terms are correct.

Reading the word "fixpoint", I immediately thought "Oh yeah, ^:_ will do the great job." Then I ended up with this abomination of angry and sad faces. And it's not even a train, it's a single verb.

Ungolfed & How it works

nth_term =: >:^:(>:(^0".@{/:~@":)^:_)^:_@>:@]^:[&0x

mpi =: ^0".@{/:~@":    Find the MPI
             /:~@":    Sort the string representation
        0   {          Take first item
         ".@           Convert back to number
       ^               Raise the input to the power of above

mpi_fix =: mpi^:_      Find the MPI fixpoint

next_term =: >:^:(>:mpi_fix)^:_@>:    Given a number, find the next term
                               @>:    Increment once, and then...
                  >:mpi_fix           Is mpi_fix not greater than input?
             >:^:           ^:_       Increment while the above is true

nth_term =: next_term@]^:[&0x    Given one-based index, find the nth term
            next_term@]          Apply next_term monadically
                       ^:[       n times
                          &0x    to the starting value of zero

The arbitrary-precision integer 0x is needed to compute the fixpoint accurately, e.g. of the number 6.