feat(app): wait_for_status + read_terminal on the live bridge (F-mcp-terminal-sync, #195)

[bastien-gallay]

What

The wait rung, closing act → wait → observe. Orchestration (#194) could
act and snapshot (#212) could perceive, but nothing could synchronise:
run_in_session writes and returns, so an agent had no way to know when a
command finished short of polling snapshot — and racing the very transition
it was watching for.

MCP tool	What it does
wait_for_status(session[, statuses][, timeout_ms])	Blocks until the session's OSC-derived activity reaches one of statuses (default idle-or-attention). Returns { status, timed_out }.
read_terminal(session[, lines])	One pane's visible text — the deep read the light snapshot leaves out. Returns { text, rendered }.

How

The wait is the first bridge request whose reply lands in a later update.
That turned out to need no new machinery: ReplyPort is already a take-once
slot behind an Arc, built precisely so an answer need not be immediate. The
shell parks it in a waiter list and settles it from the status change itself —
nothing polled, no transition raced (the feature-torture report cut
wait_for_text for exactly that failure mode).

serve(WaitForStatus) ─┬─ handle unknown ──────────► answer now (invalid_params)
                      ├─ already on a target ─────► answer now
                      └─ otherwise ──────────────► park a StatusWaiter
                                                        │
update(PtyStatus) ─┐                                    │
update(PtyExited) ─┴──► settle_waiters(session, status) ┘  + sweep dead ports

Three rules earn their own tests, each for a concrete failure:

• A session already on the target answers at once. Otherwise a caller
  asking "tell me when it's idle" about an idle session waits out its whole
  bound, having missed the transition it asked about.
• An exit settles every waiter, whatever it asked for. Verified in core:
  pty_exited records Exited and returns no effects — a crash emits no
  status change. And a dead session will never reach the target anyway.
• A caller that gave up is swept off the list, rather than held for a
  session that may never move again (ReplyPort::abandoned).

Timing out is not a failure. On timeout the tool reads the session's
current status back and answers { status, timed_out: true }, so an agent can
choose between waiting again and giving up instead of getting a bare error. The
bound is the caller's timeout_ms (default 30 s), capped at 5 minutes — no
parameterisation can park a caller indefinitely (Q7).

read_terminal keeps three outcomes distinct that a scoped snapshot
collapses into a single absent key: unknown handle (invalid_params), live but
undrawn (rendered: false — retry, don't give up on the handle), and text.
Truncation reuses core::snapshot::tail_lines rather than growing a second
rule that could drift from a snapshot's.

Two commits

1. refactor(app) — tidy-first, no behaviour change: the Message::Bridge
   arm moves out of update (which already carries a too-many-lines allow)
   into shell::serve, so there is one auditable place where an external
   caller meets core::App.
2. feat(app) — the rung above.

Tests

Written red first. 20 new, all green:

• shell (11) — answers-at-once; parks then settles; stays parked through a
  non-target status; ignores another session's change; rejects an unknown
  handle without parking; settled by an unclean exit; abandoned waiter swept;
  and four read_terminal cases (text, line budget, undrawn, unknown handle).
• tools (9) — default statuses, named statuses, unknown status name
  rejected (not silently dropped), settled status reported, rejection relayed
  as invalid_params, the timeout path (a two-reply test shell: the wait is
  received and never answered, then the status read-back), the cap, and
  read_terminal's handle/line-budget/undrawn/rejection shaping.

Full suite green (cargo test --workspace); fmt · clippy · machete ·
deny · check-deps · check-arch · markdownlint all pass. ROADMAP entry
ticked.

Closes #195.