terminal ⇄ conversation: one switch, in the bottom bar, and a better answer rule

**The switch moved and became app-wide.** It sits with zoom, because it is the
same kind of setting — how you are reading everything, not what one pane is.
Per-pane toggling was a preference nobody wanted to manage. A pane with nothing
to render (a shell) stays a terminal whatever the switch says.

**"RENDER" is gone as a name.** It described the implementation, not what you
get. The two states are `terminal` and `conversation`: one is the TTY, the other
is what was said in it. Renamed through the code, the CSS and the doc.

**The answer is the trailing RUN of messages, not the last `final`.** Seen in a
real session: asked for news, the agent searched, answered, and then a
notification arrived that it replied to with "No response requested." — which
the harness marked `final`. The card showed the boilerplate as the answer and
buried the news in the work. Everything the agent said after its last action is
the answer now; a `final` followed by more tool calls still stands, where it is.
`Exchange.answer` is a `TraceTurn[]`. Covered by the case in the test file.

Also: an exchange with nothing to say — a prompt that got no reply at all —
renders no meta row rather than an empty one.

docs/conversation-view.md

@@ -60,7 +60,7 @@ Four depths of one component:
 | **D0** brief | Overview tile | prompt (1 line) + state |
 | **D1** card | Overview card, collapsed | prompt, one meta line, answer, reply box |
 | **D2** open | Overview card, unfolded | + the steps between prompt and answer; `↑ show previous turn` walks back one exchange at a time |
-| **D3** full | Session pane, RENDER mode | every exchange, windowed, each expandable to D2 |
+| **D3** full | Session pane, conversation mode | every exchange, windowed, each expandable to D2 |
 
 The viewer stops being a different thing and becomes **a vertical stack of the card**. That is
 the whole design; the rest is consequences.
@@ -150,7 +150,7 @@ Rules that keep this from becoming the ugly viewer in a small box:
 - **Only the card you opened reads the trace.** Inline in the Overview list a card is a
   summary — one prompt, one clamped answer — and the digest already has that. Reading the trace
   per visible agent, and polling it every three seconds for the working ones, would turn the
-  Overview from one `/api/meta` poll into one transcript read per row. The window (and RENDER)
+  Overview from one `/api/meta` poll into one transcript read per row. The window (and conversation mode)
   is where the middle gets fetched.
 - **A card says nothing the surface around it already says.** No turn number (there is one turn),
   no clock (its header carries `·6m`), no model, no harness. In the viewer the same line's right
@@ -163,7 +163,7 @@ exchange per click**, never by "load everything":
 - A centred `↑ show previous turn` at the top of the body prepends the previous exchange,
   collapsed to prompt + answer (its steps fold behind the same `▸ n steps`). Centred, because it
   belongs to the whole card rather than to the column of text under it.
-- After the second one, `full history ↗` joins it, opening the pane in RENDER mode at that
+- After the second one, `full history ↗` joins it, opening the pane in conversation mode at that
   exchange. The card is for "what just happened"; archaeology has a bigger room, and the handoff
   is one click.
 - Cap the card at, say, 5 exchanges regardless — past that the card is the wrong tool and says so.
@@ -183,26 +183,29 @@ was a workaround for not having the middle; with the middle visible it has nothi
 `--vvh` is already maintained from `window.visualViewport` (`App.tsx:106-114`); the backdrop
 must use it, or an open keyboard covers the reply line it is there to serve.
 
-### 3.3 The session pane: TUI ⇄ RENDER
+### 3.3 The session pane: terminal ⇄ conversation
 
-The pane header gets a two-state segmented control, next to the title:
+The bottom bar gets a two-state control, next to the zoom:
 
 ```
-● claude  agent-manager           [ TUI | RENDER ]   ⇪ share   ✕
+                                        [ terminal | conversation ]   − 100% +
 ```
 
-- **Only an agent gets the switch.** A shell has no conversation to render, and the files/trace
-  panels are not sessions at all — same rule the Overview uses to decide what is an agent
-  (`cli !== 'shell' && !isPassive(cli)`).
-- **TUI** — today's terminal, untouched.
-- **RENDER** — the same session as a conversation: `TraceView` (already extracted upstream,
-  `TracePane.tsx:TraceView`, takes a `src` loader) over `/api/trace/:id`, at D3.
-- The mode is a **view preference**, kept in `localStorage` per session id, not in the store.
-- The terminal element stays mounted and connected underneath; RENDER draws over it. Toggling
+**It is one setting for the whole app, like zoom** — not a per-pane toggle. Reading a fleet means
+reading it the same way, and a per-session switch was a preference nobody wanted to manage. A
+pane with nothing to render (a shell) simply stays a terminal.
+
+- **Only an agent has a conversation.** A shell stays a terminal whatever the switch says, and
+  the files/trace panels are not sessions at all — same rule the Overview uses to decide what is
+  an agent (`cli !== 'shell' && !isPassive(cli)`).
+- **terminal** — today's terminal, untouched.
+- **conversation** — the same session, read: the exchange renderer over `/api/trace/:id`, at D3.
+- The mode is a **view preference**, kept in `localStorage` for the app, not in the store.
+- The terminal element stays mounted and connected underneath; the conversation draws over it. Toggling
   must not detach tmux — a reattach costs a repaint and can trip the handoff path
   (`HANDOFF_CODE`, `TerminalPane.tsx`). **Verify** this before shipping: xterm needs layout to
   fit, so "cover, don't unmount" is the low-risk option, and a refit on return is required.
-- The RENDER toolbar is a second header row, not a squeeze into the first — on a phone the
+- The conversation's toolbar is a second header row, not a squeeze into the first — on a phone the
   first row has no spare width. It carries only what is true of the whole session and said
   nowhere else: the model, `13 turns`, the token totals abbreviated (`2.2M↓ 654k↑`), `▲▼`, and
   the search box. The harness is the logo in the row above; the raw message count and the cached
@@ -216,7 +219,7 @@ The pane header gets a two-state segmented control, next to the title:
   the nearest positioned ancestor and lands a few rows off.
 - Vocabulary: a **turn** is one exchange, a **message** is a raw transcript row. Each turn's meta
   line says `turn 6/13`, so the bar counts the same things the reader does.
-- **The terminal must not keep the keyboard** while RENDER covers it. A mounted xterm with focus
+- **The terminal must not keep the keyboard** while the conversation covers it. A mounted xterm with focus
   swallows keystrokes into the agent's TTY, invisibly — and several paths grab focus back (the
   pane becoming active, the header, the key bar), some of them *after* the mode changes, so the
   guard belongs at each call rather than at the switch.
@@ -233,25 +236,25 @@ The pane header gets a two-state segmented control, next to the title:
 - **The conversation fills the pane.** A fixed reading column left a gutter of nothing on each
   side while the prompt band still spanned the full width, so the two disagreed about where the
   conversation began. The pane is the measure: narrow the pane and the conversation narrows.
-- **RENDER can be replied to.** Reading a conversation and answering it are the same act — the
+- **The conversation can be replied to.** Reading a conversation and answering it are the same act — the
   card has always known that, and a rendered session that could only be read would send you back
-  to the TUI to type. It is the card's own composer (`.ov-live`), the same `sendInput`, and the
+  to the terminal to type. It is the card's own composer (`.ov-live`), the same `sendInput`, and the
   same optimistic echo: your prompt appears at the bottom with a `working` line until the
   transcript catches up. Only a trace with **no agent behind it** — a shared file, an import — is
   read-only, which is what `readOnly` is for.
 - **Share** moves here from the sidebar. One session, one place.
-- **Handover** ("continue from this trace in a new agent") lives in the RENDER footer, beside
+- **Handover** ("continue from this trace in a new agent") lives in the conversation footer, beside
   the provenance line — the only place where its meaning is obvious.
 
 ### 3.4 What leaves the sidebar
 
 | Today | Tomorrow |
 |---|---|
-| `Read this session's trace` on every agent row (`Sidebar.tsx:245`) | pane header → **RENDER** |
+| `Read this session's trace` on every agent row (`Sidebar.tsx:245`) | bottom bar → **conversation** |
 | `Share this session` on every agent row (`Sidebar.tsx:246`) | pane header → **share** |
 | A `trace` **session row per read** (`App.tsx:openTrace`) | **gone** — no duplicate rows |
 | Trace row's `Share` (`Sidebar.tsx:237`) | trace pane header (imported traces keep a pane) |
-| Trace row's `Handover` (`Sidebar.tsx:238`) | RENDER / trace-pane footer |
+| Trace row's `Handover` (`Sidebar.tsx:238`) | conversation / trace-pane footer |
 | Quick-add **Trace** = open a shared dataset (`Sidebar.tsx:482`) | **stays** |
 
 The last row is deliberate: an **imported** trace has no session behind it, so it is a genuine
@@ -372,8 +375,8 @@ the block model already supports.
 ## 8. Open questions (operator)
 
 1. **How far back in the card?** Proposal: one exchange per click, hard cap 5, then hand off to
-   RENDER. Alternative: one, then straight to RENDER.
-2. **Is RENDER sticky per session**, or does a pane always open in TUI?
+   the conversation. Alternative: one, then straight to the full conversation.
+2. **Does the app open in conversation mode**, or always start on the terminal?
 3. **Kill the `↑ ↓` turn stepper?** Proposal: yes — unfolding replaces it.
 4. **Unfolded card of a running agent**: live-refresh every 3 s, or freeze until it finishes
    (cheaper, less alive)?
@@ -418,7 +421,7 @@ Built (this branch):
    there is no transcript to read.
 3. `pageOf()` takes a negative offset — "the last N turns" without a round trip to learn `total`
    (`server/test/trace-tail.test.mjs`).
-4. The session pane gets TUI ⇄ RENDER. RENDER draws over the terminal, which stays mounted and
+4. The session pane gets terminal ⇄ conversation, from the bottom bar, app-wide. It draws over the terminal, which stays mounted and
    connected but loses the keyboard; the mode is a per-session view preference in `localStorage`
    (`web/src/lib/paneMode.ts`), and its event reaches a pane that is already open — which is what
    the card's "full history ↗" needs.
@@ -430,9 +433,9 @@ Not yet, in the order I would do it:
 6. `head.prompts[]` (§5) — index, first line and timestamp per prompt, so a surface can draw the
    skeleton and label "show previous turn" before fetching the page that holds it.
 7. The sidebar loses its trace buttons and `openTrace`; share moves into the pane header (§3.4).
-8. Windowing by exchange in RENDER mode: a collapsed turn is 2–3 rows, so the DOM stays small,
+8. Windowing by exchange in conversation mode: a collapsed turn is 2–3 rows, so the DOM stays small,
    `head.prompts[]` gives the skeleton up front, and only an opened turn needs its page. The
    measured-height machinery in `TraceView` is reused as-is — what changes is what a "row" means.
-   Until then RENDER reads the last 400 turns in one request.
+   Until then it reads the last 400 turns in one request.
 9. The mobile card sizing block (§3.2) — the lab's `.lab-mfix` mirror of it is not the real
    `@media` rule, and the real one has not landed.

web/src/App.tsx

@@ -15,6 +15,7 @@ import BackupBanner from './components/BackupBanner';
 import Welcome from './components/Welcome';
 import * as api from './api';
 import type { Cli, GridSpec, MoveTarget, OverviewFilter, Session, Tree } from './types';
+import { onPaneMode, readPaneMode, writePaneMode } from './lib/paneMode';
 import { isPassive, isRemote } from './types';
 import { GridGlyph, ListGlyph } from './components/icons';
 
@@ -78,6 +79,11 @@ export default function App() {
   // stored — flipping the setting instantly (un)archives.
   const [showArchived, setShowArchived] = useState(false);
   const [archiveAfter, setArchiveAfter] = useState<'week' | 'month' | 'never'>('month');
+  // How every pane is read — the terminal itself, or the conversation in it.
+  // App-wide, like zoom, and remembered the same way.
+  const [paneMode, setPaneMode] = useState(readPaneMode);
+  useEffect(() => onPaneMode(setPaneMode), []);
+  const showPaneMode = (m: 'terminal' | 'conversation') => { setPaneMode(m); writePaneMode(m); };
   const [zoom, setZoom] = useState<number>(() => {
     const z = parseInt(localStorage.getItem('am-zoom') || '100', 10);
     return Number.isFinite(z) ? z : 100;
@@ -732,6 +738,7 @@ export default function App() {
                 cli={cliMap[s.cli]}
                 theme={theme}
                 zoom={zoom}
+                mode={paneMode}
                 focused={shown && sessions.length > 1 && s.id === focusedId}
                 visible={shown && deckVisible}
                 active={shown && deckVisible && s.id === focusedId}
@@ -979,6 +986,15 @@ export default function App() {
               </span>
             )}
             <span className="spacer" />
+            {/* Reading mode sits with zoom because it is the same kind of
+                setting: how you are looking at everything, not what a
+                particular pane is. */}
+            <span className="seg modebar">
+              <button className={paneMode === 'terminal' ? 'on' : ''} title="The terminal itself"
+                onClick={() => showPaneMode('terminal')}>terminal</button>
+              <button className={paneMode === 'conversation' ? 'on' : ''} title="The conversation in it, rendered"
+                onClick={() => showPaneMode('conversation')}>conversation</button>
+            </span>
             <button className="zbtn" title="Zoom out" onClick={() => setZoom((z) => Math.max(50, z - 10))}>−</button>
             <button className="zlvl" title="Reset to 100%" onClick={() => setZoom(100)}>{zoom}%</button>
             <button className="zbtn" title="Zoom in" onClick={() => setZoom((z) => Math.min(200, z + 10))}>+</button>

web/src/components/Overview.tsx

@@ -72,9 +72,9 @@ function useConversationTail(id: string, on: boolean, live: boolean) {
   return { turns, missing };
 }
 
-/** Opening the pane on this session, in RENDER mode (§3.3 keeps it per session). */
+/** Opening this session's pane, reading the conversation rather than the TTY. */
 const openRendered = (id: string, onOpen: (sid: string) => void) => {
-  writePaneMode(id, 'render');   // reaches a pane that is already open, too
+  writePaneMode('conversation');   // app-wide, and it reaches open panes too
   onOpen(id);
 };
 

web/src/components/TerminalPane.tsx

@@ -8,7 +8,6 @@ import type { Cli, Session } from '../types';
 import { STATE_LABEL } from '../types';
 import Logo from './Logo';
 import ConversationView from './conversation/ConversationView';
-import { onPaneMode, readPaneMode, writePaneMode } from '../lib/paneMode';
 import { isPassive } from '../types';
 import type { PaneMode } from '../lib/paneMode';
 import { CloseGlyph, RefreshGlyph } from './icons';
@@ -181,7 +180,7 @@ if (typeof window !== 'undefined') {
 }
 
 export default function TerminalPane({
-  session, cli, theme, focused, visible, active, zoom = 100, dragId, isMobile, onDragActive, onFocus, onRename, onClose,
+  session, cli, theme, focused, visible, active, zoom = 100, mode = 'terminal', dragId, isMobile, onDragActive, onFocus, onRename, onClose,
 }: {
   session: Session;
   cli?: Cli;
@@ -190,6 +189,7 @@ export default function TerminalPane({
   visible?: boolean;
   active?: boolean;
   zoom?: number;
+  mode?: PaneMode;          // app-wide reading mode, from the bottom bar
   dragId?: string;          // set when the pane can be rearranged (group view)
   isMobile?: boolean;       // show the on-screen control-key bar
   onDragActive?: (dragging: boolean) => void;
@@ -201,8 +201,8 @@ export default function TerminalPane({
   // Focus, unless the conversation is covering the terminal. Several paths grab
   // it — becoming active, the header, the key bar — and some fire after the mode
   // changes, so the guard lives with the call rather than with the switch.
-  const modeRef = useRef<PaneMode>('tui');
-  const focusTerm = () => { if (modeRef.current !== 'render') termRef.current?.focus(); };
+  const modeRef = useRef<PaneMode>('terminal');
+  const focusTerm = () => { if (modeRef.current !== 'conversation') termRef.current?.focus(); };
   const frameRef = useRef<HTMLDivElement>(null);
   const termRef = useRef<Terminal | null>(null);
   const resyncRef = useRef<() => void>(() => {});
@@ -212,17 +212,12 @@ export default function TerminalPane({
   const controllerRef = useRef(false);
   const previousZoomRef = useRef(zoom);
   const [preview] = useState<TerminalPreview | null>(() => loadTerminalPreview(session.id));
-  // TUI ⇄ RENDER (docs/conversation-view.md §3.3). Only an agent has a
-  // conversation to render: a shell is a shell, and files/trace panels are not
-  // this component's business at all.
+  // The mode is app-wide (the bottom bar owns it, like zoom), but only an agent
+  // has a conversation to show: a shell is a shell, and files/trace panels are
+  // not this component's business at all.
   const canRender = session.cli !== 'shell' && !isPassive(session.cli);
-  const [mode, setMode] = useState<PaneMode>(() => (canRender ? readPaneMode(session.id) : 'tui'));
-  useEffect(() => { setMode(canRender ? readPaneMode(session.id) : 'tui'); }, [session.id, canRender]);
-  // Someone else can ask for RENDER on a pane that is already open — the card's
-  // "full history ↗" does exactly that, and a localStorage write alone is silent.
-  useEffect(() => (canRender ? onPaneMode(session.id, setMode) : undefined), [session.id, canRender]);
-  const showMode = (m: PaneMode) => { setMode(m); writePaneMode(session.id, m); };
-  modeRef.current = mode;
+  const reading = mode === 'conversation' && canRender;
+  modeRef.current = reading ? 'conversation' : 'terminal';
   // Send a raw byte string to the PTY (for the mobile key-bar: arrows, Esc…).
   const sendKeyRef = useRef<(d: string) => void>(() => {});
   const [conn, setConn] = useState<ConnState>('connecting');
@@ -814,9 +809,9 @@ export default function TerminalPane({
   // with focus swallows every keystroke into the agent's TTY, invisibly. Hand
   // focus back when the terminal is on top again.
   useEffect(() => {
-    if (mode === 'render') termRef.current?.blur();
+    if (reading) termRef.current?.blur();
     else if (focused) termRef.current?.focus();
-  }, [mode, focused]);
+  }, [reading, focused]);
 
   // Focused panes tint toward THEIR agent's brand color, not the app accent.
   const tint = cli?.color;
@@ -862,23 +857,15 @@ export default function TerminalPane({
           <span className="ph-path" title={pathLabel}>{pathLabel}</span>
           {/* The trace stops being a separate thing you open: it is this
               session, read instead of watched. */}
-          {canRender && (
-          <span className="seg ph-modes" onMouseDown={(e) => e.stopPropagation()}>
-            <button className={mode === 'tui' ? 'on' : ''} title="The terminal itself"
-              onClick={(e) => { e.stopPropagation(); showMode('tui'); }}>TUI</button>
-            <button className={mode === 'render' ? 'on' : ''} title="The conversation, rendered"
-              onClick={(e) => { e.stopPropagation(); showMode('render'); }}>RENDER</button>
-          </span>
-          )}
           <button className="mini-btn ph-close" title="Close" onClick={(e) => { e.stopPropagation(); onClose(); }}><CloseGlyph /></button>
         </div>
       </div>
       <div className="term-host" ref={frameRef}>
         <div className="term-fill" ref={hostRef} />
-        {/* RENDER draws OVER the terminal rather than replacing it: xterm needs
+        {/* The conversation draws OVER the terminal rather than replacing it: xterm needs
             layout to fit, and detaching tmux costs a repaint and can trip the
             handoff path. The terminal stays mounted and connected underneath. */}
-        {mode === 'render' && (
+        {reading && (
           <div className="pane-render" onMouseDown={(e) => e.stopPropagation()}>
             <ConversationView session={session} paused={visible === false} isMobile={isMobile} />
           </div>

web/src/components/conversation/ConversationView.tsx

@@ -1,4 +1,4 @@
-// RENDER mode: a session's conversation, as a stack of exchanges.
+// Conversation mode: a session's trace, as a stack of exchanges.
 // (docs/conversation-view.md §3.3)
 //
 // The pane header above this belongs to the session; everything here is the
@@ -107,7 +107,7 @@ export default function ConversationView({ session, paused, isMobile, readOnly,
   const shown = useMemo(() => {
     if (!q) return exchanges;
     return exchanges.filter((x) =>
-      [x.prompt, x.answer, ...x.steps].some((t) =>
+      [x.prompt, ...x.answer, ...x.steps].some((t) =>
         t && t.blocks.some((b) => JSON.stringify(b).toLowerCase().includes(q))));
   }, [exchanges, q]);
 

web/src/components/conversation/Exchange.tsx

@@ -15,10 +15,12 @@ import type { Exchange, Step } from './exchanges';
 import { fmtClock, fmtDur, fmtTok, oneLine, stepSummary, stepText, stepsOf } from './exchanges';
 import ToolCall from './ToolCall';
 
-const textOf = (t: TraceTurn | null) =>
-  (t?.blocks || []).filter((b) => b.type === 'text').map((b) => ('text' in b ? b.text : '')).join('\n\n').trim();
-const moreOf = (t: TraceTurn | null) =>
-  (t?.blocks || []).reduce((n, b) => n + (('more' in b && b.more) || 0), 0);
+const blocksOf = (t: TraceTurn | TraceTurn[] | null) =>
+  (Array.isArray(t) ? t : [t]).flatMap((x) => x?.blocks || []);
+const textOf = (t: TraceTurn | TraceTurn[] | null) =>
+  blocksOf(t).filter((b) => b.type === 'text').map((b) => ('text' in b ? b.text : '')).join('\n\n').trim();
+const moreOf = (t: TraceTurn | TraceTurn[] | null) =>
+  blocksOf(t).reduce((n, b) => n + (('more' in b && b.more) || 0), 0);
 
 const moreLabel = (more?: number) =>
   (more ? `+${more > 1024 ? `${Math.round(more / 1024)} KB` : `${more} chars`} not retained` : '');
@@ -190,6 +192,7 @@ export function ExchangeView({
 
       {/* Everything about the turn on ONE line, under the prompt: what the work
           was on the left, which turn it is on the right. Nothing above. */}
+      {(summary || n != null) && (
       <div className="cx-meta mono">
         {steps.length > 0 ? (
           <button className={`cx-fold${isOpen ? ' on' : ''}`} onClick={toggle} title={isOpen ? 'Hide the work' : 'Show the work'}>
@@ -208,6 +211,7 @@ export function ExchangeView({
           </>
         )}
       </div>
+      )}
       {isOpen && steps.length > 0 && (
         <div className="cx-steps">{steps.map((s, i) => <StepRow key={i} s={s} q={q} />)}</div>
       )}

web/src/components/conversation/exchanges.ts

@@ -10,7 +10,8 @@ export interface Exchange {
   at: number;
   prompt: TraceTurn | null;
   steps: TraceTurn[];
-  answer: TraceTurn | null;
+  /** Everything the agent said after its last action — usually one turn. */
+  answer: TraceTurn[];
   startTs: number;
   endTs: number;
   tokens: number;
@@ -34,7 +35,7 @@ export function splitExchanges(turns: TraceTurn[]): Exchange[] {
   let cur: Exchange | null = null;
   const open = (at: number, prompt: TraceTurn | null) => {
     cur = {
-      key: `x${at}`, at, prompt, steps: [], answer: null,
+      key: `x${at}`, at, prompt, steps: [], answer: [],
       startTs: prompt?.ts || 0, endTs: prompt?.ts || 0, tokens: 0, toolCalls: 0,
     };
     out.push(cur);
@@ -63,20 +64,30 @@ export function splitExchanges(turns: TraceTurn[]): Exchange[] {
     const said = t.blocks.filter((b) => b.type !== 'text' || b.text.trim());
     return said.length > 0 && said[said.length - 1].type === 'text';
   };
+  const spoke = (t: TraceTurn) => saidSomething(t) && endedOnIt(t);
 
   for (const x of out) {
-    let at = -1;
-    // A later `final` supersedes an earlier one (a resumed task can have two);
-    // the earlier one stays in the work, where it happened.
+    // The answer is the trailing RUN of messages: everything the agent said
+    // after its last action. Taking only the last one buried real answers —
+    // a harness marks the last assistant text of a request as `final`, and
+    // that is sometimes a throwaway ("No response requested.") written in
+    // reply to a notification, with the actual answer in the turn above it.
+    let from = x.steps.length;
+    while (from > 0 && spoke(x.steps[from - 1])) from--;
+    if (from < x.steps.length) {
+      x.answer = x.steps.slice(from);
+      x.steps.length = from;
+      continue;
+    }
+    // Nothing at the end: an agent that answered and then went back to work
+    // (a resumed task) still answered. Its last `final` stands, where it is.
     for (let i = x.steps.length - 1; i >= 0; i--) {
-      if (x.steps[i].kind === 'final' && saidSomething(x.steps[i])) { at = i; break; }
+      if (x.steps[i].kind === 'final' && saidSomething(x.steps[i])) {
+        x.answer = [x.steps[i]];
+        x.steps.splice(i, 1);
+        break;
+      }
     }
-    // No `final` anywhere (some harnesses, some truncations): the trailing turn
-    // is the answer if it ended on words. Showing none would be a lie; showing
-    // an earlier one would be a different lie.
-    const last = x.steps.length - 1;
-    if (at < 0 && last >= 0 && saidSomething(x.steps[last]) && endedOnIt(x.steps[last])) at = last;
-    if (at >= 0) { x.answer = x.steps[at]; x.steps.splice(at, 1); }
   }
   return out;
 }

web/src/conversation.css

@@ -187,7 +187,7 @@ mark.cx-hit.on { background: var(--accent); color: var(--panel); }
   .cs-detail { font-size: 12px; }
 }
 
-/* ---------- RENDER mode inside a session pane ---------- */
+/* ---------- conversation mode inside a session pane ---------- */
 /* Drawn over the live terminal, which stays mounted underneath. */
 .pane-render { position: absolute; inset: 0; z-index: 3; display: flex; background: var(--panel); }
 .pane-render > .cxv { flex: 1; min-width: 0; }

web/src/lib/paneMode.ts

@@ -1,31 +1,27 @@
-// Which way a session's pane is being read: the terminal, or the conversation.
+// How every session pane is being read: the terminal, or the conversation.
 // (docs/conversation-view.md §3.3)
 //
-// A view preference, per session, kept in localStorage rather than the store —
-// it says nothing about the session itself, and it should survive a reload
-// without a round trip. The event exists because a pane that is ALREADY open
-// cannot see a write from somewhere else: the Overview card's "full history ↗"
-// sets the mode and then asks App to focus that pane.
-export type PaneMode = 'tui' | 'render';
+// One setting for the whole app, like zoom — not per session. Reading a fleet
+// means reading it the same way; flipping panes one at a time was a preference
+// nobody wanted to manage. Kept in localStorage so a reload does not undo it,
+// and announced so an already-mounted pane hears about it.
+export type PaneMode = 'terminal' | 'conversation';
 
-const KEY = 'am:pane-mode:';
+const KEY = 'am-pane-mode';
 const EVENT = 'am:pane-mode';
 
-export function readPaneMode(id: string): PaneMode {
-  try { return localStorage.getItem(KEY + id) === 'render' ? 'render' : 'tui'; } catch { return 'tui'; }
+export function readPaneMode(): PaneMode {
+  try { return localStorage.getItem(KEY) === 'conversation' ? 'conversation' : 'terminal'; } catch { return 'terminal'; }
 }
 
-export function writePaneMode(id: string, mode: PaneMode): void {
-  try { localStorage.setItem(KEY + id, mode); } catch { /* private mode: this session only */ }
-  window.dispatchEvent(new CustomEvent(EVENT, { detail: { id, mode } }));
+export function writePaneMode(mode: PaneMode): void {
+  try { localStorage.setItem(KEY, mode); } catch { /* private mode: this session only */ }
+  window.dispatchEvent(new CustomEvent(EVENT, { detail: mode }));
 }
 
-/** Called when someone else sets the mode for this session. */
-export function onPaneMode(id: string, apply: (m: PaneMode) => void): () => void {
-  const h = (e: Event) => {
-    const d = (e as CustomEvent<{ id: string; mode: PaneMode }>).detail;
-    if (d && d.id === id) apply(d.mode);
-  };
+/** Someone else changed it — the Overview card asking for the full history. */
+export function onPaneMode(apply: (m: PaneMode) => void): () => void {
+  const h = (e: Event) => apply((e as CustomEvent<PaneMode>).detail);
   window.addEventListener(EVENT, h);
   return () => window.removeEventListener(EVENT, h);
 }

web/src/styles.css

@@ -1062,6 +1062,10 @@ a.btn-ghost { text-decoration: none; }
 /* mobile stage top bar (back + agent chips) — rendered only on mobile */
 .mbar { display: flex; align-items: center; gap: 8px; padding: 0 0 8px; flex: none; }
 .mback { flex: none; font-size: 19px; padding-bottom: 3px; }
+/* Reading mode, in the zoom bar: the same weight as the controls beside it. */
+.modebar { flex: none; margin-right: 6px; }
+.modebar button { padding: 2px 8px; font-size: 10.5px; letter-spacing: 0.02em; }
+
 .mtitle { font-size: 13px; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .mchips { display: flex; gap: 6px; overflow-x: auto; flex: 1; padding: 2px; }
 .mchip { display: inline-flex; align-items: center; gap: 7px; padding: 6px 10px; background: var(--panel); border: 1px solid var(--border); border-radius: var(--r-md); cursor: pointer; flex: none; }

web/test/exchanges.test.mjs

@@ -30,7 +30,12 @@ const call = (name, arg) => ({ type: 'tool_use', name, text: JSON.stringify(arg)
 const result = (t, failed) => ({ type: 'tool_result', text: t, ...(failed ? { failed: true } : {}) });
 const user = (t) => ({ role: 'user', ts: at(), blocks: [text(t)] });
 const agent = (blocks, kind) => ({ role: 'assistant', ts: at(), ...(kind ? { kind } : {}), blocks });
-const said = (turn) => (turn ? turn.blocks.filter((b) => b.type === 'text').map((b) => b.text).join('') : null);
+// a prompt is one turn; an answer is the RUN of turns said after the last action
+const said = (t) => {
+  const turns = Array.isArray(t) ? t : [t].filter(Boolean);
+  if (!turns.length) return null;
+  return turns.map((x) => x.blocks.filter((b) => b.type === 'text').map((b) => b.text).join('')).join('\n\n');
+};
 const kinds = (steps) => steps.map((s) => (s.kind === 'tools' ? `${s.name}×${s.count}` : s.kind));
 
 // ---------------------------------------------------------------- mid-task
@@ -43,7 +48,7 @@ const kinds = (steps) => steps.map((s) => (s.kind === 'tools' ? `${s.name}×${s.
     agent([text('There it is — a sync stat sweep.'), call('Read', { file_path: 'runner.js' }), result('statSync(f)')]),
     agent([call('Edit', { file_path: 'runner.js' }), result('Applied 1 edit')]),
   ]);
-  assert.equal(x.answer, null, 'work in flight is not an answer');
+  assert.deepEqual(x.answer, [], 'work in flight is not an answer');
   assert.deepEqual(kinds(stepsOf(x.steps)),
     ['note', 'Grep×1', 'note', 'Read×1', 'Edit×1'],
     'messages stay above the calls they introduced');
@@ -68,7 +73,7 @@ const kinds = (steps) => steps.map((s) => (s.kind === 'tools' ? `${s.name}×${s.
     user('go'),
     agent([text('One more check.'), call('Bash', { command: 'npm test' }), result('ok')]),
   ]);
-  assert.equal(x.answer, null, 'ending on a tool call is not ending on words');
+  assert.deepEqual(x.answer, [], 'ending on a tool call is not ending on words');
 }
 
 // ------------------------------------------------------- a superseded final
@@ -85,6 +90,24 @@ const kinds = (steps) => steps.map((s) => (s.kind === 'tools' ? `${s.name}×${s.
   assert.deepEqual(kinds(stepsOf(x.steps)), ['note', 'Bash×1'], 'the earlier final keeps its position');
 }
 
+// ------------------------------------------------- a throwaway after the answer
+// Seen live: the harness marks the last assistant text of a request `final`,
+// and that was "No response requested." — written in reply to a notification,
+// with the real answer in the turn above. Taking only the last `final` buried
+// the answer in the work and showed the boilerplate as the reply.
+{
+  const [x] = splitExchanges([
+    user('any news on hugging face?'),
+    agent([text("I'll search the web for this."), call('WebSearch', { query: 'hugging face' }), result('…')]),
+    agent([text("Here's the latest on the incident: …")]),
+    agent([text('No response requested.')], 'final'),
+  ]);
+  assert.equal(said(x.answer),
+    "Here's the latest on the incident: …\n\nNo response requested.",
+    'everything said after the last action is the answer');
+  assert.deepEqual(kinds(stepsOf(x.steps)), ['note', 'WebSearch×1'], 'and none of it is left in the work');
+}
+
 // --------------------------------------------------------------- splitting
 // One exchange per operator prompt; harness-authored "user" lines are not
 // prompts, and neither is an interrupt marker.