@tryinget/pi-activity-strip 0.6.0 → 0.8.0

package/native/panel/src/card_view.rs

@@ -8,14 +8,18 @@ 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,
     phase: gtk::Label,
     repo: gtk::Label,
     state: gtk::Label,
+    window: gtk::Label,
     tool: gtk::Label,
     elapsed: gtk::Label,
     detail: gtk::Label,
@@ -23,6 +27,7 @@ pub struct CardView {
     reply: gtk::Label,
     path: gtk::Label,
     pid: gtk::Label,
+    window_detail: gtk::Label,
     agent: gtk::Label,
     task: gtk::Label,
     activation: gtk::Label,
@@ -50,19 +55,29 @@ 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);
         footer.set_margin_top(5);
+        // 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);
 
@@ -77,11 +92,15 @@ impl CardView {
         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 window_detail = inspector_row(&inspector, 5, "window");
+        // Always one short line; a wrapping label would reserve a second line of height for it.
+        window_detail.set_wrap(false);
+        window_detail.set_lines(-1);
+        let agent = inspector_row(&inspector, 6, "agent");
+        let task = inspector_row(&inspector, 7, "task");
         let activation = label("activation", gtk::Align::Start);
         activation.set_visible(false);
-        inspector.attach(&activation, 0, 7, 2, 1);
+        inspector.attach(&activation, 0, 8, 2, 1);
 
         content.append(&header);
         content.append(&footer);
@@ -100,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();
@@ -120,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);
 
@@ -177,6 +196,7 @@ impl CardView {
             phase,
             repo,
             state,
+            window,
             tool,
             elapsed,
             detail,
@@ -184,6 +204,7 @@ impl CardView {
             reply,
             path,
             pid,
+            window_detail,
             agent,
             task,
             activation,
@@ -229,6 +250,14 @@ impl CardView {
         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));
+        match window_chip_text(card) {
+            Some(text) => {
+                self.window.set_text(&text);
+                self.window.set_visible(true);
+            }
+            None => self.window.set_visible(false),
+        }
+        self.window_detail.set_text(&window_row(card));
         self.agent
             .set_text(text_or(&card.agent_label, "Pi session"));
         self.task
@@ -271,17 +300,20 @@ impl CardView {
             "no pid".to_owned()
         };
         let ak_note = ak_accessible_note(&card.ak_tasks);
+        let window_note = window_note(card);
         self.root.set_tooltip_text(Some(&format!(
-            "{} {} ({}{}){}",
+            "{} {} ({}{}{}){}",
             if hidden_tab { "Present" } else { "Focus" },
             text_or(&card.repo_label, "Pi session"),
             pid_note,
+            window_note,
             if hidden_tab { ", hidden tab" } else { "" },
             ak_note
         )));
         let accessible_label = format!(
-            "{}, {}, {}{}",
+            "{}{}, {}, {}{}",
             text_or(&card.repo_label, "Pi session"),
+            window_note,
             if stalled {
                 "stalled"
             } else {
@@ -325,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) {
@@ -410,6 +438,37 @@ fn pid_row(card: &Card, hidden_tab: bool) -> String {
     }
 }
 
+/// Compact chip text: the bare Niri window id, as agents and tools print it.
+fn window_chip_text(card: &Card) -> Option<String> {
+    card.window_id.map(|id| format!("#{id}"))
+}
+
+/// Inspector row: the window id and the workspace number the operator sees. A hidden tab has no
+/// window of its own, so its id is marked as the window hosting it.
+fn window_row(card: &Card) -> String {
+    let Some(window_id) = card.window_id else {
+        return "—".to_owned();
+    };
+    let window = if card.hidden_tab() {
+        format!("host #{window_id}")
+    } else {
+        format!("#{window_id}")
+    };
+    match card.workspace_idx {
+        Some(workspace) => format!("{window} · workspace {workspace}"),
+        None => window,
+    }
+}
+
+/// Appended to the card's tooltip and accessible label when the window is known.
+fn window_note(card: &Card) -> String {
+    match card.window_id {
+        Some(id) if card.hidden_tab() => format!(", host window {id}"),
+        Some(id) => format!(", window {id}"),
+        None => String::new(),
+    }
+}
+
 fn state_label(state: &str) -> &str {
     match state {
         "success" => "done",
@@ -435,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 {
@@ -504,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)]
@@ -547,6 +623,39 @@ mod tests {
         );
     }
 
+    #[test]
+    fn window_chip_names_the_niri_window_and_the_detail_adds_its_workspace() {
+        let visible = card(serde_json::json!({
+            "repoLabel": "dspx", "windowId": 43, "workspaceIdx": 2, "surfaceVisible": true
+        }));
+        assert_eq!(window_chip_text(&visible).as_deref(), Some("#43"));
+        assert_eq!(window_row(&visible), "#43 · workspace 2");
+        assert_eq!(window_note(&visible), ", window 43");
+
+        let hidden = card(serde_json::json!({
+            "repoLabel": "dspx", "windowId": 43, "workspaceIdx": 2, "surfaceVisible": false
+        }));
+        assert_eq!(
+            window_chip_text(&hidden).as_deref(),
+            Some("#43"),
+            "a hidden tab shows the window hosting it"
+        );
+        assert_eq!(window_row(&hidden), "host #43 · workspace 2");
+        assert_eq!(window_note(&hidden), ", host window 43");
+
+        let unindexed = card(serde_json::json!({ "windowId": 43 }));
+        assert_eq!(window_row(&unindexed), "#43");
+
+        let unplaced = card(serde_json::json!({ "repoLabel": "dspx" }));
+        assert_eq!(
+            window_chip_text(&unplaced),
+            None,
+            "no chip without a window"
+        );
+        assert_eq!(window_row(&unplaced), "—");
+        assert_eq!(window_note(&unplaced), "");
+    }
+
     #[test]
     fn ak_chip_states_map_to_classes_and_only_active_is_clickable() {
         let active = AkTask {
@@ -569,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/main.rs

@@ -19,13 +19,76 @@ fn bind_lifetime_to_parent() {
 #[cfg(not(target_os = "linux"))]
 fn bind_lifetime_to_parent() {}
 
+const APPLICATION_ID: &str = "com.tryinget.pi-activity-strip.panel";
+/// Keeps the display element well inside the 255-byte limit of a D-Bus name.
+const DISPLAY_ELEMENT_MAX: usize = 64;
+
+/// GTK uniqueness is scoped to one Wayland display. A second panel on the same compositor is
+/// refused, so no second ribbon can reserve another band, while a panel inside a nested
+/// compositor (the demo, a preview, a test) runs on its own instead of handing itself off.
+fn application_id(wayland_display: Option<&str>) -> String {
+    // GTK connects to `wayland-0` when the variable is unset, and a socket path names the same
+    // compositor as its file name, so every spelling of one display shares one id.
+    let raw = wayland_display
+        .filter(|display| !display.is_empty())
+        .unwrap_or("wayland-0");
+    let name = raw.rsplit('/').next().unwrap_or(raw);
+    let display: String = name
+        .chars()
+        .take(DISPLAY_ELEMENT_MAX)
+        .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
+        .collect();
+    format!("{APPLICATION_ID}.d_{display}")
+}
+
 fn main() {
     bind_lifetime_to_parent();
     let demo = std::env::var("PI_ACTIVITY_STRIP_PANEL_DEMO").as_deref() == Ok("1");
     let click_through = std::env::var("PI_ACTIVITY_STRIP_CLICK_THROUGH").as_deref() == Ok("1");
-    let app = RelmApp::new("com.tryinget.pi-activity-strip.panel").visible_on_activate(false);
+    let display = std::env::var("WAYLAND_DISPLAY").ok();
+    let app = RelmApp::new(&application_id(display.as_deref())).visible_on_activate(false);
     app.run::<App>(AppInit {
         demo,
         click_through,
     });
+    // A second panel on this display hands its activation to the first and returns without ever
+    // starting. It used to exit 0 having drawn nothing; say so and fail instead. Registration can
+    // also fail this way, so the message names the likely cause rather than asserting it.
+    if !protocol::was_ready() {
+        protocol::emit_error(
+            "The panel returned without starting; another activity-strip panel probably already runs on this Wayland display.",
+        );
+        std::process::exit(1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::application_id;
+
+    #[test]
+    fn uniqueness_is_scoped_to_the_wayland_display() {
+        assert_eq!(
+            application_id(Some("wayland-1")),
+            "com.tryinget.pi-activity-strip.panel.d_wayland_1"
+        );
+        assert_ne!(
+            application_id(Some("wayland-1")),
+            application_id(Some("wayland-2")),
+            "a panel in a nested compositor never hands off to the live one"
+        );
+        assert_eq!(
+            application_id(Some("/run/user/1000/wayland-1")),
+            application_id(Some("wayland-1")),
+            "a socket path and its name are the same compositor"
+        );
+        assert_eq!(
+            application_id(None),
+            application_id(Some("wayland-0")),
+            "GTK connects to wayland-0 when the variable is unset"
+        );
+        assert_eq!(application_id(Some("")), application_id(Some("wayland-0")));
+        let long = application_id(Some(&"x".repeat(400)));
+        assert!(long.len() <= 255, "a D-Bus name is at most 255 bytes");
+    }
 }

package/native/panel/src/protocol.rs

@@ -1,6 +1,7 @@
 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)]
@@ -73,6 +74,22 @@ pub struct Card {
     /// 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 {
@@ -130,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()));
@@ -140,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",
@@ -177,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 {
@@ -202,6 +229,26 @@ pub fn demo_view() -> ViewMessage {
                     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()
             },
         ],
@@ -231,6 +278,8 @@ fn empty_card() -> Card {
         ak_tasks: Vec::new(),
         ak_task_overflow: 0,
         surface_visible: None,
+        window_id: None,
+        workspace_idx: None,
     }
 }
 
@@ -253,6 +302,36 @@ mod tests {
         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(

package/native/panel/src/style.css

@@ -30,6 +30,7 @@ window {
 .brand-eyebrow,
 .meta,
 .card-state,
+.card-window,
 .card-tool,
 .card-elapsed,
 .inspector-key {
@@ -88,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 {
@@ -184,6 +188,18 @@ window {
   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 alpha(@pi_foreground, 0.12);
   padding-top: 9px;
@@ -211,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);
@@ -218,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.6.0",
+  "version": "0.8.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",