docs(glasspane): add operator-attention usability roadmap (TODO)

Capture forward direction for the glasspane/colibri-tui operator surface:
make "does this agent need me right now?" the primary, push-it-outbound
object. Six TODO items — attention as a derived flag, outbound desktop +
Telegram notifications, jump-to-next-attention key, richer pane rows
(branch/last-line/jail), persisted pane history across restarts, and a
later interactive "answer a blocked agent" socket write path.

Direction only, no implementation. Ideas drawn from agent-cockpit
terminal UIs; wiring is our own (no external code).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

docs/wiki/glasspane.md

@@ -91,6 +91,59 @@ that's fundamentally about current state, not event delivery.
 → [`crates/colibri-glasspane/src/lib.rs`](../../crates/colibri-glasspane/src/lib.rs)
 (`Supervisor`, `snapshot`)
 
+## Usability roadmap (TODO)
+
+Glasspane has the supervision spine — a stable state machine and a snapshot API.
+The open work is operator-facing: making *"does this agent need me right now?"*
+the primary, impossible-to-miss object. These are captured as direction, not yet
+built. The data mostly already exists; the work is surfacing and pushing it.
+Ideas drawn from agent-cockpit terminal UIs; wiring is our own.
+
+### Attention as a first-class derived signal
+
+Today a pane is `Idle/Working/Done/Error/Stalled`. Promote "needs the operator"
+into an explicit **attention flag** derived from the existing states (`Error`,
+`Stalled`, and a future "waiting for input") rather than a sixth state. The state
+machine stays small; attention is a view over it. The TUI highlights attention
+rows; the daemon and notifier read the same flag.
+
+### Push notifications outbound, not just on-screen
+
+The operator supervises headless hosts over Tailscale, not by staring at the
+TUI. When a pane raises attention (or hits `Done`), push it **out**: a desktop
+notification on the live image (XFCE) and a **Telegram** message (the token is
+already provisioned). An explicit `colibri notify`-style path — or a glasspane
+event type that a zot/Pi hook fires — lets an agent say "I'm blocked" rather than
+relying only on inferred state. Highest real-world impact item.
+
+### Jump-to-next-attention navigation in the TUI
+
+A keybinding in `colibri-tui` that cycles to the next attention pane. Trivial
+given the attention flag; large ergonomic win when supervising many agents.
+→ `crates/colibri-glasspane-tui/src/main.rs`
+
+### Richer pane rows (context at a glance)
+
+Glasspane already stashes non-state events in pane metadata. Surface that in the
+TUI row: current **repo/branch**, **last line / task summary**, the **jail** the
+agent runs in, optionally listening ports. Turns "Working" into "Working on
+`fix/x` in jail `cms`, last: running tests".
+
+### Persist pane history across daemon restarts
+
+The supervisor is in-memory (`Arc<RwLock<...>>`); a daemon restart loses the
+timeline. Persist pane transitions/history so returning after hours (or a
+reboot) preserves "what happened while I was away". Lightweight durability, not a
+new subsystem.
+
+### Answer a blocked agent from the dashboard (bigger lift)
+
+The snapshot API is read-heavy by design. A future write path — "send input to
+pane N" over the daemon socket — would let the operator **respond** to a blocked
+agent from `colibri-tui`, not just observe/spawn/kill. This is direction, not a
+quick win; it changes the socket from read-only supervision to interactive
+control and needs its own design pass.
+
 ## See also
 
 - [agent-harness](./agent-harness.md) — the zot/Colibri split that Glasspane observes