@tryinget/pi-activity-strip 0.2.0 → 0.4.0

package/README.md

@@ -24,7 +24,7 @@ This package is designed for the exact workflow you asked for:
 
 - auto-starts a local top-row overlay when Pi starts in a TUI session
 - tracks each active Pi session independently
-- shows one card per live session
+- on Niri, shows one card per tracked live Pi terminal on only the focused workspace; non-Niri desktops retain the global live-session view
 - surfaces:
   - repo/session label
   - current phase
@@ -33,6 +33,11 @@ This package is designed for the exact workflow you asked for:
   - elapsed time plus last-seen freshness
   - state color (`thinking`, `tool`, `waiting`, `done`, `error`)
 - keeps a local broker so multiple Pi processes can report into one strip
+- marks the Pi session in the currently focused Niri/Ghostty terminal with a stronger border and left rail, without adding another label
+- keeps green `done`/`monitoring` cards directly beside the Activity tile, followed by active work and then other settled sessions, on a calm 15-second ordering clock
+- reveals prompt, response, path, and full activity detail on hover or keyboard focus
+- focuses the exact matching Ghostty/Niri window on click or Enter, failing closed when identity is missing or ambiguous
+- keeps an aligned strip resident on its Niri workspace while that workspace still has tracked terminals, so visiting an empty workspace does not unmap or reposition it
 
 ## Architecture
 
@@ -51,14 +56,16 @@ It does not require moving your workflow onto `pi-server` first.
 Implemented now:
 - local per-host broker
 - primary-display top-row strip
-- one card per active Pi session
+- one card per tracked live Pi terminal on the focused Niri workspace, regardless of activity state
 - headless-safe telemetry publishing
-- explicit open/status/doctor/snapshot/fix-top/stop commands
+- explicit open/focus-strip/focus-session/status/doctor/snapshot/fix-top/stop commands
+- focus-scoped Left/Right navigation and Shift+Left/Right manual card movement
 - local visual capture helpers so the agent can inspect the strip directly
 
 Not implemented yet:
 - multi-monitor strip replication
-- historical timeline / expand-on-hover detail
+- historical timeline
+- persisted manual card order across strip restarts
 - remote observers via `pi-server`
 
 ## Installation in Pi
@@ -93,6 +100,8 @@ or directly:
 
 ```bash
 node ./bin/pi-activity-strip.mjs open
+node ./bin/pi-activity-strip.mjs focus-strip
+node ./bin/pi-activity-strip.mjs focus-session <full-pi-session-id>
 node ./bin/pi-activity-strip.mjs status
 node ./bin/pi-activity-strip.mjs doctor
 node ./bin/pi-activity-strip.mjs snapshot
@@ -116,6 +125,27 @@ In Pi with UI support:
 - `/activity-strip status` opens a detailed runtime status report when an editor surface is available
 - `/activity-strip doctor` opens the host-compatibility report
 
+## Interaction model
+
+- **Workspace locality:** one strip follows the Niri workspace selected with Up/Down and renders only tracked Pi terminals whose exact Ghostty windows are on that workspace. Focused-workspace events trigger reconciliation immediately, with polling retained as a fallback. When an empty workspace is visited, an aligned strip whose resident workspace still has tracked terminals remains rendered on that prior workspace; Niri keeps it off the empty workspace and returning brings the already-positioned strip back with its row. If its resident terminals disappear, the renderer is concealed and input-disabled. When an actual remap or floating correction is unavoidable, reveal waits beyond Niri's compositor movement animation and then re-verifies placement and membership. The broker remains global and non-Niri desktops retain the global card view.
+- **Ordering:** green `done` cards whose footer reads `monitoring` stay at the far left beside the Activity tile. Active tool/thinking/waiting cards follow, then other settled cards. The group order refreshes every 15 seconds rather than on every telemetry packet; text and timers still update live.
+- **Current terminal:** on Niri, the card matching the focused Ghostty window gets a stronger border and left rail without an extra label. Matching uses the same exact session-title identity seam as click-to-focus and fails closed when focus or identity is missing or ambiguous.
+- **Pointer:** hover expands the strip and reveals detail, last prompt, assistant preview, and path. Leaving the strip or activating another window collapses it immediately. Single click asks Niri to focus the one Ghostty title carrying that exact Pi session-id suffix.
+- **Keyboard inside the strip:** Left/Right changes card focus, Enter activates the focused card, and Shift+Left/Right manually moves it. Manual movement lasts until a later activity regroup or runtime restart.
+- **Fail-closed focus:** current telemetry uses the exact Pi identity directly. For already-running tabs that still publish a legacy broker id, the strip may recover only the process-bound `pi-session-presence` sidecar when its source, PID, and cwd all agree; this is not repo-name guessing or arbitrary-PID focusing. If identity still matches zero or multiple Ghostty windows, focus does nothing and asks for one `/reload`.
+
+### Keyboard-only entry on Niri
+
+The package deliberately does not reserve a global Electron shortcut. Bind one compositor key to the fail-closed CLI entrypoint instead:
+
+```kdl
+binds {
+    Mod+Shift+A { spawn "node" "/home/tryinget/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip/bin/pi-activity-strip.mjs" "focus-strip"; }
+}
+```
+
+`focus-strip` gives keyboard focus only to the unique strip already resident on the currently focused workspace; it never moves a strip between workspaces. When the focused workspace has no tracked live Pi terminals, the command fails closed rather than forcing an empty bar into view. This keeps shortcut ownership explicit in Niri and avoids application-level global-key collisions.
+
 ## Verification commands
 
 ### Package checks
@@ -179,8 +209,8 @@ Use `doctor` before opening the strip when the host/display assumptions are unce
 
 - `PI_ACTIVITY_STRIP_AUTO_START=0`
   - disable automatic strip opening on Pi session start
-- `PI_ACTIVITY_STRIP_CLICK_THROUGH=0`
-  - make the overlay clickable instead of mouse-transparent
+- `PI_ACTIVITY_STRIP_CLICK_THROUGH=1`
+  - opt out of interaction and restore a mouse-transparent overlay; interactive hover/click/keyboard behavior is the default
 - `PI_ACTIVITY_STRIP_ELECTRON_BIN=/path/to/electron`
   - override Electron binary discovery
 - `GLIMPSE_ELECTRON_BIN=/path/to/electron`
@@ -194,6 +224,7 @@ If you want this for all current tabs:
 2. run `/reload` inside each already-open Pi tab
 3. open the strip once with `/activity-strip` or `npm run strip:open`
 4. from then on, every loaded Pi session should report into the same top-row ribbon
+5. ensure `pi-little-helpers` session presence is loaded when you want exact click-to-Ghostty focus; its `· <full-32-hex-session-id-token>` title suffix is the preferred fail-closed identity seam (an 8-hex legacy title remains usable only when no legacy duplicate or migrated full title shares its prefix)
 
 ## References
 

package/bin/pi-activity-strip.mjs

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+// ---
+// summary: "command-line entrypoint for opening, inspecting, repairing, and stopping the activity strip runtime"
+// read_when:
+//   - "operating or diagnosing the activity strip from a terminal"
+// ---
+
 import { execFile, spawn } from "node:child_process";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
@@ -16,6 +22,7 @@ import {
 } from "../src/common/compatibility.mjs";
 import { ACTIVITY_STRIP_START_TIMEOUT_MS } from "../src/common/constants.mjs";
 import { locateElectron } from "../src/common/electron.mjs";
+import { focusNiriStrip, resolveActivityStripWindow } from "../src/common/niri-focus.mjs";
 import { makeMessage } from "../src/common/protocol.mjs";
 import { formatBrokerRuntimeStatus } from "../src/common/status-report.mjs";
 
@@ -26,7 +33,7 @@ const execFileAsync = promisify(execFile);
 
 function usage() {
   console.log(
-    `Usage: pi-activity-strip <open|status|doctor|snapshot|fix-top|stop|serve> [--json]\n\nCommands:\n  open      Start the top-row activity strip if it is not already running\n  status    Check broker + overlay readiness and surface runtime warnings\n  doctor    Inspect host compatibility assumptions before opening the strip\n  snapshot  Print the current broker snapshot as JSON\n  fix-top   Move the strip window flush to the top edge in Niri\n  stop      Ask the running strip to shut down\n  serve     Internal helper; starts the Electron shell in the foreground\n`,
+    `Usage: pi-activity-strip <open|focus-strip|focus-session|status|doctor|snapshot|fix-top|stop|serve> [options]\n\nCommands:\n  open              Start the interactive top-row activity strip (--click-through opts out)\n  focus-strip       Focus the visible strip already resident on the focused Niri workspace\n  focus-session ID  Focus the one Ghostty/Niri window matching an exact Pi session identity\n  status            Check broker + overlay readiness and surface runtime warnings\n  doctor            Inspect host compatibility assumptions before opening the strip\n  snapshot          Print the current broker snapshot as JSON\n  fix-top           Move the strip window flush to the top edge in Niri\n  stop              Ask the running strip to shut down\n  serve             Internal helper; starts the Electron shell in the foreground\n`,
   );
 }
 
@@ -39,12 +46,15 @@ async function moveStripToTop() {
     throw new Error("Unexpected niri windows payload");
   }
 
-  const stripWindow = windows.find((window) => window?.title === "Pi Activity Strip");
-  if (!stripWindow?.id) {
-    throw new Error("Could not find Pi Activity Strip window in niri");
+  const stripWindow = resolveActivityStripWindow(windows);
+  if (!stripWindow) {
+    throw new Error("Could not find one unique Pi Activity Strip window in niri");
   }
 
-  const currentY = Number(stripWindow.layout?.tile_pos_in_workspace_view?.[1] ?? 0);
+  const layout = /** @type {{ tile_pos_in_workspace_view?: unknown[] }} */ (
+    stripWindow.layout ?? {}
+  );
+  const currentY = Number(layout.tile_pos_in_workspace_view?.[1] ?? 0);
   if (Math.abs(currentY) < 1) {
     return 0;
   }
@@ -137,6 +147,9 @@ async function openStrip({ detached = true } = {}) {
 async function main() {
   const command = process.argv[2] ?? "open";
   const jsonOutput = process.argv.includes("--json");
+  if (process.argv.includes("--click-through")) {
+    process.env.PI_ACTIVITY_STRIP_CLICK_THROUGH = "1";
+  }
 
   switch (command) {
     case "open":
@@ -145,6 +158,43 @@ async function main() {
     case "serve":
       process.exitCode = await openStrip({ detached: false });
       return;
+    case "focus-strip": {
+      try {
+        const status = await getBrokerStatus({ expectReply: true });
+        if (status?.runtimeStatus?.windowVisible !== true) {
+          console.error("No visible strip exists on the focused workspace; focus did nothing.");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await focusNiriStrip(execFileAsync, process.env, status?.snapshot?.sessions);
+        if (!result.ok) console.error(result.error || "Strip focus did nothing.");
+        process.exitCode = result.ok ? 0 : 1;
+      } catch {
+        console.error("Activity strip is not running; focus did nothing.");
+        process.exitCode = 1;
+      }
+      return;
+    }
+    case "focus":
+    case "focus-session": {
+      const sessionId = String(process.argv[3] ?? "").trim();
+      if (!sessionId) {
+        console.error("focus-session requires the full Pi session id");
+        process.exitCode = 2;
+        return;
+      }
+      try {
+        const result = await sendBrokerMessage(makeMessage("focus", { sessionId }), {
+          expectReply: true,
+        });
+        if (!result?.ok) console.error(result?.error || "Focus did nothing.");
+        process.exitCode = result?.ok ? 0 : 1;
+      } catch {
+        console.error("Activity strip is not running; focus did nothing.");
+        process.exitCode = 1;
+      }
+      return;
+    }
     case "status": {
       try {
         const result = await getBrokerStatus({ expectReply: true });

package/examples/simulate-sessions.mjs

@@ -1,3 +1,8 @@
+/**
+summary: "Publishes a timed sequence of simulated activity-strip session snapshots, updates, and removals."
+read_when:
+  - "Changing the example session labels, lifecycle transitions, timing, or broker publication flow."
+*/
 import { setTimeout as delay } from "node:timers/promises";
 import { publishSessionSnapshot, removeSession } from "../src/client/broker-client.mjs";
 import { createInitialSnapshot } from "../src/common/telemetry.mjs";
@@ -60,5 +65,5 @@ await publishSessionSnapshot(sessions[1]);
 
 await delay(2000);
 for (const session of sessions) {
-  await removeSession(session.sessionId);
+  await removeSession({ sessionId: session.sessionId, publisherId: session.publisherId });
 }

package/extensions/activity-strip.js

@@ -1,3 +1,9 @@
+// ---
+// summary: "registers activity-strip commands and forwards Pi lifecycle telemetry to the local broker"
+// read_when:
+//   - "changing extension commands, autostart behavior, or telemetry event wiring"
+// ---
+
 import { execFile } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -188,8 +194,8 @@ export default function activityStripExtension(pi) {
     telemetry.onToolExecutionEnd(event);
   });
 
-  pi.on("turn_end", async () => {
-    telemetry.onTurnEnd();
+  pi.on("turn_end", async (event) => {
+    telemetry.onTurnEnd(event);
   });
 
   pi.on("agent_settled", async () => {

package/extensions/activity-strip.ts

@@ -1 +1,7 @@
+// ---
+// summary: "typed extension entrypoint that re-exports the JavaScript activity-strip implementation"
+// read_when:
+//   - "resolving the TypeScript-facing extension module boundary"
+// ---
+
 export { default } from "./activity-strip.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -35,9 +35,9 @@
     "quality:ci": "bash ./scripts/quality-gate.sh ci",
     "check": "npm run quality:ci",
     "test": "npm run quality:ci",
-    "docs:list": "bash ./scripts/docs-list.sh",
-    "docs:list:workspace": "bash ./scripts/docs-list.sh --workspace --discover",
-    "docs:list:json": "bash ./scripts/docs-list.sh --json",
+    "docs:list": "node ~/ai-society/core/agent-scripts/scripts/docs-list.mjs",
+    "docs:list:workspace": "node ~/ai-society/core/agent-scripts/scripts/docs-list.mjs --workspace --discover",
+    "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",
     "strip:open": "node ./bin/pi-activity-strip.mjs open",
@@ -76,15 +76,16 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
-    "@earendil-works/pi-ai": "^0.80.6",
-    "@earendil-works/pi-coding-agent": "^0.80.6",
+    "@earendil-works/pi-agent-core": "0.84.3",
+    "@earendil-works/pi-ai": "0.84.3",
+    "@earendil-works/pi-coding-agent": "0.84.3",
     "@types/node": "22.14.0",
     "@typescript/native-preview": "7.0.0-dev.20260417.1",
-    "typebox": "^1.0.0",
+    "typebox": "1.3.7",
     "typescript": "5.9.2"
   },
   "overrides": {
-    "fast-xml-parser": "5.3.6"
+    "fast-xml-parser": "5.7.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/src/broker/server.mjs

@@ -1,3 +1,9 @@
+// ---
+// summary: "hosts the Unix-socket broker that accepts session updates and broadcasts activity snapshots"
+// read_when:
+//   - "changing broker lifecycle, socket message handling, or snapshot emission"
+// ---
+
 import { EventEmitter } from "node:events";
 import fs from "node:fs";
 import net from "node:net";
@@ -41,19 +47,27 @@ export class ActivityStripBroker extends EventEmitter {
     this.socketDir = options.socketDir ?? ACTIVITY_STRIP_SOCKET_DIR;
     this.store = options.store ?? new SessionStore();
     this.getRuntimeStatus = options.getRuntimeStatus ?? (() => undefined);
+    this.focusSession =
+      options.focusSession ?? (async () => ({ ok: false, error: "Focus unavailable" }));
     this.server = net.createServer((socket) => this.handleConnection(socket));
     this.tick = null;
   }
 
   async start() {
-    fs.mkdirSync(this.socketDir, { recursive: true });
+    fs.mkdirSync(this.socketDir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(this.socketDir, 0o700);
     safeUnlink(this.socketPath);
 
     await new Promise((resolve, reject) => {
       this.server.once("error", reject);
       this.server.listen(this.socketPath, () => {
         this.server.off("error", reject);
-        resolve(undefined);
+        try {
+          fs.chmodSync(this.socketPath, 0o600);
+          resolve(undefined);
+        } catch (error) {
+          reject(error);
+        }
       });
     });
 
@@ -124,6 +138,13 @@ export class ActivityStripBroker extends EventEmitter {
           runtimeStatus: this.getRuntimeStatus(),
         });
         return;
+      case "focus":
+        Promise.resolve(this.focusSession(String(message.sessionId ?? "")))
+          .then((result) => this.reply(socket, { type: "focus", ...result }))
+          .catch(() =>
+            this.reply(socket, { ok: false, type: "focus", error: "Focus failed closed." }),
+          );
+        return;
       case "shutdown":
         this.reply(socket, { ok: true, type: "shutdown" });
         setTimeout(() => {
@@ -131,7 +152,7 @@ export class ActivityStripBroker extends EventEmitter {
         }, 20);
         return;
       case "remove":
-        this.store.remove(message.sessionId);
+        this.store.remove(String(message.sessionId ?? ""), String(message.publisherId ?? ""));
         this.emitSnapshot();
         return;
       case "upsert":

package/src/broker/session-store.mjs

@@ -1,3 +1,9 @@
+// ---
+// summary: "stores normalized session snapshots, expires stale entries, and returns display-ready ordering"
+// read_when:
+//   - "changing session retention, upsert semantics, or broker snapshot ordering"
+// ---
+
 import { ACTIVITY_STRIP_STALE_AFTER_MS } from "../common/constants.mjs";
 import { normalizeSessionSnapshot, sortSessions } from "../common/protocol.mjs";
 
@@ -5,6 +11,16 @@ import { normalizeSessionSnapshot, sortSessions } from "../common/protocol.mjs";
 /** @typedef {import("../common/contracts.ts").SessionStoreOptions} SessionStoreOptions */
 /** @typedef {import("../common/contracts.ts").BrokerSnapshot} BrokerSnapshot */
 
+/**
+ * Stable store key. Sessions resumed into a second process keep publishing under
+ * their own publisherId so two live processes never fight over one card; legacy
+ * publishers without a publisherId keep the bare sessionId key.
+ * @param {SessionSnapshot} session
+ */
+function sessionKey(session) {
+  return session.publisherId ? `${session.sessionId}|${session.publisherId}` : session.sessionId;
+}
+
 export class SessionStore {
   /** @param {SessionStoreOptions} [options] */
   constructor(options = {}) {
@@ -17,13 +33,17 @@ export class SessionStore {
   upsert(session) {
     const normalized = normalizeSessionSnapshot(session);
     if (!normalized.sessionId) return false;
-    this.sessions.set(normalized.sessionId, normalized);
+    this.sessions.set(sessionKey(normalized), normalized);
     return true;
   }
 
-  /** @param {string} sessionId */
-  remove(sessionId) {
-    return this.sessions.delete(String(sessionId ?? ""));
+  /** @param {string} sessionId @param {string} [publisherId] */
+  remove(sessionId, publisherId) {
+    const id = String(sessionId ?? "");
+    if (!id) return false;
+    return publisherId
+      ? this.sessions.delete(`${id}|${String(publisherId)}`)
+      : this.sessions.delete(id);
   }
 
   /** @param {number} [now] */

package/src/client/broker-client.mjs

@@ -1,3 +1,9 @@
+// ---
+// summary: "sends newline-delimited broker requests for status, shutdown, session publication, and removal"
+// read_when:
+//   - "changing client socket transport, reply timeouts, or broker request helpers"
+// ---
+
 import net from "node:net";
 /** @typedef {import("../common/contracts.ts").BrokerClientOptions} BrokerClientOptions */
 /** @typedef {import("../common/contracts.ts").BrokerResponse} BrokerResponse */
@@ -109,7 +115,21 @@ export async function publishSessionSnapshot(session, options = {}) {
   await sendBrokerMessage(makeMessage("upsert", { session }), options);
 }
 
-/** @param {string} sessionId @param {BrokerClientOptions} [options] */
-export async function removeSession(sessionId, options = {}) {
-  await sendBrokerMessage(makeMessage("remove", { sessionId }), options);
+/** @param {{ sessionId: string; publisherId: string }} session @param {BrokerClientOptions} [options] */
+export async function removeSession(session, options = {}) {
+  /** @type {Record<string, unknown>} */
+  let record = {};
+  let fallbackId = "";
+  if (session && typeof session === "object") {
+    record = session;
+  } else {
+    fallbackId = String(session ?? "");
+  }
+  await sendBrokerMessage(
+    makeMessage("remove", {
+      sessionId: String(record.sessionId ?? fallbackId),
+      publisherId: String(record.publisherId ?? ""),
+    }),
+    options,
+  );
 }

package/src/client/launcher.mjs

@@ -1,3 +1,9 @@
+// ---
+// summary: "ensures a compatible activity-strip process is launched and waits for overlay readiness"
+// read_when:
+//   - "changing autostart compatibility gates, process spawning, or readiness polling"
+// ---
+
 import { spawn } from "node:child_process";
 import { setTimeout as delay } from "node:timers/promises";
 import { assessActivityStripCompatibility } from "../common/compatibility.mjs";

package/src/client/session-telemetry.mjs

@@ -1,4 +1,11 @@
+// ---
+// summary: "converts Pi lifecycle and tool events into throttled session snapshots for the broker"
+// read_when:
+//   - "changing session state transitions, heartbeat delivery, or event-derived telemetry"
+// ---
+
 /** @typedef {import("../common/contracts.ts").SessionSnapshot} SessionSnapshot */
+/** @typedef {import("../common/contracts.ts").TurnEndEventLike} TurnEndEventLike */
 /** @typedef {import("../common/contracts.ts").SessionTelemetryOptions} SessionTelemetryOptions */
 /** @typedef {import("../common/contracts.ts").SessionStartContextLike} SessionStartContextLike */
 /** @typedef {import("../common/contracts.ts").BeforeAgentStartEventLike} BeforeAgentStartEventLike */
@@ -6,6 +13,7 @@
 /** @typedef {import("../common/contracts.ts").MessageUpdateEventLike} MessageUpdateEventLike */
 /** @typedef {import("../common/contracts.ts").ToolExecutionEventLike} ToolExecutionEventLike */
 import {
+  ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS,
   ACTIVITY_STRIP_HEARTBEAT_MS,
   ACTIVITY_STRIP_SEND_THROTTLE_MS,
 } from "../common/constants.mjs";
@@ -35,7 +43,14 @@ function extractAssistantDelta(event) {
 }
 
 /** @param {SessionTelemetryOptions} [options] */
-export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName = "" } = {}) {
+export function createSessionTelemetry({
+  pi,
+  cwd = process.cwd(),
+  sessionName = "",
+  transport,
+} = {}) {
+  const publish = transport?.publish ?? publishSessionSnapshot;
+  const removePublisher = transport?.remove ?? removeSession;
   /** @type {SessionSnapshot} */
   let snapshot = createInitialSnapshot({ cwd, sessionName });
   /** @type {NodeJS.Timeout | null} */
@@ -44,20 +59,52 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
   let flushTimer = null;
   let disposed = false;
   let pendingAssistant = "";
+  let lastStopReason = "";
+  let confirmedSignature = "";
+  let retryIndex = 0;
+
+  /** Signature of the display-relevant fields, used to detect lost transitions. */
+  function publishSignature() {
+    return [
+      snapshot.sessionId,
+      snapshot.state,
+      snapshot.phase,
+      snapshot.detail,
+      snapshot.agentActive,
+      snapshot.turnIndex,
+      snapshot.toolName,
+      snapshot.toolTarget,
+      snapshot.errorMessage,
+    ].join("\u001f");
+  }
 
   async function flush() {
     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.
     snapshot.updatedAt = now();
     snapshot.repoLabel = formatRepoLabel(
       snapshot.cwd,
       pi?.getSessionName?.() ?? snapshot.sessionName,
     );
     snapshot.sessionName = compactWhitespace(pi?.getSessionName?.() ?? snapshot.sessionName);
+    const signature = publishSignature();
     try {
-      await publishSessionSnapshot(snapshot);
+      await publish(snapshot);
+      confirmedSignature = signature;
+      retryIndex = 0;
     } catch {
-      // Broker is optional at runtime; silent failure keeps pi stable.
+      // 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 (
+        signature !== confirmedSignature &&
+        retryIndex < ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS.length
+      ) {
+        scheduleFlush(ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS[retryIndex]);
+        retryIndex += 1;
+      }
     }
   }
 
@@ -89,6 +136,7 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
       ...snapshot,
       ...partial,
       updatedAt: now(),
+      lastEventAt: now(),
     };
     scheduleFlush();
   }
@@ -99,10 +147,13 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
     },
     /** @param {SessionStartContextLike} ctx */
     async onSessionStart(ctx) {
+      const exactSessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "").trim();
+      const nextCwd = ctx?.cwd ?? snapshot.cwd;
       update({
-        cwd: ctx?.cwd ?? snapshot.cwd,
+        ...(exactSessionId ? { sessionId: exactSessionId } : {}),
+        cwd: nextCwd,
         sessionName: pi?.getSessionName?.() ?? snapshot.sessionName,
-        detail: previewPath(ctx?.cwd ?? snapshot.cwd, 72) || "Ready",
+        detail: previewPath(nextCwd, 72) || "Ready",
       });
       startHeartbeat();
       await flush();
@@ -176,8 +227,32 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
         toolName,
       });
     },
-    onTurnEnd() {
+    /** @param {TurnEndEventLike} event */
+    onTurnEnd(event) {
       if (!snapshot.agentActive) return;
+      const rawMessage = event?.message;
+      const message =
+        rawMessage && typeof rawMessage === "object"
+          ? /** @type {Record<string, unknown>} */ (rawMessage)
+          : null;
+      const stopReason = String(message?.stopReason ?? "");
+      if (stopReason) lastStopReason = stopReason;
+      if (stopReason === "error") {
+        const errorText = previewText(message?.errorMessage, 104) || "Provider error";
+        update({
+          state: "error",
+          phase: "Needs attention",
+          detail: errorText,
+          errorMessage: errorText,
+        });
+        return;
+      }
+      if (stopReason === "aborted") {
+        update({
+          detail: snapshot.assistantPreview || snapshot.detail || "Stopped",
+        });
+        return;
+      }
       update({
         state: snapshot.errorMessage ? "error" : "thinking",
         phase: snapshot.errorMessage ? "Needs attention" : "Thinking",
@@ -187,11 +262,12 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
     onAgentSettled() {
       const detail =
         snapshot.errorMessage || snapshot.assistantPreview || snapshot.lastPromptPreview || "Done";
+      const aborted = !snapshot.errorMessage && lastStopReason === "aborted";
       update({
         agentActive: false,
         agentStartedAt: null,
         state: snapshot.errorMessage ? "error" : "success",
-        phase: snapshot.errorMessage ? "Stopped" : "Done",
+        phase: snapshot.errorMessage ? "Stopped" : aborted ? "Stopped" : "Done",
         detail,
         toolName: "",
         toolTarget: "",
@@ -205,7 +281,10 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
         flushTimer = null;
       }
       try {
-        await removeSession(snapshot.sessionId);
+        await removePublisher({
+          sessionId: snapshot.sessionId,
+          publisherId: snapshot.publisherId,
+        });
       } catch {
         // ignore broker absence on shutdown
       }