@tryinget/pi-activity-strip 0.5.0 → 0.6.0

package/native/panel/src/style.css

@@ -1,56 +1,65 @@
+/*
+ * Every colour here derives from the handful of names the controller defines from Ghostty's own
+ * theme, so the ribbon follows the terminal into light and dark without a second palette to keep
+ * in sync. mix() against the background and alpha() against the foreground both invert correctly
+ * between schemes: a raised surface is lighter on a dark theme and darker on a light one.
+ */
+
 /* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
 window {
   background: transparent;
-  color: rgba(247, 250, 255, 0.96);
-  font-family: "IBM Plex Sans", "Avenir Next", "Segoe UI", sans-serif;
+  color: @pi_foreground;
+  font-family: "IBM Plex Sans", "Inter", "Segoe UI", sans-serif;
 }
 
-.brand,
-.cards-panel {
-  background: linear-gradient(to bottom, rgba(12, 19, 33, 0.96), rgba(8, 13, 22, 0.92));
-  border: 1px solid rgba(255, 255, 255, 0.08);
-  border-radius: 20px;
+/* One surface on the same rhythm and radius as tiled windows, so it reads as a peer of them. */
+.band {
+  /* Solid: the ribbon is the one surface that never dims, so it reads as the fixed ground. */
+  background: @pi_background;
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 12px;
+  padding: 0 14px 0 16px;
 }
 
 .brand {
-  padding: 10px 12px;
+  border-right: 1px solid alpha(@pi_foreground, 0.12);
+  margin-right: 12px;
+  padding: 11px 14px 11px 0;
 }
 
 .brand-eyebrow,
 .meta,
 .card-state,
 .card-tool,
+.card-elapsed,
 .inspector-key {
   font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
 }
 
 .brand-eyebrow {
-  color: #79b8ff;
+  color: alpha(@pi_accent, 0.9);
   font-size: 9px;
-  letter-spacing: 1px;
+  font-weight: 600;
+  letter-spacing: 1.4px;
 }
 
 .brand-title {
-  color: rgba(247, 250, 255, 0.96);
-  font-size: 18px;
+  color: @pi_foreground;
+  font-size: 17px;
   font-weight: 650;
-}
-
-.brand-subtitle {
-  color: rgba(194, 205, 224, 0.74);
-  font-size: 10px;
+  letter-spacing: -0.2px;
 }
 
 .meta {
-  color: rgba(167, 180, 203, 0.58);
+  color: alpha(@pi_foreground, 0.56);
   font-size: 9px;
 }
 
 /* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel,
 .cards-panel > viewport {
-  background: linear-gradient(to bottom, rgba(10, 16, 28, 0.94), rgba(6, 10, 18, 0.9));
-  border-radius: 20px;
-  padding: 6px 8px 8px;
+  background: transparent;
+  padding: 0;
 }
 
 /* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
@@ -61,32 +70,42 @@ window {
 }
 
 .card {
-  color: rgba(247, 250, 255, 0.96);
-  background: linear-gradient(to bottom, rgba(13, 20, 35, 0.98), rgba(9, 14, 24, 0.96));
-  border: 1px solid rgba(255, 255, 255, 0.14);
-  border-left: 3px solid #79b8ff;
-  border-radius: 16px;
-  padding: 8px 10px 8px 12px;
-  box-shadow: none;
-  transition: 120ms ease;
+  color: @pi_foreground;
+  background: mix(@pi_background, @pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.1);
+  border-left: 3px solid alpha(@pi_foreground, 0.35);
+  border-radius: 12px;
+  padding: 7px 11px 7px 10px;
+  transition:
+    background 120ms ease,
+    border-color 120ms ease;
 }
 
 .card:hover,
 .card:focus-visible,
 .card.open {
-  background: linear-gradient(to bottom, rgba(18, 28, 47, 0.99), rgba(10, 16, 28, 0.97));
-  border-color: rgba(121, 184, 255, 0.72);
+  background: mix(@pi_background, @pi_foreground, 0.14);
+  border-color: alpha(@pi_accent, 0.5);
 }
 
+/* The tab the compositor is actually showing, marked by weight rather than another border. */
 .card.current {
-  border-left-width: 5px;
-  border-color: rgba(150, 202, 255, 0.92);
-  outline: 1px solid rgba(121, 184, 255, 0.38);
-  outline-offset: -3px;
+  background: mix(@pi_background, @pi_foreground, 0.16);
+  border-color: alpha(@pi_accent, 0.42);
+  box-shadow: inset 0 0 0 1px alpha(@pi_accent, 0.22);
+}
+
+.card.hidden-tab {
+  background: alpha(@pi_background, 0.55);
+  border-style: dashed;
+}
+
+.card.hidden-tab .card-repo {
+  color: alpha(@pi_foreground, 0.78);
 }
 
 .card.stalled {
-  opacity: 0.72;
+  opacity: 0.62;
 }
 
 .card.stalled .card-phase {
@@ -94,83 +113,138 @@ window {
 }
 
 .card.state-thinking {
-  border-left-color: #8ab4ff;
+  border-left-color: @pi_thinking;
 }
 .card.state-tool {
-  border-left-color: #ffd166;
+  border-left-color: @pi_tool;
 }
 .card.state-waiting {
-  border-left-color: #ff9f7a;
+  border-left-color: @pi_waiting;
 }
 .card.state-success {
-  border-left-color: #57d9a3;
+  border-left-color: @pi_success;
 }
 .card.state-error {
-  border-left-color: #ff7d7d;
+  border-left-color: @pi_error;
 }
 
 .card-repo {
-  color: rgba(247, 250, 255, 0.96);
+  color: @pi_foreground;
   font-size: 12px;
   font-weight: 650;
 }
 
 .card-phase,
 .inspector-value {
-  color: rgba(194, 205, 224, 0.76);
+  color: alpha(@pi_foreground, 0.74);
   font-size: 10px;
 }
 
+/* A quiet pill: the state is carried mostly by the card's left edge. */
 .card-state {
-  border: 1px solid rgba(121, 184, 255, 0.36);
+  background: alpha(@pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.16);
   border-radius: 999px;
-  color: #79b8ff;
+  color: alpha(@pi_foreground, 0.68);
   font-size: 8px;
-  padding: 4px 6px;
+  letter-spacing: 0.4px;
+  padding: 3px 7px;
 }
 
+.state-thinking .card-state {
+  background: alpha(@pi_thinking, 0.14);
+  border-color: alpha(@pi_thinking, 0.38);
+  color: @pi_thinking;
+}
 .state-tool .card-state {
-  color: #ffd166;
-  border-color: rgba(255, 209, 102, 0.42);
+  background: alpha(@pi_tool, 0.14);
+  border-color: alpha(@pi_tool, 0.38);
+  color: @pi_tool;
 }
 .state-waiting .card-state {
-  color: #ff9f7a;
-  border-color: rgba(255, 159, 122, 0.42);
+  background: alpha(@pi_waiting, 0.16);
+  border-color: alpha(@pi_waiting, 0.42);
+  color: @pi_waiting;
 }
 .state-success .card-state {
-  color: #57d9a3;
-  border-color: rgba(87, 217, 163, 0.42);
+  background: alpha(@pi_success, 0.14);
+  border-color: alpha(@pi_success, 0.38);
+  color: @pi_success;
 }
 .state-error .card-state {
-  color: #ff7d7d;
-  border-color: rgba(255, 125, 125, 0.42);
+  background: alpha(@pi_error, 0.16);
+  border-color: alpha(@pi_error, 0.44);
+  color: @pi_error;
 }
 
 .card-tool,
 .card-elapsed,
 .inspector-key {
-  color: rgba(167, 180, 203, 0.58);
+  color: alpha(@pi_foreground, 0.55);
   font-size: 8px;
 }
 
 .inspector {
-  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  border-top: 1px solid alpha(@pi_foreground, 0.12);
   padding-top: 9px;
 }
 
 .inspector-value {
-  line-height: 1.25;
+  line-height: 1.3;
 }
 
 .activation {
-  color: rgba(167, 180, 203, 0.72);
+  color: alpha(@pi_foreground, 0.7);
   font-size: 9px;
 }
 
 .activation.success {
-  color: #57d9a3;
+  color: @pi_success;
 }
 
 .activation.error {
-  color: #ff7d7d;
+  color: @pi_error;
+}
+
+/*
+ * AK task references. An active chip is the one clickable element inside a card besides the card
+ * itself: it reuses the card's activation, so it carries the accent colour and a pointer cursor.
+ * Badge states (a claim that outlives its session, a deferred task) are deliberately inert pills.
+ */
+.ak-task {
+  background: alpha(@pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 999px;
+  color: alpha(@pi_foreground, 0.68);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
+  padding: 3px 8px;
+}
+
+.ak-task.ak-active {
+  background: alpha(@pi_accent, 0.14);
+  border-color: alpha(@pi_accent, 0.42);
+  color: @pi_accent;
+}
+
+.ak-task.ak-active:hover {
+  background: alpha(@pi_accent, 0.26);
+}
+
+.ak-task.ak-orphaned {
+  background: alpha(@pi_error, 0.12);
+  border: 1px dashed alpha(@pi_error, 0.4);
+  color: alpha(@pi_error, 0.92);
+}
+
+.ak-task.ak-deferred {
+  background: alpha(@pi_tool, 0.12);
+  border: 1px dashed alpha(@pi_tool, 0.4);
+  color: alpha(@pi_tool, 0.92);
+}
+
+.ak-overflow {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -88,9 +88,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
-    "@earendil-works/pi-agent-core": "0.84.3",
-    "@earendil-works/pi-ai": "0.84.3",
-    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@earendil-works/pi-agent-core": "0.84.4",
+    "@earendil-works/pi-ai": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.84.4",
     "@types/node": "22.14.0",
     "@typescript/native-preview": "7.0.0-dev.20260417.1",
     "typebox": "1.3.7",

package/src/common/agent-identity.mjs

@@ -0,0 +1,163 @@
+// ---
+// summary: "recognizes terminal-based coding agents and shapes them into activity-strip session records"
+// read_when:
+//   - "adding an agent CLI, changing agent card fields, or changing agent title matching"
+// ---
+
+import path from "node:path";
+
+/**
+ * Terminal-based coding agents that occupy a Ghostty tab the way Pi does. Recognition is by the
+ * executable name of the process that owns the terminal, never by a window title, so a tab is
+ * admitted on process evidence alone.
+ * @type {ReadonlyArray<{kind: string; label: string; commands: readonly string[]}>}
+ */
+export const AGENT_CATALOG = Object.freeze([
+  { kind: "claude", label: "Claude Code", commands: Object.freeze(["claude"]) },
+  { kind: "codex", label: "Codex", commands: Object.freeze(["codex"]) },
+  { kind: "gemini", label: "Gemini", commands: Object.freeze(["gemini"]) },
+  { kind: "amp", label: "Amp", commands: Object.freeze(["amp"]) },
+  { kind: "aider", label: "Aider", commands: Object.freeze(["aider"]) },
+  { kind: "opencode", label: "opencode", commands: Object.freeze(["opencode"]) },
+  { kind: "crush", label: "Crush", commands: Object.freeze(["crush"]) },
+  { kind: "goose", label: "Goose", commands: Object.freeze(["goose"]) },
+  { kind: "cursor", label: "Cursor Agent", commands: Object.freeze(["cursor-agent"]) },
+  { kind: "zcode", label: "zcode", commands: Object.freeze(["zcode"]) },
+]);
+
+/** Pi publishes its own telemetry, so its processes are never discovered this way. */
+const EXCLUDED_COMMANDS = new Set(["pi", "node", "bash", "sh", "zsh", "fish", "python3"]);
+/**
+ * Executables that only ever host another program. When one of these is the process name, the
+ * command line names the real agent, so it is worth the extra read to look.
+ */
+const RUNTIME_COMMANDS = [/^node/i, /^python/i, /^(bash|sh|zsh|fish|dash|env)$/i, /^(deno|bun)$/i];
+
+/** @param {unknown} command */
+export function isRuntimeCommand(command) {
+  const name = path.basename(String(command ?? "").trim());
+  return name.length > 0 && RUNTIME_COMMANDS.some((pattern) => pattern.test(name));
+}
+export const AGENT_ACTIVE_WINDOW_MS = 45_000;
+
+/** @param {NodeJS.ProcessEnv} [env] */
+export function agentCatalogFor(env = process.env) {
+  const disabled = new Set(
+    String(env.PI_ACTIVITY_STRIP_AGENT_KINDS_DISABLED ?? "")
+      .split(",")
+      .map((value) => value.trim().toLowerCase())
+      .filter(Boolean),
+  );
+  return AGENT_CATALOG.filter((agent) => !disabled.has(agent.kind));
+}
+
+/**
+ * Classify one process by the executable it runs. `command` is the kernel's comm value, which the
+ * kernel truncates to 15 characters and which names the runtime rather than the agent when the
+ * agent is launched through one; the command line entries name the agent in that case.
+ * @param {{command?: unknown; argv0?: unknown; argv1?: unknown; env?: NodeJS.ProcessEnv}} process
+ */
+export function classifyAgentProcess({ command, argv0, argv1, env = process.env } = {}) {
+  const names = [command, argv0, argv1]
+    .map((value) => path.basename(String(value ?? "").trim()).toLowerCase())
+    .filter(Boolean);
+  if (names.length === 0 || names.every((name) => EXCLUDED_COMMANDS.has(name))) return null;
+  for (const agent of agentCatalogFor(env)) {
+    if (agent.commands.some((candidate) => names.includes(candidate))) return agent;
+  }
+  return null;
+}
+
+/** @param {unknown} cwd */
+export function repoLabelFor(cwd) {
+  const normalized = String(cwd ?? "").trim();
+  if (!normalized || normalized === "/") return "";
+  return path.basename(normalized);
+}
+
+/**
+ * Shape one discovered agent tab into the record the card projection consumes. The record carries a
+ * terminal identity, so it groups and places exactly like a Pi terminal card, but its session id is
+ * namespaced by agent kind and can never be mistaken for a Pi session id.
+ * @param {{
+ *   kind: string;
+ *   label: string;
+ *   processId: number;
+ *   cwd: string;
+ *   terminalKey: string;
+ *   terminalFamily: string;
+ *   terminalSurfaceId: string;
+ *   sessionKey?: string;
+ *   titleSuffix?: string;
+ *   startedAt: number;
+ *   lastEventAt?: number;
+ *   now?: number;
+ *   telemetry?: Partial<import("./claude-transcript.mjs").ClaudeTelemetry> | null;
+ * }} tab
+ */
+export function agentSessionRecord({
+  kind,
+  label,
+  processId,
+  cwd,
+  terminalKey,
+  terminalFamily,
+  terminalSurfaceId,
+  sessionKey = "",
+  titleSuffix = "",
+  startedAt,
+  lastEventAt = 0,
+  now = Date.now(),
+  telemetry = null,
+}) {
+  // Process start times and file modification times are fractional milliseconds, while the panel
+  // protocol carries whole-millisecond integers, so every timestamp is rounded at the boundary.
+  const startedAtMs = Math.round(startedAt) || 0;
+  const lastEventMs = Math.round(lastEventAt) || 0;
+  const nowMs = Math.round(now) || 0;
+  const activity = lastEventMs > 0 ? lastEventMs : startedAtMs;
+  // Reported activity decides liveness. A published state only counts while the transcript is
+  // still moving; a stale "tool" record is not evidence that a tool is running right now.
+  const recent = lastEventMs > 0 && nowMs - lastEventMs <= AGENT_ACTIVE_WINDOW_MS;
+  const reported = String(telemetry?.state ?? "");
+  // "waiting" and "error" describe a session that is stopped on purpose, so they survive the
+  // liveness window: a permission prompt can sit unanswered for a long time and is still true.
+  const sticky = reported === "waiting" || reported === "error";
+  const busy = reported === "tool" || reported === "thinking";
+  const active = sticky || (recent && (busy || !reported));
+  const state = sticky ? reported : active ? (busy ? reported : "thinking") : "idle";
+  const toolName = active ? String(telemetry?.toolName ?? "") : "";
+  const toolTarget = active ? String(telemetry?.toolTarget ?? "") : "";
+  const detail = [toolTarget, String(telemetry?.assistantPreview ?? ""), cwd].find(Boolean) ?? "";
+  return {
+    sessionId: `agent:${kind}:${sessionKey || processId}`,
+    publisherId: `agent-scan:${processId}`,
+    publisherSequence: 0,
+    processId,
+    agentKind: kind,
+    agentSessionKey: sessionKey,
+    terminalKind: "ghostty-surface",
+    terminalKey,
+    terminalFamily,
+    terminalSurfaceId,
+    titleSuffix,
+    cwd,
+    repoLabel: repoLabelFor(cwd),
+    sessionName: "",
+    agentLabel: label,
+    phase: String(telemetry?.title ?? "").trim() || label,
+    detail,
+    assistantPreview: String(telemetry?.assistantPreview ?? ""),
+    toolName,
+    toolTarget,
+    state,
+    turnIndex: Number(telemetry?.turnIndex ?? 0) || 0,
+    updatedAt: nowMs,
+    lastEventAt: activity,
+    startedAt: startedAtMs,
+    agentStartedAt: active ? activity : null,
+    agentActive: active,
+    lastPromptPreview: String(telemetry?.lastPrompt ?? ""),
+    errorMessage: "",
+  };
+}