From 926f2c690b25887d74cccbeadf425511535ae524 Mon Sep 17 00:00:00 2001
From: Clay Delk <clay.delk@gmail.com>
Date: Fri, 25 Sep 2026 09:44:53 -0400
Subject: [PATCH 1/3] feat(messages): refine direct message opening

Signed-off-by: Clay Delk <clay.delk@gmail.com>
---
 src/bundled/channels/ChannelsPage.tsx         |  4 ++
 .../NewMessage.recovery.test.tsx              |  1 +
 .../direct-messages/NewMessage.test.tsx       | 59 ++++++++++++++++-
 src/features/direct-messages/NewMessage.tsx   | 63 ++++++++++++++++---
 .../direct-messages/RecipientPicker.tsx       | 49 +++++++++++++--
 src/features/direct-messages/usePeople.ts     |  6 +-
 src/features/relay/direct-messages.test.ts    | 24 +++++++
 src/features/relay/direct-messages.ts         | 12 ++--
 tests/browser/new-message.spec.mjs            |  5 ++
 9 files changed, 203 insertions(+), 20 deletions(-)

diff --git a/src/bundled/channels/ChannelsPage.tsx b/src/bundled/channels/ChannelsPage.tsx
index a9291f1d1..0afa2a25a 100644
--- a/src/bundled/channels/ChannelsPage.tsx
+++ b/src/bundled/channels/ChannelsPage.tsx
@@ -837,6 +837,10 @@ function ChannelWorkspace({
               scope={scope}
               extensions={extensions}
               onPreparing={(pubkeys) => handoff?.prepareDm(pubkeys)}
+              onOpened={(channelId) => {
+                handoff?.clearPreparingDm();
+                select(channelId);
+              }}
               onStarted={(channelId, id) => {
                 handoff?.clearPreparingDm();
                 setSent({ channelId, id });
diff --git a/src/features/direct-messages/NewMessage.recovery.test.tsx b/src/features/direct-messages/NewMessage.recovery.test.tsx
index 91e105385..501ccdb78 100644
--- a/src/features/direct-messages/NewMessage.recovery.test.tsx
+++ b/src/features/direct-messages/NewMessage.recovery.test.tsx
@@ -148,6 +148,7 @@ function setup(
       <NewMessage
         session={owner.session}
         scope={scope}
+        onOpened={vi.fn()}
         onStarted={onStarted}
         extensions={extensions}
       />,
diff --git a/src/features/direct-messages/NewMessage.test.tsx b/src/features/direct-messages/NewMessage.test.tsx
index 5a3615ba4..ce46a9704 100644
--- a/src/features/direct-messages/NewMessage.test.tsx
+++ b/src/features/direct-messages/NewMessage.test.tsx
@@ -136,6 +136,7 @@ function setup() {
     },
     media: (url: string) => url,
   } as unknown as RelaySession;
+  const onOpened = vi.fn();
   const onStarted = vi.fn();
   let controlState = {
     status: "ready",
@@ -170,13 +171,19 @@ function setup() {
   });
   const mount = () =>
     render(
-      <NewMessage session={session} scope={scope} onStarted={onStarted} />,
+      <NewMessage
+        session={session}
+        scope={scope}
+        onOpened={onOpened}
+        onStarted={onStarted}
+      />,
     );
   return {
     session,
     directMessages,
     messages,
     outbox,
+    onOpened,
     onStarted,
     mount,
     control,
@@ -298,7 +305,7 @@ it("opens blank and focused, adds multiple recipients, deduplicates, and enforce
   expect(screen.getAllByRole("option")).toHaveLength(10);
   await t.user.type(recipient(), "Person 2");
   await screen.findByRole("option", { name: "Person 2, Agent" });
-  await t.user.keyboard("{Enter}");
+  await t.user.keyboard("{ArrowDown}{Enter}");
   expect(recipient()).toHaveValue("");
   expect(recipient()).toHaveFocus();
   expect(screen.getByRole("button", { name: "Remove Person 2" })).toBeVisible();
@@ -306,7 +313,7 @@ it("opens blank and focused, adds multiple recipients, deduplicates, and enforce
     await waitFor(() =>
       expect(screen.getAllByRole("option").length).toBeGreaterThan(0),
     );
-    await t.user.keyboard("{Enter}");
+    await t.user.keyboard("{ArrowDown}{Enter}");
   }
   expect(
     screen.getAllByRole("button", { name: /^Remove Person/ }),
@@ -319,6 +326,52 @@ it("opens blank and focused, adds multiple recipients, deduplicates, and enforce
   expect(t.directMessages.open).not.toHaveBeenCalled();
 });
 
+it("opens the exact conversation without sending a message", async () => {
+  const t = setup();
+  t.mount();
+  await t.user.click(await screen.findByRole("option", { name: "Person 1" }));
+
+  await t.user.click(screen.getByRole("button", { name: "Open conversation" }));
+
+  await waitFor(() => expect(t.onOpened).toHaveBeenCalledWith(channel));
+  expect(t.directMessages.open).toHaveBeenCalledWith(
+    [people[0]?.pubkey],
+    expect.any(AbortSignal),
+  );
+  expect(t.messages.send).not.toHaveBeenCalled();
+  expect(t.onStarted).not.toHaveBeenCalled();
+});
+
+it("requires an arrow key before Enter selects a recipient", async () => {
+  const t = setup();
+  t.mount();
+  await screen.findByRole("option", { name: "Person 1" });
+
+  await t.user.keyboard("{Enter}");
+  expect(
+    screen.queryByRole("button", { name: "Remove Person 1" }),
+  ).not.toBeInTheDocument();
+
+  await t.user.keyboard("{ArrowDown}{Enter}");
+  expect(screen.getByRole("button", { name: "Remove Person 1" })).toBeVisible();
+});
+
+it("matches an exact public key without exposing short key substrings", async () => {
+  const t = setup();
+  t.mount();
+  await screen.findByRole("option", { name: "Person 1" });
+
+  await t.user.type(recipient(), people[0]?.pubkey ?? "");
+  expect(await screen.findByRole("option", { name: "Person 1" })).toBeVisible();
+  await t.user.clear(recipient());
+  await t.user.type(recipient(), (people[0]?.pubkey ?? "").slice(0, 7));
+  await waitFor(() =>
+    expect(
+      screen.queryByRole("option", { name: "Person 1" }),
+    ).not.toBeInTheDocument(),
+  );
+});
+
 it("removes once for pointerdown plus click, then Backspace; effects outlive chips", async () => {
   const t = setup();
   t.mount();
diff --git a/src/features/direct-messages/NewMessage.tsx b/src/features/direct-messages/NewMessage.tsx
index ba8d1539b..353e8c9bb 100644
--- a/src/features/direct-messages/NewMessage.tsx
+++ b/src/features/direct-messages/NewMessage.tsx
@@ -104,18 +104,20 @@ function recovered(operations: readonly OutgoingEvent[], viewer?: string) {
   };
 }
 
-/** Empty conversation until its first message is confirmed by the regular outbox. */
+/** Recipient-first conversation that can open directly or send through the durable outbox. */
 export function NewMessage({
   session,
   scope,
   extensions,
   onPreparing,
+  onOpened,
   onStarted,
 }: {
   session: RelaySession;
   scope: string;
   extensions?: ConversationExtensions | undefined;
   onPreparing?(pubkeys: readonly string[]): void;
+  onOpened(channelId: string): void;
   onStarted(channelId: string, messageId: string): void;
 }) {
   const [recipients, setRecipients] = useState(() =>
@@ -130,7 +132,7 @@ export function NewMessage({
   const [restoredDraft, setRestoredDraft] = useState<MentionDraft>();
   const [draftRevision, setDraftRevision] = useState(0);
   const retiring = useRef<string | undefined>(undefined);
-  const [busy, setBusy] = useState(false);
+  const [busy, setBusy] = useState<"opening" | "sending" | undefined>();
   const [error, setError] = useState("");
   const [draftChannel] = useState(() => crypto.randomUUID());
   const attempt = useRef<AbortController | null>(null);
@@ -149,7 +151,7 @@ export function NewMessage({
   }
   const failed =
     pending && session.directMessages.delivery(pending.id) === "failed";
-  const locked = !ready || busy || (!!pending && !failed);
+  const locked = !ready || !!busy || (!!pending && !failed);
   useLayoutEffect(() => {
     const confirmed = pending && session.directMessages.delivery(pending.id);
     if (pending) {
@@ -233,6 +235,38 @@ export function NewMessage({
     writeView(scope, "direct-message:recipients", people.map(recipientView));
     setError("");
   }
+  async function open() {
+    if (
+      attempt.current ||
+      !ready ||
+      !recipients.length ||
+      !session.directMessages.available
+    )
+      return;
+    const controller = new AbortController();
+    attempt.current = controller;
+    setBusy("opening");
+    setError("");
+    try {
+      validateAgents();
+      const pubkeys = recipients.map((person) => person.pubkey);
+      onPreparing?.(pubkeys);
+      const id = await session.directMessages.open(pubkeys, controller.signal);
+      controller.signal.throwIfAborted();
+      clearView(scope, "direct-message:recipients");
+      onOpened(id);
+    } catch (reason) {
+      if (!controller.signal.aborted)
+        setError(
+          reason instanceof Error
+            ? reason.message
+            : "Could not open the conversation. Try again.",
+        );
+    } finally {
+      if (!controller.signal.aborted) setBusy(undefined);
+      if (attempt.current === controller) attempt.current = null;
+    }
+  }
   async function send(draft: MentionDraft) {
     if (
       attempt.current ||
@@ -244,7 +278,7 @@ export function NewMessage({
       return;
     const controller = new AbortController();
     attempt.current = controller;
-    setBusy(true);
+    setBusy("sending");
     setError("");
     const key = keyFor(recipients);
     let current: Pending | undefined = pending;
@@ -321,7 +355,7 @@ export function NewMessage({
             : "Could not send your message. Try again.",
         );
     } finally {
-      if (!controller.signal.aborted) setBusy(false);
+      if (!controller.signal.aborted) setBusy(undefined);
       if (attempt.current === controller) attempt.current = null;
     }
   }
@@ -335,7 +369,20 @@ export function NewMessage({
       />
       <div className={styles.blank} data-new-message-body="" />
       <div className={styles.feedback}>
-        {busy && <p role="status">Sending message…</p>}
+        {recipients.length > 0 && !pending && (
+          <Button
+            type="button"
+            disabled={locked || !session.directMessages.available}
+            onClick={() => void open()}
+          >
+            Open conversation
+          </Button>
+        )}
+        {busy && (
+          <p role="status">
+            {busy === "opening" ? "Opening conversation…" : "Sending message…"}
+          </p>
+        )}
         {!session.directMessages.available && (
           <p role="status">
             Starting direct messages is unavailable on this connection.
@@ -355,7 +402,7 @@ export function NewMessage({
             {pending && !failed && (
               <Button
                 type="button"
-                disabled={busy}
+                disabled={!!busy}
                 onClick={() => pending && void send(pending.draft)}
               >
                 Retry send
@@ -381,7 +428,7 @@ export function NewMessage({
             locked,
             disabled:
               !ready ||
-              busy ||
+              !!busy ||
               !recipients.length ||
               !session.directMessages.available,
             submit: (draft) => void send(draft),
diff --git a/src/features/direct-messages/RecipientPicker.tsx b/src/features/direct-messages/RecipientPicker.tsx
index b026e17cb..2f7db42f3 100644
--- a/src/features/direct-messages/RecipientPicker.tsx
+++ b/src/features/direct-messages/RecipientPicker.tsx
@@ -42,12 +42,53 @@ export function RecipientPicker({
   );
   const removal = useChipRemoval();
   const atLimit = selected.length >= 8;
-  const candidates = directory.people.filter(
+  const existing = new Set<string>();
+  const interacted = new Set<string>();
+  const shared = new Set<string>();
+  for (const channel of session.channels.list().channels) {
+    for (const pubkey of channel.members ?? []) shared.add(pubkey);
+    if (channel.channelType !== "dm") continue;
+    for (const pubkey of channel.participants ?? []) interacted.add(pubkey);
+    if (channel.participants?.length === 1) {
+      const pubkey = channel.participants[0];
+      if (pubkey) existing.add(pubkey);
+    }
+  }
+  const relationshipRank = (person: Recipient) =>
+    !query.trim()
+      ? 0
+      : existing.has(person.pubkey)
+        ? 0
+        : interacted.has(person.pubkey)
+          ? 1
+          : controlled.has(person.pubkey)
+            ? 2
+            : shared.has(person.pubkey)
+              ? 3
+              : 4;
+  const eligible = directory.people.filter(
     (person) =>
       person.pubkey !== session.viewer &&
       (!person.isAgent || controlled.has(person.pubkey)) &&
       !selected.some((item) => item.pubkey === person.pubkey),
   );
+  const ordered = useRef<{ query: string; pubkeys: string[] }>({
+    query,
+    pubkeys: [],
+  });
+  if (ordered.current.query !== query) ordered.current = { query, pubkeys: [] };
+  const knownOrder = new Set(ordered.current.pubkeys);
+  ordered.current.pubkeys.push(
+    ...eligible
+      .filter((person) => !knownOrder.has(person.pubkey))
+      .sort((left, right) => relationshipRank(left) - relationshipRank(right))
+      .map((person) => person.pubkey),
+  );
+  const byPubkey = new Map(eligible.map((person) => [person.pubkey, person]));
+  const candidates = ordered.current.pubkeys.flatMap((pubkey) => {
+    const person = byPubkey.get(pubkey);
+    return person ? [person] : [];
+  });
   // Remember eligible namesakes while search text and selection change.
   const known = useRef(new Map<string, Recipient>());
   for (const person of [...candidates, ...selected])
@@ -67,9 +108,9 @@ export function RecipientPicker({
   const discriminator = (person: Recipient) => identities.get(person.pubkey);
   const label = (person: Recipient) =>
     [person.name, discriminator(person)].filter(Boolean).join(" ");
-  const active =
-    candidates.find((person) => person.pubkey === highlight.pubkey) ??
-    candidates[0];
+  const active = candidates.find(
+    (person) => person.pubkey === highlight.pubkey,
+  );
   const loadingRows = useRef(10);
   useEffect(() => {
     if (!directory.loading && !directory.error)
diff --git a/src/features/direct-messages/usePeople.ts b/src/features/direct-messages/usePeople.ts
index 862e99522..fcc301a62 100644
--- a/src/features/direct-messages/usePeople.ts
+++ b/src/features/direct-messages/usePeople.ts
@@ -32,7 +32,11 @@ function empty(session: RelaySession, query: string): PeopleState {
 }
 function matching(people: Recipient[], query: string) {
   const needle = normalize(query.trim());
-  return people.filter((person) => normalize(person.name).includes(needle));
+  return people.filter(
+    (person) =>
+      normalize(person.name).includes(needle) ||
+      (needle.length >= 8 && person.pubkey.startsWith(needle)),
+  );
 }
 export function usePeople(session: RelaySession, query: string) {
   const cache = useMemo(() => {
diff --git a/src/features/relay/direct-messages.test.ts b/src/features/relay/direct-messages.test.ts
index 92bdc7417..2cdbee18d 100644
--- a/src/features/relay/direct-messages.test.ts
+++ b/src/features/relay/direct-messages.test.ts
@@ -184,6 +184,30 @@ it("reads paginated verified profiles, excludes the viewer, and cancels with the
   }
 });
 
+it("reads an exact public-key profile without widening directory search", async () => {
+  const t = setup();
+  try {
+    const result = await t.dm.people(
+      t.other.pubkey,
+      1,
+      new AbortController().signal,
+    );
+    expect(result.people).toEqual([
+      expect.objectContaining({ pubkey: t.other.pubkey, name: "Other" }),
+    ]);
+    expect(t.query.mock.calls.at(-1)?.[0]).toEqual([
+      {
+        kinds: [0],
+        authors: [t.other.pubkey],
+        limit: 30,
+        page: 1,
+      },
+    ]);
+  } finally {
+    t.owner.dispose();
+  }
+});
+
 it.each(["", "C"])(
   "keeps large-profile pages within the read budget without skipping matches: %s",
   async (query) => {
diff --git a/src/features/relay/direct-messages.ts b/src/features/relay/direct-messages.ts
index 040b5f0db..b3336b3d3 100644
--- a/src/features/relay/direct-messages.ts
+++ b/src/features/relay/direct-messages.ts
@@ -29,7 +29,9 @@ export function createDirectMessages(
         throw new Error("Invalid people search.");
       // Both browse and search profiles can carry large metadata. Keep pages
       // small; the second browse page overlaps the preview and is deduplicated.
-      const browsing = !query.trim();
+      const value = query.trim();
+      const browsing = !value;
+      const exactKey = /^[0-9a-f]{64}$/.test(value);
       const limit = browsing && page === 1 ? 15 : 30;
       const relayPage = browsing && page > 1 ? page - 1 : page;
       const events = await directoryReader.read(
@@ -38,9 +40,11 @@ export function createDirectMessages(
             kinds: [0],
             limit,
             page: relayPage,
-            ...(query.trim()
-              ? { search: query.trim(), search_mode: "prefix" as const }
-              : {}),
+            ...(exactKey
+              ? { authors: [value] }
+              : value
+                ? { search: value, search_mode: "prefix" as const }
+                : {}),
           },
         ],
         { signal: active, priority: page === 1 ? "foreground" : "background" },
diff --git a/tests/browser/new-message.spec.mjs b/tests/browser/new-message.spec.mjs
index 33e51a365..0a49fb67b 100644
--- a/tests/browser/new-message.spec.mjs
+++ b/tests/browser/new-message.spec.mjs
@@ -479,6 +479,7 @@ test("empty compose, keyboard selection, pagination, removal effects, retry, the
   });
   expect(app.reads.filter((filter) => filter.search).length).toBe(searchReads);
   app.showPeople();
+  await input.press("ArrowDown");
   await input.press("Enter");
   await expect(input).toBeFocused();
   await expect(input).toHaveValue("");
@@ -691,11 +692,15 @@ test("profile Message opens a fresh DM and restores a hidden one", async ({
     .getByRole("button", { name: "Remove Avery Chen from DMs" })
     .click();
   await expect(sidebarDm).toHaveCount(0);
+  await page.reload();
+  await expect(sidebarDm).toHaveCount(0);
   await openProfileMessage();
   await expect(sidebarDm).toBeVisible();
   await expect(
     page.getByRole("textbox", { name: "Message #Avery Chen" }),
   ).toBeVisible();
+  await page.reload();
+  await expect(sidebarDm).toBeVisible();
   expect(app.commands).toHaveLength(2);
   expect(app.errors).toEqual([]);
 });

From e3826c8b53224decd47f2f76e26d8f235e0ef34f Mon Sep 17 00:00:00 2001
From: Clay Delk <clay.delk@gmail.com>
Date: Fri, 25 Sep 2026 09:47:27 -0400
Subject: [PATCH 2/3] test(messages): synchronize directory resume

Signed-off-by: Clay Delk <clay.delk@gmail.com>
---
 src/features/direct-messages/NewMessage.test.tsx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/features/direct-messages/NewMessage.test.tsx b/src/features/direct-messages/NewMessage.test.tsx
index ce46a9704..7cfc7f970 100644
--- a/src/features/direct-messages/NewMessage.test.tsx
+++ b/src/features/direct-messages/NewMessage.test.tsx
@@ -600,9 +600,8 @@ it("keeps loaded pages when clearing search or returning to New message, scoped
   expect(screen.getAllByRole("option").map((row) => row.textContent)).toEqual(
     loaded,
   );
-  expect(t.directMessages.people).toHaveBeenCalledTimes(requests);
-  fireEvent.scroll(screen.getByRole("listbox"));
   await screen.findByRole("option", { name: "Person 3" });
+  expect(t.directMessages.people).toHaveBeenCalledTimes(requests + 1);
   expect(t.directMessages.people).toHaveBeenLastCalledWith(
     "",
     3,

From 8fb04cc2a94abf53b9fd0d97ba790d1ea5774e2f Mon Sep 17 00:00:00 2001
From: Clay Delk <clay.delk@gmail.com>
Date: Fri, 25 Sep 2026 11:23:05 -0400
Subject: [PATCH 3/3] fix(messages): require exact recipient keys

Signed-off-by: Clay Delk <clay.delk@gmail.com>
---
 src/features/direct-messages/NewMessage.test.tsx | 16 +++++++++-------
 src/features/direct-messages/usePeople.ts        |  2 +-
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/features/direct-messages/NewMessage.test.tsx b/src/features/direct-messages/NewMessage.test.tsx
index 7cfc7f970..f27a8319f 100644
--- a/src/features/direct-messages/NewMessage.test.tsx
+++ b/src/features/direct-messages/NewMessage.test.tsx
@@ -363,13 +363,15 @@ it("matches an exact public key without exposing short key substrings", async ()
 
   await t.user.type(recipient(), people[0]?.pubkey ?? "");
   expect(await screen.findByRole("option", { name: "Person 1" })).toBeVisible();
-  await t.user.clear(recipient());
-  await t.user.type(recipient(), (people[0]?.pubkey ?? "").slice(0, 7));
-  await waitFor(() =>
-    expect(
-      screen.queryByRole("option", { name: "Person 1" }),
-    ).not.toBeInTheDocument(),
-  );
+  for (const length of [8, 40]) {
+    await t.user.clear(recipient());
+    await t.user.type(recipient(), (people[0]?.pubkey ?? "").slice(0, length));
+    await waitFor(() =>
+      expect(
+        screen.queryByRole("option", { name: "Person 1" }),
+      ).not.toBeInTheDocument(),
+    );
+  }
 });
 
 it("removes once for pointerdown plus click, then Backspace; effects outlive chips", async () => {
diff --git a/src/features/direct-messages/usePeople.ts b/src/features/direct-messages/usePeople.ts
index fcc301a62..8ce940352 100644
--- a/src/features/direct-messages/usePeople.ts
+++ b/src/features/direct-messages/usePeople.ts
@@ -35,7 +35,7 @@ function matching(people: Recipient[], query: string) {
   return people.filter(
     (person) =>
       normalize(person.name).includes(needle) ||
-      (needle.length >= 8 && person.pubkey.startsWith(needle)),
+      (/^[0-9a-f]{64}$/.test(needle) && person.pubkey === needle),
   );
 }
 export function usePeople(session: RelaySession, query: string) {