@hienlh/ppm 0.23.8 → 0.23.10

package/src/services/subagent-transcript-merger.ts

@@ -15,11 +15,11 @@
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import type { ChatEvent } from "../types/chat.ts";
 import { parseSessionMessage } from "./jsonl-transcript-parser.ts";
 import { groupSubagentsByCard } from "./team-member-activity/subagent-transcript-index.ts";
+import { claudeProjectsRoot } from "./agent-transcript/claude-projects-root.ts";
 
 /**
  * Locate the per-session directory (…/projects/<slug>/<sessionId>) that holds
@@ -29,8 +29,7 @@ import { groupSubagentsByCard } from "./team-member-activity/subagent-transcript
  * the session's main JSONL.
  */
 export function resolveSessionDir(sessionId: string, projectPath: string | null | undefined): string | null {
-  const home = homedir();
-  const projectsRoot = join(home, ".claude", "projects");
+  const projectsRoot = claudeProjectsRoot();
   if (projectPath) {
     const encoded = projectPath.replace(/[/\\:.]/g, "-");
     const dir = join(projectsRoot, encoded);
@@ -67,16 +66,28 @@ export interface TimedChatEvent {
  * Incremental parser for one agent transcript. Feed it JSONL lines in file
  * order (whole file at once, or a live tail's new lines) and it returns the
  * child events those lines carry, keeping the skip/limit state across calls.
+ *
+ * `midFile: true` disables the first-user-record skip: a subscriber resuming
+ * a session hub mid-file (e.g. a SendMessage resume prompt lands well after the
+ * spawn prompt) must see every user record it is fed, not just the ones after
+ * the file's first — there is no "first" from where it joined.
+ *
+ * `maxEvents` overrides the default history-payload guard (`MAX_CHILDREN_PER_AGENT`).
+ * A live session-window subscription reads one file per subscriber rather than
+ * one payload for a whole reload, and the client already bounds its own render
+ * buffer — so the hub passes `Infinity` here rather than silently freezing a
+ * long-running teammate's stream once the reload guard's count is reached.
  */
-export function createAgentTranscriptLineParser() {
-  let isFirstUser = true;
+export function createAgentTranscriptLineParser(opts?: { midFile?: boolean; maxEvents?: number }) {
+  let isFirstUser = !opts?.midFile;
+  const maxEvents = opts?.maxEvents ?? MAX_CHILDREN_PER_AGENT;
   let emitted = 0;
   let lastTs = 0;
   return {
     feed(line: string): TimedChatEvent[] {
       const out: TimedChatEvent[] = [];
       const trimmed = line.trim();
-      if (!trimmed || emitted >= MAX_CHILDREN_PER_AGENT) return out;
+      if (!trimmed || emitted >= maxEvents) return out;
       let entry: any;
       try {
         entry = JSON.parse(trimmed);
@@ -98,7 +109,7 @@ export function createAgentTranscriptLineParser() {
       if (!Number.isNaN(parsedTs)) lastTs = parsedTs;
       const parsed = parseSessionMessage(entry);
       for (const ev of parsed.events ?? []) {
-        if (emitted >= MAX_CHILDREN_PER_AGENT) break;
+        if (emitted >= maxEvents) break;
         // Keep single events from ballooning the history payload (agent files
         // can carry multi-MB tool outputs the live stream also showed in full,
         // but 24 agents × full outputs breaks mobile reloads).
@@ -151,6 +162,9 @@ export function mergeSubagentChildren(sessionDir: string, messages: MessageLike[
       if (ev.type !== "tool_use" || (ev.tool !== "Agent" && ev.tool !== "Task") || !ev.toolUseId) continue;
       const group = groups.get(ev.toolUseId);
       if (!group) continue;
+      // A group was found on disk regardless of what it parsed to — the client can slim this
+      // card's children because a session window can always stream the rest from here.
+      (ev as { transcriptAvailable?: boolean }).transcriptAvailable = true;
       const timed: TimedChatEvent[] = [];
       for (const agent of group) timed.push(...parseAgentTranscriptTimed(agent.transcriptPath));
       // Stable sort: same-timestamp events keep transcript order.

package/src/shared/agent-transcript-protocol.ts

@@ -0,0 +1,158 @@
+/**
+ * Wire protocol for the Agent card session window, carried entirely over
+ * `/ws/global`. One hub per `(providerId, sessionId)` on the server streams a
+ * card's (or teammate's) transcript from disk, from whatever byte offset the
+ * client already has, and keeps pushing new steps live as they are written.
+ *
+ * Contract the server holds to (see `agent-transcript-hub.ts`):
+ * - The client never names a file or a byte range directly — only a `source`
+ *   (a card id or a teammate handle) the server resolves itself, and a
+ *   `cursor` of offsets keyed by file keys the server handed out earlier.
+ *   Offsets for keys the server never derived are ignored; a stale offset
+ *   past the current file size is clamped down rather than rejected.
+ * - Every error the client can see is one of the four codes below — never an
+ *   exception message, a path, or a code from an internal module.
+ */
+import type { ChatEvent } from "../types/chat.ts";
+
+export type AgentTranscriptProviderId = "claude" | "codex";
+
+export type AgentTranscriptSourceKind =
+  | { kind: "card"; cardId: string }
+  | { kind: "member"; teamName: string; memberName: string };
+
+/** Byte offset already consumed, per file key the server previously derived. */
+export interface AgentTranscriptCursor {
+  [fileKey: string]: number;
+}
+
+/**
+ * One step on the wire. `k` is a stable de-dupe key, normally
+ * `"<fileKey>:<byteOffset>:<i>"` where `byteOffset` is a file position before
+ * the read that produced it, so a page re-sent after a dropped connection
+ * carries the same keys as before. `replace: true` (Codex only) means the
+ * client should update the step already shown for this `ev`'s `toolUseId` in
+ * place, not append a new one — the usual case is a tool_result answering an
+ * earlier tool_use. A `replace` envelope's `k` is the ORIGINAL key issued for
+ * that `toolUseId`, reused rather than freshly minted, precisely so a
+ * same-`k` upsert on the client has something to match.
+ */
+export interface AgentTranscriptEnvelope {
+  ev: ChatEvent;
+  ts: number;
+  k: string;
+  replace?: true;
+}
+
+export type AgentTranscriptErrorCode = "not_found" | "forbidden" | "limit" | "bad_request";
+
+/** One entry of the running-agents bar. Exactly one of `cardId`/`memberName` is set. */
+export interface AgentTranscriptRunningEntry {
+  cardId?: string;
+  memberName?: string;
+  /** Epoch ms the underlying transcript file was last written. */
+  lastWriteAt: number;
+  /** Short label for the agent's most recent step, when one could be read cheaply. */
+  lastStep?: string;
+}
+
+// ---- Client → server ----
+
+export interface AgentTranscriptSubscribeMsg {
+  type: "agent-transcript:subscribe";
+  subId: string;
+  projectName: string;
+  providerId: AgentTranscriptProviderId;
+  sessionId: string;
+  source: AgentTranscriptSourceKind;
+  cursor?: AgentTranscriptCursor;
+}
+
+export interface AgentTranscriptUnsubscribeMsg {
+  type: "agent-transcript:unsubscribe";
+  subId: string;
+}
+
+export interface AgentActivitySubscribeMsg {
+  type: "agent-activity:subscribe";
+  subId: string;
+  projectName: string;
+  providerId: AgentTranscriptProviderId;
+  sessionId: string;
+}
+
+export interface AgentActivityUnsubscribeMsg {
+  type: "agent-activity:unsubscribe";
+  subId: string;
+}
+
+export interface PingMsg {
+  type: "ping";
+}
+
+export type AgentTranscriptClientMsg =
+  | AgentTranscriptSubscribeMsg
+  | AgentTranscriptUnsubscribeMsg
+  | AgentActivitySubscribeMsg
+  | AgentActivityUnsubscribeMsg
+  | PingMsg;
+
+// ---- Server → client ----
+
+export interface AgentTranscriptEventsMsg {
+  type: "agent-transcript:events";
+  subId: string;
+  events: AgentTranscriptEnvelope[];
+  /** Current per-file consumed offsets for this subscription — the next `cursor` to resume from. */
+  cursor: AgentTranscriptCursor;
+  /** More pages are coming right behind this one (a backlog being drained on subscribe). */
+  more?: true;
+  /**
+   * The client must discard everything it has for this subscription and
+   * replace it with `events` — a truncated/rotated Claude transcript file, or
+   * a Codex compaction/rollback record, rewrote history rather than appending
+   * to it. Set only on the first page of the replacement; later pages of the
+   * same catch-up carry `more` instead.
+   */
+  reset?: true;
+  /** The source resolved to at least one readable file (as opposed to the error path). */
+  available: boolean;
+  /** Whether the underlying agent still looks active (see hub's idle heuristic). */
+  running: boolean;
+}
+
+export interface AgentTranscriptErrorMsg {
+  type: "agent-transcript:error";
+  subId: string;
+  code: AgentTranscriptErrorCode;
+}
+
+export interface AgentActivityMsg {
+  type: "agent-activity";
+  subId: string;
+  running: AgentTranscriptRunningEntry[];
+}
+
+export interface PongMsg {
+  type: "pong";
+}
+
+export type AgentTranscriptServerMsg =
+  | AgentTranscriptEventsMsg
+  | AgentTranscriptErrorMsg
+  | AgentActivityMsg
+  | PongMsg;
+
+// ---- Tuning constants, shared so client and server agree ----
+
+export const MAX_TRANSCRIPT_SUBS_PER_CLIENT = 8;
+export const MAX_TRANSCRIPT_SUBS_PER_SERVER = 64;
+export const CATCH_UP_MAX_BYTES = 512 * 1024;
+export const CATCH_UP_MAX_EVENTS = 500;
+export const TOOL_OUTPUT_MAX_CHARS = 20_000;
+export const LIVE_TICK_MS = 250;
+export const IDLE_TICK_MS = 2_000;
+export const IDLE_AFTER_MS = 30_000;
+export const ACTIVITY_TICK_MS = 3_000;
+export const ACTIVITY_WINDOW_MS = 90_000;
+export const INDEX_REFRESH_MS = 2_000;

package/src/types/chat.ts

@@ -243,15 +243,39 @@ export type ResultSubtype =
   | "error_auth";
 
 export type ChatEvent =
-  | { type: "text"; content: string; parentToolUseId?: string }
-  | { type: "thinking"; content: string; parentToolUseId?: string }
+  | { type: "text"; content: string; parentToolUseId?: string; arrivalSeq?: number }
+  | { type: "thinking"; content: string; parentToolUseId?: string; arrivalSeq?: number }
   | {
       type: "tool_use"; tool: string; input: unknown; toolUseId?: string; parentToolUseId?: string; children?: ChatEvent[];
       /** Terminal state of a backgrounded Agent/Task, once its `<task-notification>` arrives.
        *  Absent on a launched-but-unfinished agent — the card renders that as still running. */
       bgStatus?: import("../shared/background-agent-status").BackgroundAgentStatus;
+      /** Agent/Task only: distinct child tool_use ids counted as "steps" so far — a Set-like
+       *  array kept stable under a WS replay redelivering the same id. */
+      stepIds?: string[];
+      /** stepIds.length, cached alongside it so the one-line card need not measure the array. */
+      stepCount?: number;
+      /** Plain-text description of the most recent step, for the one-line card. */
+      lastStep?: string;
+      /** Set by a provider when an on-disk transcript was found for this card — its `children`
+       *  are safe to reduce to the slimmed set because a session window can stream the rest
+       *  from disk instead. Never set by the live stream itself. */
+      transcriptAvailable?: boolean;
+      /** Bounded ring buffer (last 200, or ~256KB serialized) of child events slimming would
+       *  otherwise drop — the fallback shown in a window when no on-disk transcript exists at
+       *  all, merged back with `children` in original arrival order via each entry's
+       *  `arrivalSeq`. */
+      recentChildren?: ChatEvent[];
+      /** Monotonic counter this Agent/Task card's own `applyChildToParent` routing bumps once
+       *  per incoming child — the source of `arrivalSeq` stamped onto each routed child. */
+      childSeq?: number;
+      /** Position among this child's siblings in the order they actually arrived — set when a
+       *  child is routed by `applyChildToParent`/`pushRecentChild` with a parent's `childSeq`,
+       *  so `children` and `recentChildren` (split apart by kept-vs-ring-buffer routing) can be
+       *  merged back into arrival order instead of concatenated. */
+      arrivalSeq?: number;
     }
-  | { type: "tool_result"; output: string; isError?: boolean; exitCode?: number; toolUseId?: string; parentToolUseId?: string }
+  | { type: "tool_result"; output: string; isError?: boolean; exitCode?: number; toolUseId?: string; parentToolUseId?: string; arrivalSeq?: number }
   | { type: "approval_request"; requestId: string; tool: string; input: unknown }
   | { type: "error"; message: string }
   | { type: "done"; sessionId: string; resultSubtype?: ResultSubtype; numTurns?: number; contextWindowPct?: number; costUsd?: number; lastMessageUuid?: string; usage?: import("../shared/turn-usage").TurnUsage }

package/src/web/app.tsx

@@ -54,8 +54,8 @@ import { OnboardingRoot } from "@/components/onboarding/onboarding-root";
 const MobileExplorerSheet = lazy(() =>
   import("@/components/os-explorer/mobile/mobile-explorer-sheet").then((m) => ({ default: m.MobileExplorerSheet })),
 );
-const TeamMemberSheet = lazy(() =>
-  import("@/components/chat/team-member-sheet").then((m) => ({ default: m.TeamMemberSheet })),
+const AgentSessionSheet = lazy(() =>
+  import("@/components/chat/agent-session-sheet").then((m) => ({ default: m.AgentSessionSheet })),
 );
 const RemoteDesktopMobileSheet = lazy(() =>
   import("@/components/remote-desktop/remote-desktop-mobile-sheet").then((m) => ({ default: m.RemoteDesktopMobileSheet })),
@@ -390,12 +390,12 @@ export function App() {
           <MobileExplorerSheet />
         </Suspense>
 
-        {/* Mobile stand-in for the team-member window, which WindowLayer never renders below md */}
+        {/* Mobile stand-in for the agent-session window, which WindowLayer never renders below md */}
         <Suspense fallback={null}>
-          <TeamMemberSheet />
+          <AgentSessionSheet />
         </Suspense>
 
-        {/* Mobile full-screen remote-desktop viewer — same reason as TeamMemberSheet above */}
+        {/* Mobile full-screen remote-desktop viewer — same reason as AgentSessionSheet above */}
         <Suspense fallback={null}>
           <RemoteDesktopMobileSheet />
         </Suspense>

package/src/web/components/chat/agent-card-summary.tsx

@@ -0,0 +1,73 @@
+/**
+ * The Agent/Task card's one-line row in chat: description (or teammate handle),
+ * step count, current step, status icon, and a tap that opens the live session
+ * window/sheet — no inline expansion, no long-press menu, tap only.
+ *
+ * `usePrefersCoarsePointer` (not `useIsMobile`) is what gates the 44 px minimum:
+ * a touch-capable desktop/tablet needs the bigger target just as much as a
+ * phone, and a mouse on a narrow desktop pane does not.
+ */
+import { Bot, ChevronRight, Loader2, CheckCircle2, XCircle, Users } from "@/lib/icons";
+import { cn } from "@/lib/utils";
+import { usePrefersCoarsePointer } from "@/components/os-explorer/use-coarse-long-press";
+import { formatStepCount } from "@/lib/agent-step-summary";
+
+export type AgentCardStatus = "running" | "done" | "error";
+
+export interface AgentCardSummaryProps {
+  /** Teammate handle, when the card is addressable via SendMessage — leads the row. */
+  handle: string | null;
+  /** input.description/prompt, shown when there is no handle. */
+  description: string;
+  stepCount: number;
+  lastStep?: string;
+  status: AgentCardStatus;
+  /** Mirrors the pre-existing "running…" chip for a launched-but-unconfirmed background agent —
+   *  distinct from `status === "running"`, which also covers an ordinary still-executing call. */
+  bgRunning?: boolean;
+  onOpen: () => void;
+}
+
+export function AgentCardSummary({
+  handle, description, stepCount, lastStep, status, bgRunning, onOpen,
+}: AgentCardSummaryProps) {
+  const coarse = usePrefersCoarsePointer();
+  const StatusIcon = status === "error" ? XCircle : status === "done" ? CheckCircle2 : Loader2;
+  const statusCls = status === "error" ? "text-error" : status === "done" ? "text-success" : "text-primary animate-spin";
+
+  return (
+    <button
+      type="button"
+      onClick={onOpen}
+      className={cn(
+        "flex w-full items-center gap-2.5 rounded-[11px] border border-border bg-panel px-2.5 text-left text-xs",
+        "transition-colors hover:bg-panel-2/40",
+        coarse ? "min-h-[44px] py-2" : "py-2",
+      )}
+      title={handle ? `Open ${handle}'s session` : "Open agent session"}
+    >
+      <span className={cn(
+        "inline-flex items-center justify-center size-6 rounded-[7px] shrink-0",
+        handle ? "bg-accent-2/15 text-accent-2" : "bg-accent-wash text-primary",
+      )}>
+        {handle ? <Users className="size-3.5" /> : <Bot className="size-3.5" />}
+      </span>
+
+      <span className="min-w-0 flex-1 truncate">
+        {handle
+          ? <span className="font-medium text-text-primary">{handle}</span>
+          : <span className="font-medium text-text">{description || "Agent"}</span>}
+        {!!lastStep && (
+          <span className="text-text-subtle"> · {lastStep}</span>
+        )}
+      </span>
+
+      <span className="ml-auto flex items-center gap-2 shrink-0 text-text-3">
+        {bgRunning && <span className="text-[10px] text-primary">running…</span>}
+        {stepCount > 0 && <span className="font-mono text-[10px]">{formatStepCount(stepCount)}</span>}
+        <StatusIcon className={cn("size-3.5", statusCls)} />
+        <ChevronRight className="size-3" />
+      </span>
+    </button>
+  );
+}

package/src/web/components/chat/agent-session-context.ts

@@ -0,0 +1,34 @@
+/**
+ * Which session an Agent/Task card's one-line summary belongs to.
+ *
+ * `ToolCard`/`AgentCardSummary` need `{projectName, providerId, sessionId}` to
+ * build the `openAgentSession` payload, but a card has no such identity of its
+ * own — it only ever knows its `toolUseId`. `chat-tab.tsx` provides this once
+ * per conversation; a read-only surface with no real session (the group-chat
+ * transcript viewer) provides none, and the consumer falls back to a synthetic,
+ * never-resolvable identity so the card still opens in memory-only mode instead
+ * of doing nothing on tap.
+ */
+import { createContext, createElement, useContext, type ReactNode } from "react";
+import type { AgentTranscriptProviderId } from "../../../shared/agent-transcript-protocol";
+
+export interface AgentSessionIdentity {
+  projectName: string;
+  providerId: AgentTranscriptProviderId;
+  sessionId: string;
+}
+
+/** Claude and Codex are the only hubs that exist — anything else falls back to Claude. */
+export function normalizeProviderId(id: string | undefined | null): AgentTranscriptProviderId {
+  return id === "codex" ? "codex" : "claude";
+}
+
+const AgentSessionContext = createContext<AgentSessionIdentity | null>(null);
+
+export function useAgentSessionContext(): AgentSessionIdentity | null {
+  return useContext(AgentSessionContext);
+}
+
+export function AgentSessionProvider({ value, children }: { value: AgentSessionIdentity; children: ReactNode }) {
+  return createElement(AgentSessionContext.Provider, { value }, children);
+}

package/src/web/components/chat/agent-session-fallback-store.ts

@@ -0,0 +1,60 @@
+/**
+ * Steps already held in chat memory, shown until (or unless) a window/sheet's live hub
+ * subscription takes over — seeded by the opener, since the window itself never had the
+ * chat's in-memory `children` array to fall back to.
+ *
+ * Pruned reactively rather than left to grow: every close/focus/open on the window store or
+ * the mobile sheet re-derives which keys are still on screen and drops the rest, so a
+ * session opened once and closed does not keep its whole event buffer alive for the rest of
+ * the page's life.
+ */
+import { create } from "zustand";
+import { useWindowStore } from "@/components/floating-window/window-store";
+import { useAgentSessionSheetStore } from "./agent-session-sheet-store";
+import type { AgentTranscriptSourceKind } from "../../../shared/agent-transcript-protocol";
+import type { ChatEvent } from "../../../types/chat";
+
+export function fallbackKey(sessionId: string, source: AgentTranscriptSourceKind): string {
+  return source.kind === "card"
+    ? `${sessionId}:${source.cardId}`
+    : `${sessionId}:${source.teamName}:${source.memberName}`;
+}
+
+interface FallbackStoreState {
+  entries: Record<string, ChatEvent[]>;
+}
+
+export const useAgentSessionFallbackStore = create<FallbackStoreState>(() => ({ entries: {} }));
+
+/** Called by the opener right before it opens a window/sheet for this key. */
+export function setFallbackEvents(key: string, events: ChatEvent[]): void {
+  useAgentSessionFallbackStore.setState((s) => ({ entries: { ...s.entries, [key]: events } }));
+}
+
+function activeKeys(): Set<string> {
+  const keys = new Set<string>();
+  for (const win of Object.values(useWindowStore.getState().windows)) {
+    if (win.kind !== "agent-session") continue;
+    const p = win.payload as { sessionId?: unknown; source?: AgentTranscriptSourceKind } | undefined;
+    if (typeof p?.sessionId === "string" && p.source) keys.add(fallbackKey(p.sessionId, p.source));
+  }
+  const sheetPayload = useAgentSessionSheetStore.getState().payload;
+  if (sheetPayload) keys.add(fallbackKey(sheetPayload.sessionId, sheetPayload.source));
+  return keys;
+}
+
+function prune(): void {
+  const keep = activeKeys();
+  useAgentSessionFallbackStore.setState((s) => {
+    const entries: Record<string, ChatEvent[]> = {};
+    let changed = false;
+    for (const [key, events] of Object.entries(s.entries)) {
+      if (keep.has(key)) entries[key] = events;
+      else changed = true;
+    }
+    return changed ? { entries } : s;
+  });
+}
+
+useWindowStore.subscribe(prune);
+useAgentSessionSheetStore.subscribe(prune);

package/src/web/components/chat/agent-session-sheet-store.ts

@@ -0,0 +1,23 @@
+/**
+ * Mobile-only: which agent/teammate session the full-screen sheet is showing, if any.
+ *
+ * Kept separate from `use-open-agent-session.ts` (unlike the old `team-member` stack, which
+ * had it inline) so `agent-session-fallback-store.ts` can read this store to decide what is
+ * still on screen without importing the opener — the opener already imports the fallback
+ * store to seed it on open, and a two-way import between them would make the eval order of
+ * two zustand `create()` calls load-bearing.
+ */
+import { create } from "zustand";
+import type { AgentSessionWindowPayload } from "./agent-session-window-content";
+
+interface AgentSessionSheetState {
+  payload: AgentSessionWindowPayload | null;
+  open: (payload: AgentSessionWindowPayload) => void;
+  close: () => void;
+}
+
+export const useAgentSessionSheetStore = create<AgentSessionSheetState>((set) => ({
+  payload: null,
+  open: (payload) => set({ payload }),
+  close: () => set({ payload: null }),
+}));

package/src/web/components/chat/{team-member-sheet.tsx → agent-session-sheet.tsx}

@@ -1,28 +1,28 @@
 /**
- * Full-screen mobile presentation of a teammate's work session.
+ * Full-screen mobile presentation of an agent's or teammate's work session.
  *
- * Hosts the same content component the desktop floating window uses, so the steps,
- * refresh and error states are shared code rather than a parallel mobile build.
- * Self-gated singleton, mounted once at the app root beside the other overlays.
+ * Hosts the same content component the desktop floating window uses, so steps, prompt and
+ * status are shared code rather than a parallel mobile build. Self-gated singleton, mounted
+ * once at the app root beside the other overlays.
  */
 
 import { lazy, Suspense } from "react";
 import { X } from "@/lib/icons";
 import { BottomSheet } from "@/components/ui/mobile-bottom-sheet";
-import { useTeamMemberSheet } from "./use-open-team-member";
+import { useAgentSessionSheetStore } from "./agent-session-sheet-store";
 
-const TeamMemberWindowContent = lazy(() => import("./team-member-window-content"));
+const AgentSessionWindowContent = lazy(() => import("./agent-session-window-content"));
 
-export function TeamMemberSheet() {
-  const payload = useTeamMemberSheet((s) => s.payload);
-  const close = useTeamMemberSheet((s) => s.close);
+export function AgentSessionSheet() {
+  const payload = useAgentSessionSheetStore((s) => s.payload);
+  const close = useAgentSessionSheetStore((s) => s.close);
   if (!payload) return null;
 
   return (
     <BottomSheet open onClose={close} zIndex={45} className="flex h-[var(--sheet-vh)] flex-col p-0">
       <div className="flex items-center gap-2 border-b border-border px-3 py-2 shrink-0">
         <span className="truncate text-sm font-medium text-text-primary">
-          Session — {payload.memberName}
+          {payload.title ?? "Agent session"}
         </span>
         <button
           type="button"
@@ -36,8 +36,8 @@ export function TeamMemberSheet() {
       <div className="min-h-0 flex-1 overflow-auto">
         <Suspense fallback={<div className="p-4 text-sm text-text-2">Loading…</div>}>
           {/* No floating window backs this sheet, so the id is only an identity for the content. */}
-          <TeamMemberWindowContent
-            id={`sheet-${payload.memberName}`}
+          <AgentSessionWindowContent
+            id={`sheet-${payload.sessionId}`}
             payload={payload as unknown as Record<string, unknown>}
           />
         </Suspense>