@tryinget/pi-activity-strip 0.7.0 → 0.8.0

package/README.md

@@ -128,9 +128,10 @@ The shortcut toggles exclusive keyboard mode. On entry, the first card is select
 - **Hidden tabs:** a Ghostty window title only names its active tab. A bound surface whose title is not visible is placed through its Ghostty host process: one host window is exact containment; several host windows use the window remembered for that tab. Memory comes from titles seen while the strip runs and from a read-only AT-SPI inventory of tab labels, and is persisted per Niri instance under `~/.pi/agent/state/pi-activity-strip/surface-bindings.json`. A tab whose window has never been observed stays unplaced rather than guessed; `status` reports that count. Activating a hidden-tab card calls the host process's `present-surface` action on the session bus, then focuses the window, and reports success only after the title proves the tab is visible.
 - **Window ids:** agents and tools name windows by their Niri window id (`claude-window` prints `window_id`, continuity receipts carry it). Each card shows that id as a quiet `#43` chip at the start of its footer; a hidden tab has no window of its own, so its chip shows the window hosting it. Hover or keyboard detail adds a `window` row with the workspace number the operator sees, Niri's workspace `idx` and never its internal workspace id, for example `#43 · workspace 2` or `host #43 · workspace 2` for a hidden tab. The tooltip and accessible label name the window too. Off Niri there is no window id, so no chip is drawn.
 - **Agent tabs:** a tab is admitted as an agent when the process owning its terminal is a recognized agent CLI, never on a window title alone, so plain terminal programs are not cards. Claude Code tabs are identified exactly through the per-session scratchpad the process holds open, which yields the session id and the title Claude Code put on the terminal; that title places the tab in its window and is remembered so the tab stays placed once hidden.
-- **AK task references:** cards can show the Agent Kernel task their session is working on. The controller reads the read-only `ak` CLI (`ak task list --status claimed --format json --all --verbose` and `ak task deferred --format json --all`) on a calm 15-second clock and joins claims by exact Pi session id under the AK5700 claim semantics: only `session-<uuid>` claims count, and an expired lease is vacant custody that renders nothing. A card whose session holds a live claim shows a clickable `AK #id · title` chip that reuses the card's own activation, so clicking it focuses the exact Ghostty window of the claiming session, presenting hidden tabs first. Claims whose lease has not lapsed but whose claiming session no longer exists ("claim outlives session") and tasks carrying an active deferral are joined by task repo onto cards working inside that repo and render as inert badges, never buttons — there is no live window to focus and no AK action is ever offered. Ambiguous session matches (one logical session resumed into two terminals), a missing `ak` binary, or malformed output bind nothing: fail closed, no chip, no invented state, strip behavior unchanged. The strip never writes AK state and never touches the society database directly.
+- **AK task references:** cards can show the Agent Kernel task their session is working on. The controller reads the read-only `ak` CLI (`ak task list --status claimed --format json --all --verbose` and `ak task deferred --format json --all`) on a calm 15-second clock and joins claims by exact Pi session id under the AK5700 claim semantics: only `session-<uuid>` claims count, and an expired lease is vacant custody that renders nothing. Chips sit in the card's footer as bare task numbers (`AK5701`, title in the tooltip and the expanded inspector), one per card with the rest folded into a `+N` count, so the folder name keeps the header. A card whose session holds a live claim shows a clickable chip that reuses the card's own activation, so clicking it focuses the exact Ghostty window of the claiming session, presenting hidden tabs first. Claims whose lease has not lapsed but whose claiming session no longer exists ("claim outlives session") and tasks carrying an active deferral are joined by task repo onto cards working inside that repo and render as inert badges, never buttons — there is no live window to focus and no AK action is ever offered. Ambiguous session matches (one logical session resumed into two terminals), a missing `ak` binary, or malformed output bind nothing: fail closed, no chip, no invented state, strip behavior unchanged. The strip never writes AK state and never touches the society database directly.
 - **Codex telemetry:** Codex keeps a thread index naming every session's rollout file, working directory and title. A process binds to its thread by an open rollout descriptor, or, before any task has run, by being the only session created in that directory after the process started; anything ambiguous binds nothing. The rollout tail then reports the running tool and its command, turn count, approval and sandbox policy, prompt and reply. Reading the index needs the runtime's built-in SQLite, and a host without it degrades to a process-only card.
 - **Claude Code telemetry:** cards read live state from the tail of the session transcript, giving the topic, current tool and its target, last prompt, latest reply, turn count and activity clock with no configuration. That format is internal to Claude Code and can change between releases, so a transcript that no longer parses degrades to a process-only card rather than inventing activity. Optional hooks add the one state a transcript cannot express, that a session is blocked waiting for you; run `claude-hooks` for the settings fragment. Only low-frequency events are hooked, so nothing runs per tool call. OpenTelemetry is deliberately not used: it reports aggregate usage and cost, not which tool a session is running now.
+- **You are here:** the block at the ribbon's left names the focused window's project in large type with its folder beneath (home written as `~`, cut from the front so the deepest folder stays visible), and the matching card carries a solid accent ring. With no agent window focused it shows the session counts instead.
 - **Appearance:** the ribbon reads the same theme files Ghostty reads. It resolves the `theme` setting for the desktop's current colour scheme, including the `light:…,dark:…` form, and takes colours set directly in the config over the theme file, exactly as Ghostty layers them. State colours reuse the terminal's own meanings, so green is settled, yellow is working, red failed, and the cursor colour marks a session waiting for you. The panel derives every shade from eight named colours, so a theme change is a handful of values and one stylesheet reload rather than a restart. A theme that cannot be read falls back to a neutral palette.
 - **Height repair:** showing or hiding the ribbon changes the output working area, and a window whose height is not automatic keeps the old value. After each change the strip compares window heights before and after, and resets to automatic only those windows still sitting at a height the moving windows just vacated. A height nobody vacated is never touched, each window is reset at most once per height, and a pass is bounded.
 - **Two identity keys:** a Ghostty surface id is a per-process handle that can drift away from the value a long-lived Pi process captured at startup, while the 32-hex session token in the same title never does. Memory therefore stores both, and lookups prefer the exact surface. A session token that two windows claim is ambiguous and binds nothing; two terminals resuming one logical session in the same window are both placed there.

package/native/bin/linux-x64-gnu/artifact.json

@@ -1,9 +1,9 @@
 {
   "schema": "pi-activity-strip-native-artifact.v1",
   "target": "x86_64-unknown-linux-gnu",
-  "sha256": "ebf9743947de5c872c3a5accf11bda013de71d081231d8e0f2fea83668227f74",
+  "sha256": "99b6f36e858b9c241c5aa73f7517c0f5f418673f54d9fa245156272c39bf004b",
   "cargoLockSha256": "f8ebc11bc721c569af982169e448a5ea4fed15bc06001017d97acda22b1c890b",
-  "sourceSha256": "f11355a34e72715d086297217d9cc3caabb81b6dcf3deb1c0c798f3a890f7a33",
+  "sourceSha256": "b272f4f3131cc4335ed6324ad051042fbd3d577b16944189fcdeaed7e776628f",
   "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
   "glibcFloor": "GLIBC_2.34",
   "neededSonames": [

package/native/panel/src/app.rs

@@ -16,6 +16,7 @@ const COMPACT_HEIGHT: i32 = 84;
 const OUTER_MARGIN: i32 = 8;
 const EXPANDED_HEIGHT: i32 = 276;
 const ORDER_REFRESH_MS: i64 = 15_000;
+const BRAND_WIDTH: i32 = 196;
 
 pub struct AppInit {
     pub demo: bool,
@@ -77,28 +78,42 @@ impl Component for App {
                 set_orientation: gtk::Orientation::Horizontal,
                 set_spacing: 0,
 
+                // "You are here": the project and folder of the focused window. The labels fill a
+                // fixed width instead of sizing it, so moving focus never shifts the cards beside it.
                 #[name = "brand"]
                 gtk::Box {
                     add_css_class: "brand",
                     set_orientation: gtk::Orientation::Vertical,
-                    set_width_request: 132,
+                    set_width_request: BRAND_WIDTH,
                     set_valign: gtk::Align::Center,
 
+                    #[name = "eyebrow"]
                     gtk::Label {
                         add_css_class: "brand-eyebrow",
                         set_label: "π ACTIVITY",
-                        set_halign: gtk::Align::Start,
+                        set_halign: gtk::Align::Fill,
+                        set_xalign: 0.0,
+                        set_ellipsize: gtk::pango::EllipsizeMode::End,
+                        set_max_width_chars: 1,
                     },
+                    #[name = "title"]
                     gtk::Label {
                         add_css_class: "brand-title",
                         set_label: "Sessions",
-                        set_halign: gtk::Align::Start,
+                        set_halign: gtk::Align::Fill,
+                        set_xalign: 0.0,
+                        set_ellipsize: gtk::pango::EllipsizeMode::End,
+                        set_max_width_chars: 1,
                     },
+                    // Ellipsized at the start: the deepest folder is the part that tells you where you are.
                     #[name = "meta"]
                     gtk::Label {
                         add_css_class: "meta",
                         set_label: "Waiting for sessions…",
-                        set_halign: gtk::Align::Start,
+                        set_halign: gtk::Align::Fill,
+                        set_xalign: 0.0,
+                        set_ellipsize: gtk::pango::EllipsizeMode::Start,
+                        set_max_width_chars: 1,
                     },
                 },
 
@@ -208,7 +223,7 @@ impl Component for App {
                     self.next_order_refresh_at = now_ms() + ORDER_REFRESH_MS;
                 }
                 self.refresh_cards();
-                self.update_meta(&widgets.meta);
+                self.update_brand(widgets);
             }
             AppMsg::Hover(id, entered) => {
                 if entered {
@@ -305,6 +320,57 @@ fn move_order_item(order: &mut Vec<String>, index: usize, target: usize) {
     order.insert(target, moved);
 }
 
+struct BrandCounts {
+    active: usize,
+    settled: usize,
+}
+
+#[derive(Debug, PartialEq)]
+struct BrandText {
+    eyebrow: String,
+    title: String,
+    meta: String,
+}
+
+/// The brand block names the focused window's project and folder. Without a focused agent window
+/// it falls back to the ribbon's own name and the session counts.
+fn brand_text(focused: Option<&Card>, counts: &BrandCounts, home: &str) -> BrandText {
+    let summary = format!("{} active · {} settled", counts.active, counts.settled);
+    match focused {
+        Some(card) if !card.repo_label.is_empty() || !card.cwd.is_empty() => BrandText {
+            eyebrow: format!("π {}", summary.to_uppercase()),
+            title: if card.repo_label.is_empty() {
+                short_path(&card.cwd, home)
+            } else {
+                card.repo_label.clone()
+            },
+            meta: if card.cwd.is_empty() {
+                "—".to_owned()
+            } else {
+                short_path(&card.cwd, home)
+            },
+        },
+        _ => BrandText {
+            eyebrow: "π ACTIVITY".to_owned(),
+            title: "Sessions".to_owned(),
+            meta: summary,
+        },
+    }
+}
+
+/// A path with the home directory written as `~`.
+fn short_path(path: &str, home: &str) -> String {
+    let home = home.trim_end_matches('/');
+    if home.is_empty() {
+        return path.to_owned();
+    }
+    match path.strip_prefix(home) {
+        Some("") => "~".to_owned(),
+        Some(rest) if rest.starts_with('/') => format!("~{rest}"),
+        _ => path.to_owned(),
+    }
+}
+
 fn engaged_card_id(
     hovered: &HashSet<String>,
     keyboard_active: bool,
@@ -394,7 +460,7 @@ impl App {
         }
         self.reorder_widgets(&widgets.cards_box);
         self.refresh_cards();
-        self.update_meta(&widgets.meta);
+        self.update_brand(widgets);
 
         let should_show = view.visible && !self.data.is_empty();
         if should_show != self.visible {
@@ -452,14 +518,26 @@ impl App {
         }
     }
 
-    fn update_meta(&self, meta: &gtk::Label) {
+    fn update_brand(&self, widgets: &AppWidgets) {
         let active = self.data.values().filter(|card| card.active()).count();
-        meta.set_text(&format!(
-            "{} active · {} settled · order {}s",
+        let counts = BrandCounts {
             active,
-            self.data.len().saturating_sub(active),
-            ((self.next_order_refresh_at - now_ms()).max(0) + 999) / 1000
-        ));
+            settled: self.data.len().saturating_sub(active),
+        };
+        let focused = self
+            .focused_card_id
+            .as_ref()
+            .and_then(|id| self.data.get(id));
+        let home = std::env::var("HOME").unwrap_or_default();
+        let brand = brand_text(focused, &counts, &home);
+        widgets.eyebrow.set_text(&brand.eyebrow);
+        widgets.title.set_text(&brand.title);
+        widgets.meta.set_text(&brand.meta);
+        widgets.brand.set_tooltip_text(
+            focused
+                .map(|card| card.cwd.as_str())
+                .filter(|cwd| !cwd.is_empty()),
+        );
     }
 
     fn regroup(&mut self) {
@@ -559,9 +637,59 @@ impl App {
 
 #[cfg(test)]
 mod tests {
-    use super::{engaged_card_id, move_order_item, navigation_target};
+    use super::{
+        BrandCounts, brand_text, engaged_card_id, move_order_item, navigation_target, short_path,
+    };
+    use crate::protocol::Card;
     use std::collections::HashSet;
 
+    fn counts() -> BrandCounts {
+        BrandCounts {
+            active: 2,
+            settled: 3,
+        }
+    }
+
+    #[test]
+    fn brand_names_the_focused_windows_project_and_folder() {
+        let card: Card = serde_json::from_value(serde_json::json!({
+            "repoLabel": "pi-activity-strip",
+            "cwd": "/home/op/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip"
+        }))
+        .expect("card");
+        let brand = brand_text(Some(&card), &counts(), "/home/op");
+        assert_eq!(brand.title, "pi-activity-strip");
+        assert_eq!(
+            brand.meta,
+            "~/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip"
+        );
+        assert_eq!(brand.eyebrow, "π 2 ACTIVE · 3 SETTLED");
+    }
+
+    #[test]
+    fn brand_falls_back_to_counts_without_a_focused_window() {
+        let brand = brand_text(None, &counts(), "/home/op");
+        assert_eq!(brand.title, "Sessions");
+        assert_eq!(brand.meta, "2 active · 3 settled");
+
+        let unlabelled: Card = serde_json::from_value(serde_json::json!({})).expect("card");
+        assert_eq!(
+            brand_text(Some(&unlabelled), &counts(), "/home/op").title,
+            "Sessions"
+        );
+    }
+
+    #[test]
+    fn short_path_abbreviates_only_the_whole_home_directory() {
+        assert_eq!(short_path("/home/op/repo", "/home/op"), "~/repo");
+        assert_eq!(short_path("/home/op", "/home/op/"), "~");
+        assert_eq!(
+            short_path("/home/operator/repo", "/home/op"),
+            "/home/operator/repo"
+        );
+        assert_eq!(short_path("/srv/repo", ""), "/srv/repo");
+    }
+
     #[test]
     fn stale_gtk_focus_does_not_retain_expansion_outside_keyboard_mode() {
         let focused = Some("card-a".to_owned());

package/native/panel/src/card_view.rs

@@ -8,8 +8,11 @@ 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;
+/// Rendered AK chips per card. The controller sends live-claim buttons first, then state badges;
+/// the card shows the first and folds the rest into the `+N` count. Nothing else in the footer
+/// shrinks, so this bound and the bounded timers are what hold the card at its width. The
+/// inspector still lists every reference.
+const AK_CHIP_SLOTS: usize = 1;
 
 pub struct CardView {
     pub root: gtk::Button,
@@ -52,12 +55,8 @@ 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);
@@ -65,11 +64,20 @@ impl CardView {
         // The Niri window id, so a window an agent or tool names by id can be found on the ribbon.
         // It leads the footer so it sits at the same place on every card and costs the title nothing.
         let window = label("card-window", gtk::Align::Start);
+        window.set_ellipsize(relm4::gtk::pango::EllipsizeMode::None);
         window.set_visible(false);
+        // AK references ride in the footer as bare task numbers: the header belongs to the folder
+        // name, which is what tells cards apart. The titles live in each chip's tooltip.
+        let ak_row = gtk::Box::new(gtk::Orientation::Horizontal, 3);
+        ak_row.set_valign(gtk::Align::Center);
+        ak_row.set_visible(false);
         let tool = label("card-tool", gtk::Align::Start);
         tool.set_hexpand(true);
         let elapsed = label("card-elapsed", gtk::Align::End);
+        // The window id and timers are never cut: the tool name gives way to the AK chips first.
+        elapsed.set_ellipsize(relm4::gtk::pango::EllipsizeMode::None);
         footer.append(&window);
+        footer.append(&ak_row);
         footer.append(&tool);
         footer.append(&elapsed);
 
@@ -111,9 +119,8 @@ impl CardView {
         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);
+            let chip = label("ak-task", gtk::Align::Start);
+            chip.set_ellipsize(relm4::gtk::pango::EllipsizeMode::None);
             chip.set_visible(false);
             let clickable = Rc::new(Cell::new(false));
             let click = gtk::GestureClick::new();
@@ -131,7 +138,8 @@ impl CardView {
             ak_chips.push(chip);
             ak_clickable.push(clickable);
         }
-        let ak_overflow = label("ak-overflow", gtk::Align::End);
+        let ak_overflow = label("ak-overflow", gtk::Align::Start);
+        ak_overflow.set_ellipsize(relm4::gtk::pango::EllipsizeMode::None);
         ak_overflow.set_visible(false);
         ak_row.append(&ak_overflow);
 
@@ -349,13 +357,9 @@ impl CardView {
             }
         }
         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);
-        }
+        let overflow = ak_folded_count(chips.len(), card.ak_task_overflow);
+        self.ak_overflow.set_visible(overflow > 0);
+        self.ak_overflow.set_text(&format!("+{overflow}"));
     }
 
     pub fn set_expanded(&self, expanded: bool) {
@@ -490,9 +494,16 @@ fn ak_chip_class(state: &str) -> &'static str {
     }
 }
 
-/// Compact chip text: task id plus as much title as the pill can hold.
+/// References beyond the rendered chips: those the card has no slot for plus the controller's own
+/// overflow.
+fn ak_folded_count(joined: usize, overflow: u32) -> u32 {
+    overflow.saturating_add(joined.saturating_sub(AK_CHIP_SLOTS) as u32)
+}
+
+/// Compact chip text: the task number as it is written in commits, `AK5701`, so it never reads as
+/// the `#43` window chip beside it. The title is in the tooltip and the inspector.
 fn ak_chip_text(task: &AkTask) -> String {
-    format!("AK #{} · {}", task.id, task.title)
+    format!("AK{}", task.id)
 }
 
 fn ak_chip_tooltip(task: &AkTask) -> String {
@@ -559,9 +570,19 @@ fn text_or<'a>(value: &'a str, fallback: &'a str) -> &'a str {
     if value.is_empty() { fallback } else { value }
 }
 
+/// Elapsed time in at most five characters (`59:59`, `23h59`, `99d`), so a long-running session
+/// never widens the card's footer.
 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)
+    let minutes = seconds / 60;
+    let hours = minutes / 60;
+    if hours == 0 {
+        format!("{}:{:02}", minutes, seconds % 60)
+    } else if hours < 24 {
+        format!("{}h{:02}", hours, minutes % 60)
+    } else {
+        format!("{}d", (hours / 24).min(99))
+    }
 }
 
 #[cfg(test)]
@@ -657,14 +678,25 @@ mod tests {
         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_eq!(ak_chip_text(&active), "AK5701");
+        assert_eq!(ak_folded_count(1, 0), 0);
+        assert_eq!(ak_folded_count(4, 0), 3);
+        assert_eq!(ak_folded_count(4, 21), 24);
         assert!(ak_chip_tooltip(&orphaned).contains("not clickable"));
         assert!(ak_chip_tooltip(&active).contains("focus the claiming session"));
     }
 
+    #[test]
+    fn durations_stay_within_five_characters() {
+        let at = |seconds: i64| duration(1_000 + seconds * 1000, 1_000);
+        assert_eq!(at(65), "1:05");
+        assert_eq!(at(59 * 60 + 59), "59:59");
+        assert_eq!(at(3600 + 5 * 60), "1h05");
+        assert_eq!(at(23 * 3600 + 59 * 60), "23h59");
+        assert_eq!(at(3 * 86_400), "3d");
+        assert_eq!(at(400 * 86_400), "99d");
+    }
+
     #[test]
     fn ak_inspector_lists_every_reference_with_overflow() {
         let tasks = vec![

package/native/panel/src/style.css

@@ -89,11 +89,14 @@ window {
   border-color: alpha(@pi_accent, 0.5);
 }
 
-/* The tab the compositor is actually showing, marked by weight rather than another border. */
+/*
+ * The tab the compositor is actually showing: the card the brand block names. A solid accent ring
+ * rather than a tint, so it never reads as the hover state and survives soft light themes.
+ */
 .card.current {
-  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);
+  background: mix(@pi_background, @pi_accent, 0.14);
+  border-color: @pi_accent;
+  box-shadow: inset 0 0 0 1px @pi_accent;
 }
 
 .card.hidden-tab {
@@ -224,6 +227,7 @@ window {
  * 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.
  */
+/* Footer-sized: a bare task number with no vertical padding, like the window chip beside it. */
 .ak-task {
   background: alpha(@pi_foreground, 0.07);
   border: 1px solid alpha(@pi_foreground, 0.16);
@@ -231,7 +235,7 @@ window {
   color: alpha(@pi_foreground, 0.68);
   font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
   font-size: 8px;
-  padding: 3px 8px;
+  padding: 0 5px;
 }
 
 .ak-task.ak-active {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",