@hienlh/ppm 0.9.9 → 0.9.11

package/src/server/routes/teams.ts

@@ -0,0 +1,40 @@
+import { Hono } from "hono";
+import { ok, err } from "../../types/api.ts";
+import { listTeams, readTeamDetail } from "../ws/team-inbox-watcher.ts";
+import { join } from "path";
+import { homedir } from "os";
+import { rm } from "fs/promises";
+
+/** Allowlist: team names must be alphanumeric with hyphens/underscores only */
+const VALID_TEAM_NAME = /^[a-zA-Z0-9_-]+$/;
+
+export const teamRoutes = new Hono();
+
+teamRoutes.get("/", async (c) => {
+  const teams = await listTeams();
+  return c.json(ok(teams));
+});
+
+teamRoutes.get("/:name", async (c) => {
+  const name = c.req.param("name");
+  if (!VALID_TEAM_NAME.test(name)) {
+    return c.json(err("Invalid team name"), 400);
+  }
+  const detail = await readTeamDetail(name);
+  if (!detail) return c.json(err("Team not found"), 404);
+  return c.json(ok(detail));
+});
+
+teamRoutes.delete("/:name", async (c) => {
+  const name = c.req.param("name");
+  if (!VALID_TEAM_NAME.test(name)) {
+    return c.json(err("Invalid team name"), 400);
+  }
+  const teamDir = join(homedir(), ".claude", "teams", name);
+  try {
+    await rm(teamDir, { recursive: true, force: true });
+    return c.json(ok({ deleted: name }));
+  } catch (e) {
+    return c.json(err(`Failed to delete: ${(e as Error).message}`), 500);
+  }
+});

package/src/server/ws/chat.ts

@@ -12,6 +12,7 @@ const MAX_TURN_EVENTS = 10_000; // memory safety cap
 const BUFFERABLE_TYPES = new Set([
   "text", "thinking", "tool_use", "tool_result",
   "approval_request", "error", "done", "account_info", "account_retry",
+  "team_detected",
 ]);
 
 type ChatWsSocket = {
@@ -34,6 +35,12 @@ interface SessionEntry {
   permissionMode?: string;
   /** Whether the persistent event consumer loop is running */
   isStreamingActive: boolean;
+  /** Active team watchers keyed by team name */
+  teamWatchers: Map<string, { cleanup: () => void }>;
+  /** Set of detected team names for this session */
+  teamNames: Set<string>;
+  /** toolUseId of a pending TeamCreate call */
+  pendingTeamCreate?: string;
 }
 
 /** Tracks active sessions — persists even when FE disconnects */
@@ -133,6 +140,8 @@ function startCleanupTimer(sessionId: string): void {
     logSessionEvent(sessionId, "INFO", "Session cleaned up (idle, no FE reconnected)");
     for (const interval of entry.pingIntervals.values()) clearInterval(interval);
     entry.pingIntervals.clear();
+    for (const w of entry.teamWatchers.values()) w.cleanup();
+    entry.teamWatchers.clear();
     activeSessions.delete(sessionId);
   }, CLEANUP_TIMEOUT_MS);
 }
@@ -254,8 +263,35 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         logSessionEvent(sessionId, "TEXT", ev.content?.slice(0, 500) ?? "");
       } else if (evType === "tool_use") {
         logSessionEvent(sessionId, "TOOL_USE", `${ev.tool} ${JSON.stringify(ev.input).slice(0, 300)}`);
+        // Track TeamCreate calls for team detection
+        if (ev.tool === "TeamCreate") {
+          entry.pendingTeamCreate = ev.toolUseId;
+          console.log(`[chat] session=${sessionId} TeamCreate tool_use detected, toolUseId=${ev.toolUseId}`);
+        }
       } else if (evType === "tool_result") {
         logSessionEvent(sessionId, "TOOL_RESULT", `error=${ev.isError ?? false} ${(ev.output ?? "").slice(0, 300)}`);
+        console.log(`[chat] session=${sessionId} tool_result: toolUseId=${ev.toolUseId} pendingTeamCreate=${entry.pendingTeamCreate} output=${(ev.output ?? "").slice(0, 200)}`);
+        // Detect team creation from TeamCreate tool_result
+        if (entry.pendingTeamCreate && entry.pendingTeamCreate === ev.toolUseId) {
+          const { extractTeamName, startTeamInboxWatcher } = await import("./team-inbox-watcher.ts");
+          const teamName = extractTeamName(ev.output ?? "");
+          console.log(`[chat] session=${sessionId} TeamCreate result matched, extracted teamName=${teamName}`);
+          if (teamName && !entry.teamNames.has(teamName)) {
+            entry.teamNames.add(teamName);
+            const watcher = startTeamInboxWatcher(teamName, {
+              onInboxUpdate: (tn, agent, msgs) => broadcast(sessionId, {
+                type: "team_inbox", teamName: tn, agent, messages: msgs,
+              }),
+              onConfigUpdate: (tn, config) => broadcast(sessionId, {
+                type: "team_updated", teamName: tn, team: config,
+              }),
+            });
+            entry.teamWatchers.set(teamName, watcher);
+            bufferAndBroadcast(sessionId, { type: "team_detected", teamName });
+            console.log(`[chat] session=${sessionId} team detected: ${teamName}`);
+          }
+          entry.pendingTeamCreate = undefined;
+        }
       } else if (evType === "error") {
         const errorDetail = ev.message ?? JSON.stringify(ev).slice(0, 500);
         console.error(`[chat] session=${sessionId} error: ${errorDetail}`);
@@ -333,6 +369,9 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
     entry.turnEvents = [];
     setPhase(sessionId, "idle");
     entry.pendingApprovalEvent = undefined;
+    // Cleanup team watchers
+    for (const w of entry.teamWatchers.values()) w.cleanup();
+    entry.teamWatchers.clear();
     // Close streaming session in provider
     const provider = providerRegistry.get(entry.providerId);
     if (provider && "closeStreamingSession" in provider) {
@@ -419,6 +458,8 @@ export const chatWebSocket = {
       phase: "idle",
       turnEvents: [],
       isStreamingActive: false,
+      teamWatchers: new Map(),
+      teamNames: new Set(),
     };
     activeSessions.set(sessionId, newEntry);
     setupClientPing(newEntry, ws);
@@ -470,6 +511,7 @@ export const chatWebSocket = {
       const newEntry: SessionEntry = {
         providerId: pid, clients: new Set([ws]), projectPath: pp, projectName: pn,
         pingIntervals: new Map(), phase: "idle", turnEvents: [], isStreamingActive: false,
+        teamWatchers: new Map(), teamNames: new Set(),
       };
       activeSessions.set(sessionId, newEntry);
       setupClientPing(newEntry, ws);

package/src/server/ws/team-inbox-watcher.ts

@@ -0,0 +1,181 @@
+import { watch, type FSWatcher } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { readdir } from "fs/promises";
+
+const TEAMS_DIR = join(homedir(), ".claude", "teams");
+const DEBOUNCE_MS = 200;
+
+/** Infer message type from JSON text field */
+function inferMessageType(text: string): string {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed?.type ?? "message";
+  } catch {
+    return "message";
+  }
+}
+
+interface WatcherCallbacks {
+  onInboxUpdate: (teamName: string, agent: string, messages: unknown[]) => void;
+  onConfigUpdate: (teamName: string, config: unknown) => void;
+}
+
+/** Start watching a team's inboxes directory + config.json for changes */
+export function startTeamInboxWatcher(
+  teamName: string,
+  callbacks: WatcherCallbacks,
+): { watchers: FSWatcher[]; cleanup: () => void } {
+  const inboxDir = join(TEAMS_DIR, teamName, "inboxes");
+  const configPath = join(TEAMS_DIR, teamName, "config.json");
+  const watchers: FSWatcher[] = [];
+  const inboxSnapshots = new Map<string, number>(); // filename → last known msg count
+  const debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  // Watch inboxes directory
+  try {
+    const inboxWatcher = watch(inboxDir, (_event, filename) => {
+      if (!filename?.endsWith(".json")) return;
+
+      // Debounce per file
+      const existing = debounceTimers.get(filename);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(filename, setTimeout(async () => {
+        debounceTimers.delete(filename);
+        try {
+          const content = await Bun.file(join(inboxDir, filename)).text();
+          const messages = JSON.parse(content);
+          const agentName = filename.replace(".json", "");
+          const lastKnown = inboxSnapshots.get(filename) ?? 0;
+
+          if (Array.isArray(messages) && messages.length > lastKnown) {
+            const newMessages = messages.slice(lastKnown).map((m: any) => ({
+              ...m,
+              to: agentName,
+              parsedType: inferMessageType(m.text ?? ""),
+            }));
+            inboxSnapshots.set(filename, messages.length);
+            callbacks.onInboxUpdate(teamName, agentName, newMessages);
+          }
+        } catch { /* file mid-write or deleted */ }
+      }, DEBOUNCE_MS));
+    });
+    watchers.push(inboxWatcher);
+  } catch { /* inboxes dir may not exist yet */ }
+
+  // Watch config.json
+  try {
+    const configWatcher = watch(configPath, async () => {
+      try {
+        const content = await Bun.file(configPath).text();
+        callbacks.onConfigUpdate(teamName, JSON.parse(content));
+      } catch { /* mid-write */ }
+    });
+    watchers.push(configWatcher);
+  } catch { /* config may not exist */ }
+
+  return {
+    watchers,
+    cleanup: () => {
+      for (const w of watchers) w.close();
+      for (const t of debounceTimers.values()) clearTimeout(t);
+      debounceTimers.clear();
+    },
+  };
+}
+
+/** Read team config from filesystem */
+export async function readTeamConfig(teamName: string): Promise<unknown | null> {
+  try {
+    const content = await Bun.file(join(TEAMS_DIR, teamName, "config.json")).text();
+    return JSON.parse(content);
+  } catch { return null; }
+}
+
+/** List all teams from ~/.claude/teams/ */
+export async function listTeams(): Promise<unknown[]> {
+  try {
+    const entries = await readdir(TEAMS_DIR, { withFileTypes: true });
+    const teams = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const config = await readTeamConfig(entry.name);
+      if (config) teams.push(config);
+    }
+    return teams;
+  } catch { return []; }
+}
+
+/** Read team detail with merged inbox messages + inferred member status */
+export async function readTeamDetail(teamName: string): Promise<unknown | null> {
+  const config = await readTeamConfig(teamName) as any;
+  if (!config) return null;
+
+  const inboxDir = join(TEAMS_DIR, teamName, "inboxes");
+  const messages: unknown[] = [];
+  let inboxFiles: string[] = [];
+  try {
+    inboxFiles = (await readdir(inboxDir)).filter(f => f.endsWith(".json"));
+    for (const file of inboxFiles) {
+      const content = await Bun.file(join(inboxDir, file)).text();
+      const agentName = file.replace(".json", "");
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        messages.push(...parsed.map((m: any) => ({
+          ...m,
+          to: agentName,
+          parsedType: inferMessageType(m.text ?? ""),
+        })));
+      }
+    }
+  } catch { /* no inboxes dir */ }
+
+  // Sort by timestamp
+  messages.sort((a: any, b: any) =>
+    new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+
+  // Infer member status from inboxes
+  const members = (config.members ?? []).map((m: any) => ({
+    ...m,
+    status: inferMemberStatus(messages, m.name),
+  }));
+
+  // Discover additional members from inbox filenames (reuse already-read list)
+  for (const file of inboxFiles) {
+    const name = file.replace(".json", "");
+    if (!members.some((m: any) => m.name === name)) {
+      members.push({
+        name,
+        agentId: `${name}@${teamName}`,
+        agentType: "teammate",
+        model: "unknown",
+        status: inferMemberStatus(messages, name),
+      });
+    }
+  }
+
+  return { ...config, members, messages, memberCount: members.length };
+}
+
+function inferMemberStatus(messages: unknown[], agentName: string): string {
+  const fromAgent = (messages as any[]).filter(m => m.from === agentName).reverse();
+  if (fromAgent.length === 0) return "active";
+  const last = fromAgent[0];
+  const type = last.parsedType ?? inferMessageType(last.text ?? "");
+  if (type === "shutdown_approved") return "shutdown";
+  if (type === "idle_notification") return "idle";
+  return "active";
+}
+
+/** Extract team name from TeamCreate tool_result output */
+export function extractTeamName(output: string): string | null {
+  try {
+    const parsed = JSON.parse(output);
+    return parsed?.team_name ?? parsed?.name ?? null;
+  } catch {
+    // Try regex: look for team_name in text
+    const match = output.match(/"team_name"\s*:\s*"([^"]+)"/);
+    return match?.[1] ?? null;
+  }
+}

package/src/services/git.service.ts

@@ -1,3 +1,4 @@
+import path from "node:path";
 import simpleGit, { type SimpleGit } from "simple-git";
 import type {
   GitStatus,
@@ -5,6 +6,7 @@ import type {
   GitCommit,
   GitBranch,
   GitGraphData,
+  GitWorktree,
 } from "../types/git.ts";
 
 class GitService {
@@ -398,6 +400,103 @@ class GitService {
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // Worktree operations
+  // ---------------------------------------------------------------------------
+
+  /** Parse `git worktree list --porcelain -v` output into GitWorktree[]. */
+  async listWorktrees(projectPath: string): Promise<GitWorktree[]> {
+    const git = this.git(projectPath);
+    const raw = await git.raw(["worktree", "list", "--porcelain", "-v"]);
+    const worktrees: GitWorktree[] = [];
+    // Blocks are separated by blank lines
+    const blocks = raw.trim().split(/\n\n+/);
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i]!;
+      const lines = block.split("\n").map((l) => l.trim()).filter(Boolean);
+      if (!lines.length) continue;
+      const wt: GitWorktree = {
+        path: "",
+        branch: "",
+        head: "",
+        isMain: i === 0,
+        isBare: false,
+        isDetached: false,
+        locked: false,
+        prunable: false,
+      };
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          wt.path = line.slice("worktree ".length);
+        } else if (line.startsWith("HEAD ")) {
+          wt.head = line.slice("HEAD ".length);
+        } else if (line.startsWith("branch ")) {
+          // refs/heads/main → main
+          const ref = line.slice("branch ".length);
+          wt.branch = ref.replace(/^refs\/heads\//, "");
+        } else if (line === "bare") {
+          wt.isBare = true;
+        } else if (line === "detached") {
+          wt.isDetached = true;
+        } else if (line.startsWith("locked")) {
+          wt.locked = true;
+          const reason = line.slice("locked".length).trim();
+          if (reason) wt.lockReason = reason;
+        } else if (line.startsWith("prunable")) {
+          wt.prunable = true;
+        }
+      }
+      if (wt.path) worktrees.push(wt);
+    }
+    return worktrees;
+  }
+
+  /**
+   * Validate that targetPath is safe: must be under the parent directory of
+   * projectPath and must not contain path traversal sequences.
+   */
+  private validateWorktreePath(projectPath: string, targetPath: string): void {
+    const resolvedTarget = path.resolve(targetPath);
+    const parentDir = path.dirname(path.resolve(projectPath));
+    if (!resolvedTarget.startsWith(parentDir + path.sep) && resolvedTarget !== parentDir) {
+      throw new Error(`Worktree path must be within: ${parentDir}`);
+    }
+    if (resolvedTarget.includes("..")) {
+      throw new Error("Worktree path must not contain '..'");
+    }
+  }
+
+  /** Create a new worktree. */
+  async addWorktree(
+    projectPath: string,
+    targetPath: string,
+    opts: { branch?: string; newBranch?: string } = {},
+  ): Promise<void> {
+    this.validateWorktreePath(projectPath, targetPath);
+    const args = ["worktree", "add"];
+    if (opts.newBranch) {
+      args.push("-b", opts.newBranch);
+    }
+    args.push(targetPath);
+    if (opts.branch) {
+      args.push(opts.branch);
+    }
+    await this.git(projectPath).raw(args);
+  }
+
+  /** Remove a worktree. Pass force=true to remove even with uncommitted changes. */
+  async removeWorktree(projectPath: string, targetPath: string, force = false): Promise<void> {
+    const args = ["worktree", "remove"];
+    if (force) args.push("-f");
+    args.push(targetPath);
+    await this.git(projectPath).raw(args);
+  }
+
+  /** Prune stale worktree metadata from .git/worktrees/. */
+  async pruneWorktrees(projectPath: string): Promise<void> {
+    await this.git(projectPath).raw(["worktree", "prune"]);
+  }
+
   private parseRemoteUrl(
     url: string,
   ): { host: string; owner: string; repo: string } | null {

package/src/types/chat.ts

@@ -115,7 +115,10 @@ export type ChatEvent =
   | { type: "session_migrated"; oldSessionId: string; newSessionId: string }
   | { type: "account_info"; accountId: string; accountLabel: string }
   | { type: "account_retry"; reason: string; accountId?: string; accountLabel?: string }
-  | { type: "system"; subtype: string };
+  | { type: "system"; subtype: string }
+  | { type: "team_detected"; teamName: string }
+  | { type: "team_updated"; teamName: string; team: unknown }
+  | { type: "team_inbox"; teamName: string; agent: string; messages: unknown[] };
 
 export type ToolApprovalHandler = (
   tool: string,

package/src/types/git.ts

@@ -52,3 +52,24 @@ export interface GitDiffFile {
   deletions: number;
   content: string;
 }
+
+export interface GitWorktree {
+  /** Absolute path to the worktree directory */
+  path: string;
+  /** Branch name (empty string if detached HEAD) */
+  branch: string;
+  /** HEAD commit hash */
+  head: string;
+  /** True for the main (original) worktree */
+  isMain: boolean;
+  /** True if bare repository worktree */
+  isBare: boolean;
+  /** True if in detached HEAD state */
+  isDetached: boolean;
+  /** True if worktree is locked (prevented from auto-pruning) */
+  locked: boolean;
+  /** Reason for lock, if any */
+  lockReason?: string;
+  /** True if this worktree can be pruned (directory missing/stale) */
+  prunable: boolean;
+}

package/src/types/team.ts

@@ -0,0 +1,33 @@
+export interface TeamInfo {
+  name: string;
+  description: string;
+  createdAt: number;
+  leadSessionId: string;
+  memberCount: number;
+  cwd?: string;
+}
+
+export interface TeamMember {
+  name: string;
+  agentId: string;
+  agentType: string;
+  model: string;
+  joinedAt: number;
+  status: "active" | "idle" | "shutdown";
+}
+
+export interface InboxMessage {
+  from: string;
+  to: string;
+  text: string;
+  timestamp: string;
+  read: boolean;
+  color?: string;
+  summary?: string;
+  parsedType?: "task_assignment" | "idle_notification" | "completion" | "shutdown_request" | "shutdown_approved" | "message";
+}
+
+export interface TeamDetail extends TeamInfo {
+  members: TeamMember[];
+  messages: InboxMessage[];
+}

package/src/web/components/chat/chat-tab.tsx

@@ -98,6 +98,9 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     reconnect,
     refetchMessages,
     isConnected,
+    teamActivity,
+    teamMessages,
+    markTeamRead,
   } = useChat(sessionId, providerId, projectName);
 
   // When CLI provider assigns a different session ID, update our state
@@ -403,6 +406,9 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           onModeChange={setPermissionMode}
           providerId={providerId}
           onProviderChange={!sessionId ? setProviderId : undefined}
+          teamActivity={teamActivity}
+          onTeamOpen={markTeamRead}
+          teamMessages={teamMessages}
         />
       </div>
 

package/src/web/components/chat/message-input.tsx

@@ -1,5 +1,5 @@
 import { useState, useRef, useCallback, useEffect, memo, type KeyboardEvent, type DragEvent, type ClipboardEvent } from "react";
-import { ArrowUp, Square, Paperclip, Loader2, Mic, MicOff, Zap, ListOrdered, Clock } from "lucide-react";
+import { ArrowUp, Square, Paperclip, Loader2, Mic, MicOff, Zap, ListOrdered, Clock, Users } from "lucide-react";
 import { useVoiceInput } from "@/hooks/use-voice-input";
 import { api, projectUrl, getAuthToken } from "@/lib/api-client";
 import { randomId } from "@/lib/utils";
@@ -7,6 +7,8 @@ import { isSupportedFile, isImageFile } from "@/lib/file-support";
 import { AttachmentChips } from "./attachment-chips";
 import { ModeSelector, getModeLabel, getModeIcon } from "./mode-selector";
 import { ProviderSelector } from "./provider-selector";
+import { TeamActivityPopover } from "./team-activity-popover";
+import type { TeamMessageItem } from "@/hooks/use-chat";
 import type { SlashItem } from "./slash-command-picker";
 import type { FileNode } from "../../../types/project";
 import { flattenFileTree } from "./file-picker";
@@ -52,6 +54,17 @@ interface MessageInputProps {
   providerId?: string;
   /** Provider change handler — undefined when session is active (locked) */
   onProviderChange?: (providerId: string) => void;
+  /** Team activity state from use-chat */
+  teamActivity?: {
+    hasTeams: boolean;
+    teamNames: string[];
+    messageCount: number;
+    unreadCount: number;
+  };
+  /** Called when user opens team popover (marks messages as read) */
+  onTeamOpen?: () => void;
+  /** Team messages for popover */
+  teamMessages?: TeamMessageItem[];
 }
 
 export const MessageInput = memo(function MessageInput({
@@ -73,10 +86,14 @@ export const MessageInput = memo(function MessageInput({
   onModeChange,
   providerId,
   onProviderChange,
+  teamActivity,
+  onTeamOpen,
+  teamMessages,
 }: MessageInputProps) {
   const [value, setValue] = useState(initialValue ?? "");
   const [attachments, setAttachments] = useState<ChatAttachment[]>([]);
   const [modeSelectorOpen, setModeSelectorOpen] = useState(false);
+  const [teamPopoverOpen, setTeamPopoverOpen] = useState(false);
   const [pendingSend, setPendingSend] = useState(false);
   const [priority, setPriority] = useState<MessagePriority>('next');
   const textareaRef = useRef<HTMLTextAreaElement>(null);
@@ -520,6 +537,32 @@ export const MessageInput = memo(function MessageInput({
             />
           )}
           {isStreaming && <PriorityToggle value={priority} onChange={setPriority} />}
+          {teamActivity?.hasTeams && (
+            <div className="relative">
+              <button
+                type="button"
+                onClick={(e) => {
+                  e.stopPropagation();
+                  const next = !teamPopoverOpen;
+                  setTeamPopoverOpen(next);
+                  if (next) onTeamOpen?.();
+                }}
+                className="relative flex items-center justify-center size-7 rounded-full text-text-subtle hover:text-text-primary transition-colors"
+                aria-label="Team activity"
+              >
+                <Users className="size-3.5" />
+                {(teamActivity.unreadCount ?? 0) > 0 && (
+                  <span className="absolute -top-0.5 -right-0.5 size-2 bg-primary rounded-full animate-pulse" />
+                )}
+              </button>
+              <TeamActivityPopover
+                teamNames={teamActivity.teamNames}
+                messages={teamMessages ?? []}
+                open={teamPopoverOpen}
+                onOpenChange={setTeamPopoverOpen}
+              />
+            </div>
+          )}
         </div>
         {/* Mobile: single row — attach + textarea + mic + send */}
         <div className="flex items-end gap-1 md:hidden px-2 py-2">
@@ -628,6 +671,32 @@ export const MessageInput = memo(function MessageInput({
                 />
               )}
               {isStreaming && <PriorityToggle value={priority} onChange={setPriority} />}
+              {teamActivity?.hasTeams && (
+                <div className="relative">
+                  <button
+                    type="button"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      const next = !teamPopoverOpen;
+                      setTeamPopoverOpen(next);
+                      if (next) onTeamOpen?.();
+                    }}
+                    className="relative flex items-center justify-center size-8 rounded-full text-text-subtle hover:text-text-primary hover:bg-surface-elevated transition-colors"
+                    aria-label="Team activity"
+                  >
+                    <Users className="size-4" />
+                    {(teamActivity.unreadCount ?? 0) > 0 && (
+                      <span className="absolute -top-0.5 -right-0.5 size-2.5 bg-primary rounded-full animate-pulse" />
+                    )}
+                  </button>
+                  <TeamActivityPopover
+                    teamNames={teamActivity.teamNames}
+                    messages={teamMessages ?? []}
+                    open={teamPopoverOpen}
+                    onOpenChange={setTeamPopoverOpen}
+                  />
+                </div>
+              )}
             </div>
             <div className="flex items-center gap-1">
               {voice.supported && (