@saadnvd1/agent-os 0.3.723 → 0.3.731

package/components/Analyst/cardState.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+import type { DigestSignals, Recommendation } from "@/lib/analyst/types";
+import { cardView } from "./cardState";
+
+const signals = (over: Partial<DigestSignals> = {}): DigestSignals => ({
+  turns: 1,
+  toolCalls: 3,
+  failedTools: 0,
+  checks: [],
+  filesChanged: [],
+  durationMs: 1000,
+  costUsd: 0,
+  interrupted: false,
+  errors: 0,
+  noToolTurns: 0,
+  readWeb: false,
+  ...over,
+});
+
+const rec = (over: Partial<Recommendation> = {}): Recommendation => ({
+  id: "r1",
+  linkId: "l1",
+  analystItemId: "a1",
+  coderThrough: "t1",
+  verdict: "continue",
+  summary: "Did the thing",
+  issues: [],
+  signals: signals(),
+  prompt: "Run the tests",
+  state: "open",
+  error: null,
+  sentText: null,
+  sentItemId: null,
+  edited: false,
+  createdAt: 1,
+  decidedAt: null,
+  ...over,
+});
+
+describe("cardView", () => {
+  it("offers Send, Edit and Dismiss on an open card with a prompt", () => {
+    const v = cardView(rec(), "continue", "t1");
+    expect(v).toMatchObject({
+      label: "Next prompt",
+      canSend: true,
+      canWrite: true,
+      canDismiss: true,
+      canAskAgain: false,
+      notes: [],
+    });
+  });
+
+  it("is read-only without a stored card", () => {
+    const v = cardView(null, "continue", "t1");
+    expect(v.canSend || v.canWrite || v.canDismiss).toBe(false);
+  });
+
+  it("has no Send on a blocked or needs-you card, but lets the user write one", () => {
+    for (const verdict of ["blocked", "needs_you"] as const) {
+      const v = cardView(rec({ verdict }), verdict, "t1");
+      expect(v.canSend).toBe(false);
+      expect(v.canWrite).toBe(true);
+    }
+  });
+
+  it("warns when the coding agent has moved on", () => {
+    const v = cardView(rec(), "continue", "t2");
+    expect(v.canSend).toBe(true);
+    expect(v.notes).toContain(
+      "The coding agent has moved on since this review"
+    );
+  });
+
+  it("flags a turn with no tool calls and web reads", () => {
+    const v = cardView(
+      rec({ signals: signals({ noToolTurns: 1, readWeb: true }) }),
+      "continue",
+      "t1"
+    );
+    expect(v.notes).toEqual([
+      "The coding agent's turn ended without a single tool call",
+      "It read web content: check the prompt before sending",
+    ]);
+  });
+
+  it("offers Ask again on an invalid card, with its error", () => {
+    const v = cardView(
+      rec({ state: "invalid", error: "No block", verdict: null }),
+      null,
+      "t1"
+    );
+    expect(v).toMatchObject({
+      canAskAgain: true,
+      canSend: false,
+      notes: ["No block"],
+    });
+  });
+
+  it("is settled once sent, dismissed or superseded", () => {
+    for (const state of ["sent", "dismissed", "superseded"] as const) {
+      const v = cardView(rec({ state }), "continue", "t2");
+      expect(v.canSend || v.canWrite || v.canDismiss).toBe(false);
+      expect(v.notes).toEqual([]);
+    }
+    expect(
+      cardView(rec({ state: "sent", edited: true }), "continue", "t1").label
+    ).toBe("Sent, edited");
+  });
+});

package/components/Analyst/cardState.ts

@@ -0,0 +1,95 @@
+import type { Recommendation, Verdict } from "@/lib/analyst/types";
+
+export type CardTone = "primary" | "green" | "amber" | "red" | "muted";
+
+export interface CardView {
+  label: string;
+  tone: CardTone;
+  // Send the prompt as written (or edited).
+  canSend: boolean;
+  // A blocked or needs-you card has no Send; the user can still write one.
+  canWrite: boolean;
+  canDismiss: boolean;
+  canAskAgain: boolean;
+  // Why to look twice before sending, or what happened to it.
+  notes: string[];
+}
+
+const VERDICT_LABEL: Record<Verdict, [string, CardTone]> = {
+  continue: ["Next prompt", "primary"],
+  done: ["Looks done", "green"],
+  blocked: ["Blocked", "red"],
+  needs_you: ["Needs you", "amber"],
+};
+
+const plural = (n: number, one: string) => `${n} ${one}${n === 1 ? "" : "s"}`;
+
+/**
+ * What a review card shows and offers. `rec` is the stored card for the
+ * block, or null when there is none (an old review, an ended pairing): then
+ * it's read-only.
+ */
+export function cardView(
+  rec: Recommendation | null,
+  verdict: Verdict | null,
+  coderLastTurn: string | null
+): CardView {
+  const [vLabel, vTone] = verdict
+    ? VERDICT_LABEL[verdict]
+    : (["Review", "muted"] as const);
+  const view: CardView = {
+    label: vLabel,
+    tone: vTone,
+    canSend: false,
+    canWrite: false,
+    canDismiss: false,
+    canAskAgain: false,
+    notes: [],
+  };
+  if (!rec) return view;
+
+  const s = rec.signals;
+  if (s?.noToolTurns && s.noToolTurns === s.turns)
+    view.notes.push(
+      s.turns === 1
+        ? "The coding agent's turn ended without a single tool call"
+        : `None of the ${plural(s.turns, "turn")} made a tool call`
+    );
+  if (s?.interrupted) view.notes.push("The coding agent was interrupted");
+
+  switch (rec.state) {
+    case "sent":
+      return {
+        ...view,
+        label: rec.edited ? "Sent, edited" : "Sent",
+        tone: "muted",
+        notes: [],
+      };
+    case "dismissed":
+      return { ...view, label: "Dismissed", tone: "muted", notes: [] };
+    case "superseded":
+      return { ...view, label: "Superseded", tone: "muted", notes: [] };
+    case "invalid":
+      return {
+        ...view,
+        label: "Couldn't read",
+        tone: "red",
+        canAskAgain: true,
+        canDismiss: true,
+        notes: [rec.error || "The review block was invalid"],
+      };
+  }
+
+  // Open.
+  if (rec.coderThrough && coderLastTurn && rec.coderThrough !== coderLastTurn)
+    view.notes.push("The coding agent has moved on since this review");
+  if (s?.readWeb)
+    view.notes.push("It read web content: check the prompt before sending");
+  const sendable = verdict === "continue" || verdict === "done";
+  return {
+    ...view,
+    canSend: sendable && !!rec.prompt,
+    canWrite: true,
+    canDismiss: true,
+  };
+}

package/components/Analyst/pair.ts

@@ -0,0 +1,81 @@
+"use client";
+
+import { useCallback } from "react";
+import { toast } from "sonner";
+import { usePanes } from "@/contexts/PaneContext";
+import {
+  useSessionAnalyst,
+  useStartAnalyst,
+  type StartAnalystInput,
+} from "@/data/analyst";
+import type { Session } from "@/lib/db";
+import type { AnalystLinkView, PaneSession } from "@/lib/analyst/types";
+
+// A chat's tmux name: `<agent>-<id>`, as every chat tab attaches.
+export const paneTmux = (s: PaneSession) => `${s.agentType}-${s.id}`;
+
+export type PairStatus = "paused" | "reviewing" | "recommendation" | "watching";
+
+export function pairStatus(link: AnalystLinkView): PairStatus {
+  if (link.paused) return "paused";
+  if (link.pendingDigestId) return "reviewing";
+  if (link.recommendations.some((r) => r.state === "open"))
+    return "recommendation";
+  return "watching";
+}
+
+export const PAIR_STATUS_LABEL: Record<PairStatus, string> = {
+  paused: "Paused",
+  reviewing: "Reviewing",
+  recommendation: "Prompt ready",
+  watching: "Watching",
+};
+
+// The side of a pairing a session isn't.
+export function partnerOf(link: AnalystLinkView, sessionId: string) {
+  return link.coder.id === sessionId ? link.analyst : link.coder;
+}
+
+// Starts an analyst for a chat and shows it beside the coder's pane: the
+// one given, else one showing the coder, else the focused one.
+export function useStartAnalystBeside() {
+  const start = useStartAnalyst();
+  const { openBeside, state, focusedPaneId } = usePanes();
+  const run = useCallback(
+    async (input: StartAnalystInput, paneId?: string) => {
+      try {
+        const link = await start.mutateAsync(input);
+        const showing = Object.entries(state.panes).find(([, p]) =>
+          p.tabs.some(
+            (t) => t.id === p.activeTabId && t.sessionId === link.coder.id
+          )
+        )?.[0];
+        openBeside(paneId ?? showing ?? focusedPaneId, {
+          sessionId: link.analyst.id,
+          tmux: paneTmux(link.analyst),
+        });
+        return link;
+      } catch (error) {
+        toast.error(error instanceof Error ? error.message : String(error));
+        return null;
+      }
+    },
+    [start, openBeside, state.panes, focusedPaneId]
+  );
+  return { run, isPending: start.isPending };
+}
+
+// Whether a session can be given an analyst here: a local chat that isn't
+// an orchestrator, an analyst or already paired. The server checks again.
+export function useCanAddAnalyst(session: Session | null | undefined) {
+  const chat = session?.view === "chat" ? session : null;
+  const paired = useSessionAnalyst(chat?.id).data;
+  return (
+    !!chat &&
+    !chat.role &&
+    !chat.archived_at &&
+    (chat.host_id || "local") === "local" &&
+    chat.agent_role !== "analyst" &&
+    !paired
+  );
+}

package/components/Chat/Code.tsx

@@ -12,6 +12,8 @@ import oneDark from "react-syntax-highlighter/dist/esm/styles/prism/one-dark";
 import oneLight from "react-syntax-highlighter/dist/esm/styles/prism/one-light";
 import { CopyButton } from "./CopyButton";
 import { Mermaid } from "./Mermaid";
+import { ReviewCard } from "@/components/Analyst/ReviewCard";
+import { REVIEW_FENCE } from "@/lib/analyst/parseReview";
 
 const ALIASES: Record<string, string> = {
   sh: "bash",
@@ -117,6 +119,7 @@ export function CodeBlock({
   language?: string;
 }) {
   if (language === "mermaid") return <Mermaid code={code} />;
+  if (language === REVIEW_FENCE) return <ReviewCard code={code} />;
   return (
     <div className="bg-foreground/[0.04] not-prose my-3 overflow-hidden rounded-xl">
       <div

package/components/Chat/Messages.tsx

@@ -24,9 +24,11 @@ import { FileChip } from "./FileChip";
 import { ImageThumb } from "./ImageThumb";
 import { Markdown } from "./Markdown";
 import { openSessionLink } from "./session-link";
+import { TurnCopy } from "./TurnCopy";
 import { UndoButton } from "./Undo";
 import { useRowState } from "./rowState";
 import { useBookmarkChat } from "@/components/Bookmarks/context";
+import { ChatItemContext } from "./itemContext";
 import { exportUi, exportUiActions, pickedRange } from "@/stores/exportUi";
 import {
   BookmarkButton,
@@ -299,7 +301,11 @@ export function AssistantMessage({
     <BookmarkPress itemId={item.id}>
       <div className="group">
         <div data-quotable className={cn(item.streaming && "streaming-cursor")}>
-          <Markdown text={item.text} streaming={item.streaming} />
+          <ChatItemContext.Provider
+            value={{ itemId: item.id, streaming: !!item.streaming }}
+          >
+            <Markdown text={item.text} streaming={item.streaming} />
+          </ChatItemContext.Provider>
         </div>
         {!item.streaming && (
           <div className="-ml-1.5 flex items-center">
@@ -402,6 +408,7 @@ export function TurnEnd({ item }: { item: Of<"turn_end"> }) {
       <div className="group text-muted-foreground/60 flex items-center gap-3 font-mono text-[11px]">
         <span className="bg-foreground/[0.06] h-px flex-1" />
         {label}
+        <TurnCopy turnEndId={item.id} />
         <TurnBookmark turnEndId={item.id} />
         <span className="bg-foreground/[0.06] h-px flex-1" />
       </div>

package/components/Chat/TurnCopy.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import { useState } from "react";
+import { Check, Copy } from "lucide-react";
+import { cn } from "@/lib/utils";
+import { fetchTurnCopy } from "@/data/exports";
+import { useBookmarkChat, useTurnStart } from "@/components/Bookmarks/context";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+
+type Part = "response" | "full";
+
+// "Copy" on a finished turn's end line: the answer alone, or the whole turn
+// (reasoning, tools, output, errors) as Markdown. One menu, so a phone's
+// turn row gets one button, not two.
+export function TurnCopy({ turnEndId }: { turnEndId: string }) {
+  const chat = useBookmarkChat();
+  const start = useTurnStart(turnEndId);
+  const [state, setState] = useState<"idle" | "copied" | "failed">("idle");
+  if (!chat || !start) return null;
+
+  const copy = async (part: Part) => {
+    try {
+      const turn = await fetchTurnCopy(chat.sessionId, start);
+      const text = part === "full" ? turn.full : turn.response;
+      if (!text) throw new Error("nothing to copy");
+      await navigator.clipboard.writeText(text);
+      setState("copied");
+    } catch {
+      setState("failed");
+    }
+    setTimeout(() => setState("idle"), 1500);
+  };
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <button
+          type="button"
+          aria-label="Copy turn"
+          className={cn(
+            "hover:text-foreground hover:bg-foreground/[0.06] -my-2 flex min-h-11 shrink-0 items-center gap-1 rounded-md px-2 md:-my-1 md:min-h-7",
+            state === "idle"
+              ? "opacity-60 group-hover:opacity-100 focus-visible:opacity-100"
+              : state === "failed"
+                ? "text-destructive"
+                : "text-foreground"
+          )}
+        >
+          {state === "copied" ? (
+            <Check className="h-3 w-3" />
+          ) : (
+            <Copy className="h-3 w-3" />
+          )}
+          <span className="md:hidden">
+            {state === "failed"
+              ? "Copy failed"
+              : state === "copied"
+                ? "Copied"
+                : "Copy"}
+          </span>
+        </button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="font-sans text-sm">
+        <DropdownMenuItem
+          className="min-h-11 md:min-h-8"
+          onSelect={() => void copy("response")}
+        >
+          Copy Response
+        </DropdownMenuItem>
+        <DropdownMenuItem
+          className="min-h-11 md:min-h-8"
+          onSelect={() => void copy("full")}
+        >
+          Copy Full Turn
+        </DropdownMenuItem>
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}

package/components/Chat/itemContext.ts

@@ -0,0 +1,14 @@
+"use client";
+
+import { createContext, useContext } from "react";
+
+// The message a rendered block belongs to, for blocks that act on it (a
+// review card finds its stored recommendation by the item's id).
+export interface ChatItemRef {
+  itemId: string;
+  streaming: boolean;
+}
+
+export const ChatItemContext = createContext<ChatItemRef | null>(null);
+
+export const useChatItem = () => useContext(ChatItemContext);

package/components/Draft/DraftChips.tsx

@@ -4,6 +4,7 @@ import { useEffect } from "react";
 import {
   Bot,
   Cpu,
+  Eye,
   FolderGit2,
   GitBranch,
   Flag,
@@ -252,6 +253,15 @@ export function DraftChips({
           onChange={(openPr) => onChange({ openPr })}
         />
       )}
+      {project && !draft.openPr && local && draft.agentRole !== "analyst" && (
+        <ChipToggle
+          icon={Eye}
+          label="With analyst"
+          on={!!draft.withAnalyst}
+          title="A second chat reviews each turn and drafts the next prompt for you to send"
+          onChange={(withAnalyst) => onChange({ withAnalyst })}
+        />
+      )}
       {project && draft.openPr && local && (
         <ChipMenu
           icon={Cpu}

package/components/Draft/DraftPanel.tsx

@@ -23,6 +23,7 @@ import type { StartWarning } from "@/lib/claims/startWarning";
 import { usePanes } from "@/contexts/PaneContext";
 import { setPendingPrompt } from "@/stores/initialPrompt";
 import { draftsActions, draftsStore, newDraft } from "@/stores/drafts";
+import { useStartAnalystBeside } from "@/components/Analyst/pair";
 import { DraftChips } from "./DraftChips";
 import { DraftHeading } from "./DraftHeading";
 import { ModelUnavailableDialog } from "./ModelUnavailableDialog";
@@ -57,6 +58,7 @@ export function DraftPanel({
     discovers
   );
   const launch = useLaunchSession();
+  const startAnalyst = useStartAnalystBeside();
   const { workspace } = useSelectedWorkspace();
   const createTask = useCreateTask();
   const checkStart = useCheckStart();
@@ -172,6 +174,11 @@ export function DraftPanel({
         session.tmux_name ?? "",
         session.host_id
       );
+      if (draft.withAnalyst && project && draft.hostId === "local") {
+        if (session.view === "chat")
+          void startAnalyst.run({ coderSessionId: session.id }, paneId);
+        else toast("An analyst reviews chats: this session runs in a terminal");
+      }
     } catch (error) {
       if (error instanceof ModelUnavailableError) {
         setDown({ error, text, images, files });

package/components/Pane/DesktopTabBar.tsx

@@ -16,6 +16,7 @@ import { PaneViewToggle } from "./PaneViewToggle";
 import { PaneMenu } from "./PaneMenu";
 import { HostBadge } from "@/components/Hosts/HostBadge";
 import { RolePill } from "@/components/Sessions/RolePill";
+import { PairChip } from "@/components/Analyst/PairChip";
 import { usePaneBarSlots } from "./PaneBarSlots";
 import { ChatBookmarksButton } from "@/components/Bookmarks/ChatBookmarksButton";
 import type { ViewMode } from "@/contexts/PaneContext";
@@ -37,6 +38,7 @@ interface DesktopTabBarProps {
   isFocused: boolean;
   isConductor: boolean;
   hasLog?: boolean;
+  hasReport?: boolean;
   workerCount: number;
   canSplit: boolean;
   canClose: boolean;
@@ -68,6 +70,7 @@ export function DesktopTabBar({
   isFocused,
   isConductor,
   hasLog,
+  hasReport,
   workerCount,
   canSplit,
   canClose,
@@ -163,6 +166,7 @@ export function DesktopTabBar({
 
       <div className="flex shrink-0 items-center gap-1.5">
         <RolePill session={session} paneId={paneId} />
+        <PairChip session={session} paneId={paneId} />
         <HostBadge hostId={session?.host_id} />
         <ContextMeter sessionId={session?.id} />
         <SessionPrStage sessionId={session?.id} />
@@ -182,6 +186,7 @@ export function DesktopTabBar({
             isLocalSession={isLocalSession}
             isConductor={isConductor}
             hasLog={hasLog}
+            hasReport={hasReport}
             workerCount={workerCount}
             showGit={showGit}
             gitDrawerOpen={gitDrawerOpen}
@@ -194,6 +199,7 @@ export function DesktopTabBar({
         <div className="flex items-center">
           <PaneMenu
             session={session}
+            paneId={paneId}
             bookmarksSessionId={bookmarksSessionId}
             canSplit={canSplit}
             canClose={canClose}

package/components/Pane/MobileTabBar.tsx

@@ -26,6 +26,7 @@ import {
   Share2,
   Download,
   TextSearch,
+  Eye,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { useAwayQuery } from "@/data/away";
@@ -36,6 +37,8 @@ import { RolePill } from "@/components/Sessions/RolePill";
 import { bookmarksUiActions } from "@/stores/bookmarksUi";
 import { shareUiActions } from "@/stores/shareUi";
 import { exportUiActions } from "@/stores/exportUi";
+import { analystUiActions } from "@/stores/analystUi";
+import { useCanAddAnalyst } from "@/components/Analyst/pair";
 import { MoveMenuItems } from "@/components/Tasks/MoveMenuItems";
 import { ChatBookmarksButton } from "@/components/Bookmarks/ChatBookmarksButton";
 import type { ViewMode } from "@/contexts/PaneContext";
@@ -50,6 +53,7 @@ interface MobileTabBarProps {
   viewMode: ViewMode;
   isConductor: boolean;
   hasLog?: boolean;
+  hasReport?: boolean;
   workerCount: number;
   // Local, and the folder is not known to be outside a git repository.
   showGit: boolean;
@@ -70,6 +74,7 @@ export function MobileTabBar({
   viewMode,
   isConductor,
   hasLog,
+  hasReport,
   workerCount,
   showGit,
   onMenuClick,
@@ -128,6 +133,7 @@ export function MobileTabBar({
   };
 
   const isLocalSession = !session?.host_id || session.host_id === "local";
+  const canAddAnalyst = useCanAddAnalyst(session);
 
   return (
     <div
@@ -230,6 +236,16 @@ export function MobileTabBar({
                   <Download className="h-4 w-4" />
                   Export for AI…
                 </DropdownMenuItem>
+                {canAddAnalyst && (
+                  <DropdownMenuItem
+                    onSelect={() =>
+                      analystUiActions.open(session.id, session.name)
+                    }
+                  >
+                    <Eye className="h-4 w-4" />
+                    Add analyst…
+                  </DropdownMenuItem>
+                )}
                 <DropdownMenuSeparator />
               </>
             )}
@@ -375,6 +391,7 @@ export function MobileTabBar({
           isLocalSession={isLocalSession}
           showGit={showGit}
           hasLog={hasLog}
+          hasReport={hasReport}
           isConductor={isConductor}
           workerCount={workerCount}
         />

package/components/Pane/MobileViewPicker.tsx

@@ -7,6 +7,7 @@ import {
   GitBranch,
   Package,
   ScrollText,
+  ClipboardList,
   Terminal as TerminalIcon,
   Users,
   type LucideIcon,
@@ -31,6 +32,7 @@ export interface MobileViewAvailability {
   // Local, and the folder is not known to be outside a git repository.
   showGit: boolean;
   hasLog?: boolean;
+  hasReport?: boolean;
   isConductor: boolean;
   workerCount: number;
 }
@@ -40,6 +42,7 @@ export function mobileViews({
   isLocalSession,
   showGit,
   hasLog,
+  hasReport,
   isConductor,
   workerCount,
 }: MobileViewAvailability): MobileView[] {
@@ -48,6 +51,7 @@ export function mobileViews({
     isLocalSession && { mode: "files", label: "Files", icon: FolderOpen },
     showGit && { mode: "git", label: "Git", icon: GitBranch },
     { mode: "artifacts", label: "Artifacts", icon: Package },
+    !!hasReport && { mode: "report", label: "Report", icon: ClipboardList },
     !!hasLog && { mode: "log", label: "Log", icon: ScrollText },
     isConductor && {
       mode: "workers",

package/components/Pane/PaneMenu.test.ts

@@ -6,10 +6,12 @@ import type { Session } from "@/lib/db/types";
 import { bookmarksUi } from "@/stores/bookmarksUi";
 import { docsUi } from "@/stores/docsUi";
 import { paletteUi } from "@/stores/palette";
+import { analystUi } from "@/stores/analystUi";
 
 const data = vi.hoisted(() => ({
   bookmarks: [] as unknown[],
   docs: null as { id: string } | null,
+  canAddAnalyst: false,
 }));
 vi.mock("@/data/bookmarks", () => ({
   useSessionBookmarks: () => ({ data: data.bookmarks }),
@@ -17,6 +19,9 @@ vi.mock("@/data/bookmarks", () => ({
 vi.mock("@/data/lumifyhub/docs", () => ({
   useDocsWorkspace: () => data.docs,
 }));
+vi.mock("@/components/Analyst/pair", () => ({
+  useCanAddAnalyst: () => data.canAddAnalyst,
+}));
 vi.mock("@/components/Tasks/MoveMenuItems", () => ({
   MoveMenuItems: () => null,
 }));
@@ -60,6 +65,8 @@ describe("PaneMenu", () => {
     root = createRoot(host);
     data.bookmarks = [];
     data.docs = null;
+    data.canAddAnalyst = false;
+    analystUi.open = false;
     paletteUi.open = false;
     bookmarksUi.chatSessionId = null;
     docsUi.workspaceId = null;
@@ -73,6 +80,7 @@ describe("PaneMenu", () => {
       root.render(
         createElement(PaneMenu, {
           session,
+          paneId: "pane-1",
           bookmarksSessionId,
           canSplit: true,
           canClose: true,
@@ -115,4 +123,17 @@ describe("PaneMenu", () => {
     act(() => item("Docs")?.click());
     expect(docsUi.workspaceId).toBe("w1");
   });
+
+  it("offers Add analyst only when the chat can have one, beside this pane", () => {
+    render();
+    expect(item("Add analyst")).toBeUndefined();
+    data.canAddAnalyst = true;
+    render();
+    act(() => item("Add analyst")?.click());
+    expect(analystUi).toMatchObject({
+      open: true,
+      sessionId: "s1",
+      paneId: "pane-1",
+    });
+  });
 });