@tryinget/pi-activity-strip 0.5.0 → 0.7.0

package/native/panel/src/protocol.rs

@@ -1,8 +1,28 @@
 use serde::Deserialize;
 use serde_json::{Value, json};
 use std::io::{self, Write};
+use std::sync::atomic::{AtomicBool, Ordering};
 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 +60,36 @@ 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>,
+    /// Niri window id, so a window an agent or tool names by id can be found on the ribbon. A
+    /// hidden tab has no window of its own and carries the id of the window hosting it.
+    #[serde(default, deserialize_with = "lenient_integer")]
+    pub window_id: Option<i64>,
+    /// Niri workspace `idx`: the number the operator sees, not the internal workspace id.
+    #[serde(default, deserialize_with = "lenient_integer")]
+    pub workspace_idx: Option<i64>,
+}
+
+/// An optional label is not worth a view: a value that is not an integer drops the field rather
+/// than failing the whole message and every card in it.
+fn lenient_integer<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    Ok(Value::deserialize(deserializer)?.as_i64())
 }
 
 impl Card {
@@ -51,6 +101,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")
     }
@@ -93,6 +147,7 @@ fn protocol_version() -> u8 {
 }
 
 static OUTPUT: OnceLock<Mutex<io::Stdout>> = OnceLock::new();
+static READY: AtomicBool = AtomicBool::new(false);
 
 pub fn emit(event: Value) {
     let stdout = OUTPUT.get_or_init(|| Mutex::new(io::stdout()));
@@ -103,7 +158,14 @@ pub fn emit(event: Value) {
     }
 }
 
+/// Whether this panel ever came up. GTK returns from `run` without building anything when it hands
+/// the activation to another panel on the same display.
+pub fn was_ready() -> bool {
+    READY.load(Ordering::SeqCst)
+}
+
 pub fn emit_ready() {
+    READY.store(true, Ordering::SeqCst);
     emit(json!({
         "protocol": 1,
         "type": "ready",
@@ -140,6 +202,8 @@ pub fn demo_view() -> ViewMessage {
                 started_at: now - 135_000,
                 last_event_at: now - 4_000,
                 updated_at: now,
+                window_id: Some(36),
+                workspace_idx: Some(2),
                 ..empty_card()
             },
             Card {
@@ -159,6 +223,32 @@ 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,
+                window_id: Some(43),
+                workspace_idx: Some(2),
+                ..empty_card()
+            },
+            Card {
+                card_id: "demo-hidden".into(),
+                session_id: "demo-hidden".into(),
+                repo_label: "pi-extensions".into(),
+                phase: "Waiting behind another tab".into(),
+                state: "idle".into(),
+                detail: "Hidden tab placed through its Ghostty host window".into(),
+                cwd: "/home/tryinget/ai-society/softwareco/owned/pi-extensions".into(),
+                started_at: now - 610_000,
+                last_event_at: now - 95_000,
+                updated_at: now,
+                pid: 48213,
+                agent_label: "Claude Code".into(),
+                surface_visible: Some(false),
+                window_id: Some(43),
+                workspace_idx: Some(2),
                 ..empty_card()
             },
         ],
@@ -184,6 +274,12 @@ 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,
+        window_id: None,
+        workspace_idx: None,
     }
 }
 
@@ -202,6 +298,52 @@ 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 window_and_workspace_numbers_are_optional_card_fields() {
+        let view: ViewMessage = serde_json::from_str(
+            r#"{"protocol":1,"type":"view","revision":9,"sessions":[{"cardId":"card-a","windowId":43,"workspaceIdx":2},{"cardId":"card-b","windowId":null,"workspaceIdx":null},{"cardId":"card-c"}]}"#,
+        )
+        .expect("view should parse");
+        assert_eq!(view.sessions[0].window_id, Some(43));
+        assert_eq!(view.sessions[0].workspace_idx, Some(2));
+        assert_eq!(view.sessions[1].window_id, None);
+        assert_eq!(view.sessions[1].workspace_idx, None);
+        assert_eq!(
+            view.sessions[2].window_id, None,
+            "controllers that send no window id still parse"
+        );
+        assert_eq!(view.sessions[2].workspace_idx, None);
+    }
+
+    #[test]
+    fn a_malformed_window_or_workspace_number_drops_only_that_field() {
+        let view: ViewMessage = serde_json::from_str(
+            r#"{"protocol":1,"type":"view","revision":10,"sessions":[{"cardId":"card-a","windowId":"43","workspaceIdx":2.5},{"cardId":"card-b","windowId":44,"workspaceIdx":3}]}"#,
+        )
+        .expect("a bad optional field must not reject the whole view");
+        assert_eq!(view.sessions.len(), 2);
+        assert_eq!(view.sessions[0].window_id, None);
+        assert_eq!(view.sessions[0].workspace_idx, None);
+        assert_eq!(view.sessions[1].window_id, Some(44));
+        assert_eq!(view.sessions[1].workspace_idx, Some(3));
+    }
+
+    #[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);
         }

package/native/panel/src/style.css

@@ -1,56 +1,66 @@
+/*
+ * Every colour here derives from the handful of names the controller defines from Ghostty's own
+ * theme, so the ribbon follows the terminal into light and dark without a second palette to keep
+ * in sync. mix() against the background and alpha() against the foreground both invert correctly
+ * between schemes: a raised surface is lighter on a dark theme and darker on a light one.
+ */
+
 /* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
 window {
   background: transparent;
-  color: rgba(247, 250, 255, 0.96);
-  font-family: "IBM Plex Sans", "Avenir Next", "Segoe UI", sans-serif;
+  color: @pi_foreground;
+  font-family: "IBM Plex Sans", "Inter", "Segoe UI", sans-serif;
 }
 
-.brand,
-.cards-panel {
-  background: linear-gradient(to bottom, rgba(12, 19, 33, 0.96), rgba(8, 13, 22, 0.92));
-  border: 1px solid rgba(255, 255, 255, 0.08);
-  border-radius: 20px;
+/* One surface on the same rhythm and radius as tiled windows, so it reads as a peer of them. */
+.band {
+  /* Solid: the ribbon is the one surface that never dims, so it reads as the fixed ground. */
+  background: @pi_background;
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 12px;
+  padding: 0 14px 0 16px;
 }
 
 .brand {
-  padding: 10px 12px;
+  border-right: 1px solid alpha(@pi_foreground, 0.12);
+  margin-right: 12px;
+  padding: 11px 14px 11px 0;
 }
 
 .brand-eyebrow,
 .meta,
 .card-state,
+.card-window,
 .card-tool,
+.card-elapsed,
 .inspector-key {
   font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
 }
 
 .brand-eyebrow {
-  color: #79b8ff;
+  color: alpha(@pi_accent, 0.9);
   font-size: 9px;
-  letter-spacing: 1px;
+  font-weight: 600;
+  letter-spacing: 1.4px;
 }
 
 .brand-title {
-  color: rgba(247, 250, 255, 0.96);
-  font-size: 18px;
+  color: @pi_foreground;
+  font-size: 17px;
   font-weight: 650;
-}
-
-.brand-subtitle {
-  color: rgba(194, 205, 224, 0.74);
-  font-size: 10px;
+  letter-spacing: -0.2px;
 }
 
 .meta {
-  color: rgba(167, 180, 203, 0.58);
+  color: alpha(@pi_foreground, 0.56);
   font-size: 9px;
 }
 
 /* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel,
 .cards-panel > viewport {
-  background: linear-gradient(to bottom, rgba(10, 16, 28, 0.94), rgba(6, 10, 18, 0.9));
-  border-radius: 20px;
-  padding: 6px 8px 8px;
+  background: transparent;
+  padding: 0;
 }
 
 /* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
@@ -61,32 +71,42 @@ window {
 }
 
 .card {
-  color: rgba(247, 250, 255, 0.96);
-  background: linear-gradient(to bottom, rgba(13, 20, 35, 0.98), rgba(9, 14, 24, 0.96));
-  border: 1px solid rgba(255, 255, 255, 0.14);
-  border-left: 3px solid #79b8ff;
-  border-radius: 16px;
-  padding: 8px 10px 8px 12px;
-  box-shadow: none;
-  transition: 120ms ease;
+  color: @pi_foreground;
+  background: mix(@pi_background, @pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.1);
+  border-left: 3px solid alpha(@pi_foreground, 0.35);
+  border-radius: 12px;
+  padding: 7px 11px 7px 10px;
+  transition:
+    background 120ms ease,
+    border-color 120ms ease;
 }
 
 .card:hover,
 .card:focus-visible,
 .card.open {
-  background: linear-gradient(to bottom, rgba(18, 28, 47, 0.99), rgba(10, 16, 28, 0.97));
-  border-color: rgba(121, 184, 255, 0.72);
+  background: mix(@pi_background, @pi_foreground, 0.14);
+  border-color: alpha(@pi_accent, 0.5);
 }
 
+/* The tab the compositor is actually showing, marked by weight rather than another border. */
 .card.current {
-  border-left-width: 5px;
-  border-color: rgba(150, 202, 255, 0.92);
-  outline: 1px solid rgba(121, 184, 255, 0.38);
-  outline-offset: -3px;
+  background: mix(@pi_background, @pi_foreground, 0.16);
+  border-color: alpha(@pi_accent, 0.42);
+  box-shadow: inset 0 0 0 1px alpha(@pi_accent, 0.22);
+}
+
+.card.hidden-tab {
+  background: alpha(@pi_background, 0.55);
+  border-style: dashed;
+}
+
+.card.hidden-tab .card-repo {
+  color: alpha(@pi_foreground, 0.78);
 }
 
 .card.stalled {
-  opacity: 0.72;
+  opacity: 0.62;
 }
 
 .card.stalled .card-phase {
@@ -94,83 +114,150 @@ window {
 }
 
 .card.state-thinking {
-  border-left-color: #8ab4ff;
+  border-left-color: @pi_thinking;
 }
 .card.state-tool {
-  border-left-color: #ffd166;
+  border-left-color: @pi_tool;
 }
 .card.state-waiting {
-  border-left-color: #ff9f7a;
+  border-left-color: @pi_waiting;
 }
 .card.state-success {
-  border-left-color: #57d9a3;
+  border-left-color: @pi_success;
 }
 .card.state-error {
-  border-left-color: #ff7d7d;
+  border-left-color: @pi_error;
 }
 
 .card-repo {
-  color: rgba(247, 250, 255, 0.96);
+  color: @pi_foreground;
   font-size: 12px;
   font-weight: 650;
 }
 
 .card-phase,
 .inspector-value {
-  color: rgba(194, 205, 224, 0.76);
+  color: alpha(@pi_foreground, 0.74);
   font-size: 10px;
 }
 
+/* A quiet pill: the state is carried mostly by the card's left edge. */
 .card-state {
-  border: 1px solid rgba(121, 184, 255, 0.36);
+  background: alpha(@pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.16);
   border-radius: 999px;
-  color: #79b8ff;
+  color: alpha(@pi_foreground, 0.68);
   font-size: 8px;
-  padding: 4px 6px;
+  letter-spacing: 0.4px;
+  padding: 3px 7px;
 }
 
+.state-thinking .card-state {
+  background: alpha(@pi_thinking, 0.14);
+  border-color: alpha(@pi_thinking, 0.38);
+  color: @pi_thinking;
+}
 .state-tool .card-state {
-  color: #ffd166;
-  border-color: rgba(255, 209, 102, 0.42);
+  background: alpha(@pi_tool, 0.14);
+  border-color: alpha(@pi_tool, 0.38);
+  color: @pi_tool;
 }
 .state-waiting .card-state {
-  color: #ff9f7a;
-  border-color: rgba(255, 159, 122, 0.42);
+  background: alpha(@pi_waiting, 0.16);
+  border-color: alpha(@pi_waiting, 0.42);
+  color: @pi_waiting;
 }
 .state-success .card-state {
-  color: #57d9a3;
-  border-color: rgba(87, 217, 163, 0.42);
+  background: alpha(@pi_success, 0.14);
+  border-color: alpha(@pi_success, 0.38);
+  color: @pi_success;
 }
 .state-error .card-state {
-  color: #ff7d7d;
-  border-color: rgba(255, 125, 125, 0.42);
+  background: alpha(@pi_error, 0.16);
+  border-color: alpha(@pi_error, 0.44);
+  color: @pi_error;
 }
 
 .card-tool,
 .card-elapsed,
 .inspector-key {
-  color: rgba(167, 180, 203, 0.58);
+  color: alpha(@pi_foreground, 0.55);
+  font-size: 8px;
+}
+
+/*
+ * The Niri window id, for finding a window an agent or tool names by id. A tint rather than a
+ * border and no vertical padding, so it reads as a chip without growing the footer line.
+ */
+.card-window {
+  background: alpha(@pi_foreground, 0.09);
+  border-radius: 999px;
+  color: alpha(@pi_foreground, 0.7);
   font-size: 8px;
+  padding: 0 5px;
 }
 
 .inspector {
-  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  border-top: 1px solid alpha(@pi_foreground, 0.12);
   padding-top: 9px;
 }
 
 .inspector-value {
-  line-height: 1.25;
+  line-height: 1.3;
 }
 
 .activation {
-  color: rgba(167, 180, 203, 0.72);
+  color: alpha(@pi_foreground, 0.7);
   font-size: 9px;
 }
 
 .activation.success {
-  color: #57d9a3;
+  color: @pi_success;
 }
 
 .activation.error {
-  color: #ff7d7d;
+  color: @pi_error;
+}
+
+/*
+ * AK task references. An active chip is the one clickable element inside a card besides the card
+ * itself: it reuses the card's activation, so it carries the accent colour and a pointer cursor.
+ * Badge states (a claim that outlives its session, a deferred task) are deliberately inert pills.
+ */
+.ak-task {
+  background: alpha(@pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 999px;
+  color: alpha(@pi_foreground, 0.68);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
+  padding: 3px 8px;
+}
+
+.ak-task.ak-active {
+  background: alpha(@pi_accent, 0.14);
+  border-color: alpha(@pi_accent, 0.42);
+  color: @pi_accent;
+}
+
+.ak-task.ak-active:hover {
+  background: alpha(@pi_accent, 0.26);
+}
+
+.ak-task.ak-orphaned {
+  background: alpha(@pi_error, 0.12);
+  border: 1px dashed alpha(@pi_error, 0.4);
+  color: alpha(@pi_error, 0.92);
+}
+
+.ak-task.ak-deferred {
+  background: alpha(@pi_tool, 0.12);
+  border: 1px dashed alpha(@pi_tool, 0.4);
+  color: alpha(@pi_tool, 0.92);
+}
+
+.ak-overflow {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -88,9 +88,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
-    "@earendil-works/pi-agent-core": "0.84.3",
-    "@earendil-works/pi-ai": "0.84.3",
-    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@earendil-works/pi-agent-core": "0.84.4",
+    "@earendil-works/pi-ai": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.84.4",
     "@types/node": "22.14.0",
     "@typescript/native-preview": "7.0.0-dev.20260417.1",
     "typebox": "1.3.7",