IPC and A2A Messaging

pub struct KernelMessage {
    pub id: String,
    pub from: Pid,
    pub target: MessageTarget,
    pub payload: MessagePayload,
    pub correlation_id: Option<String>,
    pub timestamp: DateTime<Utc>,
}

pub enum MessageTarget {
    /// Send to a specific process by PID.
    Process(Pid),
    /// Publish to a named topic (all subscribers receive).
    Topic(String),
    /// Broadcast to all processes.
    Broadcast,
    /// Send to a named service (routed via ServiceRegistry).
    Service(String),
    /// Send to a specific method on a named service (K2.1, D19).
    ServiceMethod { service: String, method: String },
    /// Send to the kernel itself.
    Kernel,
    /// Route to a specific process on a remote node (K6).
    RemoteNode { node_id: String, target: Box<MessageTarget> },
}

pub enum MessagePayload {
    Text(String),
    Json(serde_json::Value),
    ToolCall { name: String, args: serde_json::Value },
    ToolResult { call_id: String, result: serde_json::Value },
    Signal(KernelSignal),
    Rvf { segment_type: u8, data: Vec<u8> },
}

pub enum KernelSignal {
    Shutdown, Suspend, Resume, Custom(String),
}

Agent A                                              Agent B
  |                                                    |
  | send(msg)                                          |
  |-------> A2ARouter                                  |
  |           |                                        |
  |           | 1. Resolve target                      |
  |           |    Process(pid) -> look up inbox        |
  |           |    Service(name) -> resolve via registry|
  |           |    Topic(name) -> fan out to subs       |
  |           |    Broadcast -> all inboxes             |
  |           |    RemoteNode -> mesh transport (K6)    |
  |           |                                        |
  |           | 2. Capability check (send_checked)      |
  |           |    Validate sender IpcScope             |
  |           |                                        |
  |           | 3. [exochain] Routing gate check        |
  |           |    GovernanceGate::check()              |
  |           |    Deny -> error to sender              |
  |           |                                        |
  |           | 4. Deliver to inbox                     |
  |           +--------------------------------------> |
  |                                                    |
  |           reply(correlation_id)                     |
  |<----------------------------------------------------

impl A2ARouter {
    pub fn new() -> Self;
    pub fn register(&self, pid: Pid, sender: mpsc::Sender<KernelMessage>);
    pub fn unregister(&self, pid: Pid);
    pub fn send(&self, msg: KernelMessage) -> Result<(), IpcError>;
    pub fn send_checked(&self, msg: KernelMessage, caps: &AgentCapabilities)
        -> Result<(), IpcError>;
    pub fn broadcast(&self, msg: KernelMessage) -> usize;
}

pub struct GlobalPid {
    pub node_id: String,
    pub pid: Pid,
}
// Display format: "node_id:pid" (e.g., "abc123:42")

impl TopicRouter {
    pub fn subscribe(&self, topic: &str, subscriber_id: Pid) -> Subscription;
    pub fn unsubscribe(&self, subscription_id: &str);
    pub fn publish(&self, topic: &str, message: KernelMessage) -> usize;
    pub fn list_topics(&self) -> Vec<String>;
}