@tryinget/pi-activity-strip 0.4.0 → 0.6.0

package/src/common/claude-hook-config.mjs

@@ -0,0 +1,56 @@
+// ---
+// summary: "builds the Claude Code settings fragment that lets sessions publish live ribbon state"
+// read_when:
+//   - "changing which Claude Code hook events the ribbon subscribes to"
+// ---
+
+/**
+ * Only low-frequency events are hooked. Tool, thinking and idle state already come from the
+ * transcript at no cost, so nothing runs per tool call; hooks add exactly what the transcript
+ * cannot express, which is that a session is blocked waiting for the operator.
+ */
+export const CLAUDE_HOOK_EVENTS = Object.freeze([
+  "SessionStart",
+  "UserPromptSubmit",
+  "Notification",
+  "Stop",
+  "SessionEnd",
+]);
+
+/**
+ * @param {string} hookCommand absolute command Claude Code runs for each event
+ * @returns {{hooks: Record<string, Array<{matcher: string; hooks: Array<{type: "command"; command: string}>}>>}}
+ */
+export function claudeHookSettings(hookCommand) {
+  const command = String(hookCommand ?? "").trim();
+  if (!command) throw new Error("A hook command is required.");
+  /** @type {Record<string, Array<{matcher: string; hooks: Array<{type: "command"; command: string}>}>>} */
+  const hooks = {};
+  for (const event of CLAUDE_HOOK_EVENTS) {
+    hooks[event] = [{ matcher: "", hooks: [{ type: "command", command }] }];
+  }
+  return { hooks };
+}
+
+/**
+ * Merge the ribbon's hooks into existing settings without disturbing unrelated configuration or
+ * duplicating an entry that already runs this exact command.
+ * @param {Record<string, any>} settings
+ * @param {string} hookCommand
+ */
+export function mergeClaudeHookSettings(settings, hookCommand) {
+  const desired = claudeHookSettings(hookCommand);
+  const merged = { ...(settings ?? {}) };
+  const existingHooks = { ...(merged.hooks ?? {}) };
+  for (const [event, entries] of Object.entries(desired.hooks)) {
+    const current = Array.isArray(existingHooks[event]) ? [...existingHooks[event]] : [];
+    const alreadyPresent = current.some((entry) =>
+      (entry?.hooks ?? []).some(
+        /** @param {any} hook */ (hook) => String(hook?.command ?? "") === hookCommand,
+      ),
+    );
+    existingHooks[event] = alreadyPresent ? current : [...current, ...entries];
+  }
+  merged.hooks = existingHooks;
+  return merged;
+}

package/src/common/claude-transcript.mjs

@@ -0,0 +1,163 @@
+// ---
+// summary: "derives live Claude Code session state from the tail of its transcript"
+// read_when:
+//   - "changing Claude Code card telemetry or the transcript records it depends on"
+// ---
+
+/**
+ * Claude Code appends newline-delimited records to a per-session transcript. The format is internal
+ * to Claude Code and carries no stability guarantee, so every field is optional here and a record
+ * that does not parse is skipped. When nothing usable is found the caller keeps the process-only
+ * card rather than inventing activity.
+ */
+
+const PREVIEW_LIMIT = 100;
+const DETAIL_LIMIT = 100;
+
+/** @typedef {"idle" | "thinking" | "tool"} ClaudeState */
+/**
+ * @typedef {{
+ *   title: string; lastPrompt: string; assistantPreview: string; state: ClaudeState;
+ *   toolName: string; toolTarget: string; turnIndex: number; lastEventAt: number;
+ *   mode: string; permissionMode: string; sessionId: string; cwd: string; gitBranch: string;
+ * }} ClaudeTelemetry
+ */
+
+/** @param {unknown} value @param {number} limit */
+function preview(value, limit) {
+  const text = String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+}
+
+/** @param {unknown} value */
+function timestampMs(value) {
+  const parsed = Date.parse(String(value ?? ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+/** @param {any} record */
+function contentBlocks(record) {
+  const content = record?.message?.content;
+  return Array.isArray(content) ? content : [];
+}
+
+/**
+ * Name the thing a tool call is acting on, preferring the fields that read well on a card.
+ * @param {any} block
+ */
+export function describeToolTarget(block) {
+  const input = block?.input ?? {};
+  for (const key of ["description", "command", "file_path", "path", "pattern", "query", "url"]) {
+    const value = input?.[key];
+    if (typeof value === "string" && value.trim()) return preview(value, DETAIL_LIMIT);
+  }
+  return "";
+}
+
+/** @returns {ClaudeTelemetry} */
+function emptyTelemetry() {
+  return {
+    title: "",
+    lastPrompt: "",
+    assistantPreview: "",
+    state: "idle",
+    toolName: "",
+    toolTarget: "",
+    turnIndex: 0,
+    lastEventAt: 0,
+    mode: "",
+    permissionMode: "",
+    sessionId: "",
+    cwd: "",
+    gitBranch: "",
+  };
+}
+
+/**
+ * Read the tail of a transcript. The first line is usually a fragment and is skipped by the parse
+ * failure path. State comes from the newest record that carries a timestamp, because the latched
+ * records Claude Code rewrites after every turn have none and would otherwise mask real activity.
+ * @param {string} tail
+ * @returns {ClaudeTelemetry}
+ */
+export function parseClaudeTranscriptTail(tail) {
+  const telemetry = emptyTelemetry();
+  if (!tail) return telemetry;
+
+  /** @type {any[]} */
+  const records = [];
+  for (const line of String(tail).split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      records.push(JSON.parse(trimmed));
+    } catch {
+      // A truncated first line or a partially written last line is not evidence.
+    }
+  }
+  if (records.length === 0) return telemetry;
+
+  for (const record of records) {
+    switch (record?.type) {
+      case "ai-title":
+        if (typeof record.aiTitle === "string") telemetry.title = record.aiTitle;
+        break;
+      case "last-prompt":
+        telemetry.lastPrompt = preview(record.lastPrompt, PREVIEW_LIMIT);
+        break;
+      case "mode":
+        telemetry.mode = String(record.mode ?? "");
+        break;
+      case "permission-mode":
+        telemetry.permissionMode = String(record.permissionMode ?? "");
+        break;
+      case "system":
+        if (record.subtype === "turn_duration" && Number.isFinite(Number(record.messageCount))) {
+          telemetry.turnIndex = Number(record.messageCount);
+        }
+        break;
+      default:
+        break;
+    }
+    if (typeof record?.sessionId === "string") telemetry.sessionId = record.sessionId;
+    if (typeof record?.cwd === "string") telemetry.cwd = record.cwd;
+    if (typeof record?.gitBranch === "string") telemetry.gitBranch = record.gitBranch;
+    if (record?.type === "assistant") {
+      const text = contentBlocks(record)
+        .filter((block) => block?.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join(" ");
+      if (text.trim()) telemetry.assistantPreview = preview(text, PREVIEW_LIMIT);
+    }
+  }
+
+  const timed = records.filter(
+    (record) => record?.type !== "attachment" && timestampMs(record?.timestamp) > 0,
+  );
+  const latest = timed.at(-1);
+  if (!latest) return telemetry;
+  telemetry.lastEventAt = timestampMs(latest.timestamp);
+
+  if (latest.type === "system" && latest.subtype === "turn_duration") {
+    telemetry.state = "idle";
+    return telemetry;
+  }
+  if (latest.type === "assistant") {
+    const toolBlock = contentBlocks(latest).find((block) => block?.type === "tool_use");
+    if (toolBlock) {
+      telemetry.state = "tool";
+      telemetry.toolName = String(toolBlock.name ?? "");
+      telemetry.toolTarget = describeToolTarget(toolBlock);
+      return telemetry;
+    }
+    telemetry.state = latest.message?.stop_reason === "end_turn" ? "idle" : "thinking";
+    return telemetry;
+  }
+  if (latest.type === "user") {
+    telemetry.state = "thinking";
+    return telemetry;
+  }
+  return telemetry;
+}

package/src/common/codex-transcript.mjs

@@ -0,0 +1,153 @@
+// ---
+// summary: "derives live Codex session state from the tail of its rollout file"
+// read_when:
+//   - "changing Codex card telemetry or the rollout records it depends on"
+// ---
+
+/**
+ * Codex appends newline-delimited records to a per-session rollout. Every record carries a
+ * top-level `timestamp`, a `type` of `session_meta`, `turn_context`, `event_msg` or
+ * `response_item`, and a `payload` whose own `type` names the event. The format belongs to Codex
+ * and carries no stability guarantee, so every field is optional here and an unparseable record is
+ * skipped. When nothing usable is found the caller keeps the process-only card.
+ */
+
+const PREVIEW_LIMIT = 100;
+const TOOL_ARGUMENT_KEYS = ["cmd", "command", "query", "path", "file_path", "pattern", "workdir"];
+
+/** @typedef {import("./claude-transcript.mjs").ClaudeTelemetry} AgentTelemetry */
+
+/** @param {unknown} value */
+function preview(value) {
+  const text = String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return text.length > PREVIEW_LIMIT ? `${text.slice(0, PREVIEW_LIMIT - 1)}…` : text;
+}
+
+/** @param {unknown} value */
+function timestampMs(value) {
+  const parsed = Date.parse(String(value ?? ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+/**
+ * Name what a Codex tool call is acting on. Arguments arrive as a JSON string, and a call whose
+ * arguments do not parse still reports its tool name.
+ * @param {any} payload
+ */
+export function describeCodexToolTarget(payload) {
+  let args = payload?.arguments;
+  if (typeof args === "string") {
+    try {
+      args = JSON.parse(args);
+    } catch {
+      return preview(args);
+    }
+  }
+  if (!args || typeof args !== "object") return "";
+  for (const key of TOOL_ARGUMENT_KEYS) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) return preview(value);
+    if (Array.isArray(value) && value.length > 0) return preview(value.join(" "));
+  }
+  return "";
+}
+
+/** @param {any} payload */
+function toolNameFor(payload) {
+  const type = String(payload?.type ?? "");
+  if (type === "function_call" || type === "custom_tool_call") {
+    return String(payload?.name ?? "") || "tool";
+  }
+  if (type === "local_shell_call") return "shell";
+  if (type === "web_search_call") return "web_search";
+  return "";
+}
+
+/** @returns {AgentTelemetry} */
+function emptyTelemetry() {
+  return {
+    title: "",
+    lastPrompt: "",
+    assistantPreview: "",
+    state: "idle",
+    toolName: "",
+    toolTarget: "",
+    turnIndex: 0,
+    lastEventAt: 0,
+    mode: "",
+    permissionMode: "",
+    sessionId: "",
+    cwd: "",
+    gitBranch: "",
+  };
+}
+
+/**
+ * Read the tail of a rollout. The first line is usually a fragment and is skipped by the parse
+ * failure path. State comes from the newest record that carries a timestamp, so a tool call is
+ * reported as running only while it is still the newest record; its output lands after it.
+ * @param {string} tail
+ * @returns {AgentTelemetry}
+ */
+export function parseCodexRolloutTail(tail) {
+  const telemetry = emptyTelemetry();
+  if (!tail) return telemetry;
+
+  /** @type {any[]} */
+  const records = [];
+  for (const line of String(tail).split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      records.push(JSON.parse(trimmed));
+    } catch {
+      // A truncated first or last line is not evidence.
+    }
+  }
+  if (records.length === 0) return telemetry;
+
+  for (const record of records) {
+    const payload = record?.payload;
+    const payloadType = String(payload?.type ?? "");
+    if (record?.type === "session_meta") {
+      telemetry.sessionId = String(payload?.id ?? telemetry.sessionId);
+      telemetry.cwd = String(payload?.cwd ?? telemetry.cwd);
+      const branch = payload?.git?.branch;
+      if (typeof branch === "string") telemetry.gitBranch = branch;
+    } else if (record?.type === "turn_context") {
+      telemetry.cwd = String(payload?.cwd ?? telemetry.cwd);
+      telemetry.mode = String(payload?.approval_policy ?? telemetry.mode);
+      const sandbox = payload?.sandbox_policy?.type;
+      if (typeof sandbox === "string") telemetry.permissionMode = sandbox;
+    } else if (payloadType === "user_message") {
+      telemetry.lastPrompt = preview(payload?.message);
+    } else if (payloadType === "agent_message") {
+      telemetry.assistantPreview = preview(payload?.message);
+    } else if (payloadType === "task_complete") {
+      telemetry.turnIndex += 1;
+      if (payload?.last_agent_message) {
+        telemetry.assistantPreview = preview(payload.last_agent_message);
+      }
+    }
+  }
+
+  const timed = records.filter((record) => timestampMs(record?.timestamp) > 0);
+  const latest = timed.at(-1);
+  if (!latest) return telemetry;
+  telemetry.lastEventAt = timestampMs(latest.timestamp);
+
+  const payload = latest.payload;
+  const payloadType = String(payload?.type ?? "");
+  // A tool call that is the newest record is still running: its output would appear after it.
+  const toolName = toolNameFor(payload);
+  if (toolName) {
+    telemetry.state = "tool";
+    telemetry.toolName = toolName;
+    telemetry.toolTarget = describeCodexToolTarget(payload);
+    return telemetry;
+  }
+  telemetry.state = payloadType === "task_complete" ? "idle" : "thinking";
+  return telemetry;
+}

package/src/common/compatibility.mjs

@@ -1,12 +1,12 @@
 // ---
-// 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";
+import { detectTabInventorySupport } from "../native/tab-inventory.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -67,23 +67,29 @@ 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({
     env,
     execFileAsyncImpl: options.execFileAsyncImpl,
   });
+  const tabInventory = await detectTabInventorySupport({
+    execFileAsync: options.execFileAsyncImpl ?? execFileAsync,
+    env,
+  });
   const blockers = [];
   const warnings = [];
-  let electronPath = null;
 
   if (displayServer === "headless") {
     blockers.push(
@@ -97,10 +103,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,19 +118,26 @@ 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.",
+    );
+  }
+
+  if (windowManager === "niri" && !tabInventory.available) {
+    warnings.push(
+      `Hidden Ghostty tabs that were never shown cannot be placed: ${tabInventory.detail}. Tabs shown while the strip runs are still remembered.`,
     );
   }
 
   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",
+    tabInventory,
     blockers,
     warnings,
   };
@@ -137,10 +151,11 @@ 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)"}`,
+    `Hidden-tab inventory: ${report.tabInventory?.available ? "available" : "unavailable"} (${report.tabInventory?.detail ?? "unknown"})`,
   ];
 
   if (typeof report.displayCount === "number") {

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;
@@ -29,6 +38,32 @@ export interface SessionSnapshot {
   errorMessage: string;
 }
 
+export type AkTaskChipState = "active" | "deferred" | "orphaned";
+
+/** One read-only AK task reference joined onto a terminal card by the native projection. */
+export interface AkTaskChip {
+  id: number;
+  title: string;
+  state: AkTaskChipState;
+}
+
+/** A live-lease task claim parsed from read-only `ak task list` output. */
+export interface AkTaskClaim {
+  id: number;
+  title: string;
+  repo: string;
+  sessionId: string;
+  leaseExpiresAt: number;
+  claimedAt: number;
+}
+
+/** A task with an active deferral parsed from read-only `ak task deferred` output. */
+export interface AkTaskDeferred {
+  id: number;
+  title: string;
+  repo: string;
+}
+
 export interface BrokerSnapshot {
   generatedAt: number;
   sessions: SessionSnapshot[];
@@ -38,13 +73,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 +112,7 @@ export interface BrokerClientOptions {
 
 export interface SessionStoreOptions {
   staleAfterMs?: number;
+  maxSessions?: number;
 }
 
 export interface ActivityStripBrokerOptions {
@@ -76,7 +124,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 +192,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 +215,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[];