feat: expose per-actor metrics through runtime API

Gap analysis item 4.6: Add messages_sent, messages_received,
input/output_queue_depth, state, gpu_launched fields to KernelMetrics.

- Add kernel_metrics() to RingKernelRuntime trait (default impl via get_kernel)
- Populate metrics from control block in all 4 backends:
  CPU, CUDA, WebGPU, Metal
- CUDA reads gpu_launched flag and message counters
- All backends populate queue depths and lifecycle state

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mivertowski

crates/ringkernel-core/src/runtime.rs

@@ -387,6 +387,16 @@ pub trait RingKernelRuntime: Send + Sync {
     /// Get runtime metrics.
     fn metrics(&self) -> RuntimeMetrics;
 
+    /// Get per-kernel metrics for a specific kernel.
+    ///
+    /// Returns detailed metrics for the kernel identified by `kernel_id`,
+    /// including message counts, queue depths, uptime, state, and whether
+    /// the kernel is GPU-launched. Returns `None` if the kernel is not found.
+    fn kernel_metrics(&self, kernel_id: &KernelId) -> Option<KernelMetrics> {
+        // Default: look up the kernel handle and delegate to its metrics()
+        self.get_kernel(kernel_id).map(|handle| handle.metrics())
+    }
+
     /// Shutdown the runtime and terminate all kernels.
     async fn shutdown(&self) -> Result<()>;
 }

crates/ringkernel-core/src/telemetry.rs

@@ -134,6 +134,24 @@ pub struct KernelMetrics {
 
     /// Host memory usage in bytes.
     pub host_memory_used: u64,
+
+    /// Total messages sent to this kernel.
+    pub messages_sent: u64,
+
+    /// Total messages received from this kernel.
+    pub messages_received: u64,
+
+    /// Current number of messages in the input queue.
+    pub input_queue_depth: usize,
+
+    /// Current number of messages in the output queue.
+    pub output_queue_depth: usize,
+
+    /// Current kernel state.
+    pub state: crate::runtime::KernelState,
+
+    /// Whether the kernel has been launched on the GPU.
+    pub gpu_launched: bool,
 }
 
 impl Default for KernelMetrics {
@@ -148,6 +166,12 @@ impl Default for KernelMetrics {
             bytes_from_device: 0,
             gpu_memory_used: 0,
             host_memory_used: 0,
+            messages_sent: 0,
+            messages_received: 0,
+            input_queue_depth: 0,
+            output_queue_depth: 0,
+            state: crate::runtime::KernelState::Created,
+            gpu_launched: false,
         }
     }
 }

crates/ringkernel-cpu/src/kernel.rs

@@ -328,6 +328,9 @@ impl KernelHandleInner for CpuKernel {
 
     fn metrics(&self) -> KernelMetrics {
         let telemetry = *self.telemetry.read();
+        let state = *self.state.read();
+        let messages_sent = self.message_counter.load(Ordering::Relaxed);
+        let control = self.control.read();
         KernelMetrics {
             telemetry,
             kernel_id: self.id.to_string(),
@@ -338,6 +341,12 @@ impl KernelHandleInner for CpuKernel {
             bytes_from_device: 0,
             gpu_memory_used: 0,
             host_memory_used: 0,
+            messages_sent,
+            messages_received: control.messages_processed,
+            input_queue_depth: self.input_queue.len(),
+            output_queue_depth: self.output_queue.len(),
+            state,
+            gpu_launched: false, // CPU backend is never GPU-launched
         }
     }
 

crates/ringkernel-cuda/src/kernel.rs

@@ -374,7 +374,18 @@ impl KernelHandleInner for CudaKernel {
     }
 
     fn metrics(&self) -> KernelMetrics {
-        self.metrics.read().clone()
+        let mut metrics = self.metrics.read().clone();
+        let state = *self.state.read();
+        let cb = self.control_block.read().read().unwrap_or_default();
+        metrics.kernel_id = self.id.to_string();
+        metrics.uptime = self.created_at.elapsed();
+        metrics.messages_sent = self.message_counter.load(Ordering::Relaxed);
+        metrics.messages_received = cb.messages_processed;
+        metrics.input_queue_depth = cb.input_queue_size() as usize;
+        metrics.output_queue_depth = cb.output_queue_size() as usize;
+        metrics.state = state;
+        metrics.gpu_launched = self.gpu_launched.load(Ordering::Relaxed);
+        metrics
     }
 
     async fn activate(&self) -> Result<()> {

crates/ringkernel-metal/src/kernel.rs

@@ -763,7 +763,18 @@ impl KernelHandleInner for MetalKernel {
     }
 
     fn metrics(&self) -> KernelMetrics {
-        self.metrics.read().clone()
+        let mut metrics = self.metrics.read().clone();
+        let state = *self.state.read();
+        let cb = self.read_control_block();
+        metrics.kernel_id = self.id.to_string();
+        metrics.uptime = self.created_at.elapsed();
+        metrics.messages_sent = self.message_counter.load(Ordering::Relaxed);
+        metrics.messages_received = cb.messages_processed();
+        metrics.input_queue_depth = cb.input_queue_size() as usize;
+        metrics.output_queue_depth = cb.output_queue_size() as usize;
+        metrics.state = state;
+        metrics.gpu_launched = false; // Metal is event-driven
+        metrics
     }
 
     async fn activate(&self) -> Result<()> {

crates/ringkernel-wgpu/src/kernel.rs

@@ -187,7 +187,18 @@ impl KernelHandleInner for WgpuKernel {
     }
 
     fn metrics(&self) -> KernelMetrics {
-        self.metrics.read().clone()
+        let mut metrics = self.metrics.read().clone();
+        let state = *self.state.read();
+        let cb = self.control_block.read().read().unwrap_or_default();
+        metrics.kernel_id = self.id.to_string();
+        metrics.uptime = self.created_at.elapsed();
+        metrics.messages_sent = self.message_counter.load(Ordering::Relaxed);
+        metrics.messages_received = cb.messages_processed;
+        metrics.input_queue_depth = cb.input_queue_size() as usize;
+        metrics.output_queue_depth = cb.output_queue_size() as usize;
+        metrics.state = state;
+        metrics.gpu_launched = false; // WebGPU is event-driven, not persistently launched
+        metrics
     }
 
     async fn activate(&self) -> Result<()> {