@@ -645,6 +645,10 @@ def __init__(
             if callargs:
                 self._startup_commands.extend(callargs)
 
+        # The embedded pager shares the main toolbar. Applications can opt back
+        # into their configured external pager by setting this to False.
+        self.use_builtin_pager = enable_bottom_toolbar
+
         # Set the pager(s) for use when displaying output using a pager
         if sys.platform.startswith("win"):
             self.pager = self.pager_chop = "more"
@@ -1871,7 +1875,6 @@ def pfeedback(
                 rich_print_kwargs=rich_print_kwargs,
             )
 
-    @command_toolbar.suspend_toolbar
     def ppaged(
         self,
         *objects: Any,
@@ -1893,12 +1896,16 @@ def ppaged(
         fits on the screen. A pager is not used inside a script (Python or text) or when output is
         redirected or piped, and in these cases, output is sent to `poutput`.
 
+        With the bottom toolbar enabled, the built-in pager keeps it visible and refreshing.
+        Set ``use_builtin_pager=False`` to use the configured external ``pager`` or ``pager_chop``
+        command instead; external pagers temporarily hide the toolbar.
+
         :param chop: True -> causes lines longer than the screen width to be chopped (truncated) rather than wrapped
                               - truncated text is still accessible by scrolling with the right & left arrow keys
                               - chopping is ideal for displaying wide tabular data as is done in utilities like pgcli
                      False -> causes lines longer than the screen width to wrap to the next line
                               - wrapping is ideal when you want to keep users from having to use horizontal scrolling
-                     WARNING: On Windows, the text always wraps regardless of what the chop argument is set to
+                     WARNING: The default external pager on Windows always wraps; the built-in pager supports chopping.
         :param soft_wrap: Enable soft wrap mode. If True, lines of text will not be word-wrapped or cropped to
                           fit the terminal width. Defaults to True.
 
@@ -1941,11 +1948,19 @@ def ppaged(
                     soft_wrap=soft_wrap,
                     **(rich_print_kwargs if rich_print_kwargs is not None else {}),
                 )
-            output_bytes = capture.get().encode("utf-8", "replace")
+            output = capture.get()
+
+            if self.use_builtin_pager:
+                with self._command_toolbar_context():
+                    if self._command_toolbar is not None and self._command_toolbar.is_active:
+                        self._command_toolbar.page(output, chop=chop)
+                        return
+
+            output_bytes = output.encode("utf-8", "replace")
 
             # Prevent KeyboardInterrupts while in the pager. The pager application will
             # still receive the SIGINT since it is in the same process group as us.
-            with self.sigint_protection:
+            with self.suspend_bottom_toolbar(), self.sigint_protection:
                 import subprocess
 
                 pipe_proc = subprocess.Popen(  # noqa: S602
@@ -2056,8 +2071,8 @@ def get_bottom_toolbar(self) -> AnyFormattedText:
         or even a real-time clock.
 
         During command execution this callback runs in a background UI thread. Protect shared
-        state with a lock when necessary. The toolbar is suspended while another prompt, pager,
-        or interactive shell owns the terminal.
+        state with a lock when necessary. The built-in pager shares this toolbar. It is suspended
+        while another prompt, external pager, or interactive shell owns the terminal.
 
         :return: Content to populate the bottom toolbar.
         """
@@ -2069,7 +2084,7 @@ def suspend_bottom_toolbar(self) -> Iterator[None]:
 
         Use this context manager around application-specific calls to ``input()``, other
         terminal UIs, or subprocesses that inherit the terminal. cmd2 automatically suspends
-        its toolbar for its own input prompts, pagers, and shell commands.
+        its toolbar for its own input prompts, external pagers, and shell commands.
         """
         if self._command_toolbar is None:
             yield
 
@@ -9,23 +9,28 @@
 import sys
 import threading
 from collections.abc import Callable, Iterator
+from concurrent.futures import Future
+from concurrent.futures import TimeoutError as FutureTimeoutError
 from typing import TYPE_CHECKING, Any, TextIO, TypeVar, cast
 
 from prompt_toolkit.application import Application, create_app_session
-from prompt_toolkit.filters import Condition, is_done, renderer_height_is_known, to_filter
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.filters import Condition, to_filter
 from prompt_toolkit.input.typeahead import get_typeahead, store_typeahead
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPress, KeyPressEvent
 from prompt_toolkit.layout import HSplit, Layout, Window
 from prompt_toolkit.layout.containers import ConditionalContainer
-from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.patch_stdout import StdoutProxy
 from prompt_toolkit.utils import suspend_to_background_supported
 
+from .pager import Pager
+
 if TYPE_CHECKING:
     from .cmd2 import Cmd
 
 _F = TypeVar("_F", bound=Callable[..., Any])
+_R = TypeVar("_R")
 
 
 def suspend_toolbar(func: _F) -> _F:
@@ -94,7 +99,7 @@ def finish(self) -> None:
 
 
 class CommandToolbar:
-    """Run a prompt-toolkit display in a thread while a command runs on the main thread.
+    """Borrow the main prompt's application while a command runs on the main thread.
 
     The display owns terminal input so it can receive cursor position reports. Keys
     typed during execution are saved for the next prompt; Ctrl-C is sent to cmd2's
@@ -114,6 +119,23 @@ def __init__(self, cmd: "Cmd") -> None:
         self._proxy: StdoutProxy | None = None
 
         session = cmd.main_session
+        self.app = session.app
+        # PromptSession has no public hook for replacing just its input area.
+        # Keep this small dependency on its layout shape in one place, and fail
+        # explicitly if upstream changes it. Reuse the actual toolbar container,
+        # including its visibility filter and support for multiline toolbars.
+        root = session.layout.container
+        if not isinstance(root, HSplit):
+            raise TypeError("Unsupported PromptSession layout")
+        self.toolbar = root.children[-1]
+        if not (
+            isinstance(self.toolbar, ConditionalContainer)
+            and isinstance(self.toolbar.content, Window)
+            and self.toolbar.content.style == "class:bottom-toolbar"
+        ):
+            raise RuntimeError("Cannot locate PromptSession bottom toolbar")
+        self._layout = Layout(HSplit([Window(height=0), Window(), self.toolbar]))
+        self._display_stack: contextlib.ExitStack | None = None
         bindings = KeyBindings()
 
         @bindings.add("<any>")
@@ -143,33 +165,11 @@ def suspend(event: KeyPressEvent) -> None:
             # redraws the toolbar after the process resumes.
             event.app.suspend_to_background()
 
-        self.app: Application[None] = Application(
-            layout=Layout(
-                HSplit(
-                    [
-                        Window(height=0),
-                        Window(),
-                        ConditionalContainer(
-                            Window(
-                                FormattedTextControl(lambda: session.bottom_toolbar, style="class:bottom-toolbar.text"),
-                                style="class:bottom-toolbar",
-                                height=1,
-                                always_hide_cursor=True,
-                            ),
-                            filter=~is_done & renderer_height_is_known,
-                        ),
-                    ]
-                )
-            ),
-            input=session.input,
-            output=session.output,
-            style=session.style,
-            color_depth=session.color_depth,
-            refresh_interval=session.refresh_interval,
-            key_bindings=bindings,
-            erase_when_done=True,
-            after_render=lambda _: self._ready.set(),
-        )
+        self._bindings = bindings
+        self._suspend_binding = suspend
+
+    def _after_render(self, app: Application[str]) -> None:  # noqa: ARG002
+        self._ready.set()
 
     def start(self) -> None:
         """Start rendering and protect terminal output."""
@@ -201,6 +201,12 @@ def _restore_stream(obj: Any, name: str, stream: ToolbarStream) -> None:
     def _resume(self) -> None:
         self._ready.clear()
         self._error = None
+        stack = self._display_stack = contextlib.ExitStack()
+        for name, value in (("layout", self._layout), ("key_bindings", self._bindings), ("erase_when_done", True)):
+            stack.callback(setattr, self.app, name, getattr(self.app, name))
+            setattr(self.app, name, value)
+        self.app.after_render += self._after_render
+        stack.callback(self.app.after_render.remove_handler, self._after_render)
         context = contextvars.copy_context()
 
         def run() -> None:
@@ -239,6 +245,9 @@ def _pause(self) -> None:
             if self._thread is not None:
                 self._thread.join()
                 self._thread = None
+            if self._display_stack is not None:
+                self._display_stack.close()
+                self._display_stack = None
             # Application.run() saves its unprocessed queue before the thread
             # exits. Those keys arrived after the ones handled by save_key().
             pending_keys = get_typeahead(self.app.input)
@@ -256,6 +265,103 @@ def stop(self) -> None:
                 self._stack.close()
                 self._stack = None
 
+    @property
+    def is_active(self) -> bool:
+        """Whether the display currently owns the terminal."""
+        return self._proxy is not None and self.app.is_running
+
+    def _call_in_ui(self, func: Callable[[], _R]) -> _R:
+        """Change UI state on its event loop, propagating failures to the command."""
+        result: Future[_R] = Future()
+
+        def call() -> None:
+            try:
+                value = func()
+            except BaseException as exc:  # noqa: BLE001
+                result.set_exception(exc)
+            else:
+                result.set_result(value)
+
+        if self.app.loop is None:
+            raise RuntimeError("Toolbar is not running")
+        self.app.loop.call_soon_threadsafe(call)
+        while True:
+            try:
+                value = result.result(timeout=0.1)
+            except FutureTimeoutError:
+                if result.done():
+                    raise
+                self._check_running()
+            else:
+                return value
+
+    def _check_running(self) -> None:
+        if self._thread is None or not self._thread.is_alive():
+            if self._error is not None:
+                raise self._error
+            raise EOFError
+
+    def page(self, text: str, *, chop: bool) -> None:
+        """Show a pager above the same toolbar without starting another input reader."""
+        pager = Pager(text, chop=chop)
+        pager.bindings.add(
+            "c-z",
+            filter=Condition(lambda: suspend_to_background_supported() and to_filter(self.cmd.main_session.enable_suspend)()),
+        )(self._suspend_binding)
+        size = self.app.output.get_size()
+        # Measuring the toolbar can invoke its callback; keep that work on the
+        # UI thread along with rendering and layout changes.
+        toolbar_height = self._call_in_ui(lambda: self.toolbar.preferred_height(size.columns, size.rows).preferred)
+        if pager.fits(size.columns, max(0, size.rows - toolbar_height)):
+            self.cmd.stdout.write(text)
+            self.cmd.stdout.flush()
+            return
+
+        layout = Layout(HSplit([pager.container, self.toolbar]), focused_element=pager.text)
+        previous = (self.app.layout, self.app.key_bindings, self.app.editing_mode, self.app.full_screen)
+        entered = False
+
+        def enter() -> None:
+            nonlocal entered
+            entered = True
+            self.app.renderer.erase()
+            self.app.layout = layout
+            self.app.key_bindings = pager.bindings
+            self.app.editing_mode = EditingMode.EMACS
+            self.app.full_screen = self.app.renderer.full_screen = True
+            self.app.invalidate()
+
+        def leave() -> None:
+            nonlocal entered
+            if not entered:
+                return
+            entered = False
+            self.app.renderer.erase()
+            self.app.layout, self.app.key_bindings, self.app.editing_mode, self.app.full_screen = previous
+            self.app.renderer.full_screen = self.app.full_screen
+            self.app.renderer.request_absolute_cursor_position()
+            self.app.invalidate()
+
+        def close() -> None:
+            # Switch bindings before the next key is processed, preserving
+            # typeahead sent in the same terminal read as the pager's quit key.
+            leave()
+            pager.closed.set()
+
+        pager.on_close = close
+
+        try:
+            self._call_in_ui(enter)
+            while not pager.closed.wait(0.1):
+                self._check_running()
+        finally:
+            if self._thread is not None and self._thread.is_alive():
+                self._call_in_ui(leave)
+            else:
+                # The application's shutdown already reset the renderer.
+                self.app.layout, self.app.key_bindings, self.app.editing_mode, self.app.full_screen = previous
+                self.app.renderer.full_screen = self.app.full_screen
+
     @contextlib.contextmanager
     def suspend(self) -> Iterator[None]:
         """Temporarily restore ordinary terminal access, including nested suspensions."""