refactor(tui): thinking streams into whole pane (v0.6.5)

Operator: "Why does the thinking scroll a little section at the
bottom of the thinking pane instead of scrolling the whole pane?"

Root cause: v0.6.1's thinking-current Static was docked to the
bottom of the Thinking pane and rendered the last 200 chars of
streaming content. As deltas arrived, the displayed 200-char tail
shifted — old text fell off the left, new text appeared on the
right — visually reading as "a little section scrolling at the
bottom" while the larger thinking-log RichLog above showed only
the previous run's closed content (or nothing on first turn).

## Fix: stream directly into thinking-log

The Static is gone. Thinking deltas now write straight to the
`thinking-log` RichLog (one delta = one line in the scrollable
log). The whole pane scrolls naturally as content arrives —
operator can switch to Ctrl+3 and see streaming content fill
the pane top-to-bottom.

Routing pattern:

  First Thinking delta of run:
    → write Rule(title="turn N · thinking #K start") to thinking_log
    → write delta content as a line
    → set thinking_open = True
  Subsequent Thinking deltas:
    → write delta content as a line
  Non-thinking event (closes the run):
    → write Rule(title="turn N · thinking #K end") to thinking_log
    → reset thinking_open

The Rule(start) at the top of an in-progress run is now the
"thinking is happening" indicator. No more separate live-preview
widget required.

## Trade-off: no markdown re-render

Pre-v0.6.5 closed runs got a Markdown(full_content) render between
the start/end Rules. v0.6.5 drops that — the streamed deltas ARE
the content; re-rendering as Markdown would either need to wait
for run-end (no streaming) OR re-render incrementally per delta
(bad UX). Streaming wins for "live observability" framing.

The downside: if model thinking has Markdown structure (lists,
code), it renders as raw text. Acceptable per operator's "stream
in line" framing.

## Removed widgets

- `Static#thinking-current` (right column / Thinking pane bottom)
- `TuiPresenterState.render` no longer takes a `thinking_widget` param
- `TuiPresenterState.thinking_buffer` field dropped (no accumulation)
- `_stream_turn_worker` no longer queries `#thinking-current`
- `on_mount` no longer hides `#thinking-current`
- DEFAULT_CSS `#thinking-current` block removed

## Contract amendment

INV-022 amended: thinking now streams as raw delta lines, not
Markdown-rendered on close. INV-024 amended: thinking-current
Static removed entirely (was relocated v0.6.1, removed v0.6.5).
Drift-check clean.

## Tests

238/238 GREEN (was 241 — 3 obsolete widget tests deleted:
test_thinking_widget_truncation, test_thinking_widget_visibility_lifecycle,
test_terminal_events_belt_and_braces_widget_cleanup). 5 routing tests
rewritten for the new streaming shape (test_thinking_streams_into_thinking_log,
test_thinking_closes_to_thinking_log, test_multiple_thinking_runs_...,
test_render_exception_fallback, test_cancelled_mid_thinking_closes,
test_left_column_content_only).

ruff clean. Manual injection test confirms routing: Rule(start) +
delta lines write to thinking_log; transcript untouched.

Patch bump (v0.6.4 → v0.6.5) — internal restructure within Thinking
pane; presenter signature narrowed; no caller-visible public API
change (RatatoskrApp + AgentPickerApp surfaces identical).

docs/contracts/issues/13.contract.md

@@ -154,10 +154,16 @@ New `Static(id="pane-name")` widget alongside the existing `identity` + `hint` w
 
 - **INV-013**: Layout is `Horizontal` two-column. Left column width = 2fr; right column width = 1fr.
 - **INV-014**: `ToolStart` / `ToolResult` events route to `tools_log` (Tools pane), never to `log` (transcript).
-- **INV-015**: Every other event type (`Text`, `Thinking`, `WorkerPhase`, `TextBoundary`, `Done`, `Error`, `Cancelled`) keeps its issue-#12 routing target (`log` for chronological entries; `thinking_widget` for live deltas).
-- **INV-016**: Input retains keyboard focus across `Ctrl+1` tab switch.
-- **INV-017**: `thinking-current` Static docks to the top of the **left column**, not the whole App — TabbedContent's vertical extent on the right is independent of thinking-runs starting/stopping.
+- **INV-015** *(amended v0.5.0)*: The transcript (`log`) is **content-only** — receives `Text`, `Done` (label + Markdown body + Rule), `Error`, `Cancelled`, and the user-prompt echo (`❯ <content>`). **All telemetry events (`Thinking` closed runs, `WorkerPhase`, `TextBoundary`) route to `debug_log` (Debug pane), NOT `log`.** Live thinking deltas continue to update `thinking_widget` per-delta. The pre-v0.5.0 shape (telemetry mixed into transcript) is retired under the project's no-backwards-compat rule.
+- **INV-016**: Input retains keyboard focus across `Ctrl+1` / `Ctrl+2` tab switches.
+- **INV-017** *(amended v0.5.0)*: `thinking-current` Static docks to the top of the **right column** (above `TabbedContent`), not the left column. Live thinking visibility persists across tab switches. v0.5.0 moves it from left → right so the left column is genuinely content-only.
 - **INV-018**: CLI mode (`ratatoskr.cli._amain`) is unaffected. CLI keeps inline `· tool_start: …` / `· tool_result: …` rendering on stderr per issue #12 INV-005.
+- **INV-019** *(amended v0.6.0)*: Three TabPanes in the right column: `Tools` (id `tools-tab`, contains `#tools-log`) + `Debug` (id `debug-tab`, contains `#debug-log`) + `Thinking` (id `thinking-tab`, contains `#thinking-log`). Ctrl+1/Ctrl+2/Ctrl+3 activate respective tabs. `pane-name` Static reflects active tab name dynamically.
+- **INV-020** *(amended v0.6.0)*: Render-exception fallback (INV-009) preserves routing per event class: `ToolStart` / `ToolResult` → `tools_log`; `Thinking` → `thinking_log`; `WorkerPhase` / `TextBoundary` → `debug_log`; everything else → `log`.
+- **INV-021** *(new v0.6.0)*: `Text` events do NOT route to `log` per-delta. They accumulate into `TuiPresenterState.text_buffer` and update a single `current_text` Static (docked above the prompt). On terminal event (`Done`/`Error`/`Cancelled`), `current_text` is cleared and (raw mode) accumulated text or (non-raw) post-Done `Markdown(response)` is written to `log`. The pre-v0.6.0 per-token RichLog spam is retired.
+- **INV-022** *(amended v0.6.5)*: Thinking deltas stream DIRECTLY into `thinking_log` (one delta = one RichLog line). The first delta of a run writes `Rule(title=f"turn N · thinking #K start")`; subsequent deltas write their raw content as lines; the run closes on the next non-thinking event with `Rule(title=f"turn N · thinking #K end")`. Pre-v0.6.5 markdown re-render dropped — the streamed deltas ARE the content; the whole pane scrolls naturally as content arrives.
+- **INV-023** *(new v0.6.0)*: Turn-ID header `Rule(title=f"turn N")` is written to all four log panes (`log`, `tools_log`, `debug_log`, `thinking_log`) by `_stream_turn_worker` on the first event of each turn — enables cross-pane visual correlation during multi-turn debugging.
+- **INV-024** *(amended v0.6.5)*: `thinking-current` Static REMOVED. v0.6.1 placed it inside the Thinking pane (docked bottom); operators reported the bottom-docked Static "scrolling a little section at the bottom" (its 200-char tail acting as a scroll-window) instead of letting the whole pane scroll. v0.6.5 deletes the Static entirely and streams Thinking deltas directly into `thinking_log` (the scrollable RichLog) — the whole pane scrolls naturally as content arrives. The Rule(start) at the first delta of a run is now the live "thinking is happening" indicator.
 
 ## TESTS (additions / changes to test_tui.py)
 
@@ -185,21 +191,28 @@ Existing tests that need adjustment (NOT rewrite):
 
 All error routing from issues #4 / #6 / #7 / #12 stays verbatim. The tools_log routing change is internal to the presenter; error paths (`SseConnectFailed`, `SseConnectionDropped`, `MalformedSseId`, `MalformedSseData`, `TurnIdFlip`) all write their labeled lines to `log` (the main transcript). Reason: errors are turn-terminal and need to be visible in the operator's primary attention surface; routing them to the Tools pane would hide them behind a tab switch.
 
-## Layout-spec snapshot (after this issue lands)
+## Layout-spec snapshot (after v0.5.0)
 
 ```
 +────────────────────────────────+──────────────────────+
-| · thinking-current             |  ┌─ Tools ─────────┐ |
-|                                |  │ · tool_start:.. │ |
-|  ❯ user-typed line             |  │ · tool_result.. │ |
-|  assistant streaming text...   |  │                 │ |
-|  [done] turn_id=… duration=…   |  │                 │ |
-|                                |  │                 │ |
-|                                |  │                 │ |
-|  [prompt: type and press Enter]|  └─────────────────┘ |
+|  ❯ user-typed line             | · thinking-current   |
+|  assistant streaming text...   |  ┌Tools─┬─Debug─────┐|
+|  [done] turn_id=… duration=…   |  │ · tool_start:..  │|
+|  …markdown render…             |  │ · tool_result..  │|
+|                                |  │                  │|
+|                                |  │                  │|
+|                                |  │                  │|
+|  [prompt: type and press Enter]|  └──────────────────┘|
 +────────────────────────────────+──────────────────────+
 | agent · …sess_id  Tools  Ctrl-C twice to exit         |
 +───────────────────────────────────────────────────────+
 ```
 
-(Width split 2fr:1fr; tab strip is Textual-default.)
+Left column is content-only (transcript + prompt). Right column hosts the
+live `thinking-current` Static at top + `TabbedContent` cycling between
+`Tools` (tool events) and `Debug` (thinking closed runs + worker_phase +
+text_boundary).
+
+(Width split 2fr:1fr; tab strip is Textual-default; Header/Footer
+backgrounds explicitly set to `$surface` to override the Textual default
+`$primary`-blue tinting.)

persistent-memory.md

@@ -32,10 +32,9 @@ separate dev team rather than an in-tree Worldtree tool.
 
 ## Current state / in-flight
 
-_As of 2026-05-24 (post-v0.4.0 §5 entry point: layout reshape +
-Tools pane):_
+_As of 2026-05-24 (post-v0.6.5 thinking streams into whole pane):_
 
-**Status: v0.4.0 shipped.** Nine core issues complete (`sse_client`
+**Status: v0.6.5 shipped.** Nine core issues complete (`sse_client`
 #1, `sessions` #2, `cli` #3, `tui` #4, `--end-user-id` #5, TUI
 startup error visibility #6, presenter contract semantics amendment
 #12, startup agent picker #8, §5 layout reshape + Tools pane #13)
@@ -52,7 +51,16 @@ Static in the footer (static "Tools" v1; dynamic when more tabs
 land). CLI mode (--send) unaffected by design — INV-018.
 
 Last commits on `main`:
-- v0.4.0 feat(tui): issue #13 — §5 layout reshape + Tools pane
+- v0.6.5 refactor(tui): thinking streams into thinking-log (no Static)
+- `82437bd` style(tui): picker highlighted item → Aurora blue (v0.6.4)
+- `ac690c1` style(tui): restore Australis palette, only $background → pure black (v0.6.3)
+- `d845b20` style(tui): neutralize Australis dark palette (v0.6.2, reverted)
+- `8463eb2` style(tui): kill remaining blue + thinking-current into pane (v0.6.1)
+- `cfee89a` refactor(tui): streaming + turn headers + Thinking pane (v0.6.0)
+- `7106af5` style(tui): UI polish pass — terminal label colors, placeholders (v0.5.1)
+- `ffd22fb` refactor(tui): content-only main pane + Debug tab + chrome dark (v0.5.0)
+- `2756f5f` style(tui): apply Australis theme to TUI chrome + widgets (v0.4.1)
+- `24e4371` feat(tui): issue #13 — §5 layout reshape + Tools pane (v0.4.0)
 - `d30be12` feat(sessions,cli,tui): issue #8 — startup agent picker (v0.3.0)
 - `c85f6bd` fix(tui): anchor layout via dock so Input never moves (v0.2.1)
 - `3b9c610` feat(cli,tui): issue #12 — presenter contract semantics amendment (v0.2.0)

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ratatoskr"
-version = "0.4.0"
+version = "0.6.5"
 description = "Worldtree Conversation API debug TUI — multi-pane observability dashboard"
 readme = "README.md"
 requires-python = ">=3.12"

src/ratatoskr/tui.py

@@ -17,11 +17,11 @@ import httpx
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
+from textual.theme import Theme
 from textual.widgets import (
     Footer,
     Header,
     Input,
-    Label,
     ListItem,
     ListView,
     RichLog,
@@ -61,6 +61,74 @@ from ratatoskr.sse_client import (
     stream_turn,
 )
 
+# ---- Australis theme (https://github.com/lkraven/australis) ------------------
+#
+# The Australis Dark color theme, inspired by the Southern Lights. 16 cool-tone
+# terminal colors with medium contrast. Preference order: blue > cyan > green
+# for primary surfaces; Dawn accents (red/yellow/magenta) used sparingly for
+# terminal-event labels (error/cancelled).
+#
+# **v0.6.3 single deviation from spec**: `$background` is `#000000` (pure
+# black), NOT Australis Ice black `#222531`. The Ice black is RGB(34,37,49)
+# — blue dominant — and at App-wide scale the cumulative cast reads as
+# "the whole app is blue" to operators (even though no single surface is
+# "blue" in the strict-color sense). Pure black for the App background
+# kills that perception. EVERY OTHER Australis value — Aurora accents,
+# Sea darks for chrome (surface/panel), Ice white foreground, Dawn
+# accents — stays verbatim per spec.
+#
+# Mapping to Textual's Theme semantic tokens:
+#   primary    = Aurora blue (#6388D8) — focus rings, active selection.
+#   secondary  = Aurora cyan (#00b1a8) — secondary highlights.
+#   accent     = Aurora bright cyan (#42dcd1) — bright accents.
+#   success    = Aurora green (#16B866) — [done] label.
+#   warning    = Dawn yellow (#e1c631) — [cancelled] label.
+#   error      = Dawn red (#ff491a) — [error] label.
+#   foreground = Ice white (#a9bcc3) — default text.
+#   background = pure black (#000000) — App background (v0.6.3 deviation).
+#   surface    = Sea bright black (#373b46) — raised chrome.
+#   panel      = Sea dark 30 (#414751) — borders, separators.
+
+AUSTRALIS_THEME = Theme(
+    name="australis",
+    primary="#6388D8",
+    secondary="#00b1a8",
+    accent="#42dcd1",
+    success="#16B866",
+    warning="#e1c631",
+    error="#ff491a",
+    foreground="#a9bcc3",
+    background="#000000",
+    surface="#373b46",
+    panel="#414751",
+    dark=True,
+    variables={
+        # Sea contrast palette — usable via $au-dark-50 etc. in TCSS.
+        "au-dark-30": "#414751",
+        "au-dark-40": "#565f69",
+        "au-dark-50": "#6e7882",
+        "au-dark-60": "#86929d",
+        "au-bright-70": "#9daeb6",
+        "au-bright-80": "#b3cbcf",
+        "au-bright-white": "#cce7ec",
+        "au-bright-blue": "#a4c4ff",
+        "au-bright-cyan": "#42dcd1",
+        "au-bright-green": "#51e08a",
+    },
+)
+
+
+# Direct hex constants for Rich Text styling (Done/Error/Cancelled labels +
+# transcript user-prompt echo). Themes set TCSS variables; Rich's RichText
+# style strings live outside the theme system, so we resolve to hex here.
+_AU_SUCCESS = "#16B866"
+_AU_ERROR = "#ff491a"
+_AU_WARNING = "#e1c631"
+_AU_USER_ECHO = "#42dcd1"  # Aurora bright cyan — operator's voice
+_AU_DEMOTED = "#86929d"  # Sea dark 60 — demoted telemetry
+_AU_DEMOTED_FAINT = "#6e7882"  # Sea dark 50 — empty-state placeholders
+
+
 # ---- Issue #12 presenter contract semantics amendment -------------------------
 #
 # TuiPresenterState replaces the stateless _render_event_to_log with a stateful
@@ -117,28 +185,40 @@ class TuiPresenterState:
     See `docs/contracts/issues/12.contract.md` for the full spec.
     """
 
-    thinking_buffer: list[str] = field(default_factory=list)
     thinking_open: bool = False
+    # v0.6.0: per-turn streaming text buffer. Text deltas accumulate here
+    # and update `current_text` Static in place — no per-token RichLog spam.
+    text_buffer: list[str] = field(default_factory=list)
+    # Thinking-run counter for turn-scoped start/end markers.
+    thinking_run_index: int = 0
 
     def render(
         self,
         event: Event,
         *,
         log: RichLog,
-        thinking_widget: Static,
+        current_text: Static,
         tools_log: RichLog,
+        debug_log: RichLog,
+        thinking_log: RichLog,
         raw: bool,
     ) -> None:
         """Render one Worldtree SSE event with the TUI hierarchy + coalescing.
 
-        Two-views-of-thinking decoupling: per-delta updates go to
-        `thinking_widget`; one closed entry per run goes to `log`.
+        v0.6.5 routing:
+          - `log` (transcript) = content only: user-prompt echo (written
+            outside the presenter), terminal labels, post-Done Markdown body.
+          - `current_text` (Static below transcript) = live-streaming Text
+            deltas accumulated into one growing line; cleared on terminal.
+          - `tools_log` = ToolStart + ToolResult.
+          - `debug_log` = WorkerPhase + TextBoundary.
+          - `thinking_log` = streaming Thinking deltas inline (each chunk =
+            one line in the scrollable log). Rule(start)/Rule(end) markers
+            wrap each run. The whole pane scrolls naturally — no separate
+            tail-scrolling Static at the bottom (v0.6.5 removed
+            `thinking-current`).
 
-        Issue #13: `ToolStart` / `ToolResult` events route to `tools_log`
-        (the Tools pane in the right column) instead of `log`. Every other
-        event keeps its issue-#12 routing.
-
-        Exceptions are caught at the presenter boundary (INV-009 fallback).
+        Exceptions caught at the presenter boundary (INV-009 fallback).
         """
         assert isinstance(
             event,
@@ -150,64 +230,91 @@ class TuiPresenterState:
         from rich.text import Text as RichText
 
         def _dim(s: str) -> RichText:
-            """Wrap a demoted-telemetry line in dim style for the RichLog."""
-            return RichText(s, style="dim")
+            """Wrap a demoted-telemetry line in Australis Sea dark-60 grey."""
+            return RichText(s, style=_AU_DEMOTED)
 
         try:
-            # Thinking events: accumulate into buffer, update widget per delta.
+            # v0.6.5: Thinking deltas stream directly into thinking_log.
+            # First delta of a run writes the Rule(start) header; each
+            # subsequent delta writes its content as a line; the run closes
+            # on the next non-thinking event with a Rule(end).
             if isinstance(event, Thinking):
+                from rich.rule import Rule
+
                 if not self.thinking_open:
-                    thinking_widget.display = True
+                    self.thinking_run_index += 1
+                    turn_id = event.sse_id.turn_id
+                    thinking_log.write(Rule(
+                        title=f"turn {turn_id} · thinking #{self.thinking_run_index} start",
+                        style=_AU_DEMOTED,
+                    ))
                     self.thinking_open = True
-                self.thinking_buffer.append(event.content)
-                acc = "".join(self.thinking_buffer)
-                display_text = ("…" + acc[-200:]) if len(acc) > 200 else acc
-                thinking_widget.update(display_text)
+                # Stream the delta content (chunk-of-tokens) as one line.
+                thinking_log.write(event.content)
                 return
-            # Non-thinking event: close any open thinking run (one RichLog entry).
+            # Non-thinking event: close any open thinking run with Rule(end).
             if self.thinking_open:
-                full_thinking = "".join(self.thinking_buffer)
-                log.write(_dim(f"· thinking: {full_thinking}"))
-                self.thinking_buffer.clear()
+                from rich.rule import Rule
+
+                turn_id = event.sse_id.turn_id if hasattr(event, "sse_id") else (
+                    event.turn_id if hasattr(event, "turn_id") else "?"
+                )
+                thinking_log.write(Rule(
+                    title=f"turn {turn_id} · thinking #{self.thinking_run_index} end",
+                    style=_AU_DEMOTED,
+                ))
                 self.thinking_open = False
-                thinking_widget.update("")
-                thinking_widget.display = False
             # Now render the non-thinking event itself.
             if isinstance(event, Text):
-                # Streamed text content — no prefix, no demotion.
-                log.write(event.content)
+                # v0.6.0: streaming text accumulates into current_text Static
+                # — one growing live line, NOT per-delta RichLog entries.
+                self.text_buffer.append(event.content)
+                current_text.update("".join(self.text_buffer))
                 return
             if isinstance(event, (Done, Error, Cancelled)):
-                # Terminal events: load-bearing label (no demotion).
+                # Terminal event: clear the streaming Static first so the
+                # live-preview band collapses. Then write the colored label
+                # + (non-raw) Markdown body / (raw) accumulated plain text
+                # to the transcript.
+                accumulated = "".join(self.text_buffer)
+                self.text_buffer.clear()
+                current_text.update("")
+                # Terminal labels tinted per outcome (Aurora green / Dawn red
+                # / Dawn yellow) for at-a-glance scanning.
                 if isinstance(event, Done):
-                    log.write(
+                    log.write(RichText(
                         f"[done] turn_id={event.sse_id.turn_id} model={event.model} "
                         f"duration={_format_duration_ms(event.duration_ms)} "
-                        f"usage {_format_usage(event.usage, arrow='→')}"
-                    )
-                    if not raw:
+                        f"usage {_format_usage(event.usage, arrow='→')}",
+                        style=_AU_SUCCESS,
+                    ))
+                    if raw:
+                        # Raw mode: emit the accumulated streamed text verbatim
+                        # so the operator has a record after the Static clears.
+                        if accumulated:
+                            log.write(accumulated)
+                    else:
                         from rich.markdown import Markdown
                         from rich.rule import Rule
 
-                        log.write(Rule())
+                        log.write(Rule(style=_AU_DEMOTED))
                         log.write(Markdown(event.response))
                 elif isinstance(event, Error):
-                    log.write(
+                    log.write(RichText(
                         f"[error] turn_id={event.sse_id.turn_id} code={event.error_code} "
-                        f"message={event.message!r}"
-                    )
+                        f"message={event.message!r}",
+                        style=_AU_ERROR,
+                    ))
                 else:  # Cancelled
-                    log.write(
+                    log.write(RichText(
                         f"[cancelled] turn_id={event.turn_id} reason={event.reason!r} "
-                        f"partial_message_id={event.partial_message_id}"
-                    )
-                # Belt-and-braces (Volva F3): ensure widget cleared+hidden on EVERY
-                # terminal event, even if thinking_open was False — per STEPS 5-6.
-                thinking_widget.update("")
-                thinking_widget.display = False
+                        f"partial_message_id={event.partial_message_id}",
+                        style=_AU_WARNING,
+                    ))
                 return
             if isinstance(event, WorkerPhase):
-                log.write(_dim(
+                # v0.5.0: telemetry → Debug pane, not transcript.
+                debug_log.write(_dim(
                     f"· worker_phase: phase={event.phase} turn_id={event.turn_id}"
                 ))
                 return
@@ -225,7 +332,8 @@ class TuiPresenterState:
                 ))
                 return
             if isinstance(event, TextBoundary):
-                log.write(_dim(
+                # v0.5.0: telemetry → Debug pane, not transcript.
+                debug_log.write(_dim(
                     f"· text_boundary: kind={event.kind} char_offset={event.char_offset}"
                 ))
                 return
@@ -234,10 +342,20 @@ class TuiPresenterState:
             # the original event AND a render_error line with the class name only
             # (NO exception message — security clause). Volva F1 fix.
             #
-            # Issue #13: routing-under-failure preservation — ToolStart/ToolResult
-            # fallback writes go to tools_log (the routed destination per
-            # INV-014), not the transcript. Every other event falls back to log.
-            target = tools_log if isinstance(event, (ToolStart, ToolResult)) else log
+            # v0.6.0 routing-under-failure preservation — fallback writes go
+            # to the same destination the successful render would have used:
+            #   - ToolStart/ToolResult       → tools_log
+            #   - Thinking                   → thinking_log
+            #   - WorkerPhase/TextBoundary   → debug_log
+            #   - everything else            → log
+            if isinstance(event, (ToolStart, ToolResult)):
+                target = tools_log
+            elif isinstance(event, Thinking):
+                target = thinking_log
+            elif isinstance(event, (WorkerPhase, TextBoundary)):
+                target = debug_log
+            else:
+                target = log
             target.write(_plain_label(event))
             target.write(f"[render_error] {type(exc).__name__}")
 
@@ -253,13 +371,74 @@ class AgentPickerApp(App[str | None]):
     """
 
     DEFAULT_CSS = """
+    /* v0.6.1: kill Textual's $primary-blue tints everywhere — Header sub-
+       widgets (HeaderIcon etc.) have their own $primary tinting that the
+       parent `Header { background: $surface }` rule alone doesn't cover.
+       Sub-selectors force the cool palette down to every level. */
+    Header, HeaderIcon, HeaderTitle, HeaderClock {
+        background: $surface;
+        color: $au-bright-blue;
+    }
+    Footer {
+        background: $surface;
+    }
+    /* v0.6.1: scrollbar uses Textual's $primary-tint by default. Force
+       Australis Sea darks so the scrollbar gutter doesn't read as a blue
+       strip. Applied to ListView (the scrollable widget here). */
+    ListView {
+        scrollbar-background: $background;
+        scrollbar-background-hover: $background;
+        scrollbar-background-active: $background;
+        scrollbar-color: $au-dark-50;
+        scrollbar-color-hover: $au-dark-60;
+        scrollbar-color-active: $au-bright-cyan;
+    }
     #picker-prompt {
         dock: top;
         height: 1;
         padding: 0 1;
+        color: $au-bright-cyan;
+        background: $surface;
     }
     #agent-list {
         height: 1fr;
+        background: $background;
+    }
+    /* Multi-line agent items. Each ListItem is auto-height so the full
+       description wraps below the agent_id/name line — no truncation.
+       v0.6.4: lock bg to $background so Textual's auto background-tint on
+       focus doesn't bleed through unwanted color into the non-highlighted
+       items. */
+    #agent-list > ListItem {
+        height: auto;
+        padding: 1 1;
+        background: $background;
+    }
+    /* v0.6.4: highlighted item gets Aurora blue background (Textual's
+       default $block-cursor-background = $primary). Override only the
+       text-color descendants so id-line/desc stay readable on blue. The
+       background itself comes from Textual's default ListItem.-highlight
+       rule — we removed our previous overriding selectors.
+
+       Textual's class is `-highlight` (single dash). Use plain descendant
+       combinator to bypass internal DOM wrappers. */
+    #agent-list:focus ListItem.-highlight {
+        background: $primary;
+    }
+    #agent-list:focus ListItem.-highlight .agent-id-line {
+        color: $au-bright-white;
+        text-style: bold;
+    }
+    #agent-list:focus ListItem.-highlight .agent-desc {
+        color: $au-bright-80;
+    }
+    /* Default (unhighlighted) item text styling. */
+    .agent-id-line {
+        color: $au-bright-blue;
+        text-style: bold;
+    }
+    .agent-desc {
+        color: $au-bright-70;
     }
     """
 
@@ -276,13 +455,22 @@ class AgentPickerApp(App[str | None]):
         # [no_agents] before constructing the picker.
         assert agents
         self.agents = agents
+        self.register_theme(AUSTRALIS_THEME)
+        self.theme = "australis"
 
     def compose(self) -> ComposeResult:
         yield Header()
         yield Static("Pick an agent for the new session:", id="picker-prompt")
+        # v0.6.0: each ListItem has two Static children — the id/name line
+        # in bold blue + the wrapped description in muted dark-60. No
+        # description truncation; tall items breathe so the operator can
+        # actually read what each agent does.
         yield ListView(
             *[
-                ListItem(Label(f"{a.agent_id} · {a.name} — {a.description}"))
+                ListItem(
+                    Static(f"{a.agent_id} · {a.name}", classes="agent-id-line"),
+                    Static(a.description, classes="agent-desc"),
+                )
                 for a in self.agents
             ],
             id="agent-list",
@@ -306,55 +494,129 @@ class AgentPickerApp(App[str | None]):
 class RatatoskrApp(App[int]):
     """Textual TUI shell — single chat pane."""
 
-    # Issue #13: Horizontal two-column layout per design-brief §5.
-    # Left column (2fr) is the chat surface; right column (1fr) is the
-    # TabbedContent housing side panes. v1 has only the Tools tab.
+    # Issue #13 + v0.5.0 follow-up: Horizontal two-column layout per
+    # design-brief §5. Left column (2fr) is the **content-only** chat
+    # surface — assistant text, user prompt echo, [done]/[error]/[cancelled]
+    # terminal labels, post-Done markdown render. Right column (1fr) houses
+    # ALL telemetry: live thinking preview docked above TabbedContent;
+    # tab strip carries Tools (ToolStart/ToolResult) + Debug (Thinking
+    # closed runs + WorkerPhase + TextBoundary).
     #
-    # Dock rules narrow to per-container scope so thinking-current toggling
-    # in the left column doesn't reflow the right column's TabbedContent.
-    # The v0.2.1 layout-stability property is preserved within the left
-    # column by docking thinking-current top + prompt bottom of that column.
+    # v0.5.0 routing change: thinking-current Static moved from left column
+    # to right column header so the left column is genuinely content-only;
+    # closed thinking runs go to debug-log instead of transcript.
+    #
+    # v0.5.0 chrome fix: Header/Footer backgrounds explicitly set to $surface
+    # (Sea bright-black #373b46) overriding Textual's default $primary-blue
+    # tinting. TabbedContent active-tab tinting also softened.
+    #
+    # Australis theme variables ($primary/$accent/$au-dark-60/$au-bright-cyan/
+    # etc.) carry colors so a future theme swap rebinds centrally.
     DEFAULT_CSS = """
+    /* v0.6.1: kill Textual's default $primary-blue tinting on chrome —
+       Header sub-widgets (HeaderIcon, HeaderTitle, HeaderClock) each carry
+       their own $primary tint that the parent `Header { background }` rule
+       doesn't override; sub-selectors force the cool palette down. */
+    Header, HeaderIcon, HeaderTitle, HeaderClock {
+        background: $surface;
+        color: $au-bright-blue;
+    }
+    Footer {
+        background: $surface;
+    }
+    /* v0.6.1: scrollbars default to $primary-tint blue. Force Sea darks
+       on the scrollable widgets (RichLog instances). */
+    RichLog {
+        scrollbar-background: $background;
+        scrollbar-background-hover: $background;
+        scrollbar-background-active: $background;
+        scrollbar-color: $au-dark-50;
+        scrollbar-color-hover: $au-dark-60;
+        scrollbar-color-active: $au-bright-cyan;
+    }
     #main-row {
         height: 1fr;
     }
     #left-column {
         width: 2fr;
+        border-right: solid $panel;
     }
     #right-column {
         width: 1fr;
     }
-    #thinking-current {
-        dock: top;
-        height: auto;
-    }
+    /* v0.6.5: thinking-current Static removed; thinking now streams
+       directly into thinking-log so the whole pane scrolls naturally. */
     #transcript {
         height: 1fr;
+        background: $background;
+        padding: 0 1;
+    }
+    /* v0.6.0: streaming-text Static carries in-flight assistant tokens.
+       Replaces per-token RichLog spam — one growing line that updates in
+       place. Cleared on terminal event; final Markdown body lands in the
+       transcript. */
+    #current-text {
+        dock: bottom;
+        height: auto;
+        background: $background;
+        padding: 0 1;
+    }
+    #tools-log, #debug-log, #thinking-log {
+        background: $background;
+        padding: 0 1;
+    }
+    /* Tab strip + active-tab underline — kill blue, use Australis cyan. */
+    #side-panes > ContentTabs {
+        background: $surface;
+    }
+    #side-panes ContentTab.-active {
+        color: $au-bright-cyan;
+        text-style: bold;
+    }
+    #side-panes Underline > .underline--bar {
+        color: $au-bright-cyan;
     }
     #prompt {
         dock: bottom;
+        border: tall $panel;
+    }
+    /* v0.6.0: focused border uses Australis bright-cyan instead of $primary
+       (Aurora blue) — kills the lingering blue tint the user flagged. */
+    #prompt:focus {
+        border: tall $au-bright-cyan;
+    }
+    /* Placeholder text in the Input — dimmer than typed content. */
+    #prompt > .input--placeholder {
+        color: $au-dark-50;
     }
     #identity {
         dock: bottom;
         height: 1;
+        color: $au-bright-blue;
+        padding: 0 1;
     }
     #pane-name {
         dock: bottom;
         height: 1;
+        color: $au-bright-cyan;
+        padding: 0 1;
     }
     #hint {
         dock: bottom;
         height: 1;
+        color: $au-dark-60;
+        padding: 0 1;
     }
     """
 
     BINDINGS: ClassVar[list[Binding]] = [
         Binding("ctrl+c", "interrupt", "Cancel / Exit", priority=True),
         Binding("ctrl+d", "quit", "Exit immediately", priority=True),
-        # Issue #13: §5 keybinding family Ctrl+1..5 jumps between side panes
-        # without losing Input focus (INV-016). v1 only has Tools; Ctrl+2..5
-        # land as Persona/AdminEvents/BifrostState/ServerLog panes ship.
+        # §5 keybinding family Ctrl+1..5 jumps between side panes
+        # without losing Input focus (INV-016).
         Binding("ctrl+1", "focus_tools", "Tools tab", priority=False),
+        Binding("ctrl+2", "focus_debug", "Debug tab", priority=False),
+        Binding("ctrl+3", "focus_thinking", "Thinking tab", priority=False),
     ]
 
     HINT_IDLE = "Ctrl-C twice to exit"
@@ -378,21 +640,27 @@ class RatatoskrApp(App[int]):
         self.active_turn_id: int | None = None
         self.stream_worker = None
         self.hint: str = self.HINT_IDLE
+        self.register_theme(AUSTRALIS_THEME)
+        self.theme = "australis"
 
     def compose(self) -> ComposeResult:
         yield Header()
-        # Issue #13: Horizontal two-column layout. Left column = chat surface
-        # (thinking-current docked top, transcript fills middle, prompt docked
-        # bottom). Right column = TabbedContent for side panes (v1: Tools only).
-        # markup=False on RichLog so labeled lines like "[cancel_failed] ..."
-        # render verbatim; Rich would otherwise interpret bracket spans as
-        # style markup. The post-Done markdown render uses Markdown() directly
-        # which is a Rich Renderable and renders correctly without
-        # widget-level markup=True.
+        # v0.6.0 layout: left column is content-only (transcript + streaming
+        # text Static + prompt). Right column hosts thinking-current live
+        # preview above TabbedContent cycling Tools / Debug / Thinking.
+        #
+        # The current-text Static buffers in-flight assistant tokens so
+        # streaming doesn't spam the RichLog with one line per delta —
+        # the operator sees a single growing live line, then on Done the
+        # Static clears and the final Markdown body lands in the transcript.
+        #
+        # markup=False on RichLog so labeled lines render verbatim; the
+        # post-Done Markdown() / Rule() renders are Rich Renderables and
+        # work without widget-level markup=True.
         with Horizontal(id="main-row"):
             with Vertical(id="left-column"):
-                yield Static("", id="thinking-current")
                 yield RichLog(id="transcript", wrap=True, markup=False, highlight=False)
+                yield Static("", id="current-text")
                 yield Input(id="prompt", placeholder="Type a message and press Enter")
             with Vertical(id="right-column"):
                 with TabbedContent(id="side-panes"):
@@ -400,8 +668,22 @@ class RatatoskrApp(App[int]):
                         yield RichLog(
                             id="tools-log", wrap=True, markup=False, highlight=False
                         )
+                    with TabPane("Debug", id="debug-tab"):
+                        yield RichLog(
+                            id="debug-log", wrap=True, markup=False, highlight=False
+                        )
+                    with TabPane("Thinking", id="thinking-tab"):
+                        # v0.6.5: thinking streams directly into this
+                        # RichLog (no separate bottom Static). Each delta
+                        # writes a line; Rule(start)/Rule(end) mark run
+                        # boundaries. The whole pane scrolls naturally
+                        # as content arrives — no more "200-char tail
+                        # window scrolling at the bottom".
+                        yield RichLog(
+                            id="thinking-log", wrap=True, markup=False, highlight=False
+                        )
         # INV-002 + INV-003: visible identity + hint widgets (Footer-area).
-        # INV (issue #13): pane-name widget displays current side-pane name.
+        # pane-name widget displays current side-pane name.
         yield Static("", id="identity")
         yield Static("Tools", id="pane-name")
         yield Static(self.HINT_IDLE, id="hint")
@@ -418,11 +700,48 @@ class RatatoskrApp(App[int]):
         identity = f"{agent_slot} · …{self.session_id[-8:]}"
         self.sub_title = identity  # mirror to Header subtitle for redundancy
         self.query_one("#identity", Static).update(identity)
-        # Issue #12: thinking widget hidden until a thinking event fires.
-        self.query_one("#thinking-current", Static).display = False
+        # v0.5.1 polish: empty-state placeholder lines so the operator sees
+        # the pane is intentionally empty (not broken) before any turn fires.
+        # Wrapped in Australis dark-50 italic so they read distinctly as
+        # placeholder text, not real telemetry. Disappear naturally as the
+        # log fills with real events (the placeholders scroll off the top).
+        from rich.text import Text as RichText
+        placeholder_style = f"{_AU_DEMOTED_FAINT} italic"
+        self.query_one("#tools-log", RichLog).write(
+            RichText("(no tool events yet — start a turn that uses tools)",
+                     style=placeholder_style)
+        )
+        self.query_one("#debug-log", RichLog).write(
+            RichText("(waiting for worker_phase + text_boundary telemetry)",
+                     style=placeholder_style)
+        )
+        self.query_one("#thinking-log", RichLog).write(
+            RichText("(no chain-of-thought captured yet — start a turn)",
+                     style=placeholder_style)
+        )
         self.state = "idle"
         self._set_hint(self.HINT_IDLE)
 
+    def _write_turn_headers(self, turn_id: int) -> None:
+        """v0.6.0: Write `── turn N ──` Rule headers across every pane so
+        operators can visually correlate sections during cross-pane
+        debugging. Called from `_stream_turn_worker` on first event of
+        each new turn (idempotent per turn via active_turn_id guard).
+        """
+        from rich.rule import Rule
+
+        title = f"turn {turn_id}"
+        rule = Rule(title=title, style=_AU_DEMOTED)
+        try:
+            self.query_one("#transcript", RichLog).write(rule)
+            self.query_one("#tools-log", RichLog).write(rule)
+            self.query_one("#debug-log", RichLog).write(rule)
+            self.query_one("#thinking-log", RichLog).write(rule)
+        except Exception:
+            # Defensive: widget tree may be tearing down — never let a
+            # turn-header write block the SSE consumer.
+            pass
+
     def _set_hint(self, hint: str) -> None:
         """Set the hint state attribute AND update the visible Static widget."""
         self.hint = hint
@@ -444,7 +763,10 @@ class RatatoskrApp(App[int]):
         content = event.input.value.strip()
         if not content:
             return
-        log.write(f"❯ {content}")  # noqa: RUF001 — intentional INV-006 prefix
+        # v0.4.1 retheme: operator's voice gets Australis bright cyan so it
+        # stands out against the default-foreground assistant text below it.
+        from rich.text import Text as RichText
+        log.write(RichText(f"❯ {content}", style=_AU_USER_ECHO))  # noqa: RUF001
         event.input.value = ""
         self.state = "streaming"
         self._set_hint(self.HINT_STREAMING)
@@ -458,19 +780,26 @@ class RatatoskrApp(App[int]):
         assert self.client is not None
         assert content
         log = self.query_one("#transcript", RichLog)
-        thinking_widget = self.query_one("#thinking-current", Static)
-        # Issue #13: tools_log routes ToolStart/ToolResult into the Tools pane.
+        current_text = self.query_one("#current-text", Static)
         tools_log = self.query_one("#tools-log", RichLog)
+        debug_log = self.query_one("#debug-log", RichLog)
+        thinking_log = self.query_one("#thinking-log", RichLog)
         presenter = TuiPresenterState()
         try:
             async for event in stream_turn(self.client, self.session_id, content):
                 if self.active_turn_id is None:
                     self.active_turn_id = event.sse_id.turn_id
+                    # v0.6.0: turn-ID headers across all panes so the
+                    # operator can visually correlate sections during
+                    # cross-pane debugging.
+                    self._write_turn_headers(self.active_turn_id)
                 presenter.render(
                     event,
                     log=log,
-                    thinking_widget=thinking_widget,
+                    current_text=current_text,
                     tools_log=tools_log,
+                    debug_log=debug_log,
+                    thinking_log=thinking_log,
                     raw=self.args.raw,
                 )
                 if isinstance(event, (Done, Error, Cancelled)):
@@ -531,6 +860,17 @@ class RatatoskrApp(App[int]):
         — `test_ctrl_1_preserves_input_focus` is the regression guard.
         """
         self.query_one("#side-panes", TabbedContent).active = "tools-tab"
+        self.query_one("#pane-name", Static).update("Tools")
+
+    def action_focus_debug(self) -> None:
+        """v0.5.0: Ctrl+2 activates the Debug tab. INV-016 preserves Input focus."""
+        self.query_one("#side-panes", TabbedContent).active = "debug-tab"
+        self.query_one("#pane-name", Static).update("Debug")
+
+    def action_focus_thinking(self) -> None:
+        """v0.6.0: Ctrl+3 activates the Thinking tab. INV-016 preserves Input focus."""
+        self.query_one("#side-panes", TabbedContent).active = "thinking-tab"
+        self.query_one("#pane-name", Static).update("Thinking")
 
 
 def run_tui(args: ParsedArgs) -> int:

tests/test_tui.py

@@ -11,7 +11,6 @@ from ratatoskr.cli import ParsedArgs
 from ratatoskr.sse_client import (
     Cancelled,
     Done,
-    Error,
     SseId,
     Text,
     Thinking,
@@ -61,13 +60,18 @@ def _args_existing(session_id: str = "s-1existing", **overrides) -> ParsedArgs:
 
 
 def _spy_writes(monkeypatch) -> list:
-    """Patch RichLog.write to record every arg into a list (returned)."""
+    """Patch RichLog.write to record every arg into a list (returned).
+
+    Accepts *args/**kwargs so Textual's internal deferred-render path
+    (which calls write positionally with width/expand/shrink/scroll_end)
+    still works after a write-during-mount + Resize sequence.
+    """
     writes: list = []
     original = RichLog.write
 
-    def spy(self, content, **kw):
+    def spy(self, content, *args, **kw):
         writes.append(content)
-        return original(self, content, **kw)
+        return original(self, content, *args, **kw)
 
     monkeypatch.setattr(RichLog, "write", spy)
     return writes
@@ -111,204 +115,158 @@ SID = SseId(42, 5)
 class TestTuiPresenterState:
     """Tests for the new TuiPresenterState — per issue #12 contract."""
 
-    def test_thinking_coalesce_single_widget_update(self) -> None:
-        """thinking_coalesce_single_widget_update [happy,tracer]:
-        3 Thinking events → thinking_widget.update called 3 times with cumulative content;
-        RichLog has 0 thinking entries (closure hasn't fired yet).
+    def test_thinking_streams_into_thinking_log(self) -> None:
+        """thinking_streams_into_thinking_log [happy,tracer, v0.6.5]:
+        3 Thinking deltas → thinking_log gets Rule(start) + 3 delta lines.
+        Transcript untouched; no thinking-current Static involved.
         """
+        from rich.rule import Rule
+
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
+        thinking_log = MagicMock()
         state = TuiPresenterState()
-        state.render(
-            Thinking(sse_id=SID, content="a"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        state.render(
-            Thinking(sse_id=SID, content="b"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        state.render(
-            Thinking(sse_id=SID, content="c"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        # Widget updated 3 times — once per delta — with cumulative content
-        assert widget.update.call_count == 3
-        # Latest call shows the full accumulated content (under 200 chars so no truncation)
-        assert widget.update.call_args_list[-1][0][0] == "abc"
-        # Widget became visible at first delta
-        assert widget.display is True
-        # No RichLog write yet — closure hasn't fired
+        for chunk in ("a", "b", "c"):
+            state.render(
+                Thinking(sse_id=SID, content=chunk),
+                log=log,
+                tools_log=MagicMock(),
+                debug_log=MagicMock(),
+                current_text=MagicMock(),
+                thinking_log=thinking_log,
+                raw=False,
+            )
+        writes = [c[0][0] for c in thinking_log.write.call_args_list]
+        # 1 Rule(start) + 3 content lines = 4 writes
+        assert len(writes) == 4
+        assert isinstance(writes[0], Rule)
+        assert writes[1] == "a"
+        assert writes[2] == "b"
+        assert writes[3] == "c"
+        # Transcript untouched during thinking streaming.
         assert log.write.call_count == 0
 
-    def test_thinking_closes_one_richlog_entry(self) -> None:
-        """thinking_closes_one_richlog_entry [happy]: 2x Thinking + WorkerPhase →
-        RichLog has ONE closed thinking entry + one worker_phase entry; widget cleared+hidden.
+    def test_thinking_closes_to_thinking_log(self) -> None:
+        """thinking_closes_to_thinking_log [happy, v0.6.5]: 2x Thinking + WorkerPhase →
+        thinking_log gets Rule(start) + 2 delta lines + Rule(end); debug_log gets
+        the worker_phase line; transcript untouched.
         """
+        from rich.rule import Rule
+
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
+        debug_log = MagicMock()
+        thinking_log = MagicMock()
         state = TuiPresenterState()
-        state.render(
-            Thinking(sse_id=SID, content="a"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        state.render(
-            Thinking(sse_id=SID, content="b"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
+        for content in ("a", "b"):
+            state.render(
+                Thinking(sse_id=SID, content=content),
+                log=log,
+                tools_log=MagicMock(),
+                debug_log=debug_log,
+                current_text=MagicMock(),
+                thinking_log=thinking_log,
+                raw=False,
+            )
         state.render(
             WorkerPhase(sse_id=SID, phase="streaming", turn_id=42),
             log=log,
-            thinking_widget=widget,
             tools_log=MagicMock(),
+            debug_log=debug_log,
+            current_text=MagicMock(),
+            thinking_log=thinking_log,
             raw=False,
         )
-        # Closure wrote "· thinking: ab"; then worker_phase wrote "· worker_phase: ..."
-        assert log.write.call_count == 2
-        # First write = closed thinking entry containing the full accumulated text
-        assert "· thinking: ab" in log.write.call_args_list[0][0][0]
-        # Second write = worker_phase with demotion prefix
-        assert "· worker_phase:" in log.write.call_args_list[1][0][0]
-        # Widget cleared + hidden
-        widget.update.assert_called_with("")
-        assert widget.display is False
+        thinking_writes = [c[0][0] for c in thinking_log.write.call_args_list]
+        # 1 Rule(start) + 2 delta lines + 1 Rule(end) = 4 writes
+        assert len(thinking_writes) == 4
+        assert isinstance(thinking_writes[0], Rule)
+        assert thinking_writes[1] == "a"
+        assert thinking_writes[2] == "b"
+        assert isinstance(thinking_writes[3], Rule)
+        # worker_phase still goes to debug_log; transcript untouched.
+        assert "· worker_phase:" in _text_of(debug_log.write.call_args_list[-1][0][0])
+        assert not log.write.called
 
-    def test_thinking_widget_truncation(self) -> None:
-        """thinking_widget_truncation [trace]: buffer 500 chars → widget shows "…" + last 200."""
-        from ratatoskr.tui import TuiPresenterState
+    # v0.6.5: thinking-current Static removed; test_thinking_widget_truncation
+    # and test_thinking_widget_visibility_lifecycle deleted (no longer apply).
 
-        log = MagicMock()
-        widget = MagicMock()
-        state = TuiPresenterState()
-        # Push 500 chars across multiple deltas.
-        long = "x" * 500
-        state.render(
-            Thinking(sse_id=SID, content=long),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        last_update = widget.update.call_args_list[-1][0][0]
-        # …-prefix + last-200 = 201 chars
-        assert last_update.startswith("…")
-        assert len(last_update) == 201
-
-    def test_thinking_widget_visibility_lifecycle(self) -> None:
-        """thinking_widget_visibility_lifecycle [trace]: hidden at start; visible during thinking;
-        hidden after closing event.
+    def test_multiple_thinking_runs_each_get_thinking_log_section(self) -> None:
+        """multiple_thinking_runs_each_get_section [scenario, v0.6.5]:
+        Thinking → Text → Thinking → Done → TWO start/end Rule pairs in
+        thinking_log, each wrapping their delta lines. Text goes to
+        current_text (buffered). Transcript: [done] + Markdown body.
         """
+        from rich.rule import Rule
+
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
-        widget.display = False  # initial state (composed hidden)
+        thinking_log = MagicMock()
+        current_text = MagicMock()
         state = TuiPresenterState()
-        # First thinking delta → widget visible
-        state.render(
-            Thinking(sse_id=SID, content="x"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        assert widget.display is True
-        # Closure (WorkerPhase) → widget hidden
-        state.render(
-            WorkerPhase(sse_id=SID, phase="streaming", turn_id=42),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        assert widget.display is False
-
-    def test_multiple_thinking_runs_each_get_richlog_entry(self) -> None:
-        """multiple_thinking_runs_each_get_richlog_entry [scenario]:
-        Thinking → Text → Thinking → Done → TWO closed thinking RichLog entries.
-        """
-        from ratatoskr.tui import TuiPresenterState
-
-        log = MagicMock()
-        widget = MagicMock()
-        state = TuiPresenterState()
-        state.render(
+        for evt in (
             Thinking(sse_id=SID, content="first"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        state.render(
             Text(sse_id=SID, content="hi"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        state.render(
             Thinking(sse_id=SID, content="second"),
-            log=log,
-            thinking_widget=widget,
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        # Close the second run with a Done.
+        ):
+            state.render(
+                evt, log=log,
+                tools_log=MagicMock(), debug_log=MagicMock(),
+                current_text=current_text, thinking_log=thinking_log, raw=False,
+            )
         state.render(
-            _make_tui_done(), log=log, thinking_widget=widget, tools_log=MagicMock(), raw=True
+            _make_tui_done(),
+            log=log,
+            tools_log=MagicMock(), debug_log=MagicMock(),
+            current_text=current_text, thinking_log=thinking_log, raw=False,
         )
-        # Count closed thinking entries — now dim RichText; plain text starts with "· thinking:".
-        thinking_entries = [_text_of(call[0][0]) for call in log.write.call_args_list]
-        thinking_entries = [t for t in thinking_entries if t.startswith("· thinking:")]
-        assert len(thinking_entries) == 2
-        assert "first" in thinking_entries[0]
-        assert "second" in thinking_entries[1]
+        # v0.6.5: thinking_log holds 4 Rules (start + end per run) + 2 delta lines.
+        thinking_writes = [c[0][0] for c in thinking_log.write.call_args_list]
+        rules = [w for w in thinking_writes if isinstance(w, Rule)]
+        delta_strs = [w for w in thinking_writes if isinstance(w, str)]
+        assert len(rules) == 4, f"expected 4 Rules (2 start + 2 end), got {len(rules)}"
+        assert "first" in delta_strs
+        assert "second" in delta_strs
+        # Text "hi" went to current_text (buffered), not the transcript directly.
+        current_text.update.assert_any_call("hi")
+        # Transcript: [done] label + Markdown(response) (raw=False).
+        log_writes = [_text_of(c[0][0]) for c in log.write.call_args_list]
+        assert any(w.startswith("[done]") for w in log_writes if isinstance(w, str))
 
     def test_render_exception_fallback(self) -> None:
-        """render_exception_fallback [adversarial]:
-        widget.update raises → RichLog gets BOTH a plain-labeled fallback line for
-        the original event AND a `[render_error] <ExceptionClassName>` line
-        (NO exception message per INV-009 security clause); state does NOT propagate.
+        """render_exception_fallback [adversarial, v0.6.5]:
+        thinking_log.write raises → catch in presenter, write plain-label
+        fallback + render_error line via INV-009 fallback path (routing
+        preservation: thinking events still route to thinking_log).
         """
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
-        widget.update.side_effect = AttributeError("widget gone (msg should NOT leak)")
+        thinking_log = MagicMock()
+        # First call (Rule write) raises; subsequent calls succeed for fallback.
+        thinking_log.write.side_effect = [
+            AttributeError("rule write failed (msg should NOT leak)"),
+            None,
+            None,
+        ]
         state = TuiPresenterState()
-        # Should not raise; should write a fallback labeled line + a [render_error] line.
         state.render(
             Thinking(sse_id=SID, content="x"),
             log=log,
-            thinking_widget=widget,
             tools_log=MagicMock(),
+            debug_log=MagicMock(),
+            current_text=MagicMock(),
+            thinking_log=thinking_log,
             raw=False,
         )
-        writes = [call[0][0] for call in log.write.call_args_list if isinstance(call[0][0], str)]
-        # POST-007: plain-label fallback for the original Thinking event (pre-amendment shape).
+        writes = [c[0][0] for c in thinking_log.write.call_args_list if isinstance(c[0][0], str)]
         assert any(w.startswith("[thinking]") for w in writes), writes
-        # POST-007: render_error line with class name ONLY.
         assert any(w == "[render_error] AttributeError" for w in writes), writes
-        # Critical: exception message MUST NOT appear in any write (INV-009 security).
-        assert not any("widget gone" in w for w in writes), writes
+        assert not any("rule write failed" in w for w in writes), writes
+        assert not log.write.called
 
     def test_state_reset_per_worker(self) -> None:
         """state_reset_per_worker [trace]: fresh TuiPresenterState() starts no thinking open."""
@@ -318,8 +276,10 @@ class TestTuiPresenterState:
         s1.render(
             Thinking(sse_id=SID, content="x"),
             log=MagicMock(),
-            thinking_widget=MagicMock(),
             tools_log=MagicMock(),
+            debug_log=MagicMock(),
+            current_text=MagicMock(),
+            thinking_log=MagicMock(),
             raw=False,
         )
         s2 = TuiPresenterState()
@@ -327,39 +287,42 @@ class TestTuiPresenterState:
         assert s2.thinking_open is False
 
     def test_cancelled_mid_thinking_closes(self) -> None:
-        """cancelled_mid_thinking_closes [scenario]:
-        Thinking, Cancelled → ONE closed thinking entry + a [cancelled] entry; widget hidden.
+        """cancelled_mid_thinking_closes [scenario, v0.5.0]:
+        Thinking, Cancelled → ONE closed thinking entry in debug_log + a
+        [cancelled] entry in transcript; widget hidden.
         """
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
+        thinking_log = MagicMock()
         state = TuiPresenterState()
         state.render(
             Thinking(sse_id=SID, content="partial"),
             log=log,
-            thinking_widget=widget,
             tools_log=MagicMock(),
-            raw=False,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=thinking_log, raw=False,
         )
         state.render(
             Cancelled(
                 sse_id=SID, phase="cancelled", turn_id=42, reason="user", partial_message_id=None
             ),
             log=log,
-            thinking_widget=widget,
             tools_log=MagicMock(),
-            raw=False,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=thinking_log, raw=False,
         )
-        # Closed thinking entries are now dim RichText; terminal labels are plain str.
-        writes = [_text_of(c[0][0]) for c in log.write.call_args_list]
-        assert any(w.startswith("· thinking: partial") for w in writes)
-        assert any(w.startswith("[cancelled]") for w in writes)
-        assert widget.display is False
+        # v0.6.5: streamed thinking + Rule(end) in thinking_log; [cancelled] in transcript.
+        log_writes = [_text_of(c[0][0]) for c in log.write.call_args_list]
+        assert any(w.startswith("[cancelled]") for w in log_writes)
+        # thinking_log got at least Rule(start) + "partial" delta + Rule(end)
+        assert thinking_log.write.call_count >= 3
 
     def test_done_renders_markdown_after_label(self) -> None:
-        """done_renders_markdown_after_label [happy]:
-        Text("hi"), Done(response="hi") with raw=False → [done] label, Rule, Markdown in RichLog.
+        """done_renders_markdown_after_label [happy, v0.6.0]:
+        Text("hi") accumulates into current_text Static (buffered streaming);
+        Done(response="hi") with raw=False → [done] label + Rule + Markdown
+        in transcript. current_text cleared on terminal.
         """
         from rich.markdown import Markdown
         from rich.rule import Rule
@@ -367,24 +330,32 @@ class TestTuiPresenterState:
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
+        current_text = MagicMock()
         state = TuiPresenterState()
         state.render(
             Text(sse_id=SID, content="hi"),
             log=log,
-            thinking_widget=widget,
             tools_log=MagicMock(),
+            debug_log=MagicMock(),
+            current_text=current_text,
+            thinking_log=MagicMock(),
             raw=False,
         )
+        # Text accumulated to current_text, NOT written to log.
+        current_text.update.assert_any_call("hi")
         state.render(
-            _make_tui_done(), log=log, thinking_widget=widget, tools_log=MagicMock(), raw=False
+            _make_tui_done(),
+            log=log,
+            tools_log=MagicMock(),
+            debug_log=MagicMock(),
+            current_text=current_text,
+            thinking_log=MagicMock(),
+            raw=False,
         )
+        # Done cleared current_text and wrote [done] label + Rule + Markdown.
+        current_text.update.assert_any_call("")
         writes = [c[0][0] for c in log.write.call_args_list]
-        # Text stream wrote "hi" with no prefix.
-        assert "hi" in writes
-        # [done] label wrote.
-        assert any(isinstance(w, str) and w.startswith("[done]") for w in writes)
-        # Rule + Markdown render present (post-Done body re-render per issue #4 INV-005).
+        assert any(_text_of(w).startswith("[done]") for w in writes)
         assert any(isinstance(w, Rule) for w in writes)
         assert any(isinstance(w, Markdown) for w in writes)
 
@@ -396,70 +367,60 @@ class TestTuiPresenterState:
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
-        widget = MagicMock()
         state = TuiPresenterState()
         state.render(
             Text(sse_id=SID, content="hi"),
             log=log,
-            thinking_widget=widget,
             tools_log=MagicMock(),
-            raw=True,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=True,
         )
         state.render(
-            _make_tui_done(), log=log, thinking_widget=widget, tools_log=MagicMock(), raw=True
+            _make_tui_done(),
+            log=log,
+            tools_log=MagicMock(),
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=True,
         )
         writes = [c[0][0] for c in log.write.call_args_list]
         assert not any(isinstance(w, Rule) for w in writes)
         assert not any(isinstance(w, Markdown) for w in writes)
 
-    def test_worker_phase_demoted(self) -> None:
-        """worker_phase_demoted [trace]: WorkerPhase → RichLog "· worker_phase:" prefix
-        rendered with dim Rich style (INV-003: dim style + `· ` prefix in TUI).
+    def test_worker_phase_demoted_to_debug_log(self) -> None:
+        """worker_phase_demoted_to_debug_log [trace, v0.5.0]: WorkerPhase → debug_log
+        "· worker_phase:" prefix rendered with Australis dark-60 Rich style.
+        Transcript receives nothing.
         """
         from rich.text import Text as RichText
 
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
+        debug_log = MagicMock()
         state = TuiPresenterState()
         state.render(
             WorkerPhase(sse_id=SID, phase="streaming", turn_id=42),
             log=log,
-            thinking_widget=MagicMock(),
             tools_log=MagicMock(),
-            raw=False,
+            debug_log=debug_log,
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=False,
         )
-        renderable = log.write.call_args[0][0]
-        # INV-003: must be a dim-styled Rich Text renderable, not a plain str.
+        # v0.5.0: WorkerPhase routes to debug_log, NOT transcript.
+        assert not log.write.called
+        renderable = debug_log.write.call_args[0][0]
+        # INV-003: must be a styled Rich Text renderable, not a plain str.
+        # v0.4.1 retheme: style is now Australis Sea dark-60 ("#86929d") instead
+        # of the terminal-dim filter "dim". Assert non-empty styling either way.
         assert isinstance(renderable, RichText), type(renderable)
-        assert renderable.style == "dim"
+        assert renderable.style, "demoted telemetry must carry SOME style"
         text = renderable.plain
         assert text.startswith("· worker_phase:")
         assert "[worker_phase]" not in text
 
-    def test_terminal_events_belt_and_braces_widget_cleanup(self) -> None:
-        """terminal_events_belt_and_braces_widget_cleanup [trace]:
-        Done / Error / Cancelled MUST clear+hide the thinking widget even when
-        thinking_open is False (Volva F3 fix; POST-005 + STEPS 5-6).
-        """
-        from ratatoskr.tui import TuiPresenterState
-
-        for terminal in (
-            _make_tui_done(),
-            Error(sse_id=SID, phase="failed", message="boom", error_code="x"),
-            Cancelled(
-                sse_id=SID, phase="cancelled", turn_id=42, reason="r", partial_message_id=None
-            ),
-        ):
-            log = MagicMock()
-            widget = MagicMock()
-            widget.display = True  # pre-set to non-default to detect the clear
-            state = TuiPresenterState()
-            # thinking_open is False (state just constructed).
-            state.render(terminal, log=log, thinking_widget=widget, tools_log=MagicMock(), raw=True)
-            # Belt-and-braces: widget cleared + hidden on EVERY terminal event.
-            widget.update.assert_called_with("")
-            assert widget.display is False, type(terminal).__name__
+    # v0.6.5: test_terminal_events_belt_and_braces_widget_cleanup deleted.
+    # The thinking-current Static is gone, so there's no widget to clean up
+    # on terminal events. The corresponding Volva F3 invariant is obsoleted
+    # by the streaming-into-thinking_log architecture.
 
     def test_tool_start_routes_to_tools_log(self) -> None:
         """tool_start_routes_to_tools_log [INV-014]: ToolStart writes to tools_log, NOT transcript.
@@ -476,9 +437,9 @@ class TestTuiPresenterState:
         state.render(
             ToolStart(sse_id=SID, name="read_file", arguments={"path": "/x"}),
             log=log,
-            thinking_widget=MagicMock(),
             tools_log=tools_log,
-            raw=False,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=False,
         )
         # INV-014: write went to tools_log
         assert tools_log.write.called
@@ -496,49 +457,57 @@ class TestTuiPresenterState:
         state.render(
             ToolResult(sse_id=SID, name="read_file", result="ok", duration_ms=12),
             log=log,
-            thinking_widget=MagicMock(),
             tools_log=tools_log,
-            raw=False,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=False,
         )
         assert tools_log.write.called
         assert _text_of(tools_log.write.call_args[0][0]).startswith("· tool_result:")
         assert not log.write.called
 
-    def test_text_event_does_not_route_to_tools_log(self) -> None:
-        """text_event_does_not_route_to_tools_log [INV-015]: Text → transcript, NOT tools_log."""
+    def test_text_event_buffers_into_current_text(self) -> None:
+        """text_event_buffers_into_current_text [v0.6.0]: Text → current_text Static
+        (accumulated), NOT log or tools_log. Streaming UX fix — no per-token spam.
+        """
         from ratatoskr.tui import TuiPresenterState
 
         log = MagicMock()
         tools_log = MagicMock()
+        current_text = MagicMock()
         state = TuiPresenterState()
         state.render(
             Text(sse_id=SID, content="hello"),
             log=log,
-            thinking_widget=MagicMock(),
             tools_log=tools_log,
+            debug_log=MagicMock(),
+            current_text=current_text,
+            thinking_log=MagicMock(),
             raw=False,
         )
-        assert log.write.called
-        assert log.write.call_args[0][0] == "hello"
-        # INV-015: tools_log was NOT written to
+        current_text.update.assert_called_once_with("hello")
+        assert not log.write.called
         assert not tools_log.write.called
 
-    def test_text_no_prefix(self) -> None:
-        """text_no_prefix [trace]: Text → RichLog line has no `·` prefix, no demotion."""
+    def test_text_deltas_accumulate(self) -> None:
+        """text_deltas_accumulate [v0.6.0]: multiple Text deltas → current_text shows
+        concatenated content, NOT separate per-delta lines.
+        """
         from ratatoskr.tui import TuiPresenterState
 
-        log = MagicMock()
+        current_text = MagicMock()
         state = TuiPresenterState()
-        state.render(
-            Text(sse_id=SID, content="hello"),
-            log=log,
-            thinking_widget=MagicMock(),
-            tools_log=MagicMock(),
-            raw=False,
-        )
-        line = log.write.call_args[0][0]
-        # Pure content, no demotion prefix.
-        assert line == "hello"
+        for tok in ("Hel", "lo", " ", "world"):
+            state.render(
+                Text(sse_id=SID, content=tok),
+                log=MagicMock(),
+                tools_log=MagicMock(),
+                debug_log=MagicMock(),
+                current_text=current_text,
+                thinking_log=MagicMock(),
+                raw=False,
+            )
+        # Final update reflects the full concatenation.
+        assert current_text.update.call_args_list[-1][0][0] == "Hello world"
 
     def test_duration_format_seconds(self) -> None:
         """duration_format_seconds [trace]: Done(duration_ms=5467) → label has "duration=5.5s"."""
@@ -549,14 +518,14 @@ class TestTuiPresenterState:
         state.render(
             _make_tui_done(duration_ms=5467),
             log=log,
-            thinking_widget=MagicMock(),
             tools_log=MagicMock(),
-            raw=True,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=True,
         )
         done_line = next(
-            c[0][0]
+            _text_of(c[0][0])
             for c in log.write.call_args_list
-            if isinstance(c[0][0], str) and c[0][0].startswith("[done]")
+            if _text_of(c[0][0]).startswith("[done]")
         )
         assert "duration=5.5s" in done_line
         assert "duration_ms=5467" not in done_line
@@ -576,14 +545,14 @@ class TestTuiPresenterState:
         state.render(
             _make_tui_done(usage=usage),
             log=log,
-            thinking_widget=MagicMock(),
             tools_log=MagicMock(),
-            raw=True,
+            debug_log=MagicMock(),
+            current_text=MagicMock(), thinking_log=MagicMock(), raw=True,
         )
         done_line = next(
-            c[0][0]
+            _text_of(c[0][0])
             for c in log.write.call_args_list
-            if isinstance(c[0][0], str) and c[0][0].startswith("[done]")
+            if _text_of(c[0][0]).startswith("[done]")
         )
         assert "usage 6756 in → 126 out (6882 total, 0 cached)" in done_line
 
@@ -736,23 +705,29 @@ class TestLayoutShape:
             row = app.query_one("#main-row", Horizontal)
             assert row is not None
 
-    async def test_left_column_has_transcript_and_prompt(self) -> None:
-        """left_column_has_transcript_and_prompt: left column = transcript + prompt + thinking."""
+    async def test_left_column_content_only(self) -> None:
+        """left_column_content_only [v0.6.5]: left column = transcript + prompt
+        + current-text (streaming text Static). thinking-current Static
+        removed entirely as of v0.6.5.
+        """
         from textual.containers import Vertical
-        from textual.widgets import Input, RichLog, Static
+        from textual.widgets import Input, RichLog
 
         app = _resolved_app(_args_new(), session_id="s-new12345", agent_id="mimir")
         async with app.run_test() as pilot:
             await pilot.pause()
             left = app.query_one("#left-column", Vertical)
-            assert left is not None
             transcript = app.query_one("#transcript", RichLog)
             prompt = app.query_one("#prompt", Input)
-            thinking = app.query_one("#thinking-current", Static)
-            # Widgets are inside the left column (descendant check)
             assert transcript in left.walk_children()
             assert prompt in left.walk_children()
-            assert thinking in left.walk_children()
+            # v0.6.5: thinking-current Static removed; no longer in DOM at all.
+            from textual.css.query import NoMatches
+            try:
+                app.query_one("#thinking-current")
+                raise AssertionError("thinking-current should not exist in v0.6.5")
+            except NoMatches:
+                pass  # expected
 
     async def test_right_column_has_tabbed_content_with_tools_tab(self) -> None:
         """right_column_has_tabbed_content_with_tools_tab: #side-panes + TabPane#tools-tab."""
@@ -817,6 +792,99 @@ class TestLayoutShape:
                 f"INV-016: Input focus must survive Ctrl+1 tab switch; got focused={app.focused}"
             )
 
+    async def test_debug_tab_exists(self) -> None:
+        """debug_tab_exists [v0.5.0]: right column has Debug TabPane + #debug-log RichLog."""
+        from textual.widgets import RichLog, TabPane
+
+        app = _resolved_app(_args_new(), session_id="s-new12345", agent_id="mimir")
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            debug_tab = app.query_one("#debug-tab", TabPane)
+            debug_log = app.query_one("#debug-log", RichLog)
+            assert debug_log in debug_tab.walk_children()
+
+    async def test_ctrl_2_activates_debug_tab(self) -> None:
+        """ctrl_2_activates_debug_tab [v0.5.0]: Ctrl+2 → TabbedContent.active == 'debug-tab'."""
+        from textual.widgets import TabbedContent
+
+        app = _resolved_app(_args_new(), session_id="s-new12345", agent_id="mimir")
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await pilot.press("ctrl+2")
+            await pilot.pause()
+            assert app.query_one("#side-panes", TabbedContent).active == "debug-tab"
+
+    async def test_done_label_styled_success(self) -> None:
+        """done_label_styled_success [v0.5.1]: [done] label renders in Aurora green."""
+        from rich.text import Text as RichText
+        from textual.widgets import RichLog
+
+        app = _resolved_app(_args_new(), session_id="s-new12345", agent_id="mimir")
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            # Probe the presenter directly — write a Done via state.render.
+            from ratatoskr.tui import TuiPresenterState
+            log = app.query_one("#transcript", RichLog)
+            state = TuiPresenterState()
+            seen: list = []
+            orig = log.write
+            log.write = lambda c, *a, **kw: (seen.append(c), orig(c, *a, **kw))[1]
+            state.render(
+                _make_tui_done(),
+                log=log,
+                tools_log=app.query_one("#tools-log", RichLog),
+                debug_log=app.query_one("#debug-log", RichLog),
+                current_text=MagicMock(), thinking_log=MagicMock(), raw=True,
+            )
+            done = next(
+                c for c in seen
+                if isinstance(c, RichText) and _text_of(c).startswith("[done]")
+            )
+            assert done.style == "#16B866"  # Aurora green
+
+    async def test_empty_state_placeholders_present(self) -> None:
+        """empty_state_placeholders_present [v0.5.1]: tools-log + debug-log show
+        placeholder lines before any turn fires."""
+        from textual.widgets import RichLog
+
+        app = _resolved_app(_args_new(), session_id="s-new12345", agent_id="mimir")
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            # Activate Debug tab so its content actually renders.
+            from textual.widgets import TabbedContent
+            tabbed = app.query_one("#side-panes", TabbedContent)
+            tabbed.active = "debug-tab"
+            await pilot.pause()
+            tabbed.active = "tools-tab"
+            await pilot.pause()
+            tools_log = app.query_one("#tools-log", RichLog)
+            debug_log = app.query_one("#debug-log", RichLog)
+            tools_text = " ".join(str(line) for line in tools_log.lines)
+            tabbed.active = "debug-tab"
+            await pilot.pause()
+            debug_text = " ".join(str(line) for line in debug_log.lines)
+            assert "no tool events" in tools_text
+            assert "worker_phase" in debug_text
+
+    async def test_pane_name_updates_on_tab_switch(self) -> None:
+        """pane_name_updates_on_tab_switch [v0.5.0]: pane-name reflects active tab.
+
+        Two tabs now (Tools / Debug); pane-name updates from "Tools" to "Debug"
+        and back as the operator switches via Ctrl+1 / Ctrl+2.
+        """
+        from textual.widgets import Static
+
+        app = _resolved_app(_args_new(), session_id="s-new12345", agent_id="mimir")
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            pane_name = app.query_one("#pane-name", Static)
+            await pilot.press("ctrl+2")
+            await pilot.pause()
+            assert str(pane_name.render()) == "Debug"
+            await pilot.press("ctrl+1")
+            await pilot.pause()
+            assert str(pane_name.render()) == "Tools"
+
 
 import asyncio  # noqa: E402
 
@@ -984,7 +1052,10 @@ async def _submit_and_wait(app: RatatoskrApp, pilot, content: str) -> None:
 class TestStreamTurnWorker:
     @respx.mock
     async def test_happy_text_done_renders_markdown(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """happy_text_done_renders_markdown [happy,tracer]: …"""
+        """happy_text_done_renders_markdown [happy,tracer, v0.6.0]:
+        Text deltas go to current_text (not transcript); on Done, transcript
+        gets turn-header Rule, [done] label, post-Done Rule + Markdown body.
+        """
         stream = _sse_chunk("42:1", {"type": "text", "content": "hello"}) + _sse_chunk(
             "42:2", _DONE_BODY
         )
@@ -999,20 +1070,25 @@ class TestStreamTurnWorker:
             await pilot.pause()
             await _submit_and_wait(app, pilot, "hi")
             assert app.state == "idle"
-            # Streamed delta + done label + rule + markdown render
-            assert any(w == "hello" for w in writes)
-            assert any("[done]" in str(w) for w in writes)
-            # The post-Done markdown render uses rich Rule + Markdown — non-string writes.
-            # INV-005: BOTH separator (Rule) AND markdown render must be present in non-raw.
+            # v0.6.0: Text("hello") goes to current_text Static, NOT log.
+            # writes spy captures RichLog.write only, so "hello" SHOULD NOT appear.
             from rich.markdown import Markdown
             from rich.rule import Rule
 
+            assert not any(w == "hello" for w in writes)
+            assert any("[done]" in str(w) for w in writes)
+            # Post-Done: Markdown body + Rule + turn-header Rule all present.
             assert any(isinstance(w, Markdown) for w in writes)
             assert any(isinstance(w, Rule) for w in writes)
 
     @respx.mock
     async def test_raw_flag_skips_markdown_render(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """raw_flag_skips_markdown_render [trace]: …"""
+        """raw_flag_skips_markdown_render [trace, v0.6.0]:
+        With --raw, no Markdown render. A turn-header Rule IS still written
+        (v0.6.0 INV — turn correlation lives in every pane). The post-Done
+        Rule(separator) is suppressed; accumulated streamed text is written
+        as a plain string instead.
+        """
         stream = _sse_chunk("42:1", {"type": "text", "content": "hi"}) + _sse_chunk(
             "42:2", _DONE_BODY
         )
@@ -1024,12 +1100,17 @@ class TestStreamTurnWorker:
         async with app.run_test() as pilot:
             await pilot.pause()
             await _submit_and_wait(app, pilot, "x")
-            # INV-005: with --raw, NEITHER Rule separator NOR Markdown render appears.
             from rich.markdown import Markdown
             from rich.rule import Rule
 
+            # No Markdown in raw mode.
             assert not any(isinstance(w, Markdown) for w in writes)
-            assert not any(isinstance(w, Rule) for w in writes)
+            # Only turn-header Rules — one per pane (transcript + tools +
+            # debug + thinking = 4). No post-Done separator Rule.
+            rules = [w for w in writes if isinstance(w, Rule)]
+            assert len(rules) == 4, f"expected 4 turn-header Rules, got {len(rules)}"
+            # Accumulated text "hi" written as plain string post-Done.
+            assert "hi" in writes
 
     @respx.mock
     async def test_error_terminal_returns_to_idle(self, monkeypatch: pytest.MonkeyPatch) -> None:

uv.lock

@@ -968,7 +968,7 @@ wheels = [
 
 [[package]]
 name = "ratatoskr"
-version = "0.4.0"
+version = "0.6.5"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },