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

package/src/config-identity.test.ts

@@ -0,0 +1,78 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig, persistIdentity } from "./config";
+
+function withTempConfig(run: (path: string) => void): void {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-config-"));
+
+  try {
+    run(join(directory, "config.toml"));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+test("defaults identity to a typed provider with no name", () => {
+  withTempConfig((path) => {
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({ provider: "typed" });
+  });
+});
+
+test("persists and reloads a GitHub-synced identity", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "Markus M", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "Markus M",
+      provider: "github",
+    });
+  });
+});
+
+test("rewrites the identity block in place on a re-sync", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "typed name", provider: "typed" }, path);
+    persistIdentity({ name: "markus", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "markus",
+      provider: "github",
+    });
+  });
+});
+
+test("a display name containing a bracket survives a re-sync without corrupting the config", () => {
+  withTempConfig((path) => {
+    persistIdentity({ name: "Alice [Smith]", provider: "typed" }, path);
+    persistIdentity({ name: "Bob", provider: "github" }, path);
+
+    expect(loadConfig({ userConfigPath: path }).identity).toEqual({
+      name: "Bob",
+      provider: "github",
+    });
+  });
+});
+
+test("repository config cannot forge the reviewer identity", () => {
+  withTempConfig((userPath) => {
+    persistIdentity({ name: "Me", provider: "typed" }, userPath);
+    const repoRoot = mkdtempSync(join(tmpdir(), "cueloop-repo-"));
+
+    try {
+      mkdirSync(join(repoRoot, ".cueloop"), { recursive: true });
+      writeFileSync(
+        join(repoRoot, ".cueloop", "config.toml"),
+        '[identity]\nname = "Forged"\nprovider = "github"\n',
+      );
+
+      expect(loadConfig({ userConfigPath: userPath, repoRoot }).identity).toEqual({
+        name: "Me",
+        provider: "typed",
+      });
+    } finally {
+      rmSync(repoRoot, { recursive: true, force: true });
+    }
+  });
+});

package/src/config.ts

@@ -114,6 +114,8 @@ export interface CueloopConfig {
   };
   /** Planner-local author renames: identity id → display name ([authors] table). */
   authors: Record<string, string>;
+  /** The local reviewer's own display name, and whether it was typed or synced from GitHub ([identity] table). */
+  identity: IdentityConfig;
   /** Marker-popover quick actions ([[actions]] tables); the 5 defaults when unset. */
   actions: QuickAction[];
   /** Directory of user-level skills surfaced in the "/" palette ([skills] path); ~/.agents/skills default. */
@@ -128,6 +130,15 @@ export interface ExperimentalConfig {
   prototypePixels: boolean;
 }
 
+/** Where a display name came from: typed by the user, or verified from a GitHub login. */
+export type IdentityProvider = "typed" | "github";
+
+export interface IdentityConfig {
+  /** The reviewer's own display name; absent until they set or sync one. */
+  name?: string;
+  provider: IdentityProvider;
+}
+
 /** Every action in the grammar, with its default binding(s). */
 export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   down: ["j", "down"],
@@ -166,6 +177,7 @@ function skillsPathFrom(
 const ConfigDocumentSchema = v.object({
   actions: v.optional(v.array(v.unknown())),
   authors: v.optional(v.unknown()),
+  identity: v.optional(v.unknown()),
   integrations: v.optional(v.unknown()),
   keys: v.optional(v.unknown()),
   theme: v.optional(v.unknown()),
@@ -174,6 +186,11 @@ const ConfigDocumentSchema = v.object({
   skills: v.fallback(v.optional(SkillsSectionSchema), undefined),
 });
 
+const IdentitySchema = v.object({
+  name: v.fallback(v.optional(v.string()), undefined),
+  provider: v.fallback(v.optional(v.picklist(["typed", "github"])), undefined),
+});
+
 const QuickActionSchema = v.object({
   prompt: v.pipe(
     v.string(),
@@ -275,6 +292,7 @@ function applyUi(ui: CueloopConfig["ui"], parsed: v.InferOutput<typeof UiSchema>
 function layer(
   base: CueloopConfig,
   raw: v.InferOutput<typeof ConfigDocumentSchema>,
+  allowIdentity: boolean,
 ): CueloopConfig {
   const out: CueloopConfig = {
     keys: { ...base.keys },
@@ -282,6 +300,7 @@ function layer(
     themeOverrides: { ...base.themeOverrides },
     ui: { ...base.ui },
     authors: { ...base.authors },
+    identity: { ...base.identity },
     actions: [...base.actions],
     skillsPath: base.skillsPath,
     integrations: { obsidian: { ...base.integrations.obsidian } },
@@ -289,6 +308,7 @@ function layer(
   };
   const actions = parseActions(raw.actions);
   const authors = v.safeParse(AuthorsSchema, raw.authors);
+  const identity = v.safeParse(IdentitySchema, raw.identity);
   const keys = v.safeParse(KeysSchema, raw.keys);
   const ui = v.safeParse(UiSchema, raw.ui);
   const integrations = v.safeParse(IntegrationsSchema, raw.integrations);
@@ -311,6 +331,11 @@ function layer(
         out.keys[action] = Array.isArray(combo.output) ? combo.output : [combo.output];
     }
   }
+  // The reviewer identity is a personal credential; a repo must never forge a verified name.
+  if (allowIdentity && identity.success) {
+    if (identity.output.name !== undefined) out.identity.name = identity.output.name;
+    if (identity.output.provider !== undefined) out.identity.provider = identity.output.provider;
+  }
   if (ui.success) applyUi(out.ui, ui.output);
   if (integrations.success && integrations.output.obsidian) {
     mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
@@ -336,6 +361,7 @@ export function loadConfig(
       pins: [],
     },
     authors: {},
+    identity: { provider: "typed" },
     actions: [...DEFAULT_QUICK_ACTIONS],
     skillsPath: join(homedir(), ".agents", "skills"),
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
@@ -357,7 +383,7 @@ export function loadConfig(
     try {
       const raw = parseToml(readFileSync(path, "utf8"));
 
-      config = layer(config, raw);
+      config = layer(config, raw, path === userPath);
       const ui = v.safeParse(UiSchema, raw.ui);
       const rawTheme = ui.success ? ui.output.theme : undefined;
       const parsedThemeOverrides = v.safeParse(ThemeOverridesSchema, raw.theme);
@@ -459,6 +485,23 @@ export function persistActions(actions: QuickAction[], userConfigPath?: string):
   writeFileSync(path, text);
 }
 
+/** Persist the reviewer's own display name and its provider (`[identity]`) into the user config. */
+export function persistIdentity(identity: IdentityConfig, userConfigPath?: string): void {
+  const path = userConfigPathFrom(userConfigPath);
+  let text = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const nameLine = identity.name === undefined ? "" : `name = ${tomlString(identity.name)}\n`;
+  const block = `[identity]\n${nameLine}provider = ${tomlString(identity.provider)}\n`;
+
+  if (/^\[identity\]/m.test(text)) {
+    // Consume the header and its assignment lines only, so a bracket in a quoted name cannot truncate the block.
+    text = text.replace(/^\[identity\].*(?:\n(?![[\n]).*)*\n?/m, block);
+  } else {
+    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + block;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}
+
 /** Persist the auto-close choice (`[ui] auto_close`) into the user config. */
 export function persistAutoClose(value: AutoClose, userConfigPath?: string): void {
   persistUiSetting("auto_close", value === "off" ? '"off"' : String(value), userConfigPath);

package/src/github-identity.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, expect, test } from "bun:test";
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveGithubIdentity } from "./github-identity";
+
+const originalBinary = process.env.CUELOOP_GH;
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+  if (originalBinary === undefined) delete process.env.CUELOOP_GH;
+  else process.env.CUELOOP_GH = originalBinary;
+  for (const directory of tempDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+function stubGithubCli(script: string): string {
+  const directory = mkdtempSync(join(tmpdir(), "gh-stub-"));
+
+  tempDirectories.push(directory);
+  const path = join(directory, "gh");
+
+  writeFileSync(path, `#!/bin/sh\n${script}\n`);
+  chmodSync(path, 0o755);
+
+  return path;
+}
+
+test("reads the GitHub login and name from gh", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`printf '{"login":"markus","name":"Markus M"}'`);
+
+  expect(await resolveGithubIdentity()).toEqual({ login: "markus", name: "Markus M" });
+});
+
+test("drops a null name to undefined", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`printf '{"login":"markus","name":null}'`);
+
+  expect(await resolveGithubIdentity()).toEqual({ login: "markus" });
+});
+
+test("falls back to null when gh exits non-zero (logged out)", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`exit 1`);
+
+  expect(await resolveGithubIdentity()).toBeNull();
+});
+
+test("falls back to null when gh is not installed", async () => {
+  process.env.CUELOOP_GH = join(tmpdir(), "cueloop-absent-gh-binary");
+
+  expect(await resolveGithubIdentity()).toBeNull();
+});
+
+test("falls back to null when gh prints an unexpected shape", async () => {
+  process.env.CUELOOP_GH = stubGithubCli(`printf 'not json'`);
+
+  expect(await resolveGithubIdentity()).toBeNull();
+});

package/src/github-identity.ts

@@ -0,0 +1,41 @@
+/** The signed-in GitHub identity from the local gh tool, or null when gh cannot answer. */
+
+import * as v from "valibot";
+
+export interface GithubIdentity {
+  login: string;
+  name?: string;
+}
+
+const GithubUserSchema = v.object({
+  login: v.string(),
+  name: v.nullish(v.string()),
+});
+
+/** The gh binary is injectable so tests stub it without a real GitHub login. */
+function githubCliBinary(): string {
+  return process.env.CUELOOP_GH || "gh";
+}
+
+/** Read the authenticated GitHub login and name, or null when gh cannot answer. */
+export async function resolveGithubIdentity(): Promise<GithubIdentity | null> {
+  try {
+    const githubProcess = Bun.spawn(
+      [githubCliBinary(), "api", "user", "--jq", "{login: .login, name: .name}"],
+      { stdout: "pipe", stderr: "ignore" },
+    );
+    const [output, exitCode] = await Promise.all([
+      new Response(githubProcess.stdout).text(),
+      githubProcess.exited,
+    ]);
+
+    if (exitCode !== 0) return null;
+    const parsed = v.safeParse(GithubUserSchema, JSON.parse(output));
+
+    if (!parsed.success) return null;
+
+    return { login: parsed.output.login, name: parsed.output.name ?? undefined };
+  } catch {
+    return null;
+  }
+}

package/src/intent-dispatch.test.ts

@@ -108,6 +108,7 @@ function baseController(): ReviewController {
     walkLeave: mock(),
     submit: mock(),
     share: mock(),
+    setShareAccess: mock(),
     treeRows: mock(() => []),
     goToEntry: mock(),
     branch: mock(),
@@ -143,6 +144,7 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     quickActions: [],
     renameAuthor: mock(),
     renameThread: mock(),
+    setLocalIdentityName: mock(),
     liveInput: { current: "" },
     setCursor: mock(),
     setInboxCursor: mock(),
@@ -383,7 +385,7 @@ describe("openSubmit", () => {
 });
 
 describe("share", () => {
-  test("dispatches to the controller's share", () => {
+  test("opens the public/private choice overlay instead of publishing directly", () => {
     // Arrange
     const deps = makeDeps();
     const dispatch = createIntentDispatch(deps);
@@ -392,7 +394,8 @@ describe("share", () => {
     dispatch({ type: "share" });
 
     // Assert
-    expect(deps.controller.share).toHaveBeenCalled();
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "shareChoice", index: 0 });
+    expect(deps.controller.share).not.toHaveBeenCalled();
   });
 });
 
@@ -547,6 +550,18 @@ describe("rename author", () => {
     expect(deps.renameAuthor).toHaveBeenCalledWith("SHA256:x", "Alex");
     expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
   });
+
+  test("confirmDialog in renameSelf mode sets the trimmed local identity name and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "renameSelf", text: "  Robin  " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.setLocalIdentityName).toHaveBeenCalledWith("Robin");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
 });
 
 describe("collaborator self-name", () => {

package/src/intent-dispatch.ts

@@ -39,6 +39,8 @@ export type Mode =
   | { type: "rename"; authorId: string; text: string }
   | { type: "renameThread"; sessionId: string; text: string }
   | { type: "nameSelf"; text: string }
+  | { type: "renameSelf"; text: string }
+  | { type: "shareChoice"; index: number }
   | { type: "treePrompt"; ask: TreeAsk; entryId?: string; text: string };
 
 /** What a tree prompt asks for: a branch name, a checkpoint name, or the summary a move back leaves. */
@@ -98,6 +100,8 @@ export interface IntentDispatchDeps {
   renameAuthor: (id: string, name: string) => void;
   /** Rename a thread's title through the daemon. */
   renameThread: (id: string, title: string) => void;
+  /** Set the local reviewer's typed display name and persist it (App-owned). */
+  setLocalIdentityName: (name: string) => void;
 
   liveInput: MutableRefObject<string>;
 
@@ -238,6 +242,7 @@ function handleConfirmDialog(
   else if (mode.type === "rename") deps.renameAuthor(mode.authorId, mode.text.trim());
   else if (mode.type === "renameThread") deps.renameThread(mode.sessionId, mode.text.trim());
   else if (mode.type === "nameSelf") controller.setSelfName(mode.text.trim());
+  else if (mode.type === "renameSelf") deps.setLocalIdentityName(mode.text.trim());
   else if (mode.type === "treePrompt") confirmTreePrompt(mode, deps);
   deps.setMode({ type: "normal" });
 }
@@ -381,8 +386,9 @@ function handleOpenSubmit(_intent: IntentOfType<"openSubmit">, deps: IntentDispa
   deps.setMode({ type: "submit", verdict: defaultVerdict(session), summary: "" });
 }
 
+// share opens the public/private choice overlay; the App owns the choice keys and publishes on pick
 function handleShare(_intent: IntentOfType<"share">, deps: IntentDispatchDeps): void {
-  deps.controller.share();
+  deps.setMode({ type: "shareChoice", index: 0 });
 }
 
 function handleCut(_intent: IntentOfType<"cut">, deps: IntentDispatchDeps): void {

package/src/keymap.ts

@@ -87,6 +87,7 @@ export interface KeyState {
     | "submit"
     | "confirm"
     | "prompt"
+    | "shareChoice"
     | "spanActions"
     | "completion-prompt"
     | "completion-counting";

package/src/share.ts

@@ -12,7 +12,13 @@ import {
   SHARE_UPLOAD_USER,
   packSessionBlob,
 } from "@cueloop/daemon/share-blob";
-import { removalEntries, viewFollowing, type Annotation, type Thread } from "@cueloop/schema";
+import {
+  removalEntries,
+  viewFollowing,
+  type Annotation,
+  type ShareAccess,
+  type Thread,
+} from "@cueloop/schema";
 import { ThreadRecordSchema } from "@cueloop/daemon/validate";
 import type { SharedMerge } from "@cueloop/daemon/client";
 import * as v from "valibot";
@@ -102,11 +108,13 @@ export function mergeFromShare(remote: Thread): SharedMerge {
 export async function pushShare(
   shareId: string,
   annotations: Array<Omit<Annotation, "createdAt">>,
+  access?: ShareAccess,
   target: ShareTarget = {},
 ): Promise<void> {
+  const payload = access ? { shareId, annotations, access } : { shareId, annotations };
   const { stderr, code } = await runShareSsh(
     "cueloop-push",
-    Buffer.from(JSON.stringify({ shareId, annotations })),
+    Buffer.from(JSON.stringify(payload)),
     target,
   );
 

package/src/thread-controller.curate.test.ts

@@ -109,6 +109,7 @@ function fakeClient(initial: Thread, sink: WorkingCopySink): SessionClient {
 
       return session;
     }),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
     sessionNavigate: unimplemented("sessionNavigate"),
     sessionBranch: unimplemented("sessionBranch"),
     sessionSwitch: unimplemented("sessionSwitch"),

package/src/thread-controller.live-diff.test.ts

@@ -73,6 +73,7 @@ function fakeClient(session: Thread): SessionClient {
     sessionCutBlock: unimplemented("sessionCutBlock"),
     sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
     sessionCurate: unimplemented("sessionCurate"),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
     sessionNavigate: unimplemented("sessionNavigate"),
     sessionBranch: unimplemented("sessionBranch"),
     sessionSwitch: unimplemented("sessionSwitch"),

package/src/thread-controller.share.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test, type Mock } from "bun:test";
 import { ManualClock } from "@opentui/core/testing";
-import { SCHEMA_VERSION, type Annotation, type Thread } from "@cueloop/schema";
+import { SCHEMA_VERSION, type Annotation, type ShareAccess, type Thread } from "@cueloop/schema";
 import type { SessionClient } from "@cueloop/daemon/client";
 import {
   createReviewController,
@@ -14,7 +14,11 @@ const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", cop
 let remote: Thread;
 const pullShare = mock(async () => remote);
 const pushShare = mock(
-  async (_shareId: string, _annotations: Array<Omit<Annotation, "createdAt">>) => {},
+  async (
+    _shareId: string,
+    _annotations: Array<Omit<Annotation, "createdAt">>,
+    _access?: ShareAccess,
+  ) => {},
 );
 
 const shareTransport: ShareTransport = {
@@ -73,6 +77,7 @@ function fakeClient(session: Thread): FakeSessionClient {
     sessionCutBlock: unimplemented("sessionCutBlock"),
     sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
     sessionCurate: unimplemented("sessionCurate"),
+    sessionSetAccess: mock(async () => session),
     sessionNavigate: unimplemented("sessionNavigate"),
     sessionBranch: unimplemented("sessionBranch"),
     sessionSwitch: unimplemented("sessionSwitch"),
@@ -149,6 +154,35 @@ describe("share", () => {
   });
 });
 
+describe("setShareAccess", () => {
+  test("pushes the allowlist up to the gateway when the plan is already shared", async () => {
+    // Arrange
+    pushShare.mockClear();
+    const { controller } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }));
+
+    // Act
+    controller.setShareAccess(["octocat"]);
+    await tick();
+
+    // Assert - the existing link must enforce the new access, so it rides the push
+    expect(pushShare.mock.calls[0]?.[0]).toBe("p_abc123xy");
+    expect(pushShare.mock.calls[0]?.[2]).toEqual({ githubLogins: ["octocat"] });
+  });
+
+  test("does not push when the plan was never shared", async () => {
+    // Arrange
+    pushShare.mockClear();
+    const { controller } = await connectedController(sessionFixture());
+
+    // Act
+    controller.setShareAccess(["octocat"]);
+    await tick();
+
+    // Assert
+    expect(pushShare).not.toHaveBeenCalled();
+  });
+});
+
 describe("pullShared", () => {
   test("unions collaborator notes and identities in when the plan was shared", async () => {
     // Arrange

package/src/thread-controller.tree.test.ts

@@ -82,6 +82,7 @@ function fakeClient(session: Thread) {
     sessionCutBlock: unimplemented("sessionCutBlock"),
     sessionRestoreBlock: unimplemented("sessionRestoreBlock"),
     sessionCurate: unimplemented("sessionCurate"),
+    sessionSetAccess: unimplemented("sessionSetAccess"),
     sessionNavigate: mock(pending),
     sessionBranch: mock(pending),
     sessionSwitch: mock(pending),

package/src/thread-controller.ts

@@ -309,6 +309,8 @@ export interface ReviewController {
   submit(verdict: VerdictKind, summary: string): void;
   /** Publish the current session as a share; the ssh line lands on the clipboard. */
   share(): void;
+  /** Replace the private-share allowlist of GitHub logins for the current session. Owner only. */
+  setShareAccess(githubLogins: string[]): void;
   /** The session tree as rows for the rail's Tree tab, cached per session identity. */
   treeRows(): TreeRow[];
   /**
@@ -882,6 +884,18 @@ class Controller implements ReviewController {
     this.applyOptimistic(expected, this.client!.sessionCurate(session.id, rejections));
   }
 
+  setShareAccess(githubLogins: string[]): void {
+    const session = this.snapshot.session;
+
+    if (!session) return;
+    const access = { githubLogins };
+    const expected: Thread = { ...session, access };
+
+    this.applyOptimistic(expected, this.client!.sessionSetAccess(session.id, githubLogins));
+    // an already-shared link must enforce the new access, so push it up to the gateway blob
+    if (session.shareId) void this.shareTransport.push(session.shareId, [], access).catch(() => {});
+  }
+
   rejectedRows(): Set<number> {
     this.ensureDerived();
     if (!this.rejections.length) return EMPTY_REJECTED_ROWS;

package/src/use-annotation-surface.tsx

@@ -15,7 +15,7 @@
 import React, { useContext, useEffect, useRef, useState } from "react";
 import type { KeyEvent, MouseEvent as TerminalMouseEvent, TextRenderable } from "@opentui/core";
 import { useKeyboard } from "@opentui/react";
-import type { Thread } from "@cueloop/schema";
+import type { Annotation, Thread } from "@cueloop/schema";
 import type { Mark } from "./view-plan";
 import type { QuickAction } from "./config";
 import type { Theme } from "./theme";
@@ -104,6 +104,8 @@ export interface AnnotationSurfaceOptions {
   onAnnotate: (span: TextSpan, body: string) => void;
   onReply: (rootAnnotationId: string, body: string) => void;
   onUpdateAnnotation: (id: string, body: string) => void;
+  /** The author's display name for a comment's hover tooltip; the rail resolves it against the participant registry. */
+  resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
   leaderCombos?: readonly string[];
   onLeaderCommand?: (key: KeyEvent) => void;
   onExit: () => void;
@@ -179,6 +181,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     onAnnotate,
     onReply,
     onUpdateAnnotation,
+    resolveAuthorLabel,
     leaderCombos,
     onLeaderCommand,
     onExit,
@@ -735,7 +738,12 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
         node: editingHere ? (
           composerNode
         ) : (
-          <CommentRow key={annotation.id} annotation={annotation} tokens={tokens} />
+          <CommentRow
+            key={annotation.id}
+            annotation={annotation}
+            tokens={tokens}
+            authorLabel={resolveAuthorLabel?.(annotation)}
+          />
         ),
       };
     });

package/src/use-settings-dialog.tsx

@@ -83,6 +83,10 @@ export function useSettingsDialog(params: {
   quickActions: QuickAction[];
   setQuickActions: Dispatch<SetStateAction<QuickAction[]>>;
   setMenuDialog: Dispatch<SetStateAction<"keybinds" | "settings" | null>>;
+  identityName?: string;
+  identityProvider: "typed" | "github";
+  onSyncGithubIdentity: () => void;
+  onRenameDisplayName: () => void;
 }): SettingsDialogModel {
   const {
     theme,
@@ -98,6 +102,10 @@ export function useSettingsDialog(params: {
     quickActions,
     setQuickActions,
     setMenuDialog,
+    identityName,
+    identityProvider,
+    onSyncGithubIdentity,
+    onRenameDisplayName,
   } = params;
 
   const [settingsNav, setSettingsNav] = useState<SettingsNav>({
@@ -157,6 +165,15 @@ export function useSettingsDialog(params: {
         },
       ],
     },
+    {
+      id: "account",
+      name: "Account",
+      rows: [
+        { key: "displayName", label: "Display name", kind: "text" },
+        { key: "identitySource", label: "Source", kind: "text" },
+        { key: "syncGithub", label: "Sync from GitHub", kind: "text" },
+      ],
+    },
     {
       id: "appearance",
       name: "Appearance",
@@ -202,6 +219,9 @@ export function useSettingsDialog(params: {
     autoClose: autoClose === "off" ? "off" : `${autoClose}s`,
     diffView: diffView === "split" ? "Split" : "Stacked",
     theme: THEME_LABELS[themeName],
+    displayName: identityName ?? "-- not set --",
+    identitySource: identityProvider === "github" ? "GitHub" : "typed",
+    syncGithub: "enter to sync",
   };
   const cycleSetting = (rowKey: string): void => {
     if (rowKey === "autoClose") {
@@ -220,6 +240,10 @@ export function useSettingsDialog(params: {
       setThemeName(next);
       setTheme(composeTheme(next, themeOverrides, appearance));
       persistTheme(next);
+    } else if (rowKey === "syncGithub") {
+      onSyncGithubIdentity();
+    } else if (rowKey === "displayName") {
+      onRenameDisplayName();
     }
   };