Render markdown, and stop wiping messages still waiting to be read

Two things, both about the transcript telling the truth about itself.

Markdown is rendered rather than shown as its source. The parsing is
mikepenz/multiplatform-markdown-renderer, not something written here:
markdown is somebody else's specification, and a hand-written subset of
one disagrees with it at the edges, which is where the bug reports come
from. `Markdown.kt` is only the mapping onto this app's palette, so code,
links and rules take the Catppuccin values the rest of the app uses
rather than the renderer's defaults.

The queued-message list was cleared wholesale whenever a turn ended. But
the backend holds a queue of its own and takes one message per turn, so a
turn ending is precisely the moment the *rest* are still waiting -- the
bubbles vanished while the messages were on their way, which reads as
everything after the first having been dropped. Now a held message
leaves the list exactly two ways: the session reads it, which arrives as
a UserMessage, or its send failed and there is nothing to wait for.

Measured first, because the report was that the backend dropped them:
three messages sent behind one long turn were all delivered in order
(ONE, TWO, THREE) against current main, so the loss was in the display.

Verified on the emulator: headings, emphasis, inline code, nested lists,
a quote bar, a fenced block, a rule and a link all render, and the three
queued messages sit through their turn.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/src/session/transport.rs

@@ -103,8 +103,12 @@ impl Transport {
             Self::Here => None,
             Self::Ssh { ssh, .. } => Some(ssh),
         };
-        let mut command =
-            crate::ssh::command(host, &launch.program, &launch.args, launch.cwd.as_deref());
+        let mut command = tokio::process::Command::from(crate::ssh::command(
+            host,
+            &launch.program,
+            &launch.args,
+            launch.cwd.as_deref(),
+        ));
         match streams {
             Streams::Piped => {
                 command
@@ -141,6 +145,35 @@ impl Transport {
         })
     }
 
+    /// Runs `launch` to completion and returns its stdout, blocking.
+    ///
+    /// The synchronous twin of `capture`, for callers that are already on a
+    /// blocking task and would otherwise need a runtime to ask a machine a
+    /// question. Both build the invocation the same way -- see
+    /// `crate::ssh::command` -- so there is still only one description of
+    /// what running something on another machine means.
+    pub fn capture_blocking(&self, launch: &Launch) -> Result<String> {
+        let host = match self {
+            Self::Here => None,
+            Self::Ssh { ssh, .. } => Some(ssh),
+        };
+        let output =
+            crate::ssh::command(host, &launch.program, &launch.args, launch.cwd.as_deref())
+                .output()
+                .with_context(|| {
+                    format!("couldn't run \"{}\" {}", launch.program, self.describe())
+                })?;
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+            anyhow::bail!(if stderr.is_empty() {
+                format!("couldn't reach it ({})", output.status)
+            } else {
+                stderr
+            });
+        }
+        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
+    }
+
     /// How to say where this runs, for a log line a person reads.
     pub fn describe(&self) -> String {
         match self {