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

package/src/components/quick-actions-editor.tsx

@@ -22,8 +22,10 @@ export interface QuickActionsEditorProps {
   selectedIndex: number;
   /** The row whose system-prompt input is open and focused, or null. */
   expandedIndex: number | null;
-  /** Select and toggle a row's editor open/closed. */
-  onToggleExpand: (index: number) => void;
+  /** Which field the open editor focuses first - set by the clicked row. */
+  expandedField: "prompt" | "metadata";
+  /** Select and toggle a row's editor open/closed, focusing the given field. */
+  onToggleExpand: (index: number, field: "prompt" | "metadata") => void;
   onEditPrompt: (index: number, prompt: string) => void;
   onEditMetadata: (index: number, metadata: string) => void;
   onReset: () => void;
@@ -35,6 +37,7 @@ export function QuickActionsEditor({
   actions,
   selectedIndex,
   expandedIndex,
+  expandedField,
   onToggleExpand,
   onEditPrompt,
   onEditMetadata,
@@ -52,11 +55,9 @@ export function QuickActionsEditor({
   return (
     <box style={{ flexDirection: "column", flexGrow: 1 }}>
       <box style={{ flexDirection: "row" }}>
-        <box style={{ flexGrow: 1 }}>
-          <text fg={tokens.textDim}>click a prompt to edit its system prompt</text>
-        </box>
+        <box style={{ flexGrow: 1 }} />
         <box onMouseUp={onReset}>
-          <text fg={tokens.textDim}>reset to defaults ▸</text>
+          <text fg={tokens.textDim}>reset</text>
         </box>
       </box>
       <box style={{ height: 1 }} />
@@ -68,7 +69,8 @@ export function QuickActionsEditor({
             action={action}
             isSelected={index === selectedIndex}
             isExpanded={index === expandedIndex}
-            onToggleExpand={() => onToggleExpand(index)}
+            initialField={expandedField}
+            onToggleExpand={(field) => onToggleExpand(index, field)}
             onEditPrompt={(prompt) => onEditPrompt(index, prompt)}
             onEditMetadata={(metadata) => onEditMetadata(index, metadata)}
             theme={theme}
@@ -91,6 +93,7 @@ function ActionRow({
   action,
   isSelected,
   isExpanded,
+  initialField,
   onToggleExpand,
   onEditPrompt,
   onEditMetadata,
@@ -100,7 +103,8 @@ function ActionRow({
   action: QuickAction;
   isSelected: boolean;
   isExpanded: boolean;
-  onToggleExpand: () => void;
+  initialField: "prompt" | "metadata";
+  onToggleExpand: (field: "prompt" | "metadata") => void;
   onEditPrompt: (prompt: string) => void;
   onEditMetadata: (metadata: string) => void;
   theme?: Theme;
@@ -113,9 +117,10 @@ function ActionRow({
         <ActionEditor
           action={action}
           isSelected={isSelected}
+          initialField={initialField}
           onEditPrompt={onEditPrompt}
           onEditMetadata={onEditMetadata}
-          onDone={onToggleExpand}
+          onDone={() => onToggleExpand("prompt")}
           tokens={tokens}
         />
       </box>
@@ -126,12 +131,12 @@ function ActionRow({
     <box id={rowId} style={{ flexDirection: "column" }}>
       <box
         style={{ backgroundColor: isSelected ? tokens.border : undefined }}
-        onMouseUp={onToggleExpand}
+        onMouseUp={() => onToggleExpand("prompt")}
       >
-        <text fg={isSelected ? tokens.text : tokens.textMuted}>{`▸ ${action.prompt}`}</text>
+        <text fg={isSelected ? tokens.text : tokens.textMuted}>{action.prompt}</text>
       </box>
       {action.metadata ? (
-        <box style={{ paddingLeft: 2 }}>
+        <box onMouseUp={() => onToggleExpand("metadata")}>
           <text fg={tokens.textDim}>{truncateMetadata(action.metadata)}</text>
         </box>
       ) : null}
@@ -141,12 +146,13 @@ function ActionRow({
 
 /**
  * The two-field editor for an expanded row: the action title over its system
- * prompt. Mounts fresh per expand, so focus starts on the title without a reset
- * effect; ⏎ steps title -> description -> close, and a click focuses either.
+ * prompt. Mounts fresh per expand, so focus starts on the clicked field without a
+ * reset effect; ⏎ steps title -> description -> close, and a click focuses either.
  */
 function ActionEditor({
   action,
   isSelected,
+  initialField,
   onEditPrompt,
   onEditMetadata,
   onDone,
@@ -154,6 +160,7 @@ function ActionEditor({
 }: {
   action: QuickAction;
   isSelected: boolean;
+  initialField: "prompt" | "metadata";
   onEditPrompt: (prompt: string) => void;
   onEditMetadata: (metadata: string) => void;
   onDone: () => void;
@@ -161,7 +168,7 @@ function ActionEditor({
 }): React.ReactNode {
   const promptRef = useRef<TextareaRenderable | null>(null);
   const metadataRef = useRef<TextareaRenderable | null>(null);
-  const [activeField, setActiveField] = useState<"prompt" | "metadata">("prompt");
+  const [activeField, setActiveField] = useState<"prompt" | "metadata">(initialField);
 
   // the focused field types from its end, not from the caret parked at the start
   useEffect(() => {
@@ -184,9 +191,6 @@ function ActionEditor({
       <box
         style={{ flexDirection: "row", backgroundColor: isSelected ? tokens.border : undefined }}
       >
-        <box style={{ width: 2, flexShrink: 0 }}>
-          <text fg={isSelected ? tokens.text : tokens.textMuted}>{"▾ "}</text>
-        </box>
         <textarea
           ref={promptRef}
           focused={activeField === "prompt"}
@@ -199,10 +203,7 @@ function ActionEditor({
           style={fieldStyle}
         />
       </box>
-      <box style={{ flexDirection: "row", paddingLeft: 2 }}>
-        <box style={{ width: 2, flexShrink: 0 }}>
-          <text fg={tokens.textDim}>{">"}</text>
-        </box>
+      <box style={{ flexDirection: "row" }}>
         <textarea
           ref={metadataRef}
           focused={activeField === "metadata"}

package/src/components/session-tree.test.ts

@@ -112,19 +112,19 @@ describe("groupInbox", () => {
     expect(rows.some((row) => row.kind === "section" && row.label === "Threads")).toBe(true);
   });
 
-  test("a pinned thread lifts into a Pinned section at the top, out of its normal group", () => {
+  test("a pinned thread lifts into a Starred section at the top, out of its normal group", () => {
     // Arrange - one repo-bound thread, one standalone; pin the repo-bound one
     const sessions = [session("a", "Pinned one", "root-1"), session("b", "Loose two")];
 
     // Act
     const { rows, ordered } = groupInbox(sessions, new Set(["a"]));
 
-    // Assert - Pinned is the first section and holds thread a; a is gone from Projects
+    // Assert - Starred is the first section and holds thread a; a is gone from Projects
     const sections = rows
       .filter((row) => row.kind === "section")
       .map((row) => (row.kind === "section" ? row.label : ""));
 
-    expect(sections[0]).toBe("Pinned");
+    expect(sections[0]).toBe("Starred");
     expect(sections).not.toContain("Projects"); // its only member was pinned away
     expect(ordered[0]!.id).toBe("a"); // the cursor walks pinned threads first
     const pinnedThreadIds = rows.filter((row) => row.kind === "thread").map((row) => row.id);

package/src/components/session-tree.ts

@@ -84,7 +84,7 @@ export function groupInbox(
   };
 
   if (pinned.length > 0) {
-    rows.push({ kind: "section", id: "section:pinned", label: "Pinned" });
+    rows.push({ kind: "section", id: "section:pinned", label: "Starred" });
     for (const session of pinned) pushThread(session);
   }
 

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"],
@@ -151,6 +162,7 @@ export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   share: ["S"],
   quit: ["q"],
   walk: ["w"],
+  leader: ["ctrl+g"],
 };
 
 const SkillsSectionSchema = v.object({ path: v.optional(v.string()) });
@@ -165,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()),
@@ -173,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(),
@@ -274,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 },
@@ -281,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 } },
@@ -288,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);
@@ -310,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);
@@ -335,6 +361,7 @@ export function loadConfig(
       pins: [],
     },
     authors: {},
+    identity: { provider: "typed" },
     actions: [...DEFAULT_QUICK_ACTIONS],
     skillsPath: join(homedir(), ".agents", "skills"),
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
@@ -356,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);
@@ -458,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/diff-intraline.ts

@@ -83,12 +83,30 @@ export function intralineRunsByRow(rows: DiffRow[]): Map<number, IntralineRun[]>
 /** Lines this similar (word-set overlap) are treated as the same line edited. */
 const SIMILAR_MIN_WORD_OVERLAP = 0.3;
 
+/** Lower-cased word set of a line for the similarity gate, cached per distinct line within a block so
+ *  the LCS grid tokenizes each line once instead of once per comparison. */
+function lineWordSetCache(): (text: string) => ReadonlySet<string> {
+  const cache = new Map<string, ReadonlySet<string>>();
+
+  return (text) => {
+    const cached = cache.get(text);
+    if (cached !== undefined) return cached;
+    const words = new Set(text.toLowerCase().split(/\s+/).filter(Boolean));
+    cache.set(text, words);
+
+    return words;
+  };
+}
+
 /** Whether two lines are the same line edited, by case-insensitive word-set
  *  overlap - the matching gate, distinct from the case-sensitive word diff. */
-function linesSimilar(oldText: string, newText: string): boolean {
-  const words = (text: string) => new Set(text.toLowerCase().split(/\s+/).filter(Boolean));
-  const oldWords = words(oldText);
-  const newWords = words(newText);
+function linesSimilar(
+  wordsOf: (text: string) => ReadonlySet<string>,
+  oldText: string,
+  newText: string,
+): boolean {
+  const oldWords = wordsOf(oldText);
+  const newWords = wordsOf(newText);
 
   if (oldWords.size === 0 && newWords.size === 0) return true;
   let intersection = 0;
@@ -112,8 +130,11 @@ function alignedPairs(deletionTexts: string[], additionTexts: string[]): Array<[
   const pairs: Array<[number, number]> = [];
   let deletionOffset = 0;
   let additionOffset = 0;
+  const wordsOf = lineWordSetCache();
 
-  for (const op of lcsDiff(deletionTexts, additionTexts, linesSimilar)) {
+  for (const op of lcsDiff(deletionTexts, additionTexts, (deletionText, additionText) =>
+    linesSimilar(wordsOf, deletionText, additionText),
+  )) {
     if (op.kind === "ctx") {
       pairs.push([deletionOffset, additionOffset]);
       deletionOffset++;

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";