diff --git a/apps/roam/src/components/DiscoverSharedNodesDialog.tsx b/apps/roam/src/components/DiscoverSharedNodesDialog.tsx
index cb299caa1..543c82d8c 100644
--- a/apps/roam/src/components/DiscoverSharedNodesDialog.tsx
+++ b/apps/roam/src/components/DiscoverSharedNodesDialog.tsx
@@ -118,17 +118,23 @@ const ImportResultsSummary = ({
     (item) => item.status === "skipped",
   ).length;
   const failedImports = results.filter(isFailedSharedNodeImport);
+  const warnings = results.flatMap((item) =>
+    item.status !== "failed" && item.warning
+      ? [{ sharedNode: item.sharedNode, message: item.warning }]
+      : [],
+  );
+  const importNotices = [...failedImports, ...warnings];
   return (
     <Callout
-      intent={failedImports.length > 0 ? Intent.WARNING : Intent.SUCCESS}
-      title={`${importedCount} imported, ${skippedCount} skipped, ${failedImports.length} failed`}
+      intent={importNotices.length > 0 ? Intent.WARNING : Intent.SUCCESS}
+      title={`${importedCount} imported, ${skippedCount} skipped, ${failedImports.length} failed${warnings.length > 0 ? `, ${warnings.length} with warnings` : ""}`}
     >
       {skippedCount > 0 && (
         <div>Skipped nodes were already up to date in this graph.</div>
       )}
-      {failedImports.length > 0 && (
+      {importNotices.length > 0 && (
         <ul className="mb-0 mt-2 list-disc pl-5">
-          {failedImports.map((item) => (
+          {importNotices.map((item) => (
             <li key={item.sharedNode.rid}>
               <span className="font-medium">{item.sharedNode.title}</span>:{" "}
               {item.message}
diff --git a/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx b/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx
index 2fa6ac04a..0826a10f3 100644
--- a/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx
+++ b/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx
@@ -24,8 +24,10 @@ const RefreshImportedNodeTitleButton = ({
         id: failed
           ? "refresh-imported-node-failed"
           : "refresh-imported-node-success",
-        intent: failed ? "danger" : "success",
-        content: result.message,
+        intent: failed ? "danger" : result.warning ? "warning" : "success",
+        content: result.warning
+          ? `${result.message} ${result.warning}`
+          : result.message,
       });
     } finally {
       setRefreshing(false);
diff --git a/apps/roam/src/utils/__tests__/findTargetUid.test.ts b/apps/roam/src/utils/__tests__/findTargetUid.test.ts
new file mode 100644
index 000000000..c259b73eb
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/findTargetUid.test.ts
@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { findTargetUid, sharedReferenceRid } from "~/utils/findTargetUid";
+import { findImportedNodeUidBySourceRid } from "~/utils/importedSourceIdentity";
+
+vi.mock("~/utils/importedSourceIdentity", () => ({
+  findImportedNodeUidBySourceRid: vi.fn(),
+}));
+
+const mockedFindImportedNodeUidBySourceRid = vi.mocked(
+  findImportedNodeUidBySourceRid,
+);
+
+const LOCAL_GRAPH = "local-graph";
+const LOCAL_SPACE_URI = `https://roamresearch.com/#/app/${LOCAL_GRAPH}`;
+const OBSIDIAN_SPACE_URI = "obsidian:vault-a";
+const roamQuery = vi.fn();
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  (globalThis as { window: unknown }).window = {
+    roamAlphaAPI: { graph: { name: LOCAL_GRAPH }, q: roamQuery },
+  };
+  roamQuery.mockReturnValue([]);
+  mockedFindImportedNodeUidBySourceRid.mockResolvedValue(null);
+});
+
+describe("sharedReferenceRid", () => {
+  it("passes a RID through", () => {
+    expect(
+      sharedReferenceRid(
+        "orn:obsidian.note:vault-b/node-6",
+        OBSIDIAN_SPACE_URI,
+      ),
+    ).toBe("orn:obsidian.note:vault-b/node-6");
+  });
+
+  it("builds a note RID from a local id in an Obsidian space", () => {
+    expect(sharedReferenceRid("node-9", OBSIDIAN_SPACE_URI)).toBe(
+      "orn:obsidian.note:vault-a/node-9",
+    );
+  });
+
+  it("builds a URL RID from a local id in a Roam space", () => {
+    expect(
+      sharedReferenceRid(
+        "page-uid",
+        "https://roamresearch.com/#/app/other-graph",
+      ),
+    ).toBe("https://roamresearch.com/#/app/other-graph/page-uid");
+  });
+});
+
+describe("findTargetUid", () => {
+  it("returns the local id of a RID in this graph when the page exists", async () => {
+    roamQuery.mockReturnValue([[1]]);
+
+    await expect(
+      findTargetUid(`${LOCAL_SPACE_URI}/page-uid`, OBSIDIAN_SPACE_URI),
+    ).resolves.toBe("page-uid");
+    expect(roamQuery).toHaveBeenCalledWith(
+      "[:find (?e) :in $ ?uid :where [?e :block/uid ?uid]]",
+      "page-uid",
+    );
+    expect(mockedFindImportedNodeUidBySourceRid).not.toHaveBeenCalled();
+  });
+
+  it("passes a shared id containing query syntax as data", async () => {
+    const sharedId = 'page-uid"] [(= ?e ?e)] ; "';
+    await expect(findTargetUid(sharedId, LOCAL_SPACE_URI)).resolves.toBeNull();
+    expect(roamQuery).toHaveBeenCalledWith(
+      "[:find (?e) :in $ ?uid :where [?e :block/uid ?uid]]",
+      sharedId,
+    );
+  });
+
+  it("returns null for a RID in this graph whose page is missing", async () => {
+    await expect(
+      findTargetUid(`${LOCAL_SPACE_URI}/page-uid`, OBSIDIAN_SPACE_URI),
+    ).resolves.toBeNull();
+    expect(mockedFindImportedNodeUidBySourceRid).not.toHaveBeenCalled();
+  });
+
+  it("treats a local id of this graph's space as a page uid", async () => {
+    roamQuery.mockReturnValue([[1]]);
+
+    await expect(findTargetUid("page-uid", LOCAL_SPACE_URI)).resolves.toBe(
+      "page-uid",
+    );
+    expect(mockedFindImportedNodeUidBySourceRid).not.toHaveBeenCalled();
+  });
+
+  it("looks up a local id of the publisher's space as an imported note", async () => {
+    mockedFindImportedNodeUidBySourceRid.mockResolvedValue("imported-uid");
+
+    await expect(findTargetUid("node-9", OBSIDIAN_SPACE_URI)).resolves.toBe(
+      "imported-uid",
+    );
+    expect(mockedFindImportedNodeUidBySourceRid).toHaveBeenCalledWith(
+      "orn:obsidian.note:vault-a/node-9",
+    );
+    expect(roamQuery).not.toHaveBeenCalled();
+  });
+
+  it("looks up a RID of another space as imported", async () => {
+    await expect(
+      findTargetUid("orn:obsidian.note:vault-b/node-6", OBSIDIAN_SPACE_URI),
+    ).resolves.toBeNull();
+    expect(mockedFindImportedNodeUidBySourceRid).toHaveBeenCalledWith(
+      "orn:obsidian.note:vault-b/node-6",
+    );
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/importSharedNodes.test.ts b/apps/roam/src/utils/__tests__/importSharedNodes.test.ts
index 0712131d8..d4299a271 100644
--- a/apps/roam/src/utils/__tests__/importSharedNodes.test.ts
+++ b/apps/roam/src/utils/__tests__/importSharedNodes.test.ts
@@ -20,6 +20,13 @@ vi.mock("~/utils/resolveSharedNodeTypes", () => ({
   resolveSharedNodeTypes: vi.fn(),
 }));
 
+// Runs before the imports above: getDiscourseNodes calls generateUID at module load.
+vi.hoisted(() => {
+  (globalThis as { window?: unknown }).window = {
+    roamAlphaAPI: { util: { generateUID: () => "someUid" } },
+  };
+});
+
 const mockedMaterializeSharedNode = vi.mocked(materializeSharedNode);
 const mockedResolveSharedNodeTypes = vi.mocked(resolveSharedNodeTypes);
 
@@ -139,6 +146,56 @@ describe("importSharedNodes", () => {
     });
   });
 
+  it("materializes a node before the nodes that name it as their source", async () => {
+    const evidence = {
+      ...makeSharedNode("node-1"),
+      slots: { sourceDocument: "node-2" },
+    };
+    const source = makeSharedNode("node-2");
+    const other = makeSharedNode("node-3");
+    mockedMaterializeSharedNode
+      .mockResolvedValueOnce(successResult(source, "created"))
+      .mockResolvedValueOnce(successResult(evidence, "created"))
+      .mockResolvedValueOnce(successResult(other, "created"));
+
+    const items = await importSharedNodes({
+      client,
+      sharedNodes: [evidence, source, other],
+      onProgress: vi.fn(),
+    });
+
+    expect(
+      mockedMaterializeSharedNode.mock.calls.map(([args]) => args.sharedNode),
+    ).toEqual([source, evidence, other]);
+    expect(items.map((item) => item.sharedNode)).toEqual([
+      source,
+      evidence,
+      other,
+    ]);
+  });
+
+  it("reports the materializer's warning on the imported node", async () => {
+    const sharedNodes = [makeSharedNode("node-1")];
+    mockedMaterializeSharedNode.mockResolvedValueOnce({
+      ...successResult(sharedNodes[0], "created"),
+      warning: "No source was published with this node.",
+    });
+
+    const items = await importSharedNodes({
+      client,
+      sharedNodes,
+      onProgress: vi.fn(),
+    });
+
+    expect(items).toEqual([
+      {
+        sharedNode: sharedNodes[0],
+        status: "imported",
+        warning: "No source was published with this node.",
+      },
+    ]);
+  });
+
   it("keeps importing the remaining nodes when a materialization throws", async () => {
     const sharedNodes = ["node-1", "node-2"].map(makeSharedNode);
     mockedMaterializeSharedNode
diff --git a/apps/roam/src/utils/__tests__/importSharedRelations.test.ts b/apps/roam/src/utils/__tests__/importSharedRelations.test.ts
new file mode 100644
index 000000000..80e4d95c8
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/importSharedRelations.test.ts
@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { DGSupabaseClient } from "@repo/database/lib/client";
+import type { DiscourseRelation } from "~/utils/getDiscourseRelations";
+import { importSharedRelations } from "~/utils/importSharedRelations";
+import getDiscourseRelations from "~/utils/getDiscourseRelations";
+import { createRelationSchema } from "~/utils/createRelationSchema";
+
+vi.hoisted(() => {
+  vi.stubGlobal("window", { roamAlphaAPI: { graph: { name: "local" } } });
+});
+vi.mock("~/utils/getDiscourseRelations", () => ({ default: vi.fn() }));
+vi.mock("~/utils/getDiscourseNodes", () => ({
+  default: () => [{ type: "local-claim", text: "Claim" }],
+}));
+vi.mock("~/utils/importedSourceIdentity", () => ({
+  getImportedSourceRids: () => Promise.resolve(new Set<string>()),
+  findImportedNodeUidBySourceRid: vi.fn(),
+  writeImportedSourceIdentity: vi.fn(),
+}));
+vi.mock("~/components/settings/utils/accessors", () => ({
+  createDiscourseNodeType: vi.fn(),
+}));
+vi.mock("~/utils/createRelationSchema", () => ({
+  createRelationSchema: vi.fn(),
+}));
+vi.mock("~/utils/createReifiedBlock", () => ({
+  getReifiedRelations: () => Promise.resolve([]),
+  createReifiedRelation: vi.fn(),
+}));
+vi.mock("roamjs-components/writes", () => ({ deleteBlock: vi.fn() }));
+vi.mock("~/utils/discoverSharedRelations", () => ({
+  discoverSharedRelations: () =>
+    Promise.resolve({
+      relations: [],
+      relTypeSchemas: [],
+      nodeSchemas: [
+        {
+          localId: "claim",
+          rid: "orn:obsidian.schema:remote/claim",
+          label: "Claim",
+          authorId: "author",
+          createdAt: new Date("2026-09-07"),
+        },
+      ],
+      relTripleSchemas: [
+        {
+          localId: "supports",
+          rid: "orn:obsidian.schema:remote/supports",
+          label: "Supports",
+          complement: "Supported by",
+          sourceType: "claim",
+          destinationType: "claim",
+          authorId: "author",
+          createdAt: new Date("2026-09-07"),
+        },
+      ],
+    }),
+}));
+
+const relation = (id: string): DiscourseRelation => ({
+  id,
+  label: "Supports",
+  complement: "Supported by",
+  source: "local-claim",
+  destination: "local-claim",
+  triples: [],
+});
+const client = {} as DGSupabaseClient;
+
+beforeEach(() => vi.clearAllMocks());
+
+describe("importSharedRelations schema matching", () => {
+  it("reuses one schema when its query patterns produce multiple matches", async () => {
+    vi.mocked(getDiscourseRelations).mockReturnValue([
+      {
+        ...relation("local-supports"),
+        triples: [["source", "references", "destination"]],
+      },
+      {
+        ...relation("local-supports"),
+        triples: [["source", "is in page", "destination"]],
+      },
+    ]);
+    await expect(importSharedRelations(client, 7)).resolves.toBeUndefined();
+    expect(createRelationSchema).not.toHaveBeenCalled();
+  });
+
+  it("rejects matches to two different schemas", async () => {
+    vi.mocked(getDiscourseRelations).mockReturnValue([
+      relation("supports-one"),
+      relation("supports-two"),
+    ]);
+    await expect(importSharedRelations(client, 7)).rejects.toThrow(
+      "multiple matches",
+    );
+    expect(createRelationSchema).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts b/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts
index 5cf18f4c0..4a5009534 100644
--- a/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts
+++ b/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts
@@ -28,6 +28,13 @@ vi.mock("~/utils/importedSourceIdentity", () => ({
   writeImportedSourceIdentity: vi.fn(),
 }));
 
+// Runs before the imports above: getDiscourseNodes calls generateUID at module load.
+vi.hoisted(() => {
+  (globalThis as { window?: unknown }).window = {
+    roamAlphaAPI: { util: { generateUID: () => "someUid" } },
+  };
+});
+
 const mockedGetPageTitleByPageUid = vi.mocked(getPageTitleByPageUid);
 const mockedGetPageUidByPageTitle = vi.mocked(getPageUidByPageTitle);
 const mockedGetShallowTreeByParentUid = vi.mocked(getShallowTreeByParentUid);
@@ -48,11 +55,19 @@ const blockFromMarkdown = vi.fn();
 const pageCreate = vi.fn();
 const pageDelete = vi.fn();
 const updatePage = vi.fn();
+const roamQuery = vi.fn();
 
 const CORE_TITLE = "REM sleep and recall";
 const DECORATED_TITLE = "[[EVD]] - REM sleep and recall";
 const NODE_TYPE = { format: "[[EVD]] - {content}" };
 
+const LOCAL_GRAPH = "local-graph";
+const SOURCED_NODE_TYPE = { format: "[[EVD]] - {content} - {Source}" };
+const SOURCE_PAGE_UID = "source-page-uid";
+const SOURCE_TITLE = "@Smith 2020";
+const SOURCED_TITLE = `[[EVD]] - REM sleep and recall - [[${SOURCE_TITLE}]]`;
+const IMPORTED_SOURCE_RID = "orn:obsidian.note:vault-b/node-6";
+
 const sharedNode: SharedNode = {
   rid: "orn:obsidian.note:vault-a/node-1",
   sourceLocalId: "node-1",
@@ -129,6 +144,8 @@ beforeEach(() => {
   (globalThis as { window: unknown }).window = {
     roamAlphaAPI: {
       updatePage,
+      graph: { name: LOCAL_GRAPH },
+      q: roamQuery,
       util: { generateUID: vi.fn(() => GENERATED_PAGE_UID) },
       data: {
         block: { fromMarkdown: blockFromMarkdown },
@@ -395,20 +412,255 @@ describe("materializeSharedNode", () => {
     });
   });
 
-  it("keeps the incoming title when the format has a placeholder core_title cannot fill", async () => {
+  it("keeps the incoming title and warns when no source was published", async () => {
     const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
 
     const result = await materializeSharedNode({
       client,
       sharedNode: decoratedSharedNode,
-      nodeType: { format: "[[EVD]] - {content} - {Source}" },
+      nodeType: SOURCED_NODE_TYPE,
     });
 
-    expect(result.success).toBe(true);
+    expect(result).toMatchObject({
+      success: true,
+      warning:
+        "No source was published with this node, so its title was kept as published.",
+    });
     expect(pageFromMarkdown).toHaveBeenCalledWith({
       page: { title: decoratedSharedNode.title, uid: GENERATED_PAGE_UID },
       "markdown-string": MATERIALIZED_MARKDOWN,
     });
+    expect(roamQuery).not.toHaveBeenCalled();
+  });
+
+  it("does not warn about a source when the publisher sent no core title", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode,
+      nodeType: SOURCED_NODE_TYPE,
+    });
+
+    expect(result).toEqual({
+      success: true,
+      action: "created",
+      pageUid: GENERATED_PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+  });
+
+  it("names a source page this graph owns", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    roamQuery.mockReturnValue([[1]]);
+    mockedGetPageTitleByPageUid.mockImplementation((uid) =>
+      uid === SOURCE_PAGE_UID ? SOURCE_TITLE : "",
+    );
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: {
+          sourceDocument: `https://roamresearch.com/#/app/${LOCAL_GRAPH}/${SOURCE_PAGE_UID}`,
+        },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+    });
+
+    expect(result).toEqual({
+      success: true,
+      action: "created",
+      pageUid: GENERATED_PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+    expect(roamQuery).toHaveBeenCalledWith(
+      "[:find (?e) :in $ ?uid :where [?e :block/uid ?uid]]",
+      SOURCE_PAGE_UID,
+    );
+    expect(mockedFindImportedNodeUidBySourceRid).toHaveBeenCalledTimes(1);
+    expect(pageFromMarkdown).toHaveBeenCalledWith({
+      page: { title: SOURCED_TITLE, uid: GENERATED_PAGE_UID },
+      "markdown-string": MATERIALIZED_MARKDOWN,
+    });
+  });
+
+  it("names a source page imported from the publisher's own space", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    mockedFindImportedNodeUidBySourceRid.mockImplementation((rid) =>
+      Promise.resolve(
+        rid === "orn:obsidian.note:vault-a/node-9" ? SOURCE_PAGE_UID : null,
+      ),
+    );
+    mockedGetPageTitleByPageUid.mockImplementation((uid) =>
+      uid === SOURCE_PAGE_UID ? SOURCE_TITLE : "",
+    );
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: { sourceDocument: "node-9" },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+    });
+
+    expect(result).toMatchObject({ success: true, action: "created" });
+    expect(result).not.toHaveProperty("warning");
+    expect(roamQuery).not.toHaveBeenCalled();
+    expect(pageFromMarkdown).toHaveBeenCalledWith({
+      page: { title: SOURCED_TITLE, uid: GENERATED_PAGE_UID },
+      "markdown-string": MATERIALIZED_MARKDOWN,
+    });
+  });
+
+  it("names a source page imported from a third space", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    mockedFindImportedNodeUidBySourceRid.mockImplementation((rid) =>
+      Promise.resolve(rid === IMPORTED_SOURCE_RID ? SOURCE_PAGE_UID : null),
+    );
+    mockedGetPageTitleByPageUid.mockImplementation((uid) =>
+      uid === SOURCE_PAGE_UID ? SOURCE_TITLE : "",
+    );
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: { sourceDocument: IMPORTED_SOURCE_RID },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+    });
+
+    expect(result).toMatchObject({ success: true, action: "created" });
+    expect(pageFromMarkdown).toHaveBeenCalledWith({
+      page: { title: SOURCED_TITLE, uid: GENERATED_PAGE_UID },
+      "markdown-string": MATERIALIZED_MARKDOWN,
+    });
+  });
+
+  it("keeps the incoming title and warns when the source is not in this graph", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: { sourceDocument: IMPORTED_SOURCE_RID },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+    });
+
+    expect(result).toMatchObject({
+      success: true,
+      action: "created",
+      warning: `Its source (${IMPORTED_SOURCE_RID}) is not in this graph, so its title was kept as published. Import the source, then refresh this page.`,
+    });
+    expect(mockedFindImportedNodeUidBySourceRid).toHaveBeenCalledWith(
+      IMPORTED_SOURCE_RID,
+    );
+    expect(pageFromMarkdown).toHaveBeenCalledWith({
+      page: { title: decoratedSharedNode.title, uid: GENERATED_PAGE_UID },
+      "markdown-string": MATERIALIZED_MARKDOWN,
+    });
+  });
+
+  it("does not look up the source of an import that is up to date", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    mockedFindImportedNodeUidBySourceRid.mockResolvedValue(EXISTING_PAGE_UID);
+    mockedReadImportedSourceIdentity.mockReturnValue({
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: { sourceDocument: IMPORTED_SOURCE_RID },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+    });
+
+    expect(result).toMatchObject({ success: true, action: "skipped" });
+    expect(mockedFindImportedNodeUidBySourceRid).toHaveBeenCalledTimes(1);
+    expect(mockedGetPageTitleByPageUid).not.toHaveBeenCalled();
+  });
+
+  it("leaves a title that already names its source untouched when refreshing", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    mockedFindImportedNodeUidBySourceRid.mockImplementation((rid) =>
+      Promise.resolve(
+        rid === IMPORTED_SOURCE_RID
+          ? SOURCE_PAGE_UID
+          : rid === sharedNode.rid
+            ? EXISTING_PAGE_UID
+            : null,
+      ),
+    );
+    mockedGetPageTitleByPageUid.mockImplementation((uid) =>
+      uid === SOURCE_PAGE_UID ? SOURCE_TITLE : SOURCED_TITLE,
+    );
+    mockedReadImportedSourceIdentity.mockReturnValue({
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: { sourceDocument: IMPORTED_SOURCE_RID },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+      force: true,
+    });
+
+    expect(result).toEqual({
+      success: true,
+      action: "updated",
+      pageUid: EXISTING_PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+    expect(updatePage).not.toHaveBeenCalled();
+  });
+
+  it("renames an imported page once its source arrives and it is refreshed", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    mockedFindImportedNodeUidBySourceRid.mockImplementation((rid) =>
+      Promise.resolve(
+        rid === IMPORTED_SOURCE_RID
+          ? SOURCE_PAGE_UID
+          : rid === sharedNode.rid
+            ? EXISTING_PAGE_UID
+            : null,
+      ),
+    );
+    mockedGetPageTitleByPageUid.mockImplementation((uid) =>
+      uid === SOURCE_PAGE_UID ? SOURCE_TITLE : decoratedSharedNode.title,
+    );
+    mockedReadImportedSourceIdentity.mockReturnValue({
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode: {
+        ...decoratedSharedNode,
+        slots: { sourceDocument: IMPORTED_SOURCE_RID },
+      },
+      nodeType: SOURCED_NODE_TYPE,
+      force: true,
+    });
+
+    expect(result).toMatchObject({ success: true, action: "updated" });
+    expect(updatePage).toHaveBeenCalledWith({
+      page: { uid: EXISTING_PAGE_UID, title: SOURCED_TITLE },
+    });
   });
 
   it("strips the Roam heading by the source title while decorating the page title", async () => {
diff --git a/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts b/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts
index 021e77dea..f8799419c 100644
--- a/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts
+++ b/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts
@@ -32,6 +32,7 @@ describe("refreshAllImportedNodes", () => {
       refreshed: 2,
       skipped: 1,
       failed: 1,
+      warnings: [],
     });
     expect(mockedRefreshImportedNode.mock.calls).toEqual([
       [{ pageUid: "uid-1", force: false }],
@@ -48,7 +49,29 @@ describe("refreshAllImportedNodes", () => {
       refreshed: 0,
       skipped: 0,
       failed: 0,
+      warnings: [],
     });
     expect(mockedRefreshImportedNode).not.toHaveBeenCalled();
   });
+
+  it("preserves source warnings alongside successful refresh counts", async () => {
+    mockedGetImportedNodeUids.mockResolvedValue(new Set(["uid-1", "uid-2"]));
+    mockedRefreshImportedNode
+      .mockResolvedValueOnce({
+        status: "refreshed",
+        message: 'Refreshed "Evidence" from Research vault.',
+        warning:
+          "Its source is not in this graph, so its title was kept as published.",
+      })
+      .mockResolvedValueOnce({ status: "refreshed", message: "Refreshed." });
+
+    await expect(refreshAllImportedNodes()).resolves.toEqual({
+      refreshed: 2,
+      skipped: 0,
+      failed: 0,
+      warnings: [
+        'Refreshed "Evidence" from Research vault. Its source is not in this graph, so its title was kept as published.',
+      ],
+    });
+  });
 });
diff --git a/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts b/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts
index 95ca388ba..657abdb3a 100644
--- a/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts
+++ b/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts
@@ -36,6 +36,13 @@ vi.mock("~/utils/supabaseContext", () => ({
   getLoggedInClient: vi.fn(),
 }));
 
+// Runs before the imports above: getDiscourseNodes calls generateUID at module load.
+vi.hoisted(() => {
+  (globalThis as { window?: unknown }).window = {
+    roamAlphaAPI: { util: { generateUID: () => "someUid" } },
+  };
+});
+
 const mockedGetPageTitleByPageUid = vi.mocked(getPageTitleByPageUid);
 const mockedGetSharedNodeByRid = vi.mocked(getSharedNodeByRid);
 const mockedReadImportedSourceIdentity = vi.mocked(readImportedSourceIdentity);
@@ -121,6 +128,25 @@ describe("refreshImportedNode", () => {
     expect(mockedInternalError).not.toHaveBeenCalled();
   });
 
+  it("passes the materializer's warning through", async () => {
+    mockedMaterializeSharedNode.mockResolvedValue({
+      success: true,
+      action: "updated",
+      pageUid: PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+      warning: "No source was published with this node.",
+    });
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "refreshed",
+      message: 'Refreshed "EVD - REM sleep and recall" from Research vault.',
+      warning: "No source was published with this node.",
+    });
+  });
+
   it("passes the resolved node type to the materializer", async () => {
     mockedResolveSharedNodeTypes.mockResolvedValue(
       new Map([[sharedNode.schemaId, NODE_TYPE]]),
diff --git a/apps/roam/src/utils/__tests__/sourceSlot.test.ts b/apps/roam/src/utils/__tests__/sourceSlot.test.ts
new file mode 100644
index 000000000..2e58314e2
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/sourceSlot.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from "vitest";
+
+// Runs before the imports below: getDiscourseNodes calls generateUID at module load.
+vi.hoisted(() => {
+  (globalThis as { window?: unknown }).window = {
+    roamAlphaAPI: { util: { generateUID: () => "someUid" } },
+  };
+});
+
+import { titleWithSource } from "~/utils/sourceSlot";
+
+describe("titleWithSource", () => {
+  it("fills the content and source placeholders", () => {
+    expect(
+      titleWithSource({
+        format: "[[EVD]] - {content} - {Source}",
+        coreTitle: "REM sleep and recall",
+        sourceTitle: "@Smith 2020",
+      }),
+    ).toBe("[[EVD]] - REM sleep and recall - [[@Smith 2020]]");
+  });
+
+  it("matches placeholder names regardless of case", () => {
+    expect(
+      titleWithSource({
+        format: "{SOURCE}: {Content}",
+        coreTitle: "x",
+        sourceTitle: "y",
+      }),
+    ).toBe("[[y]]: x");
+  });
+
+  it("inserts titles that contain replacement patterns verbatim", () => {
+    expect(
+      titleWithSource({
+        format: "[[EVD]] - {content} - {Source}",
+        coreTitle: "costs $& more",
+        sourceTitle: "$1 paper",
+      }),
+    ).toBe("[[EVD]] - costs $& more - [[$1 paper]]");
+  });
+
+  it("returns null when the format has a placeholder it cannot fill", () => {
+    expect(
+      titleWithSource({
+        format: "[[EVD]] - {content} - {Source} - {Author}",
+        coreTitle: "x",
+        sourceTitle: "y",
+      }),
+    ).toBeNull();
+  });
+
+  it("returns null when the format has no content placeholder", () => {
+    expect(
+      titleWithSource({
+        format: "[[EVD]] - {Source}",
+        coreTitle: "x",
+        sourceTitle: "y",
+      }),
+    ).toBeNull();
+  });
+});
diff --git a/apps/roam/src/utils/findTargetUid.ts b/apps/roam/src/utils/findTargetUid.ts
new file mode 100644
index 000000000..18d9104c1
--- /dev/null
+++ b/apps/roam/src/utils/findTargetUid.ts
@@ -0,0 +1,37 @@
+import {
+  isRid,
+  ridToSpaceUriAndLocalId,
+  spaceUriAndLocalIdToRid,
+} from "@repo/database/lib/rid";
+import canonicalRoamUrl from "./canonicalRoamUrl";
+import { findImportedNodeUidBySourceRid } from "./importedSourceIdentity";
+
+// A shared node refers to another node by its bare local id when both live in the same
+// space, and by a RID otherwise. "note" is the subtype node RIDs carry; URL-shaped Roam
+// RIDs ignore it.
+export const sharedReferenceRid = (
+  localOrRid: string,
+  spaceUri: string,
+): string =>
+  isRid(localOrRid)
+    ? localOrRid
+    : spaceUriAndLocalIdToRid(spaceUri, localOrRid, "note");
+
+// The local page for a node another space refers to: its own uid when the RID points
+// into this graph, else the page imported from it.
+export const findTargetUid = async (
+  localOrRid: string,
+  spaceUri: string,
+): Promise<string | null> => {
+  const rid = sharedReferenceRid(localOrRid, spaceUri);
+  const { spaceUri: ridSpaceUri, sourceLocalId } = ridToSpaceUriAndLocalId(rid);
+  if (ridSpaceUri === canonicalRoamUrl()) {
+    const result = window.roamAlphaAPI.q(
+      "[:find (?e) :in $ ?uid :where [?e :block/uid ?uid]]",
+      sourceLocalId,
+    );
+    if (!result || result.length === 0) return null;
+    return sourceLocalId;
+  }
+  return await findImportedNodeUidBySourceRid(rid);
+};
diff --git a/apps/roam/src/utils/importSharedNodes.ts b/apps/roam/src/utils/importSharedNodes.ts
index 6a4f23abc..3eca603e2 100644
--- a/apps/roam/src/utils/importSharedNodes.ts
+++ b/apps/roam/src/utils/importSharedNodes.ts
@@ -1,10 +1,12 @@
 import type { DGSupabaseClient } from "@repo/database/lib/client";
 import type { SharedNode } from "@repo/database/lib/sharedNodes";
+import { sharedReferenceRid } from "./findTargetUid";
 import {
   getErrorMessage,
   materializeSharedNode,
 } from "./materializeSharedNode";
 import { resolveSharedNodeTypes } from "./resolveSharedNodeTypes";
+import { SOURCE_SLOT } from "./sourceSlot";
 
 export type FailedSharedNodeImport = {
   sharedNode: SharedNode;
@@ -13,13 +15,30 @@ export type FailedSharedNodeImport = {
 };
 
 export type SharedNodeImportItem =
-  | { sharedNode: SharedNode; status: "imported" | "skipped" }
+  | { sharedNode: SharedNode; status: "imported" | "skipped"; warning?: string }
   | FailedSharedNodeImport;
 
 export const isFailedSharedNodeImport = (
   item: SharedNodeImportItem,
 ): item is FailedSharedNodeImport => item.status === "failed";
 
+// A node's title can only name its source once that source has a local page, so the
+// nodes other batch members refer to are materialized first. One level only: a source
+// that itself names a source in the batch is not ordered after it, and its title is
+// filled on the next refresh instead.
+const orderSourcesFirst = (sharedNodes: SharedNode[]): SharedNode[] => {
+  const referencedRids = new Set(
+    sharedNodes.flatMap((node) => {
+      const source = node.slots?.[SOURCE_SLOT];
+      return source ? [sharedReferenceRid(source, node.spaceUri)] : [];
+    }),
+  );
+  return [
+    ...sharedNodes.filter((node) => referencedRids.has(node.rid)),
+    ...sharedNodes.filter((node) => !referencedRids.has(node.rid)),
+  ];
+};
+
 export const importSharedNodes = async ({
   client,
   sharedNodes,
@@ -34,7 +53,7 @@ export const importSharedNodes = async ({
     sharedNodes,
   });
   const items: SharedNodeImportItem[] = [];
-  for (const sharedNode of sharedNodes) {
+  for (const sharedNode of orderSourcesFirst(sharedNodes)) {
     try {
       const result = await materializeSharedNode({
         client,
@@ -46,6 +65,7 @@ export const importSharedNodes = async ({
           ? {
               sharedNode,
               status: result.action === "skipped" ? "skipped" : "imported",
+              ...(result.warning ? { warning: result.warning } : {}),
             }
           : { sharedNode, status: "failed", message: result.error.message },
       );
diff --git a/apps/roam/src/utils/importSharedRelations.ts b/apps/roam/src/utils/importSharedRelations.ts
index adb7aa5cd..70732bfc4 100644
--- a/apps/roam/src/utils/importSharedRelations.ts
+++ b/apps/roam/src/utils/importSharedRelations.ts
@@ -6,9 +6,9 @@ import type {
 } from "@repo/database/crossAppContracts";
 import {
   spaceUriAndLocalIdToRid,
-  isRid,
   ridToSpaceUriAndLocalId,
 } from "@repo/database/lib/rid";
+import { findTargetUid } from "./findTargetUid";
 import {
   findImportedNodeUidBySourceRid,
   getImportedSourceRids,
@@ -27,7 +27,6 @@ import {
 import { discoverSharedRelations } from "./discoverSharedRelations";
 import { DGSupabaseClient } from "@repo/database/lib/client";
 import { deleteBlock } from "roamjs-components/writes";
-import canonicalRoamUrl from "./canonicalRoamUrl";
 
 const matchImportedNodeSchemas = async (
   nodeSchemas: CrossAppNodeSchema[],
@@ -139,11 +138,13 @@ const matchImportedRelationSchemas = async (
           r.source === source &&
           r.destination === destination,
       );
-      if (match.length > 1) {
+      // Each query pattern can produce a match for the same local schema.
+      const matchIds = [...new Set(match.map(({ id }) => id))];
+      if (matchIds.length > 1) {
         throw new Error("multiple matches");
       }
-      if (match.length === 1) {
-        blockUid = match[0].id;
+      if (matchIds.length === 1) {
+        blockUid = matchIds[0];
       } else {
         blockUid = await createRelationSchema({
           label,
@@ -175,33 +176,6 @@ const matchImportedRelationSchemas = async (
   return result;
 };
 
-const localSpaceUrl = canonicalRoamUrl(window.roamAlphaAPI.graph.name);
-
-const findTargetUid = async (
-  localOrRid: string,
-  spaceUri: string,
-  ridType?: string,
-): Promise<string | null> => {
-  if (isRid(localOrRid)) {
-    const { spaceUri, sourceLocalId } = ridToSpaceUriAndLocalId(localOrRid);
-    if (spaceUri === localSpaceUrl) {
-      // check existence
-      const result = window.roamAlphaAPI.q(
-        `[:find (?e) :where [?e :block/uid "${sourceLocalId}"]]`,
-      );
-      if (!result || result.length === 0) return null;
-      return sourceLocalId;
-    }
-  } else {
-    localOrRid = spaceUriAndLocalIdToRid(
-      spaceUri,
-      localOrRid,
-      ridType ?? "note",
-    );
-  }
-  return await findImportedNodeUidBySourceRid(localOrRid);
-};
-
 const importRelations = async (
   schemaRidToLocalId: Record<string, string>,
   relations: CrossAppRelation[],
diff --git a/apps/roam/src/utils/materializeSharedNode.ts b/apps/roam/src/utils/materializeSharedNode.ts
index 6fbd7cac0..d285dd2a2 100644
--- a/apps/roam/src/utils/materializeSharedNode.ts
+++ b/apps/roam/src/utils/materializeSharedNode.ts
@@ -12,6 +12,7 @@ import getPageTitleByPageUid from "roamjs-components/queries/getPageTitleByPageU
 import getPageUidByPageTitle from "roamjs-components/queries/getPageUidByPageTitle";
 import getShallowTreeByParentUid from "roamjs-components/queries/getShallowTreeByParentUid";
 import deleteBlock from "roamjs-components/writes/deleteBlock";
+import { findTargetUid } from "./findTargetUid";
 import type { DiscourseNode } from "./getDiscourseNodes";
 import {
   findImportedNodeUidBySourceRid,
@@ -19,6 +20,11 @@ import {
   writeImportedSourceIdentity,
   type ImportedSourceIdentity,
 } from "./importedSourceIdentity";
+import {
+  schemaHasSourceSlot,
+  SOURCE_SLOT,
+  titleWithSource,
+} from "./sourceSlot";
 
 type MaterializationStage =
   | "validate-input"
@@ -48,6 +54,7 @@ type MaterializationSuccess = SourceIdentity & {
   success: true;
   action: "created" | "updated" | "skipped";
   pageUid: string;
+  warning?: string;
 };
 
 export type MaterializeSharedNodeResult =
@@ -128,6 +135,53 @@ const validateSharedNode = (
   return { sourceModifiedAt: modifiedAt.toISOString(), title };
 };
 
+// The Source page a node's sourceDocument slot names, when this graph has it.
+const resolveSourceTitle = async (
+  sharedNode: SharedNode,
+): Promise<{ sourceTitle: string } | { warning: string }> => {
+  const slotValue = sharedNode.slots?.[SOURCE_SLOT];
+  if (!slotValue)
+    return {
+      warning:
+        "No source was published with this node, so its title was kept as published.",
+    };
+  const sourceUid = await findTargetUid(slotValue, sharedNode.spaceUri);
+  const sourceTitle = sourceUid ? getPageTitleByPageUid(sourceUid) : "";
+  if (!sourceTitle)
+    return {
+      warning: `Its source (${slotValue}) is not in this graph, so its title was kept as published. Import the source, then refresh this page.`,
+    };
+  return { sourceTitle };
+};
+
+const buildPageTitle = async ({
+  sharedNode,
+  nodeType,
+  incomingTitle,
+}: {
+  sharedNode: SharedNode;
+  nodeType?: Pick<DiscourseNode, "format">;
+  incomingTitle: string;
+}): Promise<{ title: string; warning?: string }> => {
+  const coreTitle = sharedNode.coreTitle;
+  if (!coreTitle || !nodeType) return { title: incomingTitle };
+  if (!schemaHasSourceSlot(nodeType))
+    return {
+      title: decorateTitle(nodeType.format, coreTitle) ?? incomingTitle,
+    };
+  const source = await resolveSourceTitle(sharedNode);
+  if ("warning" in source)
+    return { title: incomingTitle, warning: source.warning };
+  return {
+    title:
+      titleWithSource({
+        format: nodeType.format,
+        coreTitle,
+        sourceTitle: source.sourceTitle,
+      }) ?? incomingTitle,
+  };
+};
+
 const fetchFullMarkdown = async ({
   client,
   sharedNode,
@@ -319,10 +373,6 @@ export const materializeSharedNode = async ({
     sourceModifiedAt: validated.sourceModifiedAt,
     sourceNodeRid: sharedNode.rid,
   };
-  const pageTitle =
-    (sharedNode.coreTitle && nodeType
-      ? decorateTitle(nodeType.format, sharedNode.coreTitle)
-      : null) ?? validated.title;
 
   let importedPageUid: string | null;
   let storedIdentity: ImportedSourceIdentity | undefined;
@@ -356,6 +406,12 @@ export const materializeSharedNode = async ({
       pageUid: importedPageUid,
     };
 
+  const { title: pageTitle, warning } = await buildPageTitle({
+    sharedNode,
+    nodeType,
+    incomingTitle: validated.title,
+  });
+
   const content = await fetchFullMarkdown({ client, sharedNode }).catch(
     (error: unknown) => ({ error: getErrorMessage(error) }),
   );
@@ -366,7 +422,7 @@ export const materializeSharedNode = async ({
       stage: "fetch-content",
     });
 
-  return importedPageUid
+  const result = await (importedPageUid
     ? updateImportedPage({
         identity,
         markdown: content.markdown,
@@ -377,5 +433,6 @@ export const materializeSharedNode = async ({
         identity,
         markdown: content.markdown,
         title: pageTitle,
-      });
+      }));
+  return result.success && warning ? { ...result, warning } : result;
 };
diff --git a/apps/roam/src/utils/refreshAllImportedNodes.ts b/apps/roam/src/utils/refreshAllImportedNodes.ts
index 5fbe8e990..785d1db39 100644
--- a/apps/roam/src/utils/refreshAllImportedNodes.ts
+++ b/apps/roam/src/utils/refreshAllImportedNodes.ts
@@ -5,6 +5,7 @@ type RefreshAllImportedNodesResult = {
   refreshed: number;
   skipped: number;
   failed: number;
+  warnings: string[];
 };
 
 export const refreshAllImportedNodes =
@@ -14,10 +15,13 @@ export const refreshAllImportedNodes =
       refreshed: 0,
       skipped: 0,
       failed: 0,
+      warnings: [],
     };
     for (const pageUid of pageUids) {
       const result = await refreshImportedNode({ pageUid, force: false });
       counts[result.status] += 1;
+      if (result.warning)
+        counts.warnings.push(`${result.message} ${result.warning}`);
     }
     return counts;
   };
diff --git a/apps/roam/src/utils/refreshImportedNode.ts b/apps/roam/src/utils/refreshImportedNode.ts
index a3ae9208a..2fb6a709e 100644
--- a/apps/roam/src/utils/refreshImportedNode.ts
+++ b/apps/roam/src/utils/refreshImportedNode.ts
@@ -15,6 +15,7 @@ const REFRESH_ERROR_OPERATION = "refresh-imported-node";
 type RefreshImportedNodeResult = {
   status: "refreshed" | "skipped" | "failed";
   message: string;
+  warning?: string;
 };
 
 export const refreshImportedNode = async ({
@@ -86,6 +87,7 @@ export const refreshImportedNode = async ({
     return {
       status: "refreshed",
       message: `Refreshed "${sharedNode.title}" from ${sharedNode.spaceName}.`,
+      ...(result.warning ? { warning: result.warning } : {}),
     };
   } catch (error) {
     internalError({
diff --git a/apps/roam/src/utils/registerCommandPaletteCommands.ts b/apps/roam/src/utils/registerCommandPaletteCommands.ts
index 537068342..17b215fb3 100644
--- a/apps/roam/src/utils/registerCommandPaletteCommands.ts
+++ b/apps/roam/src/utils/registerCommandPaletteCommands.ts
@@ -378,7 +378,8 @@ export const registerCommandPaletteCommands = (onloadArgs: OnloadArgs) => {
       timeout: 0,
     });
     try {
-      const { refreshed, skipped, failed } = await refreshAllImportedNodes();
+      const { refreshed, skipped, failed, warnings } =
+        await refreshAllImportedNodes();
       if (refreshed + skipped + failed === 0) {
         renderToast({
           id: REFRESH_ALL_TOAST_ID,
@@ -388,8 +389,11 @@ export const registerCommandPaletteCommands = (onloadArgs: OnloadArgs) => {
       }
       renderToast({
         id: REFRESH_ALL_TOAST_ID,
-        intent: failed > 0 ? "warning" : "success",
-        content: `${refreshed} refreshed, ${skipped} skipped, ${failed} failed.`,
+        intent: failed > 0 || warnings.length > 0 ? "warning" : "success",
+        content: [
+          `${refreshed} refreshed, ${skipped} skipped, ${failed} failed.`,
+          ...warnings,
+        ].join(" "),
       });
     } catch (error) {
       internalError({
diff --git a/apps/roam/src/utils/sourceSlot.ts b/apps/roam/src/utils/sourceSlot.ts
index 9a6c88561..12b662c50 100644
--- a/apps/roam/src/utils/sourceSlot.ts
+++ b/apps/roam/src/utils/sourceSlot.ts
@@ -1,3 +1,4 @@
+import { FORMAT_PLACEHOLDER } from "@repo/database/lib/decorateTitle";
 import getDiscourseNodes, { type DiscourseNode } from "./getDiscourseNodes";
 import getPageUidByPageTitle from "roamjs-components/queries/getPageUidByPageTitle";
 import getDiscourseNodeFormatExpression from "./getDiscourseNodeFormatExpression";
@@ -11,11 +12,13 @@ import { extractFieldFromTitle } from "./extractContentFromTitle";
 
 export const SOURCE_SLOT = "sourceDocument";
 const DEFAULT_SOURCE_SCHEMA_ID = "_SRC-node";
+const CONTENT_PLACEHOLDER = "{content}";
+const SOURCE_PLACEHOLDER = "{source}";
 
 type NodeFormat = Pick<DiscourseNode, "format">;
 
 export const schemaHasSourceSlot = (schema: NodeFormat): boolean =>
-  (schema?.format ?? "").toLowerCase().includes("{source}");
+  (schema?.format ?? "").toLowerCase().includes(SOURCE_PLACEHOLDER);
 
 const sourceNodeType = (allNodes: DiscourseNode[]): DiscourseNode | undefined =>
   allNodes.find((node) => node.text.toLowerCase() === "source");
@@ -69,3 +72,35 @@ export const sourceUidOfNode = (
     return undefined;
   return getPageUidByPageTitle(sourceTitle) || undefined;
 };
+
+const FILLABLE_PLACEHOLDERS = new Set([
+  CONTENT_PLACEHOLDER,
+  SOURCE_PLACEHOLDER,
+]);
+
+// Inverse of sourceUidOfNode, for the pull side: the local title of a node whose format
+// names a source, built from its core title and the Source page's title. Null when the
+// format has a placeholder neither fills, so the caller keeps the incoming title.
+export const titleWithSource = ({
+  format,
+  coreTitle,
+  sourceTitle,
+}: {
+  format: string;
+  coreTitle: string;
+  sourceTitle: string;
+}): string | null => {
+  const placeholders = (format.match(FORMAT_PLACEHOLDER) ?? []).map(
+    (placeholder) => placeholder.toLowerCase(),
+  );
+  if (
+    !placeholders.includes(CONTENT_PLACEHOLDER) ||
+    placeholders.some((placeholder) => !FILLABLE_PLACEHOLDERS.has(placeholder))
+  )
+    return null;
+  return format.replace(FORMAT_PLACEHOLDER, (placeholder) =>
+    placeholder.toLowerCase() === CONTENT_PLACEHOLDER
+      ? coreTitle
+      : `[[${sourceTitle}]]`,
+  );
+};
diff --git a/packages/database/src/lib/__tests__/sharedNodes.test.ts b/packages/database/src/lib/__tests__/sharedNodes.test.ts
index b854153ee..c7d03566a 100644
--- a/packages/database/src/lib/__tests__/sharedNodes.test.ts
+++ b/packages/database/src/lib/__tests__/sharedNodes.test.ts
@@ -208,7 +208,32 @@ describe("buildSharedNodes", () => {
       })[0]?.slots,
     ).toEqual({
       evidence: "node-5",
-      claim: "orn:obsidian:vault-b/node-6",
+      claim: "orn:obsidian.note:vault-b/node-6",
+    });
+  });
+
+  it("builds a URL rid without subtype for a slot in a Roam space", () => {
+    const roamSpace: BuildArgs["spaces"][number] = {
+      id: 22,
+      name: "Research graph",
+      platform: "Roam",
+      url: "https://roamresearch.com/#/app/research-graph",
+    };
+    const nodeWithRoamSlot: BuildArgs["nodes"][number] = {
+      ...nodes[0]!,
+      reference_content: { sourceDocument: 8 },
+      concepts_of_relation: [
+        { id: 8, space_id: 22, source_local_id: "roam-uid-8" },
+      ],
+    };
+    expect(
+      build({
+        nodesOverride: [nodeWithRoamSlot],
+        spacesOverride: [...spaces, roamSpace],
+      })[0]?.slots,
+    ).toEqual({
+      sourceDocument:
+        "https://roamresearch.com/#/app/research-graph/roam-uid-8",
     });
   });
 
diff --git a/packages/database/src/lib/sharedNodes.ts b/packages/database/src/lib/sharedNodes.ts
index a71310876..8bfde5a2a 100644
--- a/packages/database/src/lib/sharedNodes.ts
+++ b/packages/database/src/lib/sharedNodes.ts
@@ -39,6 +39,9 @@ type SharedSpace = Pick<
 >;
 type Platform = Enums<"Platform">;
 
+const nodeRidSubtype = (platform: Platform): string | undefined =>
+  platform === "Obsidian" ? "note" : undefined;
+
 type ValidSharedSpace = {
   name: string;
   platform: Platform;
@@ -193,7 +196,7 @@ export const buildSharedNodes = ({
         rid = spaceUriAndLocalIdToRid(
           space.url,
           node.source_local_id,
-          space.platform === "Obsidian" ? "note" : undefined,
+          nodeRidSubtype(space.platform),
         );
       } catch {
         return [];
@@ -208,7 +211,11 @@ export const buildSharedNodes = ({
             if (!space || !c.source_local_id || !c.id) return [c.id, undefined];
             return [
               c.id,
-              spaceUriAndLocalIdToRid(space.url, c.source_local_id),
+              spaceUriAndLocalIdToRid(
+                space.url,
+                c.source_local_id,
+                nodeRidSubtype(space.platform),
+              ),
             ];
           }) as [number, string | undefined][],
       );