I design with a real-time, live "monitor" in my projects.
It gives me low level access to everything happening in
the device AS it is happening. I can attach to a particular
process and examine/alter objects in its address space,
pause/resume, stop/restart, etc. It's a poor-man's ICE
with limited footprint (unlike supporting a full debugger
in the release).

For certain classes of projects (esp industrial), I *ship*
the production code with this still in place. So, I (or
my agent) can examine a running system to try to understand
unexpected behavior(s) without having to stop and then
restart the system after affixing external diagnostic tools
(which can possibly alter that behavior).

I see many consumer devices deployed with accessible shells
*if* the user can gain physical access to the interface
(e.g., a 5V-only UART). But, this typically only happens in
UN*X based products where there is already a fair bit of
bloat present (if you can afford the binaries for a full
shell vs. my tiny monitor) and the development effort to add
that capability is pretty small (the shell is already written!).

Of course, this doesn't usually give access to the same
level of detail that is available to a (privileged) monitor.

Ignoring such shell deployments, how often do folks include
diagnostic code of this fine granularity in their releases?