Sorry, the computer ate my post. I don't have time to rewrite it. :/

Here is the full precision (53-bits, 15.95 digits):

Style[psi[0, 7] /. sol, PrintPrecision -> 20]
(*  {1.1442768817404132}  *)

Read http://reference.wolfram.com/language/tutorial/Numbers.html for more about kinds of numbers.

Have you tried WorkingPrecision -> 40 or some such setting for it?

I don't understand the connection of your remarks about errors and error message to the problem at hand. I get no errors with this:

Clear[foo, sol, x, w, psi];
ClearSystemCache["Numeric"]; (* Why? IDK. Seems to fix a bug when re-run. *)
nstep = 0; neval = 0; (* steps, PDE evaluations *)
PrintTemporary@Dynamic@{Clock@Infinity, foo, nstep, neval}; (* monitors progress *)
xmax = 10;
wmax = 10;
xmin = 10^-20;
psiinit[w_, x_] := (Exp[-w^2]/Sqrt[\[Pi]] - w*Erfc[w])*x;
sol = NDSolve[{2*x*D[psi[w, x], x] == 
    D[psi[w, x], {w, 2}] + 2*w*D[psi[w, x], w] - (x*psi[w, x])^2, 
   psi[w, xmin] == psiinit[w, xmin], 
   Derivative[1, 0][psi][0, x] == -x, psi[wmax, x] == 0}, 
  psi, {w, 0, wmax}, {x, xmin, xmax},
  PrecisionGoal -> 20, AccuracyGoal -> 10,
  WorkingPrecision -> 40,
  StepMonitor :> (++nstep; foo = x),
  EvaluationMonitor :> (++neval),
  Method -> {"MethodOfLines", 
    "SpatialDiscretization" -> {"TensorProductGrid", 
      "MaxStepSize" -> 1/5000, "DifferenceOrder" -> 4}}]

Takes a few seconds to set up the first step. Takes several minutes to get to x > xmin. I have only 32GB RAM and NDSolve[] uses around 38.5GB, so much of the slowness is probably due to swapping.

Have you tried "Pseudospectral"?:

Method -> {"MethodOfLines",
  "SpatialDiscretization" -> {
    "TensorProductGrid",
    (*"MinPoints" -> 65,(* or higher *)*)
    "DifferenceOrder" -> "Pseudospectral"}}

A trial run shows that psi approaches zero very rapidly, going below $10^{-20}$. To get 20 digits of precision, the AccuracyGoal needs to be more than the maximum of $20-\log_{10} | \psi |$ throughout the solution domain. I haven't been able to determine the maximum. To achieve, say, AccuracyGoal -> 60, I need WorkingPrecision to be around 400 or more, or some internal numerical glitch happens and I get an error like the one you described (but did not provide code for!). It also takes a long time. Note: Compilers do not give run-time errors, which is what this is. I used to get an uncaught exception and a "core dump" that could be used with a debugger, if the program had been compiled with debugger metadata. Mathematica gives you a stack trace, but only of user-level expressions. I don't get to trace the numerical glitch, which probably occurs in an untraceable library anyway. It would be nice if it indicated the "non-numerical value" it encountered, instead of just giving the time. It would be a good hint to what went wrong.

Used "FixedStep" + StartingStepSize for a fixed time step and whichever method for the spatial grid. Ignore the error/warning message about StartingStepSize. You've already complained about error messages, and I have no defense for this one. (It seems StartingStepSize may be used for both temporal and spatial discretization, and it's okay for one but not the other in the examples below.)

Example 1:

\[Nu] = 0.01;
mysol = First[
  NDSolve[{D[u[x, t], t] == \[Nu] D[u[x, t], x, x] - 
      u[x, t] D[u[x, t], x], u[x, 0] == E^-x^2, u[-5, t] == u[5, t]}
   , u, {x, -5, 5}, {t, 0, 4}
   , Method -> {"MethodOfLines", 
     "SpatialDiscretization" -> {"TensorProductGrid", 
       "MinPoints" -> 257, "MaxPoints" -> 257,
        "DifferenceOrder" -> 4},
     Method -> {"FixedStep", Method -> "ExplicitRungeKutta"}}, 
   StartingStepSize -> 1/2^13]]

Example 2:

mygrid =  Join[-5. + 10  Range[0, 48]/80, 1. + Range[1, 4  70]/70];
\[Nu] = 0.01;
mysol = First[
  NDSolve[{D[u[x, t], t] == \[Nu] D[u[x, t], x, x] - 
      u[x, t] D[u[x, t], x], u[x, 0] == E^-x^2, u[-5, t] == u[5, t]}
   , u, {x, -5, 5}, {t, 0, 4}
   , Method -> {"MethodOfLines", 
     "SpatialDiscretization" -> {"TensorProductGrid", 
       "Coordinates" -> {mygrid}},
     Method -> {"FixedStep", Method -> "ExplicitRungeKutta"}}, 
   StartingStepSize -> 1/2^13]]

The following gives the distinct step sizes:

u["Coordinates"] /. mysol // Map@Differences // Map@DeleteDuplicates

Examples adapted from the [Method of Lines tutorial.]

There are lists and descriptions of methods, including implicit one-step methods:

• Under the "Details" of NDSolve

• In the ODE Integration Methods chapter of the NDSolve Overview

LSODA is the default solver for ODE's. IDA for DAEs. Not sure about other forms of DEs.

According to the Overview, "FixedStep" is restricted to one-step methods, so you can't use BDF or LSODA with it. A list of such submethods is in the docs. for NDSolve. Strangely, the FixedStep section gives an example that claims to show how to use Method -> "BDF" using fixed steps, but the steps are in fact of different sizes. You can use BDF for time integration in a PDE, but I do not know how to fix the step size or to restrict the minimum step size.

I do not know of any implementation of Rosebrock methods in Mathematica/WL. How to implement your own methods is described in the Plugin Framework.