@tryinget/pi-activity-strip 0.4.0 → 0.5.0

package/src/common/alignment-controller.mjs

@@ -1,35 +1,9 @@
 // ---
-// summary: "coalesces native-window alignment so stale async work cannot overwrite newer geometry"
+// summary: "coalesces asynchronous reconciliation so stale work cannot publish over newer state"
 // read_when:
-//   - "changing Electron/Niri geometry reconciliation or testing rapid expansion transitions"
+//   - "changing latest-only native workspace reconciliation"
 // ---
 
-/**
- * @param {{ is_floating?: boolean, layout?: { tile_pos_in_workspace_view?: unknown } } | null | undefined} window
- */
-export function hasNiriFloatingPosition(window) {
-  const position = window?.layout?.tile_pos_in_workspace_view;
-  return window?.is_floating === true && Array.isArray(position) && position.length >= 2;
-}
-
-/**
- * @param {{ is_floating?: boolean, layout?: { tile_pos_in_workspace_view?: unknown, window_size?: unknown } } | null | undefined} window
- * @param {{x: number, y: number, width: number, height: number}} target
- */
-export function isNiriWindowAligned(window, target) {
-  if (!hasNiriFloatingPosition(window)) return false;
-  const position = window?.layout?.tile_pos_in_workspace_view;
-  const size = window?.layout?.window_size;
-  return Boolean(
-    Array.isArray(position) &&
-      Array.isArray(size) &&
-      Number(size[0]) === target.width &&
-      Number(size[1]) === target.height &&
-      Math.abs(Number(position[0]) - target.x) < 1 &&
-      Math.abs(Number(position[1]) - target.y) < 1,
-  );
-}
-
 /**
  * @param {(attempt: { generation: number, isCurrent: () => boolean }) => Promise<void>} run
  */
@@ -37,34 +11,42 @@ export function createLatestOnlyRunner(run) {
   if (typeof run !== "function") throw new TypeError("run must be a function");
 
   let requestedGeneration = 0;
+  let completedGeneration = 0;
   /** @type {Promise<void> | null} */
   let worker = null;
 
+  function ensureWorker() {
+    if (!worker) worker = drain();
+  }
+
   async function drain() {
-    while (true) {
-      const generation = requestedGeneration;
-      const isCurrent = () => generation === requestedGeneration;
-      try {
-        await run({ generation, isCurrent });
-      } catch {
-        // Alignment is best effort. A newer request must still be allowed to reconcile the window.
+    try {
+      while (completedGeneration < requestedGeneration) {
+        const generation = requestedGeneration;
+        const isCurrent = () => generation === requestedGeneration;
+        try {
+          await run({ generation, isCurrent });
+        } catch {
+          // Alignment is best effort. A newer request must still be allowed to reconcile the window.
+        }
+        completedGeneration = generation;
       }
-      if (isCurrent()) return;
+    } finally {
+      worker = null;
+      // A request can arrive after the loop condition was checked but before this finally block.
+      // Hand it to a successor synchronously so no requested generation is lost.
+      if (completedGeneration < requestedGeneration) ensureWorker();
     }
   }
 
   function request() {
     requestedGeneration += 1;
-    if (!worker) {
-      worker = drain().finally(() => {
-        worker = null;
-      });
-    }
+    ensureWorker();
     return requestedGeneration;
   }
 
   async function waitForIdle() {
-    await worker;
+    while (worker) await worker;
   }
 
   return {

package/src/common/card-display.mjs

@@ -46,3 +46,8 @@ export function disambiguatedRepoLabel(session, duplicateLabels) {
     ? `${label} · ${String(processId).slice(-4)}`
     : label;
 }
+
+/** @param {{hovered?: boolean; activeElement?: boolean; documentFocused?: boolean}} state */
+export function shouldRetainExpandedCard({ hovered, activeElement, documentFocused }) {
+  return Boolean(hovered || (documentFocused && activeElement));
+}

package/src/common/compatibility.mjs

@@ -1,12 +1,11 @@
 // ---
-// summary: "detects desktop and Electron prerequisites and formats actionable activity-strip compatibility reports"
+// summary: "detects native layer-shell prerequisites and formats actionable activity-strip compatibility reports"
 // read_when:
 //   - "changing host detection, compatibility blockers, warnings, or doctor output"
 // ---
 
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { locateElectron } from "./electron.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -67,14 +66,17 @@ export async function detectDisplayCount(options = {}) {
 /**
  * @param {{
  *   env?: NodeJS.ProcessEnv;
- *   locateElectronImpl?: typeof locateElectron;
  *   execFileAsyncImpl?: typeof execFileAsync;
+ *   platform?: NodeJS.Platform;
+ *   arch?: string;
  * }} [options]
  * @returns {Promise<import("./contracts.ts").ActivityStripCompatibilityReport>}
  */
 export async function assessActivityStripCompatibility(options = {}) {
   const env = options.env || process.env;
-  const locateElectronImpl = options.locateElectronImpl || locateElectron;
+  const backend = "native";
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
   const displayServer = detectDisplayServer(env);
   const windowManager = detectWindowManager(env);
   const displayCount = await detectDisplayCount({
@@ -83,7 +85,6 @@ export async function assessActivityStripCompatibility(options = {}) {
   });
   const blockers = [];
   const warnings = [];
-  let electronPath = null;
 
   if (displayServer === "headless") {
     blockers.push(
@@ -97,10 +98,11 @@ export async function assessActivityStripCompatibility(options = {}) {
     );
   }
 
-  try {
-    electronPath = await locateElectronImpl();
-  } catch (error) {
-    blockers.push(error instanceof Error ? error.message : String(error));
+  if (displayServer !== "headless" && displayServer !== "wayland") {
+    blockers.push("The native Activity Strip panel requires a Wayland session.");
+  }
+  if (platform !== "linux" || arch !== "x64") {
+    blockers.push(`The packaged native panel requires Linux x64; detected ${platform} ${arch}.`);
   }
 
   if (displayCount && displayCount > 1) {
@@ -111,17 +113,17 @@ export async function assessActivityStripCompatibility(options = {}) {
 
   if (windowManager !== "niri") {
     warnings.push(
-      "Top-edge repair is optimized for Niri. Other window managers fall back to generic Electron bounds and may need manual adjustment.",
+      "Workspace-local projection is optimized for Niri; other layer-shell compositors show the global card view.",
     );
   }
 
   return {
     ok: blockers.length === 0,
+    backend,
     displayServer,
     windowManager: typeof windowManager === "string" ? windowManager : null,
-    electronPath,
     displayCount,
-    alignmentMode: windowManager === "niri" ? "niri" : "generic",
+    alignmentMode: "layer-shell",
     primaryDisplayOnly: true,
     clickThroughDefault: env.PI_ACTIVITY_STRIP_CLICK_THROUGH === "1",
     blockers,
@@ -137,7 +139,7 @@ export function formatCompatibilityReport(report) {
     `Compatibility: ${report.ok ? "compatible" : "blocked"}`,
     `Display server: ${report.displayServer}`,
     `Window manager: ${report.windowManager || "unknown"}`,
-    `Electron: ${report.electronPath || "not found"}`,
+    `Backend: ${report.backend}`,
     `Alignment mode: ${report.alignmentMode}`,
     `Primary-display only: ${report.primaryDisplayOnly ? "yes" : "no"}`,
     `Click-through mode: ${report.clickThroughDefault ? "enabled by environment" : "disabled (interactive default)"}`,

package/src/common/constants.mjs

@@ -1,5 +1,5 @@
 // ---
-// summary: "defines shared socket paths, window dimensions, timing thresholds, and Electron binary candidates"
+// summary: "defines shared broker paths, timing thresholds, and transport bounds"
 // read_when:
 //   - "tuning activity-strip runtime defaults or locating shared configuration values"
 // ---
@@ -8,40 +8,22 @@ import os from "node:os";
 import path from "node:path";
 
 export const ACTIVITY_STRIP_NAME = "pi-activity-strip";
-export const ACTIVITY_STRIP_SOCKET_DIR = path.join(
-  os.homedir(),
-  ".pi",
-  "agent",
-  "state",
-  ACTIVITY_STRIP_NAME,
-);
-export const ACTIVITY_STRIP_SOCKET_PATH = path.join(
-  ACTIVITY_STRIP_SOCKET_DIR,
-  "activity-strip.sock",
-);
-export const ACTIVITY_STRIP_WIDTH_PADDING = 16;
-export const ACTIVITY_STRIP_HEIGHT = 84;
-export const ACTIVITY_STRIP_EXPANDED_HEIGHT = 252;
+export const ACTIVITY_STRIP_SOCKET_DIR =
+  process.env.PI_ACTIVITY_STRIP_SOCKET_DIR?.trim() ||
+  path.join(os.homedir(), ".pi", "agent", "state", ACTIVITY_STRIP_NAME);
+export const ACTIVITY_STRIP_SOCKET_PATH =
+  process.env.PI_ACTIVITY_STRIP_SOCKET_PATH?.trim() ||
+  path.join(ACTIVITY_STRIP_SOCKET_DIR, "activity-strip.sock");
 export const ACTIVITY_STRIP_ORDER_REFRESH_MS = 15_000;
 export const ACTIVITY_STRIP_WORKSPACE_SYNC_MS = 1500;
-export const ACTIVITY_STRIP_NIRI_ANIMATION_SETTLE_MS = 450;
 export const ACTIVITY_STRIP_HEARTBEAT_MS = 2500;
 export const ACTIVITY_STRIP_STALE_AFTER_MS = 12000;
+export const ACTIVITY_STRIP_MAX_SESSIONS = 256;
+export const ACTIVITY_STRIP_MAX_MESSAGE_BYTES = 256 * 1024;
+export const ACTIVITY_STRIP_CLIENT_IDLE_TIMEOUT_MS = 2000;
 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;
-export const DEFAULT_ELECTRON_CANDIDATES = [
-  "electron",
-  "electron39",
-  "electron38",
-  "electron37",
-  "electron36",
-  "electron35",
-  "electron34",
-  "electron33",
-  "electron32",
-  "electron31",
-];
 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

@@ -9,7 +9,16 @@ export type SessionState = "idle" | "thinking" | "tool" | "waiting" | "success"
 export interface SessionSnapshot {
   sessionId: string;
   publisherId: string;
+  publisherSequence: number;
   processId: number;
+  terminalKind: "ghostty-surface" | "unbound";
+  terminalKey: string;
+  terminalFamily: string;
+  terminalSurfaceId: string;
+  cardId?: string;
+  publisherCount?: number;
+  publisherIds?: string[];
+  publisherRecordKeys?: string[];
   cwd: string;
   repoLabel: string;
   sessionName: string;
@@ -38,13 +47,25 @@ export type ActivityStripRuntimeState = "starting" | "ready" | "error";
 
 export interface ActivityStripRuntimeStatus {
   state: ActivityStripRuntimeState;
+  backend?: "native-layer-shell";
   startedAt: number;
   readyAt?: number | null;
   windowVisible?: boolean;
   displayServer?: "wayland" | "x11" | "headless" | "unknown";
   windowManager?: string | null;
   displayCount?: number | null;
-  alignmentMode?: "niri" | "generic";
+  alignmentMode?: "layer-shell";
+  rendererCardCount?: number;
+  rendererCardIds?: string[];
+  rendererVisibilityTransitionCount?: number;
+  controllerPid?: number;
+  panelPid?: number | null;
+  panelExpanded?: boolean;
+  clickThrough?: boolean;
+  panelMoveCount?: number;
+  panelActivationCount?: number;
+  panelRestartCount?: number;
+  lastMovedCardId?: string | null;
   warnings?: string[];
   error?: string | null;
 }
@@ -65,6 +86,7 @@ export interface BrokerClientOptions {
 
 export interface SessionStoreOptions {
   staleAfterMs?: number;
+  maxSessions?: number;
 }
 
 export interface ActivityStripBrokerOptions {
@@ -76,7 +98,8 @@ export interface ActivityStripBrokerOptions {
     remove(sessionId: string, publisherId?: string): boolean;
   };
   getRuntimeStatus?: () => ActivityStripRuntimeStatus | undefined;
-  focusSession?: (sessionId: string) => Promise<{ ok: boolean; error?: string; windowId?: number }>;
+  focusSession?: (targetId: string) => Promise<{ ok: boolean; error?: string; windowId?: number }>;
+  focusStrip?: () => Promise<{ ok: boolean; error?: string }>;
 }
 
 export interface ToolCallDescription {
@@ -143,6 +166,21 @@ export interface SessionTelemetryOptions {
   pi?: TelemetryPiLike;
   cwd?: string;
   sessionName?: string;
+  env?: NodeJS.ProcessEnv;
+  stdinIsTTY?: boolean;
+  resolveTerminalIdentity?: (options: {
+    env?: NodeJS.ProcessEnv;
+    hasUI?: boolean;
+    stdinIsTTY?: boolean;
+    ttyPath?: string;
+    processId?: number;
+    ancestorExecutable?: string;
+  }) => {
+    terminalKind: "ghostty-surface" | "unbound";
+    terminalKey: string;
+    terminalFamily: string;
+    terminalSurfaceId: string;
+  };
   transport?: {
     publish: (session: SessionSnapshot) => Promise<unknown>;
     remove: (session: { sessionId: string; publisherId: string }) => Promise<unknown>;
@@ -151,11 +189,11 @@ export interface SessionTelemetryOptions {
 
 export interface ActivityStripCompatibilityReport {
   ok: boolean;
+  backend: string;
   displayServer: "wayland" | "x11" | "headless" | "unknown";
   windowManager: string | null;
-  electronPath: string | null;
   displayCount: number | null;
-  alignmentMode: "niri" | "generic";
+  alignmentMode: "layer-shell";
   primaryDisplayOnly: boolean;
   clickThroughDefault: boolean;
   blockers: string[];

package/src/common/contracts.ts

@@ -9,7 +9,16 @@ export type SessionState = "idle" | "thinking" | "tool" | "waiting" | "success"
 export interface SessionSnapshot {
   sessionId: string;
   publisherId: string;
+  publisherSequence: number;
   processId: number;
+  terminalKind: "ghostty-surface" | "unbound";
+  terminalKey: string;
+  terminalFamily: string;
+  terminalSurfaceId: string;
+  cardId?: string;
+  publisherCount?: number;
+  publisherIds?: string[];
+  publisherRecordKeys?: string[];
   cwd: string;
   repoLabel: string;
   sessionName: string;
@@ -38,13 +47,25 @@ export type ActivityStripRuntimeState = "starting" | "ready" | "error";
 
 export interface ActivityStripRuntimeStatus {
   state: ActivityStripRuntimeState;
+  backend?: "native-layer-shell";
   startedAt: number;
   readyAt?: number | null;
   windowVisible?: boolean;
   displayServer?: "wayland" | "x11" | "headless" | "unknown";
   windowManager?: string | null;
   displayCount?: number | null;
-  alignmentMode?: "niri" | "generic";
+  alignmentMode?: "layer-shell";
+  rendererCardCount?: number;
+  rendererCardIds?: string[];
+  rendererVisibilityTransitionCount?: number;
+  controllerPid?: number;
+  panelPid?: number | null;
+  panelExpanded?: boolean;
+  clickThrough?: boolean;
+  panelMoveCount?: number;
+  panelActivationCount?: number;
+  panelRestartCount?: number;
+  lastMovedCardId?: string | null;
   warnings?: string[];
   error?: string | null;
 }
@@ -65,6 +86,7 @@ export interface BrokerClientOptions {
 
 export interface SessionStoreOptions {
   staleAfterMs?: number;
+  maxSessions?: number;
 }
 
 export interface ActivityStripBrokerOptions {
@@ -76,7 +98,8 @@ export interface ActivityStripBrokerOptions {
     remove(sessionId: string, publisherId?: string): boolean;
   };
   getRuntimeStatus?: () => ActivityStripRuntimeStatus | undefined;
-  focusSession?: (sessionId: string) => Promise<{ ok: boolean; error?: string; windowId?: number }>;
+  focusSession?: (targetId: string) => Promise<{ ok: boolean; error?: string; windowId?: number }>;
+  focusStrip?: () => Promise<{ ok: boolean; error?: string }>;
 }
 
 export interface ToolCallDescription {
@@ -143,6 +166,21 @@ export interface SessionTelemetryOptions {
   pi?: TelemetryPiLike;
   cwd?: string;
   sessionName?: string;
+  env?: NodeJS.ProcessEnv;
+  stdinIsTTY?: boolean;
+  resolveTerminalIdentity?: (options: {
+    env?: NodeJS.ProcessEnv;
+    hasUI?: boolean;
+    stdinIsTTY?: boolean;
+    ttyPath?: string;
+    processId?: number;
+    ancestorExecutable?: string;
+  }) => {
+    terminalKind: "ghostty-surface" | "unbound";
+    terminalKey: string;
+    terminalFamily: string;
+    terminalSurfaceId: string;
+  };
   transport?: {
     publish: (session: SessionSnapshot) => Promise<unknown>;
     remove: (session: { sessionId: string; publisherId: string }) => Promise<unknown>;
@@ -151,11 +189,11 @@ export interface SessionTelemetryOptions {
 
 export interface ActivityStripCompatibilityReport {
   ok: boolean;
+  backend: string;
   displayServer: "wayland" | "x11" | "headless" | "unknown";
   windowManager: string | null;
-  electronPath: string | null;
   displayCount: number | null;
-  alignmentMode: "niri" | "generic";
+  alignmentMode: "layer-shell";
   primaryDisplayOnly: boolean;
   clickThroughDefault: boolean;
   blockers: string[];

package/src/common/niri-focus.mjs

@@ -6,6 +6,13 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { projectSessionCards, sessionCardId } from "./session-cards.mjs";
+import {
+  appIdForGhosttyFamily,
+  canonicalGhosttyTerminalKey,
+  normalizeGhosttySurfaceId,
+  terminalTitleSegment,
+} from "./terminal-identity.mjs";
 
 const GHOSTTY_APP_IDS = new Set(["com.mitchellh.ghostty", "com.tryinget.ghosttysidequest"]);
 const PI_SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -92,11 +99,15 @@ export function shortSessionId(value, hexLength = SESSION_TITLE_TOKEN_HEX_LENGTH
     .toLowerCase();
 }
 
-/** @param {Array<Record<string, unknown>>} sessions @param {string} sessionId */
-export function resolveSnapshotSession(sessions, sessionId) {
-  const requestedId = String(sessionId ?? "");
-  const matches = sessions.filter((session) => session?.sessionId === requestedId);
-  return matches.length === 1 ? matches[0] : null;
+/** @param {Array<Record<string, unknown>>} sessions @param {string} targetId */
+export function resolveSnapshotSession(sessions, targetId) {
+  const requestedId = String(targetId ?? "");
+  const cardMatches = sessions.filter(
+    (session) => session?.cardId === requestedId || sessionCardId(session) === requestedId,
+  );
+  if (cardMatches.length === 1) return cardMatches[0];
+  const logicalMatches = sessions.filter((session) => session?.sessionId === requestedId);
+  return logicalMatches.length === 1 ? logicalMatches[0] : null;
 }
 
 /**
@@ -105,8 +116,9 @@ export function resolveSnapshotSession(sessions, sessionId) {
  * must also identify a known Ghostty build, and ambiguity always returns no match.
  * @param {Array<Record<string, unknown>>} windows
  * @param {string} sessionId
+ * @param {Record<string, unknown>} [session]
  */
-export function resolveExactGhosttyWindow(windows, sessionId) {
+export function resolveExactGhosttyWindow(windows, sessionId, session = {}) {
   const fullId = String(sessionId ?? "").trim();
   if (!PI_SESSION_ID.test(fullId)) return null;
 
@@ -123,6 +135,22 @@ export function resolveExactGhosttyWindow(windows, sessionId) {
   };
 
   const currentToken = shortSessionId(fullId);
+  if (session.terminalKind === "ghostty-surface" && !canonicalGhosttyTerminalKey(session)) {
+    return null;
+  }
+  const surfaceId = normalizeGhosttySurfaceId(session.terminalSurfaceId);
+  const titleSegment = terminalTitleSegment(session);
+  const expectedAppId = appIdForGhosttyFamily(String(session.terminalFamily ?? ""));
+  if (surfaceId && titleSegment && expectedAppId) {
+    const surfaceSuffix = ` · ${titleSegment} · ${currentToken}`;
+    const surfaceMatches = windows.filter(
+      (window) =>
+        Number.isInteger(window?.id) &&
+        String(window?.app_id ?? "") === expectedAppId &&
+        String(window?.title ?? "").endsWith(surfaceSuffix),
+    );
+    return surfaceMatches.length === 1 ? surfaceMatches[0] : null;
+  }
   const currentMatches = matchesForToken(currentToken);
   if (currentMatches.length > 0) return currentMatches.length === 1 ? currentMatches[0] : null;
 
@@ -153,16 +181,15 @@ export function resolveFocusedSnapshotSessionId(windows, sessions, options = {})
   const matches = sessions.filter((session) => {
     const sessionId = resolvePiSessionIdentity(session, options);
     if (!sessionId) return false;
-    return resolveExactGhosttyWindow(windows, sessionId)?.id === focusedWindow.id;
+    return resolveExactGhosttyWindow(windows, sessionId, session)?.id === focusedWindow.id;
   });
   return matches.length === 1 ? String(matches[0]?.sessionId ?? "") || null : null;
 }
 
 /**
  * Project the global broker snapshot onto one exact Niri workspace. Membership
- * requires an exact, unique Ghostty window; two telemetry records resolving to
- * the same window are both excluded rather than guessed. Activity state does
- * not affect membership.
+ * requires an exact Ghostty window. Multiple publisher streams bound to the same terminal are
+ * aggregated into one stable card; ambiguity between distinct windows still fails closed.
  * @param {Array<Record<string, unknown>>} windows
  * @param {Record<string, unknown>} workspace
  * @param {Array<Record<string, unknown>>} sessions
@@ -170,26 +197,57 @@ export function resolveFocusedSnapshotSessionId(windows, sessions, options = {})
  */
 export function resolveWorkspaceView(windows, workspace, sessions, options = {}) {
   if (!Number.isInteger(workspace?.id)) return null;
-  /** @type {Array<{session: Record<string, unknown>; window: Record<string, unknown>}>} */
+  /** @type {Array<{cardId: string; session: Record<string, unknown>; window: Record<string, unknown>}>} */
   const candidates = [];
   for (const session of sessions) {
     const sessionIdentity = resolvePiSessionIdentity(session, options);
     if (!sessionIdentity) continue;
-    const window = resolveExactGhosttyWindow(windows, sessionIdentity);
+    const window = resolveExactGhosttyWindow(windows, sessionIdentity, session);
     if (!window || window.workspace_id !== workspace.id) continue;
-    candidates.push({ session, window });
+    const cardId = sessionCardId(session);
+    if (!cardId) continue;
+    candidates.push({ cardId, session: { ...session, cardId }, window });
+  }
+
+  const cardIdsByWindow = new Map();
+  for (const candidate of candidates) {
+    const ids = cardIdsByWindow.get(candidate.window.id) ?? new Set();
+    ids.add(candidate.cardId);
+    cardIdsByWindow.set(candidate.window.id, ids);
   }
-  const windowCounts = new Map();
+  const allowedCardByWindow = new Map();
+  for (const [windowId, ids] of cardIdsByWindow) {
+    const terminalIds = [...ids].filter((cardId) => cardId.startsWith("terminal:"));
+    if (terminalIds.length === 1) allowedCardByWindow.set(windowId, terminalIds[0]);
+    else if (ids.size === 1) allowedCardByWindow.set(windowId, [...ids][0]);
+  }
+
+  /** @type {Map<string, Array<{session: Record<string, unknown>; window: Record<string, unknown>}>>} */
+  const groups = new Map();
   for (const candidate of candidates) {
-    windowCounts.set(candidate.window.id, (windowCounts.get(candidate.window.id) ?? 0) + 1);
+    if (allowedCardByWindow.get(candidate.window.id) !== candidate.cardId) continue;
+    const group = groups.get(candidate.cardId) ?? [];
+    group.push(candidate);
+    groups.set(candidate.cardId, group);
   }
-  const projectedSessions = candidates
-    .filter((candidate) => windowCounts.get(candidate.window.id) === 1)
-    .map((candidate) => candidate.session);
+
+  const projectedSessions = [];
+  for (const [cardId, group] of groups) {
+    const windowIds = new Set(group.map((candidate) => candidate.window.id));
+    if (windowIds.size !== 1) continue;
+    const [card] = projectSessionCards(group.map((candidate) => candidate.session));
+    if (!card) continue;
+    const window = group[0]?.window;
+    projectedSessions.push({ ...card, cardId, windowId: window?.id });
+  }
+  const focusedCard = projectedSessions.find((session) =>
+    windows.some((window) => window?.id === session.windowId && window?.is_focused === true),
+  );
   return {
     workspace,
     sessions: projectedSessions,
-    focusedSessionId: resolveFocusedSnapshotSessionId(windows, projectedSessions, options),
+    focusedSessionId: focusedCard ? String(focusedCard.sessionId ?? "") || null : null,
+    focusedCardId: focusedCard ? String(focusedCard.cardId ?? "") || null : null,
   };
 }
 
@@ -216,65 +274,6 @@ export function resolveFocusedNiriWorkspace(workspaces) {
   return matches.length === 1 ? matches[0] : null;
 }
 
-/**
- * @param {Array<Record<string, unknown>>} windows
- * @param {number | null} [workspaceId]
- */
-export function resolveActivityStripWindow(windows, workspaceId = null) {
-  const matches = windows.filter(
-    (window) =>
-      Number.isInteger(window?.id) &&
-      window?.title === "Pi Activity Strip" &&
-      (workspaceId == null || window?.workspace_id === workspaceId),
-  );
-  return matches.length === 1 ? matches[0] : null;
-}
-
-/**
- * Focus the unique strip already resident on the focused workspace. This command is
- * designed for a compositor key binding and never moves a strip across workspaces.
- * @param {(file: string, args: string[], options: object) => Promise<{stdout?: string}>} execFileAsync
- * @param {NodeJS.ProcessEnv} [env]
- * @param {Array<unknown>} [sessions]
- */
-export async function focusNiriStrip(execFileAsync, env = process.env, sessions = []) {
-  if (!env.NIRI_SOCKET)
-    return { ok: false, error: "Niri is not available; strip focus did nothing." };
-  try {
-    const [{ stdout: windowOutput }, { stdout: workspaceOutput }] = await Promise.all([
-      execFileAsync("niri", ["msg", "-j", "windows"], { env }),
-      execFileAsync("niri", ["msg", "-j", "workspaces"], { env }),
-    ]);
-    const windows = JSON.parse(String(windowOutput ?? "[]"));
-    const workspaces = JSON.parse(String(workspaceOutput ?? "[]"));
-    if (!Array.isArray(windows) || !Array.isArray(workspaces))
-      throw new Error("unexpected payload");
-    const focusedWorkspace = resolveFocusedNiriWorkspace(workspaces);
-    const strip = focusedWorkspace
-      ? resolveActivityStripWindow(windows, Number(focusedWorkspace.id))
-      : null;
-    const sessionRecords = Array.isArray(sessions)
-      ? /** @type {Array<Record<string, unknown>>} */ (sessions)
-      : [];
-    const view = resolveFocusedWorkspaceView(windows, workspaces, sessionRecords, { env });
-    if (!strip || !view?.sessions.length) {
-      return {
-        ok: false,
-        error: "No visible resident strip with exact tracked sessions exists here; nothing moved.",
-      };
-    }
-    await execFileAsync("niri", ["msg", "action", "focus-window", "--id", String(strip.id)], {
-      env,
-    });
-    return { ok: true, windowId: strip.id };
-  } catch {
-    return {
-      ok: false,
-      error: "Could not focus the strip through Niri; nothing else was focused.",
-    };
-  }
-}
-
 /**
  * @param {string | Record<string, unknown>} session
  * @param {(file: string, args: string[], options: object) => Promise<{stdout?: string}>} execFileAsync
@@ -304,7 +303,8 @@ export async function focusNiriSession(session, execFileAsync, env = process.env
   if (!Array.isArray(windows)) {
     return { ok: false, error: "Unexpected Niri window data; focus did nothing." };
   }
-  const target = resolveExactGhosttyWindow(windows, sessionId);
+  const record = session && typeof session === "object" ? session : {};
+  const target = resolveExactGhosttyWindow(windows, sessionId, record);
   if (!target) {
     return {
       ok: false,