fix(desktop): keep the space after a mention through the markdown parse

desktop/src/features/messages/lib/markdownTrailingWhitespace.test.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { markdownTrailingWhitespace } from "./markdownTrailingWhitespace.ts";
+
+// The markdown parse behind `setContent` drops end-of-line whitespace, which
+// silently breaks mention chips (`@Name ` → `@Name`, next keystroke →
+// `@Nameabc`, recipient dropped). This decides what gets put back.
+
+test("captures the single trailing space after a mention", () => {
+  assert.equal(markdownTrailingWhitespace("@Morgarita "), " ");
+});
+
+test("captures the trailing space after multiple mentions", () => {
+  assert.equal(markdownTrailingWhitespace("@Vogue @Morgarita "), " ");
+});
+
+test("returns null when there is no trailing whitespace", () => {
+  assert.equal(markdownTrailingWhitespace("@Morgarita"), null);
+  assert.equal(markdownTrailingWhitespace(""), null);
+});
+
+test("returns null for whitespace-only input", () => {
+  // Nothing to trail. Restoring here would leave a composer that reads as
+  // non-empty — Send enabled, placeholder suppressed — on an empty draft.
+  assert.equal(markdownTrailingWhitespace(" "), null);
+  assert.equal(markdownTrailingWhitespace("   \t"), null);
+});
+
+test("captures a mixed run of spaces and tabs", () => {
+  assert.equal(markdownTrailingWhitespace("@Morgarita \t "), " \t ");
+});
+
+test("captures whitespace trailing the last line only", () => {
+  assert.equal(markdownTrailingWhitespace("first line\n@Morgarita "), " ");
+});
+
+test("returns null when the string ends on a newline", () => {
+  // The caret lands on the empty final line, so nothing needs restoring.
+  assert.equal(markdownTrailingWhitespace("@Morgarita \n"), null);
+});
+
+test("ignores interior whitespace", () => {
+  assert.equal(markdownTrailingWhitespace("@Morgarita  hello"), null);
+});

desktop/src/features/messages/lib/markdownTrailingWhitespace.ts

@@ -0,0 +1,58 @@
+import type { Editor } from "@tiptap/core";
+import { Selection } from "@tiptap/pm/state";
+
+/**
+ * The run of spaces/tabs at the very end of `markdown`, or `null` when there
+ * is none.
+ *
+ * A whitespace-only string yields `null` on purpose: there is no content for
+ * the whitespace to trail, and restoring it would leave a "blank" composer
+ * that reads as non-empty (enabling Send, suppressing the placeholder).
+ */
+export function markdownTrailingWhitespace(markdown: string): string | null {
+  return /[^ \t]([ \t]+)$/.exec(markdown)?.[1] ?? null;
+}
+
+/**
+ * Re-append trailing spaces/tabs that a markdown parse dropped.
+ *
+ * `setContent` runs its argument through `tiptap-markdown`, and markdown-it
+ * discards end-of-line whitespace — `"@Name "` parses to `<p>@Name</p>`. That
+ * lone character is load-bearing: mention chips are inline decorations over
+ * plain text (see `mentionHighlightExtension`), matched only when a boundary
+ * follows the name. Restore the caret flush against `@Name` and the next
+ * keystroke produces `@Nameabc`, which stops matching — the chip disappears
+ * and `extractMentionPubkeys` no longer resolves the name, so the recipient is
+ * silently dropped from the outgoing event.
+ *
+ * The whitespace survives *serialization* (drafts on disk keep it), so it is
+ * recoverable here, at the single parse boundary, rather than at each of the
+ * call sites that reload composer content: post-send refill, draft restore on
+ * channel/thread switch, loading a message to edit, cancelling an edit, and
+ * restoring after a failed send.
+ *
+ * Uses the `preventUpdate` meta so the repair is invisible to the user-edit
+ * observers — the same mechanism `setContent`'s `emitUpdate: false` uses.
+ * Without it the insert looks like a keystroke and re-opens the mention
+ * autocomplete on every channel switch.
+ */
+export function restoreMarkdownTrailingWhitespace(
+  editor: Editor,
+  markdown: string,
+): void {
+  const trailing = markdownTrailingWhitespace(markdown);
+  if (!trailing) return;
+
+  const end = Selection.atEnd(editor.state.doc).from;
+  // Idempotence guard: if the parser ever starts preserving the whitespace,
+  // this must not double it.
+  const existing = editor.state.doc.textBetween(
+    Math.max(0, end - trailing.length),
+    end,
+  );
+  if (existing === trailing) return;
+
+  editor.view.dispatch(
+    editor.state.tr.insertText(trailing, end).setMeta("preventUpdate", true),
+  );
+}

desktop/src/features/messages/lib/useRichTextEditor.ts

@@ -26,6 +26,7 @@ import {
   mentionHighlightKey,
 } from "./mentionHighlightExtension";
 import { CUSTOM_EMOJI_NODE_NAME } from "./customEmojiNode";
+import { restoreMarkdownTrailingWhitespace } from "./markdownTrailingWhitespace";
 import { useComposerCustomEmoji } from "./useComposerCustomEmoji";
 import { buildPlainTextProjection } from "./plainTextProjection";
 import { createLinkInteractionExtension } from "./linkInteractionExtension";
@@ -681,6 +682,7 @@ export function useRichTextEditor({
     (markdown: string) => {
       if (!editor) return;
       editor.commands.setContent(markdown);
+      restoreMarkdownTrailingWhitespace(editor, markdown);
     },
     [editor],
   );
@@ -689,13 +691,12 @@ export function useRichTextEditor({
     (markdown: string) => {
       if (!editor) return;
       // The caller already synchronizes composer state. Keep this programmatic
-      // restoration out of user-edit observers (autocomplete/reconciliation),
-      // then move selection in the same command chain.
-      editor
-        .chain()
-        .setContent(markdown, { emitUpdate: false })
-        .focus("end")
-        .run();
+      // restoration out of user-edit observers (autocomplete/reconciliation).
+      editor.commands.setContent(markdown, { emitUpdate: false });
+      // Repair before focusing: the caret must land *after* any trailing
+      // whitespace the parse dropped, not flush against the last character.
+      restoreMarkdownTrailingWhitespace(editor, markdown);
+      editor.commands.focus("end");
     },
     [editor],
   );

desktop/tests/e2e/persistent-agent-audience.spec.ts

@@ -66,6 +66,25 @@ async function emitRootMessage(
   return event;
 }
 
+/**
+ * Assert the composer's *exact* text, trailing whitespace included.
+ *
+ * `toHaveText` normalizes whitespace, so `"@Morgarita"` and `"@Morgarita "`
+ * both satisfy it — which is how a dropped trailing space shipped past an
+ * assertion written to guard that very space. Mention chips are decorations
+ * over plain text and only match when a boundary follows the name, so the
+ * space is the difference between the next keystroke starting a message and
+ * it corrupting the mention.
+ */
+async function expectExactComposerText(
+  input: ReturnType<Page["getByTestId"]>,
+  expected: string,
+) {
+  await expect
+    .poll(() => input.evaluate((element) => element.textContent))
+    .toBe(expected);
+}
+
 function channelComposer(page: Page) {
   return page.getByTestId("channel-composer-overlay");
 }
@@ -147,7 +166,7 @@ test("persistent agents transition atomically before Enter-send resolves", async
 
   // The network send is still pending, so this is the first observable
   // post-submit editor state rather than the later success hydration pass.
-  await expect(input).toHaveText("@Morgarita ", { timeout: 500 });
+  await expectExactComposerText(input, "@Morgarita ");
   await expect(input.locator(".agent-mention-highlight")).toHaveCount(1, {
     timeout: 500,
   });
@@ -186,6 +205,52 @@ test("persistent agents transition atomically before Enter-send resolves", async
     .toEqual({ empty: true, atDocumentEnd: true });
 });
 
+test("typing straight after a send extends the message, not the mention", async ({
+  page,
+}) => {
+  await seedAudience(page, [AGENT_A]);
+  await installAudienceFixtures(page);
+  await openThread(page);
+
+  const composer = threadComposer(page);
+  const input = composer.getByTestId("message-input");
+  await input.fill("@Morgarita hello");
+  await input.press("Enter");
+
+  // The post-send refill goes through the markdown parse, which used to eat
+  // the trailing space and leave the caret flush against the mention.
+  await expectExactComposerText(input, "@Morgarita ");
+  await input.pressSequentially("next");
+
+  await expect(input).toHaveText("@Morgarita next");
+  await expect(input.locator(".agent-mention-highlight")).toHaveCount(1);
+});
+
+test("a mention survives the draft round-trip when a thread is reopened", async ({
+  page,
+}) => {
+  await seedAudience(page, [AGENT_A]);
+  await installAudienceFixtures(page);
+  await openThread(page);
+
+  const composer = threadComposer(page);
+  const input = composer.getByTestId("message-input");
+  await expectExactComposerText(input, "@Morgarita ");
+
+  // Leaving the thread persists the composer to the draft store; returning
+  // reloads it through the same markdown parse. Hydration cannot repair the
+  // result — it only inserts mentions that are *absent*, and this one is
+  // present, just unspaced.
+  await openGeneral(page);
+  await openThread(page);
+
+  await expectExactComposerText(input, "@Morgarita ");
+  await input.pressSequentially("hi");
+
+  await expect(input).toHaveText("@Morgarita hi");
+  await expect(input.locator(".agent-mention-highlight")).toHaveCount(1);
+});
+
 test("timeline agent send remains one-shot and returns to the placeholder", async ({
   page,
 }) => {