Omniscio

Local and cloud backups

Omniscio keeps encrypted backups of your database and settings on this computer — taken automatically when it starts, on a timer, when you close the app, and on demand — in a self-pruning ring where every file keeps at least two physical copies, so one bad sector cannot take them all. A database found corrupt at launch offers to restore from a backup. The off-machine Backup Mirror adds encrypted copies that survive losing the machine.

On this page

What it is

Backups are your protection against a database that gets corrupted or a change you want to undo. Omniscio takes them for you: on startup, on a timer while the app is running, when you close it, and whenever you ask. Each backup holds the whole SQLite database plus your configuration and the records of the automatic lander (its queue, its in-flight train and what it has landed), is encrypted and tied to this computer — so a backup file that is copied, synced, or stolen cannot be read anywhere else — and is kept in a ring that quietly retires the oldest copies to save space.

⚠️ One exception: an unavailable keychain. The backup key lives in your operating system's credential store (Windows Credential Manager / macOS Keychain / the Linux keyring). When that store is unavailable — a headless launch, a reset credential store, a changed OS account — Omniscio deliberately writes the backup unencrypted and warns you, rather than skipping the backup and leaving you with no copy at all (owner decision). Such a copy is plaintext on disk and carries the ordinary archive names (mission-control.db, not mission-control.db.enc), so it must be treated as readable by anything that can reach the folder. Two exceptions on top of that: if you have turned on encryption for the live database, a plaintext copy would silently undo that protection, so the backup is skipped with an error instead; and a plaintext copy is only ever written to this computer's default local backup folder — if you have moved the backup folder elsewhere (a synced folder, a network share, another drive), the backup is skipped with an error while the keychain is unavailable rather than leave a readable copy where it could sync off the machine. Encrypted backups are unaffected by a moved folder. See Is my data encrypted? for the surface-by-surface table.

This local ring is on by default. It is not an off-machine copy: it lives on the same disk as the database, so it protects against corruption and mistakes but not against losing the computer. The encrypted Backup Mirror and Cross-Device Sync add that; Portable Backup covers carrying a copy to another machine yourself, and Setup Backup to Gmail covers configuration only — its bundle never contains the database file, so turning it on does not satisfy the off-machine requirement and does not clear the "Backups are on the same disk as your data" warning. The warning clears only when the database itself is copied off this machine: a fully configured Backup Mirror, Cross-Device Sync, or an auto-backup directory on a different drive. All of these are linked below.

Where to find it

Open Settings → Backup & Restore and look at the Automatic Backups card:

  • Enable automatic backups — on by default.
  • Backup interval — how often a backup is taken while the app runs (1 to 24 hours; default 6).
  • Keep last — how many recent backups to keep before the oldest of them are removed (2 to 50). A thinned weekly tail is kept on top of this window — one copy per week for the last eight weeks — so an old restore point survives without the ring holding every 6-hourly copy for two months. The tail is drawn from whatever room the size ceiling below leaves.
  • A total-size ceiling — the ring also keeps itself under 1.5 GB by retiring the oldest copies, because one backup weighs as much as your database and a count alone lets the folder grow without limit. It never retires below the two newest copies, so a restore point always has the one before it to fall back on, and the weekly tail competes for the same budget rather than sitting on top of it. When even those two copies alone exceed the ceiling, the ring keeps them — a rollback pair is always better than none — and says so in its log.
  • Snapshot Now — take a backup immediately.
  • Available Backups — the saved backups, each with its project / session / message counts and a Restore from this backup (and delete) action.

Below that card sits the encrypted Backup Mirror, and further restore options, for copies kept off this machine.

How it behaves

When a backup happens. A full backup is triggered by: app startup (a short pause after boot); a timer while the app runs (the interval above, default 6 hours — the first tick after a launch is measured from the newest backup already on disk, not from the moment you started the app); app shutdown when you close it; an idle window (when nothing is running and the machine is quiet); a manual "Snapshot Now"; and automatically around a schema migration or an app update, so you have a point to roll back to before a risky change.

When the computer is very busy. The scheduled backups (startup, timer, idle) copy your database in a separate helper process so the app never freezes while a multi-gigabyte copy runs. If that helper cannot start within a minute because the machine is saturated, the scheduled backup is postponed, not copied in the app itself: it retries every 10 minutes up to six times, then waits for the next scheduled run, and the staleness watcher still speaks up if backups stop for too long. "Snapshot Now", the pre-update safety copy and the shutdown backup are unchanged — they still take the copy the old way if the helper is unavailable. (Setting AMC_DISABLE_LOCAL_BACKUP_OFFTHREAD=1 keeps the old in-app copy for every backup.) While it works, the temporary unencrypted copy is written to a private folder under your system temp directory when that drive is different from the one holding your database and has twice the database's size free; otherwise it stays in the app data folder. It is never written into your chosen backup folder, and both locations are swept for leftovers from an interrupted backup.

Retention and the bit-rot floor. The ring keeps the newest backups and retires older ones, and beyond that dense window it keeps a thinned long tail: the newest copy from each of the last eight weeks survives, so a whole-database restore point reaches back about eight weeks instead of only the ~12.5 days the newest-N window covers (with the default 50 copies at 6 hours). The size ceiling bounds the whole ring including that tail, so a ring of multi-gigabyte snapshots keeps fewer copies — down to the newest two — instead of holding ten of them regardless of the ceiling. That is the only recovery path for an old version of a task that was edited over in place, since Tasks keeps no per-task history. It never lets the surviving set rest on a single physical copy either: every archive file is kept in at least two physical copies. That is a deliberate floor, so a single damaged disk spot cannot wipe every restore point at once.

Corruption detection and restore. At launch, Omniscio runs an integrity check on the database. If it finds it corrupt, it offers to restore from one of your backups and warns you how old that backup is before it overwrites newer data; a migration that fails offers to restore the automatic snapshot taken just before it. The restore question waits for you without freezing the app, and only one is shown at a time; if the database turns out healthy before you answer, nothing is restored. A check that found damage is remembered, so the long check does not repeat on every start: it runs again after a day, after an unexpected exit, or after a restore. Every restore is made safe the same way the rest of Omniscio's restores are.

Damage that is only in indexes is repaired, not restored. An index is a lookup shortcut SQLite builds from your real rows, so it holds no data of its own. When the check finds that every problem is in an index, Omniscio rebuilds those indexes in the background, re-checks each rebuilt table and then the whole database, and carries on — no dialog, no lost work. The repair is still logged and reported, so the damage stays visible. You are offered a backup restore only when the damage touches real data, when a problem cannot be pinned to one index, when a damaged table is too large to rebuild safely (over 2 million rows), or when the database still fails a check after the rebuild. Before this, a few damaged index pages offered only a full restore from a backup up to a day old, or "Continue Anyway", which left scheduled jobs failing with "database disk image is malformed".

Room for the pre-update snapshot, and when a restart is refused instead. Before any database update, Omniscio writes a safety copy (the point you can roll back to), which needs free space equal to twice your database — one copy plus headroom. That requirement is measured from the data your database actually holds, never from the size of its files on disk, because the write-ahead log beside the database can hold a large amount of unused space that a copy never reproduces. A large log therefore no longer inflates the requirement.

If the copy genuinely cannot fit, a restart is refused before your running app is closed, on both the CLI route and the header Restart button, with a message naming your free space, the amount needed, and the folder — so you are never left with the old build gone and the new one unable to start. The refusal is not raised when the update can proceed without a fresh copy: a recent safety copy, or an update whose changes are additive and can fall back to an existing copy, both go ahead. Free up space (or retire backups you no longer need in Backup settings) and restart.

Watching that it keeps working. A staleness watcher raises a card if the ring stops producing backups, repeated failures raise a failure alert, and a weekly check confirms the newest backup actually restores — so "it says it backed up" never stands in for "the backup is good".

What it covers. These backups cover your database, settings, archived chat, your KMS vault (notes and images), and the Tasks workspace — the Tasks Hub Docs plus the files Tasks agents wrote, minus scratch folders, with at most 256 MB of it per backup (25 MB for any single file). Only those two size caps leave a Tasks workspace file out of a backup, and how many were left out is recorded on that backup's manifest. A file that cannot be written at all is different: it fails the whole backup rather than leaving you a snapshot that looks complete but is missing part of your work. So do two vault notes whose names differ only by capital letters (Plan.md and plan.md) when the backup folder's drive ignores capital letters, as Windows and macOS drives usually do: one copy would overwrite the other, so the backup asks you to rename one first. On a drive that keeps capital letters apart, both notes are backed up as they are.

Not covered: files attached to tasks. The automatic backups keep your task list but not the files you attach to tasks, so a lost or failed drive takes those files with it. The Backup Mirror copies them somewhere else, and so does a Portable Backup or the manual Export all data file you make yourself. Until the Backup Mirror is fully set up, an inbox card titled "Task attachments are not in your automatic backup" reminds you — it cannot be silenced, comes back about every 90 days, and clears by itself once the Backup Mirror is set up.

Last verified 2026-10-25