@cueloop/client 0.1.0-alpha.25 → 0.1.0-alpha.27

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.25",
+  "version": "0.1.0-alpha.27",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.25",
-    "@cueloop/extension-api": "0.1.0-alpha.25",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.25",
-    "@cueloop/schema": "0.1.0-alpha.25",
+    "@cueloop/daemon": "0.1.0-alpha.27",
+    "@cueloop/extension-api": "0.1.0-alpha.27",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.27",
+    "@cueloop/schema": "0.1.0-alpha.27",
     "@opentui/core": "^0.5.1",
     "@opentui/keymap": "0.5.1",
     "@opentui/react": "^0.5.1",

package/src/App.plan-review.test.tsx

@@ -27,9 +27,14 @@ The daemon persists sessions to disk atomically.
 let home: string;
 let server: DaemonServer;
 let session: ReviewSession;
+let priorConfig: string | undefined;
 
 beforeEach(() => {
   home = mkdtempSync(join(tmpdir(), "cueloop-plan-review-"));
+  // Isolate from the dev's real config so the rail state is the default here,
+  // not whatever review_state they last persisted (CI runs clean already).
+  priorConfig = process.env.CUELOOP_CONFIG;
+  process.env.CUELOOP_CONFIG = join(home, "no-config.toml");
   server = new DaemonServer({ home, idleExitMs: 0 });
   server.start();
   session = server.core.sessionCreate({
@@ -38,6 +43,8 @@ beforeEach(() => {
   });
 });
 afterEach(() => {
+  if (priorConfig === undefined) delete process.env.CUELOOP_CONFIG;
+  else process.env.CUELOOP_CONFIG = priorConfig;
   server.stop();
   rmSync(home, { recursive: true, force: true });
 });
@@ -130,6 +137,28 @@ describe("edit affordance", () => {
   });
 });
 
+describe("attribution", () => {
+  test("a collaborator's note shows their name in the card border", async () => {
+    // Arrange - a pulled collaborator note carries an author fingerprint
+    const { makeAnchor, parseBlocks } = await import("@cueloop/schema");
+    const blocks = parseBlocks(PLAN);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("The daemon persists"));
+    server.core.sessionAnnotate(session.id, {
+      id: "collab-1",
+      kind: "comment",
+      anchor: makeAnchor(blocks, contextBlockIndex, 0, 10),
+      body: "who owns retries?",
+      author: "SHA256:1a2b3c4d5e6f",
+    });
+
+    // Act
+    const setup = await renderApp();
+
+    // Assert - the short author handle rides the card border
+    await waitForText(setup, "1a2b3c4d");
+  });
+});
+
 describe("selection feeds the annotation quote", () => {
   test("v anchors, l extends, c composes with the char-precise quote", async () => {
     // Arrange
@@ -335,6 +364,29 @@ describe("the document selects, the rail edits", () => {
     );
   });
 
+  test("activating a collaborator's card opens rename, not a body edit", async () => {
+    // Arrange - a pulled collaborator note carries an author fingerprint
+    const { makeAnchor, parseBlocks } = await import("@cueloop/schema");
+    const blocks = parseBlocks(PLAN);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("The daemon persists"));
+    server.core.sessionAnnotate(session.id, {
+      id: "collab-1",
+      kind: "comment",
+      anchor: makeAnchor(blocks, contextBlockIndex, 0, 10),
+      body: "who owns retries?",
+      author: "SHA256:1a2b3c4d5e6f",
+    });
+    const setup = await renderApp();
+    await waitForText(setup, "1a2b3c4d");
+
+    // Act - focus the collaborator card, then activate it
+    await press(setup, "n");
+    await press(setup, "e");
+
+    // Assert - the rename prompt opens; the body never becomes an editor
+    await waitForText(setup, "Rename author");
+  });
+
   test("x deletes the selected card and un-paints the document highlight", async () => {
     // Arrange
     const setup = await renderApp();

package/src/App.tsx

@@ -16,7 +16,7 @@ import { type VerdictKind } from "@cueloop/schema";
 import { displayText, marksByDisplay, type Mark } from "./view-plan";
 import { noteForFile, viewedCount } from "./walk";
 import { DARK, dimmedTheme } from "./theme";
-import { DEFAULT_KEYS, loadConfig } from "./config";
+import { DEFAULT_KEYS, loadConfig, persistAuthorName } from "./config";
 import { returnPaneFor } from "@cueloop/schema";
 import { createReviewController } from "./session-controller";
 import type { SessionClient } from "@cueloop/daemon/client";
@@ -39,6 +39,8 @@ import {
 } from "./review-panel";
 import { CompletionOverlay } from "./components/CompletionOverlay";
 import { InboxList } from "./components/InboxList";
+import { ConfirmDialog } from "./components/ConfirmDialog";
+import { PromptDialog } from "./components/PromptDialog";
 import { ComposeBar } from "./components/ComposeBar";
 import { WalkWizard } from "./components/WalkWizard";
 
@@ -67,9 +69,14 @@ export interface AppProps {
    * viewer: annotates, but cannot edit the plan or submit an agent verdict.
    */
   role?: "owner" | "observer" | "collaborator";
+  /**
+   * A collaborator's own SSH fingerprint. On first open of a share it seeds the
+   * name prompt so their notes attribute to a name, not a fingerprint.
+   */
+  selfAuthor?: string;
 }
 
-export function App({ home, sessionId, readOnly = false, onExit, clock, openClient, role = "owner" }: AppProps): React.ReactNode {
+export function App({ home, sessionId, readOnly = false, onExit, clock, openClient, role = "owner", selfAuthor }: AppProps): React.ReactNode {
   // Observer stays fully read-only; a collaborator writes annotations but not
   // the plan or a verdict. `observer` is what the controller and every write
   // gate key off; the two capability flags carve out the collaborator's middle.
@@ -126,6 +133,7 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
   const keysRef = useRef(DEFAULT_KEYS);
   const keyBindings = useMemo(() => new KeyBindings(DEFAULT_KEYS), []);
   const [theme, setTheme] = useState(DARK);
+  const [authorNames, setAuthorNames] = useState<Record<string, string>>({});
   useEffect(() => {
     const config = loadConfig({ repoRoot: session?.workspace.repoRoot });
     keysRef.current = config.keys;
@@ -134,6 +142,7 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
     setReviewMode(config.ui.reviewState);
     setReviewWidth(config.ui.reviewWidth);
     reviewWidthRef.current = config.ui.reviewWidth;
+    setAuthorNames(config.authors);
     controller.applyConfig(config);
   }, [session?.workspace.repoRoot, controller, keyBindings]);
   useEffect(
@@ -143,6 +152,16 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
     [],
   );
 
+  // First open of a share: ask the collaborator for a display name once, unless
+  // a past visit already recorded one. esc skips and their notes read anonymous.
+  const promptedSelfRef = useRef(false);
+  useEffect(() => {
+    if (promptedSelfRef.current || role !== "collaborator" || !selfAuthor || !session) return;
+    promptedSelfRef.current = true;
+    const known = session.participants?.find((participant) => participant.id === selfAuthor)?.name;
+    if (!known) setMode({ type: "nameSelf", text: "" });
+  }, [role, selfAuthor, session]);
+
   // ── derived view model ──────────────────────
   const display = controller.display();
   const rows = controller.rows();
@@ -204,9 +223,15 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
 
   const openCardEdit = (annotationId: string): void => {
     if (observer) return controller.setStatus("observer - read-only");
-    if (resolved) return controller.setStatus("review submitted - read-only");
     const annotation = session?.annotations.find((candidate) => candidate.id === annotationId);
     if (!annotation) return;
+    // a collaborator's note is theirs to word: activating it (click or e) renames
+    // the author rather than editing the body the planner does not own
+    if (annotation.author) {
+      setFocusedAnnotationId(annotationId);
+      return void setMode({ type: "rename", authorId: annotation.author, text: authorNames[annotation.author] ?? "" });
+    }
+    if (resolved) return controller.setStatus("review submitted - read-only");
     liveInput.current = annotation.body;
     setMode({ type: "railEdit", id: annotation.id, text: annotation.body });
   };
@@ -237,6 +262,11 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
     reviewWidth,
     terminalWidth,
     focusedAnnotationId,
+    authorNames,
+    renameAuthor: (id: string, name: string) => {
+      persistAuthorName(id, name);
+      setAuthorNames((prev) => ({ ...prev, [id]: name }));
+    },
     liveInput,
     reviewWidthRef,
     planSheetRef,
@@ -258,6 +288,10 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
       ? "compose"
       : mode.type === "submit"
         ? "submit"
+        : mode.type === "confirmDelete"
+          ? "confirm"
+        : mode.type === "rename" || mode.type === "nameSelf"
+          ? "prompt"
         : completion.phase === "prompt"
           ? "completion-prompt"
           : completion.phase === "counting"
@@ -307,9 +341,25 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
     );
   }
   if (!session && inbox) {
+    const confirming = mode.type === "confirmDelete" ? mode : null;
     return (
       <ThemeProvider theme={theme}>
-        <InboxList inbox={inbox} cursor={inboxCursor} />
+        <InboxList
+          inbox={inbox}
+          cursor={inboxCursor}
+          onRequestDelete={(id, title) => setMode({ type: "confirmDelete", sessionId: id, title })}
+        />
+        <ConfirmDialog
+          isOpen={confirming !== null}
+          title=" Delete plan "
+          message={confirming ? `Delete "${confirming.title}"? This removes the plan and its review.` : ""}
+          onConfirm={() => {
+            if (confirming) controller.deleteSession(confirming.sessionId);
+            setMode({ type: "normal" });
+          }}
+          onCancel={() => setMode({ type: "normal" })}
+          theme={theme}
+        />
       </ThemeProvider>
     );
   }
@@ -513,6 +563,7 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
             railRef={railRef}
             rail={{
               session: activeSession,
+              authorNames,
               selectedId: focusedAnnotationId,
               resolvedIds: isDiff ? null : resolvedIds,
               railTab,
@@ -557,6 +608,28 @@ export function App({ home, sessionId, readOnly = false, onExit, clock, openClie
             onBack={() => dispatch({ type: "walkBack" })}
           />
         ) : null}
+        {mode.type === "rename" ? (
+          <PromptDialog
+            isOpen
+            title=" Rename author "
+            label="Display name for this collaborator:"
+            value={mode.text}
+            placeholder="their name"
+            onInput={(text) => setMode({ ...mode, text })}
+            theme={theme}
+          />
+        ) : null}
+        {mode.type === "nameSelf" ? (
+          <PromptDialog
+            isOpen
+            title=" Welcome "
+            label="Your name (optional) - it attributes the notes you leave:"
+            value={mode.text}
+            placeholder="your name"
+            onInput={(text) => setMode({ ...mode, text })}
+            theme={theme}
+          />
+        ) : null}
       </box>
     </ThemeProvider>
   );

package/src/attribution.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import type { Identity } from "@cueloop/schema";
+import { ANONYMOUS_LABEL, resolveDisplayName, shortHandle } from "./attribution";
+
+describe(shortHandle, () => {
+  test("shortens an ssh fingerprint to a stable handle", () => {
+    // Arrange / Act / Assert
+    expect(shortHandle("SHA256:1a2b3c4d5e6f")).toBe("1a2b3c4d");
+    expect(shortHandle("SHA256:1a2b3c4d5e6f")).toBe(shortHandle("SHA256:1a2b3c4d5e6f"));
+  });
+});
+
+describe(resolveDisplayName, () => {
+  const named: Identity[] = [{ id: "SHA256:abc", provider: "ssh", name: "Al" }];
+  const unnamed: Identity[] = [{ id: "SHA256:abc", provider: "ssh" }];
+
+  test("a local rename override wins over everything", () => {
+    // Arrange / Act
+    const label = resolveDisplayName("SHA256:abc", named, { "SHA256:abc": "Alex" });
+
+    // Assert
+    expect(label).toBe("Alex");
+  });
+
+  test("falls back to name, then anonymous, then the short handle", () => {
+    // Arrange / Act / Assert
+    expect(resolveDisplayName("SHA256:abc", named, {})).toBe("Al");
+    expect(resolveDisplayName("SHA256:abc", unnamed, {})).toBe(ANONYMOUS_LABEL);
+    expect(resolveDisplayName("SHA256:1a2b3c4d5e", [], {})).toBe("1a2b3c4d");
+  });
+});

package/src/attribution.ts

@@ -0,0 +1,32 @@
+/**
+ * Attribution labels for annotations. An annotation's `author` is an identity
+ * id (an SSH fingerprint today). The rail resolves it against the share's
+ * participant registry and the planner's local rename overrides; ADR 0006.
+ */
+
+import type { Identity } from "@cueloop/schema";
+
+const FINGERPRINT_PREFIX = "SHA256:";
+
+/** Shown for a known participant who chose not to give a name. */
+export const ANONYMOUS_LABEL = "-- anonymous --";
+
+/** A short, stable handle from a raw author id when no name is known. */
+export function shortHandle(authorId: string): string {
+  const base = authorId.startsWith(FINGERPRINT_PREFIX) ? authorId.slice(FINGERPRINT_PREFIX.length) : authorId;
+  return base.slice(0, 8) || authorId;
+}
+
+/**
+ * The rail label for an author id: a local rename wins, then the collaborator's
+ * own name, then anonymous for a known-but-unnamed participant, then a short
+ * handle for an id we hold no identity for.
+ */
+export function resolveDisplayName(authorId: string, participants: Identity[] | undefined, overrides: Record<string, string>): string {
+  const override = overrides[authorId];
+  if (override) return override;
+  const identity = participants?.find((participant) => participant.id === authorId);
+  if (identity?.name) return identity.name;
+  if (identity) return ANONYMOUS_LABEL;
+  return shortHandle(authorId);
+}

package/src/components/AnnotationCard.tsx

@@ -14,7 +14,8 @@ import React, { useEffect, useRef, useState } from "react";
 import type { KeyBinding, TextareaRenderable } from "@opentui/core";
 import type { Theme } from "../theme";
 import { useComponentTheme } from "./theme-context";
-import { Card } from "./primitives/Card";
+import { Card, cardHeight } from "./primitives/Card";
+import { FRAME_BORDER_STYLE } from "./primitives/frame";
 import { Button } from "./primitives/Button";
 import { Toolbar } from "./primitives/Toolbar";
 import { truncateToSingleLine } from "./truncate-text";
@@ -31,6 +32,8 @@ export interface AnnotationSaved {
   isSelected: boolean;
   isOrphan: boolean;
   isBlocking: boolean;
+  /** Resolved author display name; own notes carry none. Set = name-in-border. */
+  authorLabel?: string;
   /** Non-null while the card body is being rewritten in place. */
   editing: AnnotationDraft | null;
   onPress: () => void;
@@ -166,23 +169,39 @@ export function AnnotationCard({ id, kind, quote, draft, saved, theme }: Annotat
     );
   }
   const card = saved!;
+  // A collaborator's note (author set) renders as a named, bordered card; own notes stay borderless.
+  const authored = card.authorLabel !== undefined && card.authorLabel !== "";
+  const indent = authored ? "" : "  ";
+  const marker = card.isSelected ? "▸ " : indent;
+  // Fixed content rows (a bordered box must declare a height or it collapses): header + quote + body, or the editor.
+  const contentRows = card.editing ? editorRowCount + 3 : 3;
+  // The border + its side padding eat this much content width, so text truncates shorter.
+  const borderInset = authored ? 4 : 0;
   return (
     <box
       id={id}
-      style={{ flexDirection: "column", marginBottom: 1, backgroundColor: card.isSelected ? tokens.elevated : undefined }}
+      title={authored ? ` ${card.authorLabel} ` : undefined}
+      style={{
+        flexDirection: "column",
+        marginBottom: 1,
+        backgroundColor: card.isSelected ? tokens.elevated : undefined,
+        ...(authored
+          ? { height: cardHeight(contentRows), border: true, borderStyle: FRAME_BORDER_STYLE, borderColor: tokens.blue, paddingLeft: 1, paddingRight: 1 }
+          : {}),
+      }}
       onMouseUp={card.onPress}
     >
       <text fg={card.isSelected ? tokens.text : kindColor}>
-        {card.isSelected ? "▸ " : "  "}
+        {marker}
         {kind.toUpperCase()}
         {card.isBlocking ? <span fg={tokens.red}> · BLOCKING</span> : null}
         <span fg={tokens.textDim}>{card.isOrphan ? " · ORPHANED" : " · pending"}</span>
       </text>
-      <text fg={tokens.textDim}>  "{truncateToSingleLine(quote, 26)}"</text>
+      <text fg={tokens.textDim}>{indent}"{truncateToSingleLine(quote, 26 - borderInset)}"</text>
       {card.editing ? (
         <DraftEditor draft={card.editing} rows={editorRowCount} onRowsChange={setEditorRowCount} theme={theme} />
       ) : (
-        <text fg={card.isOrphan ? tokens.textDim : tokens.textMuted}>  {truncateToSingleLine(card.body, 28)}</text>
+        <text fg={card.isOrphan ? tokens.textDim : tokens.textMuted}>{indent}{truncateToSingleLine(card.body, 28 - borderInset)}</text>
       )}
     </box>
   );

package/src/components/ConfirmDialog.stories.tsx

@@ -0,0 +1,21 @@
+import React from "react";
+import { DARK } from "../theme";
+import type { Story, StoryMeta } from "./story";
+import { ConfirmDialog } from "./ConfirmDialog";
+
+export const meta: StoryMeta = { title: "ConfirmDialog" };
+
+const callbacks = { onConfirm: () => {}, onCancel: () => {} };
+
+export const DeletePlan: Story = {
+  render: () => (
+    <ConfirmDialog
+      isOpen
+      title=" Delete plan "
+      message={'Delete "Auth rollout"? This removes the plan and its review.'}
+      {...callbacks}
+    />
+  ),
+  expectedColors: [DARK.backdrop, DARK.panel, DARK.accent],
+  size: { width: 64, height: 16 },
+};

package/src/components/ConfirmDialog.tsx

@@ -0,0 +1,56 @@
+/**
+ * A centered yes/no confirmation on the shared Dialog overlay. Presentational:
+ * the key grammar (⏎ confirm, esc cancel) is driven by the reducer; the buttons
+ * carry the same intents for the mouse. Used for destructive actions like the
+ * inbox delete.
+ */
+
+import React from "react";
+import { useTerminalDimensions } from "@opentui/react";
+import type { Theme } from "../theme";
+import { useComponentTheme } from "./theme-context";
+import { Dialog } from "./primitives/Dialog";
+import { Button } from "./primitives/Button";
+import { Toolbar } from "./primitives/Toolbar";
+
+export interface ConfirmDialogProps {
+  isOpen: boolean;
+  title?: string;
+  message: string;
+  confirmLabel?: string;
+  cancelLabel?: string;
+  onConfirm: () => void;
+  onCancel: () => void;
+  theme?: Theme;
+}
+
+export function ConfirmDialog({
+  isOpen,
+  title,
+  message,
+  confirmLabel = "Delete",
+  cancelLabel = "Cancel",
+  onConfirm,
+  onCancel,
+  theme,
+}: ConfirmDialogProps): React.ReactNode {
+  const tokens = useComponentTheme(theme);
+  const { width: terminalWidth } = useTerminalDimensions();
+  if (!isOpen) return null;
+  return (
+    <Dialog isOpen title={title} width={Math.min(54, terminalWidth - 6)} height={7} theme={theme}>
+      <box style={{ flexDirection: "column", flexGrow: 1, paddingLeft: 1, paddingRight: 1, paddingTop: 1 }}>
+        <text fg={tokens.text}>{message}</text>
+        <box style={{ flexGrow: 1 }} />
+        <Toolbar>
+          <Button variant="solid" onPress={onConfirm} theme={theme}>
+            {` ${confirmLabel} ⏎ `}
+          </Button>
+          <Button onPress={onCancel} theme={theme}>
+            {` ${cancelLabel} esc `}
+          </Button>
+        </Toolbar>
+      </box>
+    </Dialog>
+  );
+}

package/src/components/InboxList.tsx

@@ -1,6 +1,8 @@
 /**
- * The pending-review inbox: a cursor-driven session list. Selection stays
- * with the keyboard grammar; the list only renders the snapshot.
+ * The pending-review inbox: a cursor-driven session list. Selection stays with
+ * the keyboard grammar; the list only renders the snapshot. The selected row
+ * carries a [delete] word-button (click, or `d` in the grammar) that asks the
+ * caller to confirm removal.
  */
 
 import React from "react";
@@ -8,14 +10,17 @@ import type { ReviewSession } from "@cueloop/schema";
 import type { Theme } from "../theme";
 import { useComponentTheme } from "./theme-context";
 import { StatusBar } from "./primitives/StatusBar";
+import { Button } from "./primitives/Button";
 
 export interface InboxListProps {
   inbox: ReviewSession[];
   cursor: number;
+  /** Ask to delete a plan (the selected row's [delete] button). */
+  onRequestDelete?: (id: string, title: string) => void;
   theme?: Theme;
 }
 
-export function InboxList({ inbox, cursor, theme }: InboxListProps): React.ReactNode {
+export function InboxList({ inbox, cursor, onRequestDelete, theme }: InboxListProps): React.ReactNode {
   const tokens = useComponentTheme(theme);
   return (
     <box style={{ flexDirection: "column", width: "100%", height: "100%", backgroundColor: tokens.bg, padding: 1 }}>
@@ -24,19 +29,27 @@ export function InboxList({ inbox, cursor, theme }: InboxListProps): React.React
       {inbox.length === 0 ? (
         <text fg={tokens.textDim}>nothing waiting for review</text>
       ) : (
-        inbox.map((session, index) => (
-          <text
-            key={session.id}
-            fg={index === cursor ? tokens.text : tokens.textMuted}
-            bg={index === cursor ? tokens.cursorBg : undefined}
-          >
-            {index === cursor ? "▸ " : "  "}
-            {session.artifact.meta.title ?? session.id} · {session.workspace.branch} · {session.artifact.type}
-          </text>
-        ))
+        inbox.map((session, index) => {
+          const selected = index === cursor;
+          const title = session.artifact.meta.title ?? session.id;
+          return (
+            <box key={session.id} style={{ flexDirection: "row", backgroundColor: selected ? tokens.cursorBg : undefined }}>
+              <text fg={selected ? tokens.text : tokens.textMuted}>
+                {selected ? "▸ " : "  "}
+                {title} · {session.workspace.branch} · {session.artifact.type}
+              </text>
+              <box style={{ flexGrow: 1 }} />
+              {selected && onRequestDelete ? (
+                <Button onPress={() => onRequestDelete(session.id, title)} theme={theme}>
+                  {" [delete] "}
+                </Button>
+              ) : null}
+            </box>
+          );
+        })
       )}
       <box style={{ flexGrow: 1 }} />
-      <StatusBar theme={theme}>j/k move · ⏎ open · q quit</StatusBar>
+      <StatusBar theme={theme}>j/k move · ⏎ open · d delete · q quit</StatusBar>
     </box>
   );
 }

package/src/components/PromptDialog.stories.tsx

@@ -0,0 +1,36 @@
+import React from "react";
+import { DARK } from "../theme";
+import type { Story, StoryMeta } from "./story";
+import { PromptDialog } from "./PromptDialog";
+
+export const meta: StoryMeta = { title: "PromptDialog" };
+
+export const RenameAuthor: Story = {
+  render: () => (
+    <PromptDialog
+      isOpen
+      title=" Rename author "
+      label="Display name for this collaborator:"
+      value="Robin"
+      placeholder="their name"
+      onInput={() => {}}
+    />
+  ),
+  expectedColors: [DARK.backdrop, DARK.panel, DARK.accent],
+  size: { width: 64, height: 16 },
+};
+
+export const NameYourself: Story = {
+  render: () => (
+    <PromptDialog
+      isOpen
+      title=" Welcome "
+      label="Your name (optional) - it attributes the notes you leave:"
+      value=""
+      placeholder="your name"
+      onInput={() => {}}
+    />
+  ),
+  expectedColors: [DARK.backdrop, DARK.panel],
+  size: { width: 64, height: 16 },
+};

package/src/components/PromptDialog.tsx

@@ -0,0 +1,62 @@
+/**
+ * A centered single-field text prompt on the shared Dialog overlay. The focused
+ * input owns typing/cursor natively; the reducer's `prompt` overlay drives ⏎
+ * save / esc cancel (like the composer). Used to rename an author and to ask a
+ * collaborator for their name.
+ */
+
+import React, { useEffect, useRef } from "react";
+import { useTerminalDimensions } from "@opentui/react";
+import type { KeyBinding, TextareaRenderable } from "@opentui/core";
+import type { Theme } from "../theme";
+import { useComponentTheme } from "./theme-context";
+import { Dialog } from "./primitives/Dialog";
+
+// ⏎ submits (suppresses the textarea's default newline); the grammar owns save.
+const PROMPT_KEY_BINDINGS: KeyBinding[] = [{ name: "return", action: "submit" }];
+
+export interface PromptDialogProps {
+  isOpen: boolean;
+  title?: string;
+  label: string;
+  value: string;
+  placeholder?: string;
+  onInput: (text: string) => void;
+  theme?: Theme;
+}
+
+export function PromptDialog({ isOpen, title, label, value, placeholder, onInput, theme }: PromptDialogProps): React.ReactNode {
+  const tokens = useComponentTheme(theme);
+  const { width: terminalWidth } = useTerminalDimensions();
+  const inputRef = useRef<TextareaRenderable | null>(null);
+  useEffect(() => {
+    // open with the caret after the seeded value, like a text field
+    if (inputRef.current) inputRef.current.cursorOffset = value.length;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  if (!isOpen) return null;
+  return (
+    <Dialog isOpen title={title} width={Math.min(54, terminalWidth - 6)} height={7} theme={theme}>
+      <box style={{ flexDirection: "column", flexGrow: 1, paddingLeft: 1, paddingRight: 1, paddingTop: 1 }}>
+        <text fg={tokens.textDim}>{label}</text>
+        <textarea
+          ref={inputRef}
+          focused
+          initialValue={value}
+          placeholder={placeholder}
+          keyBindings={PROMPT_KEY_BINDINGS}
+          onContentChange={() => onInput(inputRef.current?.plainText ?? "")}
+          style={{
+            height: 1,
+            backgroundColor: tokens.elevated,
+            focusedBackgroundColor: tokens.elevated,
+            textColor: tokens.text,
+            focusedTextColor: tokens.text,
+          }}
+        />
+        <box style={{ flexGrow: 1 }} />
+        <text fg={tokens.textDim}>⏎ save · esc cancel</text>
+      </box>
+    </Dialog>
+  );
+}

package/src/components/ReviewPanel.stories.tsx

@@ -9,6 +9,7 @@ export const meta: StoryMeta = { title: "ReviewPanel" };
 
 const rail = {
   session: fixturePlanSession(),
+  authorNames: {},
   selectedId: FIXTURE_ANNOTATIONS[0]!.id,
   resolvedIds: new Set(FIXTURE_ANNOTATIONS.map((annotation) => annotation.id)),
   railTab: "review" as const,

package/src/components/ReviewRail.stories.tsx

@@ -23,6 +23,7 @@ export const AnnotationStack: Story = {
     <RailFrame>
       <ReviewRail
       session={fixturePlanSession()}
+      authorNames={{}}
       selectedId={FIXTURE_ANNOTATIONS[0]!.id}
       resolvedIds={new Set(FIXTURE_ANNOTATIONS.map((annotation) => annotation.id))}
       railTab="review"
@@ -42,6 +43,7 @@ export const AgentTab: Story = {
     <RailFrame>
       <ReviewRail
       session={fixturePlanSession()}
+      authorNames={{}}
       resolvedIds={new Set()}
       railTab="agent"
       pendingCount={2}
@@ -59,6 +61,7 @@ export const SubmitConfirmOpen: Story = {
     <RailFrame>
       <ReviewRail
       session={fixturePlanSession()}
+      authorNames={{}}
       resolvedIds={new Set()}
       railTab="review"
       pendingCount={2}
@@ -89,6 +92,7 @@ export const Resolved: Story = {
         status: "resolved",
         verdict: { kind: "approve", summary: "", feedback: "", resolvedAt: "2026-01-01T00:00:00Z" },
       })}
+      authorNames={{}}
       resolvedIds={new Set()}
       railTab="review"
       pendingCount={0}

package/src/components/ReviewRail.tsx

@@ -15,6 +15,7 @@ import { Tabs, Tab, TabList } from "./primitives/Tabs";
 import { Button } from "./primitives/Button";
 import { AnnotationCard, type AnnotationDraft } from "./AnnotationCard";
 import { ConfirmCard, type ConfirmCardProps } from "./ConfirmCard";
+import { resolveDisplayName } from "../attribution";
 
 export type RailTab = "review" | "agent";
 
@@ -29,6 +30,8 @@ export interface ReviewRailHandle {
 
 export interface ReviewRailProps {
   session: ReviewSession;
+  /** Planner-local author renames (config [authors]); override the registry name. */
+  authorNames: Record<string, string>;
   selectedId?: string;
   /** Ids whose anchor resolved; null = orphan display off (diff view). */
   resolvedIds: Set<string> | null;
@@ -58,6 +61,7 @@ export function annotationBlocking(annotation: Annotation): boolean {
 export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function ReviewRail(
   {
     session,
+    authorNames,
     selectedId,
     resolvedIds,
     railTab,
@@ -121,6 +125,7 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
                     isSelected: annotation.id === selectedId,
                     isOrphan: resolvedIds !== null && !resolvedIds.has(annotation.id),
                     isBlocking: annotationBlocking(annotation),
+                    authorLabel: annotation.author ? resolveDisplayName(annotation.author, session.participants, authorNames) : undefined,
                     editing:
                       cardEdit && cardEdit.id === annotation.id
                         ? {

package/src/components/__snapshots__/stories.test.tsx.snap

@@ -467,7 +467,7 @@ exports[`stories catalog InboxList/Empty renders, snapshots, and carries its col
  nothing waiting for review                                                     
                                                                                 
                                                                                 
-  j/k move · ⏎ open · q quit                                                    
+  j/k move · ⏎ open · d delete · q quit                                         
                                                                                 
 "
 `;
@@ -483,7 +483,7 @@ exports[`stories catalog InboxList/TwoPending renders, snapshots, and carries it
                                                                                 
                                                                                 
                                                                                 
-  j/k move · ⏎ open · q quit                                                    
+  j/k move · ⏎ open · d delete · q quit                                         
                                                                                 
 "
 `;
@@ -1455,5 +1455,65 @@ exports[`stories catalog ReviewPanel/Hidden renders, snapshots, and carries its
                                                             
                                                             
                                                             
+"
+`;
+
+exports[`stories catalog ConfirmDialog/DeletePlan renders, snapshots, and carries its colors: ConfirmDialog/DeletePlan 1`] = `
+"                                                                
+                                                                
+                                                                
+                                                                
+                                                                
+     ╭─ Delete plan ──────────────────────────────────────╮     
+     │                                                    │     
+     │ Delete "Auth rollout"? This removes the plan and   │     
+     │ its review.                                        │     
+     │                                                    │     
+     │  Delete ⏎  Cancel esc                              │     
+     ╰────────────────────────────────────────────────────╯     
+                                                                
+                                                                
+                                                                
+                                                                
+"
+`;
+
+exports[`stories catalog PromptDialog/NameYourself renders, snapshots, and carries its colors: PromptDialog/NameYourself 1`] = `
+"                                                                
+                                                                
+                                                                
+                                                                
+                                                                
+     ╭─ Welcome ──────────────────────────────────────────╮     
+     │                                                    │     
+     │ Your name (optional) - it attributes the notes     │     
+     │ you leave:                                         │     
+     │ your name                                          │     
+     │ ⏎ save · esc cancel                                │     
+     ╰────────────────────────────────────────────────────╯     
+                                                                
+                                                                
+                                                                
+                                                                
+"
+`;
+
+exports[`stories catalog PromptDialog/RenameAuthor renders, snapshots, and carries its colors: PromptDialog/RenameAuthor 1`] = `
+"                                                                
+                                                                
+                                                                
+                                                                
+                                                                
+     ╭─ Rename author ────────────────────────────────────╮     
+     │                                                    │     
+     │ Display name for this collaborator:                │     
+     │ Robin                                              │     
+     │                                                    │     
+     │ ⏎ save · esc cancel                                │     
+     ╰────────────────────────────────────────────────────╯     
+                                                                
+                                                                
+                                                                
+                                                                
 "
 `;

package/src/config.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { DEFAULT_KEYS, actionFor, loadConfig, persistReviewState, persistReviewWidth } from "./config";
+import { DEFAULT_KEYS, actionFor, loadConfig, persistAuthorName, persistReviewState, persistReviewWidth } from "./config";
 import { REVIEW_DEFAULT_WIDTH, REVIEW_MAX_WIDTH } from "./review-panel";
 import { DARK } from "./theme";
 
@@ -251,3 +251,32 @@ describe("actionFor", () => {
     expect(actionFor(DEFAULT_KEYS, "zz", false)).toBeUndefined();
   });
 });
+
+describe("[authors] rename map", () => {
+  test("loads quoted fingerprint keys", () => {
+    // Arrange
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-authors-"));
+    const path = join(dir, "config.toml");
+    writeFileSync(path, `[authors]\n"SHA256:abc+def/gh" = "Alex"\n`);
+
+    // Act
+    const config = loadConfig({ userConfigPath: path });
+
+    // Assert
+    expect(config.authors["SHA256:abc+def/gh"]).toBe("Alex");
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("persistAuthorName round-trips and updates a fingerprint id in place", () => {
+    // Arrange
+    const dir = mkdtempSync(join(tmpdir(), "cueloop-authors2-"));
+    const path = join(dir, "config.toml");
+
+    // Act / Assert
+    persistAuthorName("SHA256:abc+def/gh", "Alex", path);
+    expect(loadConfig({ userConfigPath: path }).authors["SHA256:abc+def/gh"]).toBe("Alex");
+    persistAuthorName("SHA256:abc+def/gh", "Alexa", path);
+    expect(loadConfig({ userConfigPath: path }).authors["SHA256:abc+def/gh"]).toBe("Alexa");
+    rmSync(dir, { recursive: true, force: true });
+  });
+});

package/src/config.ts

@@ -34,6 +34,8 @@ export interface CueloopConfig {
    * collapse mode and expanded-rail width, persisted so they survive restarts.
    */
   ui: { autoClose: AutoClose; editor?: string; reviewState: ReviewPanelMode; reviewWidth: number };
+  /** Planner-local author renames: identity id → display name ([authors] table). */
+  authors: Record<string, string>;
   integrations: IntegrationsConfig;
 }
 
@@ -51,6 +53,7 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   next_annotation: ["n"],
   prev_annotation: ["p"],
   delete_annotation: ["backspace"],
+  rename: ["r"],
   submit: ["return", "enter"],
   share: ["S"],
   quit: ["q"],
@@ -70,8 +73,15 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
     keys: { ...base.keys },
     theme: { ...base.theme },
     ui: { ...base.ui },
+    authors: { ...base.authors },
     integrations: { obsidian: { ...base.integrations.obsidian } },
   };
+  const authors = raw["authors"] as Record<string, unknown> | undefined;
+  if (authors) {
+    for (const [id, value] of Object.entries(authors)) {
+      if (typeof value === "string") out.authors[id] = value;
+    }
+  }
   const keys = raw["keys"] as KeymapConfig | undefined;
   if (keys) {
     for (const [action, combo] of Object.entries(keys)) {
@@ -120,6 +130,7 @@ export function loadConfig(options: { repoRoot?: string; userConfigPath?: string
     keys: { ...DEFAULT_KEYS },
     theme: { ...DARK },
     ui: { autoClose: "off", reviewState: "expanded", reviewWidth: REVIEW_DEFAULT_WIDTH },
+    authors: {},
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
   };
   const userPath = userConfigPathFrom(options.userConfigPath);
@@ -187,3 +198,28 @@ export function persistReviewWidth(width: number, userConfigPath?: string): void
 export function persistReviewState(state: ReviewPanelMode, userConfigPath?: string): void {
   persistUiSetting("review_state", `"${state}"`, userConfigPath);
 }
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Persist an author rename into the `[authors]` table. The identity id (an SSH
+ * fingerprint) is not a bare TOML key, so it is written quoted.
+ */
+export function persistAuthorName(id: string, name: string, userConfigPath?: string): void {
+  const path = userConfigPathFrom(userConfigPath);
+  let text = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const key = `"${id.replace(/"/g, '\\"')}"`;
+  const value = `"${name.replace(/"/g, '\\"')}"`;
+  const assignment = new RegExp(`^(\\s*)${escapeRegExp(key)}\\s*=.*$`, "m");
+  if (assignment.test(text)) {
+    text = text.replace(assignment, `$1${key} = ${value}`);
+  } else if (/^\[authors\]/m.test(text)) {
+    text = text.replace(/^\[authors\]\s*$/m, `[authors]\n${key} = ${value}`);
+  } else {
+    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[authors]\n${key} = ${value}\n`;
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}

package/src/intent-dispatch.test.ts

@@ -26,6 +26,8 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
   const controller = {
     setStatus: mock(),
     open: mock(),
+    deleteSession: mock(),
+    setSelfName: mock(),
     cut: mock(),
     annotate: mock(),
     updateAnnotation: mock(),
@@ -56,6 +58,8 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     reviewWidth: 34,
     terminalWidth: 120,
     focusedAnnotationId: undefined,
+    authorNames: {},
+    renameAuthor: mock(),
     liveInput: { current: "" },
     reviewWidthRef: { current: 34 },
     planSheetRef: { current: null },
@@ -211,3 +215,94 @@ describe("exit", () => {
     expect(deps.onExit).toHaveBeenCalledWith(0);
   });
 });
+
+describe("inbox delete", () => {
+  test("requestDeleteSession opens the confirm on the cursor row", () => {
+    // Arrange
+    const inbox = [{ id: "ses_1", artifact: { meta: { title: "Plan A" } } }] as never;
+    const deps = makeDeps({ inbox, inboxCursor: 0 });
+
+    // Act
+    createIntentDispatch(deps)({ type: "requestDeleteSession" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "confirmDelete", sessionId: "ses_1", title: "Plan A" });
+  });
+
+  test("confirmDialog deletes the session and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "confirmDelete", sessionId: "ses_1", title: "Plan A" } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.controller.deleteSession).toHaveBeenCalledWith("ses_1");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+});
+
+describe("rename author", () => {
+  test("openRename seeds the prompt with the author's current local name", () => {
+    // Arrange
+    const session = { annotations: [{ id: "a1", author: "SHA256:x" }] } as never;
+    const deps = makeDeps({ session, focusedAnnotationId: "a1", authorNames: { "SHA256:x": "Alex" } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "openRename" });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "rename", authorId: "SHA256:x", text: "Alex" });
+  });
+
+  test("openRename on your own note does nothing but explain", () => {
+    // Arrange
+    const session = { annotations: [{ id: "a1" }] } as never;
+    const deps = makeDeps({ session, focusedAnnotationId: "a1" });
+
+    // Act
+    createIntentDispatch(deps)({ type: "openRename" });
+
+    // Assert
+    expect(deps.controller.setStatus).toHaveBeenCalled();
+    expect(deps.setMode).not.toHaveBeenCalled();
+  });
+
+  test("confirmDialog in rename mode persists the trimmed name and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "rename", authorId: "SHA256:x", text: "  Alex  " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.renameAuthor).toHaveBeenCalledWith("SHA256:x", "Alex");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+});
+
+describe("collaborator self-name", () => {
+  test("confirmDialog in nameSelf mode records the trimmed name and closes", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "nameSelf", text: "  Robin  " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.controller.setSelfName).toHaveBeenCalledWith("Robin");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+
+  test("an empty name still closes - the collaborator stays anonymous", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "nameSelf", text: "   " } });
+
+    // Act
+    createIntentDispatch(deps)({ type: "confirmDialog" });
+
+    // Assert
+    expect(deps.controller.setSelfName).toHaveBeenCalledWith("");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "normal" });
+  });
+});

package/src/intent-dispatch.ts

@@ -23,7 +23,10 @@ export type Mode =
   | { type: "span"; span: SpanState }
   | { type: "compose"; kind: "comment" | "suggestion"; displayIndex: number; start: number; end: number; text: string }
   | { type: "railEdit"; id: string; text: string }
-  | { type: "submit"; verdict: VerdictKind; summary: string };
+  | { type: "submit"; verdict: VerdictKind; summary: string }
+  | { type: "confirmDelete"; sessionId: string; title: string }
+  | { type: "rename"; authorId: string; text: string }
+  | { type: "nameSelf"; text: string };
 
 /**
  * Annotations that still count as feedback: agent notes never do, and an
@@ -60,6 +63,10 @@ export interface IntentDispatchDeps {
   reviewWidth: number;
   terminalWidth: number;
   focusedAnnotationId: string | undefined;
+  /** Planner-local author renames, for seeding the rename prompt. */
+  authorNames: Record<string, string>;
+  /** Persist an author rename and update the live overrides (App-owned). */
+  renameAuthor: (id: string, name: string) => void;
 
   liveInput: MutableRefObject<string>;
   reviewWidthRef: MutableRefObject<number>;
@@ -96,6 +103,8 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
     reviewWidth,
     terminalWidth,
     focusedAnnotationId,
+    authorNames,
+    renameAuthor,
     liveInput,
     reviewWidthRef,
     planSheetRef,
@@ -136,6 +145,22 @@ export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent)
         if (selected) controller.open(selected.id);
         return;
       }
+      case "requestDeleteSession": {
+        const selected = inbox?.[inboxCursor];
+        if (selected) setMode({ type: "confirmDelete", sessionId: selected.id, title: selected.artifact.meta.title ?? selected.id });
+        return;
+      }
+      case "openRename": {
+        const focused = session?.annotations.find((annotation) => annotation.id === focusedAnnotationId);
+        if (!focused?.author) return void controller.setStatus("that is your own note - nothing to rename");
+        return void setMode({ type: "rename", authorId: focused.author, text: authorNames[focused.author] ?? "" });
+      }
+      case "confirmDialog": {
+        if (mode.type === "confirmDelete") controller.deleteSession(mode.sessionId);
+        else if (mode.type === "rename") renameAuthor(mode.authorId, mode.text.trim());
+        else if (mode.type === "nameSelf") controller.setSelfName(mode.text.trim());
+        return void setMode({ type: "normal" });
+      }
       case "startSpan": {
         const block = display[cursor];
         if (!block?.work) return;

package/src/keymap.test.ts

@@ -437,3 +437,41 @@ describe("read-only filter", () => {
     expect(reduceKey(keyState, key("s"))).toEqual([{ type: "status", message: "observer - read-only" }]);
   });
 });
+
+describe("inbox delete", () => {
+  test("d on a session requests delete", () => {
+    // Arrange / Act / Assert
+    expect(reduceKey(state({ view: "inbox" }), key("d"))).toEqual([{ type: "requestDeleteSession" }]);
+  });
+});
+
+describe("confirm overlay", () => {
+  // Arrange
+  const keyState = state({ overlay: "confirm" });
+  const table: [string, Intent[]][] = [
+    ["return", [{ type: "confirmDialog" }]],
+    ["enter", [{ type: "confirmDialog" }]],
+    ["escape", [{ type: "closeOverlay" }]],
+    ["j", []],
+    ["d", []],
+  ];
+  for (const [name, expected] of table) {
+    test(`${name} -> ${JSON.stringify(expected)}`, () => {
+      expect(reduceKey(keyState, key(name))).toEqual(expected);
+    });
+  }
+});
+
+describe("rename grammar", () => {
+  test("r on a focused note opens rename", () => {
+    // Arrange / Act / Assert
+    expect(reduceKey(state({ hasFocusedAnnotation: true }), key("r"))).toEqual([{ type: "openRename" }]);
+  });
+
+  test("prompt overlay routes ⏎ to confirm and esc to cancel", () => {
+    // Arrange / Act / Assert
+    expect(reduceKey(state({ overlay: "prompt" }), key("return"))).toEqual([{ type: "confirmDialog" }]);
+    expect(reduceKey(state({ overlay: "prompt" }), key("escape"))).toEqual([{ type: "closeOverlay" }]);
+    expect(reduceKey(state({ overlay: "prompt" }), key("a"))).toEqual([]);
+  });
+});

package/src/keymap.ts

@@ -14,6 +14,9 @@ export type Intent =
   | { type: "move"; to: "down" | "up" | "top" | "bottom" }
   | { type: "inboxMove"; to: "down" | "up" }
   | { type: "openSession" }
+  | { type: "requestDeleteSession" }
+  | { type: "openRename" }
+  | { type: "confirmDialog" }
   | { type: "startSpan" }
   | { type: "spanKey"; name: string }
   | { type: "openCompose"; kind: "comment" | "suggestion"; from: "cursor" | "span" }
@@ -61,7 +64,7 @@ export interface KeyState {
   /** Owner-only: publish the plan as a share. A collaborator never re-shares. */
   canShare?: boolean;
   /** Layer that owns keys before the grammar runs. */
-  overlay: "none" | "walk" | "compose" | "submit" | "completion-prompt" | "completion-counting";
+  overlay: "none" | "walk" | "compose" | "submit" | "confirm" | "prompt" | "completion-prompt" | "completion-counting";
   view: "inbox" | "plan" | "diff";
   /** Plan-only span selection sub-mode. */
   spanMode: boolean;
@@ -111,6 +114,18 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
     }
     return [];
   }
+  // a modal confirm owns the keys: ⏎ commits the action, escape backs out
+  if (state.overlay === "confirm") {
+    if (name === "return" || name === "enter") return [{ type: "confirmDialog" }];
+    if (name === "escape") return [{ type: "closeOverlay" }];
+    return [];
+  }
+  // a text prompt: the focused input owns typing; only ⏎ save and esc route here
+  if (state.overlay === "prompt") {
+    if (name === "return" || name === "enter") return [{ type: "confirmDialog" }];
+    if (name === "escape") return [{ type: "closeOverlay" }];
+    return [];
+  }
   if (state.overlay === "completion-prompt" || state.overlay === "completion-counting") {
     if (name === "return" || name === "enter" || name === "q") return [{ type: "finishReview" }];
     if (name === "a") return [{ type: "optInAutoClose" }];
@@ -168,6 +183,7 @@ function inboxGrammar(state: KeyState, name: string): Intent[] {
   if (name === "j" || name === "down") return [{ type: "inboxMove", to: "down" }];
   if (name === "k" || name === "up") return [{ type: "inboxMove", to: "up" }];
   if (name === "return" || name === "enter") return [{ type: "openSession" }];
+  if (name === "d") return [{ type: "requestDeleteSession" }];
   return [];
 }
 
@@ -243,6 +259,10 @@ function annotationCluster(state: KeyState, action: string | undefined): Intent[
     if (state.resolved || !state.hasFocusedAnnotation) return [];
     return [{ type: "removeAnnotation" }];
   }
+  if (action === "rename") {
+    if (!state.hasFocusedAnnotation) return status("select a collaborator's note to rename them");
+    return [{ type: "openRename" }];
+  }
   if (action === "submit") {
     // a collaborator's notes union back as they go; there is no verdict to submit
     if (state.canSubmitVerdict === false) return status("shared view - your notes save as you go; q to leave");

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

@@ -46,9 +46,9 @@ function fakeClient(session: ReviewSession): SessionClient {
     sessionList: async () => [session],
     sessionAnnotate: mock(async () => session),
     sessionSetShareId: mock(async (_id: string, shareId: string) => ((session.shareId = shareId), session)),
-    sessionMergeAnnotations: mock(async (_id: string, incoming: Annotation[]) => {
+    sessionMergeShared: mock(async (_id: string, incoming: { annotations: Annotation[] }) => {
       const known = new Set(session.annotations.map((existing) => existing.id));
-      for (const note of incoming) if (!known.has(note.id)) session.annotations.push(note);
+      for (const note of incoming.annotations) if (!known.has(note.id)) session.annotations.push(note);
       return session;
     }),
     close: () => {},
@@ -83,9 +83,12 @@ describe("share", () => {
 });
 
 describe("pullShared", () => {
-  test("unions collaborator notes in when the plan was shared", async () => {
+  test("unions collaborator notes and identities in when the plan was shared", async () => {
     // Arrange
-    remote = sessionFixture({ annotations: [annotation("a1", "SHA256:mate")] });
+    remote = sessionFixture({
+      annotations: [annotation("a1", "SHA256:mate")],
+      participants: [{ id: "SHA256:mate", provider: "ssh", name: "Sam" }],
+    });
     const { controller, client } = await connectedController(sessionFixture({ shareId: "p_abc123xy" }));
 
     // Act
@@ -94,7 +97,10 @@ describe("pullShared", () => {
 
     // Assert
     expect(pullShare).toHaveBeenCalledWith("p_abc123xy");
-    expect(client.sessionMergeAnnotations).toHaveBeenCalledWith("ses_1", remote.annotations);
+    expect(client.sessionMergeShared).toHaveBeenCalledWith("ses_1", {
+      annotations: remote.annotations,
+      participants: remote.participants,
+    });
   });
 
   test("does nothing for a plan that was never shared", async () => {
@@ -108,7 +114,7 @@ describe("pullShared", () => {
 
     // Assert
     expect(pullShare).not.toHaveBeenCalled();
-    expect(client.sessionMergeAnnotations).not.toHaveBeenCalled();
+    expect(client.sessionMergeShared).not.toHaveBeenCalled();
   });
 });
 

package/src/session-controller.ts

@@ -104,6 +104,10 @@ export interface ReviewController {
   working(): string;
   /** Open a session from the inbox. */
   open(id: string): void;
+  /** Delete a session for good (inbox delete); the inbox refreshes on the event. */
+  deleteSession(id: string): void;
+  /** Record the viewer's own name into the share's participant registry (collaborator self-naming). */
+  setSelfName(name: string): void;
   /** Cut the block under the cursor, or restore a cut one. */
   cut(displayIndex: number): void;
   /** The $EDITOR hand-off on the working copy. */
@@ -311,6 +315,19 @@ class Controller implements ReviewController {
     else void this.refreshSession(id);
   }
 
+  deleteSession(id: string): void {
+    this.client
+      ?.sessionDelete(id)
+      .then(() => this.setStatus("plan deleted"))
+      .catch((error: unknown) => this.setStatus(`delete failed: ${error instanceof Error ? error.message : String(error)}`));
+  }
+
+  setSelfName(name: string): void {
+    const session = this.snapshot.session;
+    if (!session) return;
+    this.apply(this.client!.sessionSetSelfName(session.id, name));
+  }
+
   cut(displayIndex: number): void {
     const session = this.snapshot.session;
     if (!session || session.status === "resolved") return;
@@ -514,7 +531,9 @@ class Controller implements ReviewController {
     if (!session?.shareId || !this.client) return Promise.resolve();
     const client = this.client;
     return pullShare(session.shareId)
-      .then((remote) => client.sessionMergeAnnotations(session.id, collaboratorAnnotations(remote)))
+      .then((remote) =>
+        client.sessionMergeShared(session.id, { annotations: collaboratorAnnotations(remote), participants: remote.participants }),
+      )
       .then(() => {})
       .catch(() => {});
   }