diff --git a/apps/roam/src/components/DiscourseContext.tsx b/apps/roam/src/components/DiscourseContext.tsx
index 92fd5cdba..206c3ea50 100644
--- a/apps/roam/src/components/DiscourseContext.tsx
+++ b/apps/roam/src/components/DiscourseContext.tsx
@@ -5,6 +5,7 @@ import getDiscourseContextResults from "~/utils/getDiscourseContextResults";
 import ResultsView from "./results-view/ResultsView";
 import posthog from "posthog-js";
 import { CreateRelationButton } from "./CreateRelationDialog";
+import TentativeRelationInstances from "./TentativeRelationInstances";
 import { useDiscourseContextMutationRefresh } from "~/utils/discourseContextMutationRefresh";
 
 export type DiscourseContextResults = Awaited<
@@ -172,7 +173,10 @@ export const ContextContent = ({ uid, results, overlayRefresh }: Props) => {
   });
   const [tabId, setTabId] = useState(0);
   const [groupByTarget, setGroupByTarget] = useState(false);
-  return queryResults.length ? (
+  const [tentativeCount, setTentativeCount] = useState<number | undefined>(
+    undefined,
+  );
+  const body = queryResults.length ? (
     <>
       <style>{`@media (hover: hover) and (pointer: fine) {
   .roamjs-discourse-result-panel .roamjs-query-results-delete-relation {
@@ -249,10 +253,16 @@ export const ContextContent = ({ uid, results, overlayRefresh }: Props) => {
     </Tabs>
   ) : (
     <div className="flex flex-col items-start">
-      <span>No discourse relations found.</span>
+      {tentativeCount === 0 && <span>No discourse relations found.</span>}
       <CreateRelationButton sourceNodeUid={uid} onCreated={delayedRefresh} />
     </div>
   );
+  return (
+    <>
+      {body}
+      <TentativeRelationInstances uid={uid} onCountChange={setTentativeCount} />
+    </>
+  );
 };
 
 const DiscourseContext = ({ uid }: Props) => {
diff --git a/apps/roam/src/components/TentativeRelationInstances.tsx b/apps/roam/src/components/TentativeRelationInstances.tsx
new file mode 100644
index 000000000..b7878ac42
--- /dev/null
+++ b/apps/roam/src/components/TentativeRelationInstances.tsx
@@ -0,0 +1,212 @@
+import React, { useCallback, useEffect, useState } from "react";
+import { Button, Classes, Tag } from "@blueprintjs/core";
+import { render as renderToast } from "roamjs-components/components/Toast";
+import deleteBlock from "roamjs-components/writes/deleteBlock";
+import getPageTitleByPageUid from "roamjs-components/queries/getPageTitleByPageUid";
+import posthog from "posthog-js";
+import { isRid, ridToSpaceUriAndLocalId } from "@repo/database/lib/rid";
+import getDiscourseRelations from "~/utils/getDiscourseRelations";
+import internalError from "~/utils/internalError";
+import { getErrorMessage } from "~/utils/materializeSharedNode";
+import { getStoredRelationsEnabled } from "~/utils/storedRelations";
+import {
+  refreshDiscourseContextsForMutatedUids,
+  useDiscourseContextMutationRefresh,
+} from "~/utils/discourseContextMutationRefresh";
+import { acceptTentativeRelationInstance } from "~/utils/createReifiedBlock";
+import {
+  getTentativeRelationInstances,
+  type TentativeRelationInstance,
+} from "~/utils/tentativeRelations";
+import type { ImportedSourceIdentity } from "~/utils/importedSourceIdentity";
+
+type TentativeRelationRow = TentativeRelationInstance & {
+  label: string;
+  otherText: string;
+  provenance: string;
+};
+
+const buildProvenance = (importedFrom?: ImportedSourceIdentity): string => {
+  if (!importedFrom || !isRid(importedFrom.sourceNodeRid)) return "";
+  const { spaceUri, sourceLocalId } = ridToSpaceUriAndLocalId(
+    importedFrom.sourceNodeRid,
+  );
+  const modifiedAt = new Date(importedFrom.sourceModifiedAt);
+  const modified = Number.isNaN(modifiedAt.getTime())
+    ? undefined
+    : modifiedAt.toLocaleString();
+  return `from ${[spaceUri, sourceLocalId, modified].filter(Boolean).join(" · ")}`;
+};
+
+const TentativeRelationInstances = ({
+  uid,
+  onCountChange,
+}: {
+  uid: string;
+  onCountChange: (count: number | undefined) => void;
+}): React.JSX.Element | null => {
+  const [rows, setRows] = useState<TentativeRelationRow[]>([]);
+  const [pending, setPending] = useState<{
+    uid: string;
+    action: "accept" | "remove";
+  } | null>(null);
+
+  const loadRows = useCallback(async () => {
+    if (!getStoredRelationsEnabled()) {
+      onCountChange(0);
+      return;
+    }
+    onCountChange(undefined);
+    try {
+      const instances = await getTentativeRelationInstances();
+      const relevant = instances.filter(
+        (instance) =>
+          instance.sourceUid === uid || instance.destinationUid === uid,
+      );
+      const relationById = new Map(
+        getDiscourseRelations().map((r) => [r.id, r]),
+      );
+      const nextRows = relevant.map((instance) => {
+        const isOutgoing = instance.sourceUid === uid;
+        const otherUid = isOutgoing
+          ? instance.destinationUid
+          : instance.sourceUid;
+        const schema = relationById.get(instance.schemaUid);
+        const label =
+          (isOutgoing ? schema?.label : schema?.complement || schema?.label) ||
+          "Unknown relation";
+        return {
+          ...instance,
+          label,
+          otherText: getPageTitleByPageUid(otherUid) || otherUid,
+          provenance: buildProvenance(instance.importedFrom),
+        };
+      });
+      setRows(nextRows);
+      onCountChange(nextRows.length);
+    } catch (error) {
+      internalError({
+        error,
+        type: "Load Tentative Relations Failed",
+        context: { uid },
+        userMessage:
+          "Could not load imported relations. Refresh and try again.",
+        sendEmail: false,
+      });
+    }
+  }, [uid, onCountChange]);
+
+  useEffect(() => {
+    void loadRows();
+  }, [loadRows]);
+
+  const onMutationRefresh = useCallback(() => void loadRows(), [loadRows]);
+  useDiscourseContextMutationRefresh({ uid, onMutationRefresh });
+
+  const onAccept = async (row: TentativeRelationRow): Promise<void> => {
+    posthog.capture("Discourse Context: Accept Tentative Relation Triggered", {
+      instanceUid: row.instanceUid,
+      uid,
+    });
+    setPending({ uid: row.instanceUid, action: "accept" });
+    try {
+      await acceptTentativeRelationInstance({ instanceUid: row.instanceUid });
+      renderToast({
+        id: "accept-relation-success",
+        content: "Relation accepted",
+        intent: "success",
+      });
+      refreshDiscourseContextsForMutatedUids({
+        uids: [row.sourceUid, row.destinationUid],
+      });
+    } catch (error) {
+      internalError({
+        error,
+        type: "Accept Tentative Relation Failed",
+        context: { instanceUid: row.instanceUid },
+        userMessage: `Could not accept relation: ${getErrorMessage(error)}`,
+        sendEmail: false,
+      });
+    } finally {
+      setPending(null);
+    }
+  };
+
+  const onRemove = async (row: TentativeRelationRow): Promise<void> => {
+    posthog.capture("Discourse Context: Remove Tentative Relation Triggered", {
+      instanceUid: row.instanceUid,
+      uid,
+    });
+    setPending({ uid: row.instanceUid, action: "remove" });
+    try {
+      await deleteBlock(row.instanceUid);
+      renderToast({
+        id: "remove-relation-success",
+        content: "Relation removed",
+        intent: "success",
+      });
+      refreshDiscourseContextsForMutatedUids({
+        uids: [row.sourceUid, row.destinationUid],
+      });
+    } catch (error) {
+      internalError({
+        error,
+        type: "Remove Tentative Relation Failed",
+        context: { instanceUid: row.instanceUid },
+        userMessage: `Could not remove relation: ${getErrorMessage(error)}`,
+        sendEmail: false,
+      });
+    } finally {
+      setPending(null);
+    }
+  };
+
+  if (!rows.length) return null;
+
+  return (
+    <div className="roamjs-discourse-tentative-relations mt-2 px-2">
+      <div className={`${Classes.TEXT_MUTED} text-xs font-semibold`}>
+        Imported relations pending review ({rows.length})
+      </div>
+      {rows.map((row) => (
+        <div key={row.instanceUid} className="flex items-center gap-2 py-1">
+          <div className="min-w-0 flex-1">
+            <div className="truncate" title={row.otherText}>
+              <Tag minimal>{row.label}</Tag> {row.otherText}
+            </div>
+            {row.provenance && (
+              <div
+                className={`${Classes.TEXT_MUTED} truncate text-xs`}
+                title={row.importedFrom?.sourceNodeRid}
+              >
+                {row.provenance}
+              </div>
+            )}
+          </div>
+          <Button
+            minimal
+            icon="tick"
+            title="Accept relation"
+            disabled={pending !== null}
+            loading={
+              pending?.uid === row.instanceUid && pending.action === "accept"
+            }
+            onClick={() => void onAccept(row)}
+          />
+          <Button
+            minimal
+            icon="delete"
+            title="Remove relation"
+            disabled={pending !== null}
+            loading={
+              pending?.uid === row.instanceUid && pending.action === "remove"
+            }
+            onClick={() => void onRemove(row)}
+          />
+        </div>
+      ))}
+    </div>
+  );
+};
+
+export default TentativeRelationInstances;
diff --git a/apps/roam/src/components/results-view/ResultsTable.tsx b/apps/roam/src/components/results-view/ResultsTable.tsx
index 4b67b836c..ec00de157 100644
--- a/apps/roam/src/components/results-view/ResultsTable.tsx
+++ b/apps/roam/src/components/results-view/ResultsTable.tsx
@@ -279,7 +279,8 @@ const ResultRow = ({
       hasSchema: r["id"],
     } as Record<string, string>;
     // types got checked as a condition for displaying the button
-    strictQueryForReifiedBlocks(data)
+    // The visible row is accepted; a pending twin must not be its delete target.
+    strictQueryForReifiedBlocks(data, { acceptedOnly: true })
       .then((blockUid) => {
         if (blockUid === null) {
           renderToast({
diff --git a/apps/roam/src/utils/__tests__/getDiscourseContextResults.test.ts b/apps/roam/src/utils/__tests__/getDiscourseContextResults.test.ts
index f95e761ce..ca291f0b7 100644
--- a/apps/roam/src/utils/__tests__/getDiscourseContextResults.test.ts
+++ b/apps/roam/src/utils/__tests__/getDiscourseContextResults.test.ts
@@ -7,6 +7,7 @@ const mocks = vi.hoisted(() => ({
   fireQuery: vi.fn(),
   generateUID: vi.fn(),
   getSetting: vi.fn(),
+  getTentativeOnlyRelationKeys: vi.fn(),
 }));
 
 vi.mock("~/utils/deriveDiscourseNodeAttribute", () => ({
@@ -34,6 +35,10 @@ vi.mock("~/utils/getDiscourseRelations", () => ({
   default: () => [],
 }));
 
+vi.mock("~/utils/tentativeRelations", () => ({
+  getTentativeOnlyRelationKeys: mocks.getTentativeOnlyRelationKeys,
+}));
+
 import getDiscourseContextResults from "~/utils/getDiscourseContextResults";
 
 const makeNode = ({
@@ -66,6 +71,7 @@ describe("getDiscourseContextResults", () => {
     mocks.generateUID.mockReturnValue("condition");
     mocks.getSetting.mockReturnValue(true);
     mocks.findDiscourseNode.mockReturnValue({ type: "CLM" });
+    mocks.getTentativeOnlyRelationKeys.mockResolvedValue(new Set());
   });
 
   it("regroups all-relation reified query results by schema order", async () => {
@@ -160,4 +166,115 @@ describe("getDiscourseContextResults", () => {
     expect(onResult).toHaveBeenNthCalledWith(1, results[0]);
     expect(onResult).toHaveBeenNthCalledWith(2, results[1]);
   });
+
+  it("excludes tentative imported relation instances from reified results", async () => {
+    const onResult = vi.fn();
+    const nodes: DiscourseNode[] = [
+      makeNode({ type: "CLM", text: "Claim" }),
+      makeNode({ type: "QUE", text: "Question" }),
+      makeNode({ type: "EVD", text: "Evidence" }),
+    ];
+    const relations: DiscourseRelation[] = [
+      {
+        id: "supports",
+        label: "Supports",
+        complement: "Supported By",
+        source: "CLM",
+        destination: "QUE",
+        triples: [],
+      },
+      {
+        id: "informs",
+        label: "Informs",
+        complement: "Informed By",
+        source: "EVD",
+        destination: "CLM",
+        triples: [],
+      },
+    ];
+
+    mocks.fireQuery.mockResolvedValue([
+      {
+        text: "Evidence A",
+        uid: "evidence-a",
+        relationUid: "informs",
+        effectiveSource: "evidence-a",
+      },
+      {
+        text: "Question A",
+        uid: "question-a",
+        relationUid: "supports",
+        effectiveSource: "claim-a",
+      },
+    ]);
+    mocks.getTentativeOnlyRelationKeys.mockResolvedValue(
+      new Set(["supports|claim-a|question-a"]),
+    );
+
+    const results = await getDiscourseContextResults({
+      uid: "claim-a",
+      nodes,
+      relations,
+      onResult,
+    });
+
+    expect(results).toHaveLength(1);
+    expect(results[0].label).toBe("Informed By");
+    expect(Object.keys(results[0].results)).toEqual(["evidence-a"]);
+    expect(onResult).toHaveBeenCalledTimes(1);
+  });
+
+  it("excludes tentative instances where the active node is the destination", async () => {
+    const nodes: DiscourseNode[] = [
+      makeNode({ type: "CLM", text: "Claim" }),
+      makeNode({ type: "QUE", text: "Question" }),
+      makeNode({ type: "EVD", text: "Evidence" }),
+    ];
+    const relations: DiscourseRelation[] = [
+      {
+        id: "supports",
+        label: "Supports",
+        complement: "Supported By",
+        source: "CLM",
+        destination: "QUE",
+        triples: [],
+      },
+      {
+        id: "informs",
+        label: "Informs",
+        complement: "Informed By",
+        source: "EVD",
+        destination: "CLM",
+        triples: [],
+      },
+    ];
+
+    mocks.fireQuery.mockResolvedValue([
+      {
+        text: "Evidence A",
+        uid: "evidence-a",
+        relationUid: "informs",
+        effectiveSource: "evidence-a",
+      },
+      {
+        text: "Question A",
+        uid: "question-a",
+        relationUid: "supports",
+        effectiveSource: "claim-a",
+      },
+    ]);
+    mocks.getTentativeOnlyRelationKeys.mockResolvedValue(
+      new Set(["informs|evidence-a|claim-a"]),
+    );
+
+    const results = await getDiscourseContextResults({
+      uid: "claim-a",
+      nodes,
+      relations,
+    });
+
+    expect(results).toHaveLength(1);
+    expect(results[0].label).toBe("Supports");
+    expect(Object.keys(results[0].results)).toEqual(["question-a"]);
+  });
 });
diff --git a/apps/roam/src/utils/__tests__/importSharedNodes.test.ts b/apps/roam/src/utils/__tests__/importSharedNodes.test.ts
index 0712131d8..e7bc1ebfd 100644
--- a/apps/roam/src/utils/__tests__/importSharedNodes.test.ts
+++ b/apps/roam/src/utils/__tests__/importSharedNodes.test.ts
@@ -16,6 +16,8 @@ vi.mock("~/utils/materializeSharedNode", async () => {
   return { ...actual, materializeSharedNode: vi.fn() };
 });
 
+vi.mock("~/utils/internalError", () => ({ default: vi.fn() }));
+
 vi.mock("~/utils/resolveSharedNodeTypes", () => ({
   resolveSharedNodeTypes: vi.fn(),
 }));
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__/importedSourceIdentity.test.ts b/apps/roam/src/utils/__tests__/importedSourceIdentity.test.ts
index 602b37cb3..160f2ab33 100644
--- a/apps/roam/src/utils/__tests__/importedSourceIdentity.test.ts
+++ b/apps/roam/src/utils/__tests__/importedSourceIdentity.test.ts
@@ -1,14 +1,18 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { DISCOURSE_GRAPH_PROP_NAME } from "~/utils/createReifiedBlock";
+import {
+  DISCOURSE_GRAPH_PROP_NAME,
+  IMPORTED_FROM_PROP_KEY,
+} from "~/utils/createReifiedBlock";
 import {
   findImportedNodeUidBySourceRid,
   getImportedSourceRids,
-  IMPORTED_FROM_PROP_KEY,
   readImportedSourceIdentity,
   writeImportedSourceIdentity,
 } from "~/utils/importedSourceIdentity";
 import type { json } from "~/utils/getBlockProps";
 
+vi.mock("~/utils/internalError", () => ({ default: vi.fn() }));
+
 const SOURCE_NODE_RID = "orn:obsidian.note:vault-a/node-1";
 const SOURCE_MODIFIED_AT = "2026-06-14T15:00:00.000Z";
 const PAGE_UID = "page-uid";
diff --git a/apps/roam/src/utils/__tests__/tentativeRelationLoading.test.ts b/apps/roam/src/utils/__tests__/tentativeRelationLoading.test.ts
new file mode 100644
index 000000000..03e7aa76b
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/tentativeRelationLoading.test.ts
@@ -0,0 +1,98 @@
+// @vitest-environment jsdom
+import React from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { act } from "react-dom/test-utils";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import TentativeRelationInstances from "~/components/TentativeRelationInstances";
+import { getTentativeRelationInstances } from "~/utils/tentativeRelations";
+import { getStoredRelationsEnabled } from "~/utils/storedRelations";
+import internalError from "~/utils/internalError";
+
+vi.mock("~/utils/tentativeRelations", () => ({
+  getTentativeRelationInstances: vi.fn(),
+}));
+vi.mock("~/utils/storedRelations", () => ({
+  getStoredRelationsEnabled: vi.fn(),
+}));
+vi.mock("~/utils/internalError", () => ({ default: vi.fn() }));
+vi.mock("~/utils/getDiscourseRelations", () => ({ default: () => [] }));
+vi.mock("~/utils/materializeSharedNode", () => ({ getErrorMessage: String }));
+vi.mock("~/utils/createReifiedBlock", () => ({
+  acceptTentativeRelationInstance: vi.fn(),
+}));
+vi.mock("roamjs-components/queries/getPageTitleByPageUid", () => ({
+  default: (uid: string) => uid,
+}));
+vi.mock("roamjs-components/writes/deleteBlock", () => ({ default: vi.fn() }));
+vi.mock("roamjs-components/components/Toast", () => ({ render: vi.fn() }));
+vi.mock("posthog-js", () => ({ default: { capture: vi.fn() } }));
+
+let root: Root;
+let container: HTMLDivElement;
+const onCountChange = vi.fn();
+const render = async (): Promise<void> => {
+  await act(async () => {
+    root.render(
+      React.createElement(TentativeRelationInstances, {
+        uid: "node",
+        onCountChange,
+      }),
+    );
+    await Promise.resolve();
+  });
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  vi.mocked(getStoredRelationsEnabled).mockReturnValue(true);
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+  vi.unstubAllGlobals();
+});
+
+describe("pending relation loading", () => {
+  it("reports loading until the query establishes that no relations exist", async () => {
+    let finish: (() => void) | undefined;
+    vi.mocked(getTentativeRelationInstances).mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finish = () => resolve([]);
+        }),
+    );
+    await render();
+    expect(onCountChange).toHaveBeenCalledExactlyOnceWith(undefined);
+    await act(async () => {
+      finish?.();
+      await Promise.resolve();
+    });
+    expect(onCountChange).toHaveBeenLastCalledWith(0);
+    expect(internalError).not.toHaveBeenCalled();
+  });
+
+  it("reports a failed load without claiming the relation set is empty", async () => {
+    const error = new Error("graph query failed");
+    vi.mocked(getTentativeRelationInstances).mockRejectedValue(error);
+    await render();
+    expect(onCountChange).toHaveBeenCalledExactlyOnceWith(undefined);
+    expect(internalError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        error,
+        userMessage:
+          "Could not load imported relations. Refresh and try again.",
+      }),
+    );
+  });
+
+  it("settles to zero without querying when stored relations are disabled", async () => {
+    vi.mocked(getStoredRelationsEnabled).mockReturnValue(false);
+    await render();
+    expect(onCountChange).toHaveBeenCalledExactlyOnceWith(0);
+    expect(getTentativeRelationInstances).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/roam/src/utils/__tests__/tentativeRelations.test.ts b/apps/roam/src/utils/__tests__/tentativeRelations.test.ts
new file mode 100644
index 000000000..3c0263f2e
--- /dev/null
+++ b/apps/roam/src/utils/__tests__/tentativeRelations.test.ts
@@ -0,0 +1,264 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  DISCOURSE_GRAPH_PROP_NAME,
+  acceptTentativeRelationInstance,
+  createReifiedRelation,
+  strictQueryForReifiedBlocks,
+} from "~/utils/createReifiedBlock";
+import {
+  getTentativeOnlyRelationKeys,
+  getTentativeRelationInstances,
+} from "~/utils/tentativeRelations";
+import type { json } from "~/utils/getBlockProps";
+
+vi.mock("roamjs-components/queries/getPageUidByPageTitle", () => ({
+  default: () => "relations-page",
+}));
+
+vi.mock("~/utils/internalError", () => ({ default: vi.fn() }));
+
+const RELATION_UID = "rel-block-1";
+const SOURCE_NODE_RID = "orn:obsidian.note:vault-a/relation-1";
+const SOURCE_MODIFIED_AT = "2026-08-21T15:00:00.000Z";
+
+const propsByUid = new Map<string, Record<string, json>>();
+const query = vi.fn();
+const update = vi.fn(
+  ({ block }: { block: { props: Record<string, json>; uid: string } }) => {
+    propsByUid.set(block.uid, block.props);
+    return Promise.resolve();
+  },
+);
+
+const setRoamAlphaApi = (): void => {
+  (globalThis as { window: unknown }).window = {
+    roamAlphaAPI: {
+      data: {
+        async: { q: query },
+        block: { update },
+      },
+      pull: (_pattern: string, [, uid]: [string, string]) => ({
+        ":block/props": propsByUid.get(uid) ?? {},
+      }),
+    },
+  };
+};
+
+const tentativeRelationProps = (): Record<string, json> => ({
+  sourceUid: "claim-a",
+  destinationUid: "question-a",
+  hasSchema: "supports",
+  tentative: "true",
+  importedFrom: {
+    sourceModifiedAt: SOURCE_MODIFIED_AT,
+    sourceNodeRid: SOURCE_NODE_RID,
+  },
+});
+
+const acceptedRelationProps = (): Record<string, json> => ({
+  sourceUid: "claim-a",
+  destinationUid: "question-a",
+  hasSchema: "supports",
+  importedFrom: {
+    sourceModifiedAt: SOURCE_MODIFIED_AT,
+    sourceNodeRid: SOURCE_NODE_RID,
+  },
+});
+
+beforeEach(() => {
+  propsByUid.clear();
+  query.mockReset();
+  update.mockClear();
+  setRoamAlphaApi();
+});
+
+describe("getTentativeRelationInstances", () => {
+  it("returns only tentative relations with their source identity", async () => {
+    query.mockResolvedValue([
+      [RELATION_UID, tentativeRelationProps()],
+      [
+        "rel-block-2",
+        {
+          sourceUid: "evidence-a",
+          destinationUid: "claim-a",
+          hasSchema: "informs",
+        },
+      ],
+    ]);
+
+    expect(await getTentativeRelationInstances()).toEqual([
+      {
+        instanceUid: RELATION_UID,
+        schemaUid: "supports",
+        sourceUid: "claim-a",
+        destinationUid: "question-a",
+        importedFrom: {
+          sourceModifiedAt: SOURCE_MODIFIED_AT,
+          sourceNodeRid: SOURCE_NODE_RID,
+        },
+      },
+    ]);
+  });
+});
+
+describe("getTentativeOnlyRelationKeys", () => {
+  it("keeps a triple visible when an accepted twin asserts it too", async () => {
+    query.mockResolvedValue([
+      [RELATION_UID, tentativeRelationProps()],
+      [
+        "rel-block-accepted-twin",
+        {
+          sourceUid: "claim-a",
+          destinationUid: "question-a",
+          hasSchema: "supports",
+        },
+      ],
+      [
+        "rel-block-3",
+        {
+          sourceUid: "evidence-a",
+          destinationUid: "claim-a",
+          hasSchema: "informs",
+          tentative: "true",
+        },
+      ],
+    ]);
+
+    expect(await getTentativeOnlyRelationKeys()).toEqual(
+      new Set(["informs|evidence-a|claim-a"]),
+    );
+  });
+});
+
+describe("acceptTentativeRelationInstance", () => {
+  it("removes the tentative flag while preserving identity and provenance", async () => {
+    propsByUid.set(RELATION_UID, {
+      [DISCOURSE_GRAPH_PROP_NAME]: tentativeRelationProps(),
+    });
+
+    await acceptTentativeRelationInstance({ instanceUid: RELATION_UID });
+
+    expect(propsByUid.get(RELATION_UID)).toEqual({
+      [DISCOURSE_GRAPH_PROP_NAME]: acceptedRelationProps(),
+    });
+  });
+
+  it("is a no-op for a relation that is already accepted", async () => {
+    propsByUid.set(RELATION_UID, {
+      [DISCOURSE_GRAPH_PROP_NAME]: acceptedRelationProps(),
+    });
+
+    await acceptTentativeRelationInstance({ instanceUid: RELATION_UID });
+
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it("throws when the relation block cannot be read", async () => {
+    await expect(
+      acceptTentativeRelationInstance({ instanceUid: "missing" }),
+    ).rejects.toThrow(/could not be read/);
+    expect(update).not.toHaveBeenCalled();
+  });
+});
+
+describe("createReifiedRelation", () => {
+  it("promotes a matching tentative import instead of returning it hidden", async () => {
+    query.mockResolvedValue([[RELATION_UID, tentativeRelationProps()]]);
+    propsByUid.set(RELATION_UID, {
+      [DISCOURSE_GRAPH_PROP_NAME]: tentativeRelationProps(),
+    });
+
+    const uid = await createReifiedRelation({
+      sourceUid: "claim-a",
+      destinationUid: "question-a",
+      relationBlockUid: "supports",
+    });
+
+    expect(uid).toBe(RELATION_UID);
+    expect(propsByUid.get(RELATION_UID)).toEqual({
+      [DISCOURSE_GRAPH_PROP_NAME]: acceptedRelationProps(),
+    });
+  });
+
+  it("leaves a matching tentative import untouched during re-import", async () => {
+    query.mockResolvedValue([[RELATION_UID, tentativeRelationProps()]]);
+    propsByUid.set(RELATION_UID, {
+      [DISCOURSE_GRAPH_PROP_NAME]: tentativeRelationProps(),
+    });
+
+    const uid = await createReifiedRelation({
+      sourceUid: "claim-a",
+      destinationUid: "question-a",
+      relationBlockUid: "supports",
+      tentative: true,
+    });
+
+    expect(uid).toBe(RELATION_UID);
+    expect(update).not.toHaveBeenCalled();
+  });
+});
+
+describe("strictQueryForReifiedBlocks", () => {
+  it("matches imported relation blocks despite annotation keys", async () => {
+    query.mockResolvedValue([[RELATION_UID, tentativeRelationProps()]]);
+
+    expect(
+      await strictQueryForReifiedBlocks({
+        sourceUid: "claim-a",
+        destinationUid: "question-a",
+        hasSchema: "supports",
+      }),
+    ).toBe(RELATION_UID);
+  });
+
+  it.each([undefined, "false"])(
+    "selects the accepted deletion target when a pending twin is returned first (%s)",
+    async (tentative) => {
+      query.mockResolvedValue([
+        [RELATION_UID, tentativeRelationProps()],
+        [
+          "accepted-twin",
+          { ...acceptedRelationProps(), ...(tentative && { tentative }) },
+        ],
+      ]);
+      expect(
+        await strictQueryForReifiedBlocks(
+          {
+            sourceUid: "claim-a",
+            destinationUid: "question-a",
+            hasSchema: "supports",
+          },
+          { acceptedOnly: true },
+        ),
+      ).toBe("accepted-twin");
+    },
+  );
+
+  it("does not fall back to deleting a pending relation when no accepted twin remains", async () => {
+    query.mockResolvedValue([[RELATION_UID, tentativeRelationProps()]]);
+    expect(
+      await strictQueryForReifiedBlocks(
+        {
+          sourceUid: "claim-a",
+          destinationUid: "question-a",
+          hasSchema: "supports",
+        },
+        { acceptedOnly: true },
+      ),
+    ).toBeNull();
+  });
+
+  it("still rejects blocks with extra role keys", async () => {
+    query.mockResolvedValue([
+      [RELATION_UID, { ...tentativeRelationProps(), contextUid: "context-a" }],
+    ]);
+
+    expect(
+      await strictQueryForReifiedBlocks({
+        sourceUid: "claim-a",
+        destinationUid: "question-a",
+        hasSchema: "supports",
+      }),
+    ).toBeNull();
+  });
+});
diff --git a/apps/roam/src/utils/createReifiedBlock.ts b/apps/roam/src/utils/createReifiedBlock.ts
index c4d044fae..7e9032d7b 100644
--- a/apps/roam/src/utils/createReifiedBlock.ts
+++ b/apps/roam/src/utils/createReifiedBlock.ts
@@ -1,13 +1,29 @@
 import createBlock from "roamjs-components/writes/createBlock";
 import createPage from "roamjs-components/writes/createPage";
 import getPageUidByPageTitle from "roamjs-components/queries/getPageUidByPageTitle";
+import getBlockProps, { isJsonObject, type json } from "./getBlockProps";
+import { setBlockPropsAsync } from "./setBlockProps";
+import internalError from "./internalError";
 
 export const DISCOURSE_GRAPH_PROP_NAME = "discourse-graph";
+export const TENTATIVE_PROP_KEY = "tentative";
+export const IMPORTED_FROM_PROP_KEY = "importedFrom";
 
-const SANE_ROLE_NAME_RE = new RegExp(/^[\w\-]*$/);
+// Annotations describe a relation's review/provenance state; they are not part
+// of its identity, so lookups by role parameters must ignore them.
+const RELATION_ANNOTATION_KEYS = new Set<string>([
+  TENTATIVE_PROP_KEY,
+  IMPORTED_FROM_PROP_KEY,
+]);
+
+const countRoleKeys = (params: Record<string, unknown>): number =>
+  Object.keys(params).filter((k) => !RELATION_ANNOTATION_KEYS.has(k)).length;
+
+const SANE_ROLE_NAME_RE = new RegExp(/^[\w-]*$/);
 
 export const strictQueryForReifiedBlocks = async (
   parameterUids: Record<string, string>,
+  { acceptedOnly = false }: { acceptedOnly?: boolean } = {},
 ): Promise<string | null> => {
   const paramsAsSeq = Object.entries(parameterUids);
   // validate parameter names
@@ -26,9 +42,13 @@ export const strictQueryForReifiedBlocks = async (
     ...paramsAsSeq.map(([, v]) => v),
   )) as [string, Record<string, string>][];
   // post-filtering because cannot filter by number of keys in datascript
-  const numParams = Object.keys(parameterUids).length;
+  const numParams = countRoleKeys(parameterUids);
   const resultF = result
-    .filter(([, params]) => Object.keys(params).length === numParams)
+    .filter(
+      ([, params]) =>
+        countRoleKeys(params) === numParams &&
+        (!acceptedOnly || params[TENTATIVE_PROP_KEY] !== "true"),
+    )
     .map(([uid]) => uid);
   if (resultF.length > 1) {
     const paramsAsText = Object.entries(parameterUids)
@@ -41,6 +61,25 @@ export const strictQueryForReifiedBlocks = async (
   return resultF.length > 0 ? resultF[0] : null;
 };
 
+export const acceptTentativeRelationInstance = async ({
+  instanceUid,
+}: {
+  instanceUid: string;
+}): Promise<void> => {
+  const existing = getBlockProps(instanceUid)[DISCOURSE_GRAPH_PROP_NAME];
+  if (!isJsonObject(existing) || typeof existing.sourceUid !== "string") {
+    throw new Error(
+      "The relation block could not be read. It may have been deleted; refresh and try again.",
+    );
+  }
+  if (existing[TENTATIVE_PROP_KEY] === undefined) return;
+  const accepted = { ...existing };
+  delete accepted[TENTATIVE_PROP_KEY];
+  await setBlockPropsAsync(instanceUid, {
+    [DISCOURSE_GRAPH_PROP_NAME]: accepted,
+  });
+};
+
 const createReifiedBlock = async ({
   destinationBlockUid,
   schemaUid,
@@ -56,7 +95,24 @@ const createReifiedBlock = async ({
     hasSchema: schemaUid,
   };
   const existing = await strictQueryForReifiedBlocks(data);
-  if (existing !== null) return existing;
+  if (existing !== null) {
+    // Deliberate local creation counts as user acceptance, so a dedupe hit on
+    // a tentative imported block promotes it instead of returning a block the
+    // UI hides as pending review. Best-effort: the relation exists either way.
+    if (parameterUids[TENTATIVE_PROP_KEY] === undefined) {
+      try {
+        await acceptTentativeRelationInstance({ instanceUid: existing });
+      } catch (error) {
+        internalError({
+          error,
+          type: "Promote Tentative Relation On Create Failed",
+          context: { instanceUid: existing },
+          sendEmail: false,
+        });
+      }
+    }
+    return existing;
+  }
   const newUid = window.roamAlphaAPI.util.generateUID();
   await createBlock({
     node: {
@@ -106,6 +162,8 @@ export type ReifiedRelationData = {
   sourceUid: string;
   destinationUid: string;
   hasSchema: string;
+  tentative?: string;
+  importedFrom?: json;
   importedFromRid?: string;
 };
 
@@ -146,7 +204,9 @@ export const createReifiedRelation = async ({
   const parameterUids: Record<string, string> = {
     sourceUid,
     destinationUid,
-    ...(tentative !== undefined && { tentative: String(tentative) }),
+    ...(tentative !== undefined && {
+      [TENTATIVE_PROP_KEY]: String(tentative),
+    }),
   };
   return await createReifiedBlock({
     destinationBlockUid: await getOrCreateRelationPageUid(),
diff --git a/apps/roam/src/utils/getBlockProps.ts b/apps/roam/src/utils/getBlockProps.ts
index f8c839f1c..88d76e1a1 100644
--- a/apps/roam/src/utils/getBlockProps.ts
+++ b/apps/roam/src/utils/getBlockProps.ts
@@ -6,6 +6,9 @@ export type json =
   | json[]
   | { [key: string]: json };
 
+export const isJsonObject = (value: json): value is Record<string, json> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
 export const normalizeProps = (props: json): json =>
   typeof props === "object"
     ? props === null
diff --git a/apps/roam/src/utils/getDiscourseContextResults.ts b/apps/roam/src/utils/getDiscourseContextResults.ts
index 8962dd5cf..cbc1a1925 100644
--- a/apps/roam/src/utils/getDiscourseContextResults.ts
+++ b/apps/roam/src/utils/getDiscourseContextResults.ts
@@ -12,6 +12,7 @@ import {
   ANY_RELATION_NAME,
   ANY_RELATION_REGEX,
 } from "./deriveDiscourseNodeAttribute";
+import { getTentativeOnlyRelationKeys } from "./tentativeRelations";
 
 const resultCache: Record<string, Awaited<ReturnType<typeof fireQuery>>> = {};
 const CACHE_TIMEOUT = 1000 * 60 * 5;
@@ -278,10 +279,19 @@ const getDiscourseContextResults = async ({
     resultsWithRelation.length > 0 &&
     resultsWithRelation[0].results.length > 0
   ) {
+    const tentativeKeys = await getTentativeOnlyRelationKeys();
+    const isTentativeResult = (r: Result): boolean => {
+      const source = r.effectiveSource as string;
+      const destination = source === targetUid ? r.uid : targetUid;
+      return tentativeKeys.has(
+        `${r.relationUid as string}|${source}|${destination}`,
+      );
+    };
     const byRel: Record<string, Result[]> = {};
     const results = resultsWithRelation[0].results;
     resultsWithRelation = [];
     for (const r of results) {
+      if (isTentativeResult(r)) continue;
       const relKey = `${r.relationUid as string}-${r.effectiveSource !== targetUid}`;
       byRel[relKey] = byRel[relKey] || [];
       byRel[relKey].push(r);
diff --git a/apps/roam/src/utils/importSharedRelations.ts b/apps/roam/src/utils/importSharedRelations.ts
index adb7aa5cd..2011acbbc 100644
--- a/apps/roam/src/utils/importSharedRelations.ts
+++ b/apps/roam/src/utils/importSharedRelations.ts
@@ -139,11 +139,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,
diff --git a/apps/roam/src/utils/importedSourceIdentity.ts b/apps/roam/src/utils/importedSourceIdentity.ts
index 0b3775f25..addc49c96 100644
--- a/apps/roam/src/utils/importedSourceIdentity.ts
+++ b/apps/roam/src/utils/importedSourceIdentity.ts
@@ -1,6 +1,9 @@
 import type { Rid } from "@repo/database/crossAppContracts";
-import { DISCOURSE_GRAPH_PROP_NAME } from "./createReifiedBlock";
-import getBlockProps, { type json } from "./getBlockProps";
+import {
+  DISCOURSE_GRAPH_PROP_NAME,
+  IMPORTED_FROM_PROP_KEY,
+} from "./createReifiedBlock";
+import getBlockProps, { isJsonObject, type json } from "./getBlockProps";
 import { setBlockPropsAsync } from "./setBlockProps";
 
 export type ImportedSourceIdentity = {
@@ -8,21 +11,14 @@ export type ImportedSourceIdentity = {
   sourceNodeRid: Rid;
 };
 
-export const IMPORTED_FROM_PROP_KEY = "importedFrom";
 const SOURCE_NODE_RID_KEY = "sourceNodeRid";
 const SOURCE_MODIFIED_AT_KEY = "sourceModifiedAt";
 
-const isJsonObject = (value: json): value is Record<string, json> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
-const parseImportedSourceIdentity = (
-  props: Record<string, json>,
+export const parseSourceIdentity = (
+  importedFrom: json | undefined,
 ): ImportedSourceIdentity | undefined => {
-  const discourseGraphProps = props[DISCOURSE_GRAPH_PROP_NAME];
-  if (!isJsonObject(discourseGraphProps)) return undefined;
-
-  const importedFrom = discourseGraphProps[IMPORTED_FROM_PROP_KEY];
-  if (!isJsonObject(importedFrom)) return undefined;
+  if (importedFrom === undefined || !isJsonObject(importedFrom))
+    return undefined;
 
   const sourceModifiedAt = importedFrom[SOURCE_MODIFIED_AT_KEY];
   const sourceNodeRid = importedFrom[SOURCE_NODE_RID_KEY];
@@ -32,6 +28,15 @@ const parseImportedSourceIdentity = (
   return { sourceModifiedAt, sourceNodeRid };
 };
 
+const parseImportedSourceIdentity = (
+  props: Record<string, json>,
+): ImportedSourceIdentity | undefined => {
+  const discourseGraphProps = props[DISCOURSE_GRAPH_PROP_NAME];
+  if (!isJsonObject(discourseGraphProps)) return undefined;
+
+  return parseSourceIdentity(discourseGraphProps[IMPORTED_FROM_PROP_KEY]);
+};
+
 export const readImportedSourceIdentity = (
   pageUid: string,
 ): ImportedSourceIdentity | undefined =>
diff --git a/apps/roam/src/utils/tentativeRelations.ts b/apps/roam/src/utils/tentativeRelations.ts
new file mode 100644
index 000000000..6aa0386aa
--- /dev/null
+++ b/apps/roam/src/utils/tentativeRelations.ts
@@ -0,0 +1,46 @@
+import { getReifiedRelations } from "./createReifiedBlock";
+import { normalizeProps } from "./getBlockProps";
+import {
+  parseSourceIdentity,
+  type ImportedSourceIdentity,
+} from "./importedSourceIdentity";
+
+export type TentativeRelationInstance = {
+  instanceUid: string;
+  schemaUid: string;
+  sourceUid: string;
+  destinationUid: string;
+  importedFrom?: ImportedSourceIdentity;
+};
+
+export const getTentativeRelationInstances = async (): Promise<
+  TentativeRelationInstance[]
+> => {
+  const relations = await getReifiedRelations();
+  return relations
+    .filter((r) => r.tentative === "true")
+    .map((r) => ({
+      instanceUid: r.relationId,
+      schemaUid: r.hasSchema,
+      sourceUid: r.sourceUid,
+      destinationUid: r.destinationUid,
+      importedFrom:
+        r.importedFrom === undefined
+          ? undefined
+          : parseSourceIdentity(normalizeProps(r.importedFrom)),
+    }));
+};
+
+// A triple is only excluded from accepted results when no accepted block
+// asserts it too: a graph can hold both a tentative import and an accepted
+// local twin of the same triple, and the accepted one must stay visible.
+export const getTentativeOnlyRelationKeys = async (): Promise<Set<string>> => {
+  const relations = await getReifiedRelations();
+  const accepted = new Set<string>();
+  const tentative = new Set<string>();
+  for (const r of relations) {
+    const key = `${r.hasSchema}|${r.sourceUid}|${r.destinationUid}`;
+    (r.tentative === "true" ? tentative : accepted).add(key);
+  }
+  return new Set([...tentative].filter((key) => !accepted.has(key)));
+};