@tryinget/pi-activity-strip 0.4.0 → 0.5.0

package/native/panel/src/style.css

@@ -0,0 +1,176 @@
+/* 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;
+}
+
+.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;
+}
+
+.brand {
+  padding: 10px 12px;
+}
+
+.brand-eyebrow,
+.meta,
+.card-state,
+.card-tool,
+.inspector-key {
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+}
+
+.brand-eyebrow {
+  color: #79b8ff;
+  font-size: 9px;
+  letter-spacing: 1px;
+}
+
+.brand-title {
+  color: rgba(247, 250, 255, 0.96);
+  font-size: 18px;
+  font-weight: 650;
+}
+
+.brand-subtitle {
+  color: rgba(194, 205, 224, 0.74);
+  font-size: 10px;
+}
+
+.meta {
+  color: rgba(167, 180, 203, 0.58);
+  font-size: 9px;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.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;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel scrollbar {
+  opacity: 0;
+  min-width: 0;
+  min-height: 0;
+}
+
+.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;
+}
+
+.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);
+}
+
+.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;
+}
+
+.card.stalled {
+  opacity: 0.72;
+}
+
+.card.stalled .card-phase {
+  text-decoration-line: line-through;
+}
+
+.card.state-thinking {
+  border-left-color: #8ab4ff;
+}
+.card.state-tool {
+  border-left-color: #ffd166;
+}
+.card.state-waiting {
+  border-left-color: #ff9f7a;
+}
+.card.state-success {
+  border-left-color: #57d9a3;
+}
+.card.state-error {
+  border-left-color: #ff7d7d;
+}
+
+.card-repo {
+  color: rgba(247, 250, 255, 0.96);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.card-phase,
+.inspector-value {
+  color: rgba(194, 205, 224, 0.76);
+  font-size: 10px;
+}
+
+.card-state {
+  border: 1px solid rgba(121, 184, 255, 0.36);
+  border-radius: 999px;
+  color: #79b8ff;
+  font-size: 8px;
+  padding: 4px 6px;
+}
+
+.state-tool .card-state {
+  color: #ffd166;
+  border-color: rgba(255, 209, 102, 0.42);
+}
+.state-waiting .card-state {
+  color: #ff9f7a;
+  border-color: rgba(255, 159, 122, 0.42);
+}
+.state-success .card-state {
+  color: #57d9a3;
+  border-color: rgba(87, 217, 163, 0.42);
+}
+.state-error .card-state {
+  color: #ff7d7d;
+  border-color: rgba(255, 125, 125, 0.42);
+}
+
+.card-tool,
+.card-elapsed,
+.inspector-key {
+  color: rgba(167, 180, 203, 0.58);
+  font-size: 8px;
+}
+
+.inspector {
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  padding-top: 9px;
+}
+
+.inspector-value {
+  line-height: 1.25;
+}
+
+.activation {
+  color: rgba(167, 180, 203, 0.72);
+  font-size: 9px;
+}
+
+.activation.success {
+  color: #57d9a3;
+}
+
+.activation.error {
+  color: #ff7d7d;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -26,6 +26,12 @@
   "engines": {
     "node": ">=22.19.0"
   },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
   "scripts": {
     "fix": "bash ./scripts/quality-gate.sh fix",
     "lint": "bash ./scripts/quality-gate.sh lint",
@@ -40,6 +46,8 @@
     "docs:list:json": "node ~/ai-society/core/agent-scripts/scripts/docs-list.mjs --json",
     "release:check": "bash ./scripts/release-check.sh",
     "release:check:quick": "SKIP_PI_SMOKE=1 bash ./scripts/release-check.sh",
+    "native:check": "cd native/panel && RUSTUP_TOOLCHAIN=stable cargo fmt --check && RUSTUP_TOOLCHAIN=stable cargo test",
+    "native:build": "bash ./scripts/build-native-panel.sh",
     "strip:open": "node ./bin/pi-activity-strip.mjs open",
     "strip:status": "node ./bin/pi-activity-strip.mjs status",
     "strip:doctor": "node ./bin/pi-activity-strip.mjs doctor",
@@ -56,6 +64,10 @@
     "extensions/activity-strip.js",
     "extensions/activity-strip.ts",
     "src",
+    "native/bin",
+    "native/panel/Cargo.toml",
+    "native/panel/Cargo.lock",
+    "native/panel/src",
     "prompts",
     "examples",
     "policy/security-policy.json"

package/src/broker/server.mjs

@@ -10,6 +10,8 @@ import net from "node:net";
 /** @typedef {import("../common/contracts.ts").ActivityStripBrokerOptions} ActivityStripBrokerOptions */
 import {
   ACTIVITY_STRIP_BROADCAST_TICK_MS,
+  ACTIVITY_STRIP_CLIENT_IDLE_TIMEOUT_MS,
+  ACTIVITY_STRIP_MAX_MESSAGE_BYTES,
   ACTIVITY_STRIP_SOCKET_DIR,
   ACTIVITY_STRIP_SOCKET_PATH,
 } from "../common/constants.mjs";
@@ -49,6 +51,8 @@ export class ActivityStripBroker extends EventEmitter {
     this.getRuntimeStatus = options.getRuntimeStatus ?? (() => undefined);
     this.focusSession =
       options.focusSession ?? (async () => ({ ok: false, error: "Focus unavailable" }));
+    this.focusStrip =
+      options.focusStrip ?? (async () => ({ ok: false, error: "Strip focus unavailable" }));
     this.server = net.createServer((socket) => this.handleConnection(socket));
     this.tick = null;
   }
@@ -98,12 +102,18 @@ export class ActivityStripBroker extends EventEmitter {
   handleConnection(socket) {
     let buffer = "";
     socket.setEncoding("utf8");
+    socket.setTimeout?.(ACTIVITY_STRIP_CLIENT_IDLE_TIMEOUT_MS, () => socket.destroy());
     socket.on("error", (error) => {
       if (!isExpectedClientDisconnect(error)) this.emit("client-error", error);
     });
 
     socket.on("data", (chunk) => {
       buffer += chunk;
+      if (Buffer.byteLength(buffer, "utf8") > ACTIVITY_STRIP_MAX_MESSAGE_BYTES) {
+        this.reply(socket, { ok: false, error: "Activity strip broker message is too large." });
+        socket.destroy();
+        return;
+      }
       let newlineIndex = buffer.indexOf("\n");
       while (newlineIndex >= 0) {
         const line = buffer.slice(0, newlineIndex);
@@ -139,26 +149,52 @@ export class ActivityStripBroker extends EventEmitter {
         });
         return;
       case "focus":
-        Promise.resolve(this.focusSession(String(message.sessionId ?? "")))
+        Promise.resolve(this.focusSession(String(message.cardId ?? message.sessionId ?? "")))
           .then((result) => this.reply(socket, { type: "focus", ...result }))
           .catch(() =>
             this.reply(socket, { ok: false, type: "focus", error: "Focus failed closed." }),
           );
         return;
+      case "focus-strip":
+        Promise.resolve(this.focusStrip())
+          .then((result) => this.reply(socket, { type: "focus-strip", ...result }))
+          .catch(() =>
+            this.reply(socket, {
+              ok: false,
+              type: "focus-strip",
+              error: "Strip focus failed closed.",
+            }),
+          );
+        return;
       case "shutdown":
         this.reply(socket, { ok: true, type: "shutdown" });
         setTimeout(() => {
           this.emit("shutdown-requested");
         }, 20);
         return;
-      case "remove":
-        this.store.remove(String(message.sessionId ?? ""), String(message.publisherId ?? ""));
-        this.emitSnapshot();
+      case "remove": {
+        const accepted = this.store.remove(
+          String(message.sessionId ?? ""),
+          String(message.publisherId ?? ""),
+        );
+        if (accepted) this.emitSnapshot();
+        this.reply(socket, {
+          ok: accepted,
+          type: "remove",
+          ...(accepted ? {} : { error: "Activity strip broker rejected remove." }),
+        });
         return;
-      case "upsert":
-        this.store.upsert(message.session);
-        this.emitSnapshot();
+      }
+      case "upsert": {
+        const accepted = this.store.upsert(message.session);
+        if (accepted) this.emitSnapshot();
+        this.reply(socket, {
+          ok: accepted,
+          type: "upsert",
+          ...(accepted ? {} : { error: "Activity strip broker rejected upsert." }),
+        });
         return;
+      }
       default:
         this.reply(socket, { ok: false, error: `Unsupported message type: ${message.type}` });
     }

package/src/broker/session-store.mjs

@@ -4,7 +4,10 @@
 //   - "changing session retention, upsert semantics, or broker snapshot ordering"
 // ---
 
-import { ACTIVITY_STRIP_STALE_AFTER_MS } from "../common/constants.mjs";
+import {
+  ACTIVITY_STRIP_MAX_SESSIONS,
+  ACTIVITY_STRIP_STALE_AFTER_MS,
+} from "../common/constants.mjs";
 import { normalizeSessionSnapshot, sortSessions } from "../common/protocol.mjs";
 
 /** @typedef {import("../common/contracts.ts").SessionSnapshot} SessionSnapshot */
@@ -25,36 +28,61 @@ export class SessionStore {
   /** @param {SessionStoreOptions} [options] */
   constructor(options = {}) {
     this.staleAfterMs = options.staleAfterMs ?? ACTIVITY_STRIP_STALE_AFTER_MS;
-    /** @type {Map<string, SessionSnapshot>} */
+    this.maxSessions = options.maxSessions ?? ACTIVITY_STRIP_MAX_SESSIONS;
+    /** @type {Map<string, {session: SessionSnapshot; receivedAt: number}>} */
     this.sessions = new Map();
+    /** @type {Map<string, number>} */
+    this.tombstones = new Map();
   }
 
-  /** @param {Partial<SessionSnapshot> | Record<string, unknown>} session */
-  upsert(session) {
+  /** @param {Partial<SessionSnapshot> | Record<string, unknown>} session @param {number} [receivedAt] */
+  upsert(session, receivedAt = Date.now()) {
+    if (!session || typeof session !== "object") return false;
+    this.purge(receivedAt);
     const normalized = normalizeSessionSnapshot(session);
     if (!normalized.sessionId) return false;
-    this.sessions.set(sessionKey(normalized), normalized);
+    const key = sessionKey(normalized);
+    if (this.tombstones.has(key)) return false;
+    const current = this.sessions.get(key);
+    if (
+      current &&
+      current.session.publisherSequence > 0 &&
+      (normalized.publisherSequence === 0 ||
+        normalized.publisherSequence <= current.session.publisherSequence)
+    ) {
+      return false;
+    }
+    if (!current && this.sessions.size >= this.maxSessions) return false;
+    this.sessions.set(key, { session: normalized, receivedAt });
     return true;
   }
 
-  /** @param {string} sessionId @param {string} [publisherId] */
-  remove(sessionId, publisherId) {
+  /** @param {string} sessionId @param {string} [publisherId] @param {number} [removedAt] */
+  remove(sessionId, publisherId, removedAt = Date.now()) {
     const id = String(sessionId ?? "");
     if (!id) return false;
-    return publisherId
-      ? this.sessions.delete(`${id}|${String(publisherId)}`)
-      : this.sessions.delete(id);
+    if (!publisherId) return this.sessions.delete(id);
+    const key = `${id}|${String(publisherId)}`;
+    this.purge(removedAt);
+    if (!this.sessions.has(key)) return false;
+    if (!this.tombstones.has(key) && this.tombstones.size >= this.maxSessions) return false;
+    this.sessions.delete(key);
+    this.tombstones.set(key, removedAt);
+    return true;
   }
 
   /** @param {number} [now] */
   purge(now = Date.now()) {
     let changed = false;
-    for (const [sessionId, session] of this.sessions.entries()) {
-      if (now - session.updatedAt > this.staleAfterMs) {
+    for (const [sessionId, entry] of this.sessions.entries()) {
+      if (now - entry.receivedAt > this.staleAfterMs) {
         this.sessions.delete(sessionId);
         changed = true;
       }
     }
+    for (const [sessionId, removedAt] of this.tombstones.entries()) {
+      if (now - removedAt > this.staleAfterMs) this.tombstones.delete(sessionId);
+    }
     return changed;
   }
 
@@ -63,7 +91,7 @@ export class SessionStore {
     this.purge(now);
     return {
       generatedAt: now,
-      sessions: sortSessions([...this.sessions.values()]),
+      sessions: sortSessions([...this.sessions.values()].map((entry) => entry.session)),
     };
   }
 }

package/src/client/broker-client.mjs

@@ -112,7 +112,12 @@ export async function requestBrokerShutdown(options = {}) {
 
 /** @param {SessionSnapshot} session @param {BrokerClientOptions} [options] */
 export async function publishSessionSnapshot(session, options = {}) {
-  await sendBrokerMessage(makeMessage("upsert", { session }), options);
+  const result = await sendBrokerMessage(makeMessage("upsert", { session }), {
+    ...options,
+    expectReply: true,
+  });
+  if (result?.ok !== true)
+    throw new Error(result?.error || "Activity strip broker rejected upsert.");
 }
 
 /** @param {{ sessionId: string; publisherId: string }} session @param {BrokerClientOptions} [options] */
@@ -125,11 +130,13 @@ export async function removeSession(session, options = {}) {
   } else {
     fallbackId = String(session ?? "");
   }
-  await sendBrokerMessage(
+  const result = await sendBrokerMessage(
     makeMessage("remove", {
       sessionId: String(record.sessionId ?? fallbackId),
       publisherId: String(record.publisherId ?? ""),
     }),
-    options,
+    { ...options, expectReply: true },
   );
+  if (result?.ok !== true)
+    throw new Error(result?.error || "Activity strip broker rejected remove.");
 }

package/src/client/session-telemetry.mjs

@@ -30,6 +30,7 @@ import {
   extractToolResultText,
   summarizeToolResult,
 } from "../common/telemetry.mjs";
+import { resolveTerminalIdentity as resolveTerminalIdentityDefault } from "../common/terminal-identity.mjs";
 import { publishSessionSnapshot, removeSession } from "./broker-client.mjs";
 
 function now() {
@@ -47,6 +48,9 @@ export function createSessionTelemetry({
   pi,
   cwd = process.cwd(),
   sessionName = "",
+  env = process.env,
+  stdinIsTTY = Boolean(process.stdin.isTTY),
+  resolveTerminalIdentity = resolveTerminalIdentityDefault,
   transport,
 } = {}) {
   const publish = transport?.publish ?? publishSessionSnapshot;
@@ -62,6 +66,9 @@ export function createSessionTelemetry({
   let lastStopReason = "";
   let confirmedSignature = "";
   let retryIndex = 0;
+  /** @type {Promise<void> | null} */
+  let flushPromise = null;
+  let flushAgain = false;
 
   /** Signature of the display-relevant fields, used to detect lost transitions. */
   function publishSignature() {
@@ -75,15 +82,20 @@ export function createSessionTelemetry({
       snapshot.toolName,
       snapshot.toolTarget,
       snapshot.errorMessage,
+      snapshot.terminalKey,
     ].join("\u001f");
   }
 
-  async function flush() {
+  function clearScheduledFlush() {
+    if (!flushTimer) return;
+    clearTimeout(flushTimer);
     flushTimer = null;
-    if (disposed) return;
-    // Heartbeat republish refreshes transport liveness only; lastEventAt stays
-    // pinned to the last real lifecycle event so stalled streams stay visible.
+  }
+
+  async function publishLatest() {
+    // Heartbeats refresh transport liveness only; lastEventAt remains the last real event.
     snapshot.updatedAt = now();
+    snapshot.publisherSequence += 1;
     snapshot.repoLabel = formatRepoLabel(
       snapshot.cwd,
       pi?.getSessionName?.() ?? snapshot.sessionName,
@@ -91,29 +103,48 @@ export function createSessionTelemetry({
     snapshot.sessionName = compactWhitespace(pi?.getSessionName?.() ?? snapshot.sessionName);
     const signature = publishSignature();
     try {
-      await publish(snapshot);
+      await publish({ ...snapshot });
       confirmedSignature = signature;
       retryIndex = 0;
     } catch {
-      // Broker is optional at runtime; silent failure keeps pi stable. Retry a
-      // bounded number of times when a state transition may not have landed so
-      // a transient connect failure cannot freeze the displayed state.
       if (
+        !disposed &&
         signature !== confirmedSignature &&
         retryIndex < ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS.length
       ) {
-        scheduleFlush(ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS[retryIndex]);
+        const delayMs = ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS[retryIndex];
         retryIndex += 1;
+        scheduleFlush(delayMs);
       }
     }
   }
 
-  function scheduleFlush(delayMs = ACTIVITY_STRIP_SEND_THROTTLE_MS) {
+  async function flush() {
+    clearScheduledFlush();
     if (disposed) return;
-    if (flushTimer) return;
+    if (flushPromise) {
+      flushAgain = true;
+      return flushPromise;
+    }
+    flushPromise = (async () => {
+      do {
+        flushAgain = false;
+        if (disposed) break;
+        await publishLatest();
+      } while (flushAgain && !disposed);
+    })().finally(() => {
+      flushPromise = null;
+    });
+    return flushPromise;
+  }
+
+  function scheduleFlush(delayMs = ACTIVITY_STRIP_SEND_THROTTLE_MS) {
+    if (disposed || flushTimer) return;
     flushTimer = setTimeout(() => {
+      flushTimer = null;
       flush().catch(() => {});
     }, delayMs);
+    flushTimer.unref?.();
   }
 
   function startHeartbeat() {
@@ -149,8 +180,15 @@ export function createSessionTelemetry({
     async onSessionStart(ctx) {
       const exactSessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "").trim();
       const nextCwd = ctx?.cwd ?? snapshot.cwd;
+      const terminalIdentity = resolveTerminalIdentity({
+        env,
+        hasUI: Boolean(ctx?.hasUI),
+        stdinIsTTY,
+        processId: process.pid,
+      });
       update({
         ...(exactSessionId ? { sessionId: exactSessionId } : {}),
+        ...terminalIdentity,
         cwd: nextCwd,
         sessionName: pi?.getSessionName?.() ?? snapshot.sessionName,
         detail: previewPath(nextCwd, 72) || "Ready",
@@ -276,9 +314,11 @@ export function createSessionTelemetry({
     async shutdown() {
       disposed = true;
       stopHeartbeat();
-      if (flushTimer) {
-        clearTimeout(flushTimer);
-        flushTimer = null;
+      clearScheduledFlush();
+      try {
+        await flushPromise;
+      } catch {
+        // Broker absence remains non-fatal; publisher removal is still attempted below.
       }
       try {
         await removePublisher({

package/src/common/activity-order.mjs

@@ -6,6 +6,11 @@
 
 const ACTIVE_STATES = new Set(["thinking", "tool", "waiting"]);
 
+/** @param {{cardId?: string; sessionId?: string}} session */
+export function activityCardKey(session) {
+  return String(session?.cardId ?? session?.sessionId ?? "");
+}
+
 /** @param {{ state?: string; agentActive?: boolean }} session */
 export function isActiveSession(session) {
   return Boolean(session?.agentActive || ACTIVE_STATES.has(String(session?.state ?? "")));
@@ -24,18 +29,19 @@ export function isMonitoringSession(session) {
  * Reconcile at the calm clock: green settled/monitoring cards first, then active cards,
  * then other inactive cards. Preserve previous/manual order inside each group and append
  * new cards deterministically.
- * @param {Array<{ sessionId: string; state?: string; agentActive?: boolean; toolName?: string; toolTarget?: string; updatedAt?: number }>} sessions
+ * @param {Array<{ sessionId: string; cardId?: string; state?: string; agentActive?: boolean; toolName?: string; toolTarget?: string; updatedAt?: number }>} sessions
  * @param {string[]} previousOrder
  * @param {{ regroup?: boolean }} [options]
  */
 export function reconcileActivityOrder(sessions, previousOrder = [], { regroup = true } = {}) {
-  const byId = new Map(sessions.map((session) => [session.sessionId, session]));
+  const byId = new Map(sessions.map((session) => [activityCardKey(session), session]));
   const surviving = previousOrder.filter((id) => byId.has(id));
   const known = new Set(surviving);
   for (const session of sessions) {
-    if (!session.sessionId || known.has(session.sessionId)) continue;
-    surviving.push(session.sessionId);
-    known.add(session.sessionId);
+    const id = activityCardKey(session);
+    if (!id || known.has(id)) continue;
+    surviving.push(id);
+    known.add(id);
   }
   if (!regroup) return surviving;
 
@@ -45,16 +51,16 @@ export function reconcileActivityOrder(sessions, previousOrder = [], { regroup =
     const rightPriority = isMonitoringSession(right) ? 2 : isActiveSession(right) ? 1 : 0;
     const groupDelta = rightPriority - leftPriority;
     if (groupDelta) return groupDelta;
-    const leftPrior = priorIndex.get(left.sessionId);
-    const rightPrior = priorIndex.get(right.sessionId);
+    const leftPrior = priorIndex.get(activityCardKey(left));
+    const rightPrior = priorIndex.get(activityCardKey(right));
     if (leftPrior != null || rightPrior != null) {
       return (leftPrior ?? Number.MAX_SAFE_INTEGER) - (rightPrior ?? Number.MAX_SAFE_INTEGER);
     }
     const updateDelta = Number(right.updatedAt ?? 0) - Number(left.updatedAt ?? 0);
     if (updateDelta) return updateDelta;
-    return left.sessionId.localeCompare(right.sessionId);
+    return activityCardKey(left).localeCompare(activityCardKey(right));
   });
-  return ordered.map((session) => session.sessionId).filter((id) => byId.has(id));
+  return ordered.map(activityCardKey).filter((id) => byId.has(id));
 }
 
 /** @param {string[]} order @param {string} sessionId @param {-1 | 1} delta */