Conflict & Health
How memrynote handles conflicting edits across devices, and where to see sync health.
Conflict Resolution
| Domain | Strategy |
|---|---|
| Notes & journal entries | CRDT (Yjs) — concurrent edits merge automatically |
| Tasks & projects | Field-level vector clocks — non-overlapping edits merge cleanly; same-field collisions resolve last-writer-wins by tick-sum |
| Settings | Per-setting vector clocks — different settings merge cleanly; the same setting changed on two devices ends on one value |
| Inbox items, templates | Doc-level vector clocks — last writer wins on conflict |
CRDT Merging (Notes / Journals)
Yjs is commutative — two devices typing different paragraphs in the same note merge without losing either side. Even concurrent edits to the same paragraph merge into a sensible result.
You don't see conflict UI for notes because there's nothing to resolve.
A Note Deleted on Another Device
When you delete a note or a journal day on one device, the delete wins everywhere. If another device holds text for that note that never reached the first device, such as edits made offline, that device saves the text to your Inbox before it removes the note. The copy is titled <note title> (kept from deleted note) or Journal <date> (kept from deleted day). This also covers a delete made while the deleting device was offline: text another device synced in the meantime is kept, even if the delete reaches the server hours later. File it as a note, or archive it if you don't need it. A note you delete after all devices have synced makes no copy.
Field-Level Merge (Tasks / Projects)
Each field on a task or project carries its own vector clock. Examples:
- Device A changes due date; Device B changes priority. Both apply.
- Both devices change status. The higher tick-sum wins; ties favor the remote write deterministically.
This is much friendlier than naive last-writer-wins on the whole record.
Synced Settings
Each synced setting (theme, font, journal template per weekday, and so on) carries its own vector clock, keyed by the device that changed it. Device A changing the theme and Device B changing the language both apply. When both devices change the same setting without having seen each other's change, one value wins, and the device that merged queues the merged settings straight back for push so both devices end on that value.
Doc-Level Conflicts
For inbox items, templates, tags, folders, bookmarks, saved filters, reminders, and note / journal metadata (title, emoji, path, tags — not the text), a same-record concurrent change resolves with a single doc-level vector clock. When both devices changed the record without having seen each other's change, the incoming remote record is written over the local one, the two clocks are merged, and the merged record is queued straight back for push so the other device converges on the same result.
That all happens inside the pull. Nothing stops to ask you.
What You Actually See
Nothing. A conflict is already resolved when the app learns about it: the winning version is written to your local database and queued back for push. The sync status menu shows no conflict notice, there is no marker on the affected note or task, and there is no compare view. Sync History does not list conflicts either — it records pushes, pulls, and errors.
Each merge is written to the app's diagnostic log with the item's id and type, so a bug report can show that one happened. That log is for support, not a list you browse.
What "Resolved" Means for Your Data
Auto-resolved is not the same as auto-merged. CRDT text keeps both sides. Everywhere else, resolving means picking a winner, and the losing version is overwritten in place.
| Your item | How it resolves | What you can lose |
|---|---|---|
| Note & journal text | Yjs merges both sides | Nothing — both edits survive |
| Tasks & projects | Per field, the higher clock tick-sum wins. On an exact tie with differing values the remote value wins, unless your local edit was made offline | The losing value on a tied field — you set priority High here, and it comes back Low |
| Note / journal metadata, inbox items, templates, tags, folders, bookmarks, filters, reminders | The remote record overwrites the local one and the clocks merge | Your local change to those fields |
| Canvases | Neither side is dropped — the other version lands as a conflict copy | Nothing; you end up with a second canvas |
There is nothing to act on when a conflict resolves, which is why the app does not warn you. If a value you set came back different, see Recovering an Overwritten Edit.
Sync History
A record of recent sync runs, stored in the local database:
- Pushes (item count, duration)
- Pulls (item count, duration)
- Errors (with the failure message)
It does not record conflicts, auth events, or links to affected items.
There is currently no panel for it in the app. Read it from the CLI:
memrynote sync history --limit 20The log is cleared when you sign out of sync; it is not aged out on a timer.
Has a Note Reached the Server?
A note's text travels separately from its title, tags, and properties, so the last-synced time alone cannot say whether your latest edit left the device. Hover the outline rail on the right of a note or journal day and look at the Sync line under the dates. A note without headings has no rail; hover the small dot in its place instead. The panel shows from the medium window width up:
| Sync line | Meaning |
|---|---|
| On the server time | Nothing is waiting, and the server stored this note's text at that time |
| Waiting since time | This device has changes to the note that have not been sent yet |
| Sending | A push is out and the server has not answered yet |
| The server refused the last change | The server turned down the latest push for good; those changes are not on the server |
| Nothing waiting to send | No change is waiting, but this device has not seen the server store the note's text since the update that added this line |
| Local only / Not syncing | The note is marked local-only, or this device does not sync |
Only the server's answer to a text push counts as On the server. A push the server reports as already seen does not. After a refused push, the note keeps saying so even when later edits go through, because those edits carry only themselves. Memry sends the note's whole text on its own within two minutes. Once the server stores that copy, the line says On the server again.
Settings → Account → Sync → Notes with unsent changes lists every note in the vault with changes the server has not stored: queued text (Text), queued title, tag, or property changes (Details), a file whose text the synced note has not taken in yet (File not merged yet, which includes notes the first launch after an update found out of step), and refused pushes. The list is hidden when nothing is waiting.
Agents get the same answer as a sync field on vault_read_note, vault_search_notes, vault_list_folder, vault_get_journal_entry, and vault_list_journal_entries; see Agent MCP.
Health View
The Inbox → Health tab shows:
- Failed sync jobs with retry buttons
- Items with broken source URLs
- Items missing required fields
- Low-storage warnings (if approaching the vault quota)
This is the actionable punch list — fix everything here and sync should be clean.
Common Sync Errors
| Error | Likely cause | Fix |
|---|---|---|
| "Authentication expired" | The server rejected this device's session for good. Network errors never cause it | Sign in again with your email code; a device that kept its keys does not need the recovery phrase |
| "Sync paused: device keys missing" | This device signed in without finishing its key setup, so its changes are not uploading | Choose Repair in the sync menu. If the device still holds its keys, sync resumes. Otherwise you sign in again, and may need your recovery phrase. Edits and deletes you make in the meantime are kept and upload once sync resumes. If this vault belongs to another account, Repair restores the keys but the vault stays local on this device |
| "Quota exceeded" | Vault size hit storage limit | Upgrade plan or clean attachments |
| "note name is too large to sync" | That note's encrypted sync payload is over the per-note limit — a payload problem, not account storage | Split the note into smaller notes, or move large pasted content into attachments; other notes keep syncing |
| "Network unreachable" | Offline | Reconnect; sync auto-resumes |
| "Server temporarily unavailable" | Cloudflare hiccup | Wait; backoff retries automatically |
| "Blob hash mismatch" | Corruption (rare) | Push the affected item again from the source device |
| "Crypto version mismatch" | Sync server behind a desktop release | Wait for server to update or downgrade desktop |
| "All items failed to decrypt" | This device's vault key no longer matches the account | The app signs you out and prompts recovery — sign in and enter your recovery phrase; your server data is intact |
When a Note Gets Too Big to Sync
A note body has its own size ceiling, separate from your plan's storage quota and separate from the per-file limit that governs attachments. Past roughly 3.7 MB of text, a note's sync payload no longer fits in a single request and that note stops syncing. Every other note keeps syncing normally.
A lower ceiling of about 900 KB of encrypted state applies while this device still has to merge changes another device made to that note. A large note can hit it briefly; it shows the same error and syncs once the merge finishes.
This used to be silent. It is not any more:
- Before it breaks. Settings → Vault → Notes near the sync limit lists any note that is close to the ceiling, with its name, its location in the vault, and its size. A note marked Approaching the limit still syncs. The section is hidden entirely when no note is near the ceiling, which is the normal case.
- When it breaks. The note is named in the error, so you know which one to split, and it is marked Not syncing in the same list.
- In an existing vault. A note that was already over the ceiling shows up in that list too, rather than staying quietly broken.
The fix is to split the note, or move the bulk of it out — a large pasted log or transcript usually belongs in an attachment rather than in the note body. Nothing is lost while a note is over the ceiling: the text is safe on the device you typed it on, and it syncs again once the note is small enough.
Recovering an Overwritten Edit
There is no undo for an auto-resolved conflict, and no conflict list in the app to read back. What you can do:
- Note and journal text — Version history keeps snapshots, so you can open the timeline and restore. Versions are local to each device, so look on the device you typed the lost text on.
- Everything else — set the value again on the device you want to win. That edit carries a higher clock, so it sticks on the next push.
A side-by-side compare with Keep mine / Keep remote does not exist in memrynote. If you want one, that is a feature request, not a setting you have missed.
A Note That Stops Updating Its File
memrynote will pause writing a note's .md file rather than write a copy with content missing from it. If the note's document contains something this app version cannot represent — most often a newer note type opened on an older build — the file is left exactly as it was and the app records the reason.
What you see: the note is correct in the editor and on every synced device, but its file on disk stops changing.
What to do: update memrynote on that device. The note writes its file again on the next edit, with nothing lost — the pause is what protected the content.
Repairing a Damaged Vault Database
Each vault keeps tasks, projects, settings and sync state in .memry/data.db. If that file is damaged (a disk error or a crash mid-write), memrynote detects it when the vault opens, or the first time a read or write hits the damage, and asks before changing anything. It asks once per session.
Choosing Repair:
- Moves the damaged file aside as
.memry/data.db.corrupt-<timestamp>. It is never deleted. - Starts a fresh database and rebuilds what comes from your vault files.
- Restores synced items on the next sync.
- Copies changes that had not synced yet out of the damaged file where they are still readable, and sends them on the next sync.
- Keeps the vault's identity, sign-in binding and settings from the damaged file where they are still readable, so sync continues with the same vault instead of asking you to merge it.
Your note and journal files are not touched. Not now keeps the damaged database in use, and the prompt returns on the next open.
What memrynote Won't Do
memrynote doesn't auto-merge across record types — e.g. it won't combine two competing project structures. The vector clock comparison stays within a single record.
It also won't ask you to pick a winner. Every strategy above is built to resolve without a prompt, which is why there is no manual-resolution screen.
And it doesn't keep the losing version. Once a conflict resolves, that version is gone from the database, and Sync History never held conflicts to begin with.
See Also
- How Sync Works
- Sync Protocol — architecture deep-dive
- CRDT & Notes Sync — for the Yjs internals