@tryinget/pi-activity-strip 0.5.0 → 0.6.0

package/src/native/height-repair.mjs

@@ -0,0 +1,154 @@
+// ---
+// summary: "restores tiled windows stranded at the wrong height when the ribbon's exclusive zone appears or disappears"
+// read_when:
+//   - "changing height repair, its evidence rules, or its safety bounds"
+// ---
+
+export const HEIGHT_REPAIR_SETTLE_MS = 300;
+export const HEIGHT_REPAIR_MAX_PER_TRANSITION = 48;
+
+/** @typedef {{id?: unknown; is_floating?: unknown; layout?: {window_size?: number[]}}} NiriWindow */
+/** @typedef {{id: number; height: number}} StaleWindow */
+
+/** @param {NiriWindow} window */
+function tiledHeight(window) {
+  if (window?.is_floating === true) return 0;
+  const height = Number(window?.layout?.window_size?.[1] ?? 0);
+  return Number.isFinite(height) && height > 0 ? height : 0;
+}
+
+/** @param {NiriWindow[]} windows */
+function heightsById(windows) {
+  /** @type {Map<number, number>} */
+  const heights = new Map();
+  for (const window of windows ?? []) {
+    if (!Number.isInteger(window?.id)) continue;
+    const height = tiledHeight(window);
+    if (height > 0) heights.set(Number(window.id), height);
+  }
+  return heights;
+}
+
+/**
+ * Decide which windows the compositor left behind. Changing the exclusive zone changes the output
+ * working area, so every window whose height is automatic moves. A window that did not move while
+ * others did is only treated as stale when it still sits at a height those movers just vacated:
+ * that is positive evidence of the old working area, so a deliberately chosen height of any other
+ * value is never touched.
+ * @param {NiriWindow[]} before
+ * @param {NiriWindow[]} after
+ * @returns {StaleWindow[]}
+ */
+export function findStaleWindows(before, after) {
+  const previous = heightsById(before);
+  const current = heightsById(after);
+  /** @type {Set<number>} */
+  const vacated = new Set();
+  for (const [id, height] of current) {
+    const wasHeight = previous.get(id);
+    if (wasHeight !== undefined && wasHeight !== height) vacated.add(wasHeight);
+  }
+  if (vacated.size === 0) return [];
+
+  /** @type {StaleWindow[]} */
+  const stale = [];
+  for (const [id, height] of current) {
+    const wasHeight = previous.get(id);
+    if (wasHeight === undefined || wasHeight !== height) continue;
+    if (vacated.has(height)) stale.push({ id, height });
+  }
+  return stale.sort((left, right) => left.id - right.id);
+}
+
+/**
+ * @param {{
+ *   execFileAsync: (file: string, args: string[], options: object) => Promise<{stdout?: string}>;
+ *   env?: NodeJS.ProcessEnv;
+ *   runtimeStatus: import("../common/contracts.ts").ActivityStripRuntimeStatus;
+ *   readWindows: () => Promise<NiriWindow[]>;
+ *   sleep?: (milliseconds: number) => Promise<void>;
+ *   settleMs?: number;
+ * }} options
+ */
+export function createHeightRepair({
+  execFileAsync,
+  env = process.env,
+  runtimeStatus,
+  readWindows,
+  sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  settleMs = HEIGHT_REPAIR_SETTLE_MS,
+}) {
+  const enabled = env.PI_ACTIVITY_STRIP_HEIGHT_REPAIR !== "0";
+  /** @type {NiriWindow[]} */
+  let lastWindows = [];
+  /** Windows already reset at a given height, so one pass can never loop on one window. */
+  /** @type {Set<string>} */
+  const repaired = new Set();
+  let inFlight = false;
+  runtimeStatus.heightRepairState = enabled ? "enabled" : "disabled";
+  runtimeStatus.heightRepairCount = 0;
+  runtimeStatus.lastHeightRepairAt = 0;
+
+  /** @param {NiriWindow[]} windows */
+  function observe(windows) {
+    if (!Array.isArray(windows) || windows.length === 0) return;
+    // A window seen at a height other than the one it was reset at has moved since, so a future
+    // stranding there is a new event and must not be suppressed by the earlier repair.
+    for (const window of windows) {
+      if (!Number.isInteger(window?.id)) continue;
+      const height = tiledHeight(window);
+      if (height <= 0) continue;
+      for (const key of repaired) {
+        const [id, at] = key.split(":");
+        if (Number(id) === Number(window.id) && Number(at) !== height) repaired.delete(key);
+      }
+    }
+    lastWindows = windows;
+  }
+
+  /**
+   * Run after the panel reports that it applied a visibility change, which is the only moment the
+   * exclusive zone changes. One pass at a time; a pass never retries a window it already reset.
+   */
+  async function repairAfterZoneChange() {
+    if (!enabled || inFlight) return [];
+    const before = lastWindows;
+    if (before.length === 0) return [];
+    inFlight = true;
+    try {
+      await sleep(settleMs);
+      const after = await readWindows();
+      if (after.length === 0) return [];
+      lastWindows = after;
+      const stale = findStaleWindows(before, after).filter(
+        (window) => !repaired.has(`${window.id}:${window.height}`),
+      );
+      const bounded = stale.slice(0, HEIGHT_REPAIR_MAX_PER_TRANSITION);
+      /** @type {number[]} */
+      const applied = [];
+      for (const window of bounded) {
+        try {
+          await execFileAsync(
+            "niri",
+            ["msg", "action", "reset-window-height", "--id", String(window.id)],
+            { env },
+          );
+          repaired.add(`${window.id}:${window.height}`);
+          applied.push(window.id);
+        } catch {
+          // A window that closed mid-pass, or a rejected action, is left to the next transition.
+        }
+      }
+      if (applied.length > 0) {
+        runtimeStatus.heightRepairCount =
+          Number(runtimeStatus.heightRepairCount ?? 0) + applied.length;
+        runtimeStatus.lastHeightRepairAt = Date.now();
+      }
+      return applied;
+    } finally {
+      inFlight = false;
+    }
+  }
+
+  return { observe, repairAfterZoneChange, enabled };
+}

package/src/native/main.mjs

@@ -13,15 +13,17 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { createActivityStripBroker } from "../broker/server.mjs";
 import { createLatestOnlyRunner } from "../common/alignment-controller.mjs";
+import { pruneClaudeEventRecords } from "../common/claude-events.mjs";
 import { ACTIVITY_STRIP_WORKSPACE_SYNC_MS } from "../common/constants.mjs";
-import {
-  focusNiriSession,
-  readNiriWindows,
-  readNiriWorkspaces,
-  resolveFocusedWorkspaceView,
-} from "../common/niri-focus.mjs";
+import { focusNiriSession, readNiriWindows, readNiriWorkspaces } from "../common/niri-focus.mjs";
 import { haveSameRecordMembership } from "../common/session-cards.mjs";
+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 { createNativePanelProjection } from "./panel-projection.mjs";
+import { createPlacementRuntime } from "./placement.mjs";
+import { createThemeRuntime, THEME_POLL_INTERVAL_MS } from "./theme-runtime.mjs";
 import { createNiriWorkspaceEventWatcher } from "./workspace-events.mjs";
 
 /** @typedef {import("../common/contracts.ts").ActivityStripRuntimeStatus} ActivityStripRuntimeStatus */
@@ -66,6 +68,15 @@ const runtimeStatus = {
   lastMovedCardId: null,
   rendererCardCount: 0,
   rendererCardIds: [],
+  rendererHiddenTabCardCount: 0,
+  agentTabCount: 0,
+  surfaceBindingCount: 0,
+  unplacedSurfaceCount: 0,
+  tabInventoryState: process.env.PI_ACTIVITY_STRIP_TAB_INVENTORY === "0" ? "disabled" : "pending",
+  tabInventoryDetail: null,
+  tabInventoryFrameCount: 0,
+  tabInventoryTabCount: 0,
+  tabInventoryProbedAt: null,
   warnings: [],
   error: null,
 };
@@ -74,6 +85,15 @@ function isNiriSession() {
   return Boolean(process.env.NIRI_SOCKET);
 }
 
+// Hidden Ghostty tabs are placed by their own runtime: host-process containment plus the window
+// memory learned from visible titles and the bounded AT-SPI tab inventory.
+const placement = createPlacementRuntime({
+  env: process.env,
+  runtimeStatus,
+  execFileAsync,
+  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";
@@ -150,19 +170,32 @@ const projection = createNativePanelProjection({
   publish(view) {
     runtimeStatus.rendererCardCount = view.sessions.length;
     runtimeStatus.rendererCardIds = view.sessions.map((session) => String(session.cardId ?? ""));
+    runtimeStatus.rendererHiddenTabCardCount = view.sessions.filter(
+      (session) => session.surfaceVisible === false,
+    ).length;
+    runtimeStatus.akTaskRenderedCount = view.sessions.reduce(
+      (total, session) => total + (Array.isArray(session.akTasks) ? session.akTasks.length : 0),
+      0,
+    );
     writePanel(view);
   },
 });
 
-/** @param {string} targetId @returns {Promise<{ok: boolean; error?: string; windowId?: number}>} */
+// AK task references are a read-only projection of claims held by live sessions; the strip
+// never writes AK state and renders nothing when the read fails.
+startAkTaskProjection({ execFileAsync, env: process.env, runtimeStatus, projection });
+
+/** @param {string} targetId @returns {Promise<{ok: boolean; error?: string; windowId?: number; presented?: boolean; verified?: boolean}>} */
 async function focusSession(targetId) {
   const session = projection.resolveTarget(targetId);
   if (!session) {
     return { ok: false, error: "Session is no longer present or is ambiguous; focus did nothing." };
   }
-  const rawResult = await focusNiriSession(session, execFileAsync, process.env);
+  const rawResult = await focusNiriSession(session, execFileAsync, process.env, placement.options);
   const result = {
     ok: rawResult.ok === true,
+    presented: rawResult.presented === true,
+    verified: rawResult.verified === true,
     ...(typeof rawResult.error === "string" ? { error: rawResult.error } : {}),
     ...(Number.isInteger(rawResult.windowId) ? { windowId: Number(rawResult.windowId) } : {}),
   };
@@ -212,6 +245,7 @@ function consumePanelEvents(child, chunk) {
             }
           }, 30_000);
           child._stableTimer.unref?.();
+          theme.republish();
           if (pendingView) {
             const view = pendingView;
             pendingView = null;
@@ -220,7 +254,12 @@ function consumePanelEvents(child, chunk) {
             projection.send();
           }
         } else if (event.type === "visibility-applied") {
-          runtimeStatus.windowVisible = event.visible === true;
+          const visible = event.visible === true;
+          const changed = runtimeStatus.windowVisible !== visible;
+          runtimeStatus.windowVisible = visible;
+          // Showing or hiding the surface is the only moment the exclusive zone changes, so it is
+          // the only moment a tiled window can be left at the previous working area's height.
+          if (changed) void heightRepair.repairAfterZoneChange();
         } else if (event.type === "expanded") {
           runtimeStatus.panelExpanded = event.expanded === true;
         } else if (event.type === "activate") {
@@ -232,7 +271,11 @@ function consumePanelEvents(child, chunk) {
               cardId,
               ok: result.ok === true,
               message: result.ok
-                ? "Focused Ghostty window."
+                ? result.presented
+                  ? result.verified
+                    ? "Presented the hidden tab and focused its Ghostty window."
+                    : "Focused its Ghostty window and asked Ghostty to show the tab."
+                  : "Focused Ghostty window."
                 : result.error || "Focus failed; nothing moved.",
             }),
           );
@@ -310,6 +353,49 @@ const getNiriWindows = () =>
 const getNiriWorkspaces = () =>
   readNiriWorkspaces(execFileAsync, process.env, ACTIVITY_STRIP_WORKSPACE_SYNC_MS);
 
+// Agent tabs are read from the process table, not the broker, so they are refreshed on a calm
+// clock of their own rather than on every workspace event.
+const AGENT_SCAN_INTERVAL_MS = 3000;
+let agentScanAt = 0;
+
+function refreshAgentTabs() {
+  if (process.env.PI_ACTIVITY_STRIP_AGENT_TABS === "0") return;
+  if (Date.now() - agentScanAt < AGENT_SCAN_INTERVAL_MS) return;
+  agentScanAt = Date.now();
+  try {
+    const records = discoverAgentTabs({ env: process.env });
+    runtimeStatus.agentTabCount = records.length;
+    runtimeStatus.agentScanError = null;
+    projection.setAgentSessions(records);
+    // A session that dies without firing its end hook leaves a record behind; retire the ones no
+    // live tab claims so they cannot accumulate.
+    pruneClaudeEventRecords(
+      records
+        .filter((record) => record.agentKind === "claude" && record.agentSessionKey)
+        .map((record) => String(record.agentSessionKey)),
+    );
+  } catch (error) {
+    // Recorded on its own field: replacing the shared warning list would erase a panel error, and
+    // a transient scan failure must not leave a permanent warning behind.
+    runtimeStatus.agentScanError = error instanceof Error ? error.message : String(error);
+  }
+}
+
+// The ribbon reads Ghostty's own theme, so it follows the terminal into light and dark.
+const theme = createThemeRuntime({
+  execFileAsync,
+  env: process.env,
+  runtimeStatus,
+  publish: (definitions) => writePanel({ protocol: 1, type: "theme", definitions }),
+});
+
+const heightRepair = createHeightRepair({
+  execFileAsync,
+  env: process.env,
+  runtimeStatus,
+  readWindows: getNiriWindows,
+});
+
 const reconcileRunner = createLatestOnlyRunner(async ({ isCurrent }) => {
   if (!isNiriSession()) {
     projection.send();
@@ -317,18 +403,25 @@ const reconcileRunner = createLatestOnlyRunner(async ({ isCurrent }) => {
   }
   const [windows, workspaces] = await Promise.all([getNiriWindows(), getNiriWorkspaces()]);
   if (!isCurrent()) return;
-  const view = resolveFocusedWorkspaceView(windows, workspaces, projection.getRawSessions(), {
-    env: process.env,
-  });
+  placement.observeWindowList(windows);
+  heightRepair.observe(windows);
+  refreshAgentTabs();
+  runtimeStatus.surfaceBindingCount = placement.bindingCount;
+  const sessions = projection.getRawSessions();
+  runtimeStatus.unplacedSurfaceCount = placement.countUnplaced(windows, sessions);
+  const view = resolveFocusedWorkspaceView(windows, workspaces, sessions, placement.options);
+  if (view) placement.learnFromPlacements(view.sessions, windows);
   projection.publishWorkspaceView(
     view ?? { workspace: null, sessions: [], focusedSessionId: null, focusedCardId: null },
   );
+  void placement.scheduleInventory(windows);
 });
 
 async function shutdown(exitCode = 0) {
   if (shuttingDown) return;
   shuttingDown = true;
   watcher?.stop();
+  placement.persist();
   writePanel({
     protocol: 1,
     type: "view",
@@ -356,8 +449,10 @@ async function main() {
     }),
   });
   broker.on("snapshot", (snapshot) => {
+    // Compare like with like: the raw set also holds discovered agent tabs, which the broker
+    // never publishes, so comparing it to a broker snapshot would always differ and reconcile.
     const membershipChanged = !haveSameRecordMembership(
-      projection.getRawSessions(),
+      projection.getBrokerSessions(),
       snapshot.sessions,
     );
     projection.updateSnapshot(snapshot);
@@ -373,10 +468,21 @@ async function main() {
       env: process.env,
       onFocusedWorkspace: () => reconcileRunner.request(),
       onFallback: () => reconcileRunner.request(),
+      onWindowChanged: (window) => {
+        if (placement.observeWindowEvent(window)) reconcileRunner.request();
+      },
+      onWindowClosed: (windowId) => {
+        if (placement.forgetWindow(windowId)) reconcileRunner.request();
+      },
+      onWindowFocusChanged: () => reconcileRunner.request(),
       fallbackMs: ACTIVITY_STRIP_WORKSPACE_SYNC_MS,
     });
   }
 
+  void theme.refresh({ force: true });
+  const themeTimer = setInterval(() => void theme.refresh(), THEME_POLL_INTERVAL_MS);
+  themeTimer.unref?.();
+
   process.once("SIGINT", () => void shutdown(0));
   process.once("SIGTERM", () => void shutdown(0));
 }

package/src/native/panel-projection.mjs

@@ -4,18 +4,23 @@
 //   - "changing native panel card membership, focus, or transport revisions"
 // ---
 
+import { joinAkTaskChips } from "../common/ak-tasks.mjs";
 import { resolveSnapshotSession } from "../common/niri-focus.mjs";
 import { projectSessionCards, sessionRecordKey } from "../common/session-cards.mjs";
 
 /** @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 {{isNiriSession: () => boolean; publish: (view: Record<string, unknown> & {type: string; sessions: SessionRecord[]}) => void}} NativePanelProjectionOptions */
 
 /** @param {NativePanelProjectionOptions} options */
 export function createNativePanelProjection({ isNiriSession, publish }) {
   /** @type {Snapshot} */
   let snapshot = { generatedAt: Date.now(), sessions: [] };
+  /** Agent tabs discovered from the process table; they publish no telemetry of their own. */
+  /** @type {SessionRecord[]} */
+  let agentSessions = [];
   /** @type {string | null} */
   let focusedSessionId = null;
   /** @type {string | null} */
@@ -26,13 +31,44 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
   let workspaceCardIds = new Set();
   /** @type {Set<string>} */
   let workspaceRecordKeys = new Set();
+  /** @type {Map<string, CardPlacement>} */
+  let workspacePlacements = new Map();
+  /** Read-only AK task claims joined onto cards; absent until the first successful AK read. */
+  /** @type {{claims: import("../common/contracts.ts").AkTaskClaim[]; deferred: import("../common/contracts.ts").AkTaskDeferred[]} | null} */
+  let akTasks = null;
   let revision = 0;
 
+  function allSessions() {
+    return agentSessions.length > 0 ? [...snapshot.sessions, ...agentSessions] : snapshot.sessions;
+  }
+
   function getDisplaySessions() {
-    const sessions = isNiriSession()
-      ? snapshot.sessions.filter((session) => workspaceRecordKeys.has(sessionRecordKey(session)))
-      : snapshot.sessions;
-    return projectSessionCards(sessions, isNiriSession() ? workspaceCardIds : null);
+    const rawSessions = allSessions();
+    let cards;
+    if (!isNiriSession()) {
+      cards = projectSessionCards(rawSessions, null);
+    } else {
+      const sessions = rawSessions.filter((session) =>
+        workspaceRecordKeys.has(sessionRecordKey(session)),
+      );
+      cards = projectSessionCards(sessions, workspaceCardIds).map((card) => {
+        const placement = workspacePlacements.get(card.cardId);
+        return placement ? { ...card, ...placement } : card;
+      });
+    }
+    if (!akTasks) return cards;
+    // Dead-session detection must consider every live session, including cards projected onto
+    // other workspaces, so a claim is only orphaned when no live session anywhere holds it.
+    const liveSessionIds = new Set(
+      rawSessions.map((session) => String(session.sessionId ?? "")).filter(Boolean),
+    );
+    return joinAkTaskChips({
+      cards,
+      claims: akTasks.claims,
+      deferred: akTasks.deferred,
+      liveSessionIds,
+      nowMs: Date.now(),
+    }).cards;
   }
 
   function currentView() {
@@ -64,7 +100,23 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
 
   return {
     getDisplaySessions,
-    getRawSessions: () => snapshot.sessions,
+    getRawSessions: allSessions,
+    /** Broker-published records only, for comparisons against a broker snapshot. */
+    getBrokerSessions: () => snapshot.sessions,
+    /** @param {SessionRecord[]} records */
+    setAgentSessions(records) {
+      agentSessions = Array.isArray(records) ? records : [];
+    },
+    /**
+     * Replace the read-only AK task data joined onto cards. An empty refresh clears every chip;
+     * `null` data (AK never read) leaves cards untouched, which is how the strip stays unchanged
+     * when AK is absent.
+     * @param {{claims: import("../common/contracts.ts").AkTaskClaim[]; deferred: import("../common/contracts.ts").AkTaskDeferred[]} | null} state
+     */
+    setAkTasks(state) {
+      akTasks = state;
+      send();
+    },
     /** @param {string} targetId */
     resolveTarget: (targetId) => resolveSnapshotSession(getDisplaySessions(), targetId),
     /** @param {WorkspaceView} view */
@@ -78,6 +130,16 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
             : [sessionRecordKey(session)],
         ),
       );
+      workspacePlacements = new Map(
+        view.sessions.map((session) => [
+          String(session.cardId ?? ""),
+          {
+            placement: String(session.placement ?? "title"),
+            surfaceVisible: session.surfaceVisible !== false,
+            windowId: Number.isInteger(session.windowId) ? Number(session.windowId) : null,
+          },
+        ]),
+      );
       focusedSessionId = view.focusedSessionId;
       focusedCardId = view.focusedCardId ?? null;
       send();