ek_ui/

plugin.rs

//! `UiPlugin` —— 总线面:`eLog` 入环形日志、`ePlugUp/Down` 记事件 + rev、
//! `eBar`./`eBarUpdate.` 记行情库(K线窗数据面)、`eTick.` 记 tick 库(v4 行情带
//! 唯一源,S7 上屏地面)、
//! `eTimer`(1s 宿主自带)拉一次 `svctl.list` + 逐插件服务目录组快照 +
//! ask oms 全量查询组交易监控帧(S5),
//! 并辞行窗口面的操作指令队列(svctl 起停 + dm.reload 回灌 + oms 五段管线
//! 下单/守卫撤单)。
//!
//! 纪律:UI 不直调任何插件;唯一管制面是 ask 契约(svctl / dm.reload /
//! oms 查询与 submit_order·cancel_order / ctp 配置订阅,全部与
//! headless 同源;`PluginContext` 只在 worker 可用)。0.1.1 BD-UI-30:
//! 下单/撤单直发网关的旁路口删除——风控与守卫不可绕过。0.2.10 BD-UI-38:
//! sim 纸面网关退场(流控查询口随之撤)。

use std::sync::OnceLock;
use std::time::Duration;

use ek_core::context::PluginContext;
use ek_core::plugin::Plugin;
use ek_core::service::{PlugNotice, ServiceDesc};
use ek_core::{EVENT_PLUG_DOWN, EVENT_PLUG_UP};
use ek_ctp::plugin::{
    ConfigureReply, ConfigureReq, DisconnectReply, DisconnectReq, GatewayStatus, StatusReq,
    SubscribeReply as CtpSubscribeReply, SubscribeReq as CtpSubscribeReq,
};
use ek_data::account::AccountData;
use ek_data::event::{EVENT_BAR, EVENT_CONTRACT, EVENT_LOG, EVENT_TICK};
use ek_data::log::LogData;
use ek_data::order::OrderData;
use ek_data::position::PositionData;
use ek_data::trade::TradeData;
use ek_dm::plugin::{EVENT_BAR_UPDATE, ReloadReq};
use ek_event::EVENT_TIMER;
use ek_oms::plugin::{
    GetAllAccountsReq, GetAllOrdersReq, GetAllPositionsReq, GetAllTradesReq, OmsCancelOrderReq,
    OmsCancelReply, PipelineStatusReq, SubmitOrderReq,
};
use ek_oms::{SubmitReply, SubmitStatus};
use ek_station::wire::{
    ListReq, PlugRow, RemoveReq, RemoveRes, SVC_LIST, SVC_REMOVE, SVC_START, StartReq, StartRes,
};

use crate::state::{BusSnap, UiShared};

/// 注册名 = 工厂名 = `"ui"`(BD-U5:两者一致)。
pub const UI_NAME: &str = "ui";

/// oms 四张全量表的 ask 时限(0.4.5,P7b 超时分级)。
///
/// 1 秒而不是 2 秒:这四口是 oms 内存查询,正常个位数毫秒,2 秒从来不是给
/// 「查询本身」留的余量,而是给「信封排在几百条成交回报后面」留的。分级把
/// 单拍停顿上限从 `4 × 2s` 压到 `4 × 1s`。`svctl.list` 与 `{gw}.status` 留 2 秒
/// (前者可能正撞 `close_one` 的 2 秒摘除窗口,后者可能正撞网关查询协调点的
/// 900ms 墙钟护栏 —— 那两处是真会慢的)。
/// 这一条必须与 P7a(超时保旧帧)同版落地:单独降时限只会让空帧更频繁。
pub const OMS_ASK_TIMEOUT: Duration = Duration::from_secs(1);

/// 一张表的读数裁决(0.4.5,P7a)。
///
/// 三档必须各自判得出来(钉在 `tests/ui_ops.rs` 的 u4):
/// - `Ok` → 用新读数;
/// - `Timeout` → **保留上一帧**。问不到 ≠ 没有:原先 `unwrap_or_default()` 把四张表
///   一起清空,而那一刻可能正有一笔单在场上 —— 空帧是「断言此刻没有委托」,
///   比「可能旧的」更坏。
/// - 其余(`TargetGone` / `UnknownService` / `InvalidPayload` / `BusStopped`)→ 清空。
///   这一档是**事实**:oms 不在场就没有委托,留着旧帧才是骗人。
///
/// 与 `svctl.list` 那侧对齐:那里超时从来不碰快照(`set_snapshot` 只在 `Ok` 分支),
/// 同一个「超时」在两处口径不一致就是本轮读 P7 时发现的病。
pub fn merge_frame<T>(res: Result<Vec<T>, ek_core::error::AskError>, prev: Vec<T>) -> Vec<T> {
    match res {
        Ok(v) => v,
        Err(ek_core::error::AskError::Timeout { .. }) => prev,
        Err(_) => Vec::new(),
    }
}

/// 常驻观测插件(窗口面在 [`crate::runtime`] 持 [`UiShared`] 渲染)。
pub struct UiPlugin {
    shared: std::sync::Arc<UiShared>,
    ctx: OnceLock<PluginContext>,
}

impl UiPlugin {
    /// 与窗口面共用的共享状态句柄。
    pub fn new(shared: std::sync::Arc<UiShared>) -> Self {
        Self {
            shared,
            ctx: OnceLock::new(),
        }
    }

    /// eTimer 节流回调:先辞行操作指令(有则记录),再组一次快照。
    fn refresh(&self) {
        let Some(ctx) = self.ctx.get() else {
            return; // 未 init 就吃到 eTimer:忽略,等下轮
        };
        self.run_cmds(ctx);
        match ctx.ask_service::<ListReq, Vec<PlugRow>>(SVC_LIST, ListReq, Duration::from_secs(2)) {
            Ok(rows) => {
                let mut services = Vec::with_capacity(rows.len());
                for r in &rows {
                    let ids = ctx
                        .services_of(&r.name)
                        .map(|v| v.iter().map(|s| s.id.clone()).collect::<Vec<_>>())
                        .unwrap_or_default();
                    services.push((r.name.clone(), ids));
                }
                // 账户连接位回填 + 新上线检测(订阅重放判据,规划 §5.C)。
                let newly = self.shared.sync_accounts_connected(&rows);
                // 0.4.5(P7d):邮箱溢出的当场显形。运维窗那一列一直有 spilled,
                // 但 ek-core 的 stderr 诊断每 128 条才打一条 —— 屏上此前没有任何东西。
                self.shared.note_plugin_spill(&rows);
                self.shared.set_snapshot(BusSnap { rows, services });
                let md = self.shared.md_source();
                let subs = self.shared.subscriptions();
                for gw in newly {
                    if !md.is_empty() && gw == md && !subs.is_empty() {
                        self.shared.push_cmd(crate::state::UiCmd::CtpSubscribe {
                            gateway: gw.clone(),
                            symbols: subs.clone(),
                        });
                        self.shared
                            .log_line(format!("[ops] 行情源 {gw} 上线,重放订阅 {} 项", subs.len()));
                    }
                }
            }
            Err(e) => self.shared.log_line(format!("[ui] svctl.list 失败: {e:?}")),
        }
        // S5 交易监控:ask oms 全量查询组帧(0.4.5 起三档裁决,见 `merge_frame`)。
        // P7b 超时分级(1s)+ P7a 超时保旧帧,两条同版落地 —— 单独降时限只会让空帧更频繁。
        let orders = ctx.ask_service::<GetAllOrdersReq, Vec<OrderData>>(
            "oms.get_all_orders",
            GetAllOrdersReq,
            OMS_ASK_TIMEOUT,
        );
        let trades = ctx.ask_service::<GetAllTradesReq, Vec<TradeData>>(
            "oms.get_all_trades",
            GetAllTradesReq,
            OMS_ASK_TIMEOUT,
        );
        let positions = ctx.ask_service::<GetAllPositionsReq, Vec<PositionData>>(
            "oms.get_all_positions",
            GetAllPositionsReq,
            OMS_ASK_TIMEOUT,
        );
        let accounts = ctx.ask_service::<GetAllAccountsReq, Vec<AccountData>>(
            "oms.get_all_accounts",
            GetAllAccountsReq,
            OMS_ASK_TIMEOUT,
        );
        let timed_out =
            |e: &ek_core::error::AskError| matches!(e, ek_core::error::AskError::Timeout { .. });
        let stale = orders.as_ref().err().is_some_and(timed_out)
            || trades.as_ref().err().is_some_and(timed_out)
            || positions.as_ref().err().is_some_and(timed_out)
            || accounts.as_ref().err().is_some_and(timed_out);
        let prev = self.shared.trade_snap();
        self.shared.set_trade_snap(crate::state::TradeSnap {
            orders: merge_frame(orders, prev.orders.clone()),
            trades: merge_frame(trades, prev.trades.clone()),
            positions: merge_frame(positions, prev.positions.clone()),
            accounts: merge_frame(accounts, prev.accounts.clone()),
        });
        // 旧帧必须被标明是旧的:状态位给渲染侧(`trade_frame_stale`),日志只在**迁移**
        // 那一次落一条 —— 拥堵期每拍都问不到,每拍刷一条会把日志环挤满。
        if self.shared.note_trade_frame_stale(stale) {
            self.shared.log_line(if stale {
                "[ui] oms 四问有超时:交易监控显示的是上一帧(不是此刻没有委托)".to_string()
            } else {
                "[ui] oms 四问恢复:交易监控回到当前帧".to_string()
            });
        }
        // 0.2.19 状态轮询(规划 P3 / 裁定 3):每 `STATUS_POLL_TICKS` 拍向每个
        // **已装配且在场**的账户问一次 `{gw}.status`,把读数折成状态列的登录态。
        //
        // 只问在场的:实例已被摘除时 ask 会等到超时(2s),按账户串行就是按账户把
        // 整个刷新循环拖住 —— 而那种账户本来也没有会话可问。
        // 只读口不写日志(ek-ctp D-STATUS ④),所以这条轮询不会冲 eLog 环。
        if self.shared.status_poll_due() {
            for a in self.shared.accounts() {
                if a.stage != crate::state::AccountStage::Assembled || !a.connected {
                    continue;
                }
                let svc = format!("{}.status", a.gateway);
                match ctx.ask_service::<StatusReq, GatewayStatus>(
                    &svc,
                    StatusReq,
                    Duration::from_secs(2),
                ) {
                    Ok(st) => self.shared.note_gateway_status(&a.gateway, &st),
                    Err(e) => self
                        .shared
                        .note_status_unreachable(&a.gateway, &format!("{e:?}")),
                }
            }
        }
        // 0.4.4(P5-a 裁定接的那条服务):`oms.pipeline_status` 上运维窗。
        // 插件表给的是「谁在场」,这一节给的是「oms 里面装了什么」——五段管线、
        // 限速与撤单守卫、拆单器、每道风控闸一行(工厂注入的是 ek_risk::standard_gates
        // 缺省限额那四道)。此前这条服务在全链**零消费方**(0.3.x 加它时是「可观测性
        // 补偿」,但界面没有出口),只在 ek-oms 的 on_start 日志里显形一次。
        // 节拍比状态轮询再慢一档(PIPELINE_POLL_TICKS = 4):装配很少变,而它是 oms
        // worker 上又一次串行 ask(DESIGN 0.4.3 段 P7 那本账)。
        if self.shared.pipeline_poll_due() {
            match ctx.ask_service::<PipelineStatusReq, Vec<String>>(
                "oms.pipeline_status",
                PipelineStatusReq,
                Duration::from_secs(2),
            ) {
                Ok(lines) => self.shared.set_pipeline_lines(lines),
                Err(e) => {
                    // 不每拍刷日志:oms 不在场是合法态(清单里没选它,ask 走 TargetGone
                    // 快错)。只在「从有到无」那一次显形一条,与状态轮询「只读口不冲 eLog 环」
                    // 同口径。读数清空 → 运维窗那一节整节不画。
                    if !self.shared.pipeline_lines().is_empty() {
                        self.shared
                            .log_line(format!("[ui] oms.pipeline_status 失手: {e:?}"));
                    }
                    self.shared.set_pipeline_lines(Vec::new());
                }
            }
        }
    }

    /// 辞行指令队列(S2 svctl 操作面;回执进日志,面板语义可断言)。
    fn run_cmds(&self, ctx: &PluginContext) {
        for cmd in self.shared.drain_cmds() {
            match cmd {
                crate::state::UiCmd::Start { factory, name } => {
                    match ctx.ask_service::<StartReq, StartRes>(
                        SVC_START,
                        StartReq {
                            factory: factory.clone(),
                            name: name.clone(),
                        },
                        Duration::from_secs(3),
                    ) {
                        Ok(StartRes::Started { name }) => {
                            self.shared
                                .log_line(format!("[ops] svctl.start {factory} → {name} 上线"));
                        }
                        Ok(StartRes::Rejected { reason }) => {
                            self.shared
                                .log_line(format!("[ops] start {factory} 被拒: {reason}"));
                        }
                        Err(e) => {
                            self.shared
                                .log_line(format!("[ops] start {factory} 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::Remove { name } => {
                    // 观测面自身的闸(0.4.3 BD-UI-64,审核 P1):这条指令是在 ui 插件自己的
                    // worker 里执行的 —— 摘 ui = 自己等自己(ek-core `close_one` 只能走到
                    // 2 秒超时的 detach 分支),而且摘完就没有下一拍 eTimer 来执行任何指令,
                    // 窗口还开着但快照/日志/指令队列全停。所以在这里直拒,不发 svctl。
                    // 管制面 `svctl` 的同一道闸长在 ek-station supervisor 侧(0.2.11)。
                    if name == UI_NAME {
                        self.shared.log_line(
                            "[ops] 拒绝移除 ui:观测面自身不可自摘(摘掉后没有下一拍执行任何指令)"
                                .to_string(),
                        );
                        continue;
                    }
                    match ctx.ask_service::<RemoveReq, RemoveRes>(
                        SVC_REMOVE,
                        RemoveReq { name: name.clone() },
                        Duration::from_secs(3),
                    ) {
                        Ok(RemoveRes::Removed { name }) => {
                            self.shared
                                .log_line(format!("[ops] svctl.remove {name} 完成"));
                        }
                        Ok(RemoveRes::NoSuchName { name }) => {
                            self.shared
                                .log_line(format!("[ops] remove {name} 不存在/不可摘"));
                        }
                        // 0.4.3:回执枚举增项(ek-station 0.2.11)—— 名字在场但不可摘,
                        // 或宿主另有错。原先这一档被塞进 NoSuchName 的 name 栏(错误文本
                        // 当名字打),这一栏现在照请求回填,错因只进 reason。
                        Ok(RemoveRes::Rejected { name, reason }) => {
                            self.shared
                                .log_line(format!("[ops] remove {name} 被拒: {reason}"));
                        }
                        Err(e) => {
                            self.shared
                                .log_line(format!("[ops] remove {name} 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::Reload {
                    interval,
                    symbol,
                    bars,
                } => {
                    // 回灌走 dm.reload ask(push=true 逐条广播 → 行情板实时见回执面)。
                    match ctx.ask_service::<ReloadReq, usize>(
                        "dm.reload",
                        ReloadReq {
                            interval,
                            symbol: symbol.clone(),
                            bars: bars.clone(),
                            size: Some(bars.len()),
                            push: true,
                        },
                        Duration::from_secs(5),
                    ) {
                        Ok(n) => {
                            self.shared.market().note_reload();
                            self.shared.log_line(format!(
                                "[ops] dm.reload {symbol}@{interval}s 回灌 {n} 条"
                            ));
                        }
                        Err(e) => {
                            self.shared
                                .log_line(format!("[ops] dm.reload {symbol} 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::SendOrder { req, gateway, mode } => {
                    // 0.1.1 BD-UI-30 薄下单者:五段管线全走 oms.submit_order
                    // (拆单/风控/逐腿发送/记账;直发 {gw}.send_order 旁路口删除,
                    // 守卫不可绕过)。parent 聚合逐腿显形进日志。
                    match ctx.ask_service::<SubmitOrderReq, SubmitReply>(
                        "oms.submit_order",
                        SubmitOrderReq {
                            req: req.clone(),
                            gateway_name: gateway.clone(),
                            mode,
                        },
                        Duration::from_secs(10),
                    ) {
                        Ok(reply) => {
                            let tag = match reply.status {
                                SubmitStatus::Sent => "SENT",
                                SubmitStatus::Partial => "PARTIAL",
                                SubmitStatus::Rejected => "REJECTED",
                            };
                            for leg in &reply.legs {
                                match (leg.ok, &leg.en_orderid, &leg.reason) {
                                    (true, Some(id), _) => self.shared.log_line(format!(
                                        "[ops] submit {} {} {}x{} → {id} (parent {})",
                                        leg.req.symbol,
                                        leg.req.direction.as_str(),
                                        leg.req.offset.as_str(),
                                        leg.req.volume,
                                        reply.parent_id
                                    )),
                                    _ => self.shared.log_line(format!(
                                        "[ops] submit {} {} {}x{} 被拒: {} (parent {})",
                                        leg.req.symbol,
                                        leg.req.direction.as_str(),
                                        leg.req.offset.as_str(),
                                        leg.req.volume,
                                        leg.reason.as_deref().unwrap_or("?"),
                                        reply.parent_id
                                    )),
                                }
                            }
                            if reply.legs.is_empty() {
                                self.shared.log_line(format!(
                                    "[ops] submit {} {}x{} {tag}:可平不足零腿 (parent {})",
                                    req.symbol,
                                    req.offset.as_str(),
                                    req.volume,
                                    reply.parent_id
                                ));
                            }
                        }
                        Err(e) => {
                            self.shared
                                .log_line(format!("[ops] oms.submit_order 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::CancelOrder { orderid, gateway } => {
                    // 0.1.1 BD-UI-30:守卫撤单(尝试 ≤4000 在 oms;直发
                    // {gw}.cancel_order 旁路口删除)。en_orderid 组式与
                    // OrderData.en_orderid() 同式。
                    match ctx.ask_service::<OmsCancelOrderReq, OmsCancelReply>(
                        "oms.cancel_order",
                        OmsCancelOrderReq {
                            en_orderid: format!("{gateway}.{orderid}"),
                            gateway_name: gateway.clone(),
                        },
                        Duration::from_secs(10),
                    ) {
                        Ok(OmsCancelReply { ok: true, msg }) => {
                            self.shared.log_line(format!("[ops] {msg}"));
                        }
                        Ok(OmsCancelReply { ok: false, msg }) => {
                            self.shared.log_line(format!("[ops] 撤单被拒: {msg}"));
                        }
                        Err(e) => {
                            self.shared
                                .log_line(format!("[ops] oms.cancel_order 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::CtpConfigure { gateway, form } => {
                    // 定盘口径:界面手工输入 → 插件自带配置口(插件不读文件)。
                    // 多账号面:服务名随网关走(`{gw}.configure`),不再硬编码 ctp。
                    let svc = format!("{gateway}.configure");
                    match ctx.ask_service::<ConfigureReq, ConfigureReply>(
                        svc.as_str(),
                        form.to_configure_req(),
                        Duration::from_secs(5),
                    ) {
                        // `..`:ConfigureReply 0.6.0 起带 product_classes(实际生效值)。
                        // 这里不回填表单勾选 —— 被拒时回带的是「网关当前仍在跑」的那一份,
                        // 用它覆盖用户刚点的勾选会把他的意图吃掉;日志里网关已写明收录产品类。
                        Ok(ConfigureReply { ok: true, msg, .. }) => {
                            self.shared.log_line(format!("[ops] {svc} 受理:{msg}"));
                        }
                        Ok(ConfigureReply { ok: false, msg, .. }) => {
                            self.shared.log_line(format!("[ops] {svc} 被拒:{msg}"));
                        }
                        Err(e) => {
                            self.shared.log_line(format!("[ops] {svc} 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::Connect { gateway, form } => {
                    // **四态分离的「连接」**(规划裁定「添加 ≠ 连接」):一次做完
                    // `svctl.start(factory=ctp)` + `{gw}.configure`,结果回写账户行
                    // (`Assembling → Assembled / AssembleFailed` + 失败原因留显形)。
                    // 失败**不回滚清册行** —— 行留着给『重试』(旧口径"必须先移除才能重试"作废)。
                    self.shared.note_connect_sent(&gateway);
                    // 单源纪律在此裁决:非行情源账户的 md 位就地清空,**留档与下发同一份**
                    // (旧口径只清下发不清留档,编辑页回填会带着一根用不上的行情前置)。
                    let form = self.shared.prepare_connect_form(&gateway, form);
                    let started = match ctx.ask_service::<StartReq, StartRes>(
                        SVC_START,
                        StartReq {
                            factory: "ctp".to_string(),
                            name: gateway.clone(),
                        },
                        Duration::from_secs(3),
                    ) {
                        Ok(StartRes::Started { name }) => {
                            self.shared
                                .log_line(format!("[ops] svctl.start ctp → {name} 上线"));
                            true
                        }
                        Ok(StartRes::Rejected { reason }) => {
                            // 防重入(规划 Q7):实例已在场时重复点『连接』/『重试』不是失败,
                            // 重投凭据即可(否则会把正在跑的账户误判成"装配失败")。
                            if self.shared.account(&gateway).is_some_and(|a| a.connected) {
                                self.shared
                                    .log_line(format!("[ops] {gateway} 已在场,重投凭据: {reason}"));
                                true
                            } else {
                                self.shared
                                    .log_line(format!("[ops] {gateway} 装配被拒: {reason}"));
                                self.shared.note_connect_result(&gateway, Err(reason));
                                continue;
                            }
                        }
                        Err(e) => {
                            self.shared
                                .log_line(format!("[ops] {gateway} 装配失败: {e:?}"));
                            self.shared
                                .note_connect_result(&gateway, Err(format!("{e:?}")));
                            continue;
                        }
                    };
                    if !started {
                        continue;
                    }
                    let svc = format!("{gateway}.configure");
                    match ctx.ask_service::<ConfigureReq, ConfigureReply>(
                        svc.as_str(),
                        form.to_configure_req(),
                        Duration::from_secs(5),
                    ) {
                        // `..`:ConfigureReply 带的 product_classes(实际生效值)不回填勾选
                        // (被拒时回带的是「网关仍在跑」的那一份,覆盖用户刚点的勾选会吃掉意图);
                        // 0.2.18 起把它显示出来(见 state::note_effective_product_classes)。
                        Ok(ConfigureReply {
                            ok: true,
                            msg,
                            product_classes,
                        }) => {
                            self.shared.log_line(format!("[ops] {svc} 受理:{msg}"));
                            self.shared
                                .note_effective_product_classes(&gateway, &product_classes);
                            self.shared.note_connect_result(&gateway, Ok(()));
                        }
                        Ok(ConfigureReply { ok: false, msg, .. }) => {
                            self.shared.log_line(format!("[ops] {svc} 被拒:{msg}"));
                            self.shared.note_connect_result(&gateway, Err(msg));
                        }
                        Err(e) => {
                            self.shared.log_line(format!("[ops] {svc} 失败: {e:?}"));
                            self.shared
                                .note_connect_result(&gateway, Err(format!("{e:?}")));
                        }
                    }
                }
                crate::state::UiCmd::CtpSubscribe { gateway, symbols } => {
                    // 多账号面:一律路由到行情元账号(渲染侧已按此入列);
                    // 纯 TD 账号收到订阅会**静默成功**(do_subscribe 恒 ok:true),
                    // 所以路由正确性靠界面纪律,不靠网关报错(规划 §9.4-21)。
                    let svc = format!("{gateway}.subscribe");
                    match ctx.ask_service::<CtpSubscribeReq, CtpSubscribeReply>(
                        svc.as_str(),
                        CtpSubscribeReq {
                            symbols: symbols.clone(),
                        },
                        Duration::from_secs(5),
                    ) {
                        Ok(CtpSubscribeReply { ok: true, msg }) => {
                            self.shared.note_subscriptions(&symbols);
                            self.shared.log_line(format!(
                                "[ops] {svc} {} 受理:{}",
                                symbols.join(","),
                                msg
                            ));
                        }
                        Ok(CtpSubscribeReply { ok: false, msg }) => {
                            self.shared.log_line(format!(
                                "[ops] {svc} {} 被拒:{}",
                                symbols.join(","),
                                msg
                            ));
                        }
                        Err(e) => {
                            self.shared.log_line(format!("[ops] {svc} 失败: {e:?}"));
                        }
                    }
                }
                crate::state::UiCmd::Disconnect { gateway } => {
                    // 0.2.19 规划裁定 1:『断开』= `{gw}.disconnect`(停会话),
                    // 『移除』= `svctl.remove`(停实例)—— 两条走两条不同的口,不共用。
                    // 发令即把该行标成「已断开」:用户按了钮就要立刻看到,不等下一轮轮询。
                    let svc = format!("{gateway}.disconnect");
                    match ctx.ask_service::<DisconnectReq, DisconnectReply>(
                        svc.as_str(),
                        DisconnectReq,
                        Duration::from_secs(5),
                    ) {
                        Ok(DisconnectReply { ok: true, msg }) => {
                            self.shared.mark_account_stopped(&gateway);
                            self.shared
                                .log_line(format!("[账户] 断开 {gateway}:{msg}(实例仍在场)"));
                        }
                        Ok(DisconnectReply { ok: false, msg }) => {
                            self.shared
                                .log_line(format!("[账户] 断开 {gateway} 未执行:{msg}"));
                        }
                        Err(e) => {
                            self.shared.log_line(format!(
                                "[账户] 断开 {gateway} 失败:{e:?}(网关不在场或超时)",
                            ));
                        }
                    }
                }
            }
        }
    }
}

impl Plugin for UiPlugin {
    fn name(&self) -> &str {
        UI_NAME
    }

    fn deps(&self) -> &[&str] {
        &[] // 纯观测;谁先上都能看到(bus 契约不依赖启动序)
    }

    fn routes(&self) -> Vec<std::borrow::Cow<'static, str>> {
        vec![
            std::borrow::Cow::Borrowed(EVENT_LOG),
            std::borrow::Cow::Borrowed(EVENT_PLUG_UP),
            std::borrow::Cow::Borrowed(EVENT_PLUG_DOWN),
            std::borrow::Cow::Borrowed(EVENT_BAR),
            std::borrow::Cow::Borrowed(EVENT_BAR_UPDATE),
            std::borrow::Cow::Borrowed(EVENT_TICK),
            std::borrow::Cow::Borrowed(EVENT_CONTRACT),
            std::borrow::Cow::Borrowed("eContractFinish"),
            std::borrow::Cow::Borrowed(EVENT_TIMER),
        ]
    }

    fn mailbox_cap(&self) -> usize {
        1024
    }

    fn version(&self) -> std::borrow::Cow<'static, str> {
        std::borrow::Cow::Borrowed(env!("CARGO_PKG_VERSION"))
    }

    fn services(&self) -> Vec<ServiceDesc> {
        Vec::new() // 纯视图零服务;管制面在 svctl
    }

    fn on_init(&self, ctx: &PluginContext) {
        let _ = self.ctx.set(ctx.clone());
    }

    fn on_start(&self) {
        self.shared.log_line("[ui] 界面插件上线");
    }

    fn on_stop(&self) {
        self.shared.log_line("[ui] 界面插件下线");
    }

    fn on_mail(&self, event: &ek_event::Event) {
        let ty = event.event_type.as_str();
        if ty == EVENT_LOG {
            if let Some(d) = event.data.downcast_ref::<LogData>() {
                let tag = if d.is_warning_or_above() {
                    "WARN"
                } else {
                    "INFO"
                };
                self.shared
                    .log_line(format!("[{tag}][{}] {}", d.gateway_name, d.msg));
            } else {
                self.shared.log_line("[eLog] 载荷类型异常(非 LogData)");
            }
            return;
        }
        if ty == EVENT_PLUG_UP || ty == EVENT_PLUG_DOWN {
            if let Some(n) = event.data.downcast_ref::<PlugNotice>() {
                let verb = if ty == EVENT_PLUG_UP {
                    "上线"
                } else {
                    "下线"
                };
                self.shared
                    .log_line(format!("[host] 插件{verb} {} v{}", n.name, n.version));
            }
            self.shared.bump();
            return;
        }
        if ty == EVENT_BAR {
            if let Some(f) = event.data.downcast_ref::<ek_dm::wire::BarsFrame>() {
                self.shared.market().on_frame(f);
            }
            self.shared.bump();
            return;
        }
        if ty == EVENT_BAR_UPDATE {
            if let Some(b) = event.data.downcast_ref::<ek_data::bar::BarData>() {
                self.shared.market().on_update(b);
            }
            self.shared.bump();
            return;
        }
        if ty == EVENT_TICK {
            if let Some(t) = event.data.downcast_ref::<ek_data::tick::TickData>() {
                self.shared.update_tick(t);
            }
            return;
        }
        if ty == EVENT_CONTRACT {
            if let Some(c) = event.data.downcast_ref::<ek_data::contract::ContractData>() {
                self.shared.update_contract(c);
            }
            return;
        }
        if ty == "eContractFinish" {
            let gw = event
                .data
                .downcast_ref::<String>()
                .cloned()
                .unwrap_or_else(|| "?".to_string());
            self.shared
                .log_line(format!("[ctp] 合约流完成 {gw}(查询合约窗可勾选订阅)"));
            return;
        }
        if ty == EVENT_TIMER {
            self.refresh();
        }
    }
}