Struct MailboxBuffers 

pub struct MailboxBuffers {

    pub agent_id: String,
    pub inbox: Vec<MessageRow>,
    pub sent: Vec<MessageRow>,
    pub channel: Vec<MessageRow>,
    pub wire: Vec<MessageRow>,
    pub inbox_after: i64,
    pub sent_after: i64,
    pub channel_after: i64,
    pub wire_after: i64,
    pub inbox_cursor: CursorState,
    pub sent_cursor: CursorState,
    pub channel_cursor: CursorState,
    pub wire_cursor: CursorState,
    pub inbox_filter: String,
    pub sent_filter: String,
    pub channel_filter: String,
    pub wire_filter: String,
    pub inbox_search: String,
    pub sent_search: String,
    pub channel_search: String,
    pub wire_search: String,
}

Per-agent buffer state — four tabs, four after_id cursors. Lives on App so swapping the focused agent resets the cursors without trying to back-fill: the operator sees only forward motion in the tab they’re watching.

Fields

agent_id: String

The focused agent’s id (<project>:<agent>), set by refresh_mailbox. The sender != me source for the Inbox merge’s inbound filter (#462) — kept here so rows() and the cursor methods that read it don’t have to thread me through every signature. Empty until the first refresh; an empty id means the filter is a no-op (one transient frame at most).

inbox: Vec<MessageRow>

sent: Vec<MessageRow>

channel: Vec<MessageRow>

wire: Vec<MessageRow>

inbox_after: i64

sent_after: i64

channel_after: i64

wire_after: i64

inbox_cursor: CursorState

sent_cursor: CursorState

channel_cursor: CursorState

wire_cursor: CursorState

inbox_filter: String

sent_filter: String

channel_filter: String

wire_filter: String

inbox_search: String

sent_search: String

channel_search: String

wire_search: String

Implementations

impl MailboxBuffers

pub fn rows(&self, tab: MailboxTab) -> Cow<'_, [MessageRow]>

Rows for tab, in ascending broker-id (receipt) order.

Most tabs hand back a borrow of their backing buffer. Inbox is the exception (#462): it returns an owned, time-merged view of inbound DMs + channel + wire, so it allocates. Cow lets the common borrowed case stay zero-copy while the merged case owns its Vec; callers use the result as a slice either way (Cow derefs to [MessageRow]).

pub fn visible_indices(&self, tab: MailboxTab) -> Vec<usize>

Indices into rows(tab) for the rows currently presented to the operator — filter ∩ search. PR-2 swapped this body in; every cursor method and the render call site stayed unchanged from PR-1 because they go through this abstraction. A row at rows(tab)[i] is visible iff:

1. filter_text(tab) is empty OR row.sender (lower-cased) contains the filter (lower-cased) as a substring.
2. search_text(tab) is empty OR row.text (lower-cased) contains the search (lower-cased) as a substring.

When both axes are empty, the result is identity (0..rows.len()) — PR-1’s default behavior recovers exactly. Case-insensitive substring is the documented contract; the per-keystroke recompute on small (~500-row) buffers is well within budget.

pub fn visible_indices_in( &self, rows: &[MessageRow], tab: MailboxTab, ) -> Vec<usize>

Like [visible_indices] but against an already-materialised row slice. The render path already holds rows(tab), so it computes visibility through this to avoid a second rows() call — for the Inbox that call is non-trivial (it clones, sorts, and dedups the merged feed, #462), and the per-frame render would otherwise pay for the merge twice.

pub fn filter_text(&self, tab: MailboxTab) -> &str

Current sender-substring filter on tab; empty = no filter.

pub fn search_text(&self, tab: MailboxTab) -> &str

Current body-substring search on tab; empty = no search.

pub fn input_push_char( &mut self, tab: MailboxTab, kind: MailboxInputKind, c: char, )

Push c onto the active input buffer for tab, then clamp the cursor against the (possibly shorter) new visible_indices. Called per-keystroke by the App input-mode handler.

pub fn input_pop_char(&mut self, tab: MailboxTab, kind: MailboxInputKind)

Pop one character (Backspace) from the active input buffer for tab, then re-clamp the cursor.

pub fn set_input( &mut self, tab: MailboxTab, kind: MailboxInputKind, value: String, )

Replace the active input buffer for tab wholesale — used by the Esc-cancel-revert path to restore the pre-open snapshot.

pub fn cursor(&self, tab: MailboxTab) -> &CursorState

pub fn move_cursor_down(&mut self, tab: MailboxTab)

Move the cursor one row toward the tail; clamps at the last visible row (vim-like — no wrap).

pub fn move_cursor_up(&mut self, tab: MailboxTab)

Move the cursor one row toward the head; clamps at 0.

pub fn page_cursor_down(&mut self, tab: MailboxTab)

Jump a screen toward the tail.

pub fn page_cursor_up(&mut self, tab: MailboxTab)

Jump a screen toward the head.

pub fn cursor_home(&mut self, tab: MailboxTab)

Jump to the first visible row.

pub fn cursor_end(&mut self, tab: MailboxTab)

Jump to the last visible row.

pub fn inbox_at_tail(&self) -> bool

Whether the Inbox cursor is at (or past) the tail of the merged view — i.e. the operator is following new arrivals. Captured before a refresh’s extends so [follow_inbox_tail] can re-anchor the cursor afterwards: per-tab extend only follows the tab it touches, but a channel/wire arrival grows the Inbox view too, so without this the highlight would stop tracking the newest row on the merged tab (#462).

pub fn follow_inbox_tail(&mut self)

Snap the Inbox cursor to the tail of the post-merge view. Called after a refresh’s extends when [inbox_at_tail] held before them, so following the Inbox keeps tracking the newest row even when the new arrival came via the channel or wire buffer (#462).

pub fn extend(&mut self, tab: MailboxTab, batch: Vec<MessageRow>)

Fold a freshly-fetched batch into the appropriate tab, trimming to the last MAX_TAB_ROWS. Bumps the broker pagination cursor to the last returned id when the batch is non-empty. T-131 PR-1: when the UI cursor was already at the tail (or the tab was empty), follow new arrivals — matching the pre-T-131 “tail to whatever fits” UX. Always re-clamps the UI cursor against the (possibly drained) post-extend visible length so a stale index can never reference a missing row.

pub fn reset(&mut self)

Reset every tab’s contents and cursor. Called when the focused agent changes — the new agent’s inbox filter would otherwise skip historical rows that landed before our last inbox_after, and the UI cursor would point into the wrong agent’s buffer.

Trait Implementations

impl Clone for MailboxBuffers

fn clone(&self) -> MailboxBuffers

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MailboxBuffers

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MailboxBuffers

fn default() -> MailboxBuffers

Returns the “default value” for a type.