diff --git a/BUGS.md b/BUGS.md
new file mode 100644
index 0000000..423bd33
--- /dev/null
+++ b/BUGS.md
@@ -0,0 +1,43 @@
+# Bugs
+
+These are bugs (or missing features) I've observed while working with `multi checks`.
+
+- [ ] No use of Cersei workflows to chain multiple prompts together.
+
+- [ ] No support for Fireworks AI.
+
+- [ ] No GitHub Action available.
+
+- [ ] No loading of skills.
+
+- [ ] No loading of RULES.md files from the .claude directory.
+
+- [ ] Assemble_instructions is hard-coded: src/checks/executor/mod.rs:98 (definition), called from src/checks/executor/cersei.rs:110
+
+- [ ] No system prompt provided.
+
+- [ ] Not sure if prompt caching is enabled at all.
+
+- [ ] No trace capture. We need a way to record all session traces so that we can analyze why they failed.
+
+- CERSEI: `append_system_prompt()` function is dead unless routed through the separate build_system_prompt() composer.
+
+## Fixes
+
+- [x] No loading of CLAUDE.md files
+
+- [x] Concurrency still not respected.
+
+- [x] Full error text got cut off at the end of the terminal screen instead of wrapping. Turned out to
+live in the *presenter* (`src/checks/presenter/inline.rs`), not the `Reporter` — the inline TUI is the
+sole terminal writer for the whole run (see `owns_record` in `src/checks/mod.rs`), so `Reporter::report()`
+never even runs in a TTY session. The presenter renders into a fixed-size `ratatui::Buffer` via
+`insert_before`, which clips instead of wrapping; fixed by word-wrapping every flushed line to the
+terminal width before building it.
+
+- [x] A `tracing::info!`/`debug!` log line fired mid-run (e.g. the "retrying check whose agent did not
+report" line) wrote raw bytes straight to stdout, corrupting the inline TUI's cursor-managed viewport.
+Fixed by giving the presenter full ownership of log output: `PresenterActor` now registers itself as
+`tracing`'s active sink (`src/terminal/logging.rs::route_logs`) for the run's duration and folds each
+line in as a `UiEvent::Log`. The inline TUI flushes each line to permanent scrollback (same mechanism as
+a completed requirement) and also keeps the last few in a small live pane, separate from the tree.
diff --git a/Cargo.lock b/Cargo.lock
index e68796c..67c8cc0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3455,6 +3455,7 @@ dependencies = [
  "bigdecimal",
  "bon",
  "cersei-agent",
+ "cersei-memory",
  "cersei-provider",
  "cersei-tools",
  "cersei-types",
@@ -3489,6 +3490,7 @@ dependencies = [
  "serde_with",
  "static_assertions",
  "tempfile",
+ "textwrap",
  "thiserror 2.0.18",
  "tokio",
  "tokio-graceful-shutdown",
@@ -5499,6 +5501,12 @@ version = "1.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
 
+[[package]]
+name = "smawk"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8e2fb0f499abb4d162f2bedad68f5ef91a1682b5a03596ddb67efd37768d100"
+
 [[package]]
 name = "socket2"
 version = "0.5.10"
@@ -5915,6 +5923,7 @@ version = "0.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
 dependencies = [
+ "smawk",
  "unicode-linebreak",
  "unicode-width 0.2.0",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 84bd9a8..f6abe84 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -84,8 +84,10 @@ comrak = { version = "0.52", default-features = false }
 libc = "0.2.186"
 tempfile = "3"
 cersei-agent = { git = "https://github.com/wack/cersei.git", branch = "trunk" }
+cersei-memory = { git = "https://github.com/wack/cersei.git", branch = "trunk" }
 cersei-tools = { git = "https://github.com/wack/cersei.git", branch = "trunk" }
 cersei-types = { git = "https://github.com/wack/cersei.git", branch = "trunk" }
+textwrap = "0.16"
 
 [workspace.dependencies]
 pretty_assertions = "1.4"
diff --git a/src/checks/executor/cersei.rs b/src/checks/executor/cersei.rs
index 4895247..8e9a4db 100644
--- a/src/checks/executor/cersei.rs
+++ b/src/checks/executor/cersei.rs
@@ -2,10 +2,12 @@
 //! `cersei_agent::Agent` in its CoW sandbox, capturing the verdict through a
 //! per-check judge tool — no `claude -p` subprocess, no MCP endpoints.
 
+use std::path::Path;
 use std::time::Duration;
 
 use async_trait::async_trait;
 use cersei_agent::Agent;
+use cersei_memory::claudemd;
 use cersei_tools::permissions::AllowReadOnly;
 use cersei_tools::{Tool, clear_session_shell_state};
 use cersei_types::CerseiError;
@@ -64,6 +66,21 @@ fn read_only_tools() -> Vec<Box<dyn Tool>> {
     ]
 }
 
+/// Load the project's `CLAUDE.md` hierarchy (managed `~/.claude/rules/*.md`,
+/// user `~/.claude/CLAUDE.md`, project `{root}/CLAUDE.md`, local
+/// `{root}/.claude/CLAUDE.md`, with `@include` expansion) as a single system
+/// prompt string, or `None` if no instruction files were found.
+///
+/// Calls `claudemd` directly rather than going through
+/// `cersei_memory::manager::MemoryManager` so this stays a stateless
+/// filesystem read — no session storage, no graph memory, no multi-session
+/// persistence gets pulled in as a side effect.
+fn project_instructions(project_root: &Path) -> Option<String> {
+    let files = claudemd::load_all_memory_files(project_root);
+    let prompt = claudemd::build_memory_prompt(&files);
+    (!prompt.trim().is_empty()).then_some(prompt)
+}
+
 /// Map our coarse [`Effort`] onto a sampling temperature.
 ///
 /// Extended thinking would be the natural effort vehicle, but cersei-provider
@@ -109,7 +126,7 @@ impl CheckExecutor for CerseiExecutor {
 
         let instructions = assemble_instructions(&req.check, &judge_tool_directive());
 
-        let agent = Agent::builder()
+        let mut agent_builder = Agent::builder()
             .provider_boxed(provider)
             .model(self.model.clone())
             .working_dir(req.working_dir.clone())
@@ -122,7 +139,19 @@ impl CheckExecutor for CerseiExecutor {
             // Thinking is intentionally left disabled (see `effort_temperature`).
             .temperature(effort_temperature(self.effort))
             .max_turns(MAX_TURNS)
-            .cancel_token(cancel.clone())
+            .cancel_token(cancel.clone());
+
+        // `.system_prompt()`, not `.append_system_prompt()`: cersei's agent
+        // runner only ever reads `Agent.system_prompt` when building each
+        // completion request (`append_system_prompt` is exclusively consumed
+        // by the separate `cersei_agent::system_prompt::build_system_prompt`
+        // composer, which this executor doesn't use), and we don't set a base
+        // system prompt anywhere else here.
+        if let Some(project_prompt) = project_instructions(&req.working_dir) {
+            agent_builder = agent_builder.system_prompt(project_prompt);
+        }
+
+        let agent = agent_builder
             .build()
             .map_err(|e| miette!("building check agent: {e}"))?;
 
diff --git a/src/checks/presenter/heartbeat.rs b/src/checks/presenter/heartbeat.rs
index bf90114..536fd40 100644
--- a/src/checks/presenter/heartbeat.rs
+++ b/src/checks/presenter/heartbeat.rs
@@ -73,8 +73,18 @@ impl HeartbeatBackend {
 }
 
 impl RenderBackend for HeartbeatBackend {
-    fn apply(&mut self, _state: &PresenterState, _event: &UiEvent) {
-        // Heartbeat is purely time-driven; events only update shared state.
+    fn apply(&mut self, _state: &PresenterState, event: &UiEvent) {
+        // Heartbeat is otherwise purely time-driven; events only update shared
+        // state. Routed log lines are the exception: the presenter is now
+        // `tracing`'s sole sink for the run (see the module docs), so if we
+        // don't re-emit them here they simply vanish. Stderr, not stdout, to
+        // honor this backend's own invariant that stdout stays reserved for the
+        // reporting actor's byte-for-byte report.
+        if let UiEvent::Log(line) = event {
+            let mut err = std::io::stderr().lock();
+            let _ = writeln!(err, "{line}");
+            let _ = err.flush();
+        }
     }
 
     fn tick(&mut self, state: &PresenterState) {
diff --git a/src/checks/presenter/inline.rs b/src/checks/presenter/inline.rs
index 5ce42ea..61b1347 100644
--- a/src/checks/presenter/inline.rs
+++ b/src/checks/presenter/inline.rs
@@ -13,7 +13,25 @@
 //! The flushed record reuses the reporting actor's exact text (the requirement
 //! line + [`failing_check_text`]) and the same AND-aggregation, so the TTY
 //! scrollback and the non-TTY stdout report differ only in inter-requirement
-//! order (completion vs declaration), never in per-requirement content.
+//! order (completion vs declaration), never in per-requirement content. Unlike
+//! [`report`], which prints through the real terminal and so gets its line
+//! wrapping for free, a `ratatui` [`Buffer`] is a fixed-size grid: any row wider
+//! than the buffer is silently clipped rather than wrapped. Because
+//! `insert_before` renders into such a buffer, long evidence text (which
+//! [`report`] never truncates) is word-wrapped to the terminal width *before*
+//! it becomes [`Line`]s, so every wrapped row is reserved height and nothing is
+//! lost.
+//!
+//! [`report`]: crate::checks::reporting::report
+//! [`Buffer`]: ratatui::buffer::Buffer
+//!
+//! [`UiEvent::Log`]s get the same durable treatment: each one is flushed to
+//! scrollback the instant it arrives ([`InlineTuiBackend::flush_log_line`]), via
+//! the identical `insert_before` mechanism, so a `tracing::info!` mid-run can
+//! never write raw bytes over the live region. The live region *also* keeps the
+//! last few lines in a small pane below the tree — separate from it, never
+//! interleaved into a check's row — purely as an ephemeral "what just happened"
+//! glance; the scrollback copy is the permanent record.
 //!
 //! [`Terminal::insert_before`]: ratatui::Terminal::insert_before
 //! [`failing_check_text`]: crate::checks::reporting::failing_check_text
@@ -38,9 +56,10 @@ use super::backend::RenderBackend;
 use super::format::{clock_elapsed, gauge_bar, human_elapsed, spinner_frame};
 use super::state::{CheckState, PresenterState};
 
-/// Reserved height for the live region. Completed requirements flush out, so this
-/// only ever needs to hold the in-flight tree + the gauge header.
-const VIEWPORT_HEIGHT: u16 = 12;
+/// Reserved height for the live region. Completed requirements flush out, so
+/// this only ever needs to hold the in-flight tree + the gauge header, plus a
+/// few rows for the recent-log pane (header + up to `RECENT_LOGS_CAP` lines).
+const VIEWPORT_HEIGHT: u16 = 16;
 /// Width of the textual gauge bar.
 const GAUGE_WIDTH: usize = 12;
 /// Redraw cadence: ~20fps keeps the spinner and elapsed timers fluid.
@@ -82,6 +101,14 @@ impl InlineTuiBackend {
         })
     }
 
+    /// The terminal's current column count — the exact width `insert_before`
+    /// renders into (see the module docs), so this is what callers wrap text to
+    /// before reserving height for it. Falls back to a sane default if the
+    /// terminal can't report its size (never observed in practice).
+    fn terminal_width(&self) -> u16 {
+        self.terminal.size().map(|s| s.width).unwrap_or(80)
+    }
+
     /// Flush every requirement that has fully settled (and isn't already flushed)
     /// into scrollback, in `req_index` order. Only runs once discovery is complete
     /// so a requirement's check count is final.
@@ -96,7 +123,11 @@ impl InlineTuiBackend {
             let Some(outcome) = state.requirement_outcome(req_index) else {
                 continue;
             };
-            let lines = requirement_record_lines(&outcome, self.color);
+            // Word-wrap to the render width now: each wrapped row becomes its own
+            // `Line`, which makes `lines.len()` the correct height to reserve —
+            // no row gets clipped.
+            let width = self.terminal_width();
+            let lines = requirement_record_lines(&outcome, self.color, width);
             let height = lines.len() as u16;
             let _ = self.terminal.insert_before(height, move |buf| {
                 let area = buf.area;
@@ -106,6 +137,23 @@ impl InlineTuiBackend {
         }
     }
 
+    /// Flush a single routed log line into scrollback immediately, the same way
+    /// a completed requirement is flushed — so it never fights the live region
+    /// for control of the cursor, and (per the module docs) is word-wrapped
+    /// rather than clipped. This is the *permanent* record of the line; the live
+    /// region separately keeps the last few for at-a-glance context (see
+    /// [`live_lines`]).
+    fn flush_log_line(&mut self, line: &str) {
+        let width = self.terminal_width();
+        let style = self.color.then(|| Style::new().add_modifier(Modifier::DIM));
+        let lines = styled_wrapped_lines(line, width, style);
+        let height = lines.len() as u16;
+        let _ = self.terminal.insert_before(height, move |buf| {
+            let area = buf.area;
+            Paragraph::new(lines).render(area, buf);
+        });
+    }
+
     /// Redraw the live region (gauge header + in-flight tree).
     fn draw_live(&mut self, state: &PresenterState) {
         let lines = live_lines(state, &self.flushed, self.frame, GAUGE_WIDTH);
@@ -121,13 +169,15 @@ impl RenderBackend for InlineTuiBackend {
         if self.torn_down {
             return;
         }
-        // A settle (or the discovery-complete gate opening) can complete a
-        // requirement; flush it to scrollback immediately so the record is durable.
-        if matches!(
-            event,
-            UiEvent::CheckSettled { .. } | UiEvent::DiscoveryComplete { .. }
-        ) {
-            self.flush_completed(state);
+        match event {
+            // A settle (or the discovery-complete gate opening) can complete a
+            // requirement; flush it to scrollback immediately so the record is
+            // durable.
+            UiEvent::CheckSettled { .. } | UiEvent::DiscoveryComplete { .. } => {
+                self.flush_completed(state);
+            }
+            UiEvent::Log(line) => self.flush_log_line(line),
+            _ => {}
         }
     }
 
@@ -210,36 +260,65 @@ extern "C" fn restore_on_sigint(_sig: libc::c_int) {
     }
 }
 
-/// The persistent record for one completed requirement — byte-identical in text
-/// to the reporting actor's output, only styled for the terminal.
-fn requirement_record_lines(outcome: &RequirementOutcome, color: bool) -> Vec<Line<'static>> {
+/// The persistent record for one completed requirement — same text content as
+/// the reporting actor's output (just spread across more rows when a line is
+/// word-wrapped to `width`), styled for the terminal.
+fn requirement_record_lines(
+    outcome: &RequirementOutcome,
+    color: bool,
+    width: u16,
+) -> Vec<Line<'static>> {
     let mut lines = Vec::new();
-    let title = outcome.title.clone();
-    lines.push(if color {
-        let mut style = Style::new().add_modifier(Modifier::BOLD);
-        style = style.fg(if outcome.satisfied {
-            Color::Green
-        } else {
-            Color::Red
-        });
-        Line::styled(title, style)
+    let title_style = color.then(|| {
+        Style::new()
+            .add_modifier(Modifier::BOLD)
+            .fg(if outcome.satisfied {
+                Color::Green
+            } else {
+                Color::Red
+            })
+    });
+    let title_text = if color {
+        outcome.title.clone()
     } else {
         let mark = if outcome.satisfied { "PASS" } else { "FAIL" };
-        Line::raw(format!("[{mark}] {title}"))
-    });
+        format!("[{mark}] {}", outcome.title)
+    };
+    lines.extend(styled_wrapped_lines(&title_text, width, title_style));
+
     if !outcome.satisfied {
+        let evidence_style = color.then(|| Style::new().fg(Color::Red));
         for check in outcome.failing_checks() {
             let text = failing_check_text(check);
-            lines.push(if color {
-                Line::styled(text, Style::new().fg(Color::Red))
-            } else {
-                Line::raw(text)
-            });
+            lines.extend(styled_wrapped_lines(&text, width, evidence_style));
         }
     }
     lines
 }
 
+/// Word-wrap `text` to `width` columns and render each resulting row as its own
+/// `Line`, uniformly styled. Wrapping (rather than clipping) is what keeps long
+/// evidence text from being lost off the edge of the fixed-size `Buffer` that
+/// [`InlineTuiBackend::flush_completed`] renders into.
+fn styled_wrapped_lines(text: &str, width: u16, style: Option<Style>) -> Vec<Line<'static>> {
+    // A degenerate width (terminal not yet sized) can't wrap meaningfully;
+    // fall back to a single unwrapped row rather than looping or dividing by it.
+    if width == 0 {
+        return vec![raw_or_styled(text.to_string(), style)];
+    }
+    textwrap::wrap(text, width as usize)
+        .into_iter()
+        .map(|row| raw_or_styled(row.into_owned(), style))
+        .collect()
+}
+
+fn raw_or_styled(text: String, style: Option<Style>) -> Line<'static> {
+    match style {
+        Some(style) => Line::styled(text, style),
+        None => Line::raw(text),
+    }
+}
+
 /// Build the live region: the gauge/tally header, then the in-flight tree grouped
 /// by requirement (flushed requirements excluded). Requirements with active work
 /// are ordered first so a bounded viewport never hides a running check.
@@ -311,6 +390,18 @@ fn live_lines(
         }
     }
 
+    // A small, separate pane for the most recent log lines — kept apart from
+    // the tree above so a mid-run `tracing::info!` never reads as one of its
+    // rows. The full history of every line already sits in scrollback (each is
+    // flushed there the instant it arrives; see `flush_log_line`), so this is
+    // just an ephemeral "what just happened" glance, not the record of truth.
+    if !state.recent_logs.is_empty() {
+        lines.push(Line::raw("logs"));
+        for entry in &state.recent_logs {
+            lines.push(Line::raw(format!("  {entry}")));
+        }
+    }
+
     lines
 }
 
@@ -341,7 +432,8 @@ mod tests {
     }
 
     /// The flushed record's plain text must match the reporting actor's output —
-    /// one record, never divergent.
+    /// one record, never divergent — as long as the width is generous enough
+    /// that nothing wraps.
     #[test]
     fn flushed_record_text_matches_reporting() {
         let failing = CheckOutcome {
@@ -351,7 +443,7 @@ mod tests {
         };
         let out = outcome("R", false, vec![failing.clone()]);
 
-        let lines = requirement_record_lines(&out, false);
+        let lines = requirement_record_lines(&out, false, 80);
         let rendered: Vec<String> = lines
             .iter()
             .map(|l| l.spans.iter().map(|s| s.content.as_ref()).collect())
@@ -364,7 +456,49 @@ mod tests {
     #[test]
     fn satisfied_record_is_single_line() {
         let out = outcome("OK", true, vec![]);
-        let lines = requirement_record_lines(&out, false);
+        let lines = requirement_record_lines(&out, false, 80);
         assert_eq!(lines.len(), 1);
     }
+
+    /// Evidence text longer than the terminal is word-wrapped into multiple
+    /// rows rather than being clipped by the fixed-width `Buffer` — the fix for
+    /// long error messages getting cut off once the TUI hands off to scrollback.
+    #[test]
+    fn long_evidence_wraps_instead_of_clipping() {
+        // Every word is short enough to fit within `width` on its own, so
+        // wrapping only ever splits *between* words, never inside one — which
+        // keeps the "every word survives" assertion below unambiguous.
+        let evidence = "this evidence line is much longer than the width so it wraps across several rows instead of clipping";
+        let failing = CheckOutcome {
+            title: "c".into(),
+            verdict: Verdict::Failed,
+            evidence: Some(evidence.into()),
+        };
+        let out = outcome("R", false, vec![failing]);
+
+        let width = 10;
+        let lines = requirement_record_lines(&out, false, width);
+        let rendered: Vec<String> = lines
+            .iter()
+            .map(|l| {
+                l.spans
+                    .iter()
+                    .map(|s| s.content.as_ref())
+                    .collect::<String>()
+            })
+            .collect();
+
+        // No row exceeds the reserved width...
+        assert!(
+            rendered
+                .iter()
+                .all(|row| row.chars().count() <= width as usize)
+        );
+        // ...and every word of the original evidence survives somewhere in the
+        // wrapped output, so nothing was silently dropped.
+        let joined = rendered.join(" ");
+        for word in evidence.split_whitespace() {
+            assert!(joined.contains(word), "lost {word:?} from wrapped evidence");
+        }
+    }
 }
diff --git a/src/checks/presenter/mod.rs b/src/checks/presenter/mod.rs
index 952bf8a..4e2260e 100644
--- a/src/checks/presenter/mod.rs
+++ b/src/checks/presenter/mod.rs
@@ -19,6 +19,13 @@
 //! periodic [`Tick`] drives `backend.tick()` so spinners and elapsed timers keep
 //! moving between events — the liveness signal that proves a slow run isn't hung.
 //!
+//! The presenter also owns `tracing` output for the run's duration: `on_start`
+//! registers itself via [`crate::terminal::route_logs`] and pumps every routed
+//! line in as a [`UiEvent::Log`], so a `tracing::info!` fired mid-run reaches the
+//! same backend instead of writing raw bytes straight to stdout — which, for
+//! [`InlineTuiBackend`], would corrupt its cursor-managed viewport. `on_stop`
+//! drops the registration, restoring direct stdout logging.
+//!
 //! [`InlineTuiBackend`]: inline::InlineTuiBackend
 //! [`HeartbeatBackend`]: heartbeat::HeartbeatBackend
 //! [`NullBackend`]: recording::NullBackend
@@ -39,6 +46,7 @@ use kameo::error::ActorStopReason;
 use kameo::message::{Context, Message};
 
 use crate::checks::model::{CheckId, CheckOutcome};
+use crate::terminal::{LogRouteGuard, route_logs};
 
 pub(crate) use backend::RenderBackend;
 use heartbeat::HeartbeatBackend;
@@ -72,6 +80,11 @@ pub(crate) enum UiEvent {
     /// The check reached a terminal verdict. Carries the reconciled outcome so the
     /// presenter can render the same record the reporting actor would.
     CheckSettled { id: CheckId, outcome: CheckOutcome },
+    /// A `tracing` log line fired somewhere in the run, already formatted.
+    /// Routed through the presenter (via [`crate::terminal::route_logs`]) so it
+    /// never writes raw bytes over a live backend's cursor-managed display; each
+    /// backend decides for itself where a log line belongs.
+    Log(String),
 }
 
 /// The periodic redraw nudge. Decoupled from [`UiEvent`] so rendering is
@@ -84,6 +97,12 @@ pub(crate) struct PresenterActor {
     backend: Box<dyn RenderBackend>,
     /// The redraw ticker task, joined on stop so it never outlives the actor.
     ticker: Option<tokio::task::JoinHandle<()>>,
+    /// The task pumping routed log lines into `self` as [`UiEvent::Log`]s.
+    /// Joined on stop, after `log_route` is dropped closes its channel.
+    log_pump: Option<tokio::task::JoinHandle<()>>,
+    /// Keeps this actor registered as `tracing`'s active sink; dropping it (in
+    /// `on_stop`) restores direct stdout logging and closes `log_pump`'s channel.
+    log_route: Option<LogRouteGuard>,
 }
 
 impl PresenterActor {
@@ -93,6 +112,8 @@ impl PresenterActor {
             state: PresenterState::new(),
             backend,
             ticker: None,
+            log_pump: None,
+            log_route: None,
         }
     }
 }
@@ -128,8 +149,28 @@ impl Actor for PresenterActor {
                 }
             }
         });
+
+        // Become tracing's active sink for the run's duration and pump routed
+        // lines in as `UiEvent::Log`s, mirroring the ticker's weak-ref pattern so
+        // this task can't keep the actor alive and exits the instant it's gone.
+        let (log_tx, mut log_rx) = tokio::sync::mpsc::unbounded_channel();
+        let log_route = route_logs(log_tx);
+        let weak_log = actor_ref.downgrade();
+        let log_handle = tokio::spawn(async move {
+            while let Some(line) = log_rx.recv().await {
+                let Some(actor) = weak_log.upgrade() else {
+                    break;
+                };
+                if actor.tell(UiEvent::Log(line)).await.is_err() {
+                    break;
+                }
+            }
+        });
+
         let mut me = args;
         me.ticker = Some(handle);
+        me.log_pump = Some(log_handle);
+        me.log_route = Some(log_route);
         Ok(me)
     }
 
@@ -144,6 +185,13 @@ impl Actor for PresenterActor {
             handle.abort();
             let _ = handle.await;
         }
+        // Unregister first so tracing falls back to stdout again, which closes
+        // the pump's channel; then wait for it to drain whatever was already
+        // queued and exit on its own rather than aborting it mid-line.
+        self.log_route.take();
+        if let Some(handle) = self.log_pump.take() {
+            let _ = handle.await;
+        }
         // The authoritative restore: runs on graceful stop, kill, *and* panic
         // (in addition to the panic hook that shows the cursor).
         self.backend.teardown(&self.state);
diff --git a/src/checks/presenter/state.rs b/src/checks/presenter/state.rs
index 63a9bf5..c89b4a2 100644
--- a/src/checks/presenter/state.rs
+++ b/src/checks/presenter/state.rs
@@ -12,7 +12,7 @@
 //! [`Message<UiEvent>`]: super::PresenterActor
 //! [`Message<Tick>`]: super::PresenterActor
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, VecDeque};
 use std::path::PathBuf;
 use std::time::Instant;
 
@@ -20,6 +20,12 @@ use crate::checks::model::{CheckId, CheckOutcome, RequirementOutcome, Verdict};
 
 use super::UiEvent;
 
+/// How many recent log lines the live view keeps for at-a-glance context. Full
+/// history is never lost — every line is *also* flushed straight to permanent
+/// scrollback (see `InlineTuiBackend::flush_log_line`) — so this only bounds the
+/// ephemeral in-viewport pane.
+const RECENT_LOGS_CAP: usize = 3;
+
 /// Where a single check is in its lifecycle, as seen by the presenter.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) enum CheckState {
@@ -70,6 +76,8 @@ pub(crate) struct PresenterState {
     /// Every check, keyed by id. A `BTreeMap` so iteration is in id order, which
     /// is `(req_index, declaration)` order — matching the canonical report.
     pub rows: BTreeMap<CheckId, CheckRow>,
+    /// The last [`RECENT_LOGS_CAP`] routed log lines, oldest first.
+    pub recent_logs: VecDeque<String>,
 }
 
 impl PresenterState {
@@ -80,6 +88,7 @@ impl PresenterState {
             total: None,
             discovery_complete: false,
             rows: BTreeMap::new(),
+            recent_logs: VecDeque::new(),
         }
     }
 
@@ -125,6 +134,12 @@ impl PresenterState {
                     row.outcome = Some(outcome.clone());
                 }
             }
+            UiEvent::Log(line) => {
+                self.recent_logs.push_back(line.clone());
+                if self.recent_logs.len() > RECENT_LOGS_CAP {
+                    self.recent_logs.pop_front();
+                }
+            }
         }
     }
 
diff --git a/src/terminal/logging.rs b/src/terminal/logging.rs
index 652575d..557f88c 100644
--- a/src/terminal/logging.rs
+++ b/src/terminal/logging.rs
@@ -1,5 +1,8 @@
-use std::sync::Once;
+use std::io::{self, Write};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Mutex, Once, OnceLock};
 
+use tokio::sync::mpsc::UnboundedSender;
 use tracing_subscriber::{filter::LevelFilter, fmt::time::ChronoLocal};
 
 static LOGGER_READY: Once = Once::new();
@@ -25,6 +28,9 @@ pub(super) fn setup_logger(level: LevelFilter) {
             .with_file(false)
             .with_line_number(false)
             .with_target(false)
+            // Route every formatted line through `RoutingWriter` instead of
+            // writing straight to stdout — see its docs for why.
+            .with_writer(RoutingWriter::default)
             // Scope the subscriber to ONLY the multitool module.
             .with_env_filter(format!("multitool={}", level))
             .compact()
@@ -34,3 +40,94 @@ pub(super) fn setup_logger(level: LevelFilter) {
             .expect("setting tracing default failed");
     });
 }
+
+/// The currently-registered log sink, tagged with the generation that installed
+/// it. Tagging lets a stale guard's `Drop` recognize it's no longer current and
+/// skip clearing a newer registration — otherwise two overlapping presenter runs
+/// in the same process (e.g. concurrent tests) could race to uninstall each
+/// other's sink.
+type Sink = (u64, UnboundedSender<String>);
+static LOG_SINK: OnceLock<Mutex<Option<Sink>>> = OnceLock::new();
+static NEXT_GENERATION: AtomicU64 = AtomicU64::new(0);
+
+fn sink() -> &'static Mutex<Option<Sink>> {
+    LOG_SINK.get_or_init(|| Mutex::new(None))
+}
+
+/// Route every subsequently-formatted log line to `tx` instead of stdout, until
+/// the returned guard drops.
+///
+/// The live presenter (MULTI-1369 follow-up) becomes the terminal's sole writer
+/// for the run — without this, a `tracing::info!` fired mid-run (e.g. "retrying
+/// check whose agent did not report") writes raw bytes straight over the inline
+/// TUI's cursor-managed viewport and corrupts it. Routing lets the presenter
+/// fold log lines into its own display instead.
+pub(crate) fn route_logs(tx: UnboundedSender<String>) -> LogRouteGuard {
+    let generation = NEXT_GENERATION.fetch_add(1, Ordering::Relaxed);
+    *sink().lock().unwrap() = Some((generation, tx));
+    LogRouteGuard { generation }
+}
+
+/// Restores direct stdout logging when dropped — but only if no newer
+/// registration has since replaced this one.
+pub(crate) struct LogRouteGuard {
+    generation: u64,
+}
+
+impl Drop for LogRouteGuard {
+    fn drop(&mut self) {
+        let mut guard = sink().lock().unwrap();
+        if matches!(&*guard, Some((generation, _)) if *generation == self.generation) {
+            *guard = None;
+        }
+    }
+}
+
+/// Forward one complete, already-formatted log line to the active
+/// [`route_logs`] sink, falling back to stdout when none is registered (i.e.
+/// outside a live presenter run — today's unchanged behavior).
+fn emit(text: String) {
+    let sender = sink().lock().unwrap().as_ref().map(|(_, tx)| tx.clone());
+    match sender {
+        Some(tx) => {
+            // A closed receiver only happens mid-teardown; dropping the line is
+            // fine since the presenter is on its way out anyway.
+            let _ = tx.send(text);
+        }
+        None => {
+            let _ = writeln!(io::stdout(), "{text}");
+        }
+    }
+}
+
+/// A [`tracing_subscriber`] writer that buffers until it sees a complete line,
+/// then hands that line to [`emit`]. `tracing-subscriber`'s formatter isn't
+/// guaranteed to make one `write` call per event, so buffering (rather than
+/// treating each `write` as a line) is what keeps a single log record intact.
+#[derive(Default)]
+struct RoutingWriter {
+    buf: Vec<u8>,
+}
+
+impl Write for RoutingWriter {
+    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
+        self.buf.extend_from_slice(data);
+        while let Some(pos) = self.buf.iter().position(|&b| b == b'\n') {
+            let line: Vec<u8> = self.buf.drain(..=pos).collect();
+            emit(String::from_utf8_lossy(&line[..line.len() - 1]).into_owned());
+        }
+        Ok(data.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Drop for RoutingWriter {
+    fn drop(&mut self) {
+        if !self.buf.is_empty() {
+            emit(String::from_utf8_lossy(&self.buf).into_owned());
+        }
+    }
+}
diff --git a/src/terminal/mod.rs b/src/terminal/mod.rs
index 7168a60..0d911fd 100644
--- a/src/terminal/mod.rs
+++ b/src/terminal/mod.rs
@@ -10,6 +10,8 @@ mod dest;
 mod logging;
 mod theme;
 
+pub(crate) use logging::{LogRouteGuard, route_logs};
+
 pub struct Terminal {
     stdout: TermDestination,
     stderr: TermDestination,