fix(ai-chat): «send now» во время detached-run — авторитетный серверный stop + ограниченный ретрай 409 (#396)

В автономном режиме «Interrupt and send now» во время живого detached-run делал
только локальный stop() (abort SSE), который сервер игнорирует (run живёт по
дизайну #184/#234), поэтому onFinish→flush новый POST упирался в гейт «один
активный run на чат» → 409 A_RUN_ALREADY_ACTIVE, новый turn не стартовал.
handleStop делает правильно (доп. onServerStop), sendNow — нет. Вариант A
(клиентский, горячий путь сервера не тронут):

- sendNow в автономном режиме дополнительно зовёт onServerStop(chatId) (или
  откладывает через stopPendingRef, если chatId ещё не усыновлён — как
  handleStop) и взводит one-shot supersedeRetryRef ДО stop();
- транспорт-fetch на supersede-отправке (и только на ней) ретраит РОВНО 409 с
  body.code===A_RUN_ALREADY_ACTIVE до 4 попыток с бэкоффом 150/300/600ms;
  onServerStop гарантирует осадку run → ретрай сходится. Обычная отправка (не
  взведён флаг) падает на 409 мгновенно. isRunAlreadyActive читает
  response.clone() → тело оригинала возвращается потребителю нетронутым.
  409 всегда до записи user-строки (pre-check/beginRun раньше insert) → повтор
  POST безопасен, дублей нет.

Внутренний цикл: 2 прохода. Ревью нашло CRITICAL: supersedeRetryRef застревал
взведённым, когда sendNow взвёл, но POST не ушёл (promoted head удалён →
flushNext() false; либо wasResumed-return) — следующая обычная отправка молча
ретраила настоящий 409. Починка: разоружать флаг симметрично остальным one-shot
(в ветке !flushNext() и в isStreaming-defuse-эффекте); транспорт read-and-clear
на входе каждой отправки. Мутационно: убрать disarm → strand-тест краснеет
(4 вызова вместо 1). Легаси-режим не тронут (регресс-гард).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/client/src/features/ai-chat/components/chat-thread.test.tsx

@@ -28,7 +28,10 @@ const h = vi.hoisted(() => ({
         body: Record<string, unknown>;
       }) => { body: Record<string, unknown> };
       prepareReconnectToStreamRequest?: () => { api?: string };
-      fetch?: (input: unknown, init?: { method?: string }) => Promise<unknown>;
+      fetch?: (
+        input: unknown,
+        init?: { method?: string; body?: unknown },
+      ) => Promise<unknown>;
     },
   },
 }));
@@ -200,6 +203,244 @@ describe("ChatThread — send now (#198)", () => {
   });
 });
 
+// #396: in autonomous mode a live sendNow must additionally request the
+// AUTHORITATIVE server stop of the detached run (a local abort is only a client
+// disconnect the server ignores) and arm a bounded 409 retry so the re-POST
+// converges once the one-active-run slot frees. Legacy mode is unchanged.
+describe("ChatThread — send now server-stop + supersede retry (#396)", () => {
+  beforeEach(resetState);
+  afterEach(cleanup);
+
+  // A settled assistant tail => no mount resume (attemptResumeRef false), so the
+  // "Send now" button is visible for the NEW local streaming turn while
+  // autonomous runs are enabled.
+  const settledTail = () => [
+    row("u1", "user", undefined, "hi"),
+    row("a1", "assistant", "succeeded", "done"),
+  ];
+
+  it("autonomous: sendNow during a live stream calls onServerStop with the chat id", () => {
+    const { onServerStop } = renderThread({
+      autonomousRunsEnabled: true,
+      initialRows: settledTail(),
+    });
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+
+    expect(h.state.stop).toHaveBeenCalledTimes(1);
+    expect(onServerStop).toHaveBeenCalledWith("c1");
+  });
+
+  it("legacy (autonomous off): sendNow does NOT call onServerStop and does NOT retry the send", async () => {
+    const { onServerStop } = renderThread({
+      autonomousRunsEnabled: false,
+      initialRows: settledTail(),
+    });
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+    expect(onServerStop).not.toHaveBeenCalled();
+
+    // The supersede retry must NOT be armed: a POST that 409s is returned as-is
+    // (single fetch, no retry).
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValue(
+        new Response(JSON.stringify({ code: "A_RUN_ALREADY_ACTIVE" }), {
+          status: 409,
+        }),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(res.status).toBe(409);
+  });
+
+  it("armed supersede send retries 409 A_RUN_ALREADY_ACTIVE and succeeds once the slot frees", async () => {
+    renderThread({ autonomousRunsEnabled: true, initialRows: settledTail() });
+    // Arm the retry by performing a live sendNow (autonomous branch sets the ref).
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+
+    const fetchMock = vi
+      .fn()
+      // First POST: the old detached run still holds the slot -> 409.
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ code: "A_RUN_ALREADY_ACTIVE" }), {
+          status: 409,
+        }),
+      )
+      // Retry: the server stop settled the old run -> 200.
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(res.status).toBe(200);
+  });
+
+  it("supersede retry is one-shot: a later send (ref cleared) does NOT retry a 409", async () => {
+    renderThread({ autonomousRunsEnabled: true, initialRows: settledTail() });
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now")); // arms the one-shot
+
+    // First armed send: immediately succeeds, consuming the arm.
+    let fetchMock = vi
+      .fn()
+      .mockResolvedValue(new Response("ok", { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+    await act(async () => {
+      await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      });
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+
+    // A subsequent send is NOT armed -> a 409 is returned as-is (no retry).
+    fetchMock = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ code: "A_RUN_ALREADY_ACTIVE" }), {
+        status: 409,
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(res.status).toBe(409);
+  });
+
+  it("supersede retry is bounded: exhaustion surfaces the 409 error", async () => {
+    renderThread({ autonomousRunsEnabled: true, initialRows: settledTail() });
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+
+    // Every attempt 409s -> after 4 attempts the last 409 surfaces.
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ code: "A_RUN_ALREADY_ACTIVE" }), {
+        status: 409,
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    // 4 attempts total (1 immediate + 3 backoff retries), then give up.
+    expect(fetchMock).toHaveBeenCalledTimes(4);
+    expect(res.status).toBe(409);
+  });
+
+  it("armed supersede send does NOT retry a non-409 status", async () => {
+    renderThread({ autonomousRunsEnabled: true, initialRows: settledTail() });
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValue(new Response("boom", { status: 500 }));
+    vi.stubGlobal("fetch", fetchMock);
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(res.status).toBe(500);
+  });
+
+  // Strand-path regression: sendNow arms the supersede retry, but if the promoted
+  // head is removed before the abort's onFinish lands, flushNext() sends nothing
+  // (returns false) and NO re-POST consumes the arm. The arm must be disarmed on
+  // that no-send branch so the NEXT unrelated NORMAL send does not inherit it and
+  // silently retry a genuine 409 (e.g. a legitimate two-tab conflict) 4x instead
+  // of surfacing it immediately.
+  it("strand-path: a stranded supersede arm (flushNext no-send) does NOT retry a later normal 409", async () => {
+    renderThread({ autonomousRunsEnabled: true, initialRows: settledTail() });
+    // Arm the retry via a live autonomous sendNow (promotes the head + arms).
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+
+    // Remove the promoted head BEFORE the abort lands, so flushNext() returns
+    // false (no POST) and the arm would strand without the disarm fix.
+    fireEvent.click(screen.getByLabelText("Remove queued message"));
+
+    // The abort's onFinish now takes the flushOnAbortRef branch, calls flushNext()
+    // which finds an empty queue and returns false -> the no-send disarm must run.
+    act(() => {
+      h.state.onFinish?.({
+        message: { id: "a1", role: "assistant", parts: [] },
+        isAbort: true,
+        isDisconnect: false,
+        isError: false,
+      });
+    });
+    // No re-POST was sent (nothing to flush).
+    expect(h.state.sendMessage).not.toHaveBeenCalled();
+
+    // A subsequent NORMAL send that 409s must be returned as-is (exactly 1 fetch):
+    // the stranded arm must NOT cause the genuine 409 to be retried.
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValue(
+        new Response(JSON.stringify({ code: "A_RUN_ALREADY_ACTIVE" }), {
+          status: 409,
+        }),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(res.status).toBe(409);
+  });
+
+  it("armed supersede send does NOT retry a 409 with a different (non-A_RUN_ALREADY_ACTIVE) body", async () => {
+    renderThread({ autonomousRunsEnabled: true, initialRows: settledTail() });
+    fireEvent.click(screen.getByTestId("queue-btn"));
+    fireEvent.click(screen.getByLabelText("Send now"));
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ code: "SOMETHING_ELSE" }), {
+        status: 409,
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    let res!: Response;
+    await act(async () => {
+      res = (await h.state.transport!.fetch!("http://x", {
+        method: "POST",
+        body: "{}",
+      })) as Response;
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(res.status).toBe(409);
+  });
+});
+
 // #388: the editor selection is snapshotted at send time and nested inside
 // openPage on the wire. The getter is read live from a ref, so each send ships a
 // fresh snapshot.

apps/client/src/features/ai-chat/components/chat-thread.tsx

@@ -70,6 +70,36 @@ const RECONNECT_MAX_ATTEMPTS = 5;
 // Backoff before attempt N (1-based): 1s, 2s, 4s, 8s, 16s.
 const RECONNECT_BASE_DELAY_MS = 1000;
 
+// #396: bounded retry for the "Interrupt and send now" re-send when it races the
+// authoritative server stop of the just-superseded detached run. The re-POST can
+// arrive before the old run has released the one-active-run slot, so the server
+// returns 409 A_RUN_ALREADY_ACTIVE. The server stop guarantees the slot frees, so
+// a few short backoffs converge. 4 total attempts: attempt 1 fires immediately,
+// then these are the waits BEFORE attempts 2, 3 and 4 (150ms, 300ms, 600ms). If
+// all 4 attempts 409, the last 409 surfaces (the banner) — acceptable per #396.
+const SUPERSEDE_RETRY_DELAYS_MS = [150, 300, 600];
+// The server error code that means "another run is already active for this chat".
+const A_RUN_ALREADY_ACTIVE = "A_RUN_ALREADY_ACTIVE";
+
+/**
+ * #396: defensively decide whether a 409 response is the one-active-run gate
+ * rejection (code A_RUN_ALREADY_ACTIVE) vs. some other 409. Reads a CLONE so the
+ * original response body stays intact for the caller when it is returned as-is.
+ * Any parse failure or unexpected shape => false (do NOT retry).
+ */
+async function isRunAlreadyActive(response: Response): Promise<boolean> {
+  try {
+    const body = (await response.clone().json()) as unknown;
+    return (
+      typeof body === "object" &&
+      body !== null &&
+      (body as { code?: unknown }).code === A_RUN_ALREADY_ACTIVE
+    );
+  } catch {
+    return false;
+  }
+}
+
 /** The page the user is currently viewing, sent as chat context. */
 export interface OpenPageContext {
   id: string;
@@ -326,6 +356,26 @@ export default function ChatThread({
   const flushOnAbortRef = useRef(false);
   const interruptNextSendRef = useRef(false);
 
+  // #396: one-shot arm for the bounded 409 A_RUN_ALREADY_ACTIVE retry on the
+  // "Interrupt and send now" re-send in autonomous mode. sendNow triggers the
+  // authoritative server stop of the detached run, but that stop and the
+  // onFinish->flushNext re-POST race: the new POST can hit the one-active-run
+  // gate before the old detached run has settled, yielding a spurious 409. When
+  // this ref is armed, the transport's send path retries that 409 with a short
+  // bounded backoff (the server stop guarantees convergence). A normal send (ref
+  // not armed) must STILL fail a 409 instantly (e.g. a genuine two-tab conflict).
+  //
+  // INVARIANT: sendNow arms this only to be consumed by the ONE re-POST that
+  // flushNext fires from onFinish. But that re-POST does not always happen (the
+  // promoted head may be gone, the finish may be a resumed turn, or the arm may
+  // race a stale finish). To keep the arm strictly one-shot it is disarmed on
+  // EVERY path where the paired interrupt one-shots (flushOnAbortRef /
+  // interruptNextSendRef) are cleared without a POST: the transport POST branch
+  // consumes it (read-and-clear), the onFinish `!flushNext()` no-send branch
+  // clears it, and the isStreaming-defuse effect clears it symmetrically. So it
+  // can never leak into a later, unrelated send and retry that send's genuine 409.
+  const supersedeRetryRef = useRef(false);
+
   // #234 F5: the user pressed Stop while streaming a BRAND-NEW chat whose server
   // chat id has not been adopted yet (the `start` chunk carrying it hadn't landed
   // when Stop was pressed). A local SSE abort alone does NOT stop the DETACHED
@@ -382,7 +432,43 @@ export default function ChatThread({
           }`,
         }),
         fetch: async (input: RequestInfo | URL, init: RequestInit = {}) => {
-          if ((init.method ?? "GET") !== "GET") return fetch(input, init); // send path untouched
+          if ((init.method ?? "GET") !== "GET") {
+            // Send path (POST). #396: read-and-clear the one-shot supersede arm
+            // here so it is strictly scoped to THIS send. When unarmed, behave
+            // exactly as before — a single fetch, a 409 surfaces instantly (a
+            // genuine two-tab conflict must NOT be retried).
+            const supersede = supersedeRetryRef.current;
+            supersedeRetryRef.current = false;
+            if (!supersede) return fetch(input, init);
+            // Buffer a ReadableStream body once so each retry can replay it.
+            // DefaultChatTransport sends the body as a JSON STRING (replayable as
+            // is), but guard defensively in case a future SDK streams it.
+            let sendInit = init;
+            if (init.body instanceof ReadableStream) {
+              const buffered = await new Response(init.body).arrayBuffer();
+              sendInit = { ...init, body: buffered };
+            }
+            // Bounded retry: attempt 1 fires immediately, then wait between
+            // attempts per SUPERSEDE_RETRY_DELAYS_MS. Retry ONLY on a real
+            // 409 A_RUN_ALREADY_ACTIVE; any other status/body is returned as-is.
+            for (let attempt = 0; ; attempt++) {
+              const response = await fetch(input, sendInit);
+              if (
+                response.status !== 409 ||
+                attempt >= SUPERSEDE_RETRY_DELAYS_MS.length ||
+                !(await isRunAlreadyActive(response))
+              ) {
+                return response;
+              }
+              // The old detached run has not released the one-active-run slot
+              // yet; the server stop we requested guarantees it will, so back off
+              // and re-POST (the 409 fired before the user message was persisted,
+              // so re-POSTing is safe — no duplicate rows).
+              await new Promise((r) =>
+                setTimeout(r, SUPERSEDE_RETRY_DELAYS_MS[attempt]),
+              );
+            }
+          }
           // Reconnect GET: the SDK passes no AbortSignal, so wire our own controller
           // for observer Stop / unmount abort.
           const controller = new AbortController();
@@ -562,9 +648,14 @@ export default function ChatThread({
         setStopNotice(null);
         // If the promoted head vanished (e.g. the user removed it before the
         // abort landed) flushNext sends nothing — clear the one-shot interrupt
-        // tag so it can't leak onto the next unrelated send. On a real send the
-        // tag is consumed by prepareSendMessagesRequest and stays untouched.
-        if (!flushNext()) interruptNextSendRef.current = false;
+        // tag AND the #396 supersede arm so neither can leak onto the next
+        // unrelated send (no re-POST will consume the arm here). On a real send
+        // the tag is consumed by prepareSendMessagesRequest and the arm by the
+        // transport POST branch, so both stay untouched then.
+        if (!flushNext()) {
+          interruptNextSendRef.current = false;
+          supersedeRetryRef.current = false;
+        }
         return;
       }
       if (isAbort || isDisconnect || isError) return;
@@ -873,6 +964,30 @@ export default function ChatThread({
         setQueue(promoteToHead(queuedRef.current, id));
         flushOnAbortRef.current = true;
         interruptNextSendRef.current = true;
+        // #396: in autonomous mode the turn is a DETACHED run — a local stop()
+        // is only a client disconnect the server ignores, so the run keeps going.
+        // The onFinish->flushNext re-POST would then hit the one-active-run gate
+        // and get a spurious 409 A_RUN_ALREADY_ACTIVE. Mirror handleStop: request
+        // the AUTHORITATIVE server stop so the detached run settles, and arm the
+        // one-shot bounded 409 retry BEFORE stop() so the re-send converges once
+        // the slot frees. Read chatId live from chatIdRef (adopted at the `start`
+        // chunk). If it is not known yet (brand-new chat, first moment of its
+        // first turn), defer the server stop via stopPendingRef exactly as
+        // handleStop does — the onServerChatId adoption effect fires it once the
+        // id lands; the retry stays armed so the re-send still converges then.
+        if (autonomousRunsEnabled) {
+          supersedeRetryRef.current = true; // arm the bounded 409 retry
+          if (chatIdRef.current) {
+            onServerStop?.(chatIdRef.current);
+          } else {
+            // Same #234-F5 sub-window limitation documented in handleStop: if the
+            // local abort below cancels the reader before the `start` chunk lands,
+            // the adoption effect never runs and the deferred stop never fires. Not
+            // a regression; at minimum we don't strand refs (the isStreaming effect
+            // defuses stopPendingRef on the next turn start).
+            stopPendingRef.current = true;
+          }
+        }
         stop(); // -> onFinish({ isAbort: true }) flushes the promoted head
       } else {
         // Nothing to interrupt: just send it now (no interrupt note).
@@ -884,7 +999,7 @@ export default function ChatThread({
         sendMessageRef.current?.({ text: msg.text });
       }
     },
-    [setQueue, stop, setResumedTurnPair],
+    [setQueue, stop, setResumedTurnPair, autonomousRunsEnabled, onServerStop],
   );
 
   // Stop the current turn. ALWAYS abort the local SSE (`stop()`) so the composer
@@ -944,6 +1059,13 @@ export default function ChatThread({
       setStopNotice(null);
       flushOnAbortRef.current = false;
       interruptNextSendRef.current = false;
+      // #396: symmetric with the other one-shot interrupt flags — defuse a stale
+      // supersede arm that was set but whose expected re-POST never fired (the
+      // turn finished in the same tick as the click, or the promoted head was
+      // gone), so it can never leak into this (or a later) turn's send and retry
+      // that send's genuine 409. A legit arm is consumed by the transport POST
+      // branch before this new turn streams, so this does not clobber it.
+      supersedeRetryRef.current = false;
       // #234 F5: a new turn is starting — drop any pending deferred-stop from a
       // previous turn that never adopted an id, so it can never fire against this
       // (or a later) unrelated turn's run. A deferred stop for the CURRENT turn is

packages/mcp/src/client.ts

@@ -82,6 +82,7 @@ import {
   canonicalizeFootnotes,
   insertInlineFootnote,
 } from "./lib/transforms.js";
+import { normalizeAndMergeFootnotes } from "./lib/footnote-normalize-merge.js";
 import vm from "node:vm";
 
 // Supported image types, kept as two lookup tables so both a local file
@@ -1719,6 +1720,8 @@ export class DocmostClient {
     // leave footnotes out of order, orphaned, or in multiple lists — the bottom
     // list + numbering are always derived from reference order. No-op when the
     // footnotes are already canonical.
+    // #419: normalize + merge glyph-forked definitions before canonicalizing.
+    doc = normalizeAndMergeFootnotes(doc);
     doc = canonicalizeFootnotes(doc);
 
     // Write the BODY first, then the title (#159 split-brain): a failed body
@@ -1983,7 +1986,8 @@ export class DocmostClient {
     // footnotes before copying — a no-op on already-canonical source content, but
     // it guarantees a copy can never propagate a non-canonical footnote topology
     // to the target (parity with the other full-doc write paths).
-    const canonical = canonicalizeFootnotes(content);
+    // #419: normalize + merge glyph-forked definitions before canonicalizing.
+    const canonical = canonicalizeFootnotes(normalizeAndMergeFootnotes(content));
 
     const collabToken = await this.getCollabTokenWithReauth();
     // Open the TARGET collab doc by its canonical UUID, never the slugId (#260).
@@ -4249,7 +4253,8 @@ export class DocmostClient {
       // path can leave footnotes out of order / orphaned / in a raw `[^id]`
       // block. In a dryRun preview this may surface footnote edits the script
       // author did not write (the canonicalizer tidied them) — that is expected.
-      const result = canonicalizeFootnotes(raw);
+      // #419: normalize + merge glyph-forked definitions before canonicalizing.
+      const result = canonicalizeFootnotes(normalizeAndMergeFootnotes(raw));
       newDoc = result;
       return result;
     };

packages/mcp/src/lib/collaboration.ts

@@ -15,6 +15,7 @@ import { docmostExtensions, docmostSchema } from "./docmost-schema.js";
 import { withPageLock } from "./page-lock.js";
 import { sanitizeForYjs, findUnstorableAttr } from "@docmost/prosemirror-markdown";
 import { canonicalizeFootnotes } from "./footnote-canonicalize.js";
+import { normalizeAndMergeFootnotes } from "./footnote-normalize-merge.js";
 import { VerifyReport } from "./diff.js";
 import { acquireCollabSession } from "./collab-session.js";
 
@@ -82,7 +83,12 @@ global.WebSocket = WebSocket;
 export async function markdownToProseMirrorCanonical(
   markdownContent: string,
 ): Promise<any> {
-  return canonicalizeFootnotes(await markdownToProseMirror(markdownContent));
+  // #419: normalize + merge glyph-forked footnote definitions BEFORE
+  // canonicalizing, so the canonicalizer re-hangs references and drops the
+  // now-orphaned duplicate definitions.
+  return canonicalizeFootnotes(
+    normalizeAndMergeFootnotes(await markdownToProseMirror(markdownContent)),
+  );
 }
 
 /**

packages/mcp/src/lib/footnote-normalize-merge.ts

@@ -0,0 +1,280 @@
+/**
+ * Deterministic server-side NORMALIZATION + MERGE of footnote DEFINITIONS
+ * (MCP, PURE).
+ *
+ * Problem (#419): footnotes with the same meaning but different GLYPHS —
+ * typographic quotes («…»/“…”) vs ASCII "…", em/en-dash vs `-`, non-breaking
+ * space vs normal space, differing space counts — are not recognized as equal
+ * and "fork": two definitions appear where the author meant one. The existing
+ * de-dup paths miss this: `footnoteContentKey` (footnote-authoring.ts) only
+ * collapses ASCII whitespace (quotes/dashes/NBSP untouched), and
+ * `canonicalizeFootnotes` keys purely by `attrs.id` (the two forks have
+ * different ids), so neither glues the forks together.
+ *
+ * This pass fixes that DETERMINISTICALLY on the MCP write-paths (an LLM
+ * instruction gives no glue guarantee). It:
+ *   1. Normalizes the TEXT of every `footnoteDefinition`'s text nodes IN PLACE
+ *      (typographic quotes -> ASCII "/', dashes -> `-`, NBSP & friends ->
+ *      normal space, whitespace runs collapsed, whole-definition edges
+ *      trimmed) — unconditionally, for ALL definitions, KEEPING their marks.
+ *   2. Computes a MERGE KEY per definition (normalized text + an ATTRS-AWARE
+ *      inline-mark signature, via the local `footnoteMergeKey`), so notes that
+ *      read the same but differ in formatting (bold vs plain) OR in a mark
+ *      attribute (a `link` with a different `href`, differing `code`/`highlight`
+ *      attrs) are NOT merged. See `footnoteMergeKey` for why this diverges from
+ *      the shared type-only `footnoteContentKey`.
+ *   3. Maps every duplicate definition id to the FIRST (document-order)
+ *      definition's id and re-hangs `footnoteReference` nodes onto it.
+ *
+ * Duplicate definitions keep their original ids but now have NO references, so
+ * the canonicalizer that runs immediately after this pass removes them as
+ * orphans and derives the single tail list + numbering. This pass therefore
+ * MUST run BEFORE `canonicalizeFootnotes(doc)` at every write-path call-site
+ * (see the enforcement rule in `footnote-canonicalize.ts`).
+ *
+ * Accepted tradeoff: the exact typographic glyphs of the SURVIVING footnote are
+ * rewritten to ASCII, in exchange for a GUARANTEED merge. Scope is strictly
+ * INSIDE `footnoteDefinition` — body text (normal paragraphs) is never touched.
+ *
+ * Pure: deep-clones its input, deterministic, idempotent (a re-run is a no-op —
+ * text is already normalized and references already point at the canonical id,
+ * so no spurious mutations / git-sync churn).
+ */
+
+const FOOTNOTE_DEFINITION_NAME = "footnoteDefinition";
+const FOOTNOTE_REFERENCE_NAME = "footnoteReference";
+
+/**
+ * Typographic glyph maps. DUPLICATED from `comment-anchor.ts` (the source of
+ * truth, `normalizeForMatch`) on purpose: those constants are private there and
+ * bound to that module's anchor-matching golden tests, so extracting them would
+ * risk changing anchor behaviour. Keeping a local copy makes this pass fully
+ * self-contained. If the anchor maps grow, mirror the change here.
+ */
+/** Typographic double-quote variants mapped to ASCII `"`. */
+const DOUBLE_QUOTES = "«»„“”‟〝〞＂";
+/** Typographic single-quote/apostrophe variants mapped to ASCII `'`. */
+const SINGLE_QUOTES = "‘’‚‛";
+/** Dash variants mapped to ASCII `-`. */
+const DASHES = "–—―−‐‑‒";
+
+function cloneJson<T>(v: T): T {
+  if (typeof structuredClone === "function") return structuredClone(v);
+  return JSON.parse(JSON.stringify(v)) as T;
+}
+
+/**
+ * True for any character we collapse/replace with a single normal space.
+ * Mirrors `comment-anchor.ts`'s `isWhitespaceChar`: ASCII whitespace (`\s`
+ * covers tab/newline) plus the non-breaking / special spaces listed explicitly
+ * for determinism across engines.
+ */
+function isWhitespaceChar(ch: string): boolean {
+  return (
+    /\s/.test(ch) ||
+    ch === " " || // no-break space
+    ch === " " || // figure space
+    ch === " " || // narrow no-break space
+    ch === " " || // thin space
+    ch === " " || // hair space
+    ch === " " || // en space
+    ch === " " // em space
+  );
+}
+
+/**
+ * Map typographic quotes/dashes to ASCII and collapse every whitespace run
+ * (including NBSP & friends) to a SINGLE normal space. Does NOT trim — the
+ * whole-definition edge trim is applied separately so inter-node spacing across
+ * a multi-text-node definition is preserved.
+ */
+function normalizeAndCollapse(s: string): string {
+  let out = "";
+  let i = 0;
+  while (i < s.length) {
+    const ch = s[i];
+    if (isWhitespaceChar(ch)) {
+      while (i < s.length && isWhitespaceChar(s[i])) i++;
+      out += " ";
+      continue;
+    }
+    let mapped = ch;
+    if (DOUBLE_QUOTES.indexOf(ch) !== -1) mapped = '"';
+    else if (SINGLE_QUOTES.indexOf(ch) !== -1) mapped = "'";
+    else if (DASHES.indexOf(ch) !== -1) mapped = "-";
+    out += mapped;
+    i++;
+  }
+  return out;
+}
+
+/** Collect every text node inside `def`, in document order (deep). */
+function collectTextNodes(node: any, out: any[]): void {
+  if (!node || typeof node !== "object") return;
+  if (node.type === "text" && typeof node.text === "string") out.push(node);
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) collectTextNodes(child, out);
+  }
+}
+
+/** Collect every `footnoteDefinition` node in document order (deep). */
+function collectDefinitions(node: any, out: any[]): void {
+  if (!node || typeof node !== "object") return;
+  if (node.type === FOOTNOTE_DEFINITION_NAME) out.push(node);
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) collectDefinitions(child, out);
+  }
+}
+
+/**
+ * Normalize the text of one definition's text nodes IN PLACE: map glyphs +
+ * collapse whitespace on every node (marks untouched), then trim the leading
+ * edge of the first text node and the trailing edge of the last so the
+ * definition as a whole is trimmed WITHOUT dropping the spacing between two
+ * adjacent text nodes. The edge trims are guarded so an all-whitespace edge
+ * node is never emptied into a schema-invalid empty text node.
+ */
+function normalizeDefinitionText(def: any): void {
+  const textNodes: any[] = [];
+  collectTextNodes(def, textNodes);
+  for (const t of textNodes) {
+    // Skip text carrying a `code` mark: inline code is a verbatim literal, not
+    // prose typography. Rewriting quotes/dashes/special-spaces there would
+    // corrupt the literal's meaning (a string literal, an em-dash flag, i18n).
+    // Leaving it untouched also makes it contribute its RAW text to
+    // `footnoteMergeKey`, so two notes differing only by glyphs inside code
+    // stay distinct (while prose glyph-forks still merge). See #419.
+    if ((t.marks || []).some((m: any) => m?.type === "code")) continue;
+    t.text = normalizeAndCollapse(t.text);
+  }
+  if (textNodes.length === 0) return;
+  const hasCodeMark = (t: any): boolean =>
+    (t.marks || []).some((m: any) => m?.type === "code");
+  const first = textNodes[0];
+  if (!hasCodeMark(first)) {
+    const startTrimmed = first.text.replace(/^ +/, "");
+    if (startTrimmed !== "") first.text = startTrimmed;
+  }
+  const last = textNodes[textNodes.length - 1];
+  if (!hasCodeMark(last)) {
+    const endTrimmed = last.text.replace(/ +$/, "");
+    if (endTrimmed !== "") last.text = endTrimmed;
+  }
+}
+
+/** Rewrite `footnoteReference` ids IN PLACE using `defIdToCanon` (deep). */
+function rehangReferences(
+  node: any,
+  defIdToCanon: Map<string, string>,
+): void {
+  if (!node || typeof node !== "object") return;
+  if (node.type === FOOTNOTE_REFERENCE_NAME) {
+    const id = node?.attrs?.id;
+    if (typeof id === "string") {
+      const canon = defIdToCanon.get(id);
+      if (canon && canon !== id) node.attrs.id = canon;
+    }
+  }
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) rehangReferences(child, defIdToCanon);
+  }
+}
+
+/**
+ * Stable, order-independent serialization of a mark's `attrs`: sort keys so the
+ * same attrs always yield the same string regardless of authoring order. Empty /
+ * missing attrs -> "" (so an attr-less mark keys identically to a type-only mark
+ * signature, preserving bold-vs-plain parity).
+ */
+function stableAttrs(attrs: any): string {
+  if (!attrs || typeof attrs !== "object") return "";
+  const sorted: Record<string, any> = {};
+  for (const k of Object.keys(attrs).sort()) sorted[k] = attrs[k];
+  return JSON.stringify(sorted);
+}
+
+/**
+ * ATTRS-AWARE merge key for a footnote definition. Deliberately DIVERGES from
+ * the shared `footnoteContentKey` (footnote-authoring.ts): that key's mark
+ * signature is TYPE-ONLY (`m.type`), so two definitions with identical visible
+ * text but marks differing only in ATTRIBUTES — most importantly a `link` with a
+ * different `href` (footnotes are usually citations/links), also `code` /
+ * `highlight` with differing attrs — collapse to the SAME key and get merged;
+ * one definition then loses its references and the canonicalizer deletes it as an
+ * orphan, silently dropping a distinct link target (data loss, #419).
+ *
+ * This key folds each mark's `attrs` (stable, sorted-key serialization) into the
+ * signature, so different-href / different-attr notes stay separate. We do NOT
+ * change `footnoteContentKey` itself: it is shared with the live
+ * `insertInlineFootnote` / `commentsToFootnotes` dedup and altering it there
+ * would change their behaviour — out of scope here.
+ *
+ * The TEXT portion mirrors `footnoteContentKey` exactly (per text node
+ * `text + mark-signature`, concatenated, whitespace-collapsed, trimmed) over the
+ * already-in-place-normalized text, so empty text still yields "" (empties never
+ * collapse) and merge parity with the rest of the pass is preserved.
+ */
+function footnoteMergeKey(defNode: any): string {
+  const parts: string[] = [];
+  const visit = (n: any): void => {
+    if (!n || typeof n !== "object") return;
+    if (n.type === "text" && typeof n.text === "string") {
+      const marks = Array.isArray(n.marks)
+        ? n.marks
+            .filter((m: any) => m && m.type)
+            .map((m: any) => `${m.type}${stableAttrs(m.attrs)}`)
+            .sort()
+            .join(",")
+        : "";
+      parts.push(`${n.text}${marks}`);
+    }
+    if (Array.isArray(n.content)) for (const c of n.content) visit(c);
+  };
+  visit(defNode);
+  return parts
+    .join("")
+    .replace(/[ \t\r\n]+/g, " ")
+    .trim();
+}
+
+/**
+ * Normalize footnote-definition text and merge definitions whose normalized
+ * text (+ mark signature) matches. See the file header for the full contract.
+ * Pure (deep-clones input, deterministic, idempotent). Intended to run
+ * immediately BEFORE `canonicalizeFootnotes(doc)`.
+ */
+export function normalizeAndMergeFootnotes<T = any>(doc: T): T {
+  if (doc == null || typeof doc !== "object") return doc;
+  const out = cloneJson(doc) as any;
+
+  // 1) All definitions in document order; normalize each one's text in place.
+  const defNodes: any[] = [];
+  collectDefinitions(out, defNodes);
+  for (const def of defNodes) normalizeDefinitionText(def);
+
+  // 2) Merge key per definition (normalized text + inline-mark signature). The
+  //    first definition in document order per key wins; later ones map onto it.
+  //    Empty-text definitions (key === "") are NOT merged — otherwise every
+  //    empty footnote would collapse into one (parity with insertInlineFootnote).
+  const keyToCanon = new Map<string, string>();
+  const defIdToCanon = new Map<string, string>();
+  for (const def of defNodes) {
+    const id = def?.attrs?.id;
+    if (typeof id !== "string" || id === "") continue;
+    const key = footnoteMergeKey(def);
+    if (key === "") continue;
+    const canon = keyToCanon.get(key);
+    if (canon === undefined) {
+      keyToCanon.set(key, id);
+    } else if (canon !== id) {
+      defIdToCanon.set(id, canon);
+    }
+  }
+
+  // 3) Re-hang references from duplicate ids onto the canonical id. Duplicate
+  //    definitions keep their ids but now have no references -> the following
+  //    canonicalizer pass drops them as orphans.
+  if (defIdToCanon.size > 0) rehangReferences(out, defIdToCanon);
+
+  return out;
+}

packages/mcp/src/lib/transforms.ts

@@ -14,6 +14,7 @@
  *  - `marks` arrays are preserved verbatim when fragments are split/reordered.
  */
 
+import { normalizeAndMergeFootnotes } from "./footnote-normalize-merge.js";
 import {
   blockPlainText,
   footnoteContentKey,
@@ -766,6 +767,8 @@ export function insertInlineFootnote(
     appendDefinition(working, makeFootnoteDefinition(footnoteId, inline));
   }
 
+  // #419: normalize + merge glyph-forked definitions before canonicalizing.
+  working = normalizeAndMergeFootnotes(working);
   // Derive numbering + the single bottom list deterministically.
   working = canonicalizeFootnotes(working);
   return { doc: working, inserted: true, footnoteId, reused };

packages/mcp/test/unit/footnote-normalize-merge.test.mjs

@@ -0,0 +1,317 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { normalizeAndMergeFootnotes } from "../../build/lib/footnote-normalize-merge.js";
+import { canonicalizeFootnotes } from "../../build/lib/footnote-canonicalize.js";
+
+function findAll(node, type, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  if (node.type === type) acc.push(node);
+  if (Array.isArray(node.content)) {
+    for (const c of node.content) findAll(c, type, acc);
+  }
+  return acc;
+}
+const defs = (doc) => findAll(doc, "footnoteDefinition");
+const defIds = (doc) => defs(doc).map((d) => d.attrs.id);
+const refIds = (doc) => findAll(doc, "footnoteReference").map((r) => r.attrs.id);
+const defText = (d) =>
+  findAll(d, "text")
+    .map((t) => t.text)
+    .join("");
+
+const ref = (id) => ({ type: "footnoteReference", attrs: { id } });
+const para = (...inline) => ({ type: "paragraph", content: inline });
+const txt = (text, marks) =>
+  marks ? { type: "text", text, marks } : { type: "text", text };
+const def = (id, ...inline) => ({
+  type: "footnoteDefinition",
+  attrs: { id },
+  content: [para(...inline)],
+});
+const list = (...defs) => ({ type: "footnotesList", content: defs });
+const doc = (...content) => ({ type: "doc", content });
+
+// --- Normalization + merge of glyph forks ----------------------------------
+
+test("typographic double quotes «…» vs \"…\" merge into one", () => {
+  const d = doc(
+    para(txt("a"), ref("A"), txt(" b"), ref("B")),
+    list(def("A", txt("«word»")), def("B", txt('"word"'))),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  // Both references now point at the first definition's id.
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  // Surviving text is ASCII-normalized.
+  assert.equal(defText(defs(out)[0]), '"word"');
+  // Duplicate def kept its id (canonicalizer removes it as an orphan later).
+  const canon = canonicalizeFootnotes(out);
+  assert.deepEqual(defIds(canon), ["A"]);
+  assert.equal(findAll(canon, "footnotesList").length, 1);
+});
+
+test("em/en dash and hyphen merge", () => {
+  const d = doc(
+    para(ref("A"), ref("B"), ref("C")),
+    list(
+      def("A", txt("see — here")),
+      def("B", txt("see – here")),
+      def("C", txt("see - here")),
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A", "A"]);
+  assert.equal(defText(defs(out)[0]), "see - here");
+});
+
+test("NBSP and extra spaces merge with normal spacing", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(
+      def("A", txt("foo bar")), // NBSP
+      def("B", txt("foo   bar")), // collapsed spaces
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  assert.equal(defText(defs(out)[0]), "foo bar");
+});
+
+test("same text but different styling (bold vs plain) does NOT merge", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(
+      def("A", txt("word", [{ type: "bold" }])),
+      def("B", txt("word")),
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  // No re-hang: references keep their own ids.
+  assert.deepEqual(refIds(out), ["A", "B"]);
+  assert.deepEqual(defIds(out), ["A", "B"]);
+  // Marks preserved on the surviving text node.
+  assert.deepEqual(defs(out)[0].content[0].content[0].marks, [
+    { type: "bold" },
+  ]);
+});
+
+test("same text but a link mark with different href does NOT merge (data-loss guard)", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(
+      def("A", txt("source", [{ type: "link", attrs: { href: "https://a.example/1" } }])),
+      def("B", txt("source", [{ type: "link", attrs: { href: "https://b.example/2" } }])),
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  // No re-hang: each reference keeps its own definition (distinct link target).
+  assert.deepEqual(refIds(out), ["A", "B"]);
+  assert.deepEqual(defIds(out), ["A", "B"]);
+  // Both distinct hrefs survive.
+  assert.deepEqual(
+    defs(out).map((dn) => dn.content[0].content[0].marks[0].attrs.href),
+    ["https://a.example/1", "https://b.example/2"],
+  );
+  // Canonicalize keeps both as two tail entries (neither is an orphan).
+  const canon = canonicalizeFootnotes(out);
+  assert.deepEqual(defIds(canon), ["A", "B"]);
+  assert.deepEqual(refIds(canon), ["A", "B"]);
+});
+
+test("same text and SAME link href still merges (attrs-aware key doesn't over-separate)", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(
+      def("A", txt("source", [{ type: "link", attrs: { href: "https://a.example/1" } }])),
+      def("B", txt("source", [{ type: "link", attrs: { href: "https://a.example/1" } }])),
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  const canon = canonicalizeFootnotes(out);
+  assert.deepEqual(defIds(canon), ["A"]);
+  assert.equal(findAll(canon, "footnotesList").length, 1);
+});
+
+test("marks are kept on merged (surviving) definition text", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(
+      def("A", txt("«x»", [{ type: "italic" }])),
+      def("B", txt("«x»", [{ type: "italic" }])),
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  assert.deepEqual(defs(out)[0].content[0].content[0].marks, [
+    { type: "italic" },
+  ]);
+  assert.equal(defText(defs(out)[0]), '"x"');
+});
+
+// --- Inline code is verbatim (not typography) ------------------------------
+
+test("text inside a code mark is left verbatim; prose in the same def is normalized", () => {
+  const d = doc(
+    para(ref("A")),
+    list({
+      type: "footnoteDefinition",
+      attrs: { id: "A" },
+      content: [
+        para(
+          txt("a—b «x»", [{ type: "code" }]),
+          txt(" prose «y» — z"),
+        ),
+      ],
+    }),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  const nodes = findAll(defs(out)[0], "text");
+  // Code node: byte-for-byte unchanged (typography preserved).
+  assert.equal(nodes[0].text, "a—b «x»");
+  // Prose node: dashes/quotes normalized to ASCII.
+  assert.equal(nodes[1].text, ' prose "y" - z');
+});
+
+test("two notes differing ONLY by glyphs inside a code mark do NOT merge", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(
+      def("A", txt("«x»", [{ type: "code" }]), txt(" same prose «q»")),
+      def("B", txt('"x"', [{ type: "code" }]), txt(" same prose «q»")),
+    ),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  // Prose is identical after normalization, but the code literals differ raw
+  // -> the merge key diverges -> both definitions survive, no re-hang.
+  assert.deepEqual(refIds(out), ["A", "B"]);
+  assert.deepEqual(defIds(out), ["A", "B"]);
+  // Each code literal stays verbatim.
+  assert.equal(defs(out)[0].content[0].content[0].text, "«x»");
+  assert.equal(defs(out)[1].content[0].content[0].text, '"x"');
+  // Both survive canonicalization (neither is an orphan).
+  const canon = canonicalizeFootnotes(out);
+  assert.deepEqual(defIds(canon), ["A", "B"]);
+  assert.deepEqual(refIds(canon), ["A", "B"]);
+});
+
+// --- Composition with the canonicalizer ------------------------------------
+
+test("pass + canonicalize: single tail list and sequential numbering", () => {
+  const d = doc(
+    para(txt("intro "), ref("A"), txt(" middle "), ref("B")),
+    list(def("A", txt("«note»")), def("B", txt('"note"'))),
+  );
+  const canon = canonicalizeFootnotes(normalizeAndMergeFootnotes(d));
+  assert.equal(findAll(canon, "footnotesList").length, 1);
+  assert.deepEqual(defIds(canon), ["A"]);
+  assert.deepEqual(refIds(canon), ["A", "A"]);
+});
+
+// --- Idempotency -----------------------------------------------------------
+
+test("idempotent: a second run is a no-op", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(def("A", txt("«word»")), def("B", txt('"word"'))),
+  );
+  const once = normalizeAndMergeFootnotes(d);
+  const twice = normalizeAndMergeFootnotes(once);
+  assert.deepEqual(twice, once);
+});
+
+test("input document is not mutated (pure)", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(def("A", txt("«word»")), def("B", txt('"word"'))),
+  );
+  const snapshot = JSON.parse(JSON.stringify(d));
+  normalizeAndMergeFootnotes(d);
+  assert.deepEqual(d, snapshot);
+});
+
+// --- Nested definitions ----------------------------------------------------
+
+test("definitions nested in a callout are normalized and merged", () => {
+  const callout = (...content) => ({
+    type: "callout",
+    attrs: { type: "info" },
+    content,
+  });
+  const d = doc(
+    para(ref("A"), ref("B")),
+    callout(list(def("A", txt("«c»")), def("B", txt('"c"')))),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  assert.equal(defText(defs(out)[0]), '"c"');
+});
+
+// --- Empty footnotes -------------------------------------------------------
+
+test("empty footnotes do NOT collapse into each other", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(def("A", txt("")), { type: "footnoteDefinition", attrs: { id: "B" }, content: [{ type: "paragraph" }] }),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  // Both empty definitions keep distinct ids; references unchanged.
+  assert.deepEqual(refIds(out), ["A", "B"]);
+  assert.deepEqual(defIds(out), ["A", "B"]);
+});
+
+// --- Body text left untouched ----------------------------------------------
+
+test("body text (outside footnotes) is NOT normalized", () => {
+  const d = doc(
+    para(txt("body «quoted» — dash"), ref("A")),
+    list(def("A", txt("«note»"))),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  // Body paragraph keeps its typographic glyphs verbatim.
+  assert.equal(out.content[0].content[0].text, "body «quoted» — dash");
+  // Footnote text IS normalized.
+  assert.equal(defText(defs(out)[0]), '"note"');
+});
+
+// --- Multi-paragraph structure preserved -----------------------------------
+
+test("multi-paragraph definition: text normalized, structure preserved", () => {
+  const d = doc(
+    para(ref("A")),
+    list({
+      type: "footnoteDefinition",
+      attrs: { id: "A" },
+      content: [para(txt("«p1»")), para(txt("p2 — end"))],
+    }),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  const def0 = defs(out)[0];
+  assert.equal(def0.content.length, 2);
+  assert.equal(def0.content[0].content[0].text, '"p1"');
+  assert.equal(def0.content[1].content[0].text, "p2 - end");
+});
+
+// --- Multi-reference footnote not broken -----------------------------------
+
+test("one id shared by multiple references is preserved", () => {
+  const d = doc(
+    para(ref("A"), txt(" x "), ref("A")),
+    list(def("A", txt("note"))),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  assert.deepEqual(defIds(out), ["A"]);
+});
+
+// --- Whole-definition edge trim --------------------------------------------
+
+test("leading/trailing whitespace is trimmed for the merge and stored text", () => {
+  const d = doc(
+    para(ref("A"), ref("B")),
+    list(def("A", txt("  hello  ")), def("B", txt("hello"))),
+  );
+  const out = normalizeAndMergeFootnotes(d);
+  assert.deepEqual(refIds(out), ["A", "A"]);
+  assert.equal(defText(defs(out)[0]), "hello");
+});