Struct Router 

pub struct Router {
    policy: Mutex<PolicyState>,
    broker: Arc<Broker>,
    config: Arc<ConfigState>,
    store: Arc<Store>,
    pending_activation: Mutex<Option<PendingActivation>>,
    internal: UnboundedSender<Internal>,
    last_tray: Mutex<Option<TrayState>>,
    turn_active: Mutex<HashMap<String, bool>>,
    stopped_at: Mutex<HashMap<String, i64>>,
    notified_turns: Mutex<HashSet<(String, u64, u64)>>,
}

Fields

policy: Mutex<PolicyState>

broker: Arc<Broker>

config: Arc<ConfigState>

store: Arc<Store>

pending_activation: Mutex<Option<PendingActivation>>

A click whose pane’s workspace was open in no window: taken by the window the launcher opens on that workspace.

internal: UnboundedSender<Internal>

last_tray: Mutex<Option<TrayState>>

turn_active: Mutex<HashMap<String, bool>>

block_id → last turn_active seen in controllerstatus.

stopped_at: Mutex<HashMap<String, i64>>

block_id → when the user last stopped its turn (epoch ms).

notified_turns: Mutex<HashSet<(String, u64, u64)>>

(block_id, turn_id, ended_at_ms) of turn ends already notified.

Implementations

impl Router

fn settings(&self) -> Settings

fn owns_block(&self, block_id: &str) -> bool

Does this Router’s store know the block? BLOCKING (SQLite).

fn block_labels(&self, block_id: &str) -> (String, Option<String>)

The block’s sanitized agent name and session summary, from one read. BLOCKING (SQLite behind Store’s process-wide mutex) — only ever reached through emit / emit_fixed, which callers must run off the async workers (spawn_blocking; the #1782 failure class, see websocket.rs’s controllerinput note). Not cached: the summary changes every turn and emits are rare, so the read the summary needs anyway also serves the name.

fn step(&self, input: Input) -> Vec<Action>

Run the policy and publish what it decided. Activate is returned, not published: only ack produces it, and it needs a store lookup.

fn publish_tray_if_changed(&self, tray: TrayState)

fn publish(&self, action: &Action)

fn publish_event<E: Event>(&self, payload: &E::Payload)

pub fn emit( &self, kind: NotifyKind, block_id: &str, question: Option<&str>, question_count: usize, )

A frontend reports a pane event. question is only used for InputWaiting and goes through redact_body; question_count adds “ (+N more)“ after it.

BLOCKING (the block lookup hits the store) — call from spawn_blocking, never inline on an async worker.

pub fn emit_fixed(&self, kind: NotifyKind, block_id: &str, body: Option<String>)

srv-internal sources: the body is app-controlled fixed text, so it is not redacted — only the preview=none setting strips it (in policy). BLOCKING, like emit.

pub fn input_waiting_nonblocking( &self, block_id: &str, question: Option<String>, count: usize, )

srv-observed “agent is waiting on you” (Phase 5). Non-blocking: safe from the controller’s stdout reader thread. Coalesces with the renderer’s own report for the same block (same input: group).

pub fn turn_stopped_nonblocking(&self, block_id: &str)

The user stopped this block’s turn: cancel “finished” for it, and don’t turn the resulting turn-end into one (queued, ordered).

pub fn resolve_nonblocking(&self, block_id: &str, family: Family)

Ordered counterpart of resolve: queued behind any emit already sent for the same block.

pub fn resolve(&self, block_id: &str, family: Family)

pub fn test(&self)

pub fn cloud_signed_out(&self)

This channel’s MuxBus sign-in stopped working (muxbus::delivery_status). Fixed text; about no agent. Taken down with resolve("", Family::Cloud).

pub fn focus(&self, conn_id: &str, report: FocusReport)

pub fn disconnect(&self, conn_id: &str)

pub fn ack(&self, id: &str, clicked: bool) -> AckOutcome

Presenter feedback (rich-content spec §3.3 A–D, F). For a click on a pane’s toast: find the open window showing the pane and tell only it to select the pane (notification:activate names the window); if the pane’s workspace is open nowhere, park the click for the window the launcher will open on it. The outcome tells the launcher what to raise or open — every click ends with something in front.

BLOCKING (store reads) — call from spawn_blocking.

pub fn reveal_target(&self, block_id: &str) -> Option<BlockRevealEvent>

block.reveal: the block’s tab and the open window showing it, resolved exactly as a toast click is (resolve_click_target + the same open-window pick). None when the block is gone or its workspace is open in no window.

BLOCKING (store reads) — call from spawn_blocking.

pub fn publish_block_reveal(&self, target: &BlockRevealEvent)

Tell target.window_id’s renderer to reveal the block.

pub fn take_pending_activation( &self, workspace_id: Option<&str>, ) -> Option<PendingActivation>

One-shot: the pane a click asked for while its workspace was open in no window. Only a window on that workspace takes it (workspace_id None = an older frontend, which takes any), and only for 30 s.