diff --git a/apps/roam/src/components/Export.tsx b/apps/roam/src/components/Export.tsx
index 6d1b5f071..0f1c350fb 100644
--- a/apps/roam/src/components/Export.tsx
+++ b/apps/roam/src/components/Export.tsx
@@ -91,7 +91,7 @@ import {
   type NodeUidWithType,
 } from "~/utils/publishNodesToGroups";
 import { getLoggedInClient, getSupabaseContext } from "~/utils/supabaseContext";
-import { isSyncEnabled } from "~/components/settings/utils/accessors";
+import { isNodeSharingEnabled } from "~/components/settings/utils/accessors";
 
 const ExportProgress = ({ id }: { id: string }) => {
   const [progress, setProgress] = useState(0);
@@ -218,12 +218,12 @@ const ExportDialog: ExportDialogComponent = ({
     useState<(typeof SEND_TO_DESTINATIONS)[number]>("page");
   const isSendToGraph = activeSendToDestination === "graph";
   const [livePages, setLivePages] = useState<Result[]>([]);
-  const syncEnabled = useMemo(() => isSyncEnabled(), []);
+  const sharingEnabled = useMemo(() => isNodeSharingEnabled(), []);
   const [selectedTabId, setSelectedTabId] = useState("sendto");
   useEffect(() => {
-    if (initialPanel === "publish" && !syncEnabled) return;
+    if (initialPanel === "publish" && !sharingEnabled) return;
     if (initialPanel) setSelectedTabId(INITIAL_PANEL_TO_TAB_ID[initialPanel]);
-  }, [initialPanel, syncEnabled]);
+  }, [initialPanel, sharingEnabled]);
   const [includeDiscourseContext, setIncludeDiscourseContext] = useState(false);
   const [gitHubAccessToken, setGitHubAccessToken] = useState<string | null>(
     getSetting<string | null>("oauth-github", null),
@@ -240,7 +240,7 @@ const ExportDialog: ExportDialogComponent = ({
 
   const publishableNodes = useMemo(
     () =>
-      syncEnabled
+      sharingEnabled
         ? results
             .map((r) => {
               const node = findDiscourseNode({ uid: r.uid });
@@ -250,7 +250,7 @@ const ExportDialog: ExportDialogComponent = ({
             })
             .filter((n): n is NodeUidWithType => n !== null)
         : [],
-    [results, syncEnabled],
+    [results, sharingEnabled],
   );
   const nonDiscourseCount = results.length - publishableNodes.length;
 
@@ -808,7 +808,7 @@ const ExportDialog: ExportDialogComponent = ({
   };
   useEffect(() => {
     if (
-      !syncEnabled ||
+      !sharingEnabled ||
       !isOpen ||
       selectedTabId !== "publish" ||
       groupsLoaded ||
@@ -829,7 +829,7 @@ const ExportDialog: ExportDialogComponent = ({
         setGroupsLoaded(true);
       }
     })();
-  }, [syncEnabled, isOpen, selectedTabId, groupsLoaded, groupsLoading]);
+  }, [sharingEnabled, isOpen, selectedTabId, groupsLoaded, groupsLoading]);
 
   const handlePublish = async () => {
     setPublishError("");
@@ -840,7 +840,7 @@ const ExportDialog: ExportDialogComponent = ({
       if (!client || !context) throw new Error("Could not connect to sync.");
       const {
         publishedNodeUids,
-        skippedUnsyncedUids,
+        failedUpsertUids,
         okGroupIds,
         failedGroupIds,
       } = await publishNodeUidsWithTypeToGroups({
@@ -849,10 +849,14 @@ const ExportDialog: ExportDialogComponent = ({
         groupIds: selectedGroupIds,
         nodeUids: publishableNodes,
       });
+      const selectedNodeUids = new Set(publishableNodes.map((n) => n.uid));
+      const failedNodeCount = failedUpsertUids.filter((uid) =>
+        selectedNodeUids.has(uid),
+      ).length;
       posthog.capture("Export Dialog: Publish", {
         groupCount: okGroupIds.length,
         publishedNodeCount: publishedNodeUids.length,
-        skippedUnsyncedCount: skippedUnsyncedUids.length,
+        failedUpsertCount: failedUpsertUids.length,
         nonDiscourseCount,
         failedGroupCount: failedGroupIds.length,
       });
@@ -866,10 +870,8 @@ const ExportDialog: ExportDialogComponent = ({
             }.`,
           ]
         : ["No nodes were published."];
-      if (skippedUnsyncedUids.length)
-        messages.push(
-          `${skippedUnsyncedUids.length} not synced yet — try again shortly.`,
-        );
+      if (failedNodeCount)
+        messages.push(`${failedNodeCount} failed to publish.`);
       if (nonDiscourseCount)
         messages.push(`${nonDiscourseCount} skipped (not discourse nodes).`);
       if (failedGroupIds.length)
@@ -881,7 +883,9 @@ const ExportDialog: ExportDialogComponent = ({
       renderToast({
         content: messages.join(" "),
         intent:
-          failedGroupIds.length || !hasPublishedNodes ? "warning" : "success",
+          failedGroupIds.length || failedNodeCount || !hasPublishedNodes
+            ? "warning"
+            : "success",
         id: "query-builder-publish-success",
       });
       if (hasPublishedNodes) onClose();
@@ -1263,7 +1267,7 @@ const ExportDialog: ExportDialogComponent = ({
         >
           <Tab id="sendto" title="Send To" panel={SendToPanel} />
           <Tab id="export" title="Export" panel={ExportPanel} />
-          {syncEnabled && (
+          {sharingEnabled && (
             <Tab id="publish" title="Publish" panel={PublishPanel} />
           )}
         </Tabs>
diff --git a/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx b/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx
new file mode 100644
index 000000000..2fa6ac04a
--- /dev/null
+++ b/apps/roam/src/components/RefreshImportedNodeTitleButton.tsx
@@ -0,0 +1,63 @@
+import { Button } from "@blueprintjs/core";
+import posthog from "posthog-js";
+import React, { useState } from "react";
+import renderToast from "roamjs-components/components/Toast";
+import { handleTitleAdditions } from "~/utils/handleTitleAdditions";
+import { refreshImportedNode } from "~/utils/refreshImportedNode";
+
+const REFRESH_TITLE_BUTTON_ATTRIBUTE =
+  "data-roamjs-refresh-imported-node-title-button";
+
+const RefreshImportedNodeTitleButton = ({
+  uid,
+}: {
+  uid: string;
+}): JSX.Element => {
+  const [refreshing, setRefreshing] = useState(false);
+
+  const refresh = async (): Promise<void> => {
+    setRefreshing(true);
+    try {
+      const result = await refreshImportedNode({ pageUid: uid, force: true });
+      const failed = result.status === "failed";
+      renderToast({
+        id: failed
+          ? "refresh-imported-node-failed"
+          : "refresh-imported-node-success",
+        intent: failed ? "danger" : "success",
+        content: result.message,
+      });
+    } finally {
+      setRefreshing(false);
+    }
+  };
+
+  return (
+    <Button
+      text="Refresh"
+      icon="refresh"
+      minimal
+      outlined
+      loading={refreshing}
+      onClick={() => {
+        posthog.capture("Refresh Imported Node: Page Title Button Triggered", {
+          pageUid: uid,
+        });
+        void refresh();
+      }}
+    />
+  );
+};
+
+export const renderRefreshImportedNodeTitleButton = ({
+  h1,
+  uid,
+}: {
+  h1: HTMLHeadingElement;
+  uid: string;
+}): void => {
+  if (h1.getAttribute(REFRESH_TITLE_BUTTON_ATTRIBUTE) === uid) return;
+
+  h1.setAttribute(REFRESH_TITLE_BUTTON_ATTRIBUTE, uid);
+  handleTitleAdditions(h1, <RefreshImportedNodeTitleButton uid={uid} />);
+};
diff --git a/apps/roam/src/components/settings/AdminPanel.tsx b/apps/roam/src/components/settings/AdminPanel.tsx
index d05cdfe29..da19cd120 100644
--- a/apps/roam/src/components/settings/AdminPanel.tsx
+++ b/apps/roam/src/components/settings/AdminPanel.tsx
@@ -356,6 +356,12 @@ const FeatureFlagsTab = (): React.ReactElement => {
         onAfterChange={(checked) => setAdvancedNodeSearchValue(checked)}
       />
 
+      <FeatureFlagPanel
+        title="Node sharing"
+        description="This enables a user to share nodes to other discourse spaces and keeps shared nodes synced in the background. Reload the graph after toggling."
+        featureKey="Enable node sharing"
+      />
+
       <Alert
         isOpen={isConsentAlertOpen}
         onConfirm={() => {
diff --git a/apps/roam/src/components/settings/DiscourseNodeSuggestiveRules.tsx b/apps/roam/src/components/settings/DiscourseNodeSuggestiveRules.tsx
index 67a546c92..a224327dd 100644
--- a/apps/roam/src/components/settings/DiscourseNodeSuggestiveRules.tsx
+++ b/apps/roam/src/components/settings/DiscourseNodeSuggestiveRules.tsx
@@ -5,6 +5,7 @@ import getSubTree from "roamjs-components/util/getSubTree";
 import { DiscourseNode } from "~/utils/getDiscourseNodes";
 import extractRef from "roamjs-components/util/extractRef";
 import { getAllDiscourseNodesSince } from "~/utils/getAllDiscourseNodesSince";
+import { getImportedNodeUids } from "~/utils/importedSourceIdentity";
 import { upsertNodesToSupabaseAsContentWithEmbeddings } from "~/utils/syncDgNodesToSupabase";
 import { getLoggedInClient, getSupabaseContext } from "~/utils/supabaseContext";
 import {
@@ -56,8 +57,11 @@ const DiscourseNodeSuggestiveRules = ({
 
       const context = await getSupabaseContext();
       if (context && blockNodesSince) {
+        const importedNodeUids = await getImportedNodeUids();
         await upsertNodesToSupabaseAsContentWithEmbeddings(
-          blockNodesSince,
+          blockNodesSince.filter(
+            (node) => !importedNodeUids.has(node.source_local_id),
+          ),
           supabaseClient,
           context,
         );
diff --git a/apps/roam/src/components/settings/utils/accessors.ts b/apps/roam/src/components/settings/utils/accessors.ts
index 1c1fa0ad5..2eaa190c8 100644
--- a/apps/roam/src/components/settings/utils/accessors.ts
+++ b/apps/roam/src/components/settings/utils/accessors.ts
@@ -763,6 +763,9 @@ export const readAllLegacyDiscourseNodeSettings = (
 export const isSyncEnabled = (): boolean =>
   getFeatureFlag("Suggestive mode overlay enabled");
 
+export const isNodeSharingEnabled = (): boolean =>
+  getFeatureFlag("Enable node sharing");
+
 export const setFeatureFlag = (
   key: keyof FeatureFlags,
   value: boolean,
diff --git a/apps/roam/src/components/settings/utils/settingKeys.ts b/apps/roam/src/components/settings/utils/settingKeys.ts
index 1dcec7bf0..6278f423e 100644
--- a/apps/roam/src/components/settings/utils/settingKeys.ts
+++ b/apps/roam/src/components/settings/utils/settingKeys.ts
@@ -13,6 +13,7 @@ import type {
 
 export const FEATURE_FLAG_KEYS = {
   enableLeftSidebar: "Enable left sidebar",
+  enableNodeSharing: "Enable node sharing",
   suggestiveModeOverlayEnabled: "Suggestive mode overlay enabled",
   useNewSettingsStore: "Use new settings store",
 } as const satisfies Record<string, keyof FeatureFlags>;
diff --git a/apps/roam/src/components/settings/utils/zodSchema.example.ts b/apps/roam/src/components/settings/utils/zodSchema.example.ts
index 58fc827da..fc199a676 100644
--- a/apps/roam/src/components/settings/utils/zodSchema.example.ts
+++ b/apps/roam/src/components/settings/utils/zodSchema.example.ts
@@ -87,6 +87,7 @@ const discourseNodeSettings: DiscourseNodeSettings = {
 const featureFlags: FeatureFlags = {
   "Advanced node search enabled": true,
   "Enable left sidebar": true,
+  "Enable node sharing": true,
   "Suggestive mode overlay enabled": true,
   "Use new settings store": false,
 };
@@ -94,6 +95,7 @@ const featureFlags: FeatureFlags = {
 const defaultFeatureFlags: FeatureFlags = {
   "Advanced node search enabled": false,
   "Enable left sidebar": false,
+  "Enable node sharing": false,
   "Suggestive mode overlay enabled": false,
   "Use new settings store": false,
 };
diff --git a/apps/roam/src/components/settings/utils/zodSchema.ts b/apps/roam/src/components/settings/utils/zodSchema.ts
index 7f6e0d592..a9793ba3b 100644
--- a/apps/roam/src/components/settings/utils/zodSchema.ts
+++ b/apps/roam/src/components/settings/utils/zodSchema.ts
@@ -157,6 +157,7 @@ export const DiscourseRelationSchema = z.object({
 export const FeatureFlagsSchema = z.object({
   "Advanced node search enabled": z.boolean().default(false),
   "Enable left sidebar": z.boolean().default(false),
+  "Enable node sharing": z.boolean().default(false),
   "Suggestive mode overlay enabled": z.boolean().default(false),
   "Use new settings store": z.boolean().default(false),
 });
diff --git a/apps/roam/src/index.ts b/apps/roam/src/index.ts
index 8149fb188..6333a4465 100644
--- a/apps/roam/src/index.ts
+++ b/apps/roam/src/index.ts
@@ -37,6 +37,7 @@ import { initPostHog } from "./utils/posthog";
 import { initSchema } from "./components/settings/utils/init";
 import {
   bulkReadSettings,
+  isNodeSharingEnabled,
   isSyncEnabled,
 } from "./components/settings/utils/accessors";
 import { PERSONAL_KEYS } from "./components/settings/utils/settingKeys";
@@ -134,7 +135,7 @@ export default runExtension(async (onloadArgs) => {
   document.addEventListener("input", discourseNodeSearchTriggerListener);
   document.addEventListener("selectionchange", nodeCreationPopoverListener);
 
-  if (isSyncEnabled()) {
+  if (isSyncEnabled() || isNodeSharingEnabled()) {
     initializeSupabaseSync();
   }
 
diff --git a/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts b/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts
index aa52bf039..425404fc8 100644
--- a/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts
+++ b/apps/roam/src/utils/__tests__/materializeSharedNode.test.ts
@@ -269,6 +269,32 @@ describe("materializeSharedNode", () => {
     expect(mockedWriteImportedSourceIdentity).not.toHaveBeenCalled();
   });
 
+  it("force-updates an imported page whose source has not changed", async () => {
+    const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
+    mockedFindImportedNodeUidBySourceRid.mockResolvedValue(EXISTING_PAGE_UID);
+    mockedGetPageTitleByPageUid.mockReturnValue(sharedNode.title);
+    mockedReadImportedSourceIdentity.mockReturnValue({
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+
+    await expect(
+      materializeSharedNode({ client, sharedNode, force: true }),
+    ).resolves.toEqual({
+      success: true,
+      action: "updated",
+      pageUid: EXISTING_PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+    expect(blockFromMarkdown).toHaveBeenCalled();
+    expect(mockedWriteImportedSourceIdentity).toHaveBeenCalledWith({
+      pageUid: EXISTING_PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+  });
+
   it("updates an imported page whose source changed since the import", async () => {
     const { client } = clientWithFullContent({ text: FULL_MARKDOWN });
     mockedFindImportedNodeUidBySourceRid.mockResolvedValue(EXISTING_PAGE_UID);
diff --git a/apps/roam/src/utils/__tests__/nodeSharingFeatureFlag.test.ts b/apps/roam/src/utils/__tests__/nodeSharingFeatureFlag.test.ts
new file mode 100644
index 000000000..5aefa2f0f
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/nodeSharingFeatureFlag.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("~/utils/internalError", () => ({ default: vi.fn() }));
+vi.mock("~/utils/extensionSettings", () => ({ getSetting: vi.fn() }));
+vi.mock("~/utils/parseQuery", () => ({ roamNodeToCondition: vi.fn() }));
+
+import {
+  isNodeSharingEnabled,
+  isSyncEnabled,
+} from "~/components/settings/utils/accessors";
+
+const seedWindow = (featureFlags: Record<string, boolean>) => {
+  (globalThis as { window: unknown }).window = {
+    roamAlphaAPI: {
+      user: { uid: () => "user-1" },
+      pull: () => ({
+        ":block/children": [
+          {
+            ":block/string": "Feature Flags",
+            ":block/props": {
+              "Use new settings store": true,
+              ...featureFlags,
+            },
+          },
+        ],
+      }),
+    },
+  };
+};
+
+describe("node sharing feature flag", () => {
+  it("defaults to disabled alongside suggestive mode", () => {
+    seedWindow({});
+    expect(isNodeSharingEnabled()).toBe(false);
+    expect(isSyncEnabled()).toBe(false);
+  });
+
+  it("enables node sharing without suggestive mode", () => {
+    seedWindow({ "Enable node sharing": true });
+    expect(isNodeSharingEnabled()).toBe(true);
+    expect(isSyncEnabled()).toBe(false);
+  });
+
+  it("does not enable node sharing when only suggestive mode is on", () => {
+    seedWindow({ "Suggestive mode overlay enabled": true });
+    expect(isNodeSharingEnabled()).toBe(false);
+    expect(isSyncEnabled()).toBe(true);
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/publishNodesToGroups.test.ts b/apps/roam/src/utils/__tests__/publishNodesToGroups.test.ts
new file mode 100644
index 000000000..46dae6534
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/publishNodesToGroups.test.ts
@@ -0,0 +1,316 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { CrossAppNode } from "@repo/database/crossAppContracts";
+import type { DGSupabaseClient } from "@repo/database/lib/client";
+import type { DiscourseNode } from "~/utils/getDiscourseNodes";
+import { contentTypes } from "@repo/content-model";
+
+const mocks = vi.hoisted(() => ({
+  getDiscourseNodes: vi.fn(),
+  getAvailableGroupIds: vi.fn(),
+  ensurePartialSpaceAccess: vi.fn(),
+  internalError: vi.fn(),
+}));
+
+vi.mock("~/utils/getDiscourseNodes", () => ({
+  default: mocks.getDiscourseNodes,
+}));
+
+vi.mock("~/utils/getDiscourseRelations", () => ({
+  default: () => [],
+}));
+
+vi.mock("~/utils/createReifiedBlock", () => ({
+  getReifiedRelations: () => Promise.resolve([]),
+}));
+
+vi.mock("~/utils/internalError", () => ({
+  default: mocks.internalError,
+}));
+
+vi.mock("~/utils/importedSourceIdentity", () => ({
+  readImportedSourceIdentity: () => undefined,
+}));
+
+vi.mock("~/utils/roamToCrossAppConverters", () => ({
+  nodeUidsWithTypeToCrossApp: vi.fn(),
+  nodeSchemaToCrossApp: (s: DiscourseNode) => ({
+    localId: s.type,
+    label: s.text,
+    authorId: "author-1",
+    createdAt: new Date("2026-01-01T00:00:00.000Z"),
+  }),
+  reifiedRelationToCrossApp: vi.fn(),
+  relationTripleSchemaToCrossApp: vi.fn(),
+}));
+
+vi.mock("@repo/database/lib/groups", () => ({
+  getAvailableGroupIds: mocks.getAvailableGroupIds,
+  ensurePartialSpaceAccess: mocks.ensurePartialSpaceAccess,
+}));
+
+vi.mock("@repo/database/lib/contextFunctions", () => ({
+  isIgnorableUpsertError: (error: { code?: string } | null) =>
+    !error || error.code === "23505",
+}));
+
+import { publishNodesToGroups } from "~/utils/publishNodesToGroups";
+
+const SPACE_ID = 42;
+const GROUP_ID = "group-1";
+const SCHEMA_UID = "schema-1";
+
+const claimSchema: DiscourseNode = {
+  type: SCHEMA_UID,
+  text: "Claim",
+  shortcut: "C",
+  specification: [],
+  backedBy: "user",
+  canvasSettings: {},
+  format: "[[CLM]] - {content}",
+};
+
+const makeCrossAppNode = ({
+  uid,
+  title,
+}: {
+  uid: string;
+  title: string;
+}): CrossAppNode => ({
+  localId: uid,
+  nodeType: SCHEMA_UID,
+  authorId: "user-1",
+  createdAt: new Date("2026-01-02T00:00:00.000Z"),
+  modifiedAt: new Date("2026-01-03T00:00:00.000Z"),
+  content: {
+    direct: { localId: uid, value: title },
+    full: {
+      localId: uid,
+      value: `# ${title}\n\nBody\n`,
+      contentType: contentTypes.roamMarkdown,
+      scale: "document",
+    },
+  },
+});
+
+type RpcArgs = { v_space_id: number; data: Record<string, unknown>[] };
+
+const makeFakeClient = ({
+  syncedUids = [],
+  rpcResponse,
+}: {
+  syncedUids?: string[];
+  rpcResponse?: { data: number[] | null; error: { message: string } | null };
+}) => {
+  const rpcCalls: { fn: string; args: RpcArgs }[] = [];
+  const upsertCalls: {
+    table: string;
+    rows: Record<string, unknown>[];
+    options: Record<string, unknown>;
+  }[] = [];
+  const selectResult = (table: string) =>
+    Promise.resolve({
+      data:
+        table === "my_concepts"
+          ? syncedUids.map((uid) => ({ source_local_id: uid }))
+          : [],
+      error: null,
+    });
+  const client = {
+    from: (table: string) => ({
+      select: () => ({
+        eq: () => ({ in: () => selectResult(table) }),
+        in: () => selectResult(table),
+      }),
+      upsert: (
+        rows: Record<string, unknown>[],
+        options: Record<string, unknown>,
+      ) => {
+        upsertCalls.push({ table, rows, options });
+        return Promise.resolve({ error: null });
+      },
+    }),
+    rpc: (fn: string, args: RpcArgs) => {
+      rpcCalls.push({ fn, args });
+      return Promise.resolve(
+        rpcResponse ?? { data: args.data.map((_, i) => i + 1), error: null },
+      );
+    },
+  } as unknown as DGSupabaseClient;
+  return { client, rpcCalls, upsertCalls };
+};
+
+describe("publishNodesToGroups", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getDiscourseNodes.mockReturnValue([claimSchema]);
+    mocks.getAvailableGroupIds.mockResolvedValue([GROUP_ID]);
+    mocks.ensurePartialSpaceAccess.mockImplementation(
+      ({ groupIds }: { groupIds: string[] }) =>
+        Promise.resolve({
+          existing: Object.fromEntries(groupIds.map((g) => [g, "partial"])),
+          missing: {},
+        }),
+    );
+  });
+
+  it("upserts the schema and the complete node concept before granting access to a new node", async () => {
+    const { client, rpcCalls, upsertCalls } = makeFakeClient({});
+
+    const result = await publishNodesToGroups({
+      client,
+      spaceId: SPACE_ID,
+      groupIds: [GROUP_ID],
+      nodes: [makeCrossAppNode({ uid: "node-1", title: "CLM - new claim" })],
+    });
+
+    expect(rpcCalls).toHaveLength(1);
+    expect(rpcCalls[0].fn).toBe("upsert_concepts");
+    const { v_space_id: rpcSpaceId, data } = rpcCalls[0].args;
+    expect(rpcSpaceId).toBe(SPACE_ID);
+    expect(data).toHaveLength(2);
+    expect(data[0]).toMatchObject({
+      source_local_id: SCHEMA_UID,
+      is_schema: true,
+      name: "Claim",
+    });
+    expect(data[1]).toMatchObject({
+      source_local_id: "node-1",
+      name: "CLM - new claim",
+      schema_represented_by_local_id: SCHEMA_UID,
+    });
+    expect(data[1].contents_inline).toEqual([
+      expect.objectContaining({
+        source_local_id: "node-1",
+        variant: "direct",
+        text: "CLM - new claim",
+      }),
+      expect.objectContaining({
+        source_local_id: "node-1",
+        variant: "full",
+        text: "# CLM - new claim\n\nBody\n",
+        content_type: contentTypes.roamMarkdown,
+      }),
+    ]);
+
+    expect(upsertCalls).toHaveLength(1);
+    expect(upsertCalls[0].table).toBe("ResourceAccess");
+    expect(upsertCalls[0].options).toEqual({ ignoreDuplicates: true });
+    expect(upsertCalls[0].rows).toEqual(
+      expect.arrayContaining([
+        {
+          account_uid: GROUP_ID,
+          source_local_id: "node-1",
+          space_id: SPACE_ID,
+        },
+        {
+          account_uid: GROUP_ID,
+          source_local_id: SCHEMA_UID,
+          space_id: SPACE_ID,
+        },
+      ]),
+    );
+    expect(result.publishedNodeUids).toEqual(["node-1"]);
+    expect(result.publishedNodeSchemaUids).toEqual([SCHEMA_UID]);
+    expect(result.syncedNodeSchemaUids).toEqual([SCHEMA_UID]);
+    expect(result.okGroupIds).toEqual([GROUP_ID]);
+    expect(result.failedUpsertUids).toEqual([]);
+  });
+
+  it("still upserts title and full content when republishing an already-synced node", async () => {
+    const { client, rpcCalls } = makeFakeClient({ syncedUids: [SCHEMA_UID] });
+
+    const result = await publishNodesToGroups({
+      client,
+      spaceId: SPACE_ID,
+      groupIds: [GROUP_ID],
+      nodes: [
+        makeCrossAppNode({ uid: "node-1", title: "CLM - updated title" }),
+      ],
+    });
+
+    const { data } = rpcCalls[0].args;
+    expect(data).toHaveLength(1);
+    expect(data[0]).toMatchObject({ source_local_id: "node-1" });
+    expect(data[0].contents_inline).toEqual([
+      expect.objectContaining({
+        variant: "direct",
+        text: "CLM - updated title",
+      }),
+      expect.objectContaining({
+        variant: "full",
+        text: "# CLM - updated title\n\nBody\n",
+      }),
+    ]);
+    expect(result.syncedNodeSchemaUids).toEqual([]);
+    expect(result.publishedNodeUids).toEqual(["node-1"]);
+    expect(result.okGroupIds).toEqual([GROUP_ID]);
+  });
+
+  it("grants no access at all when the concept upsert request fails", async () => {
+    const { client, upsertCalls } = makeFakeClient({
+      rpcResponse: { data: null, error: { message: "boom" } },
+    });
+
+    const result = await publishNodesToGroups({
+      client,
+      spaceId: SPACE_ID,
+      groupIds: [GROUP_ID],
+      nodes: [makeCrossAppNode({ uid: "node-1", title: "CLM - new claim" })],
+    });
+
+    expect(upsertCalls).toHaveLength(0);
+    expect(result.publishedNodeUids).toEqual([]);
+    expect(result.okGroupIds).toEqual([]);
+  });
+
+  it.each([
+    { code: -1, label: "unique-violation" },
+    { code: -2, label: "generic-error" },
+  ])(
+    "withholds grants for nodes whose upsert failed with $label",
+    async ({ code }) => {
+      const { client, upsertCalls } = makeFakeClient({
+        syncedUids: [SCHEMA_UID],
+        rpcResponse: { data: [7, code], error: null },
+      });
+
+      const result = await publishNodesToGroups({
+        client,
+        spaceId: SPACE_ID,
+        groupIds: [GROUP_ID],
+        nodes: [
+          makeCrossAppNode({ uid: "node-1", title: "CLM - publishes" }),
+          makeCrossAppNode({ uid: "node-2", title: "CLM - fails" }),
+        ],
+      });
+
+      expect(result.failedUpsertUids).toEqual(["node-2"]);
+      expect(result.publishedNodeUids).toEqual(["node-1"]);
+      const grantedIds = upsertCalls[0].rows.map((r) => r.source_local_id);
+      expect(grantedIds).toContain("node-1");
+      expect(grantedIds).toContain(SCHEMA_UID);
+      expect(grantedIds).not.toContain("node-2");
+    },
+  );
+
+  it("withholds dependent nodes when their schema upsert fails", async () => {
+    const { client, upsertCalls } = makeFakeClient({
+      rpcResponse: { data: [-1, 2, 3], error: null },
+    });
+
+    const result = await publishNodesToGroups({
+      client,
+      spaceId: SPACE_ID,
+      groupIds: [GROUP_ID],
+      nodes: [
+        makeCrossAppNode({ uid: "node-1", title: "CLM - first" }),
+        makeCrossAppNode({ uid: "node-2", title: "CLM - second" }),
+      ],
+    });
+
+    expect(result.failedUpsertUids).toEqual([SCHEMA_UID, "node-1", "node-2"]);
+    expect(result.publishedNodeUids).toEqual([]);
+    expect(result.publishedNodeSchemaUids).toEqual([]);
+    expect(upsertCalls[0].rows).toEqual([]);
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts b/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts
new file mode 100644
index 000000000..021e77dea
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/refreshAllImportedNodes.test.ts
@@ -0,0 +1,54 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getImportedNodeUids } from "~/utils/importedSourceIdentity";
+import { refreshAllImportedNodes } from "~/utils/refreshAllImportedNodes";
+import { refreshImportedNode } from "~/utils/refreshImportedNode";
+
+vi.mock("~/utils/importedSourceIdentity", () => ({
+  getImportedNodeUids: vi.fn(),
+}));
+vi.mock("~/utils/refreshImportedNode", () => ({
+  refreshImportedNode: vi.fn(),
+}));
+
+const mockedGetImportedNodeUids = vi.mocked(getImportedNodeUids);
+const mockedRefreshImportedNode = vi.mocked(refreshImportedNode);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("refreshAllImportedNodes", () => {
+  it("refreshes every imported node without forcing and tallies the outcomes", async () => {
+    mockedGetImportedNodeUids.mockResolvedValue(
+      new Set(["uid-1", "uid-2", "uid-3", "uid-4"]),
+    );
+    mockedRefreshImportedNode
+      .mockResolvedValueOnce({ status: "refreshed", message: "Refreshed." })
+      .mockResolvedValueOnce({ status: "skipped", message: "Up to date." })
+      .mockResolvedValueOnce({ status: "failed", message: "Not shared." })
+      .mockResolvedValueOnce({ status: "refreshed", message: "Refreshed." });
+
+    await expect(refreshAllImportedNodes()).resolves.toEqual({
+      refreshed: 2,
+      skipped: 1,
+      failed: 1,
+    });
+    expect(mockedRefreshImportedNode.mock.calls).toEqual([
+      [{ pageUid: "uid-1", force: false }],
+      [{ pageUid: "uid-2", force: false }],
+      [{ pageUid: "uid-3", force: false }],
+      [{ pageUid: "uid-4", force: false }],
+    ]);
+  });
+
+  it("returns zero counts when the graph has no imported nodes", async () => {
+    mockedGetImportedNodeUids.mockResolvedValue(new Set());
+
+    await expect(refreshAllImportedNodes()).resolves.toEqual({
+      refreshed: 0,
+      skipped: 0,
+      failed: 0,
+    });
+    expect(mockedRefreshImportedNode).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts b/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts
new file mode 100644
index 000000000..0ba1b468b
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/refreshImportedNode.test.ts
@@ -0,0 +1,224 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import getPageTitleByPageUid from "roamjs-components/queries/getPageTitleByPageUid";
+import type { DGSupabaseClient } from "@repo/database/lib/client";
+import {
+  getSharedNodeByRid,
+  type SharedNode,
+} from "@repo/database/lib/sharedNodes";
+import { readImportedSourceIdentity } from "~/utils/importedSourceIdentity";
+import internalError from "~/utils/internalError";
+import { materializeSharedNode } from "~/utils/materializeSharedNode";
+import { refreshImportedNode } from "~/utils/refreshImportedNode";
+import { getLoggedInClient } from "~/utils/supabaseContext";
+
+vi.mock("roamjs-components/queries/getPageTitleByPageUid", () => ({
+  default: vi.fn(),
+}));
+vi.mock("@repo/database/lib/sharedNodes", () => ({
+  getSharedNodeByRid: vi.fn(),
+}));
+vi.mock("~/utils/importedSourceIdentity", () => ({
+  findImportedNodeUidBySourceRid: vi.fn(),
+  readImportedSourceIdentity: vi.fn(),
+  writeImportedSourceIdentity: vi.fn(),
+}));
+vi.mock("~/utils/internalError", () => ({ default: vi.fn() }));
+vi.mock("~/utils/materializeSharedNode", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("~/utils/materializeSharedNode")>()),
+  materializeSharedNode: vi.fn(),
+}));
+vi.mock("~/utils/supabaseContext", () => ({
+  getLoggedInClient: vi.fn(),
+}));
+
+const mockedGetPageTitleByPageUid = vi.mocked(getPageTitleByPageUid);
+const mockedGetSharedNodeByRid = vi.mocked(getSharedNodeByRid);
+const mockedReadImportedSourceIdentity = vi.mocked(readImportedSourceIdentity);
+const mockedInternalError = vi.mocked(internalError);
+const mockedMaterializeSharedNode = vi.mocked(materializeSharedNode);
+const mockedGetLoggedInClient = vi.mocked(getLoggedInClient);
+
+const PAGE_UID = "imported-page-uid";
+const LOCAL_TITLE = "EVD - old local title";
+const OTHER_PAGE_TITLE = "EVD - duplicate page";
+
+const client = {} as DGSupabaseClient;
+
+const sharedNode: SharedNode = {
+  rid: "orn:obsidian.note:vault-a/node-1",
+  sourceLocalId: "node-1",
+  spaceId: 20,
+  spaceName: "Research vault",
+  spaceUri: "obsidian:vault-a",
+  platform: "Obsidian",
+  title: "EVD - REM sleep and recall",
+  created: "2026-06-14T12:30:00.000Z",
+  lastModified: "2026-06-14T15:00:00.000Z",
+  authorId: 7,
+  directMetadata: null,
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockedGetPageTitleByPageUid.mockImplementation((uid) =>
+    uid === PAGE_UID ? LOCAL_TITLE : OTHER_PAGE_TITLE,
+  );
+  mockedReadImportedSourceIdentity.mockReturnValue({
+    sourceModifiedAt: "2026-06-14T12:00:00.000Z",
+    sourceNodeRid: sharedNode.rid,
+  });
+  mockedGetLoggedInClient.mockResolvedValue(client);
+  mockedGetSharedNodeByRid.mockResolvedValue(sharedNode);
+  mockedMaterializeSharedNode.mockResolvedValue({
+    success: true,
+    action: "updated",
+    pageUid: PAGE_UID,
+    sourceModifiedAt: sharedNode.lastModified,
+    sourceNodeRid: sharedNode.rid,
+  });
+});
+
+describe("refreshImportedNode", () => {
+  it("refreshes the page from its stored source identity", async () => {
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "refreshed",
+      message: 'Refreshed "EVD - REM sleep and recall" from Research vault.',
+    });
+    expect(mockedGetSharedNodeByRid).toHaveBeenCalledWith({
+      client,
+      rid: sharedNode.rid,
+    });
+    expect(mockedMaterializeSharedNode).toHaveBeenCalledWith({
+      client,
+      sharedNode,
+      force: true,
+    });
+    expect(mockedInternalError).not.toHaveBeenCalled();
+  });
+
+  it("skips an up-to-date import when not forced", async () => {
+    mockedMaterializeSharedNode.mockResolvedValue({
+      success: true,
+      action: "skipped",
+      pageUid: PAGE_UID,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: false }),
+    ).resolves.toEqual({
+      status: "skipped",
+      message: '"EVD - REM sleep and recall" is already up to date.',
+    });
+    expect(mockedMaterializeSharedNode).toHaveBeenCalledWith({
+      client,
+      sharedNode,
+      force: false,
+    });
+    expect(mockedInternalError).not.toHaveBeenCalled();
+  });
+
+  it("fails when the page has no stored source identity", async () => {
+    mockedReadImportedSourceIdentity.mockReturnValue(undefined);
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "failed",
+      message: `"${LOCAL_TITLE}" has no stored source identity, so it cannot be refreshed.`,
+    });
+    expect(mockedGetLoggedInClient).not.toHaveBeenCalled();
+    expect(mockedMaterializeSharedNode).not.toHaveBeenCalled();
+    expect(mockedInternalError).not.toHaveBeenCalled();
+  });
+
+  it("fails when the database client is unavailable", async () => {
+    mockedGetLoggedInClient.mockResolvedValue(null);
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "failed",
+      message: "Could not connect to shared persistence.",
+    });
+    expect(mockedGetSharedNodeByRid).not.toHaveBeenCalled();
+    expect(mockedInternalError).not.toHaveBeenCalled();
+  });
+
+  it("fails when the source node is no longer shared", async () => {
+    mockedGetSharedNodeByRid.mockResolvedValue(null);
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "failed",
+      message: `The source of "${LOCAL_TITLE}" is no longer shared with your groups, so it cannot be refreshed.`,
+    });
+    expect(mockedMaterializeSharedNode).not.toHaveBeenCalled();
+    expect(mockedInternalError).not.toHaveBeenCalled();
+  });
+
+  it("reports the materialization failure message", async () => {
+    mockedMaterializeSharedNode.mockResolvedValue({
+      success: false,
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+      error: {
+        message: 'Failed to replace the content of "EVD - old local title"',
+        stage: "replace-page-content",
+      },
+    });
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "failed",
+      message: 'Failed to replace the content of "EVD - old local title"',
+    });
+    expect(mockedInternalError).toHaveBeenCalledTimes(1);
+    expect(mockedInternalError.mock.calls[0]?.[0]).toMatchObject({
+      type: "Imported node refresh failed",
+      context: {
+        operation: "refresh-imported-node",
+        pageUid: PAGE_UID,
+        stage: "replace-page-content",
+      },
+    });
+  });
+
+  it("fails when a different page linked to the source was refreshed", async () => {
+    mockedMaterializeSharedNode.mockResolvedValue({
+      success: true,
+      action: "updated",
+      pageUid: "other-page-uid",
+      sourceModifiedAt: sharedNode.lastModified,
+      sourceNodeRid: sharedNode.rid,
+    });
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "failed",
+      message: `A different page ("${OTHER_PAGE_TITLE}") is linked to the same source and was refreshed instead.`,
+    });
+  });
+
+  it("reports an unexpected error", async () => {
+    const thrown = new Error("network down");
+    mockedGetSharedNodeByRid.mockRejectedValue(thrown);
+
+    await expect(
+      refreshImportedNode({ pageUid: PAGE_UID, force: true }),
+    ).resolves.toEqual({
+      status: "failed",
+      message: "Could not refresh this page: network down",
+    });
+    expect(mockedInternalError).toHaveBeenCalledTimes(1);
+    const reported = mockedInternalError.mock.calls[0]?.[0];
+    expect(reported?.error).toBe(thrown);
+    expect(reported?.type).toBe("Imported node refresh failed");
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/roamToCrossAppConverters.test.ts b/apps/roam/src/utils/__tests__/roamToCrossAppConverters.test.ts
new file mode 100644
index 000000000..5596eb602
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/roamToCrossAppConverters.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Json } from "@repo/database/dbTypes";
+
+vi.mock("roamjs-components/queries/getFullTreeByParentUid", () => ({
+  default: () => ({ children: [] }),
+}));
+vi.mock("roamjs-components/queries/getPageViewType", () => ({
+  default: () => "bullet",
+}));
+vi.mock("~/utils/pageToMarkdown", () => ({ toMarkdown: () => "" }));
+
+import { nodeUidsWithTypeToCrossApp } from "~/utils/roamToCrossAppConverters";
+
+const USER_ROW = { ":db/id": 5, ":user/uid": "user-1" };
+
+const convertRow = async (row: Record<string, Json>) => {
+  (globalThis as { window: unknown }).window = {
+    roamAlphaAPI: {
+      data: {
+        async: {
+          pull_many: vi
+            .fn()
+            .mockResolvedValueOnce([row])
+            .mockResolvedValueOnce([USER_ROW]),
+        },
+      },
+    },
+  };
+  const [node] = await nodeUidsWithTypeToCrossApp([
+    { uid: "node-1", type: "schema-1" },
+  ]);
+  return node;
+};
+
+const baseRow = {
+  ":block/uid": "node-1",
+  ":node/title": "CLM - claim",
+  ":create/user": { ":db/id": 5 },
+  ":create/time": 1000,
+};
+
+describe("nodeUidsWithTypeToCrossApp timestamps", () => {
+  it("uses the page edit time when present", async () => {
+    const node = await convertRow({
+      ...baseRow,
+      ":edit/time": 2000,
+      ":page/edit-time": 3000,
+    });
+    expect(node.createdAt).toEqual(new Date(1000));
+    expect(node.modifiedAt).toEqual(new Date(3000));
+  });
+
+  it("falls back to the node edit time when page edit time is absent", async () => {
+    const node = await convertRow({ ...baseRow, ":edit/time": 2000 });
+    expect(node.modifiedAt).toEqual(new Date(2000));
+  });
+
+  it("falls back to the create time when no edit time exists", async () => {
+    const node = await convertRow(baseRow);
+    expect(node.modifiedAt).toEqual(new Date(1000));
+  });
+});
diff --git a/apps/roam/src/utils/importedSourceIdentity.ts b/apps/roam/src/utils/importedSourceIdentity.ts
index 64588918a..0b3775f25 100644
--- a/apps/roam/src/utils/importedSourceIdentity.ts
+++ b/apps/roam/src/utils/importedSourceIdentity.ts
@@ -74,6 +74,21 @@ export const getImportedSourceRids = async (): Promise<Set<string>> => {
   );
 };
 
+export const getImportedNodeUids = async (): Promise<Set<string>> => {
+  const query = `[:find [?uid ...]
+    :where
+      [?page :block/uid ?uid]
+      [?page :block/props ?props]
+      [(get ?props :${DISCOURSE_GRAPH_PROP_NAME}) ?dgData]
+      [(get ?dgData :${IMPORTED_FROM_PROP_KEY}) ?importedFrom]
+      [(get ?importedFrom :${SOURCE_NODE_RID_KEY}) ?rid]]`;
+  const result = (await window.roamAlphaAPI.data.async.q(query)) as unknown[];
+
+  return new Set(
+    result.filter((uid): uid is string => typeof uid === "string"),
+  );
+};
+
 export const findImportedNodeUidBySourceRid = async (
   sourceNodeRid: string,
 ): Promise<string | null> => {
diff --git a/apps/roam/src/utils/initializeObserversAndListeners.ts b/apps/roam/src/utils/initializeObserversAndListeners.ts
index c084cf182..6446d69b4 100644
--- a/apps/roam/src/utils/initializeObserversAndListeners.ts
+++ b/apps/roam/src/utils/initializeObserversAndListeners.ts
@@ -47,6 +47,8 @@ import { mountLeftSidebar } from "~/components/LeftSidebarView";
 import { getCleanTagText } from "~/components/settings/NodeConfig";
 import { getNodeTagStyles } from "~/utils/getDiscourseNodeColors";
 import { renderPublishNodeTitleButton } from "~/components/PublishNodeTitleButton";
+import { renderRefreshImportedNodeTitleButton } from "~/components/RefreshImportedNodeTitleButton";
+import { readImportedSourceIdentity } from "~/utils/importedSourceIdentity";
 import { renderCanvasEmbed } from "~/components/canvas/CanvasEmbed";
 import getPageUidByPageTitle from "roamjs-components/queries/getPageUidByPageTitle";
 import getPageTitleByPageUid from "roamjs-components/queries/getPageTitleByPageUid";
@@ -120,11 +122,14 @@ export const initObservers = ({
         snapshot: settings,
       });
 
+      const sharingEnabled =
+        settings.featureFlags[FEATURE_FLAG_KEYS.enableNodeSharing];
+      if (sharingEnabled && uid && readImportedSourceIdentity(uid)) {
+        renderRefreshImportedNodeTitleButton({ h1, uid });
+      }
       const isDiscourseNode = node && node.backedBy !== "default";
       if (isDiscourseNode) {
-        const syncEnabled =
-          settings.featureFlags[FEATURE_FLAG_KEYS.suggestiveModeOverlayEnabled];
-        if (syncEnabled && node.backedBy === "user") {
+        if (sharingEnabled && node.backedBy === "user") {
           renderPublishNodeTitleButton({
             h1,
             uid,
diff --git a/apps/roam/src/utils/materializeSharedNode.ts b/apps/roam/src/utils/materializeSharedNode.ts
index 6e36569e6..599aed4a3 100644
--- a/apps/roam/src/utils/materializeSharedNode.ts
+++ b/apps/roam/src/utils/materializeSharedNode.ts
@@ -292,9 +292,11 @@ const updateImportedPage = async ({
 export const materializeSharedNode = async ({
   client,
   sharedNode,
+  force = false,
 }: {
   client: DGSupabaseClient;
   sharedNode: SharedNode;
+  force?: boolean;
 }): Promise<MaterializeSharedNodeResult> => {
   const rawIdentity: SourceIdentity = {
     sourceModifiedAt: sharedNode.lastModified,
@@ -331,6 +333,7 @@ export const materializeSharedNode = async ({
   }
 
   if (
+    !force &&
     importedPageUid &&
     storedIdentity &&
     isImportUpToDate({
diff --git a/apps/roam/src/utils/publishNodesToGroups.ts b/apps/roam/src/utils/publishNodesToGroups.ts
index b6c27bfb5..8b60547ce 100644
--- a/apps/roam/src/utils/publishNodesToGroups.ts
+++ b/apps/roam/src/utils/publishNodesToGroups.ts
@@ -15,6 +15,7 @@ import getDiscourseRelations from "./getDiscourseRelations";
 import { getReifiedRelations } from "./createReifiedBlock";
 import {
   crossAppNodeSchemaToDbConcept,
+  crossAppNodeToDbConcept,
   crossAppRelationToDbConcept,
   crossAppRelationTripleSchemaToDbConcept,
 } from "@repo/database/lib/crossAppConverters";
@@ -206,20 +207,20 @@ type PublishNodesResult = {
   syncedNodeSchemaUids: string[];
   syncedRelationTripleSchemaUids: string[];
   syncedRelationUids: string[];
-  failedSyncedUids: string[];
-  skippedUnsyncedUids: string[];
+  failedUpsertUids: string[];
   okGroupIds: string[];
   failedGroupIds: string[];
 };
 
-// Grants a group access to already-synced discourse nodes by mirroring the
-// Obsidian publish-to-group access model (SpaceAccess + ResourceAccess),
-// without its file/frontmatter/relation/asset coupling.
+// Grants a group access to discourse nodes by mirroring the Obsidian
+// publish-to-group access model (SpaceAccess + ResourceAccess), without its
+// file/frontmatter/asset coupling.
 //
-// ResourceAccess has no foreign key on source_local_id, so granting access to a
-// node that has not synced yet would create an orphaned row. We therefore only
-// publish nodes confirmed present as instance concepts in this space, and
-// report the rest as not-yet-synced (they self-heal on the next sync).
+// ResourceAccess has no foreign key on source_local_id, so granting access to
+// a node absent from this space would create an orphaned row. We therefore
+// upsert every selected node as a complete concept (direct title + full
+// content) before granting access, and withhold grants for anything whose
+// upsert failed.
 export const publishNodesToGroups = async ({
   client,
   spaceId,
@@ -239,8 +240,7 @@ export const publishNodesToGroups = async ({
     syncedNodeSchemaUids: [],
     syncedRelationUids: [],
     syncedRelationTripleSchemaUids: [],
-    failedSyncedUids: [],
-    skippedUnsyncedUids: [],
+    failedUpsertUids: [],
     okGroupIds: [],
     failedGroupIds: [],
   };
@@ -267,7 +267,8 @@ export const publishNodesToGroups = async ({
   }
   if (groupIds.length === 0) return result;
 
-  let nodeUids = [...new Set(nodes.map((node) => node.localId))];
+  const nodesByUid = new Map(nodes.map((node) => [node.localId, node]));
+  let nodeUids = [...nodesByUid.keys()];
   const nodeSchemaUids = new Set(nodes.map((node) => node.nodeType));
   const nodeSchemas = getDiscourseNodes()
     .filter((s) => nodeSchemaUids.has(s.type))
@@ -286,7 +287,6 @@ export const publishNodesToGroups = async ({
 
   const neededUids = [
     ...nodeSchemaUids,
-    ...nodeUids,
     ...relationTripleSchemaUids,
     ...relationUids,
   ];
@@ -303,32 +303,24 @@ export const publishNodesToGroups = async ({
   const syncedUids = new Set(
     onlyStrings((syncedRes.data ?? []).map((row) => row.source_local_id)),
   );
-  result.skippedUnsyncedUids = nodeUids.filter((uid) => !syncedUids.has(uid));
-  nodeUids = [...intersection(syncedUids, new Set(nodeUids))];
   const missingNodeSchemas = nodeSchemas.filter(
     (s) => !syncedUids.has(s.localId),
   );
   const missingRelationTripleSchemas = relationTripleSchemas.filter(
     (s) => !syncedUids.has(s.localId),
   );
-  const missingNodeUids = new Set(nodeUids.filter((id) => !syncedUids.has(id)));
-  const relationsWithSyncedNodes = relations.filter(
-    (r) =>
-      !missingNodeUids.has(r.source) && !missingNodeUids.has(r.destination),
-  );
-  const missingRelations = relationsWithSyncedNodes.filter(
-    (r) => !syncedUids.has(r.localId),
-  );
+  const missingRelations = relations.filter((r) => !syncedUids.has(r.localId));
 
-  result.skippedUnsyncedUids = nodeUids.filter((uid) => !syncedUids.has(uid));
   const upsertConcepts = [
     ...missingNodeSchemas.map((s) => crossAppNodeSchemaToDbConcept(s)),
+    ...[...nodesByUid.values()].map((node) => crossAppNodeToDbConcept(node)),
     ...missingRelationTripleSchemas.map((rs3) =>
       crossAppRelationTripleSchemaToDbConcept(rs3),
     ),
     ...missingRelations.map((r) => crossAppRelationToDbConcept(r)),
   ].filter((r) => r !== undefined);
 
+  const upsertedNodeUids = new Set(nodeUids);
   const syncedRelationUids = new Set(missingRelations.map((s) => s.localId));
   const syncedRelationTripleSchemaUids = new Set(
     missingRelationTripleSchemas.map((s) => s.localId),
@@ -337,50 +329,64 @@ export const publishNodesToGroups = async ({
     missingNodeSchemas.map((s) => s.localId),
   );
 
-  if (upsertConcepts.length > 0) {
-    const response = await client.rpc("upsert_concepts", {
-      v_space_id: spaceId,
-      data: upsertConcepts,
-    });
-    if (response.error) {
-      internalError({ error: response.error });
-      return result;
-    }
+  const response = await client.rpc("upsert_concepts", {
+    v_space_id: spaceId,
+    data: upsertConcepts,
+  });
+  if (response.error) {
+    internalError({ error: response.error });
+    return result;
+  }
 
-    response.data.forEach((v, i) => {
-      if (v === -1) {
-        const localId = upsertConcepts[i].source_local_id;
-        if (localId) {
-          if (syncedNodeSchemaUids.has(localId)) {
-            syncedNodeSchemaUids.delete(localId);
-            nodeSchemaUids.delete(localId);
-          } else if (syncedRelationTripleSchemaUids.has(localId)) {
-            syncedRelationTripleSchemaUids.delete(localId);
-          } else if (syncedRelationUids.has(localId)) {
-            syncedRelationUids.delete(localId);
-          }
-          result.failedSyncedUids.push(localId);
+  response.data.forEach((v, i) => {
+    if (v < 0) {
+      const localId = upsertConcepts[i].source_local_id;
+      if (localId) {
+        if (syncedNodeSchemaUids.has(localId)) {
+          syncedNodeSchemaUids.delete(localId);
+          nodeSchemaUids.delete(localId);
+        } else if (upsertedNodeUids.has(localId)) {
+          upsertedNodeUids.delete(localId);
+        } else if (syncedRelationTripleSchemaUids.has(localId)) {
+          syncedRelationTripleSchemaUids.delete(localId);
+        } else if (syncedRelationUids.has(localId)) {
+          syncedRelationUids.delete(localId);
         }
+        result.failedUpsertUids.push(localId);
       }
-    });
-    result.syncedNodeSchemaUids = [...syncedNodeSchemaUids];
-    result.syncedRelationTripleSchemaUids = [...syncedRelationTripleSchemaUids];
-    result.syncedRelationUids = [...syncedRelationUids];
+    }
+  });
+  for (const node of nodesByUid.values()) {
+    if (
+      !nodeSchemaUids.has(node.nodeType) &&
+      upsertedNodeUids.has(node.localId)
+    ) {
+      upsertedNodeUids.delete(node.localId);
+      result.failedUpsertUids.push(node.localId);
+    }
   }
-  const failedSyncIds = new Set(result.failedSyncedUids);
+  result.syncedNodeSchemaUids = [...syncedNodeSchemaUids];
+  result.syncedRelationTripleSchemaUids = [...syncedRelationTripleSchemaUids];
+  result.syncedRelationUids = [...syncedRelationUids];
+  nodeUids = [...upsertedNodeUids];
+  const failedUpsertIds = new Set(result.failedUpsertUids);
 
   const resourceAccesses = [];
   const resourceIds = [...nodeUids, ...nodeSchemaUids];
   for (const groupId of groupIds) {
     let groupRelationIds = new Set(relevantRelationIdsPerGroupId[groupId]);
-    const groupRelations = relationsWithSyncedNodes.filter(
-      (r) => groupRelationIds.has(r.localId) && !failedSyncIds.has(r.localId),
+    const groupRelations = relations.filter(
+      (r) =>
+        groupRelationIds.has(r.localId) &&
+        !failedUpsertIds.has(r.localId) &&
+        !failedUpsertIds.has(r.source) &&
+        !failedUpsertIds.has(r.destination),
     );
     groupRelationIds = new Set(groupRelations.map((r) => r.localId));
     const groupRelationTripleSchemaIds = new Set(
       groupRelations
         .map((r) => r.relationType)
-        .filter((r) => !failedSyncIds.has(r)),
+        .filter((r) => !failedUpsertIds.has(r)),
     );
     const groupResourceIds = [
       ...resourceIds,
diff --git a/apps/roam/src/utils/refreshAllImportedNodes.ts b/apps/roam/src/utils/refreshAllImportedNodes.ts
new file mode 100644
index 000000000..5fbe8e990
--- /dev/null
+++ b/apps/roam/src/utils/refreshAllImportedNodes.ts
@@ -0,0 +1,23 @@
+import { getImportedNodeUids } from "./importedSourceIdentity";
+import { refreshImportedNode } from "./refreshImportedNode";
+
+type RefreshAllImportedNodesResult = {
+  refreshed: number;
+  skipped: number;
+  failed: number;
+};
+
+export const refreshAllImportedNodes =
+  async (): Promise<RefreshAllImportedNodesResult> => {
+    const pageUids = await getImportedNodeUids();
+    const counts: RefreshAllImportedNodesResult = {
+      refreshed: 0,
+      skipped: 0,
+      failed: 0,
+    };
+    for (const pageUid of pageUids) {
+      const result = await refreshImportedNode({ pageUid, force: false });
+      counts[result.status] += 1;
+    }
+    return counts;
+  };
diff --git a/apps/roam/src/utils/refreshImportedNode.ts b/apps/roam/src/utils/refreshImportedNode.ts
new file mode 100644
index 000000000..f355eb383
--- /dev/null
+++ b/apps/roam/src/utils/refreshImportedNode.ts
@@ -0,0 +1,96 @@
+import { getSharedNodeByRid } from "@repo/database/lib/sharedNodes";
+import getPageTitleByPageUid from "roamjs-components/queries/getPageTitleByPageUid";
+import { readImportedSourceIdentity } from "./importedSourceIdentity";
+import internalError from "./internalError";
+import {
+  getErrorMessage,
+  materializeSharedNode,
+} from "./materializeSharedNode";
+import { getLoggedInClient } from "./supabaseContext";
+
+export const REFRESH_ERROR_TYPE = "Imported node refresh failed";
+const REFRESH_ERROR_OPERATION = "refresh-imported-node";
+
+type RefreshImportedNodeResult = {
+  status: "refreshed" | "skipped" | "failed";
+  message: string;
+};
+
+export const refreshImportedNode = async ({
+  pageUid,
+  force,
+}: {
+  pageUid: string;
+  force: boolean;
+}): Promise<RefreshImportedNodeResult> => {
+  try {
+    const title = getPageTitleByPageUid(pageUid);
+    const identity = readImportedSourceIdentity(pageUid);
+    if (!identity)
+      return {
+        status: "failed",
+        message: `"${title}" has no stored source identity, so it cannot be refreshed.`,
+      };
+
+    const client = await getLoggedInClient();
+    if (!client)
+      return {
+        status: "failed",
+        message: "Could not connect to shared persistence.",
+      };
+
+    const sharedNode = await getSharedNodeByRid({
+      client,
+      rid: identity.sourceNodeRid,
+    });
+    if (!sharedNode)
+      return {
+        status: "failed",
+        message: `The source of "${title}" is no longer shared with your groups, so it cannot be refreshed.`,
+      };
+
+    const result = await materializeSharedNode({
+      client,
+      sharedNode,
+      force,
+    });
+    if (!result.success) {
+      internalError({
+        error: new Error(result.error.message),
+        type: REFRESH_ERROR_TYPE,
+        context: {
+          operation: REFRESH_ERROR_OPERATION,
+          pageUid,
+          stage: result.error.stage,
+        },
+        sendEmail: false,
+      });
+      return { status: "failed", message: result.error.message };
+    }
+    if (result.pageUid !== pageUid)
+      return {
+        status: "failed",
+        message: `A different page ("${getPageTitleByPageUid(result.pageUid)}") is linked to the same source and was refreshed instead.`,
+      };
+    if (result.action === "skipped")
+      return {
+        status: "skipped",
+        message: `"${sharedNode.title}" is already up to date.`,
+      };
+    return {
+      status: "refreshed",
+      message: `Refreshed "${sharedNode.title}" from ${sharedNode.spaceName}.`,
+    };
+  } catch (error) {
+    internalError({
+      error,
+      type: REFRESH_ERROR_TYPE,
+      context: { operation: REFRESH_ERROR_OPERATION, pageUid },
+      sendEmail: false,
+    });
+    return {
+      status: "failed",
+      message: `Could not refresh this page: ${getErrorMessage(error)}`,
+    };
+  }
+};
diff --git a/apps/roam/src/utils/registerCommandPaletteCommands.ts b/apps/roam/src/utils/registerCommandPaletteCommands.ts
index 11d55ba38..d8579fe9c 100644
--- a/apps/roam/src/utils/registerCommandPaletteCommands.ts
+++ b/apps/roam/src/utils/registerCommandPaletteCommands.ts
@@ -31,6 +31,7 @@ import {
   setPersonalSetting,
   setGlobalSetting,
   isSyncEnabled,
+  isNodeSharingEnabled,
 } from "~/components/settings/utils/accessors";
 import {
   DISCOURSE_NODE_KEYS,
@@ -54,6 +55,11 @@ import {
   insertPageRefAtRange,
 } from "./advancedSearchFooterUtils";
 import { renderDiscoverSharedNodesDialog } from "~/components/DiscoverSharedNodesDialog";
+import { refreshAllImportedNodes } from "~/utils/refreshAllImportedNodes";
+import { REFRESH_ERROR_TYPE } from "~/utils/refreshImportedNode";
+import internalError from "~/utils/internalError";
+
+const REFRESH_ALL_TOAST_ID = "refresh-imported-nodes";
 
 export const createDiscourseNodeFromCommand = (
   extensionAPI: OnloadArgs["extensionAPI"],
@@ -248,10 +254,10 @@ export const registerCommandPaletteCommands = (onloadArgs: OnloadArgs) => {
   };
 
   const shareCurrentNode = () => {
-    if (!isSyncEnabled()) {
+    if (!isNodeSharingEnabled()) {
       renderToast({
-        id: "share-node-sync-disabled",
-        content: "Sync must be enabled to publish discourse nodes.",
+        id: "share-node-sharing-disabled",
+        content: "Node sharing must be enabled to publish discourse nodes.",
       });
       return;
     }
@@ -347,6 +353,50 @@ export const registerCommandPaletteCommands = (onloadArgs: OnloadArgs) => {
     renderDiscoverSharedNodesDialog({});
   };
 
+  const refreshAllImportedNodesFromCommand = async () => {
+    if (!isNodeSharingEnabled()) {
+      renderToast({
+        id: "refresh-imported-nodes-sharing-disabled",
+        content: "Node sharing must be enabled to refresh imported nodes.",
+      });
+      return;
+    }
+
+    posthog.capture("Refresh Imported Node: Refresh All Command Triggered");
+    renderToast({
+      id: REFRESH_ALL_TOAST_ID,
+      content: "Refreshing imported nodes…",
+      timeout: 0,
+    });
+    try {
+      const { refreshed, skipped, failed } = await refreshAllImportedNodes();
+      if (refreshed + skipped + failed === 0) {
+        renderToast({
+          id: REFRESH_ALL_TOAST_ID,
+          content: "No imported nodes to refresh.",
+        });
+        return;
+      }
+      renderToast({
+        id: REFRESH_ALL_TOAST_ID,
+        intent: failed > 0 ? "warning" : "success",
+        content: `${refreshed} refreshed, ${skipped} skipped, ${failed} failed.`,
+      });
+    } catch (error) {
+      internalError({
+        error,
+        type: REFRESH_ERROR_TYPE,
+        context: { operation: "refresh-all-imported-nodes" },
+        sendEmail: false,
+      });
+      renderToast({
+        id: REFRESH_ALL_TOAST_ID,
+        intent: "danger",
+        content: "Could not refresh imported nodes.",
+      });
+    }
+  };
+
   const toggleDiscourseContextOverlay = async () => {
     const currentValue = getPersonalSetting<boolean>([
       PERSONAL_KEYS.discourseContextOverlay,
@@ -422,6 +472,12 @@ export const registerCommandPaletteCommands = (onloadArgs: OnloadArgs) => {
   void addCommand("DG: Open - Discourse settings", renderSettingsPopup);
   if (isSyncEnabled()) {
     void addCommand("DG: Discover shared nodes", discoverSharedNodes);
+  }
+  if (isNodeSharingEnabled()) {
+    void addCommand(
+      "DG: Refresh all imported nodes",
+      () => void refreshAllImportedNodesFromCommand(),
+    );
     void addCommand("DG: Share current node", shareCurrentNode);
   }
   if (getFeatureFlag("Advanced node search enabled")) {
diff --git a/apps/roam/src/utils/roamToCrossAppConverters.ts b/apps/roam/src/utils/roamToCrossAppConverters.ts
index acfa75b05..a3c33f399 100644
--- a/apps/roam/src/utils/roamToCrossAppConverters.ts
+++ b/apps/roam/src/utils/roamToCrossAppConverters.ts
@@ -45,13 +45,27 @@ export const buildFullMarkdown = ({
   return body ? `# ${title}\n\n${body}\n` : `# ${title}\n`;
 };
 
+const buildFullInlineContent = ({
+  uid,
+  title,
+}: {
+  uid: string;
+  title: string;
+}): NonNullable<CrossAppNode["content"]["full"]> => {
+  const blocks = getFullTreeByParentUid(uid).children;
+  const viewType = getPageViewType(title) || "bullet";
+  return {
+    localId: uid,
+    value: buildFullMarkdown({ title, blocks, viewType }),
+    contentType: contentTypes.roamMarkdown,
+    scale: "document",
+  };
+};
+
 export const fullContentNodeToCrossApp = (
   node: RoamFullContentNode,
 ): CrossAppNode => {
   const title = node.node_title ?? node.text;
-  const blocks = getFullTreeByParentUid(node.source_local_id).children;
-  const viewType = getPageViewType(title) || "bullet";
-  const fullText = buildFullMarkdown({ title, blocks, viewType });
 
   return {
     authorId: node.author_local_id,
@@ -62,14 +76,9 @@ export const fullContentNodeToCrossApp = (
     content: {
       direct: {
         localId: node.source_local_id,
-        value: node.node_title ?? node.text,
-      },
-      full: {
-        localId: node.source_local_id,
-        value: fullText,
-        contentType: contentTypes.roamMarkdown,
-        scale: "document",
+        value: title,
       },
+      full: buildFullInlineContent({ uid: node.source_local_id, title }),
     },
   };
 };
@@ -99,25 +108,26 @@ export const nodeUidsWithTypeToCrossApp = async (
   );
   const results = nodeRows.map((row) => {
     const uid = row[":block/uid"] as string;
+    const title = row[":node/title"] as string;
     const userUid =
       userUidByEid[(row[":create/user"] as Record<string, number>)[":db/id"]];
+    const createdTime = row[":create/time"] as number;
+    const editTime = (row[":edit/time"] as number | undefined) ?? createdTime;
+    const pageEditTime =
+      (row[":page/edit-time"] as number | undefined) ?? editTime;
 
     return {
       localId: uid,
       nodeType: typesByUid[uid],
       authorId: userUid,
-      createdAt: new Date((row[":create/time"] as number) || Date.now()),
-      modifiedAt: new Date(
-        Math.max(
-          row[":edit/time"] as number,
-          row[":page/edit-time"] as number,
-        ) || Date.now(),
-      ),
+      createdAt: new Date(createdTime),
+      modifiedAt: new Date(Math.max(editTime, pageEditTime)),
       content: {
         direct: {
           localId: uid,
-          value: row[":node/title"] as string,
+          value: title,
         },
+        full: buildFullInlineContent({ uid, title }),
       },
     };
   });
diff --git a/apps/roam/src/utils/syncDgNodesToSupabase.ts b/apps/roam/src/utils/syncDgNodesToSupabase.ts
index 85d6c12e0..194599002 100644
--- a/apps/roam/src/utils/syncDgNodesToSupabase.ts
+++ b/apps/roam/src/utils/syncDgNodesToSupabase.ts
@@ -4,6 +4,7 @@ import {
   nodeTypeSince,
 } from "./getAllDiscourseNodesSince";
 import getDiscourseNodeFormatExpression from "./getDiscourseNodeFormatExpression";
+import { getImportedNodeUids } from "./importedSourceIdentity";
 import { cleanupOrphanedNodes } from "./cleanupOrphanedNodes";
 import {
   getLoggedInClient,
@@ -28,6 +29,7 @@ import { intersection } from "@repo/utils/setOperations";
 import type { Json, Enums } from "@repo/database/dbTypes";
 import { render as renderToast } from "roamjs-components/components/Toast";
 import internalError from "~/utils/internalError";
+import { isSyncEnabled } from "~/components/settings/utils/accessors";
 import { FatalError } from "@repo/database/lib/contextFunctions";
 import { getAllPages } from "@repo/database/lib/pagination";
 import type {
@@ -38,6 +40,7 @@ import type {
 import type { Properties } from "posthog-js";
 
 const SYNC_FUNCTION = "embedding";
+const SHARED_CONTENT_SYNC_FUNCTION = "shared-content";
 // Minimal interval between syncs of all clients for this task.
 const SYNC_INTERVAL = "130s";
 // Interval between syncs for each client individually
@@ -191,6 +194,7 @@ const syncTelemetryContext = ({
   attemptId,
   worker,
   userUid,
+  syncFunction,
   context,
   startTime,
   claimed,
@@ -204,6 +208,7 @@ const syncTelemetryContext = ({
   attemptId: string;
   worker: string;
   userUid: string;
+  syncFunction: string;
   context: SupabaseContext | null;
   startTime: Date;
   claimed: boolean;
@@ -225,7 +230,7 @@ const syncTelemetryContext = ({
   return {
     syncAttemptId: attemptId,
     syncWorkerId: worker,
-    syncFunction: SYNC_FUNCTION,
+    syncFunction,
     syncUserUid: userUid,
     claimed,
     status,
@@ -321,7 +326,6 @@ const notifyEndSyncFailure = ({
     error,
     type: "Sync Failed",
     context: {
-      syncFunction: SYNC_FUNCTION,
       status,
       reason,
       ...(context || {}),
@@ -333,6 +337,7 @@ const notifyEndSyncFailure = ({
 
 export const endSyncTask = async ({
   worker,
+  syncFunction,
   status,
   showToast = false,
   taskStartedAt,
@@ -341,6 +346,7 @@ export const endSyncTask = async ({
   telemetryContext,
 }: {
   worker: string;
+  syncFunction: string;
   status: Enums<"task_status">;
   showToast: boolean;
   taskStartedAt: Date;
@@ -352,7 +358,7 @@ export const endSyncTask = async ({
     resolvedContext?: SupabaseContext,
   ): Properties => ({
     syncWorkerId: worker,
-    syncFunction: SYNC_FUNCTION,
+    syncFunction,
     spaceId: resolvedContext?.spaceId ?? context?.spaceId,
     ...(telemetryContext || {}),
   });
@@ -383,7 +389,7 @@ export const endSyncTask = async ({
     }
     const { data, error } = await resolvedClient.rpc("end_sync_task", {
       s_target: resolvedContext.spaceId,
-      s_function: SYNC_FUNCTION,
+      s_function: syncFunction,
       s_worker: worker,
       s_status: status,
       s_started_at: taskStartedAt.toISOString(),
@@ -501,16 +507,22 @@ export const endSyncTask = async ({
   }
 };
 
-export const proposeSyncTask = async (
-  worker: string,
-  supabaseClient: DGSupabaseClient,
-  context: SupabaseContext,
-): Promise<SyncTaskInfo> => {
+export const proposeSyncTask = async ({
+  worker,
+  syncFunction,
+  supabaseClient,
+  context,
+}: {
+  worker: string;
+  syncFunction: string;
+  supabaseClient: DGSupabaseClient;
+  context: SupabaseContext;
+}): Promise<SyncTaskInfo> => {
   try {
     const now = new Date();
     const { data, error } = await supabaseClient.rpc("propose_sync_task", {
       s_target: context.spaceId,
-      s_function: SYNC_FUNCTION,
+      s_function: syncFunction,
       s_worker: worker,
       task_interval: SYNC_INTERVAL,
       timeout: SYNC_TIMEOUT,
@@ -759,6 +771,18 @@ export const upsertNodesToSupabaseAsContentWithEmbeddings = async (
   });
 };
 
+const upsertNodesToSupabaseAsContent = async (
+  roamNodes: RoamDiscourseNodeData[],
+  supabaseClient: DGSupabaseClient,
+  context: SupabaseContext,
+): Promise<void> => {
+  if (roamNodes.length === 0) {
+    return;
+  }
+  const content = convertRoamNodeToLocalContent({ nodes: roamNodes });
+  await uploadContentBatches({ content, supabaseClient, context });
+};
+
 const upsertRoamNodesToSupabaseAsFullContent = async ({
   nodes,
   supabaseClient,
@@ -1064,6 +1088,10 @@ export const createOrUpdateDiscourseEmbedding = async (
   let failureReason: string | undefined;
   let failureContext: Properties | undefined;
   const worker = getSyncWorkerId();
+  const sharedNodesOnlySync = !isSyncEnabled();
+  const syncFunction = sharedNodesOnlySync
+    ? SHARED_CONTENT_SYNC_FUNCTION
+    : SYNC_FUNCTION;
 
   const buildTelemetry = ({
     status,
@@ -1082,6 +1110,7 @@ export const createOrUpdateDiscourseEmbedding = async (
       attemptId,
       worker,
       userUid,
+      syncFunction,
       context,
       startTime,
       claimed,
@@ -1125,7 +1154,12 @@ export const createOrUpdateDiscourseEmbedding = async (
         phase: "proposeSyncTask",
         phases,
         operation: () =>
-          proposeSyncTask(worker, activeSupabaseClient, activeContext),
+          proposeSyncTask({
+            worker,
+            syncFunction,
+            supabaseClient: activeSupabaseClient,
+            context: activeContext,
+          }),
       });
     if (!shouldProceed) {
       if (nextUpdateTime === undefined) {
@@ -1193,6 +1227,19 @@ export const createOrUpdateDiscourseEmbedding = async (
           spaceId: activeContext.spaceId,
         }),
     });
+    const importedNodeUids = await measureSyncPhase({
+      phase: "getImportedNodeUids",
+      phases,
+      operation: () => getImportedNodeUids(),
+    });
+    const localNodeInstances = changedNodeInstances.filter(
+      (node) => !importedNodeUids.has(node.source_local_id),
+    );
+    const nodeInstancesToSync = sharedNodesOnlySync
+      ? localNodeInstances.filter((node) =>
+          sharedSourceLocalIds.has(node.source_local_id),
+        )
+      : localNodeInstances;
     const sharedSourceLocalIdsToBackfill = await measureSyncPhase({
       phase: "getSharedSourceLocalIdsMissingFullContent",
       phases,
@@ -1244,11 +1291,17 @@ export const createOrUpdateDiscourseEmbedding = async (
       phase: "upsertNodes",
       phases,
       operation: () =>
-        upsertNodesToSupabaseAsContentWithEmbeddings(
-          changedNodeInstances,
-          activeSupabaseClient,
-          activeContext,
-        ),
+        sharedNodesOnlySync
+          ? upsertNodesToSupabaseAsContent(
+              nodeInstancesToSync,
+              activeSupabaseClient,
+              activeContext,
+            )
+          : upsertNodesToSupabaseAsContentWithEmbeddings(
+              nodeInstancesToSync,
+              activeSupabaseClient,
+              activeContext,
+            ),
     });
     await measureSyncPhase({
       phase: "upsertFullContent",
@@ -1265,7 +1318,7 @@ export const createOrUpdateDiscourseEmbedding = async (
       phases,
       operation: () =>
         convertDgToSupabaseConcepts({
-          nodesSince: changedNodeInstances,
+          nodesSince: nodeInstancesToSync,
           since: sinceTime,
           allNodeTypes: allDgNodeTypes,
           sharedNodeTypeIds,
@@ -1285,6 +1338,7 @@ export const createOrUpdateDiscourseEmbedding = async (
       operation: () =>
         endSyncTask({
           worker,
+          syncFunction,
           status: "complete",
           showToast,
           taskStartedAt: activeClaimedAt,
@@ -1352,6 +1406,7 @@ export const createOrUpdateDiscourseEmbedding = async (
         operation: () =>
           endSyncTask({
             worker,
+            syncFunction,
             status: "failed",
             showToast,
             taskStartedAt: failedClaimedAt,
diff --git a/packages/database/src/lib/__tests__/sharedNodes.test.ts b/packages/database/src/lib/__tests__/sharedNodes.test.ts
index b13e373fe..37b422299 100644
--- a/packages/database/src/lib/__tests__/sharedNodes.test.ts
+++ b/packages/database/src/lib/__tests__/sharedNodes.test.ts
@@ -1,5 +1,6 @@
-import { describe, expect, it } from "vitest";
-import { buildSharedNodes } from "../sharedNodes";
+import { describe, expect, it, vi } from "vitest";
+import type { DGSupabaseClient } from "../client";
+import { buildSharedNodes, getSharedNodeByRid } from "../sharedNodes";
 
 type BuildArgs = Parameters<typeof buildSharedNodes>[0];
 
@@ -187,3 +188,151 @@ describe("buildSharedNodes", () => {
     ).toEqual(["node-1", "node-2"]);
   });
 });
+
+type QueryResult = { data: unknown; error: { message: string } | null };
+
+const makeQueryBuilder = (result: QueryResult) => {
+  const builder = {
+    select: vi.fn(),
+    eq: vi.fn(),
+    maybeSingle: vi.fn().mockResolvedValue(result),
+    then: (
+      resolve: (value: QueryResult) => unknown,
+      reject?: (reason: unknown) => unknown,
+    ) => Promise.resolve(result).then(resolve, reject),
+  };
+  builder.select.mockReturnValue(builder);
+  builder.eq.mockReturnValue(builder);
+  return builder;
+};
+
+const makeClient = ({
+  space,
+  concepts = nodes,
+  direct = directContents,
+  full = fullContentSummaries,
+}: {
+  space: BuildArgs["spaces"][number] | null;
+  concepts?: BuildArgs["nodes"];
+  direct?: BuildArgs["directContents"];
+  full?: BuildArgs["fullContentSummaries"];
+}) => {
+  const spacesBuilder = makeQueryBuilder({ data: space, error: null });
+  const conceptsBuilder = makeQueryBuilder({ data: concepts, error: null });
+  const makeContentsBuilder = () => {
+    let variant = "";
+    const builder = {
+      select: vi.fn(),
+      eq: vi.fn(),
+      then: (
+        resolve: (value: QueryResult) => unknown,
+        reject?: (reason: unknown) => unknown,
+      ) =>
+        Promise.resolve({
+          data: variant === "direct" ? direct : variant === "full" ? full : [],
+          error: null,
+        }).then(resolve, reject),
+    };
+    builder.select.mockReturnValue(builder);
+    builder.eq.mockImplementation((column: string, value: unknown) => {
+      if (column === "variant") variant = value as string;
+      return builder;
+    });
+    return builder;
+  };
+  const from = vi.fn((table: string) =>
+    table === "my_spaces"
+      ? spacesBuilder
+      : table === "my_concepts"
+        ? conceptsBuilder
+        : makeContentsBuilder(),
+  );
+  return {
+    client: { from } as unknown as DGSupabaseClient,
+    spacesBuilder,
+    conceptsBuilder,
+  };
+};
+
+describe("getSharedNodeByRid", () => {
+  it("fetches one shared node by its stored rid", async () => {
+    const { client, spacesBuilder, conceptsBuilder } = makeClient({
+      space: spaces[0]!,
+    });
+
+    await expect(getSharedNodeByRid({ client, rid })).resolves.toEqual({
+      rid,
+      sourceLocalId: "node-1",
+      spaceId: 20,
+      spaceName: "Research vault",
+      spaceUri: "obsidian:vault-a",
+      platform: "Obsidian",
+      title: "EVD - REM sleep and recall",
+      created: "2026-06-14T11:00:00.000Z",
+      lastModified: "2026-06-14T15:00:00.000Z",
+      authorId: 42,
+      directMetadata: { source: "obsidian" },
+    });
+    expect(spacesBuilder.eq).toHaveBeenCalledWith("url", "obsidian:vault-a");
+    expect(conceptsBuilder.eq).toHaveBeenCalledWith("space_id", 20);
+    expect(conceptsBuilder.eq).toHaveBeenCalledWith(
+      "source_local_id",
+      "node-1",
+    );
+  });
+
+  it("queries with the space url and local id parsed from a URL-form rid", async () => {
+    const { client, spacesBuilder, conceptsBuilder } = makeClient({
+      space: {
+        id: 30,
+        name: "Research graph",
+        platform: "Roam",
+        url: "https://roamresearch.com/#/app/research-graph",
+      },
+      concepts: [],
+      direct: [],
+      full: [],
+    });
+
+    await expect(
+      getSharedNodeByRid({
+        client,
+        rid: "https://roamresearch.com/#/app/research-graph/roam-uid-1",
+      }),
+    ).resolves.toBeNull();
+    expect(spacesBuilder.eq).toHaveBeenCalledWith(
+      "url",
+      "https://roamresearch.com/#/app/research-graph",
+    );
+    expect(conceptsBuilder.eq).toHaveBeenCalledWith(
+      "source_local_id",
+      "roam-uid-1",
+    );
+  });
+
+  it("returns null when the source space is not visible", async () => {
+    const { client } = makeClient({ space: null });
+
+    await expect(getSharedNodeByRid({ client, rid })).resolves.toBeNull();
+  });
+
+  it("returns null when the node has no direct content", async () => {
+    const { client } = makeClient({ space: spaces[0]!, direct: [] });
+
+    await expect(getSharedNodeByRid({ client, rid })).resolves.toBeNull();
+  });
+
+  it("throws when the space lookup fails", async () => {
+    const failingBuilder = makeQueryBuilder({
+      data: null,
+      error: { message: "permission denied" },
+    });
+    const client = {
+      from: vi.fn(() => failingBuilder),
+    } as unknown as DGSupabaseClient;
+
+    await expect(getSharedNodeByRid({ client, rid })).rejects.toEqual({
+      message: "permission denied",
+    });
+  });
+});
diff --git a/packages/database/src/lib/sharedNodes.ts b/packages/database/src/lib/sharedNodes.ts
index f423eea01..f7c36aaf5 100644
--- a/packages/database/src/lib/sharedNodes.ts
+++ b/packages/database/src/lib/sharedNodes.ts
@@ -1,5 +1,5 @@
 import type { DGSupabaseClient } from "./client";
-import { spaceUriAndLocalIdToRid } from "./rid";
+import { ridToSpaceUriAndLocalId, spaceUriAndLocalIdToRid } from "./rid";
 import type { Enums, Json, Tables } from "../dbTypes";
 
 type SharedConcept = Pick<
@@ -54,6 +54,13 @@ export type SharedNodeRows = {
   spaces: SharedSpace[];
 };
 
+const CONCEPT_COLUMNS =
+  "is_schema, last_modified, schema_id, source_local_id, space_id";
+const DIRECT_CONTENT_COLUMNS =
+  "author_id, created, last_modified, metadata, source_local_id, space_id, text, variant";
+const FULL_CONTENT_SUMMARY_COLUMNS = "last_modified, source_local_id, space_id";
+const SPACE_COLUMNS = "id, name, platform, url";
+
 const getResourceKey = ({
   sourceLocalId,
   spaceId,
@@ -211,28 +218,21 @@ const getSharedNodeRows = async ({
     await Promise.all([
       client
         .from("my_concepts")
-        .select(
-          "is_schema, last_modified, schema_id, source_local_id, space_id",
-        )
+        .select(CONCEPT_COLUMNS)
         .neq("space_id", currentSpaceId)
         .eq("is_schema", false)
         .eq("arity", 0),
       client
         .from("my_contents")
-        .select(
-          "author_id, created, last_modified, metadata, source_local_id, space_id, text, variant",
-        )
+        .select(DIRECT_CONTENT_COLUMNS)
         .neq("space_id", currentSpaceId)
         .eq("variant", "direct"),
       client
         .from("my_contents")
-        .select("last_modified, source_local_id, space_id")
+        .select(FULL_CONTENT_SUMMARY_COLUMNS)
         .neq("space_id", currentSpaceId)
         .eq("variant", "full"),
-      client
-        .from("my_spaces")
-        .select("id, name, platform, url")
-        .neq("id", currentSpaceId),
+      client.from("my_spaces").select(SPACE_COLUMNS).neq("id", currentSpaceId),
     ]);
   if (conceptsResponse.error) throw conceptsResponse.error;
   if (directResponse.error) throw directResponse.error;
@@ -257,3 +257,54 @@ export const listGroupSharedNodes = async ({
   const rows = await getSharedNodeRows({ client, currentSpaceId });
   return buildSharedNodes(rows);
 };
+
+export const getSharedNodeByRid = async ({
+  client,
+  rid,
+}: {
+  client: DGSupabaseClient;
+  rid: string;
+}): Promise<SharedNode | null> => {
+  const { spaceUri, sourceLocalId } = ridToSpaceUriAndLocalId(rid);
+  const spaceResponse = await client
+    .from("my_spaces")
+    .select(SPACE_COLUMNS)
+    .eq("url", spaceUri)
+    .maybeSingle();
+  if (spaceResponse.error) throw spaceResponse.error;
+  const space = spaceResponse.data;
+  if (!space || typeof space.id !== "number") return null;
+
+  const [conceptsResponse, directResponse, fullResponse] = await Promise.all([
+    client
+      .from("my_concepts")
+      .select(CONCEPT_COLUMNS)
+      .eq("space_id", space.id)
+      .eq("source_local_id", sourceLocalId)
+      .eq("is_schema", false)
+      .eq("arity", 0),
+    client
+      .from("my_contents")
+      .select(DIRECT_CONTENT_COLUMNS)
+      .eq("space_id", space.id)
+      .eq("source_local_id", sourceLocalId)
+      .eq("variant", "direct"),
+    client
+      .from("my_contents")
+      .select(FULL_CONTENT_SUMMARY_COLUMNS)
+      .eq("space_id", space.id)
+      .eq("source_local_id", sourceLocalId)
+      .eq("variant", "full"),
+  ]);
+  if (conceptsResponse.error) throw conceptsResponse.error;
+  if (directResponse.error) throw directResponse.error;
+  if (fullResponse.error) throw fullResponse.error;
+
+  const [sharedNode] = buildSharedNodes({
+    nodes: conceptsResponse.data,
+    directContents: directResponse.data,
+    fullContentSummaries: fullResponse.data,
+    spaces: [space],
+  });
+  return sharedNode ?? null;
+};