@tryinget/pi-activity-strip 0.5.0 → 0.6.0

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

@@ -6,6 +6,7 @@
 
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { detectTabInventorySupport } from "../native/tab-inventory.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -83,6 +84,10 @@ export async function assessActivityStripCompatibility(options = {}) {
     env,
     execFileAsyncImpl: options.execFileAsyncImpl,
   });
+  const tabInventory = await detectTabInventorySupport({
+    execFileAsync: options.execFileAsyncImpl ?? execFileAsync,
+    env,
+  });
   const blockers = [];
   const warnings = [];
 
@@ -117,6 +122,12 @@ export async function assessActivityStripCompatibility(options = {}) {
     );
   }
 
+  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,
@@ -126,6 +137,7 @@ export async function assessActivityStripCompatibility(options = {}) {
     alignmentMode: "layer-shell",
     primaryDisplayOnly: true,
     clickThroughDefault: env.PI_ACTIVITY_STRIP_CLICK_THROUGH === "1",
+    tabInventory,
     blockers,
     warnings,
   };
@@ -143,6 +155,7 @@ export function formatCompatibilityReport(report) {
     `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/contracts.d.ts

@@ -38,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[];

package/src/common/contracts.ts

@@ -19,6 +19,12 @@ export interface SessionSnapshot {
   publisherCount?: number;
   publisherIds?: string[];
   publisherRecordKeys?: string[];
+  publisherSessionIds?: string[];
+  akTasks?: AkTaskChip[];
+  akTaskOverflow?: number;
+  windowId?: number | null;
+  placement?: "title" | "host" | "binding";
+  surfaceVisible?: boolean;
   cwd: string;
   repoLabel: string;
   sessionName: string;
@@ -38,6 +44,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[];
@@ -57,6 +89,30 @@ export interface ActivityStripRuntimeStatus {
   alignmentMode?: "layer-shell";
   rendererCardCount?: number;
   rendererCardIds?: string[];
+  rendererHiddenTabCardCount?: number;
+  surfaceBindingCount?: number;
+  unplacedSurfaceCount?: number;
+  agentTabCount?: number;
+  themeScheme?: "dark" | "light" | "unknown";
+  themeName?: string | null;
+  themeSource?: string | null;
+  themeFingerprint?: string;
+  themeError?: string;
+  agentScanError?: string | null;
+  heightRepairState?: "enabled" | "disabled";
+  heightRepairCount?: number;
+  lastHeightRepairAt?: number;
+  tabInventoryState?: "pending" | "ready" | "failed" | "unavailable" | "disabled";
+  tabInventoryDetail?: string | null;
+  tabInventoryFrameCount?: number;
+  tabInventoryTabCount?: number;
+  tabInventoryProbedAt?: number | null;
+  akTaskState?: "pending" | "ok" | "unavailable" | "disabled";
+  akTaskError?: string | null;
+  akTaskClaimCount?: number;
+  akTaskDeferredCount?: number;
+  akTaskOrphanCount?: number;
+  akTaskRenderedCount?: number;
   rendererVisibilityTransitionCount?: number;
   controllerPid?: number;
   panelPid?: number | null;
@@ -98,7 +154,13 @@ export interface ActivityStripBrokerOptions {
     remove(sessionId: string, publisherId?: string): boolean;
   };
   getRuntimeStatus?: () => ActivityStripRuntimeStatus | undefined;
-  focusSession?: (targetId: string) => Promise<{ ok: boolean; error?: string; windowId?: number }>;
+  focusSession?: (targetId: string) => Promise<{
+    ok: boolean;
+    error?: string;
+    windowId?: number;
+    presented?: boolean;
+    verified?: boolean;
+  }>;
   focusStrip?: () => Promise<{ ok: boolean; error?: string }>;
 }
 
@@ -196,6 +258,7 @@ export interface ActivityStripCompatibilityReport {
   alignmentMode: "layer-shell";
   primaryDisplayOnly: boolean;
   clickThroughDefault: boolean;
+  tabInventory?: { available: boolean; detail: string };
   blockers: string[];
   warnings: string[];
 }

package/src/common/ghostty-present.mjs

@@ -0,0 +1,100 @@
+// ---
+// summary: "presents one Ghostty surface through the running process's session-bus present-surface action"
+// read_when:
+//   - "changing hidden-tab activation, Ghostty D-Bus targeting, or its fail-closed conditions"
+// ---
+
+import { normalizeGhosttySurfaceId } from "./terminal-identity.mjs";
+
+const GHOSTTY_OBJECT_PATHS = new Map([
+  ["main", "/com/mitchellh/ghostty"],
+  ["legacy", "/com/tryinget/ghosttysidequest"],
+]);
+export const GHOSTTY_PRESENT_SURFACE_TIMEOUT_MS = 2000;
+
+/** @typedef {(file: string, args: string[], options: object) => Promise<{stdout?: string}>} ExecFileAsync */
+/** @typedef {{ok: true; busName: string} | {ok: false; error: string}} PresentSurfaceResult */
+
+/** @param {unknown} family */
+export function ghosttyObjectPathForFamily(family) {
+  return GHOSTTY_OBJECT_PATHS.get(String(family ?? "")) ?? "";
+}
+
+/**
+ * Every running Ghostty process, single-instance server or standalone window, exports
+ * `org.gtk.Actions` on its unique bus name. `present-surface` selects the tab owning the surface
+ * and presents its window; a surface id the process does not own is ignored by Ghostty itself.
+ * The target is the exact host process already proven to contain the surface, never a
+ * well-known name that another build could claim.
+ * @param {{execFileAsync: ExecFileAsync; env?: NodeJS.ProcessEnv; hostPid: number; terminalFamily: unknown; surfaceId: unknown; timeout?: number}} options
+ * @returns {Promise<PresentSurfaceResult>}
+ */
+export async function presentGhosttySurface({
+  execFileAsync,
+  env = process.env,
+  hostPid,
+  terminalFamily,
+  surfaceId,
+  timeout = GHOSTTY_PRESENT_SURFACE_TIMEOUT_MS,
+}) {
+  const objectPath = ghosttyObjectPathForFamily(terminalFamily);
+  const normalizedSurfaceId = normalizeGhosttySurfaceId(surfaceId);
+  if (
+    !objectPath ||
+    !normalizedSurfaceId ||
+    normalizedSurfaceId === "0" ||
+    !Number.isInteger(hostPid) ||
+    hostPid <= 0
+  ) {
+    return { ok: false, error: "the surface target is incomplete" };
+  }
+
+  let rows;
+  try {
+    const { stdout } = await execFileAsync(
+      "busctl",
+      ["--user", "list", "--no-pager", "--no-legend"],
+      { env, timeout },
+    );
+    rows = String(stdout ?? "")
+      .split("\n")
+      .map((line) => line.trim().split(/\s+/));
+  } catch {
+    return { ok: false, error: "the session bus is unavailable" };
+  }
+  const uniqueNames = rows
+    .filter(
+      (fields) => fields[0]?.startsWith(":") && Number.parseInt(fields[1] ?? "", 10) === hostPid,
+    )
+    .map((fields) => String(fields[0]));
+  if (uniqueNames.length === 0) {
+    return { ok: false, error: "the Ghostty process is not on the session bus" };
+  }
+  if (uniqueNames.length > 1) {
+    return { ok: false, error: "the Ghostty process owns several bus connections" };
+  }
+
+  try {
+    await execFileAsync(
+      "busctl",
+      [
+        "--user",
+        "call",
+        uniqueNames[0],
+        objectPath,
+        "org.gtk.Actions",
+        "Activate",
+        "sava{sv}",
+        "present-surface",
+        "1",
+        "t",
+        normalizedSurfaceId,
+        "0",
+      ],
+      { env, timeout },
+    );
+    return { ok: true, busName: uniqueNames[0] };
+  } catch {
+    return { ok: false, error: "Ghostty rejected present-surface" };
+  }
+}