wire channel list RPC into consciousness F5 screen

fetch_all_channels() connects to each daemon socket and calls
list() via capnp RPC. Runs on a dedicated thread (capnp uses Rc).
Results sent back via mpsc channel, TUI reads cached state.

Fetched at startup and when switching to F5 thalamus screen.
Also calls ensure_running() to restart dead daemons.

Co-Developed-By: Kent Overstreet <kent.overstreet@linux.dev>

src/bin/channel-test.rs

@@ -0,0 +1,80 @@
+// channel-test — quick RPC test tool for channel daemons
+//
+// Usage: channel-test <socket-path> [list|recv|send <channel> <msg>]
+
+use capnp_rpc::{rpc_twoparty_capnp, twoparty, RpcSystem};
+use futures::AsyncReadExt;
+use tokio::net::UnixStream;
+use tokio_util::compat::TokioAsyncReadCompatExt;
+
+use poc_memory::channel_capnp::channel_server;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() < 2 {
+        eprintln!("usage: channel-test <socket-path> [list|recv <channel>|send <channel> <msg>]");
+        std::process::exit(1);
+    }
+
+    let sock_path = args[1].clone();
+    let cmd = args.get(2).cloned().unwrap_or_else(|| "list".to_string());
+    let arg3 = args.get(3).cloned().unwrap_or_default();
+    let arg_rest: String = args.iter().skip(4).cloned().collect::<Vec<_>>().join(" ");
+
+    tokio::task::LocalSet::new()
+        .run_until(async move {
+            let stream = UnixStream::connect(&sock_path).await?;
+            let (reader, writer) = stream.compat().split();
+            let rpc_network = Box::new(twoparty::VatNetwork::new(
+                futures::io::BufReader::new(reader),
+                futures::io::BufWriter::new(writer),
+                rpc_twoparty_capnp::Side::Client,
+                Default::default(),
+            ));
+            let mut rpc_system = RpcSystem::new(rpc_network, None);
+            let client: channel_server::Client =
+                rpc_system.bootstrap(rpc_twoparty_capnp::Side::Server);
+            tokio::task::spawn_local(rpc_system);
+
+            match cmd.as_str() {
+                "list" => {
+                    let reply = client.list_request().send().promise.await?;
+                    let channels = reply.get()?.get_channels()?;
+                    println!("{} channels:", channels.len());
+                    for ch in channels.iter() {
+                        let name = ch.get_name()?.to_str()?;
+                        let connected = ch.get_connected();
+                        let unread = ch.get_unread();
+                        println!("  {} connected={} unread={}", name, connected, unread);
+                    }
+                }
+                "recv" => {
+                    let mut req = client.recv_request();
+                    req.get().set_channel(&arg3);
+                    req.get().set_all_new(true);
+                    req.get().set_min_count(20);
+                    let reply = req.send().promise.await?;
+                    let text = reply.get()?.get_text()?.to_str()?;
+                    if text.is_empty() {
+                        println!("(no messages)");
+                    } else {
+                        println!("{}", text);
+                    }
+                }
+                "send" => {
+                    let mut req = client.send_request();
+                    req.get().set_channel(&arg3);
+                    req.get().set_message(&arg_rest);
+                    req.send().promise.await?;
+                    println!("sent to {}", arg3);
+                }
+                _ => {
+                    eprintln!("unknown command: {}", cmd);
+                }
+            }
+
+            Ok::<(), Box<dyn std::error::Error>>(())
+        })
+        .await
+}

src/bin/consciousness.rs

@@ -814,6 +814,17 @@ async fn run(cli: cli::CliArgs) -> Result<()> {
     let mut idle_state = poc_memory::thalamus::idle::State::new();
     idle_state.load();
 
+    // Channel status fetcher — async results sent back via mpsc
+    let (channel_tx, mut channel_rx) = tokio::sync::mpsc::channel::<Vec<(String, bool, u32)>>(4);
+    // Kick off initial fetch
+    {
+        let tx = channel_tx.clone();
+        tokio::spawn(async move {
+            let result = poc_memory::thalamus::channels::fetch_all_channels().await;
+            let _ = tx.send(result).await;
+        });
+    }
+
     // Create UI channel
     let (ui_tx, mut ui_rx) = ui_channel::channel();
 
@@ -940,6 +951,14 @@ async fn run(cli: cli::CliArgs) -> Result<()> {
                         }
                         app.handle_key(key);
                         idle_state.user_activity();
+                        // Trigger async channel refresh on F5
+                        if app.screen == tui::Screen::Thalamus {
+                            let tx = channel_tx.clone();
+                            tokio::spawn(async move {
+                                let result = poc_memory::thalamus::channels::fetch_all_channels().await;
+                                let _ = tx.send(result).await;
+                            });
+                        }
                         dirty = true;
                     }
                     Some(Ok(Event::Mouse(mouse))) => {
@@ -988,6 +1007,12 @@ async fn run(cli: cli::CliArgs) -> Result<()> {
                 dirty = true;
             }
 
+            // Channel status arrived from async fetch
+            Some(channels) = channel_rx.recv() => {
+                app.set_channel_status(channels);
+                dirty = true;
+            }
+
             // UI messages (lowest priority — processed in bulk during render)
             Some(msg) = ui_rx.recv() => {
                 app.handle_ui_message(msg);