@tryinget/pi-activity-strip 0.4.0 → 0.5.0

package/README.md

@@ -1,91 +1,77 @@
 ---
-summary: "Top-row live activity strip for local Pi sessions running in Ghostty or other terminals."
+summary: "Native Niri layer-shell activity ribbon for live Pi sessions."
 read_when:
   - "Starting work in this package workspace."
-  - "Installing or verifying the activity strip in Pi."
+  - "Installing or verifying the Activity Strip in Pi."
 system4d:
-  container: "Monorepo package for a local broker + Electron overlay + Pi extension telemetry seam."
-  compass: "Make Pi session activity visible at a glance without changing the operator's normal terminal workflow."
-  engine: "Pi extension emits session telemetry -> local broker aggregates -> top-row Electron strip renders live state."
-  fog: "Main risks are runtime drift across Pi host versions, Electron availability, and stale-session behavior under real long-running work."
+  container: "Monorepo package with a Node telemetry broker/controller and native GTK4 layer-shell panel."
+  compass: "Show exact workspace-local Pi activity without changing normal terminal workflows or mutating compositor configuration."
+  engine: "Pi telemetry -> local broker -> Niri workspace projection -> native layer-shell panel."
+  fog: "Main risks are native ABI availability, stale-session identity, and unverified multi-output behavior."
 ---
 
 # @tryinget/pi-activity-strip
 
-A Pi extension package that gives you a **screen-top activity strip** showing what your live Pi sessions are doing.
+A screen-top activity ribbon for live Pi sessions running in Ghostty.
 
-This package is designed for the exact workflow you asked for:
-- multiple Ghostty tabs
-- multiple Pi sessions
-- a persistent top-row ribbon
-- fine-grained live detail without changing how you normally run Pi
+The runtime is Electron-free. A Node controller retains the tested telemetry, identity, ordering, and exact-focus logic; a small Rust/Relm4/GTK4 panel owns rendering and the Wayland layer-shell surface.
 
 ## What it does
 
-- auto-starts a local top-row overlay when Pi starts in a TUI session
-- tracks each active Pi session independently
-- on Niri, shows one card per tracked live Pi terminal on only the focused workspace; non-Niri desktops retain the global live-session view
-- surfaces:
-  - repo/session label
-  - current phase
-  - current tool or target
-  - fine-grained detail text
-  - elapsed time plus last-seen freshness
-  - state color (`thinking`, `tool`, `waiting`, `done`, `error`)
-- keeps a local broker so multiple Pi processes can report into one strip
-- marks the Pi session in the currently focused Niri/Ghostty terminal with a stronger border and left rail, without adding another label
-- keeps green `done`/`monitoring` cards directly beside the Activity tile, followed by active work and then other settled sessions, on a calm 15-second ordering clock
-- reveals prompt, response, path, and full activity detail on hover or keyboard focus
-- focuses the exact matching Ghostty/Niri window on click or Enter, failing closed when identity is missing or ambiguous
-- keeps an aligned strip resident on its Niri workspace while that workspace still has tracked terminals, so visiting an empty workspace does not unmap or reposition it
+- auto-starts with interactive Pi TUI sessions
+- shows one card per admitted Ghostty terminal on the focused Niri workspace
+- aggregates independent publishers beneath stable terminal cards
+- displays repo, phase, tool, detail, elapsed time, and freshness
+- marks the exact currently focused terminal card
+- 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
+- focuses the exact matching Ghostty window on click or Enter
+- hides completely on workspaces without tracked cards
+- releases its 84px exclusive zone automatically when hidden or crashed
 
 ## Architecture
 
 ```text
-Pi session
-  -> activity-strip extension
-  -> local unix-socket broker
-  -> Electron top-row overlay
+Pi publisher streams
+  -> Node Unix-socket broker and session store
+  -> exact terminal identity + Niri workspace projection
+  -> versioned NDJSON child protocol
+  -> Rust / Relm4 / GTK4 panel
+  -> wlr-layer-shell top surface with an 84px exclusive zone
 ```
 
-This is intentionally **local-first**.
-It does not require moving your workflow onto `pi-server` first.
+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.
 
-## Current scope
+The compact surface is 84px tall. One engaged card expands the surface to 252px while the exclusive zone remains 84px, so detail overlays content without repeatedly resizing tiled windows.
 
-Implemented now:
-- local per-host broker
-- primary-display top-row strip
-- one card per tracked live Pi terminal on the focused Niri workspace, regardless of activity state
-- headless-safe telemetry publishing
-- explicit open/focus-strip/focus-session/status/doctor/snapshot/fix-top/stop commands
-- focus-scoped Left/Right navigation and Shift+Left/Right manual card movement
-- local visual capture helpers so the agent can inspect the strip directly
-
-Not implemented yet:
-- multi-monitor strip replication
-- historical timeline
-- persisted manual card order across strip restarts
-- remote observers via `pi-server`
+## Supported host
 
-## Installation in Pi
+The packaged native artifact currently supports:
 
-From this package directory:
+- Linux x86_64
+- Wayland
+- a compositor implementing `wlr-layer-shell` (dogfooded on Niri 26.04)
+- GTK4 and gtk4-layer-shell runtime libraries
+
+On Arch Linux:
 
 ```bash
-cd ~/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip
-pi install "$PWD"
+sudo pacman -S gtk4 gtk4-layer-shell
 ```
 
-Then for **existing Pi tabs**:
-- run `/reload` in each tab you want tracked
+Multi-output replication remains unimplemented. The current surface is single-output and must not be described as multi-monitor complete.
 
-For **new Pi tabs**:
-- the package will load automatically from your Pi settings
+## Installation
+
+```bash
+cd ~/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip
+pi install "$PWD"
+```
 
-## Operator commands
+Reload already-running Pi tabs with `/reload`. New tabs load the package automatically.
 
-### Package-local CLI
+## Commands
 
 ```bash
 npm run strip:open
@@ -96,7 +82,7 @@ npm run strip:fix-top
 npm run strip:stop
 ```
 
-or directly:
+Direct CLI:
 
 ```bash
 node ./bin/pi-activity-strip.mjs open
@@ -105,130 +91,88 @@ node ./bin/pi-activity-strip.mjs focus-session <full-pi-session-id>
 node ./bin/pi-activity-strip.mjs status
 node ./bin/pi-activity-strip.mjs doctor
 node ./bin/pi-activity-strip.mjs snapshot
-node ./bin/pi-activity-strip.mjs fix-top
+node ./bin/pi-activity-strip.mjs stop
 ```
 
-### Pi slash commands
+`fix-top` is now a compatibility no-op: layer-shell placement is compositor-owned.
 
-Inside Pi:
+## Keyboard-only entry
 
-```text
-/activity-strip
-/activity-strip status
-/activity-strip doctor
-/activity-strip fix-top
-/activity-strip stop
-/activity-strip-stop
-```
-
-In Pi with UI support:
-- `/activity-strip status` opens a detailed runtime status report when an editor surface is available
-- `/activity-strip doctor` opens the host-compatibility report
-
-## Interaction model
-
-- **Workspace locality:** one strip follows the Niri workspace selected with Up/Down and renders only tracked Pi terminals whose exact Ghostty windows are on that workspace. Focused-workspace events trigger reconciliation immediately, with polling retained as a fallback. When an empty workspace is visited, an aligned strip whose resident workspace still has tracked terminals remains rendered on that prior workspace; Niri keeps it off the empty workspace and returning brings the already-positioned strip back with its row. If its resident terminals disappear, the renderer is concealed and input-disabled. When an actual remap or floating correction is unavoidable, reveal waits beyond Niri's compositor movement animation and then re-verifies placement and membership. The broker remains global and non-Niri desktops retain the global card view.
-- **Ordering:** green `done` cards whose footer reads `monitoring` stay at the far left beside the Activity tile. Active tool/thinking/waiting cards follow, then other settled cards. The group order refreshes every 15 seconds rather than on every telemetry packet; text and timers still update live.
-- **Current terminal:** on Niri, the card matching the focused Ghostty window gets a stronger border and left rail without an extra label. Matching uses the same exact session-title identity seam as click-to-focus and fails closed when focus or identity is missing or ambiguous.
-- **Pointer:** hover expands the strip and reveals detail, last prompt, assistant preview, and path. Leaving the strip or activating another window collapses it immediately. Single click asks Niri to focus the one Ghostty title carrying that exact Pi session-id suffix.
-- **Keyboard inside the strip:** Left/Right changes card focus, Enter activates the focused card, and Shift+Left/Right manually moves it. Manual movement lasts until a later activity regroup or runtime restart.
-- **Fail-closed focus:** current telemetry uses the exact Pi identity directly. For already-running tabs that still publish a legacy broker id, the strip may recover only the process-bound `pi-session-presence` sidecar when its source, PID, and cwd all agree; this is not repo-name guessing or arbitrary-PID focusing. If identity still matches zero or multiple Ghostty windows, focus does nothing and asks for one `/reload`.
-
-### Keyboard-only entry on Niri
-
-The package deliberately does not reserve a global Electron shortcut. Bind one compositor key to the fail-closed CLI entrypoint instead:
+Bind a Niri key to the fail-closed CLI entrypoint:
 
 ```kdl
 binds {
-    Mod+Shift+A { spawn "node" "/home/tryinget/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip/bin/pi-activity-strip.mjs" "focus-strip"; }
+    Mod+Shift+A repeat=false allow-inhibiting=false hotkey-overlay-title="Toggle Pi Activity Ribbon keyboard mode" { spawn "/usr/bin/node" "/home/tryinget/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip/bin/pi-activity-strip.mjs" "focus-strip"; }
 }
 ```
 
-`focus-strip` gives keyboard focus only to the unique strip already resident on the currently focused workspace; it never moves a strip between workspaces. When the focused workspace has no tracked live Pi terminals, the command fails closed rather than forcing an empty bar into view. This keeps shortcut ownership explicit in Niri and avoids application-level global-key collisions.
-
-## Verification commands
+The shortcut toggles exclusive keyboard mode. On entry, the first card is selected. Left/Right wraps through cards, Shift+Left/Right moves the selected card with wraparound, Enter focuses its exact Ghostty terminal and exits, and Escape or a second shortcut press exits without activation. Space does not activate a card. Pointer hover expands detail but deliberately does not capture keyboard input. Empty workspaces and click-through mode reject keyboard entry.
 
-### Package checks
+## Interaction contract
 
-```bash
-npm install
-npm run check
-npm run release:check:quick
-```
+- **Workspace locality:** Niri focus events 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.
+- **Ordering:** monitoring, active, and settled groups refresh on a calm 15-second clock. Manual moves survive until regroup or restart.
+- **Accessibility:** cards expose native GTK labels, selected/expanded state, activation descriptions, and GTK accessible announcements.
 
-### Run the strip locally
-
-```bash
-npm run strip:open
-npm run strip:status
-npm run strip:doctor
-npm run strip:snapshot
-```
-
-### Capture what the agent should inspect
+## Environment controls
 
-```bash
-npm run capture:strip   # just the Pi activity strip window
-npm run capture:top     # top band of the focused output, including the strip + upper window area
-```
+- `PI_ACTIVITY_STRIP_AUTO_START=0` disables extension autostart.
+- `PI_ACTIVITY_STRIP_CLICK_THROUGH=1` installs an empty Wayland input region and disables keyboard entry.
+- `PI_ACTIVITY_STRIP_NATIVE_PANEL_BIN=/absolute/path` selects another receipted panel artifact.
+- `PI_ACTIVITY_STRIP_SOCKET_DIR` and `PI_ACTIVITY_STRIP_SOCKET_PATH` isolate broker fixtures and nested-compositor tests.
 
-These are specifically useful so the agent can inspect the current visual state without you manually posting screenshots.
+Unverified native binaries are rejected unless `PI_ACTIVITY_STRIP_ALLOW_UNVERIFIED_PANEL=1` is explicitly set for development fixtures.
 
-### Simulate multiple sessions
+## Verification
 
 ```bash
-npm run demo:simulate
+npm run native:build   # exact Rust 1.98 build, tests, staged artifact receipt
+npm run check          # canonical Node/package quality gate
+npm run native:check   # Rust formatting and tests
+npm run release:check  # full packed install and native-artifact smoke
 ```
 
-### Real Pi smoke on the live broker
+The staged artifact receipt binds:
 
-```bash
-npm run smoke:headless-live
-```
+- binary SHA-256
+- Cargo lock SHA-256
+- complete Rust/CSS source SHA-256
+- Rust compiler version
+- glibc symbol floor
+- required shared libraries
 
-This smoke:
-- opens the strip
-- runs a real headless Pi session with this extension loaded
-- exercises a real tool call
-- verifies that the broker observed the session while it was active
-
-### Compatibility diagnostics
+Live verification must inspect Niri layers rather than regular windows:
 
 ```bash
-npm run strip:doctor
-node ./bin/pi-activity-strip.mjs doctor --json
+niri msg -j layers | jq '[.[] | select(.namespace == "pi-activity-strip")]'
 ```
 
-Use `doctor` before opening the strip when the host/display assumptions are uncertain. It reports:
-- whether a graphical session is present
-- whether Electron can be resolved
-- whether Niri-specific top-edge repair is available
-- whether the current setup is multi-display even though the strip remains primary-display-only
-
-## Environment controls
+## Current scope
 
-- `PI_ACTIVITY_STRIP_AUTO_START=0`
-  - disable automatic strip opening on Pi session start
-- `PI_ACTIVITY_STRIP_CLICK_THROUGH=1`
-  - opt out of interaction and restore a mouse-transparent overlay; interactive hover/click/keyboard behavior is the default
-- `PI_ACTIVITY_STRIP_ELECTRON_BIN=/path/to/electron`
-  - override Electron binary discovery
-- `GLIMPSE_ELECTRON_BIN=/path/to/electron`
-  - shared Electron override also respected
+Implemented:
 
-## Practical usage for your Ghostty tabs
+- local broker and telemetry publishers
+- native GTK4 layer-shell rendering
+- workspace-local Niri projection
+- hide/reclaim and restore
+- pointer and keyboard card interaction
+- exact Ghostty activation
+- bounded panel restart and parent-death cleanup
+- click-through input region
 
-If you want this for all current tabs:
+Not implemented:
 
-1. install the package once with `pi install`
-2. run `/reload` inside each already-open Pi tab
-3. open the strip once with `/activity-strip` or `npm run strip:open`
-4. from then on, every loaded Pi session should report into the same top-row ribbon
-5. ensure `pi-little-helpers` session presence is loaded when you want exact click-to-Ghostty focus; its `· <full-32-hex-session-id-token>` title suffix is the preferred fail-closed identity seam (an 8-hex legacy title remains usable only when no legacy duplicate or migrated full title shares its prefix)
+- one panel per output
+- historical timeline
+- persisted manual ordering
+- remote observers via `pi-server`
 
 ## References
 
 - [Project vision](docs/project/vision.md)
 - [Project resources](docs/project/resources.md)
-- [Verification notes](docs/project/verification.md)
-- [Next session prompt](next_session_prompt.md)
+- [Verification evidence](docs/project/verification.md)
+- [Superseded adaptive-strut design investigation](docs/project/2026-08-31-adaptive-niri-space-design.md)

package/bin/pi-activity-strip.mjs

@@ -5,11 +5,11 @@
 //   - "operating or diagnosing the activity strip from a terminal"
 // ---
 
-import { execFile, spawn } from "node:child_process";
+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 { promisify } from "node:util";
 import {
   getBrokerStatus,
   isBrokerAlive,
@@ -20,61 +20,22 @@ import {
   assessActivityStripCompatibility,
   formatCompatibilityReport,
 } from "../src/common/compatibility.mjs";
-import { ACTIVITY_STRIP_START_TIMEOUT_MS } from "../src/common/constants.mjs";
-import { locateElectron } from "../src/common/electron.mjs";
-import { focusNiriStrip, resolveActivityStripWindow } from "../src/common/niri-focus.mjs";
+import {
+  ACTIVITY_STRIP_SOCKET_DIR,
+  ACTIVITY_STRIP_START_TIMEOUT_MS,
+} from "../src/common/constants.mjs";
 import { makeMessage } from "../src/common/protocol.mjs";
 import { formatBrokerRuntimeStatus } from "../src/common/status-report.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const electronEntry = path.resolve(__dirname, "..", "src", "electron", "main.mjs");
-const execFileAsync = promisify(execFile);
+const nativeEntry = path.resolve(__dirname, "..", "src", "native", "main.mjs");
+const runtimeLockPath = path.join(ACTIVITY_STRIP_SOCKET_DIR, "runtime.lock");
 
 function usage() {
   console.log(
-    `Usage: pi-activity-strip <open|focus-strip|focus-session|status|doctor|snapshot|fix-top|stop|serve> [options]\n\nCommands:\n  open              Start the interactive top-row activity strip (--click-through opts out)\n  focus-strip       Focus the visible strip already resident on the focused Niri workspace\n  focus-session ID  Focus the one Ghostty/Niri window matching an exact Pi session identity\n  status            Check broker + overlay readiness and surface runtime warnings\n  doctor            Inspect host compatibility assumptions before opening the strip\n  snapshot          Print the current broker snapshot as JSON\n  fix-top           Move the strip window flush to the top edge in Niri\n  stop              Ask the running strip to shut down\n  serve             Internal helper; starts the Electron shell in the foreground\n`,
-  );
-}
-
-async function moveStripToTop() {
-  const { stdout } = await execFileAsync("niri", ["msg", "-j", "windows"], {
-    env: process.env,
-  });
-  const windows = JSON.parse(stdout);
-  if (!Array.isArray(windows)) {
-    throw new Error("Unexpected niri windows payload");
-  }
-
-  const stripWindow = resolveActivityStripWindow(windows);
-  if (!stripWindow) {
-    throw new Error("Could not find one unique Pi Activity Strip window in niri");
-  }
-
-  const layout = /** @type {{ tile_pos_in_workspace_view?: unknown[] }} */ (
-    stripWindow.layout ?? {}
+    `Usage: pi-activity-strip <open|focus-strip|focus-session|status|doctor|snapshot|fix-top|stop|serve> [options]\n\nCommands:\n  open              Start the interactive top-row activity strip (--click-through opts out)\n  focus-strip       Focus the visible strip already resident on the focused Niri workspace\n  focus-session ID  Focus the one Ghostty/Niri window matching an exact Pi session identity\n  status            Check broker + overlay readiness and surface runtime warnings\n  doctor            Inspect host compatibility assumptions before opening the strip\n  snapshot          Print the current broker snapshot as JSON\n  fix-top           Confirm compositor-owned layer-shell placement\n  stop              Ask the running strip to shut down\n  serve             Internal helper; starts the native runtime in the foreground\n`,
   );
-  const currentY = Number(layout.tile_pos_in_workspace_view?.[1] ?? 0);
-  if (Math.abs(currentY) < 1) {
-    return 0;
-  }
-
-  await execFileAsync(
-    "niri",
-    [
-      "msg",
-      "action",
-      "move-floating-window",
-      "--id",
-      String(stripWindow.id),
-      "-y",
-      String(-Math.round(currentY)),
-    ],
-    { env: process.env },
-  );
-
-  console.log("Moved activity strip to the top edge.");
-  return 0;
 }
 
 async function waitForBrokerReady(timeoutMs = ACTIVITY_STRIP_START_TIMEOUT_MS) {
@@ -111,8 +72,19 @@ async function waitForBrokerReady(timeoutMs = ACTIVITY_STRIP_START_TIMEOUT_MS) {
 /** @param {{ detached?: boolean }} [options] @returns {Promise<number>} */
 async function openStrip({ detached = true } = {}) {
   if (await isBrokerAlive()) {
-    console.log("Activity strip is already running.");
-    return 0;
+    const status = await getBrokerStatus({ expectReply: true }).catch(() => null);
+    if (status?.runtimeStatus?.state !== "error") {
+      console.log("Activity strip is already running.");
+      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));
+      return 1;
+    }
   }
 
   const compatibility = await assessActivityStripCompatibility();
@@ -121,11 +93,11 @@ async function openStrip({ detached = true } = {}) {
     return 1;
   }
 
-  const electron = await locateElectron();
-  const child = spawn(electron, [electronEntry], {
+  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,
+    env: { ...process.env, PI_ACTIVITY_STRIP_RUNTIME_LOCK_HELD: "1" },
   });
 
   if (detached) {
@@ -166,7 +138,9 @@ async function main() {
           process.exitCode = 1;
           return;
         }
-        const result = await focusNiriStrip(execFileAsync, process.env, status?.snapshot?.sessions);
+        const result = await sendBrokerMessage(makeMessage("focus-strip"), {
+          expectReply: true,
+        });
         if (!result.ok) console.error(result.error || "Strip focus did nothing.");
         process.exitCode = result.ok ? 0 : 1;
       } catch {
@@ -234,15 +208,10 @@ async function main() {
       }
       return;
     }
-    case "fix-top": {
-      try {
-        process.exitCode = await moveStripToTop();
-      } catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exitCode = 1;
-      }
+    case "fix-top":
+      console.log("Native layer-shell placement is compositor-owned; no repair was needed.");
+      process.exitCode = 0;
       return;
-    }
     case "stop": {
       try {
         const result = await requestBrokerShutdown();

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

@@ -0,0 +1,21 @@
+{
+  "schema": "pi-activity-strip-native-artifact.v1",
+  "target": "x86_64-unknown-linux-gnu",
+  "sha256": "4cc72663dda90369a3a3ad60aabeefc4a609f42c6cc4a4661d2dc052570a3f0a",
+  "cargoLockSha256": "f8ebc11bc721c569af982169e448a5ea4fed15bc06001017d97acda22b1c890b",
+  "sourceSha256": "9467e315aa20fef76c25b88d29e69f3ef6960481b55b639c602e77805986f0e1",
+  "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+  "glibcFloor": "GLIBC_2.34",
+  "neededSonames": [
+    "libgtk4-layer-shell.so.0",
+    "libgtk-4.so.1",
+    "libcairo.so.2",
+    "libgio-2.0.so.0",
+    "libgobject-2.0.so.0",
+    "libglib-2.0.so.0",
+    "libgcc_s.so.1",
+    "libm.so.6",
+    "libc.so.6",
+    "ld-linux-x86-64.so.2"
+  ]
+}