diff --git a/.github/workflows/data-consistency-contract-ci.yml b/.github/workflows/data-consistency-contract-ci.yml
index f738c18a3..59076aeb0 100644
--- a/.github/workflows/data-consistency-contract-ci.yml
+++ b/.github/workflows/data-consistency-contract-ci.yml
@@ -19,6 +19,12 @@ on:
       - "backend/tests/backup-restore-*.test.ts"
       - "backend/tests/offline-workspace-sync.test.ts"
       - "frontend/src/lib/mobileSync*"
+      - "frontend/src/lib/mobileNoteSyncReceipt.ts"
+      - "frontend/src/lib/noteSyncReceipt.ts"
+      - "frontend/src/lib/useNoteSyncReceipt.ts"
+      - "frontend/src/components/SyncStatusBadge.tsx"
+      - "frontend/src/components/EditorPane.tsx"
+      - "frontend/src/i18n/coverageTranslations.ts"
       - "frontend/src/lib/mobileLocalFirst*"
       - "frontend/src/lib/nativeLocal*"
       - "frontend/src/lib/offline*"
@@ -28,6 +34,12 @@ on:
       - "frontend/src/lib/__tests__/syncEngine*.test.ts"
       - "frontend/src/lib/__tests__/noteSyncSafety*.test.ts"
       - "frontend/src/lib/__tests__/offlineQueue.test.ts"
+      - "frontend/src/lib/__tests__/noteSyncReceipt.test.ts"
+      - "frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts"
+      - "frontend/src/lib/__tests__/noteSyncReceiptBadge.test.tsx"
+      - "frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts"
+      - "frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx"
+      - "frontend/src/lib/__tests__/nativeLocalNoteList.test.ts"
   pull_request:
     paths:
       - "docs/architecture/data-consistency-contract*"
@@ -45,6 +57,12 @@ on:
       - "backend/tests/backup-restore-*.test.ts"
       - "backend/tests/offline-workspace-sync.test.ts"
       - "frontend/src/lib/mobileSync*"
+      - "frontend/src/lib/mobileNoteSyncReceipt.ts"
+      - "frontend/src/lib/noteSyncReceipt.ts"
+      - "frontend/src/lib/useNoteSyncReceipt.ts"
+      - "frontend/src/components/SyncStatusBadge.tsx"
+      - "frontend/src/components/EditorPane.tsx"
+      - "frontend/src/i18n/coverageTranslations.ts"
       - "frontend/src/lib/mobileLocalFirst*"
       - "frontend/src/lib/nativeLocal*"
       - "frontend/src/lib/offline*"
@@ -54,6 +72,12 @@ on:
       - "frontend/src/lib/__tests__/syncEngine*.test.ts"
       - "frontend/src/lib/__tests__/noteSyncSafety*.test.ts"
       - "frontend/src/lib/__tests__/offlineQueue.test.ts"
+      - "frontend/src/lib/__tests__/noteSyncReceipt.test.ts"
+      - "frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts"
+      - "frontend/src/lib/__tests__/noteSyncReceiptBadge.test.tsx"
+      - "frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts"
+      - "frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx"
+      - "frontend/src/lib/__tests__/nativeLocalNoteList.test.ts"
   workflow_dispatch:
 
 permissions:
diff --git a/docs/architecture/data-consistency-contract.matrix.json b/docs/architecture/data-consistency-contract.matrix.json
index c6b38ad3d..3e0d94936 100644
--- a/docs/architecture/data-consistency-contract.matrix.json
+++ b/docs/architecture/data-consistency-contract.matrix.json
@@ -183,6 +183,77 @@
           "case": "preserves a stale offline edit as one pending conflict without issuing PUT"
         }
       ]
+    },
+    {
+      "id": "DCC-011",
+      "title": "逐笔记同步收据以当前修改的版本/Mutation ACK 为依据",
+      "status": "covered",
+      "checks": [
+        {
+          "file": "frontend/src/lib/__tests__/noteSyncReceipt.test.ts",
+          "case": "requires exact local revision before acknowledging a note write"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/noteSyncReceipt.test.ts",
+          "case": "preserves pending queue and conflict priority over an older ACK"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/noteSyncReceipt.test.ts",
+          "case": "isolates receipt data across account and server scopes"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts",
+          "case": "requires a matching native mutation receipt instead of global sync time"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts",
+          "case": "keeps native pending and conflicts ahead of committed ACK"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/offlineQueue.test.ts",
+          "case": "does not discard a newer queued edit after a stale in-flight HTTP 200"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/noteSyncReceiptBadge.test.tsx",
+          "case": "never uses global synced state to claim a note has cloud confirmation"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/noteSyncReceipt.test.ts",
+          "case": "does not treat an Electron local SQLite response as a cloud ACK"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/noteSyncReceipt.test.ts",
+          "case": "does not confirm a metadata-only REST response while CRDT body is unresolved"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts",
+          "case": "stores the actual applied and duplicate versions in an atomic mutation ACK"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts",
+          "case": "keeps conflict.serverVersion separate from successful applied.version"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts",
+          "case": "ignores only the known own ACK echo with a newer queued edit, without overwriting local"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts",
+          "case": "keeps real competing remote modifications as conflicts (not own echoes)"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/nativeLocalNoteList.test.ts",
+          "case": "refreshes both Markdown and rich-text notes only after new Outbox commits"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx",
+          "case": "does not repaint an obsolete confirmed query after a newer pending refresh"
+        },
+        {
+          "file": "frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx",
+          "case": "updates the real editor badge after a committed Android edit"
+        }
+      ]
     }
   ]
 }
diff --git a/docs/architecture/data-consistency-contract.md b/docs/architecture/data-consistency-contract.md
index 1505dae62..3b5a180ee 100644
--- a/docs/architecture/data-consistency-contract.md
+++ b/docs/architecture/data-consistency-contract.md
@@ -41,6 +41,7 @@
 - **DCC-008 — 备份恢复必须先校验、失败要保护原数据。** 附件和数据库快照校验失败时不得覆盖正在使用的数据；发生中途失败，原数据库及受管文件应有回滚/保护路径。
 - **DCC-009 — Native 离线与身份安全。** Native 仅此设备模式的编辑在重启/初始化后仍保留；重新连接服务器前不能偷发写入；同步成功后方可清除相应待发送 mutation。
 - **DCC-010 — Web 离线并不是云端确认。** Web 端失败写入、冲突快照必须保留在已有浏览器队列/冲突存储中，不能把“排队中”渲染成“服务器最新”；浏览器离线存储的实际耐久性仍受浏览器环境限制。
+- **DCC-011 — 逐笔记同步收据须有对应证据。** Web 按账号/服务器作用域保存本地逻辑修订，只有包含完整正文快照的本次版本化写入得到服务端版本推进且无更新的本地修订，才能确认；元数据 REST ACK 不能证明 CRDT 正文已经到达云端。离线队列与冲突优先于旧 ACK。Android 仅依据同一 Profile、同一笔记的 Outbox、冲突以及与 Outbox 出队同事务写入的 mutationId ACK；Native 本地笔记 CRUD 必须在事务提交后立即刷新收据（包括旧 ACK 后的新修改），`applied/duplicate` 结果用 `version` 而非冲突专用 `serverVersion`；回拉只允许通过同一 Profile/笔记的精确 ACK 版本跳过已确认的自身回声，真实远端并发修改仍保留冲突；全局 lastSyncAt 和全局队列空不能证明单篇笔记已同步。缺失证据只能显示“待核验”。
 
 ## 3. 关键时序约束
 
@@ -89,8 +90,8 @@ GitHub Actions：`.github/workflows/data-consistency-contract-ci.yml`，对同
 
 **尚未统一实现，后续应另开 Issue/PR：**
 
-- 为所有编辑器和轻量表格统一 `localRevision / acknowledgedRevision / conflict` 的**同步收据**（Sync Receipt）与原子状态更新；不要先造假的“已同步”标签。
-- 基于该收据统一「正在保存 / 已保存到本机 / 等待云端 / 云端已确认 / 冲突 / 失败」文案，区分服务器持久化与其他设备应用完毕。
+- 本阶段已为普通笔记编辑器实现逐笔记 Sync Receipt；轻量表格、任务、附件和全部其他保存入口尚未覆盖。需要继续统一原生端本地逻辑修订号、服务端 ACK 版本，以及多平台设备级验收。
+- 本阶段显示「正在保存 / 等待云端 / 云端已确认 / 冲突 / 失败 / 待核验」；Electron 内嵌后端的 REST 成功仅代表本地 SQLite 写入，不可据此确认云端；“已保存到本机”尚未覆盖全部 Web 本地存储失败场景，未获持久化证明时不得显示。服务端确认不等于附件或第二设备已应用。
 - Native Android/iOS、桌面与 Web 的真实设备断网、切账号、重启、强杀、磁盘不足、代理异常、附件一致性全链路验收。
 - 备份/恢复在 SQLite 与 PostgreSQL、对象存储等部署组合下的生产级恢复演练和附件逐项校验报告。
 
diff --git a/frontend/src/components/EditorPane.tsx b/frontend/src/components/EditorPane.tsx
index 7fbdcd735..fe0c44224 100644
--- a/frontend/src/components/EditorPane.tsx
+++ b/frontend/src/components/EditorPane.tsx
@@ -2604,7 +2604,7 @@ const moveToTrash = useCallback(async () => {
       <MobileEditorToolbarPortal location="trailing">
         {compactMobileEditing ? (
           <div className="flex items-center gap-1">
-            <SyncStatusBadge saving={syncStatus === "saving" || syncStatus === "error"} />
+            <SyncStatusBadge noteId={activeNote.id} saving={syncStatus === "saving"} />
             <Button
               data-mobile-note-menu-trigger
               variant="ghost"
@@ -2714,7 +2714,7 @@ const moveToTrash = useCallback(async () => {
               本地写入成功就是"已保存"，同步失败只叫"等待同步"，
               绝不能让一次网络抖动显示成"保存失败"。
               Android 保留轻量文字，未开启同步时不渲染。 */}
-          {!compactMobileEditing && <SyncStatusBadge saving={syncStatus === "saving" || syncStatus === "error"} />}
+          {!compactMobileEditing && <SyncStatusBadge noteId={activeNote.id} saving={syncStatus === "saving"} />}
           <span className="flex shrink-0 items-center gap-0.5" aria-hidden="true">
             {activeNote.isLocked || isViewLocked ? <Lock size={12} className={activeNote.isLocked ? "text-orange-500" : "text-tx-tertiary"} /> : null}
             {activeNote.isPinned ? <Pin size={12} className="text-accent-primary fill-accent-primary" /> : null}
diff --git a/frontend/src/components/SyncStatusBadge.tsx b/frontend/src/components/SyncStatusBadge.tsx
index ce460e16d..b751c80af 100644
--- a/frontend/src/components/SyncStatusBadge.tsx
+++ b/frontend/src/components/SyncStatusBadge.tsx
@@ -23,14 +23,29 @@ import { useTranslation } from "react-i18next";
 import { cn } from "@/lib/utils";
 import { useSyncIndicator } from "@/lib/useSyncIndicator";
 import { isAndroidNativeRuntime } from "@/lib/mobileLocalMode";
+import { useNoteSyncReceipt } from "@/lib/useNoteSyncReceipt";
 
-export default function SyncStatusBadge({ className, saving = false }: { className?: string; saving?: boolean }) {
+export default function SyncStatusBadge({ className, saving = false, noteId }: { className?: string; saving?: boolean; noteId?: string }) {
   const { t } = useTranslation();
   const sync = useSyncIndicator(saving);
   const android = isAndroidNativeRuntime();
+  const receipt = useNoteSyncReceipt(noteId, sync.syncEnabled);
 
   // 未启用同步：不占用任何空间。
-  if (!sync.syncEnabled || saving) return null;
+  if (!sync.syncEnabled) return null;
+  if (noteId) {
+    const phase = saving ? "saving" : receipt;
+    const warning = phase === "conflict" || phase === "error";
+    return (
+      <span role="status" aria-live="polite" title={t("syncBadge.receiptHint")}
+        className={cn("flex shrink-0 items-center gap-1 whitespace-nowrap px-1.5 py-1 rounded-md text-[11px]",
+          warning ? "text-amber-600 dark:text-amber-400" : "text-tx-tertiary", className)}>
+        {warning ? <AlertTriangle size={12} /> : phase === "confirmed" ? <Check size={12} /> : <RefreshCw size={12} />}
+        <span>{t(`syncBadge.receipt.${phase}`)}</span>
+      </span>
+    );
+  }
+  if (saving) return null;
 
   // 一切正常时保持安静。有冲突则必须提示，即使状态是 synced ——
   // 冲突不会自动消失，用户需要去处理。
diff --git a/frontend/src/components/__tests__/SyncStatusBadge.mobile.test.tsx b/frontend/src/components/__tests__/SyncStatusBadge.mobile.test.tsx
index e1bf2dc57..017af709f 100644
--- a/frontend/src/components/__tests__/SyncStatusBadge.mobile.test.tsx
+++ b/frontend/src/components/__tests__/SyncStatusBadge.mobile.test.tsx
@@ -7,7 +7,7 @@ const mocks = vi.hoisted(() => ({ settings: vi.fn(), diagnostics: vi.fn() }));
 vi.mock("@/lib/syncLocalApi", () => ({
   fetchSyncSettings: mocks.settings, fetchSyncDiagnostics: mocks.diagnostics, SyncV2DisabledError: class extends Error {},
 }));
-(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
 let root: Root, host: HTMLElement;
 let pending = 0, attachments = 0;
 const render = async (saving = false) => { await act(async () => root.render(<SyncStatusBadge saving={saving} />)); };
diff --git a/frontend/src/i18n/coverageTranslations.ts b/frontend/src/i18n/coverageTranslations.ts
index 18c6fb89f..728b0726e 100644
--- a/frontend/src/i18n/coverageTranslations.ts
+++ b/frontend/src/i18n/coverageTranslations.ts
@@ -180,6 +180,15 @@ export const zhCNCoverageTranslations = {
     "verifyFirst": "请先通过已保存地址连接一次，确认服务器身份后即可自动切换。",
   },
   syncBadge: {
+    "receiptHint": "当前笔记的同步收据。确认仅代表服务器收到笔记修改，不代表附件和其他设备已更新。",
+    "receipt": {
+      "unverified": "云端状态待核验",
+      "saving": "正在保存…",
+      "pending": "等待云端确认",
+      "confirmed": "云端已确认",
+      "conflict": "版本冲突待处理",
+      "error": "同步遇到问题"
+    },
     "conflicts": "{{count}} 个冲突待处理",
     "pending": "待同步 {{count}}",
     "syncing": "同步中… {{count}}",
@@ -764,6 +773,15 @@ export const enCoverageTranslations = {
     "verifyFirst": "Connect through the saved address once to verify the server identity before automatic switching.",
   },
   syncBadge: {
+    "receiptHint": "Receipt for this note only. Confirmation does not guarantee attachment uploads or delivery to other devices.",
+    "receipt": {
+      "unverified": "Cloud status unverified",
+      "saving": "Saving…",
+      "pending": "Awaiting cloud confirmation",
+      "confirmed": "Cloud confirmed",
+      "conflict": "Version conflict",
+      "error": "Sync issue"
+    },
     "conflicts": "{{count}} conflicts to resolve",
     "pending": "{{count}} pending changes",
     "syncing": "Syncing… {{count}}",
diff --git a/frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts b/frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts
new file mode 100644
index 000000000..e1a3f7f4e
--- /dev/null
+++ b/frontend/src/lib/__tests__/mobileNativeReceiptIntegration.test.ts
@@ -0,0 +1,120 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { MobileSyncEngine, isAckedOwnNoteEcho } from "../mobileSyncEngine";
+import { nativeReceiptKey } from "../mobileNoteSyncReceipt";
+import type { NativeDatabase } from "../nativeDatabase";
+
+const scope = {
+  scopeKey: "personal", workspaceId: null, workspaceName: null,
+  role: null, canWrite: true, accessFingerprint: "same",
+};
+const local = { id: "note-a", scopeKey: "personal", version: 4, title: "RACE NEW", content: "new body", contentFormat: "markdown", contentText: "new body" };
+const ownAck = JSON.stringify({ mutationId: "mutation-old", serverVersion: 3 });
+const pending = { baseVersion: 3, payload: JSON.stringify(local) };
+
+afterEach(() => { vi.unstubAllGlobals(); });
+
+describe("PR #821 Android receipt ACK and in-flight pull regressions", () => {
+  function setupDb(config: {
+    rows?: Array<Record<string, unknown>>; server?: Array<Record<string, unknown>>;
+    lastAck?: string; pending?: { payload: string; baseVersion: number } | null;
+  } = {}) {
+    const query = vi.fn(async (sql: string) => {
+      if (sql.includes("SELECT mutationId,entityType,entityId,operation")) return config.rows ?? [];
+      if (sql.includes("SELECT * FROM notes")) return [local];
+      if (sql.includes("SELECT id FROM sync_conflicts")) return [];
+      if (sql.includes("SELECT payload,baseVersion FROM sync_outbox")) return config.pending ? [config.pending] : [];
+      if (sql.includes("SELECT value FROM native_runtime_meta")) return config.lastAck ? [{ value: config.lastAck }] : [];
+      return [];
+    });
+    const run = vi.fn(async (sql: string, params?: unknown[]) => {
+      void sql;
+      void params;
+      return { changes: 1 };
+    });
+    const db: NativeDatabase = {
+      query: query as NativeDatabase["query"],
+      run,
+      transaction: async (work) => work(db),
+      close: async () => undefined,
+    };
+    const engine = new MobileSyncEngine({
+      db, attachments: {} as never, serverUrl: "https://notes.example.com",
+      token: "test", userId: "user", profileId: "profile", deviceId: "device",
+    }) as unknown as {
+      push: (target: typeof scope) => Promise<void>;
+      applyEntries: (target: typeof scope, entries: Array<{entityType:"note";entityId:string;payload: Record<string,unknown>}>, bootstrap:boolean) => Promise<void>;
+    };
+    return { engine, query, run };
+  }
+
+  it("stores the actual applied and duplicate versions in an atomic mutation ACK", async () => {
+    for (const status of ["applied", "duplicate"]) {
+    const row = {
+      mutationId: "mutation-1", entityType: "note", entityId: "note-a",
+      operation: "upsert", baseVersion: 3, payload: JSON.stringify(local),
+    };
+    const { engine, run } = setupDb({ rows: [row] });
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+      ok: true, json: async () => ({ serverSequence: 16, results: [
+        { mutationId: "mutation-1", status, version: 4 },
+      ] }),
+    }));
+    await engine.push(scope);
+    const ack = run.mock.calls.find(([sql]) => String(sql).includes("INSERT INTO native_runtime_meta (key,value"));
+    expect(ack).toBeTruthy();
+    const ackValues = ack?.[1] as unknown[] | undefined;
+    expect(ackValues).toBeDefined();
+    expect(ackValues?.[0]).toBe(nativeReceiptKey("profile","note-a"));
+    expect(JSON.parse(String(ackValues?.[1]))).toEqual({ mutationId: "mutation-1", serverVersion: 4 });
+    expect(run.mock.calls.some(([sql]) => String(sql).includes("DELETE FROM sync_outbox WHERE mutationId"))).toBe(true);
+    }
+  });
+
+  it("keeps conflict.serverVersion separate from successful applied.version", async () => {
+    const row = {
+      mutationId: "mutation-1", entityType: "note", entityId: "note-a",
+      operation: "upsert", baseVersion: 3, payload: JSON.stringify(local),
+    };
+    const { engine, run } = setupDb({ rows: [row] });
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
+      ok: true, json: async () => ({ results: [
+        { mutationId: "mutation-1", status: "conflict", code: "VERSION_CONFLICT", serverVersion: 21,
+          serverPayload: { version: 21, contentFormat: "markdown", content: "other-device" } },
+      ] }),
+    }));
+    await engine.push(scope);
+    expect(run.mock.calls.filter(([sql]) => String(sql).includes("INSERT INTO native_runtime_meta (key,value"))).toHaveLength(0);
+    const conflict = run.mock.calls.find(([sql]) => String(sql).includes("INSERT INTO sync_conflicts"));
+    expect(conflict).toBeTruthy();
+    const conflictValues = conflict?.[1] as unknown[] | undefined;
+    expect(conflictValues?.[6]).toBe(21);
+  });
+
+  it("ignores only the known own ACK echo with a newer queued edit, without overwriting local", async () => {
+    const { engine, run } = setupDb({ pending, lastAck: ownAck });
+    await engine.applyEntries(scope, [{ entityType:"note", entityId:"note-a", payload: {
+      id:"note-a", version:3, content:"prior acknowledged body", contentFormat:"markdown",
+    } }], false);
+    expect(run.mock.calls.some(([sql]) => String(sql).includes("INSERT INTO sync_conflicts"))).toBe(false);
+    expect(run.mock.calls.some(([sql]) => String(sql).includes("INSERT INTO notes"))).toBe(false);
+  });
+
+  it("keeps real competing remote modifications as conflicts (not own echoes)", async () => {
+    const { engine, run } = setupDb({ pending, lastAck: ownAck });
+    await engine.applyEntries(scope, [{ entityType:"note", entityId:"note-a", payload: {
+      id:"note-a", version:5, content:"other device change", contentFormat:"markdown",
+    } }], false);
+    expect(run.mock.calls.some(([sql]) => String(sql).includes("INSERT INTO sync_conflicts"))).toBe(true);
+    expect(run.mock.calls.some(([sql]) => String(sql).includes("INSERT INTO notes"))).toBe(false);
+  });
+
+  it("fails closed on missing provenance, stale bases or malformed metadata", () => {
+    const remote = { version: 3, content:"acknowledged" };
+    expect(isAckedOwnNoteEcho(remote, local, pending, undefined)).toBe(false);
+    expect(isAckedOwnNoteEcho(remote, local, pending, "{bad")).toBe(false);
+    expect(isAckedOwnNoteEcho(remote, local, { ...pending, baseVersion: 2 }, ownAck)).toBe(false);
+    expect(isAckedOwnNoteEcho(remote, local, pending, JSON.stringify({ mutationId:"m", serverVersion:null }))).toBe(false);
+    expect(isAckedOwnNoteEcho(remote, local, pending, ownAck)).toBe(true);
+  });
+});
diff --git a/frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts b/frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts
new file mode 100644
index 000000000..10ddbecfe
--- /dev/null
+++ b/frontend/src/lib/__tests__/mobileNoteSyncReceipt.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+import { readNativeNoteSyncReceipt, nativeReceiptKey } from "@/lib/mobileNoteSyncReceipt";
+import type { NativeDatabase } from "@/lib/nativeDatabase";
+
+function dbStub(input: { conflicts?: unknown[]; outbox?: unknown[]; receipt?: { mutationId: string; serverVersion?: number } } = {}) {
+  const query = vi.fn(async (sql: string) => {
+    if (sql.includes("sync_conflicts")) return input.conflicts ?? [];
+    if (sql.includes("sync_outbox")) return input.outbox ?? [];
+    if (sql.includes("native_runtime_meta")) return input.receipt ? [{ value: JSON.stringify(input.receipt) }] : [];
+    return [];
+  });
+  return { db: { query } as unknown as NativeDatabase, query };
+}
+describe("native per-note sync receipt", () => {
+  it("requires a matching native mutation receipt instead of global sync time", async () => {
+    const { db, query } = dbStub();
+    expect(await readNativeNoteSyncReceipt(db, "profile-a", "note-a")).toMatchObject({ phase: "unverified" });
+    expect(query).toHaveBeenCalledWith(expect.stringContaining("native_runtime_meta"),
+      [nativeReceiptKey("profile-a", "note-a")]);
+    const confirmed = dbStub({ receipt: { mutationId: "mutation-1", serverVersion: 9 } });
+    expect(await readNativeNoteSyncReceipt(confirmed.db, "profile-a", "note-a")).toMatchObject({
+      phase: "confirmed", acknowledgedRevision: 9,
+    });
+  });
+  it("keeps native pending and conflicts ahead of committed ACK", async () => {
+    const receipt = { mutationId: "mutation-1", serverVersion: 8 };
+    expect(await readNativeNoteSyncReceipt(dbStub({
+      receipt, outbox: [{ status: "pending", lastError: null }],
+    }).db, "profile-a", "note-a")).toMatchObject({ phase: "pending" });
+    expect(await readNativeNoteSyncReceipt(dbStub({
+      receipt, outbox: [{ status: "failed", lastError: "NETWORK_UNAVAILABLE" }],
+    }).db, "profile-a", "note-a")).toMatchObject({ phase: "error" });
+    expect(await readNativeNoteSyncReceipt(dbStub({
+      receipt, conflicts: [{ id: "conflict-1" }],
+    }).db, "profile-a", "note-a")).toMatchObject({ phase: "conflict" });
+  });
+});
diff --git a/frontend/src/lib/__tests__/nativeLocalNoteList.test.ts b/frontend/src/lib/__tests__/nativeLocalNoteList.test.ts
index af7f01b57..11fa056ea 100644
--- a/frontend/src/lib/__tests__/nativeLocalNoteList.test.ts
+++ b/frontend/src/lib/__tests__/nativeLocalNoteList.test.ts
@@ -2,6 +2,8 @@ import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import { NativeLocalRepository } from "../nativeLocalRepository";
+import { MOBILE_SYNC_STATUS_CHANGED_EVENT } from "../mobileSyncStatus";
+import { readNativeNoteSyncReceipt, nativeReceiptKey } from "../mobileNoteSyncReceipt";
 import type { NativeDatabase } from "../nativeDatabase";
 
 interface SqliteDatabase {
@@ -54,6 +56,40 @@ async function insertNote(id: string, content = "full body", contentText = "prev
     VALUES (?,'user','book',?,?,?,'markdown','blue',1,1,7,3,'created','updated')`, [id,title,content,contentText]);
 }
 
+describe("PR #821 native committed-write receipt notifications", () => {
+  it("refreshes both Markdown and rich-text notes only after new Outbox commits", async () => {
+    await db.run("INSERT INTO sync_profiles (id,name,serverUrl,remoteUserId,enabled,createdAt,updatedAt) VALUES ('profile','A','https://example.com','user',1,'now','now')");
+    await db.run("INSERT INTO sync_devices (profileId,deviceId,platform,createdAt) VALUES ('profile','device','android','now')");
+    for (const format of ["markdown", "tiptap-json"]) {
+    const noteId = "receipt-" + format;
+    await insertNote(noteId);
+    await db.run("UPDATE notes SET contentFormat=? WHERE id=?", [format, noteId]);
+    await db.run("INSERT INTO native_runtime_meta (key,value,updatedAt) VALUES (?,?,?)", [
+      nativeReceiptKey("profile", noteId),
+      JSON.stringify({ mutationId:"previous-ack", serverVersion:7 }), "now",
+    ]);
+    expect((await readNativeNoteSyncReceipt(db, "profile", noteId)).phase).toBe("confirmed");
+    const observed: Array<Promise<string>> = [];
+    const onChanged = () => observed.push(
+      readNativeNoteSyncReceipt(db, "profile", noteId).then((result) => result.phase),
+    );
+    window.addEventListener(MOBILE_SYNC_STATUS_CHANGED_EVENT, onChanged);
+    try {
+      await repository.notes.update(noteId, { content:"new local text" });
+      expect(observed).toHaveLength(1);
+      expect(await observed[0]).toBe("pending");
+      const rows = await db.query<{mutationId:string}>(
+        "SELECT mutationId FROM sync_outbox WHERE entityType='note' AND entityId=?", [noteId],
+      );
+      expect(rows).toHaveLength(1);
+      expect(rows[0].mutationId).not.toBe("previous-ack");
+    } finally {
+      window.removeEventListener(MOBILE_SYNC_STATUS_CHANGED_EVENT, onChanged);
+    }
+    }
+  });
+});
+
 describe("native note list bridge payloads", () => {
   it("bounds raw list results for many large notes while detail reads preserve the entire body", async () => {
     const body = "正文".repeat(64_000);
diff --git a/frontend/src/lib/__tests__/noteSyncReceipt.test.ts b/frontend/src/lib/__tests__/noteSyncReceipt.test.ts
new file mode 100644
index 000000000..f88d30945
--- /dev/null
+++ b/frontend/src/lib/__tests__/noteSyncReceipt.test.ts
@@ -0,0 +1,68 @@
+// @vitest-environment jsdom
+import { beforeEach, describe, expect, it, vi } from "vitest";
+const scope = vi.hoisted(() => ({ value: "server-a:user-a" }));
+vi.mock("@/lib/offlineScope", () => ({ getOfflineQueueStorageKey: () => scope.value }));
+import {
+  beginNoteReceiptWrite, acknowledgeNoteReceipt, getNoteSyncReceipt,
+  markNoteReceiptPending, resolveNoteReceiptPhase, acknowledgeRestNoteReceipt,
+} from "@/lib/noteSyncReceipt";
+
+describe("per-note sync receipt (browser)", () => {
+  beforeEach(() => { localStorage.clear(); scope.value = "server-a:user-a"; });
+
+  it("requires exact local revision before acknowledging a note write", () => {
+    const first = beginNoteReceiptWrite("note-a");
+    const latest = beginNoteReceiptWrite("note-a");
+    expect(acknowledgeNoteReceipt("note-a", first, 8)).toBe(false);
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("note-a"), [])).toBe("unverified");
+    expect(acknowledgeNoteReceipt("note-a", latest, 8)).toBe(true);
+    expect(getNoteSyncReceipt("note-a")).toMatchObject({
+      localRevision: 2, acknowledgedRevision: 2, acknowledgedVersion: 8, phase: "confirmed",
+    });
+    expect(acknowledgeNoteReceipt("note-a", latest, NaN)).toBe(false);
+  });
+
+  it("preserves pending queue and conflict priority over an older ACK", () => {
+    const revision = beginNoteReceiptWrite("note-a");
+    acknowledgeNoteReceipt("note-a", revision, 4);
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("note-a"), [{ noteId: "note-a" }])).toBe("pending");
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("note-a"), [
+      { noteId: "note-a", conflict: true },
+    ])).toBe("conflict");
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("note-a"), [
+      { noteId: "note-a", blocked: true, errorCode: "NETWORK_ERROR" },
+    ])).toBe("error");
+    markNoteReceiptPending("note-a");
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("note-a"), [])).toBe("pending");
+  });
+
+  it("does not confirm a metadata-only REST response while CRDT body is unresolved", () => {
+    const revision = beginNoteReceiptWrite("crdt-note");
+    expect(acknowledgeRestNoteReceipt("crdt-note", revision, 10, false)).toBe(false);
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("crdt-note"), [])).toBe("unverified");
+    expect(acknowledgeRestNoteReceipt("crdt-note", revision, 10, true)).toBe(true);
+  });
+  it("does not treat an Electron local SQLite response as a cloud ACK", () => {
+    const revision = beginNoteReceiptWrite("desktop-note");
+    Object.assign(window, { nowenDesktop: { isDesktop: true } });
+    try {
+      expect(acknowledgeRestNoteReceipt("desktop-note", revision, 12, true)).toBe(false);
+      expect(resolveNoteReceiptPhase(getNoteSyncReceipt("desktop-note"), [])).toBe("unverified");
+    } finally {
+      Reflect.deleteProperty(window, "nowenDesktop");
+    }
+  });
+  it("isolates receipt data across account and server scopes", () => {
+    const revision = beginNoteReceiptWrite("note-a");
+    acknowledgeNoteReceipt("note-a", revision, 3);
+    scope.value = "server-b:user-b";
+    expect(getNoteSyncReceipt("note-a")).toBeNull();
+    scope.value = "server-a:user-a";
+    expect(getNoteSyncReceipt("note-a")?.phase).toBe("confirmed");
+  });
+
+  it("does not revive a save-in-flight as confirmed after a reload", () => {
+    beginNoteReceiptWrite("note-a");
+    expect(resolveNoteReceiptPhase(getNoteSyncReceipt("note-a"), [])).toBe("unverified");
+  });
+});
diff --git a/frontend/src/lib/__tests__/noteSyncReceiptBadge.test.tsx b/frontend/src/lib/__tests__/noteSyncReceiptBadge.test.tsx
new file mode 100644
index 000000000..9fcef42ab
--- /dev/null
+++ b/frontend/src/lib/__tests__/noteSyncReceiptBadge.test.tsx
@@ -0,0 +1,35 @@
+// @vitest-environment jsdom
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+const mocks = vi.hoisted(() => ({ receipt: vi.fn() }));
+vi.mock("@/lib/useSyncIndicator", () => ({
+  useSyncIndicator: () => ({ syncEnabled: true, state: "synced", conflictCount: 0, pendingMutations: 0 }),
+}));
+vi.mock("@/lib/useNoteSyncReceipt", () => ({ useNoteSyncReceipt: mocks.receipt }));
+vi.mock("@/lib/mobileLocalMode", () => ({ isAndroidNativeRuntime: () => false }));
+vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+import SyncStatusBadge from "@/components/SyncStatusBadge";
+(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+let host: HTMLDivElement, root: Root;
+beforeEach(() => {
+  mocks.receipt.mockReset().mockReturnValue("unverified");
+  host = document.createElement("div"); document.body.appendChild(host); root = createRoot(host);
+});
+afterEach(() => { act(() => root.unmount()); host.remove(); });
+describe("per-note editor sync receipt", () => {
+  it("never uses global synced state to claim a note has cloud confirmation", async () => {
+    await act(async () => root.render(<SyncStatusBadge noteId="note-a" />));
+    expect(mocks.receipt).toHaveBeenCalledWith("note-a", true);
+    expect(host.textContent).toBe("syncBadge.receipt.unverified");
+    expect(host.textContent).not.toContain("syncBadge.state.synced");
+    mocks.receipt.mockReturnValue("confirmed");
+    await act(async () => root.render(<SyncStatusBadge noteId="note-a" />));
+    expect(host.textContent).toBe("syncBadge.receipt.confirmed");
+  });
+  it("shows a saving state without claiming cloud ACK", async () => {
+    mocks.receipt.mockReturnValue("confirmed");
+    await act(async () => root.render(<SyncStatusBadge noteId="note-a" saving />));
+    expect(host.textContent).toBe("syncBadge.receipt.saving");
+  });
+});
diff --git a/frontend/src/lib/__tests__/offlineQueue.test.ts b/frontend/src/lib/__tests__/offlineQueue.test.ts
index ab7d189b5..5302e5f0b 100644
--- a/frontend/src/lib/__tests__/offlineQueue.test.ts
+++ b/frontend/src/lib/__tests__/offlineQueue.test.ts
@@ -194,10 +194,27 @@ describe("offlineQueue reliability", () => {
     expect(getQueueLength()).toBe(0);
   });
 
+  it("does not discard a newer queued edit after a stale in-flight HTTP 200", async () => {
+    enqueueUpdate("inflight-race", 2);
+    let resolveRequest: ((value: { ok: boolean; status: number; data: { id: string; version: number } }) => void) | undefined;
+    const fetchFn = vi.fn(() => new Promise<{ ok: boolean; status: number; data: { id: string; version: number } }>((resolve) => {
+      resolveRequest = resolve;
+    }));
+    const replay = flushQueue(fetchFn);
+    expect(fetchFn).toHaveBeenCalledOnce();
+    enqueue({
+      type: "updateNote", noteId: "inflight-race", url: "/notes/inflight-race", method: "PUT",
+      body: { content: "newer edit", contentText: "newer edit", title: "newer", version: 2 },
+    });
+    resolveRequest?.({ ok: true, status: 200, data: { id: "inflight-race", version: 3 } });
+    await replay;
+    expect(getQueue()).toHaveLength(1);
+    expect(getQueue()[0].body).toMatchObject({ content: "newer edit" });
+  });
   it("makes concurrent manual and automatic flush callers await the same in-flight work", async () => {
     enqueueUpdate("note-race", 1);
-    let resolveRequest: ((value: { ok: boolean; status: number; data: any }) => void) | undefined;
-    const fetchFn = vi.fn(() => new Promise<{ ok: boolean; status: number; data: any }>((resolve) => {
+    let resolveRequest: ((value: { ok: boolean; status: number; data: { id: string; version: number } }) => void) | undefined;
+    const fetchFn = vi.fn(() => new Promise<{ ok: boolean; status: number; data: { id: string; version: number } }>((resolve) => {
       resolveRequest = resolve;
     }));
 
diff --git a/frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx b/frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx
new file mode 100644
index 000000000..eae942230
--- /dev/null
+++ b/frontend/src/lib/__tests__/useNoteSyncReceipt.nativeWiring.test.tsx
@@ -0,0 +1,85 @@
+// @vitest-environment jsdom
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { MOBILE_SYNC_STATUS_CHANGED_EVENT } from "../mobileSyncStatus";
+
+const mocks = vi.hoisted(() => ({
+  fetchReceipt: vi.fn(),
+}));
+vi.mock("../mobileLocalMode", () => ({ isAndroidNativeRuntime: () => true }));
+vi.mock("../useSyncIndicator", () => ({
+  useSyncIndicator: () => ({ syncEnabled: true, state: "synced", conflictCount: 0, pendingMutations: 0 }),
+}));
+vi.mock("react-i18next", () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+vi.mock("../syncLocalApi", () => ({ fetchNoteSyncReceipt: mocks.fetchReceipt }));
+vi.mock("../offlineQueue", () => ({ getQueue: () => [], subscribe: () => () => undefined }));
+vi.mock("../noteSyncReceipt", () => ({
+  NOTE_SYNC_RECEIPT_CHANGED_EVENT: "nowen:note-receipt-changed",
+  getNoteSyncReceipt: () => null, resolveNoteReceiptPhase: () => "unverified",
+}));
+vi.mock("../noteSyncSafety", () => ({ getNoteSyncConflict: () => null }));
+
+import { useNoteSyncReceipt } from "../useNoteSyncReceipt";
+import SyncStatusBadge from "@/components/SyncStatusBadge";
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+function ReceiptText({ noteId }: { noteId: string }) {
+  const phase = useNoteSyncReceipt(noteId, true);
+  return <span role="status">{phase}</span>;
+}
+let root: Root;
+let host: HTMLDivElement;
+beforeEach(() => {
+  mocks.fetchReceipt.mockReset();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  root = createRoot(host);
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+});
+const reply = (phase: string) => ({
+  phase, localRevision: null, acknowledgedRevision: phase === "confirmed" ? 3 : null,
+});
+describe("PR #821 current-note receipt UI after native Outbox commit", () => {
+  it("updates the real editor badge after a committed Android edit", async () => {
+    let pending = false;
+    mocks.fetchReceipt.mockImplementation(async () => reply(pending ? "pending" : "confirmed"));
+    await act(async () => root.render(<SyncStatusBadge noteId="note-a" saving={false} />));
+    expect(host.textContent).toBe("syncBadge.receipt.confirmed");
+    // Emitted after the SQLite write transaction; the previous ACK is stale.
+    pending = true;
+    await act(async () => window.dispatchEvent(new Event(MOBILE_SYNC_STATUS_CHANGED_EVENT)));
+    expect(host.textContent).toBe("syncBadge.receipt.pending");
+  });
+
+  it.each(["Markdown", "rich text"])("invalidates a stale confirmed snapshot for %s editing while ACK is delayed", async () => {
+    let actualOutboxCount = 0;
+    mocks.fetchReceipt.mockImplementation(async () => reply(actualOutboxCount ? "pending" : "confirmed"));
+    await act(async () => root.render(<ReceiptText noteId="note-a" />));
+    expect(host.textContent).toBe("confirmed");
+    // NativeLocalRepository broadcasts this only AFTER its SQLite transaction
+    // has persisted the new note and Outbox mutation, before any push ACK.
+    actualOutboxCount = 1;
+    await act(async () => window.dispatchEvent(new Event(MOBILE_SYNC_STATUS_CHANGED_EVENT)));
+    expect(mocks.fetchReceipt).toHaveBeenLastCalledWith("note-a");
+    expect(host.textContent).toBe("pending");
+    actualOutboxCount = 2;
+    await act(async () => window.dispatchEvent(new Event(MOBILE_SYNC_STATUS_CHANGED_EVENT)));
+    expect(host.textContent).toBe("pending");
+  });
+
+  it("does not repaint an obsolete confirmed query after a newer pending refresh", async () => {
+    const resolvers: Array<(result: ReturnType<typeof reply>) => void> = [];
+    mocks.fetchReceipt.mockImplementation(() => new Promise((resolve) => resolvers.push(resolve)));
+    await act(async () => root.render(<ReceiptText noteId="note-a" />));
+    expect(resolvers).toHaveLength(1);
+    await act(async () => window.dispatchEvent(new Event(MOBILE_SYNC_STATUS_CHANGED_EVENT)));
+    expect(resolvers).toHaveLength(2);
+    await act(async () => resolvers[1](reply("pending")));
+    expect(host.textContent).toBe("pending");
+    await act(async () => resolvers[0](reply("confirmed")));
+    expect(host.textContent).toBe("pending");
+  });
+});
diff --git a/frontend/src/lib/mobileLocalFirstRuntime.ts b/frontend/src/lib/mobileLocalFirstRuntime.ts
index 01f62103e..1603615f6 100644
--- a/frontend/src/lib/mobileLocalFirstRuntime.ts
+++ b/frontend/src/lib/mobileLocalFirstRuntime.ts
@@ -21,6 +21,7 @@ import { createNativeLocalRepository } from "./nativeLocalRepository";
 import { newLocalId, setLocalRepository } from "./localRepository";
 import { clearQueue, getQueue } from "./offlineQueue";
 import { setSyncLocalAdminAdapter, SYNC_CONFLICT_ENTITY_TYPES } from "./syncLocalApi";
+import { readNativeNoteSyncReceipt } from "./mobileNoteSyncReceipt";
 import type { NativeLocalRepository } from "./nativeLocalRepository";
 import {
   MOBILE_LOCAL_ACCOUNT_ID,
@@ -314,6 +315,13 @@ function createNativeAdminAdapter(
     }
     if(path==="/engine"){const state=await repository.sync.getState();return {running:active?.enabled===1,state:state.mode==="server"?(state.conflictCount?"conflict":state.lastError?"error":"idle"):"disabled",pendingCount:state.mode==="server"?state.pendingMutations:0,conflictCount:state.mode==="server"?state.conflictCount:0,lastError:state.mode==="server"?state.lastError:null,localAuthoritative:true} as T;}
     if(path==="/sync-now"&&method==="POST"){engine.requestSync(0);return {engineRunning:active?.enabled===1,message:"已请求立即同步"} as T;}
+    if (method === "GET" && path.startsWith("/receipts/")) {
+      const noteId = decodeURIComponent(path.slice("/receipts/".length));
+      if (!noteId || active?.enabled !== 1) {
+        return { phase: "unverified", localRevision: null, acknowledgedRevision: null } as T;
+      }
+      return await readNativeNoteSyncReceipt(db, profileId, noteId) as T;
+    }
     if(path==="/diagnostics"){
       const state=(await db.query<{lastSequence:number;lastSyncAt:string|null;lastError:string|null}>("SELECT lastSequence,lastSyncAt,lastError FROM sync_state WHERE profileId=? AND scopeKey='personal'",[profileId]))[0];
       const pending=await db.query<Record<string,unknown>>("SELECT scopeKey,entityType,entityId,operation,status,retryCount,lastError,createdAt FROM sync_outbox WHERE profileId=? AND status IN ('pending','failed') ORDER BY createdAt LIMIT 20",[profileId]);
diff --git a/frontend/src/lib/mobileNoteSyncReceipt.ts b/frontend/src/lib/mobileNoteSyncReceipt.ts
new file mode 100644
index 000000000..5f70bf9f3
--- /dev/null
+++ b/frontend/src/lib/mobileNoteSyncReceipt.ts
@@ -0,0 +1,40 @@
+import type { NativeDatabase } from "./nativeDatabase";
+import type { NoteReceiptPhase } from "./noteSyncReceipt";
+
+export interface NativeNoteSyncReceipt {
+  phase: NoteReceiptPhase;
+  localRevision: number | null;
+  acknowledgedRevision: number | null;
+}
+export function nativeReceiptKey(profileId: string, noteId: string): string {
+  return `note-receipt:v1:${profileId}:${noteId}`;
+}
+/** Persisted mutation-specific ACK, scoped to the profile and note. */
+export async function readNativeNoteSyncReceipt(
+  db: NativeDatabase, profileId: string, noteId: string,
+): Promise<NativeNoteSyncReceipt> {
+  const conflicts = await db.query<{ id: string }>(
+    "SELECT id FROM sync_conflicts WHERE profileId=? AND entityType='note' AND entityId=? AND status='unresolved' LIMIT 1",
+    [profileId, noteId],
+  );
+  if (conflicts.length) return { phase: "conflict", localRevision: null, acknowledgedRevision: null };
+  const pending = await db.query<{ status: string; lastError: string | null }>(
+    "SELECT status,lastError FROM sync_outbox WHERE profileId=? AND entityType='note' AND entityId=? AND status IN ('pending','failed','inflight') LIMIT 20",
+    [profileId, noteId],
+  );
+  if (pending.some((row) => row.status === "failed" || !!row.lastError))
+    return { phase: "error", localRevision: null, acknowledgedRevision: null };
+  if (pending.length) return { phase: "pending", localRevision: null, acknowledgedRevision: null };
+  const rows = await db.query<{ value: string }>(
+    "SELECT value FROM native_runtime_meta WHERE key=? LIMIT 1", [nativeReceiptKey(profileId, noteId)],
+  );
+  try {
+    const receipt = rows[0] && JSON.parse(rows[0].value) as { mutationId?: unknown; serverVersion?: unknown };
+    if (typeof receipt?.mutationId === "string" && receipt.mutationId) {
+      const version = typeof receipt.serverVersion === "number" && Number.isSafeInteger(receipt.serverVersion)
+        ? receipt.serverVersion : null;
+      return { phase: "confirmed", localRevision: null, acknowledgedRevision: version };
+    }
+  } catch { /* Corrupt metadata cannot prove an ACK. */ }
+  return { phase: "unverified", localRevision: null, acknowledgedRevision: null };
+}
diff --git a/frontend/src/lib/mobileSyncEngine.ts b/frontend/src/lib/mobileSyncEngine.ts
index d12e771e2..063b6964f 100644
--- a/frontend/src/lib/mobileSyncEngine.ts
+++ b/frontend/src/lib/mobileSyncEngine.ts
@@ -6,6 +6,7 @@ import { fetchWithAuthRefresh, getAccessToken } from "./authSession";
 import { SERVER_ENDPOINT_CHANGED_EVENT } from "./serverEndpointState";
 import { forgetUnsentLocalNotes } from "./nativeLocalNoteOrigin";
 import { notifyMobileSyncStatusChanged } from "./mobileSyncStatus";
+import { nativeReceiptKey } from "./mobileNoteSyncReceipt";
 import { validateEncryptedNoteWrite } from "./encryptedNotes/noteDocument";
 
 type ScopeStatus = "active" | "replan_required" | "access_revoked";
@@ -59,6 +60,34 @@ function stable(value: unknown): string {
   return JSON.stringify(value) ?? "undefined";
 }
 
+/** Fail closed: a same-number remote edit is not proof of a local echo.
+ * Only a recorded mutation-specific server ACK may establish provenance. */
+export function isAckedOwnNoteEcho(
+  remote: Record<string, unknown>,
+  local: Record<string, unknown>,
+  pending: { payload: string | null; baseVersion?: number | null },
+  storedReceipt: string | undefined,
+): boolean {
+  if (!storedReceipt) return false;
+  try {
+    const receipt: unknown = JSON.parse(storedReceipt);
+    if (!receipt || typeof receipt !== "object") return false;
+    const { mutationId, serverVersion } = receipt as { mutationId?: unknown; serverVersion?: unknown };
+    const validVersion = (value: unknown): value is number =>
+      typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+    if (typeof mutationId !== "string" || !mutationId ||
+        !validVersion(serverVersion) || !validVersion(remote.version) ||
+        !validVersion(local.version)) return false;
+    if (remote.version !== serverVersion || local.version <= serverVersion) return false;
+    // A newer queued edit must be based on (or later than) the confirmed
+    // version. Missing/older bases might be a genuine concurrent conflict.
+    if (!validVersion(pending.baseVersion) || pending.baseVersion < serverVersion) return false;
+    const payload: unknown = pending.payload ? JSON.parse(pending.payload) : null;
+    return !!payload && typeof payload === "object" &&
+      (payload as { version?: unknown }).version === local.version;
+  } catch { return false; }
+}
+
 function isCoreEntityType(value:unknown):value is EntityType {
   return value === "notebook" || value === "note" || value === "tag"
     || value === "note_tag" || value === "favorite" || value === "attachment"
@@ -481,7 +510,7 @@ export class MobileSyncEngine {
     // 请求即使超时也可能已被服务器接收，不能继续把该笔记当作“确定未同步”。
     const noteIds = rows.filter((row) => row.entityType === "note").map((row) => row.entityId);
     if (noteIds.length) await this.options.db.transaction((tx) => forgetUnsentLocalNotes(tx, scope.scopeKey, noteIds));
-    const response = await this.request<{ serverSequence:number;results:Array<{mutationId:string;status:string;code?:string;serverVersion?:number;serverPayload?:Record<string,unknown>}> }>(
+    const response = await this.request<{ serverSequence:number;results:Array<{mutationId:string;status:string;code?:string;version?:number;serverVersion?:number;serverPayload?:Record<string,unknown>}> }>(
       `/push?scopeKey=${encodeURIComponent(scope.scopeKey)}`,
       { method:"POST",body:JSON.stringify({scopeKey:scope.scopeKey,deviceId:this.options.deviceId,mutations}) },
     );
@@ -497,6 +526,17 @@ export class MobileSyncEngine {
         const source = rows.find((row) => row.mutationId===result.mutationId);
         if (result.status === "applied" || result.status === "duplicate") {
           await tx.run("DELETE FROM sync_outbox WHERE mutationId=?",[result.mutationId]);
+          if (source?.entityType === "note" && source.operation === "upsert") {
+            // Persist the mutation-specific ACK atomically with the Outbox removal.
+            await tx.run(`INSERT INTO native_runtime_meta (key,value,updatedAt) VALUES (?,?,?)
+              ON CONFLICT(key) DO UPDATE SET value=excluded.value,updatedAt=excluded.updatedAt`, [
+              nativeReceiptKey(this.options.profileId, source.entityId),
+              JSON.stringify({ mutationId: result.mutationId,
+                serverVersion: typeof result.version === "number" && Number.isSafeInteger(result.version) && result.version > 0
+                  ? result.version : null }),
+              now(),
+            ]);
+          }
           if (source?.entityType === "attachment" && source.operation === "delete") {
             await this.options.attachments.remove(source.entityId).catch(() => undefined);
           }
@@ -583,11 +623,22 @@ export class MobileSyncEngine {
             WHERE id=?`,[JSON.stringify(entry.payload),Number(entry.payload.version)||null,conflict.id]);
           continue;
         }
-        const pending=(await tx.query<{payload:string|null}>(`SELECT payload FROM sync_outbox WHERE
+        const pending=(await tx.query<{payload:string|null;baseVersion:number|null}>(`SELECT payload,baseVersion FROM sync_outbox WHERE
           profileId=? AND scopeKey=? AND entityType=? AND entityId=? AND status IN ('pending','failed','inflight') LIMIT 1`,
         [this.options.profileId,scope.scopeKey,entry.entityType,entry.entityId]))[0];
         if(pending&&!entry.payload.__delete){
           const local=await this.readEntity(tx,scope.scopeKey,entry.entityType,entry.entityId);
+          if (!bootstrap && entry.entityType === "note" && local) {
+            // A previous mutation from THIS profile was already acknowledged,
+            // and the pull sees that exact server version while a newer local
+            // edit waits in Outbox. This is our own echo, not a true conflict.
+            // Keep the newer local body and queued mutation untouched.
+            const receipt = (await tx.query<{value:string}>(
+              "SELECT value FROM native_runtime_meta WHERE key=? LIMIT 1",
+              [nativeReceiptKey(this.options.profileId, entry.entityId)],
+            ))[0];
+            if (isAckedOwnNoteEcho(entry.payload, local, pending, receipt?.value)) continue;
+          }
           if(!bootstrap||stable(local)!==stable(entry.payload)){
             await tx.run(`INSERT INTO sync_conflicts (id,profileId,scopeKey,entityType,entityId,
               localPayload,remotePayload,status,createdAt) VALUES (?,?,?,?,?,?,?,'unresolved',?)`,[
diff --git a/frontend/src/lib/nativeLocalRepository.ts b/frontend/src/lib/nativeLocalRepository.ts
index d6a631c8b..a526824b8 100644
--- a/frontend/src/lib/nativeLocalRepository.ts
+++ b/frontend/src/lib/nativeLocalRepository.ts
@@ -10,6 +10,7 @@ import type { NativeDatabase } from "./nativeDatabase";
 import type { NativeAttachmentStore } from "./nativeAttachmentStore";
 import { newLocalId } from "./localRepository";
 import { unsentLocalNoteKey } from "./nativeLocalNoteOrigin";
+import { notifyMobileSyncStatusChanged } from "./mobileSyncStatus";
 import { isEncryptedNoteFormat, validateEncryptedNoteWrite } from "./encryptedNotes/noteDocument";
 
 type EntityType = "notebook" | "note" | "tag" | "note_tag" | "favorite" | "attachment";
@@ -228,6 +229,7 @@ export class NativeLocalRepository implements LocalRepository {
         await this.enqueue(tx,"note",note.id,"delete",undefined,note.version,scopeKey);
       }
     });
+    if (notes.length) notifyMobileSyncStatusChanged();
     await Promise.all(attachments.map(({id})=>this.attachmentStore.remove(id).catch(()=>undefined)));
     for(const {id} of attachments)this.attachmentUrls.delete(id);
     return {success:true,count:notes.length,skipped:0,noteIds:notes.map(({id})=>id),removedFiles:attachments.length};
@@ -416,6 +418,8 @@ export class NativeLocalRepository implements LocalRepository {
         ON CONFLICT(key) DO UPDATE SET value=excluded.value,updatedAt=excluded.updatedAt`, [unsentLocalNoteKey(scope.scopeKey, input.id), savedAt]);
       await this.enqueue(tx, "note", input.id, "upsert", row);
     });
+    // The receipt is invalidated only after the SQLite Outbox transaction commits.
+    notifyMobileSyncStatusChanged();
     return { id: input.id, savedAt };
   }
 
@@ -441,6 +445,8 @@ export class NativeLocalRepository implements LocalRepository {
       if (encrypted && changed.changes !== 1) throw Object.assign(new Error("笔记版本已改变"), { status: 409, code: "VERSION_CONFLICT" });
       await this.enqueue(tx, "note", id, "upsert", next as unknown as Record<string, unknown>, current.version);
     });
+    // Refresh per-note receipt from committed Outbox, even while a push is in flight.
+    notifyMobileSyncStatusChanged();
     return { id, savedAt: next.updatedAt };
   }
 
@@ -454,6 +460,7 @@ export class NativeLocalRepository implements LocalRepository {
       await tx.run("DELETE FROM native_runtime_meta WHERE key=?", [unsentLocalNoteKey(scope.scopeKey, id)]);
       await this.enqueue(tx, "note", id, "delete", undefined, current?.version ?? null);
     });
+    notifyMobileSyncStatusChanged();
   }
 
   private async listNotebooks(requestedScopeKey?: string): Promise<Notebook[]> {
diff --git a/frontend/src/lib/noteSyncReceipt.ts b/frontend/src/lib/noteSyncReceipt.ts
new file mode 100644
index 000000000..fc8b17245
--- /dev/null
+++ b/frontend/src/lib/noteSyncReceipt.ts
@@ -0,0 +1,112 @@
+/**
+ * Per-note Sync Receipt. Metadata only: no note bodies or credentials.
+ * Logical revisions are monotonic per scoped browser account/server.
+ */
+import { getOfflineQueueStorageKey } from "./offlineScope";
+import { isNativeClientRuntime } from "./serverUrl";
+
+export type NoteReceiptPhase = "unverified" | "saving" | "pending" | "confirmed" | "conflict" | "error";
+export interface NoteSyncReceipt {
+  noteId: string;
+  localRevision: number;
+  acknowledgedRevision: number;
+  acknowledgedVersion: number | null;
+  phase: NoteReceiptPhase;
+  updatedAt: number;
+}
+export const NOTE_SYNC_RECEIPT_CHANGED_EVENT = "nowen:note-sync-receipt-changed";
+const PREFIX = "nowen-note-sync-receipts:v1:";
+const MAX_RECORDS = 128;
+const storageKey = () => PREFIX + getOfflineQueueStorageKey();
+
+function readAll(): Record<string, NoteSyncReceipt> {
+  try {
+    const data: unknown = JSON.parse(localStorage.getItem(storageKey()) || "{}");
+    return data && typeof data === "object" && !Array.isArray(data)
+      ? data as Record<string, NoteSyncReceipt> : {};
+  } catch { return {}; }
+}
+export function getNoteSyncReceipt(noteId: string): NoteSyncReceipt | null {
+  const row = readAll()[noteId];
+  return row && row.noteId === noteId &&
+    Number.isSafeInteger(row.localRevision) && Number.isSafeInteger(row.acknowledgedRevision)
+    ? row : null;
+}
+function mutate(noteId: string, update: (old: NoteSyncReceipt) => NoteSyncReceipt): NoteSyncReceipt {
+  const all = readAll();
+  const previous = getNoteSyncReceipt(noteId) || {
+    noteId, localRevision: 0, acknowledgedRevision: 0,
+    acknowledgedVersion: null, phase: "unverified" as const, updatedAt: 0,
+  };
+  const next = { ...update(previous), updatedAt: Date.now() };
+  try {
+    all[noteId] = next;
+    const entries = Object.values(all)
+      .filter((entry) => entry && typeof entry.noteId === "string")
+      .sort((a, b) => b.updatedAt - a.updatedAt).slice(0, MAX_RECORDS);
+    localStorage.setItem(storageKey(), JSON.stringify(Object.fromEntries(
+      entries.map((entry) => [entry.noteId, entry]),
+    )));
+    if (typeof window !== "undefined") window.dispatchEvent(new CustomEvent(NOTE_SYNC_RECEIPT_CHANGED_EVENT, {
+      detail: { noteId },
+    }));
+  } catch {
+    // No durable receipt if storage fails. Consumers re-read and stay unverified.
+  }
+  return next;
+}
+export function beginNoteReceiptWrite(noteId: string): number {
+  return mutate(noteId, (old) => ({
+    ...old, localRevision: old.localRevision + 1, phase: "saving",
+  })).localRevision;
+}
+export function markNoteReceiptPending(noteId: string, revision?: number | null, conflict = false): void {
+  mutate(noteId, (old) => revision != null && revision !== old.localRevision
+    ? old : { ...old, phase: conflict ? "conflict" : "pending" });
+}
+export function markNoteReceiptError(noteId: string, revision?: number | null): void {
+  mutate(noteId, (old) => revision != null && revision !== old.localRevision
+    ? old : { ...old, phase: "error" });
+}
+/** Valid only for the exact in-flight revision, with a positive server version. */
+export function acknowledgeNoteReceipt(noteId: string, revision: number, serverVersion: number): boolean {
+  if (!Number.isSafeInteger(serverVersion) || serverVersion < 1) return false;
+  const old = getNoteSyncReceipt(noteId);
+  if (!old || old.localRevision !== revision) return false;
+  mutate(noteId, (current) => current.localRevision !== revision ? current : ({
+    ...current, acknowledgedRevision: revision,
+    acknowledgedVersion: serverVersion, phase: "confirmed",
+  }));
+  return true;
+}
+export interface NoteReceiptQueueEntry {
+  noteId: string;
+  conflict?: boolean;
+  blocked?: boolean;
+  errorCode?: string;
+}
+export function resolveNoteReceiptPhase(
+  receipt: NoteSyncReceipt | null,
+  queue: readonly NoteReceiptQueueEntry[],
+): NoteReceiptPhase {
+  if (queue.some((item) => item.conflict || item.errorCode === "VERSION_CONFLICT")) return "conflict";
+  if (queue.some((item) => item.blocked || item.errorCode)) return "error";
+  if (queue.length) return "pending";
+  if (!receipt) return "unverified";
+  // A crashed/incomplete save is never proof of local durability or remote ACK.
+  if (receipt.phase === "saving") return "unverified";
+  if (receipt.phase === "confirmed" && receipt.acknowledgedRevision === receipt.localRevision &&
+      receipt.acknowledgedVersion !== null) return "confirmed";
+  if (receipt.phase === "pending" || receipt.phase === "conflict" || receipt.phase === "error")
+    return receipt.phase;
+  return "unverified";
+}
+
+/** A Native/Electron REST write may reach only local SQLite, never the cloud. */
+export function acknowledgeRestNoteReceipt(
+  noteId: string, revision: number, serverVersion: number, hasContentSnapshot: boolean,
+): boolean {
+  // CRDT/metadata-only REST updates do not prove the editor body reached the cloud.
+  return hasContentSnapshot && !isNativeClientRuntime() &&
+    acknowledgeNoteReceipt(noteId, revision, serverVersion);
+}
diff --git a/frontend/src/lib/noteSyncSafety.ts b/frontend/src/lib/noteSyncSafety.ts
index 387b09f04..0631749cf 100644
--- a/frontend/src/lib/noteSyncSafety.ts
+++ b/frontend/src/lib/noteSyncSafety.ts
@@ -10,6 +10,7 @@ import {
 } from "@/lib/offlineRead";
 import { dequeue, enqueue, getQueue, updateItem } from "@/lib/offlineQueue";
 import { saveDraft } from "@/lib/draftStorage";
+import { beginNoteReceiptWrite, acknowledgeRestNoteReceipt, markNoteReceiptPending, markNoteReceiptError } from "@/lib/noteSyncReceipt";
 
 const INSTALL_KEY = "__NOWEN_NOTE_SYNC_SAFETY_V1__" as const;
 const CONFLICT_STORAGE_KEY = "nowen-note-sync-conflicts:v1";
@@ -282,6 +283,7 @@ function preserveConflict(
   persistLocalDraft(noteId, data, baseVersion, { serverVersion: record.serverVersion });
   upsertConflictQueueItem(noteId, data, record.serverVersion);
   recordNoteSyncConflict(record);
+  markNoteReceiptPending(noteId, null, true);
   return record;
 }
 
@@ -341,14 +343,16 @@ export function installNoteSyncSafety(): void {
     baseVersion: number,
     server: Note,
     conflict: boolean,
+    receiptRevision?: number | null,
   ): PendingNote {
+    markNoteReceiptPending(noteId, receiptRevision, conflict);
     persistLocalDraft(noteId, data, baseVersion, conflict ? { serverVersion: server.version } : undefined);
     restorePendingDraft(noteId, data, baseVersion, conflict, server.version);
     dispatchPending(noteId, baseVersion, { conflict, serverVersion: server.version });
     return makePendingNote(server, data);
   }
 
-  async function retryOnFreshVersion(noteId: string, data: NoteMutation, fresh: Note): Promise<Note | null> {
+  async function retryOnFreshVersion(noteId: string, data: NoteMutation, fresh: Note, receiptRevision?: number | null): Promise<Note | null> {
     try {
       const updated = await originalUpdateNote(noteId, { ...data, version: fresh.version } as Partial<Note>);
       if (!isCompleteNote(updated, noteId) || !isServerConfirmedNoteWrite(fresh.version, updated.version)) {
@@ -357,6 +361,7 @@ export function installNoteSyncSafety(): void {
       clearOfflineNoteSnapshot(noteId);
       clearResolvedConflictArtifacts(noteId);
       rememberConfirmedNote(updated, noteId);
+      if (receiptRevision != null) acknowledgeRestNoteReceipt(noteId, receiptRevision, updated.version, typeof data.content === "string");
       return updated;
     } catch {
       return null;
@@ -382,6 +387,8 @@ export function installNoteSyncSafety(): void {
       );
     }
 
+    const receiptRevision = versioned ? beginNoteReceiptWrite(noteId) : null;
+
     if (versioned && !resolvingNoteIds.has(noteId) && hasPendingNoteSyncConflict(noteId)) {
       let server = confirmedNotes.get(noteId) || null;
       if (!server) {
@@ -398,7 +405,7 @@ export function installNoteSyncSafety(): void {
       if (!server) {
         throw syncError("REMOTE_BASE_UNVERIFIED", "无法确认服务端最新版本，已保留本地草稿并阻止覆盖。");
       }
-      return completePendingResponse(noteId, data, baseVersion, server, true);
+      return completePendingResponse(noteId, data, baseVersion, server, true, receiptRevision);
     }
 
     if (versioned) persistLocalDraft(noteId, data, baseVersion);
@@ -409,13 +416,13 @@ export function installNoteSyncSafety(): void {
       const fresh = await fetchCurrentServerNote(noteId);
       if (!fresh) {
         preserveConflict(noteId, data, baseVersion, previousConfirmed, "REMOTE_BASE_UNVERIFIED");
-        if (previousConfirmed) return completePendingResponse(noteId, data, baseVersion, previousConfirmed, true);
+        if (previousConfirmed) return completePendingResponse(noteId, data, baseVersion, previousConfirmed, true, receiptRevision);
         throw syncError("REMOTE_BASE_UNVERIFIED", "无法确认服务端最新版本，已保留本地草稿并阻止覆盖。");
       }
 
       if (isCurrentlyOffline()) {
         preserveConflict(noteId, data, baseVersion, fresh, "REMOTE_BASE_UNVERIFIED");
-        return completePendingResponse(noteId, data, baseVersion, fresh, true);
+        return completePendingResponse(noteId, data, baseVersion, fresh, true, receiptRevision);
       }
 
       clearOfflineNoteSnapshot(noteId);
@@ -427,15 +434,16 @@ export function installNoteSyncSafety(): void {
         if (mutationMatchesNote(fresh, data)) {
           clearResolvedConflictArtifacts(noteId);
           rememberConfirmedNote(fresh, noteId);
+          if (receiptRevision != null) acknowledgeRestNoteReceipt(noteId, receiptRevision, fresh.version, typeof data.content === "string");
           return fresh;
         }
         if (previousConfirmed && noteBodiesEqual(fresh, previousConfirmed)) {
-          const retried = await retryOnFreshVersion(noteId, data, fresh);
+          const retried = await retryOnFreshVersion(noteId, data, fresh, receiptRevision);
           if (retried) return retried;
         }
         preserveConflict(noteId, data, baseVersion, fresh, "STALE_OFFLINE_BASE");
         confirmedNotes.set(noteId, fresh);
-        return completePendingResponse(noteId, data, baseVersion, fresh, true);
+        return completePendingResponse(noteId, data, baseVersion, fresh, true, receiptRevision);
       }
     }
 
@@ -446,7 +454,8 @@ export function installNoteSyncSafety(): void {
         persistLocalDraft(noteId, data, baseVersion);
         markOfflineNoteSnapshot({ id: noteId, version: baseVersion, updatedAt: updated?.updatedAt });
         const server = previousConfirmed || (isCompleteNote(updated, noteId) ? updated : null);
-        if (server) return completePendingResponse(noteId, data, baseVersion, server, false);
+        if (server) return completePendingResponse(noteId, data, baseVersion, server, false, receiptRevision);
+        markNoteReceiptPending(noteId, receiptRevision);
         dispatchPending(noteId, baseVersion, { responseIncomplete: true });
         const error = syncError("OFFLINE_WRITE_QUEUED", "修改已保存在本地并等待上传，尚未得到服务端确认。") as any;
         error.queued = true;
@@ -456,19 +465,24 @@ export function installNoteSyncSafety(): void {
       clearOfflineNoteSnapshot(noteId);
       clearResolvedConflictArtifacts(noteId);
       rememberConfirmedNote(updated, noteId);
+      if (receiptRevision != null) acknowledgeRestNoteReceipt(noteId, receiptRevision, updated.version, typeof data.content === "string");
       return updated;
     } catch (error: any) {
-      if (error?.status !== 409 && error?.code !== "VERSION_CONFLICT") throw error;
+      if (error?.status !== 409 && error?.code !== "VERSION_CONFLICT") {
+        if (receiptRevision != null) markNoteReceiptError(noteId, receiptRevision);
+        throw error;
+      }
 
       const fresh = await fetchCurrentServerNote(noteId);
       if (fresh && mutationMatchesNote(fresh, data)) {
         clearOfflineNoteSnapshot(noteId);
         clearResolvedConflictArtifacts(noteId);
         rememberConfirmedNote(fresh, noteId);
+        if (receiptRevision != null) acknowledgeRestNoteReceipt(noteId, receiptRevision, fresh.version, typeof data.content === "string");
         return fresh;
       }
       if (fresh && previousConfirmed && noteBodiesEqual(fresh, previousConfirmed)) {
-        const retried = await retryOnFreshVersion(noteId, data, fresh);
+        const retried = await retryOnFreshVersion(noteId, data, fresh, receiptRevision);
         if (retried) return retried;
       }
 
@@ -483,7 +497,7 @@ export function installNoteSyncSafety(): void {
       }
       if (server) {
         if (fresh) confirmedNotes.set(noteId, fresh);
-        return completePendingResponse(noteId, data, baseVersion, server, true);
+        return completePendingResponse(noteId, data, baseVersion, server, true, receiptRevision);
       }
       throw syncError("REMOTE_BASE_UNVERIFIED", "无法确认服务端最新版本，已保留本地草稿并阻止覆盖。");
     }
diff --git a/frontend/src/lib/offlineQueue.ts b/frontend/src/lib/offlineQueue.ts
index bc831fb34..beecfcc36 100644
--- a/frontend/src/lib/offlineQueue.ts
+++ b/frontend/src/lib/offlineQueue.ts
@@ -11,6 +11,7 @@ import { getOfflineQueueStorageKey, STORAGE_KEY_PREFIX } from "./offlineScope";
 export { getOfflineQueueStorageKey } from "./offlineScope";
 import { assertConversionMutation } from "./encryptedNotes/conversionBarrier";
 import { CONVERSION_REPLAY_LOCK, ConversionCleanupError } from "./encryptedNotes/conversionCoordination";
+import { getNoteSyncReceipt, acknowledgeRestNoteReceipt } from "./noteSyncReceipt";
 
 export type OfflineMutationType = "createNote" | "updateNote" | "deleteNote";
 
@@ -470,6 +471,7 @@ async function flushQueueInternal(fetchFn: OfflineQueueFetch): Promise<FlushResu
       }
 
       try {
+        const receiptRevision = getNoteSyncReceipt(item.noteId)?.localRevision ?? 0;
         const replayBody = item.type === "createNote" && item.body && !item.body.id && !item.noteId.startsWith("local-")
           ? { ...item.body, id: item.noteId }
           : item.body;
@@ -480,11 +482,23 @@ async function flushQueueInternal(fetchFn: OfflineQueueFetch): Promise<FlushResu
         assertScope();
 
         if (response.ok) {
-          if (item.type === "createNote" && item.noteId.startsWith("local-") && response.data?.id) {
+          // A new edit can replace the same queued item while its previous
+          // payload is in flight. Never dequeue or ACK the newer snapshot.
+          const removal = discardResolvedQueueItems(item);
+          if (removal.discarded && item.type === "createNote" &&
+              item.noteId.startsWith("local-") && response.data?.id) {
             setLocalIdMapping(item.noteId, response.data.id);
           }
-          dequeue(item.id);
-          result.success += 1;
+          if (removal.discarded && !removal.remainingForNote && item.type !== "deleteNote") {
+            const version = response.data?.version;
+            const baseVersion = Number(item.body?.version);
+            const verified = item.type === "createNote"
+              ? typeof version === "number" && Number.isSafeInteger(version) && version > 0
+              : Number.isFinite(baseVersion) && typeof version === "number" &&
+                Number.isSafeInteger(version) && version > baseVersion;
+            if (verified) acknowledgeRestNoteReceipt(item.noteId, receiptRevision, version, typeof item.body?.content === "string");
+          }
+          if (removal.discarded) result.success += 1;
           continue;
         }
 
diff --git a/frontend/src/lib/syncLocalApi.ts b/frontend/src/lib/syncLocalApi.ts
index 9457ce91c..1beedd9c7 100644
--- a/frontend/src/lib/syncLocalApi.ts
+++ b/frontend/src/lib/syncLocalApi.ts
@@ -302,6 +302,11 @@ export function disableSync(): Promise<{
   return request("/settings/disable", { method: "POST" });
 }
 
+/** Only the Android Native adapter handles this local SQLite endpoint. */
+export function fetchNoteSyncReceipt(noteId: string): Promise<import("./mobileNoteSyncReceipt").NativeNoteSyncReceipt> {
+  return request(`/receipts/${encodeURIComponent(noteId)}`);
+}
+
 export function fetchSyncDiagnostics(): Promise<SyncDiagnostics> {
   return request<SyncDiagnostics>("/diagnostics");
 }
diff --git a/frontend/src/lib/useNoteSyncReceipt.ts b/frontend/src/lib/useNoteSyncReceipt.ts
new file mode 100644
index 000000000..19bfbdc61
--- /dev/null
+++ b/frontend/src/lib/useNoteSyncReceipt.ts
@@ -0,0 +1,45 @@
+import { useEffect, useState } from "react";
+import { getNoteSyncReceipt, NOTE_SYNC_RECEIPT_CHANGED_EVENT, resolveNoteReceiptPhase, type NoteReceiptPhase } from "./noteSyncReceipt";
+import { getQueue, subscribe } from "./offlineQueue";
+import { getNoteSyncConflict } from "./noteSyncSafety";
+import { isAndroidNativeRuntime } from "./mobileLocalMode";
+import { MOBILE_SYNC_STATUS_CHANGED_EVENT } from "./mobileSyncStatus";
+import { fetchNoteSyncReceipt } from "./syncLocalApi";
+
+/** No aggregate "synced" or lastSyncAt may confirm an individual note. */
+export function useNoteSyncReceipt(noteId?: string, syncEnabled = false): NoteReceiptPhase {
+  const [snapshot, setSnapshot] = useState<{ noteId?: string; phase: NoteReceiptPhase }>({ phase: "unverified" });
+  const setPhase = (phase: NoteReceiptPhase) => setSnapshot({ noteId, phase });
+  useEffect(() => {
+    if (!noteId || !syncEnabled) { setPhase("unverified"); return; }
+    let disposed = false;
+    let requestId = 0;
+    const refresh = () => {
+      if (isAndroidNativeRuntime()) {
+        const current = ++requestId;
+        void fetchNoteSyncReceipt(noteId).then((receipt) => {
+          if (!disposed && requestId === current) setPhase(receipt.phase);
+        }).catch(() => {
+          if (!disposed && requestId === current) setPhase("unverified");
+        });
+        return;
+      }
+      const queue = getQueue().filter((item) => item.noteId === noteId);
+      const next = resolveNoteReceiptPhase(getNoteSyncReceipt(noteId), queue);
+      setPhase(getNoteSyncConflict(noteId) ? "conflict" : next);
+    };
+    refresh();
+    const unsubscribe = subscribe(refresh);
+    const onReceipt = (event: Event) => {
+      if ((event as CustomEvent<{ noteId: string }>).detail?.noteId === noteId) refresh();
+    };
+    window.addEventListener(NOTE_SYNC_RECEIPT_CHANGED_EVENT, onReceipt);
+    window.addEventListener(MOBILE_SYNC_STATUS_CHANGED_EVENT, refresh);
+    return () => {
+      disposed = true; ++requestId; unsubscribe();
+      window.removeEventListener(NOTE_SYNC_RECEIPT_CHANGED_EVENT, onReceipt);
+      window.removeEventListener(MOBILE_SYNC_STATUS_CHANGED_EVENT, refresh);
+    };
+  }, [noteId, syncEnabled]);
+  return syncEnabled && snapshot.noteId === noteId ? snapshot.phase : "unverified";
+}