[FEATURE]: show and load the messages the TUI hides in long sessions #53642

Feature hasn't been suggested before.

• I have verified this feature I'm about to request hasn't been suggested before.

Describe the enhancement you want to request

The TUI keeps at most 100 messages of a session loaded. Opening a session fetches the newest 100 (session.messages({ limit: 100 })), and every new message past 100 drops the oldest one from the store (packages/tui/src/context/sync.tsx). The limit counts messages only; every part of a kept message stays loaded, whatever its size. Nothing else limits what the transcript renders.

That limit is reasonable, but today it is invisible and final:

• Nothing in the transcript says that messages are missing. Scrolling to the top of a long session lands on some message in the middle of the work, which reads as if the session started there.
• The first prompt, which usually says what the whole session is about, is the first thing to go.
• There is no way to see the older messages again from the TUI, short of exporting the session.
• The 100 is hard-coded, so a user on a small machine can't lower it and a user who wants more scrollback can't raise it.

Proposal:

1. A divider wherever messages are hidden. A horizontal rule across the transcript with the count centered on it, ──── 1,234 messages hidden ────, and below it the actions that load them: load 50 above, load 50 below and load all. A gap of 50 or fewer offers only load all 23. The actions are clickable and are also commands in the palette ("Load 50 hidden messages above the divider", "... below the divider", "Load all hidden messages", /load-hidden), with keybinds that default to none (messages_hidden_above, messages_hidden_below, messages_hidden_all).
2. Keep the first prompt. When older messages are hidden, the session's first prompt stays at the top, above the divider. tui.json transcript.keep_first_prompt, default true. This is a visible change from today; it could default to false if you'd rather keep the current look.
3. Configurable limit. tui.json transcript.max_messages, default 100, the current value.

"Above" fills the gap from its older edge: the messages right after the first prompt, or the session's very first messages when no prompt is pinned. "Below" fills it from its newer edge, extending the recent messages backwards. load all loads the rest and stops dropping messages for that session. Loading 50 grows the window by what was loaded, so new output does not immediately drop what you just loaded.

Loading keeps the reader's place: if the view is scrolled away from the divider, the block at the top of the viewport stays on the same row while the loaded messages are inserted above it.

API

GET /session/:id/message already pages backwards with limit and an opaque before cursor (X-Next-Cursor). The first prompt and "above" need the other direction, and the divider needs a count, so the same route gains:

• after: messages strictly newer than a cursor, oldest first, X-Next-Cursor continuing forward;
• order=asc: without an anchor, page from the oldest message instead of the newest;
• before and after also accept a message ID, so a client can anchor on a message it already has instead of holding a cursor that goes stale when messages are dropped;
• X-Total-Count on paged responses.

before with after, after with order=desc and before with order=asc are rejected with 400. Requests without limit are unchanged. The experimental /api/session/:id/message route has ascending order, but it reads the session_message projection, which sessions older than the event tables don't have.

The TUI asks for the first prompt (limit=1&order=asc) only when the newest page doesn't cover the whole session, so short sessions make exactly the request they make today.