@tryinget/pi-activity-strip 0.6.0 → 0.7.0

package/README.md

@@ -28,6 +28,7 @@ The runtime is Electron-free. A Node controller retains the tested telemetry, id
 - shows the AK task a session is working on: read-only `ak` output is joined onto cards, clicking the task reference focuses the claiming terminal, and claims that outlive their session or deferred tasks appear as non-clickable badges
 - displays repo, phase, tool, detail, elapsed time, and freshness
 - marks the exact currently focused terminal card and prefixes hidden-tab cards with `⧉`
+- labels each card with its Niri window id (`#43`), so a window an agent or tool names by id can be found on the ribbon
 - keeps monitoring-success cards beside the Activity tile, then active and settled cards
 - expands rich details on hover or keyboard focus
 - supports Left/Right navigation and Shift+Left/Right manual movement
@@ -46,9 +47,11 @@ Pi publisher streams
   -> wlr-layer-shell top surface with an 84px exclusive zone
 ```
 
+Every child-protocol message carries `protocol: 1`, and the panel drops any view carrying another version. A new card field is therefore added as an optional field: a panel that does not know it ignores it, and a panel talking to a controller that does not send it falls back to a default. The version changes only for a change an existing panel would misread.
+
 Layer-shell replaces the old floating Electron window and dynamic Niri-config strut helper. The package no longer edits `~/.config/niri/config.kdl`, resets tiled heights, or requires Electron.
 
-The compact surface is 84px tall and sits inset by an 8px margin on the top, left and right, matching the compositor's window gaps, with the same 12px corner radius as tiled windows. It therefore reserves 92px in total. One engaged card expands the surface to 276px while the reservation is unchanged, so detail overlays content without repeatedly resizing tiled windows.
+The compact surface is 84px tall and sits inset by an 8px margin on the top, left and right, matching the compositor's window gaps, with the same 12px corner radius as tiled windows. It therefore reserves 92px in total. One engaged card expands the surface to at least 276px, taller when its detail rows wrap, while the reservation is unchanged, so detail overlays content without repeatedly resizing tiled windows.
 
 ## Supported host
 
@@ -100,6 +103,8 @@ node ./bin/pi-activity-strip.mjs claude-hooks
 node ./bin/pi-activity-strip.mjs stop
 ```
 
+`stop` returns once the runtime has exited and released its lock, waiting up to 15 seconds and exiting non-zero if it has not, so `npm run strip:stop && npm run strip:open` restarts cleanly. Pi's `/activity-strip stop` and `/activity-strip-stop` wait the same way. An `open` that finds the lock still held by a runtime that never answers says so instead of timing out silently.
+
 `fix-top` is now a compatibility no-op: layer-shell placement is compositor-owned.
 
 ## Keyboard-only entry
@@ -116,11 +121,12 @@ The shortcut toggles exclusive keyboard mode. On entry, the first card is select
 
 ## Interaction contract
 
-- **Workspace locality:** Niri focus events trigger immediate reprojection; bounded polling remains a fallback.
+- **Workspace locality:** Niri focus events and workspace list changes trigger immediate reprojection; bounded polling remains a fallback.
 - **Hide/reclaim:** zero cards unmaps the layer surface. Niri then removes its exclusive zone as part of normal Wayland surface lifecycle.
 - **Crash behavior:** panel lifetime is bound to the Node controller through Linux parent-death signaling and stdin EOF. Unexpected panel exits are restarted with bounded backoff; a dead surface cannot retain an exclusive zone.
 - **Exact focus:** card activation returns to Node, which performs existing fail-closed terminal identity resolution and Niri focus.
 - **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.
 - **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.
@@ -167,6 +173,16 @@ The staged artifact receipt binds:
 - glibc symbol floor
 - required shared libraries
 
+To see the panel without touching the live ribbon, run its built-in demo cards in a nested Niri with a config that spawns nothing:
+
+```bash
+printf 'prefer-no-csd\nhotkey-overlay {\n    skip-at-startup\n}\n' >/tmp/pi-activity-preview.kdl
+niri -c /tmp/pi-activity-preview.kdl -- env PI_ACTIVITY_STRIP_PANEL_DEMO=1 \
+  "$PWD/native/bin/linux-x64-gnu/pi-activity-strip-panel"
+```
+
+The panel is unique per Wayland display: this demo runs beside the live ribbon, while a second panel on the live display is refused with an error rather than reserving a second band. Never run the panel under a private session bus such as `dbus-run-session`: GTK then starts a second accessibility bus that takes over the desktop's AT-SPI socket and leaves it dead when it exits.
+
 Live verification must inspect Niri layers rather than regular windows:
 
 ```bash
@@ -185,6 +201,7 @@ Implemented:
 - exact Ghostty activation, including hidden tabs via `present-surface`
 - hidden Ghostty tab placement through host process containment and learned window memory
 - clickable AK task references joined from read-only `ak` output, with claim-outlives-session and deferred badges
+- Niri window id on every card, and its workspace number in the detail
 - non-Pi agent tab discovery with an exact Claude Code adapter
 - live Claude Code telemetry from its transcript, with optional hooks for blocked-on-you states
 - live Codex telemetry from its thread index and rollout files

package/bin/pi-activity-strip.mjs

@@ -8,7 +8,6 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
 import {
   getBrokerStatus,
@@ -16,6 +15,13 @@ import {
   requestBrokerShutdown,
   sendBrokerMessage,
 } from "../src/client/broker-client.mjs";
+import {
+  RUNTIME_LOCK_CONFLICT_EXIT_CODE,
+  RUNTIME_LOCK_PATH as runtimeLockPath,
+  stopRuntime,
+  waitForRuntimeExit,
+  waitForStartedRuntime,
+} from "../src/client/runtime-lock.mjs";
 import {
   assessActivityStripCompatibility,
   formatCompatibilityReport,
@@ -23,6 +29,7 @@ import {
 import {
   ACTIVITY_STRIP_SOCKET_DIR,
   ACTIVITY_STRIP_START_TIMEOUT_MS,
+  ACTIVITY_STRIP_STOP_TIMEOUT_MS,
 } from "../src/common/constants.mjs";
 import { makeMessage } from "../src/common/protocol.mjs";
 import { formatBrokerRuntimeStatus } from "../src/common/status-report.mjs";
@@ -30,7 +37,11 @@ import { formatBrokerRuntimeStatus } from "../src/common/status-report.mjs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const nativeEntry = path.resolve(__dirname, "..", "src", "native", "main.mjs");
-const runtimeLockPath = path.join(ACTIVITY_STRIP_SOCKET_DIR, "runtime.lock");
+const STOP_MESSAGES = {
+  stopped: "stopped",
+  "not-running": "not-running",
+  "still-stopping": "stopping (still shutting down)",
+};
 
 function usage() {
   console.log(
@@ -38,37 +49,6 @@ function usage() {
   );
 }
 
-async function waitForBrokerReady(timeoutMs = ACTIVITY_STRIP_START_TIMEOUT_MS) {
-  const timeoutAt = Date.now() + timeoutMs;
-  /** @type {import("../src/common/contracts.ts").BrokerResponse | null} */
-  let latestStatus = null;
-
-  while (Date.now() < timeoutAt) {
-    try {
-      latestStatus = await getBrokerStatus();
-    } catch {
-      latestStatus = null;
-    }
-
-    if (
-      latestStatus?.ok &&
-      (!latestStatus.runtimeStatus || latestStatus.runtimeStatus.state === "ready")
-    ) {
-      return { ok: true };
-    }
-    if (latestStatus?.runtimeStatus?.state === "error") {
-      return { ok: false, error: formatBrokerRuntimeStatus(latestStatus) };
-    }
-
-    await delay(125);
-  }
-
-  return {
-    ok: false,
-    error: `${formatBrokerRuntimeStatus(latestStatus || { ok: false })}\nTimeout: ${timeoutMs}ms`,
-  };
-}
-
 /** @param {{ detached?: boolean }} [options] @returns {Promise<number>} */
 async function openStrip({ detached = true } = {}) {
   if (await isBrokerAlive()) {
@@ -78,11 +58,12 @@ async function openStrip({ detached = true } = {}) {
       return 0;
     }
     await requestBrokerShutdown().catch(() => null);
-    for (let attempt = 0; attempt < 20 && (await isBrokerAlive()); attempt += 1) {
-      await delay(50);
-    }
-    if (await isBrokerAlive()) {
-      console.error(formatBrokerRuntimeStatus(status));
+    // Its broker closes before it exits; starting before the lock is released would lose it.
+    const exit = await waitForRuntimeExit(runtimeLockPath, {
+      timeoutMs: ACTIVITY_STRIP_STOP_TIMEOUT_MS,
+    });
+    if (!exit.released) {
+      console.error(exit.error ?? formatBrokerRuntimeStatus(status));
       return 1;
     }
   }
@@ -94,26 +75,62 @@ async function openStrip({ detached = true } = {}) {
   }
 
   fs.mkdirSync(ACTIVITY_STRIP_SOCKET_DIR, { recursive: true, mode: 0o700 });
-  const child = spawn("flock", ["--nonblock", runtimeLockPath, process.execPath, nativeEntry], {
-    detached,
-    stdio: detached ? "ignore" : "inherit",
-    env: { ...process.env, PI_ACTIVITY_STRIP_RUNTIME_LOCK_HELD: "1" },
-  });
-
-  if (detached) {
-    child.unref();
-    const ready = await waitForBrokerReady();
-    if (!ready.ok) {
-      console.error(ready.error || "Activity strip did not become ready.");
-      return 1;
-    }
-    console.log("Started activity strip.");
-    return 0;
+  const child = spawn(
+    "flock",
+    [
+      "--nonblock",
+      "--conflict-exit-code",
+      String(RUNTIME_LOCK_CONFLICT_EXIT_CODE),
+      runtimeLockPath,
+      process.execPath,
+      nativeEntry,
+    ],
+    {
+      detached,
+      stdio: detached ? "ignore" : "inherit",
+      env: { ...process.env, PI_ACTIVITY_STRIP_RUNTIME_LOCK_HELD: "1" },
+    },
+  );
+  if (!detached) {
+    return await new Promise((resolve) => {
+      child.on("exit", (code) => resolve(typeof code === "number" ? code : 0));
+    });
   }
 
-  return await new Promise((resolve) => {
-    child.on("exit", (code) => resolve(typeof code === "number" ? code : 0));
+  /** @type {{exitCode: number | null | undefined; error?: string}} */
+  const controller = { exitCode: undefined };
+  child.once("exit", (code) => {
+    controller.exitCode = code;
+  });
+  child.once("error", (error) => {
+    controller.exitCode = null;
+    controller.error = error.message;
   });
+  child.unref();
+  const result = await waitForStartedRuntime({
+    controller,
+    getStatus: () => getBrokerStatus().catch(() => null),
+  });
+  if (result.ok) {
+    console.log(result.started ? "Started activity strip." : "Activity strip is already running.");
+    return 0;
+  }
+  if (result.reason === "lock-held") {
+    console.error(
+      "Another activity-strip runtime still holds the runtime lock, probably one that is shutting down; nothing was started. `stop` waits for it to exit.",
+    );
+  } else if (result.reason === "exited") {
+    console.error(
+      controller.error
+        ? `The activity-strip runtime could not be started: ${controller.error}`
+        : `The activity-strip runtime exited during startup (code ${result.exitCode}).`,
+    );
+  } else {
+    const timeout =
+      result.reason === "timeout" ? `\nTimeout: ${ACTIVITY_STRIP_START_TIMEOUT_MS}ms` : "";
+    console.error(`${formatBrokerRuntimeStatus(result.status ?? { ok: false })}${timeout}`);
+  }
+  return 1;
 }
 
 async function main() {
@@ -234,14 +251,10 @@ async function main() {
       process.exitCode = 0;
       return;
     case "stop": {
-      try {
-        const result = await requestBrokerShutdown();
-        console.log(result?.ok ? "stopping" : "not-running");
-        process.exitCode = result?.ok ? 0 : 1;
-      } catch {
-        console.log("not-running");
-        process.exitCode = 1;
-      }
+      const result = await stopRuntime();
+      if (result.outcome === "error") console.error(result.error);
+      else console.log(STOP_MESSAGES[result.outcome]);
+      process.exitCode = result.outcome === "stopped" ? 0 : 1;
       return;
     }
     case "-h":

package/extensions/activity-strip.js

@@ -14,8 +14,9 @@ import { promisify } from "node:util";
 /** @typedef {import("../src/common/contracts.ts").SessionStartContextLike} SessionStartContextLike */
 /** @typedef {import("../src/common/contracts.ts").ToolExecutionEventLike} ToolExecutionEventLike */
 /** @typedef {import("../src/common/contracts.ts").TurnStartEventLike} TurnStartEventLike */
-import { getBrokerStatus, requestBrokerShutdown } from "../src/client/broker-client.mjs";
+import { getBrokerStatus } from "../src/client/broker-client.mjs";
 import { ensureActivityStripRunning } from "../src/client/launcher.mjs";
+import { stopRuntime } from "../src/client/runtime-lock.mjs";
 import { createSessionTelemetry } from "../src/client/session-telemetry.mjs";
 import {
   formatBrokerRuntimeStatus,
@@ -34,6 +35,13 @@ function wantsAutostart() {
   return process.env.PI_ACTIVITY_STRIP_AUTO_START !== "0";
 }
 
+/** @type {Record<string, [string, "info" | "warning" | "error"]>} */
+const STOP_NOTICES = {
+  stopped: ["Activity strip stopped", "info"],
+  "not-running": ["Activity strip is not running", "warning"],
+  "still-stopping": ["Activity strip is still shutting down", "warning"],
+};
+
 /** @param {ExtensionAPI} pi */
 export default function activityStripExtension(pi) {
   const telemetry = createSessionTelemetry({
@@ -57,6 +65,20 @@ export default function activityStripExtension(pi) {
     return result;
   }
 
+  /**
+   * Returns once the runtime has exited, so an open right after it cannot race a runtime that is
+   * still shutting down and leave no ribbon running.
+   * @param {UiContextLike} ctx
+   */
+  async function stopStrip(ctx) {
+    const result = await stopRuntime();
+    if (!ctx.hasUI) return;
+    /** @type {[string, "info" | "warning" | "error"]} */
+    const [message, level] =
+      result.outcome === "error" ? [result.error, "error"] : STOP_NOTICES[result.outcome];
+    ctx.ui?.notify?.(message, level);
+  }
+
   pi.registerCommand("activity-strip", {
     description: "Open or check the top-row activity strip",
     /** @param {string} args @param {UiContextLike} ctx */
@@ -122,16 +144,7 @@ export default function activityStripExtension(pi) {
       }
 
       if (action === "stop") {
-        try {
-          const result = await requestBrokerShutdown();
-          if (ctx.hasUI)
-            ctx.ui?.notify?.(
-              result?.ok ? "Stopping activity strip" : "Activity strip is not running",
-              result?.ok ? "info" : "warning",
-            );
-        } catch {
-          if (ctx.hasUI) ctx.ui?.notify?.("Activity strip is not running", "warning");
-        }
+        await stopStrip(ctx);
         return;
       }
 
@@ -143,16 +156,7 @@ export default function activityStripExtension(pi) {
     description: "Stop the running activity strip broker/window",
     /** @param {string} _args @param {UiContextLike} ctx */
     handler: async (_args, ctx) => {
-      try {
-        const result = await requestBrokerShutdown();
-        if (ctx.hasUI)
-          ctx.ui?.notify?.(
-            result?.ok ? "Stopping activity strip" : "Activity strip is not running",
-            result?.ok ? "info" : "warning",
-          );
-      } catch {
-        if (ctx.hasUI) ctx.ui?.notify?.("Activity strip is not running", "warning");
-      }
+      await stopStrip(ctx);
     },
   });
 

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": "999724e6bb34a0cceea631d1cbe58541f20221291b3e9d065e9bb19e193a3b27",
+  "sha256": "ebf9743947de5c872c3a5accf11bda013de71d081231d8e0f2fea83668227f74",
   "cargoLockSha256": "f8ebc11bc721c569af982169e448a5ea4fed15bc06001017d97acda22b1c890b",
-  "sourceSha256": "1fa65ddf13e1a3c1267081de641e65617822fd409c88e865fec6f769b8161a35",
+  "sourceSha256": "f11355a34e72715d086297217d9cc3caabb81b6dcf3deb1c0c798f3a890f7a33",
   "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
   "glibcFloor": "GLIBC_2.34",
   "neededSonames": [

package/native/panel/src/card_view.rs

@@ -16,6 +16,7 @@ pub struct CardView {
     phase: gtk::Label,
     repo: gtk::Label,
     state: gtk::Label,
+    window: gtk::Label,
     tool: gtk::Label,
     elapsed: gtk::Label,
     detail: gtk::Label,
@@ -23,6 +24,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,
@@ -60,9 +62,14 @@ impl CardView {
 
         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_visible(false);
         let tool = label("card-tool", gtk::Align::Start);
         tool.set_hexpand(true);
         let elapsed = label("card-elapsed", gtk::Align::End);
+        footer.append(&window);
         footer.append(&tool);
         footer.append(&elapsed);
 
@@ -77,11 +84,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);
@@ -177,6 +188,7 @@ impl CardView {
             phase,
             repo,
             state,
+            window,
             tool,
             elapsed,
             detail,
@@ -184,6 +196,7 @@ impl CardView {
             reply,
             path,
             pid,
+            window_detail,
             agent,
             task,
             activation,
@@ -229,6 +242,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 +292,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 {
@@ -410,6 +434,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",
@@ -547,6 +602,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 {

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 {
@@ -184,6 +185,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;

package/package.json

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

package/src/client/runtime-lock.mjs

@@ -0,0 +1,140 @@
+// ---
+// summary: "waits on the native runtime flock so stop returns only after the controller exits, and open can name a held lock"
+// read_when:
+//   - "changing how stop waits for shutdown or how open reports a runtime that failed to start"
+// ---
+
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+import {
+  ACTIVITY_STRIP_SOCKET_DIR,
+  ACTIVITY_STRIP_START_TIMEOUT_MS,
+  ACTIVITY_STRIP_STOP_TIMEOUT_MS,
+} from "../common/constants.mjs";
+import { requestBrokerShutdown } from "./broker-client.mjs";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * The exit status `flock` uses for a held lock. It differs from every status the controller or
+ * `flock` itself can return, so a held lock is never confused with a failure to check it.
+ */
+export const RUNTIME_LOCK_CONFLICT_EXIT_CODE = 75;
+
+/** The controller holds this lock for its whole lifetime. */
+export const RUNTIME_LOCK_PATH = path.join(ACTIVITY_STRIP_SOCKET_DIR, "runtime.lock");
+
+/** @typedef {import("../common/contracts.ts").BrokerResponse} BrokerResponse */
+/** @typedef {{exitCode: number | null | undefined}} ControllerHandle */
+
+/**
+ * Take and release the lock once, reporting whether it was held.
+ * @param {string} lockPath
+ * @param {string[]} mode
+ * @returns {Promise<"free" | "held" | {error: string}>}
+ */
+async function tryRuntimeLock(lockPath, mode) {
+  const conflict = String(RUNTIME_LOCK_CONFLICT_EXIT_CODE);
+  try {
+    await execFileAsync("flock", [...mode, "--conflict-exit-code", conflict, lockPath, "true"]);
+    return "free";
+  } catch (error) {
+    const failure = /** @type {{code?: unknown; message?: string}} */ (error ?? {});
+    if (failure.code === RUNTIME_LOCK_CONFLICT_EXIT_CODE) return "held";
+    return {
+      error: `Could not check the activity-strip runtime lock: ${failure.message ?? String(error)}`,
+    };
+  }
+}
+
+/**
+ * Wait until the controller holding the runtime lock has exited. The controller holds the lock for
+ * its whole lifetime and closes its broker before it lets go, so a closed broker alone does not
+ * prove it is gone. `waited` says whether a runtime was still there.
+ * @param {string} lockPath
+ * @param {{timeoutMs: number}} options
+ * @returns {Promise<{released: boolean; waited?: boolean; error?: string}>}
+ */
+export async function waitForRuntimeExit(lockPath, { timeoutMs }) {
+  const now = await tryRuntimeLock(lockPath, ["--nonblock"]);
+  if (now === "free") return { released: true, waited: false };
+  if (now !== "held") return { released: false, error: now.error };
+  const later = await tryRuntimeLock(lockPath, ["--wait", String(timeoutMs / 1000)]);
+  if (later === "free") return { released: true, waited: true };
+  if (later === "held") return { released: false, waited: true };
+  return { released: false, error: later.error };
+}
+
+/**
+ * Stop the runtime and return once it has exited. Every stop path, the CLI and Pi's commands, goes
+ * through here, so a following open can never race a runtime that is still shutting down. The lock
+ * is waited on even when no broker answers: a runtime whose broker has closed still holds it.
+ * @param {{
+ *   requestShutdown?: () => Promise<{ok?: boolean} | null | undefined>;
+ *   waitForExit?: typeof waitForRuntimeExit;
+ *   lockPath?: string;
+ *   timeoutMs?: number;
+ * }} [options]
+ * @returns {Promise<{outcome: "stopped" | "not-running" | "still-stopping"} | {outcome: "error"; error: string}>}
+ */
+export async function stopRuntime({
+  requestShutdown = requestBrokerShutdown,
+  waitForExit = waitForRuntimeExit,
+  lockPath = RUNTIME_LOCK_PATH,
+  timeoutMs = ACTIVITY_STRIP_STOP_TIMEOUT_MS,
+} = {}) {
+  let accepted = false;
+  try {
+    accepted = (await requestShutdown())?.ok === true;
+  } catch {
+    accepted = false;
+  }
+  const exit = await waitForExit(lockPath, { timeoutMs });
+  if (exit.error) return { outcome: "error", error: exit.error };
+  if (!exit.released) return { outcome: "still-stopping" };
+  return { outcome: accepted || exit.waited ? "stopped" : "not-running" };
+}
+
+/**
+ * Wait for the controller `open` just spawned under the runtime lock to become ready. A spawn that
+ * finds the lock held exits with the conflict status. The wait still continues, because the holder
+ * may be a controller another `open` is starting; the held lock is reported only if nothing
+ * becomes ready in time.
+ * @param {{
+ *   controller: ControllerHandle;
+ *   getStatus: () => Promise<BrokerResponse | null>;
+ *   timeoutMs?: number;
+ *   retryMs?: number;
+ *   now?: () => number;
+ *   sleep?: (ms: number) => Promise<unknown>;
+ * }} options
+ * @returns {Promise<{ok: true; started: boolean} | {ok: false; reason: "error" | "exited" | "lock-held" | "timeout"; status: BrokerResponse | null; exitCode?: number | null}>}
+ */
+export async function waitForStartedRuntime({
+  controller,
+  getStatus,
+  timeoutMs = ACTIVITY_STRIP_START_TIMEOUT_MS,
+  retryMs = 125,
+  now = Date.now,
+  sleep = delay,
+}) {
+  const deadline = now() + timeoutMs;
+  while (true) {
+    const status = await getStatus();
+    if (status?.ok && (!status.runtimeStatus || status.runtimeStatus.state === "ready")) {
+      return { ok: true, started: controller.exitCode === undefined };
+    }
+    if (status?.runtimeStatus?.state === "error") return { ok: false, reason: "error", status };
+    const exitCode = controller.exitCode;
+    if (exitCode !== undefined && exitCode !== RUNTIME_LOCK_CONFLICT_EXIT_CODE) {
+      return { ok: false, reason: "exited", status, exitCode };
+    }
+    if (now() >= deadline) {
+      const reason = exitCode === RUNTIME_LOCK_CONFLICT_EXIT_CODE ? "lock-held" : "timeout";
+      return { ok: false, reason, status };
+    }
+    await sleep(retryMs);
+  }
+}

package/src/common/claude-events.mjs

@@ -46,7 +46,7 @@ export function claudeEventPath(sessionId, directory = CLAUDE_EVENT_DIR) {
  */
 export function describeHookToolTarget(toolInput) {
   for (const key of ["description", "command", "file_path", "path", "pattern", "query", "url"]) {
-    const value = /** @type {any} */ (toolInput ?? {})[key];
+    const value = /** @type {any} */ (toolInput)?.[key];
     if (typeof value === "string" && value.trim()) return preview(value);
   }
   return "";

package/src/common/constants.mjs

@@ -25,5 +25,7 @@ export const ACTIVITY_STRIP_BROADCAST_TICK_MS = 1000;
 export const ACTIVITY_STRIP_SEND_THROTTLE_MS = 120;
 export const ACTIVITY_STRIP_CONNECT_TIMEOUT_MS = 450;
 export const ACTIVITY_STRIP_START_TIMEOUT_MS = 5000;
+/** How long `stop` waits for the runtime to exit; an in-flight read-only `ak` query can take 8 s. */
+export const ACTIVITY_STRIP_STOP_TIMEOUT_MS = 15_000;
 export const ACTIVITY_STRIP_EVENT_STALL_MS = 15 * 60_000;
 export const ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS = [250, 750];

package/src/common/contracts.d.ts

@@ -19,6 +19,15 @@ export interface SessionSnapshot {
   publisherCount?: number;
   publisherIds?: string[];
   publisherRecordKeys?: string[];
+  publisherSessionIds?: string[];
+  akTasks?: AkTaskChip[];
+  akTaskOverflow?: number;
+  /** Niri window id; for a hidden tab, the window hosting it. */
+  windowId?: number | null;
+  /** Niri workspace `idx`, the number the operator sees, never the internal workspace id. */
+  workspaceIdx?: number | null;
+  placement?: "title" | "host" | "binding";
+  surfaceVisible?: boolean;
   cwd: string;
   repoLabel: string;
   sessionName: string;

package/src/common/contracts.ts

@@ -22,7 +22,10 @@ export interface SessionSnapshot {
   publisherSessionIds?: string[];
   akTasks?: AkTaskChip[];
   akTaskOverflow?: number;
+  /** Niri window id; for a hidden tab, the window hosting it. */
   windowId?: number | null;
+  /** Niri workspace `idx`, the number the operator sees, never the internal workspace id. */
+  workspaceIdx?: number | null;
   placement?: "title" | "host" | "binding";
   surfaceVisible?: boolean;
   cwd: string;

package/src/common/niri-focus.mjs

@@ -7,8 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { presentGhosttySurface } from "./ghostty-present.mjs";
-import { projectSessionCards, sessionCardId } from "./session-cards.mjs";
-import { parseTerminalTitleBinding } from "./surface-bindings.mjs";
+import { sessionCardId } from "./session-cards.mjs";
 import {
   appIdForGhosttyFamily,
   canonicalGhosttyTerminalKey,

package/src/common/workspace-view.mjs

@@ -4,11 +4,7 @@
 //   - "changing workspace card membership, card visibility, or focused-card selection"
 // ---
 
-import {
-  canVerifyTabVisibility,
-  placeSessionWindow,
-  resolvePiSessionIdentity,
-} from "./niri-focus.mjs";
+import { canVerifyTabVisibility, placeSessionWindow } from "./niri-focus.mjs";
 import { projectSessionCards, sessionCardId } from "./session-cards.mjs";
 import { parseTerminalTitleBinding } from "./surface-bindings.mjs";
 import { canonicalGhosttyTerminalKey } from "./terminal-identity.mjs";
@@ -96,6 +92,8 @@ export function resolveWorkspaceView(windows, workspace, sessions, options = {})
     groups.set(candidate.cardId, group);
   }
 
+  // The number the operator sees in the workspace list, not Niri's internal workspace id.
+  const workspaceIdx = Number.isInteger(workspace.idx) ? Number(workspace.idx) : null;
   const projectedSessions = [];
   for (const [cardId, group] of groups) {
     const windowIds = new Set(group.map((candidate) => candidate.window.id));
@@ -115,7 +113,9 @@ export function resolveWorkspaceView(windows, workspace, sessions, options = {})
     projectedSessions.push({
       ...card,
       cardId,
+      // A hidden tab has no window of its own, so this is the window hosting it.
       windowId: window?.id,
+      workspaceIdx,
       placement,
       // Only a tab proven to sit behind another one is marked hidden.
       surfaceVisible: visibility !== "hidden",

package/src/native/main.mjs

@@ -6,10 +6,6 @@
 // ---
 
 import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { createActivityStripBroker } from "../broker/server.mjs";
 import { createLatestOnlyRunner } from "../common/alignment-controller.mjs";
@@ -21,6 +17,7 @@ import { resolveFocusedWorkspaceView } from "../common/workspace-view.mjs";
 import { discoverAgentTabs } from "./agent-discovery.mjs";
 import { startAkTaskProjection } from "./ak-runtime.mjs";
 import { createHeightRepair } from "./height-repair.mjs";
+import { resolvePanelBinary } from "./panel-binary.mjs";
 import { createNativePanelProjection } from "./panel-projection.mjs";
 import { createPlacementRuntime } from "./placement.mjs";
 import { createThemeRuntime, THEME_POLL_INTERVAL_MS } from "./theme-runtime.mjs";
@@ -30,8 +27,6 @@ import { createNiriWorkspaceEventWatcher } from "./workspace-events.mjs";
 /** @typedef {import("node:child_process").ChildProcessWithoutNullStreams & {_activityBuffer?: string; _readyTimer?: NodeJS.Timeout; _stableTimer?: NodeJS.Timeout}} PanelChild */
 /** @typedef {{type: string; protocol?: number; revision?: number; visible?: boolean; sessions?: Array<Record<string, unknown>>; [key: string]: unknown}} PanelMessage */
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const packageRoot = path.resolve(__dirname, "..", "..");
 const execFileAsync = promisify(execFile);
 
 /** @type {import("../broker/server.mjs").ActivityStripBroker | null} */
@@ -94,49 +89,6 @@ const placement = createPlacementRuntime({
   onBindingsLearned: () => reconcileRunner.request(),
 });
 
-function panelBinaryPath() {
-  const override = process.env.PI_ACTIVITY_STRIP_NATIVE_PANEL_BIN?.trim();
-  const allowUnverified = process.env.PI_ACTIVITY_STRIP_ALLOW_UNVERIFIED_PANEL === "1";
-  const candidates = [
-    ...(override ? [override] : []),
-    path.join(packageRoot, "native", "bin", "linux-x64-gnu", "pi-activity-strip-panel"),
-    ...(allowUnverified
-      ? [path.join(packageRoot, "native", "panel", "target", "release", "pi-activity-strip-panel")]
-      : []),
-  ].filter(Boolean);
-  const binary = candidates.find((candidate) => {
-    try {
-      fs.accessSync(candidate, fs.constants.X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  if (!binary) {
-    throw new Error(`Native panel binary is unavailable. Checked: ${candidates.join(", ")}`);
-  }
-  if (allowUnverified) return binary;
-  if (process.platform !== "linux" || process.arch !== "x64") {
-    throw new Error(`Native panel requires Linux x64, got ${process.platform} ${process.arch}.`);
-  }
-  const artifactPath = path.join(path.dirname(binary), "artifact.json");
-  let artifact;
-  try {
-    artifact = JSON.parse(fs.readFileSync(artifactPath, "utf8"));
-  } catch {
-    throw new Error(`Native panel receipt is unavailable: ${artifactPath}`);
-  }
-  const digest = createHash("sha256").update(fs.readFileSync(binary)).digest("hex");
-  if (
-    artifact.schema !== "pi-activity-strip-native-artifact.v1" ||
-    artifact.target !== "x86_64-unknown-linux-gnu" ||
-    artifact.sha256 !== digest
-  ) {
-    throw new Error("Native panel binary does not match its reviewed artifact receipt.");
-  }
-  return binary;
-}
-
 /** @param {PanelMessage} message */
 function writePanel(message) {
   if (!panelReady || !panelWriteReady || !panel?.stdin?.writable) {
@@ -297,9 +249,8 @@ function consumePanelEvents(child, chunk) {
 
 function startPanel() {
   if (shuttingDown) return;
-  const binary = panelBinaryPath();
   /** @type {PanelChild} */
-  const child = spawn(binary, [], {
+  const child = spawn(resolvePanelBinary(process.env), [], {
     env: process.env,
     stdio: ["pipe", "pipe", "pipe"],
   });
@@ -475,6 +426,7 @@ async function main() {
         if (placement.forgetWindow(windowId)) reconcileRunner.request();
       },
       onWindowFocusChanged: () => reconcileRunner.request(),
+      onWorkspacesChanged: () => reconcileRunner.request(),
       fallbackMs: ACTIVITY_STRIP_WORKSPACE_SYNC_MS,
     });
   }

package/src/native/panel-binary.mjs

@@ -0,0 +1,56 @@
+// ---
+// summary: "locates the native panel binary and verifies it against its reviewed artifact receipt"
+// read_when:
+//   - "changing which panel binary the controller starts or how its receipt is checked"
+// ---
+
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+/** @param {NodeJS.ProcessEnv} env */
+export function resolvePanelBinary(env) {
+  const override = env.PI_ACTIVITY_STRIP_NATIVE_PANEL_BIN?.trim();
+  const allowUnverified = env.PI_ACTIVITY_STRIP_ALLOW_UNVERIFIED_PANEL === "1";
+  const candidates = [
+    ...(override ? [override] : []),
+    path.join(packageRoot, "native", "bin", "linux-x64-gnu", "pi-activity-strip-panel"),
+    ...(allowUnverified
+      ? [path.join(packageRoot, "native", "panel", "target", "release", "pi-activity-strip-panel")]
+      : []),
+  ].filter(Boolean);
+  const binary = candidates.find((candidate) => {
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  if (!binary) {
+    throw new Error(`Native panel binary is unavailable. Checked: ${candidates.join(", ")}`);
+  }
+  if (allowUnverified) return binary;
+  if (process.platform !== "linux" || process.arch !== "x64") {
+    throw new Error(`Native panel requires Linux x64, got ${process.platform} ${process.arch}.`);
+  }
+  const artifactPath = path.join(path.dirname(binary), "artifact.json");
+  let artifact;
+  try {
+    artifact = JSON.parse(fs.readFileSync(artifactPath, "utf8"));
+  } catch {
+    throw new Error(`Native panel receipt is unavailable: ${artifactPath}`);
+  }
+  const digest = createHash("sha256").update(fs.readFileSync(binary)).digest("hex");
+  if (
+    artifact.schema !== "pi-activity-strip-native-artifact.v1" ||
+    artifact.target !== "x86_64-unknown-linux-gnu" ||
+    artifact.sha256 !== digest
+  ) {
+    throw new Error("Native panel binary does not match its reviewed artifact receipt.");
+  }
+  return binary;
+}

package/src/native/panel-projection.mjs

@@ -11,7 +11,7 @@ import { projectSessionCards, sessionRecordKey } from "../common/session-cards.m
 /** @typedef {Record<string, unknown>} SessionRecord */
 /** @typedef {{generatedAt: number; sessions: SessionRecord[]}} Snapshot */
 /** @typedef {{workspace: Record<string, unknown> | null; sessions: SessionRecord[]; focusedSessionId: string | null; focusedCardId?: string | null}} WorkspaceView */
-/** @typedef {{placement: string; surfaceVisible: boolean; windowId: number | null}} CardPlacement */
+/** @typedef {{placement: string; surfaceVisible: boolean; windowId: number | null; workspaceIdx: number | null}} CardPlacement */
 /** @typedef {{isNiriSession: () => boolean; publish: (view: Record<string, unknown> & {type: string; sessions: SessionRecord[]}) => void}} NativePanelProjectionOptions */
 
 /** @param {NativePanelProjectionOptions} options */
@@ -137,6 +137,9 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
             placement: String(session.placement ?? "title"),
             surfaceVisible: session.surfaceVisible !== false,
             windowId: Number.isInteger(session.windowId) ? Number(session.windowId) : null,
+            workspaceIdx: Number.isInteger(session.workspaceIdx)
+              ? Number(session.workspaceIdx)
+              : null,
           },
         ]),
       );

package/src/native/workspace-events.mjs

@@ -9,6 +9,8 @@
  * stream while retaining the slower poll as a fail-closed fallback. Window
  * open/change/close and focus events are forwarded so title changes that reveal
  * a Ghostty tab, or windows moving between workspaces, are seen between polls.
+ * Workspace list changes are forwarded too, because reordering or removing a
+ * workspace renumbers the focused one without activating anything.
  * @param {{
  *   spawn: typeof import("node:child_process").spawn;
  *   env: NodeJS.ProcessEnv;
@@ -17,6 +19,7 @@
  *   onWindowChanged?: (window: Record<string, unknown>) => void;
  *   onWindowClosed?: (windowId: number) => void;
  *   onWindowFocusChanged?: (windowId: number | null) => void;
+ *   onWorkspacesChanged?: () => void;
  *   fallbackMs: number;
  *   setIntervalFn?: typeof setInterval;
  *   clearIntervalFn?: typeof clearInterval;
@@ -57,6 +60,9 @@ export function createNiriWorkspaceEventWatcher(options) {
             lastFocusedWorkspaceId = activation.id;
             options.onFocusedWorkspace(activation.id);
           }
+          if (event && typeof event === "object" && "WorkspacesChanged" in event) {
+            options.onWorkspacesChanged?.();
+          }
           const changedWindow = event?.WindowOpenedOrChanged?.window;
           if (changedWindow && typeof changedWindow === "object") {
             options.onWindowChanged?.(changedWindow);