@tryinget/pi-activity-strip 0.5.0 → 0.6.0

package/native/panel/src/card_view.rs

@@ -1,10 +1,15 @@
 use crate::app::AppMsg;
-use crate::protocol::Card;
+use crate::protocol::{AkTask, Card};
 use relm4::Sender;
 use relm4::gtk;
 use relm4::gtk::gdk;
 use relm4::gtk::glib;
 use relm4::gtk::prelude::*;
+use std::cell::Cell;
+use std::rc::Rc;
+
+/// Rendered AK chips per card: at most two live-claim buttons plus two state badges.
+const AK_CHIP_SLOTS: usize = 4;
 
 pub struct CardView {
     pub root: gtk::Button,
@@ -17,8 +22,15 @@ pub struct CardView {
     prompt: gtk::Label,
     reply: gtk::Label,
     path: gtk::Label,
+    pid: gtk::Label,
+    agent: gtk::Label,
+    task: gtk::Label,
     activation: gtk::Label,
     inspector: gtk::Grid,
+    ak_row: gtk::Box,
+    ak_chips: Vec<gtk::Label>,
+    ak_clickable: Vec<Rc<Cell<bool>>>,
+    ak_overflow: gtk::Label,
 }
 
 impl CardView {
@@ -38,8 +50,12 @@ impl CardView {
         let phase = label("card-phase", gtk::Align::Start);
         label_box.append(&repo);
         label_box.append(&phase);
+        let ak_row = gtk::Box::new(gtk::Orientation::Horizontal, 4);
+        ak_row.set_valign(gtk::Align::Center);
+        ak_row.set_visible(false);
         let state = label("card-state", gtk::Align::End);
         header.append(&label_box);
+        header.append(&ak_row);
         header.append(&state);
 
         let footer = gtk::Box::new(gtk::Orientation::Horizontal, 8);
@@ -60,9 +76,12 @@ impl CardView {
         let prompt = inspector_row(&inspector, 1, "prompt");
         let reply = inspector_row(&inspector, 2, "reply");
         let path = inspector_row(&inspector, 3, "path");
+        let pid = inspector_row(&inspector, 4, "pid");
+        let agent = inspector_row(&inspector, 5, "agent");
+        let task = inspector_row(&inspector, 6, "task");
         let activation = label("activation", gtk::Align::Start);
         activation.set_visible(false);
-        inspector.attach(&activation, 0, 4, 2, 1);
+        inspector.attach(&activation, 0, 7, 2, 1);
 
         content.append(&header);
         content.append(&footer);
@@ -75,6 +94,36 @@ impl CardView {
             let _ = tx.send(AppMsg::Activate(card_id.clone()));
         });
 
+        // AK task chips: an `active` chip reuses the card's own activation, so clicking it focuses
+        // the exact Ghostty window of the session holding that task's live claim. Badge states stop
+        // propagation instead, so a non-actionable reference never fires anything.
+        let mut ak_chips = Vec::with_capacity(AK_CHIP_SLOTS);
+        let mut ak_clickable = Vec::with_capacity(AK_CHIP_SLOTS);
+        for _slot in 0..AK_CHIP_SLOTS {
+            let chip = label("ak-task", gtk::Align::End);
+            chip.set_ellipsize(relm4::gtk::pango::EllipsizeMode::End);
+            chip.set_max_width_chars(20);
+            chip.set_visible(false);
+            let clickable = Rc::new(Cell::new(false));
+            let click = gtk::GestureClick::new();
+            let card_id = id.to_owned();
+            let tx = sender.clone();
+            let chip_clickable = Rc::clone(&clickable);
+            click.connect_released(move |gesture, _, _, _| {
+                if chip_clickable.get() {
+                    let _ = tx.send(AppMsg::Activate(card_id.clone()));
+                }
+                gesture.set_state(gtk::EventSequenceState::Claimed);
+            });
+            chip.add_controller(click);
+            ak_row.append(&chip);
+            ak_chips.push(chip);
+            ak_clickable.push(clickable);
+        }
+        let ak_overflow = label("ak-overflow", gtk::Align::End);
+        ak_overflow.set_visible(false);
+        ak_row.append(&ak_overflow);
+
         let motion = gtk::EventControllerMotion::new();
         let card_id = id.to_owned();
         let tx = sender.clone();
@@ -134,12 +183,20 @@ impl CardView {
             prompt,
             reply,
             path,
+            pid,
+            agent,
+            task,
             activation,
             inspector,
+            ak_row,
+            ak_chips,
+            ak_clickable,
+            ak_overflow,
         }
     }
 
     pub fn update(&self, card: &Card, focused: bool, duplicate_label: bool, now_ms: i64) {
+        let hidden_tab = card.hidden_tab();
         self.repo.set_text(&display_repo(card, duplicate_label));
         self.phase.set_text(text_or(&card.phase, "Idle"));
         let real_event_at = if card.last_event_at > 0 {
@@ -171,6 +228,12 @@ impl CardView {
             .set_text(text_or(&card.last_prompt_preview, "—"));
         self.reply.set_text(text_or(&card.assistant_preview, "—"));
         self.path.set_text(text_or(&card.cwd, "—"));
+        self.pid.set_text(&pid_row(card, hidden_tab));
+        self.agent
+            .set_text(text_or(&card.agent_label, "Pi session"));
+        self.task
+            .set_text(&ak_inspector_text(&card.ak_tasks, card.ak_task_overflow));
+        self.apply_ak_tasks(card);
 
         for class in [
             "state-idle",
@@ -181,9 +244,13 @@ impl CardView {
             "state-error",
             "current",
             "stalled",
+            "hidden-tab",
         ] {
             self.root.remove_css_class(class);
         }
+        if hidden_tab {
+            self.root.add_css_class("hidden-tab");
+        }
         self.root.add_css_class(&format!(
             "state-{}",
             if stalled {
@@ -198,18 +265,34 @@ impl CardView {
         if stalled {
             self.root.add_css_class("stalled");
         }
+        let pid_note = if card.pid > 0 {
+            format!("pid {}", card.pid)
+        } else {
+            "no pid".to_owned()
+        };
+        let ak_note = ak_accessible_note(&card.ak_tasks);
         self.root.set_tooltip_text(Some(&format!(
-            "Focus {}",
-            text_or(&card.repo_label, "Pi session")
+            "{} {} ({}{}){}",
+            if hidden_tab { "Present" } else { "Focus" },
+            text_or(&card.repo_label, "Pi session"),
+            pid_note,
+            if hidden_tab { ", hidden tab" } else { "" },
+            ak_note
         )));
         let accessible_label = format!(
-            "{}, {}, press Enter to focus its Ghostty window",
+            "{}, {}, {}{}",
             text_or(&card.repo_label, "Pi session"),
             if stalled {
                 "stalled"
             } else {
                 text_or(&card.phase, "idle")
-            }
+            },
+            if hidden_tab {
+                "hidden tab, press Enter to present it in its Ghostty window"
+            } else {
+                "press Enter to focus its Ghostty window"
+            },
+            ak_note
         );
         self.root
             .update_property(&[gtk::accessible::Property::Label(&accessible_label)]);
@@ -217,11 +300,45 @@ impl CardView {
             .update_state(&[gtk::accessible::State::Selected(Some(focused))]);
     }
 
+    fn apply_ak_tasks(&self, card: &Card) {
+        let chips = &card.ak_tasks;
+        for (index, chip) in self.ak_chips.iter().enumerate() {
+            let clickable = self.ak_clickable.get(index).map(Rc::as_ref);
+            match (chips.get(index), clickable) {
+                (Some(task), Some(flag)) => {
+                    chip.set_visible(true);
+                    chip.set_text(&ak_chip_text(task));
+                    for class in ["ak-active", "ak-deferred", "ak-orphaned"] {
+                        chip.remove_css_class(class);
+                    }
+                    chip.add_css_class(ak_chip_class(&task.state));
+                    chip.set_tooltip_text(Some(&ak_chip_tooltip(task)));
+                    flag.set(task.is_active());
+                }
+                _ => {
+                    chip.set_visible(false);
+                    chip.set_tooltip_text(None);
+                    if let Some(flag) = clickable {
+                        flag.set(false);
+                    }
+                }
+            }
+        }
+        self.ak_row.set_visible(!chips.is_empty());
+        if card.ak_task_overflow > 0 {
+            self.ak_overflow.set_visible(true);
+            self.ak_overflow
+                .set_text(&format!("+{} more", card.ak_task_overflow));
+        } else {
+            self.ak_overflow.set_visible(false);
+        }
+    }
+
     pub fn set_expanded(&self, expanded: bool) {
         self.root
             .update_state(&[gtk::accessible::State::Expanded(Some(expanded))]);
         self.root
-            .set_height_request(if expanded { 228 } else { 60 });
+            .set_height_request(if expanded { 252 } else { 60 });
         self.inspector.set_visible(expanded);
         if expanded {
             self.root.add_css_class("open");
@@ -267,14 +384,29 @@ fn inspector_row(grid: &gtk::Grid, row: i32, key: &str) -> gtk::Label {
 }
 
 fn display_repo(card: &Card, duplicate: bool) -> String {
+    let marker = if card.hidden_tab() { "⧉ " } else { "" };
     if duplicate && card.pid > 0 {
         format!(
-            "{} · {:04}",
+            "{}{} · {:04}",
+            marker,
             text_or(&card.repo_label, "Pi session"),
             card.pid % 10_000
         )
     } else {
-        text_or(&card.repo_label, "Pi session").to_owned()
+        format!("{}{}", marker, text_or(&card.repo_label, "Pi session"))
+    }
+}
+
+fn pid_row(card: &Card, hidden_tab: bool) -> String {
+    let pid = if card.pid > 0 {
+        card.pid.to_string()
+    } else {
+        "—".to_owned()
+    };
+    if hidden_tab {
+        format!("{pid} · hidden tab")
+    } else {
+        pid
     }
 }
 
@@ -293,6 +425,81 @@ fn state_class(state: &str) -> &str {
     }
 }
 
+/// CSS class for one AK chip state. Unknown states render as a muted, non-clickable chip.
+fn ak_chip_class(state: &str) -> &'static str {
+    match state {
+        "active" => "ak-active",
+        "deferred" => "ak-deferred",
+        "orphaned" => "ak-orphaned",
+        _ => "ak-unknown",
+    }
+}
+
+/// Compact chip text: task id plus as much title as the pill can hold.
+fn ak_chip_text(task: &AkTask) -> String {
+    format!("AK #{} · {}", task.id, task.title)
+}
+
+fn ak_chip_tooltip(task: &AkTask) -> String {
+    match task.state.as_str() {
+        "active" => format!(
+            "AK task #{} — {}. Click to focus the claiming session's Ghostty window.",
+            task.id, task.title
+        ),
+        "orphaned" => format!(
+            "AK task #{} — {}. Claim outlives its session (lease not expired); not clickable.",
+            task.id, task.title
+        ),
+        "deferred" => format!(
+            "AK task #{} — {}. Deferred by AK; not clickable.",
+            task.id, task.title
+        ),
+        _ => format!("AK task #{} — {}", task.id, task.title),
+    }
+}
+
+/// Inspector row: every joined reference with its state, plus the overflow count.
+fn ak_inspector_text(tasks: &[AkTask], overflow: u32) -> String {
+    if tasks.is_empty() && overflow == 0 {
+        return "—".to_owned();
+    }
+    let mut lines: Vec<String> = tasks
+        .iter()
+        .map(|task| {
+            format!(
+                "#{} [{}] {}",
+                task.id,
+                match task.state.as_str() {
+                    "active" => "live claim",
+                    "orphaned" => "claim outlives session",
+                    "deferred" => "deferred",
+                    _ => "unknown",
+                },
+                task.title
+            )
+        })
+        .collect();
+    if overflow > 0 {
+        lines.push(format!("+{overflow} more"));
+    }
+    lines.join("\n")
+}
+
+/// Appended to the card's tooltip and accessible label when AK references exist.
+fn ak_accessible_note(tasks: &[AkTask]) -> String {
+    match tasks.first() {
+        Some(task) if task.is_active() => format!(
+            ". AK task #{} {} (click the chip to focus the claiming session)",
+            task.id, task.title
+        ),
+        Some(task) => format!(
+            ". AK task #{} {} (badge only, not clickable)",
+            task.id, task.title
+        ),
+        None => String::new(),
+    }
+}
+
 fn text_or<'a>(value: &'a str, fallback: &'a str) -> &'a str {
     if value.is_empty() { fallback } else { value }
 }
@@ -301,3 +508,95 @@ fn duration(now_ms: i64, anchor_ms: i64) -> String {
     let seconds = now_ms.saturating_sub(anchor_ms.max(1)) / 1000;
     format!("{}:{:02}", seconds / 60, seconds % 60)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn card(json: serde_json::Value) -> Card {
+        serde_json::from_value(json).expect("card")
+    }
+
+    #[test]
+    fn hidden_tabs_carry_a_marker_and_pid_note() {
+        let agent = card(serde_json::json!({ "agentLabel": "Claude Code" }));
+        assert_eq!(agent.agent_label, "Claude Code");
+        assert_eq!(text_or(&agent.agent_label, "Pi session"), "Claude Code");
+        assert_eq!(
+            text_or(&card(serde_json::json!({})).agent_label, "Pi session"),
+            "Pi session"
+        );
+
+        let hidden = card(serde_json::json!({
+            "repoLabel": "dspx", "processId": 12345, "surfaceVisible": false
+        }));
+        assert!(hidden.hidden_tab());
+        assert_eq!(display_repo(&hidden, false), "⧉ dspx");
+        assert_eq!(display_repo(&hidden, true), "⧉ dspx · 2345");
+        assert_eq!(pid_row(&hidden, true), "12345 · hidden tab");
+
+        let visible = card(serde_json::json!({ "repoLabel": "dspx", "surfaceVisible": true }));
+        assert!(!visible.hidden_tab());
+        assert_eq!(display_repo(&visible, false), "dspx");
+        assert_eq!(pid_row(&visible, false), "—");
+
+        let legacy = card(serde_json::json!({ "repoLabel": "dspx" }));
+        assert!(
+            !legacy.hidden_tab(),
+            "controllers without placement never mark tabs hidden"
+        );
+    }
+
+    #[test]
+    fn ak_chip_states_map_to_classes_and_only_active_is_clickable() {
+        let active = AkTask {
+            id: 5701,
+            title: "Show clickable AK-task references".into(),
+            state: "active".into(),
+        };
+        let orphaned = AkTask {
+            state: "orphaned".into(),
+            ..active.clone()
+        };
+        let deferred = AkTask {
+            state: "deferred".into(),
+            ..active.clone()
+        };
+        assert_eq!(ak_chip_class("active"), "ak-active");
+        assert_eq!(ak_chip_class("orphaned"), "ak-orphaned");
+        assert_eq!(ak_chip_class("deferred"), "ak-deferred");
+        assert_eq!(ak_chip_class("surprise"), "ak-unknown");
+        assert!(active.is_active());
+        assert!(!orphaned.is_active());
+        assert!(!deferred.is_active());
+        assert_eq!(
+            ak_chip_text(&active),
+            "AK #5701 · Show clickable AK-task references"
+        );
+        assert!(ak_chip_tooltip(&orphaned).contains("not clickable"));
+        assert!(ak_chip_tooltip(&active).contains("focus the claiming session"));
+    }
+
+    #[test]
+    fn ak_inspector_lists_every_reference_with_overflow() {
+        let tasks = vec![
+            AkTask {
+                id: 5701,
+                title: "Live claim task".into(),
+                state: "active".into(),
+            },
+            AkTask {
+                id: 4220,
+                title: "Deferred task".into(),
+                state: "deferred".into(),
+            },
+        ];
+        let text = ak_inspector_text(&tasks, 3);
+        assert!(text.contains("#5701 [live claim] Live claim task"));
+        assert!(text.contains("#4220 [deferred] Deferred task"));
+        assert!(text.contains("+3 more"));
+        assert_eq!(ak_inspector_text(&[], 0), "—");
+        assert!(ak_accessible_note(&tasks).starts_with(". AK task #5701"));
+        assert_eq!(ak_accessible_note(&[]), "");
+    }
+}

package/native/panel/src/protocol.rs

@@ -3,6 +3,25 @@ use serde_json::{Value, json};
 use std::io::{self, Write};
 use std::sync::{Mutex, OnceLock};
 
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AkTask {
+    #[serde(default)]
+    pub id: i64,
+    #[serde(default)]
+    pub title: String,
+    #[serde(default)]
+    pub state: String,
+}
+
+impl AkTask {
+    /// Only an `active` chip is a button: the card's own session holds a live claim, so clicking
+    /// it focuses that session's Ghostty window. Every other state is a badge and never fires.
+    pub fn is_active(&self) -> bool {
+        self.state == "active"
+    }
+}
+
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Card {
@@ -40,6 +59,20 @@ pub struct Card {
     pub agent_active: bool,
     #[serde(default, rename = "processId")]
     pub pid: i64,
+    /// Set for tabs running an agent other than Pi, which publish no telemetry of their own.
+    #[serde(default)]
+    pub agent_label: String,
+    /// Read-only AK task references joined onto this card by the controller. `active` chips are
+    /// clickable and focus this card's terminal; the rest are inert badges.
+    #[serde(default)]
+    pub ak_tasks: Vec<AkTask>,
+    /// How many further AK references exist beyond the rendered chips.
+    #[serde(default)]
+    pub ak_task_overflow: u32,
+    /// `Some(false)` marks a tab hidden behind another tab of its Ghostty window; the controller
+    /// placed it through its host process, so activation presents the tab before focusing.
+    #[serde(default)]
+    pub surface_visible: Option<bool>,
 }
 
 impl Card {
@@ -51,6 +84,10 @@ impl Card {
         }
     }
 
+    pub fn hidden_tab(&self) -> bool {
+        self.surface_visible == Some(false)
+    }
+
     pub fn active(&self) -> bool {
         self.agent_active || matches!(self.state.as_str(), "thinking" | "tool" | "waiting")
     }
@@ -159,6 +196,12 @@ pub fn demo_view() -> ViewMessage {
                 last_event_at: now - 1_000,
                 updated_at: now,
                 agent_active: true,
+                ak_tasks: vec![AkTask {
+                    id: 5701,
+                    title: "Show clickable AK-task references on the activity ribbon".into(),
+                    state: "active".into(),
+                }],
+                ak_task_overflow: 1,
                 ..empty_card()
             },
         ],
@@ -184,6 +227,10 @@ fn empty_card() -> Card {
         updated_at: 0,
         agent_active: false,
         pid: 0,
+        agent_label: String::new(),
+        ak_tasks: Vec::new(),
+        ak_task_overflow: 0,
+        surface_visible: None,
     }
 }
 
@@ -202,6 +249,22 @@ mod tests {
         assert!(view.sessions[0].active());
         assert_eq!(view.sessions[0].agent_started_at, None);
         assert_eq!(view.sessions[0].pid, 4242);
+        assert!(view.sessions[0].ak_tasks.is_empty());
+        assert_eq!(view.sessions[0].ak_task_overflow, 0);
+    }
+
+    #[test]
+    fn ak_task_chips_parse_with_states() {
+        let view: ViewMessage = serde_json::from_str(
+            r#"{"protocol":1,"type":"view","revision":8,"sessions":[{"cardId":"card-a","akTasks":[{"id":5701,"title":"Show clickable AK-task references","state":"active"},{"id":5432,"title":"Preserve safe NEXUS recovery reasons","state":"orphaned"},{"id":4220,"title":"Control Decision 77 epoch admissions","state":"deferred"}],"akTaskOverflow":3}]}"#,
+        )
+        .expect("view should parse");
+        let card = &view.sessions[0];
+        assert_eq!(card.ak_tasks.len(), 3);
+        assert!(card.ak_tasks[0].is_active());
+        assert!(!card.ak_tasks[1].is_active());
+        assert!(!card.ak_tasks[2].is_active());
+        assert_eq!(card.ak_task_overflow, 3);
     }
 
     #[test]

package/native/panel/src/runtime.rs

@@ -5,17 +5,44 @@ use std::collections::{HashMap, HashSet};
 use std::io::{BufRead, BufReader};
 use std::time::{SystemTime, UNIX_EPOCH};
 
+/// Colour definitions used until the controller reports what Ghostty is showing.
+const FALLBACK_DEFINITIONS: &str = concat!(
+    "@define-color pi_background #1e2326;\n",
+    "@define-color pi_foreground #d3c6aa;\n",
+    "@define-color pi_accent #7fbbb3;\n",
+    "@define-color pi_thinking #7fbbb3;\n",
+    "@define-color pi_tool #dbbc7f;\n",
+    "@define-color pi_waiting #e69875;\n",
+    "@define-color pi_success #a7c080;\n",
+    "@define-color pi_error #e67e80;\n",
+);
+
+thread_local! {
+    static THEME_PROVIDER: gtk::CssProvider = gtk::CssProvider::new();
+}
+
+/// The stylesheet derives every shade from a handful of named colours, so following the terminal's
+/// theme is a matter of redefining those names and reloading one provider.
 #[allow(deprecated)]
 pub fn install_css() {
-    let provider = gtk::CssProvider::new();
-    provider.load_from_data(include_str!("style.css"));
-    if let Some(display) = gtk::gdk::Display::default() {
-        gtk::style_context_add_provider_for_display(
-            &display,
-            &provider,
-            gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
-        );
-    }
+    apply_theme(FALLBACK_DEFINITIONS);
+    THEME_PROVIDER.with(|provider| {
+        if let Some(display) = gtk::gdk::Display::default() {
+            gtk::style_context_add_provider_for_display(
+                &display,
+                provider,
+                gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+            );
+        }
+    });
+}
+
+/// Replace the active colour definitions. Definitions must sit in the same provider as the rules
+/// that reference them, so both are loaded together.
+#[allow(deprecated)]
+pub fn apply_theme(definitions: &str) {
+    let css = format!("{definitions}\n{}", include_str!("style.css"));
+    THEME_PROVIDER.with(|provider| provider.load_from_data(&css));
 }
 
 pub fn start_input_reader(sender: relm4::Sender<AppMsg>) {
@@ -53,6 +80,20 @@ fn consume_line(sender: &relm4::Sender<AppMsg>, line: &str) {
                 let _ = sender.send(AppMsg::InputError(format!("invalid view message: {error}")));
             }
         },
+        Some("theme") => {
+            let definitions = value
+                .get("definitions")
+                .and_then(|item| item.as_str())
+                .unwrap_or_default()
+                .to_owned();
+            if definitions.is_empty() {
+                let _ = sender.send(AppMsg::InputError(
+                    "theme message carried no colours".into(),
+                ));
+            } else {
+                let _ = sender.send(AppMsg::Theme(definitions));
+            }
+        }
         Some("focus-strip") => {
             let _ = sender.send(AppMsg::FocusStrip);
         }