@cueloop/client 0.1.0-alpha.76 → 0.1.0-alpha.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.76",
+  "version": "0.1.0-alpha.77",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -27,10 +27,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.76",
-    "@cueloop/extension-api": "0.1.0-alpha.76",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.76",
-    "@cueloop/schema": "0.1.0-alpha.76",
+    "@cueloop/daemon": "0.1.0-alpha.77",
+    "@cueloop/extension-api": "0.1.0-alpha.77",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.77",
+    "@cueloop/schema": "0.1.0-alpha.77",
     "@opentui/core": "^0.5.8",
     "@opentui/keymap": "0.5.8",
     "@opentui/react": "^0.5.8",

package/src/App.identity.test.tsx

@@ -0,0 +1,78 @@
+/** Reviewer identity surfaces: the Account settings tab and the author-name tooltip on a comment dot. */
+
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { DaemonServer } from "@cueloop/daemon";
+import { App } from "./App";
+import { isolateUserConfig, locateText, renderReadyApp, waitForText } from "./test-support";
+
+const PLAN = "# Migration Plan\n\nThe daemon persists sessions to disk atomically.\n";
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let sessionId: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-identity-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  const session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
+  });
+  sessionId = session.id;
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp() {
+  return renderReadyApp(<App home={home} sessionId={sessionId} />, { width: 120, height: 32 });
+}
+
+test("the Account settings tab shows the display name row and the GitHub sync action", async () => {
+  const setup = await renderApp();
+
+  await setup.mockMouse.click(1, 0);
+  await waitForText(setup, "Settings");
+  const menu = setup.captureCharFrame().split("\n");
+  const settingsRow = menu.findIndex((line) => line.includes("Settings"));
+
+  await setup.mockMouse.click(menu[settingsRow]!.indexOf("Settings") + 1, settingsRow);
+  await waitForText(setup, "Account");
+  const dialog = setup.captureCharFrame().split("\n");
+  const accountRow = dialog.findIndex((line) => line.includes("Account"));
+
+  await setup.mockMouse.click(dialog[accountRow]!.indexOf("Account") + 1, accountRow);
+  await waitForText(setup, "Display name");
+  expect(setup.captureCharFrame()).toContain("Sync from GitHub");
+});
+
+test("hovering an own comment's dot surfaces the author tooltip", async () => {
+  server.core.sessionAnnotate(sessionId, {
+    id: "a_own",
+    kind: "comment",
+    anchor: { quote: "atomically", prefix: "sessions to disk ", suffix: "." },
+    body: "My note.",
+  });
+  const setup = await renderApp();
+
+  await waitForText(setup, "● My note.");
+  // the tooltip is not painted until the pointer is over the dot
+  expect(setup.captureCharFrame()).not.toContain("you");
+  const dot = locateText(setup, "● My note.");
+
+  await setup.mockMouse.moveTo(dot.column, dot.row);
+  await waitForText(setup, "you");
+});

package/src/App.share-choice.test.tsx

@@ -0,0 +1,105 @@
+/** The share shortcut opens an app-level public/private choice reachable from any view. */
+
+import { afterEach, beforeEach, describe, mock, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import type { ShareTransport } from "./thread-controller";
+import { isolateUserConfig, press, pressKey, waitForText, waitForTextGone } from "./test-support";
+
+const shareTransport: ShareTransport = {
+  publish: mock(async () => ({ line: "ssh p_share01@cueloop.dev", copied: true })),
+  pull: mock(async () => {
+    throw new Error("Unexpected share pull");
+  }),
+  push: mock(async () => {}),
+  watch: () => () => {},
+  parseShareId: (line) => line.match(/^ssh (\S+)@/)?.[1],
+  collaboratorAnnotations: () => [],
+  mergeFromShare: () => ({ annotations: [] }),
+};
+
+const PLAN = `# Migration Plan\n\n## Context\n\nThe daemon persists sessions to disk atomically.\n`;
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: Thread;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-share-choice-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("share choice", () => {
+  test("the shortcut opens the public/private choice", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await pressKey(setup, "s", { ctrl: true });
+
+    // Assert
+    await waitForText(setup, "public link");
+    await waitForText(setup, "private link");
+  });
+
+  test("the private choice opens the manage-access surface", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act: open the choice, move to private, select it
+    await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "private link");
+    await press(setup, "down");
+    await press(setup, "enter");
+
+    // Assert
+    await waitForText(setup, "Manage access");
+  });
+
+  test("escape cancels the choice without sharing", async () => {
+    // Arrange
+    const setup = await testRender(
+      <App home={home} sessionId={session.id} shareTransport={shareTransport} />,
+      { width: 120, height: 32 },
+    );
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "public link");
+    await press(setup, "escape");
+
+    // Assert
+    await waitForTextGone(setup, "public link");
+  });
+});

package/src/App.toast.test.tsx

@@ -73,8 +73,10 @@ describe("share toast", () => {
 
     await waitForText(setup, "cueloop");
 
-    // Act: share raises the toast, then open a composer under it by typing
+    // Act: share opens the choice, enter picks public and raises the toast, then a composer under it
     await pressKey(setup, "s", { ctrl: true });
+    await waitForText(setup, "public link");
+    await press(setup, "enter");
     await waitForText(setup, "share link copied");
     await clickText(setup, "daemon");
     await typeText(setup, "x");

package/src/App.tsx

@@ -15,11 +15,15 @@ import {
   loadConfig,
   persistAuthorName,
   persistDiffView,
+  persistIdentity,
   persistPins,
   type AutoClose,
   type DiffViewMode,
+  type IdentityConfig,
   type QuickAction,
 } from "./config";
+import { resolveDisplayName } from "./attribution";
+import { resolveGithubIdentity } from "./github-identity";
 import { loadSkills, PaletteNamesContext, SlashSkillsContext } from "./skills";
 import { mergeSlashItems, slashItemsFrom, type SlashItem } from "./slash-palette";
 import {
@@ -38,6 +42,7 @@ import { KeyBindings, type CheatsheetSection } from "./key-bindings";
 import { useReadySignal } from "./ready-signal";
 import { ThemeProvider } from "./components/theme-context";
 import { Button } from "./components/primitives/Button";
+import { ShareChoiceDialog, SHARE_CHOICES } from "./components/ShareChoiceDialog";
 import { Toolbar } from "./components/primitives/Toolbar";
 import { groupInbox, projectName, threadTitle } from "./components/session-tree";
 import { ThreadTree } from "./components/ThreadTree";
@@ -52,6 +57,7 @@ import { useRememberLayout } from "./use-remember-layout";
 import type { LaunchLayout } from "./launch-layout";
 import { ThreadFooter } from "./components/ThreadFooter";
 import { ConfirmCard } from "./components/ConfirmCard";
+import { ManageAccessDialog } from "./components/ManageAccessDialog";
 import { THREAD_VIEW_CHEATSHEET, ThreadView } from "./components/ThreadView";
 import {
   diffChordEntries,
@@ -67,7 +73,7 @@ import {
 import { type DiffFoldControls } from "./components/DiffContentView";
 import { commentCountsByFile } from "./view-diff";
 import { annotationTarget } from "@cueloop/schema";
-import type { Artifact, DiffFileContents, Thread } from "@cueloop/schema";
+import type { Annotation, Artifact, DiffFileContents, Identity, Thread } from "@cueloop/schema";
 import { PrototypePixels } from "./prototype-pixels";
 import type { PrototypeElement } from "./prototype-browser";
 import {
@@ -139,6 +145,11 @@ function menuChromeOpen(menuDialog: "keybinds" | "settings" | null): boolean {
   return menuDialog !== null;
 }
 
+/** The private-share allowlist for a session, or an empty list for a public one. */
+function allowedGithubLogins(session: Thread | null): string[] {
+  return session?.access?.githubLogins ?? [];
+}
+
 /** The drop-up chrome or a floating popover menu (thread actions, editor split) holds the keyboard. */
 function keyboardHeldByMenu(
   menuDialog: "keybinds" | "settings" | null,
@@ -184,11 +195,89 @@ function keyboardOwnedElsewhere(menuOwnsKeyboard: boolean, overlay: KeyState["ov
   return menuOwnsKeyboard || overlay !== "none";
 }
 
+/** The highlighted share option, or the public default when the choice is closed. */
+function shareChoiceIndex(mode: Mode): number {
+  return mode.type === "shareChoice" ? mode.index : 0;
+}
+
+interface ShareChoiceActions {
+  setMode: (mode: Mode) => void;
+  isOwner: boolean;
+  publish: () => void;
+  openManageAccess: () => void;
+}
+
+/** Move the share-choice highlight by one row, clamped to the list. */
+function movedShareChoice(index: number, delta: number): Mode {
+  const next = Math.min(SHARE_CHOICES.length - 1, Math.max(0, index + delta));
+
+  return { type: "shareChoice", index: next };
+}
+
+/** Commit the highlighted share option: public publishes a link, private opens manage-access. */
+function commitShareChoice(index: number, actions: ShareChoiceActions): void {
+  const picked = SHARE_CHOICES[index]?.choice;
+
+  actions.setMode({ type: "normal" });
+
+  if (!actions.isOwner) return;
+
+  if (picked === "private") actions.openManageAccess();
+  else actions.publish();
+}
+
+/** Route one key to the open share choice: escape cancels, arrows move, enter commits. */
+function handleShareChoiceKey(
+  index: number,
+  key: { name: string },
+  actions: ShareChoiceActions,
+): void {
+  if (key.name === "escape") return actions.setMode({ type: "normal" });
+
+  if (key.name === "down" || key.name === "j") return actions.setMode(movedShareChoice(index, 1));
+
+  if (key.name === "up" || key.name === "k") return actions.setMode(movedShareChoice(index, -1));
+
+  if (key.name === "return" || key.name === "enter") commitShareChoice(index, actions);
+}
+
+/**
+ * An app-level dialog owns the keyboard while open: the manage-access dialog takes its own keys,
+ * and the share choice moves the highlight, commits on enter, and cancels on escape. Returns true
+ * when a dialog consumed the key so the caller stops the grammar.
+ */
+function appDialogOwnsKey(
+  accessDialogOpen: boolean,
+  mode: Mode,
+  key: { name: string },
+  actions: ShareChoiceActions,
+): boolean {
+  if (accessDialogOpen) return true;
+
+  if (mode.type !== "shareChoice") return false;
+
+  handleShareChoiceKey(mode.index, key, actions);
+
+  return true;
+}
+
 /** The footer submit fires only for the owner of an unresolved review, never an observer. */
 function canSubmitReview(isOwner: boolean, resolved: boolean, observer: boolean): boolean {
   return isOwner && !resolved && !observer;
 }
 
+/** The author display name for a comment's hover tooltip: the reviewer's own name for their notes, else the resolved collaborator name. */
+function authorLabelResolver(
+  ownName: string | undefined,
+  participants: Identity[] | undefined,
+  overrides: Record<string, string>,
+): (annotation: Annotation) => string | undefined {
+  return (annotation) =>
+    annotation.author === undefined
+      ? (ownName ?? "you")
+      : resolveDisplayName(annotation.author, participants, overrides);
+}
+
 /** The Project pane body: the resolved repo's changed files in changes mode, its full tree otherwise. */
 function ProjectPanelBody(props: {
   mode: ProjectPanelMode;
@@ -505,6 +594,7 @@ export function App({
   const [mode, setMode] = useState<Mode>({ type: "normal" });
   // the top-left settings gear drop-down and the centered dialog it opens
   const [menuDialog, setMenuDialog] = useState<"keybinds" | "settings" | null>(null);
+  const [accessDialogOpen, setAccessDialogOpen] = useState(false);
   const [autoClose, setAutoClose] = useState<AutoClose>("off");
   // unified or side-by-side diff; split only lays out when the Changes pane is zoomed
   const [diffView, setDiffView] = useState<DiffViewMode>("split");
@@ -526,6 +616,7 @@ export function App({
   const [themeName, setThemeName] = useState<ThemeName>(DEFAULT_THEME_NAME);
   const [themeOverrides, setThemeOverrides] = useState<Partial<Theme>>({});
   const [authorNames, setAuthorNames] = useState<Record<string, string>>({});
+  const [identity, setIdentity] = useState<IdentityConfig>({ provider: "typed" });
   const [quickActions, setQuickActions] = useState<QuickAction[]>(DEFAULT_QUICK_ACTIONS);
   const [skills, setSkills] = useState<SlashItem[]>([]);
   const paletteNames = useMemo(
@@ -545,6 +636,7 @@ export function App({
     setThemeName(config.ui.theme);
     setThemeOverrides(config.themeOverrides);
     setAuthorNames(config.authors);
+    setIdentity(config.identity);
     setQuickActions(config.actions);
     setSkills(loadSkills(config.skillsPath));
     setAutoClose(config.ui.autoClose);
@@ -578,6 +670,29 @@ export function App({
     if (!known) setMode({ type: "nameSelf", text: "" });
   }, [role, selfAuthor, session]);
 
+  // Bumped on every identity change so a slow GitHub sync that lands after a newer rename is discarded.
+  const identityGenerationRef = useRef(0);
+  const applyIdentity = (next: IdentityConfig): void => {
+    identityGenerationRef.current += 1;
+    setIdentity(next);
+    try {
+      persistIdentity(next);
+    } catch {
+      controller.setStatus("could not save identity to config");
+    }
+  };
+  const syncGithubIdentity = (): void => {
+    const generation = (identityGenerationRef.current += 1);
+    void resolveGithubIdentity().then((github) => {
+      if (identityGenerationRef.current !== generation) return;
+      if (!github) return controller.setStatus("GitHub not connected - run gh auth login");
+      const name = github.name?.trim() || github.login;
+
+      applyIdentity({ name, provider: "github" });
+      controller.setStatus(`identity synced from GitHub - ${name}`);
+    });
+  };
+
   // ── settings dialog: config-backed model, navigation, persistence ──
   const {
     settingsNav,
@@ -600,6 +715,13 @@ export function App({
     quickActions,
     setQuickActions,
     setMenuDialog,
+    identityName: identity.name,
+    identityProvider: identity.provider,
+    onSyncGithubIdentity: syncGithubIdentity,
+    onRenameDisplayName: () => {
+      setMenuDialog(null);
+      setMode({ type: "renameSelf", text: identity.name ?? "" });
+    },
   });
 
   // ── derived view model ──────────────────────
@@ -718,6 +840,9 @@ export function App({
       setAuthorNames((prev) => ({ ...prev, [id]: name }));
     },
     renameThread: (id: string, title: string) => controller.renameSession(id, title),
+    setLocalIdentityName: (name: string) => {
+      applyIdentity(name ? { name, provider: "typed" } : { provider: "typed" });
+    },
     liveInput,
     setCursor,
     setInboxCursor,
@@ -746,8 +871,8 @@ export function App({
 
   const menuControl = useMenuControlState();
   const menuOwnsKeyboard = keyboardHeldByMenu(menuDialog, menuControl.openMenuId);
-  // an overlay (submit, walk, prompt, confirm) or the menu takes the keyboard
-  // from the thread view; the view suspends its own grammar meanwhile
+  // an overlay (submit, walk, prompt, confirm, share choice) or the menu takes the
+  // keyboard from the thread view; the view suspends its own grammar meanwhile
   const threadViewSuspended = keyboardOwnedElsewhere(menuOwnsKeyboard, overlay);
 
   const leaderCombos = leaderCombosFor(keysRef.current.leader);
@@ -787,6 +912,16 @@ export function App({
 
   useKeyboard((key) => {
     if (quitKeyHandled(key, onExit)) return;
+    // an app-level dialog (manage-access, share choice) owns the keyboard while open
+    if (
+      appDialogOwnsKey(accessDialogOpen, mode, key, {
+        setMode,
+        isOwner,
+        publish: () => controller.share(),
+        openManageAccess: () => setAccessDialogOpen(true),
+      })
+    )
+      return;
     if (menuModalHandled(menuControl, key)) return;
     if (
       appLeaderHandled({ focusedPane, key, leaderCombos, pending: leaderPending, runLeaderCommand })
@@ -919,6 +1054,11 @@ export function App({
     );
 
   const activeSession = session;
+  const resolveAuthorLabel = authorLabelResolver(
+    identity.name,
+    activeSession.participants,
+    authorNames,
+  );
 
   if (isCompletionOverlayPhase(completion) && activeSession.verdict)
     return (
@@ -968,12 +1108,19 @@ export function App({
     runEditorHandOff();
   };
 
-  // clicking the header Share button: publish the plan, copy the ssh line
+  // the share choice's public option: publish the plan, copy the ssh line
   const onShareRequest = (): void => {
     if (!isOwner) return controller.setStatus("only the plan owner can share");
     controller.share();
   };
 
+  // the share choice's private option opens the manage-access allowlist surface
+  const onPrivateShareRequest = (): void => {
+    if (!isOwner) return controller.setStatus("only the plan owner can share");
+    setAccessDialogOpen(true);
+  };
+  const allowedLogins = allowedGithubLogins(session);
+
   // clicking the rail Submit button: same read-only answer as the submit key
   const onSubmitRequest = (): void => {
     if (observer) return controller.setStatus("observer - read-only");
@@ -1027,7 +1174,7 @@ export function App({
                     <Button onPress={onEditRequest} theme={theme}>
                       {" edit "}
                     </Button>
-                    <Button onPress={onShareRequest} theme={theme}>
+                    <Button onPress={() => dispatch({ type: "share" })} theme={theme}>
                       {" share "}
                     </Button>
                   </Toolbar>
@@ -1092,6 +1239,7 @@ export function App({
                           void controller.reply(rootAnnotationId, body)
                         }
                         onUpdateAnnotation={(id, body) => controller.updateAnnotation(id, body)}
+                        resolveAuthorLabel={resolveAuthorLabel}
                         onExit={() => onExit?.(0)}
                       />
                     )}
@@ -1160,6 +1308,7 @@ export function App({
                         onReply: (rootAnnotationId, body) =>
                           void controller.reply(rootAnnotationId, body),
                         onUpdateAnnotation: (id, body) => controller.updateAnnotation(id, body),
+                        resolveAuthorLabel,
                         leaderCombos,
                         onLeaderCommand: runLeaderCommand,
                         onExit: () => onExit?.(0),
@@ -1231,6 +1380,28 @@ export function App({
                   </box>
                 </box>
               ) : null}
+              <ManageAccessDialog
+                isOpen={accessDialogOpen}
+                logins={allowedLogins}
+                onAdd={(login) => controller.setShareAccess([...allowedLogins, login])}
+                onRemove={(login) =>
+                  controller.setShareAccess(allowedLogins.filter((entry) => entry !== login))
+                }
+                onCreateLink={() => {
+                  setAccessDialogOpen(false);
+                  controller.share();
+                }}
+                onClose={() => setAccessDialogOpen(false)}
+                theme={theme}
+              />
+              <ShareChoiceDialog
+                isOpen={mode.type === "shareChoice"}
+                selectedIndex={shareChoiceIndex(mode)}
+                onPublicShare={onShareRequest}
+                onPrivateShare={onPrivateShareRequest}
+                onClose={() => setMode({ type: "normal" })}
+                theme={theme}
+              />
               {menuChrome}
             </AppShell>
           </MenuControlProvider>

package/src/app-screens.tsx

@@ -532,6 +532,19 @@ export function TrailingOverlays(props: {
           theme={theme}
         />
       ) : null}
+      {mode.type === "renameSelf" ? (
+        <PromptDialog
+          isOpen
+          title=" Display name "
+          label="Your display name - it attributes the notes you leave:"
+          value={mode.text}
+          placeholder="your name"
+          onInput={(text) => setMode({ ...mode, text })}
+          onSave={() => dispatch({ type: "confirmDialog" })}
+          onCancel={() => setMode({ type: "normal" })}
+          theme={theme}
+        />
+      ) : null}
       {mode.type === "treePrompt" ? (
         <PromptDialog
           isOpen

package/src/app-view-model.ts

@@ -57,6 +57,7 @@ export function resolveOverlay(
     mode.type === "treePrompt"
   )
     return "prompt";
+  if (mode.type === "shareChoice") return "shareChoice";
   if (mode.type === "spanActions") return "spanActions";
   if (completionPhase === "prompt") return "completion-prompt";
   if (completionPhase === "counting") return "completion-counting";

package/src/components/AnnotatableFileView.tsx

@@ -4,7 +4,13 @@
 // hold the notes; the bare-launch welcome shell uses the read-only FileContentsView instead.
 
 import React, { useEffect, useRef, useState } from "react";
-import { makeAnchor, annotationTarget, type Anchor, type Thread } from "@cueloop/schema";
+import {
+  makeAnchor,
+  annotationTarget,
+  type Anchor,
+  type Annotation,
+  type Thread,
+} from "@cueloop/schema";
 import type { Theme } from "../theme";
 import type { QuickAction } from "../config";
 import { useComponentTheme } from "./theme-context";
@@ -28,6 +34,7 @@ export interface AnnotatableFileViewProps {
   onAddComment: (anchor: Anchor, body: string) => void;
   onReply: (rootAnnotationId: string, body: string) => void;
   onUpdateAnnotation: (id: string, body: string) => void;
+  resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
   onExit: () => void;
   theme?: Theme;
 }
@@ -119,6 +126,7 @@ export function AnnotatableFileView(props: AnnotatableFileViewProps): React.Reac
       }
       onReply={props.onReply}
       onUpdateAnnotation={props.onUpdateAnnotation}
+      resolveAuthorLabel={props.resolveAuthorLabel}
       onExit={props.onExit}
       theme={props.theme}
     />

package/src/components/AnnotationCards.tsx

@@ -7,9 +7,15 @@
  */
 
 import React, { useContext, useLayoutEffect, useRef, useState } from "react";
-import type { BoxRenderable, KeyBinding, TextareaRenderable } from "@opentui/core";
+import type {
+  BoxRenderable,
+  KeyBinding,
+  MouseEvent as TerminalMouseEvent,
+  TextareaRenderable,
+} from "@opentui/core";
 import type { Annotation } from "@cueloop/schema";
 import type { Theme } from "../theme";
+import { useTooltip } from "./Tooltip";
 import { lighten } from "../annotation-palette";
 import { useFrameMeasure } from "../use-frame-measure";
 import { skillReferenceRanges, type SlashItem } from "../slash-palette";
@@ -281,22 +287,34 @@ export function DiscussionCard({
 export function CommentRow({
   annotation,
   tokens,
+  authorLabel,
 }: {
   annotation: Annotation;
   tokens: Theme;
+  /** The author's resolved display name, shown as a tooltip when the dot is hovered. */
+  authorLabel?: string;
 }): React.ReactNode {
   // own comments (no author) wear the filled dot, collaborators the outline
   const own = annotation.author === undefined;
   const glyph = own ? "●" : "○";
   const glyphColor = own ? tokens.text : tokens.textMuted;
+  const { showTooltip, hideTooltip } = useTooltip();
+  const dotHover = authorLabel
+    ? {
+        onMouseOver: (event: TerminalMouseEvent) => showTooltip(authorLabel, event.x, event.y),
+        onMouseOut: hideTooltip,
+      }
+    : {};
 
   return (
     <box style={{ flexDirection: "column" }}>
       {annotation.body.split("\n").map((line, lineIndex) => (
         <box key={lineIndex} style={{ flexDirection: "row" }}>
-          <text selectable={false} fg={glyphColor} style={{ flexShrink: 0 }}>
-            {lineIndex === 0 ? `${glyph} ` : "  "}
-          </text>
+          <box style={{ flexShrink: 0 }} {...(lineIndex === 0 ? dotHover : {})}>
+            <text selectable={false} fg={glyphColor}>
+              {lineIndex === 0 ? `${glyph} ` : "  "}
+            </text>
+          </box>
           <text fg={tokens.text} style={{ wrapMode: "word", flexGrow: 1, flexShrink: 1 }}>
             {line}
           </text>