Changelog.

Agent sync moves into the app. The Agents folder that v0.7.0 introduced no longer needs a terminal: a new Agents section in Settings shows exactly what is in sync, what is waiting to be applied or pulled, and what genuinely conflicts, with a Sync now button and one-click conflict resolution (keep the vault's version, or keep this machine's). Most of the time you won't even open it: with auto-sync on, which is the default, the app applies agent configuration changes moments after they land, so editing a skill on one machine updates every other machine as soon as sync delivers it. Auto-sync never resolves conflicts on its own, never blocks your writing, and can be switched off in the same section. The command line gains matching precision: jotura agents sync --item resolves a single conflicted file without touching the rest. The docs now cover the whole surface, from the new Settings section to the memory, context, and hook commands.

First party, self improving agents. This release completes the story the last two started: your AI tools don't just work in your vault, they get better because of it, out of the box. New in 0.7.0, agent configuration moves into your vault. A new Agents folder holds the instruction files, skills, and rules for every tool you use: Claude Code, Codex, Gemini, and Copilot are covered automatically, and any other tool, like Cursor rules, joins with a few lines of frontmatter. Edit them on any device, even your phone, and the new jotura agents sync command applies them back to exactly where each tool expects them on every machine. It detects drift in both directions, so hand edits and installer changes flow back into the vault, reports real conflicts instead of papering over them, never deletes anything without being asked, and takes a one time backup the first time it touches a file it has never seen. Your agents' memory, knowledge, and configuration now all live in one place: your vault, encrypted, synced, and yours.

Your agents gain a memory. New jotura memory commands let any AI agent record decisions (with the reasoning behind them), facts about your world, and follow-ups that must not slip, all as ordinary notes in a Memory folder in your vault. A new jotura context command bundles what matters into one briefing: your conventions, the memories relevant to the task at hand, and every open follow-up. For Claude Code, one command wires that briefing into the start of every session automatically; other tools pick it up through their standing instructions. Recall is built for how work actually happens: important and recent memories rank first, superseded decisions retire instead of resurfacing, and old decisions are surfaced as things to confirm rather than laws. When new work contradicts an old decision, agents flag it and supersede the old note in the open. And because every memory is a plain note, you can read, edit, or delete any of them: nothing hidden, nothing inferred, and if you delete it, the agent forgets.

Your AI tools now learn how you like things done. jotura skill install teaches Claude Code, Codex, Gemini, and now GitHub Copilot how to work in your vault, and it does it politely: instructions land inside clearly marked blocks in each tool's config file, so nothing you wrote there is ever overwritten, and upgrades replace only what Jotura put there. A new companion skill teaches agents the craft of note-keeping itself: where things belong, when to capture, and how to link notes together. And what agents learn about your particular vault, your folder structure, your naming rules, your corrections, now lives in a conventions note inside the vault itself: shared by every agent you use, synced to every machine, and safe across upgrades and reinstalls.

The phone catches up with plain text. All the file types that became first-class on desktop in v0.4.0 (.txt, code, SQL, logs, CSV, HTML) now show up on Android too: they appear in your file list with their own icons, open in a clean read-only viewer (HTML gets the same safe rendered preview as desktop, with a one-tap source toggle), and search on the phone now looks inside the text of your notes and files instead of only matching titles. Editing on the phone stays markdown-only, so a stray tap can never mangle a data file. Two Android annoyances are gone as well: tapping a checkbox in a long note no longer makes the page lurch, and that fix ships with this release's app update. A milestone to go with it: Jotura is now on Google Play, so Android installs and updates are one tap from the store, with the direct APK still available on the download page. On desktop, pressing Enter on an empty list item now always exits the list, including nested bullets, which used to keep spawning new bullets one level at a time. Right-clicking a note or folder in the sidebar offers Copy path, putting its vault-relative path on your clipboard. The app also opens at a sensible size now: maximized on a 1080p display, a large centered window on anything bigger. And a fix for anyone whose search felt incomplete: a single file that wasn't valid UTF-8 (SQL Server and PowerShell save UTF-16 by default) could silently stall indexing partway through the vault; those files now decode and index like everything else, and one unreadable file can no longer hold up the rest.

Your vault is no longer just markdown. Plain text files like .txt, .sql, code, config, and CSV now open right inside the app in a proper code editor with syntax highlighting for over a hundred languages, autosave, and the same safe syncing as your notes, instead of bouncing out to an external program. HTML files get their own view: a safe rendered preview (scripts stay off) with a one-click source toggle, and search now reads the visible text of HTML pages rather than their markup. Mermaid diagrams in code blocks finally render as real flowcharts in the editor. Links understand all of this too: wiki links and relative links to any of these files open them in the right tab, and backlinks count them. The app has also stopped generating markdown mirror copies of HTML and CSV files, and quietly cleans up ones it made before (anything you edited yourself is left alone). The jotura command line tool gains the same abilities: plain text files are listed, searched, grepped, and edited like notes, and frontmatter commands now refuse to touch non-markdown files instead of corrupting them. In the sidebar, files that open in the app no longer look disabled, and right-clicking an HTML file offers Open in browser.

Jotura now installs with one line. Paste a single command into your terminal (it's on the download page, with a copy button) and it installs the app, puts the jotura command on your PATH, and sets up the AI agent skill so tools like Claude can work with your vault, then launches Jotura. Every download is checksum verified, the script is plain text you can read before running, and on Windows there is no security warning to click through. Rerunning the same command later upgrades you. On Linux the script installs the AppImage by default, which means Linux now auto-updates just like Windows and Mac (a flag installs the .deb instead if you prefer your package manager). The desktop got a round of polish too: moving a note to trash is now a single click with no dialog (the trash is always recoverable, and permanent deletion has left the menus), right-click menus stay fully on screen near the bottom of the window, and you can now drag whole folders into other folders, reveal any note in your file manager, and rename with F2. We also fixed a family of confirmation dialogs that behaved wrongly in the installed app, including one that silently blocked creating a note from a wiki link. On Android, the app gains a bottom navigation bar with a full folder tree alongside your recent notes, and you can create notes right on your phone. Task checkboxes finally line up with their text on every font size, and the recents list updates the moment you save.

The big one first: you should stop getting signed out of sync all the time. The cause turned out to be the server treating perfectly innocent situations, like two of your devices refreshing their session at the same moment, as suspicious activity and signing everyone out. The server now recognises these cases and keeps you signed in; a session only ends when you sign out or leave a device untouched for thirty days. This part is already live, so existing installs benefit without updating. On Android, the confusing state where a banner said you were signed out while the menu insisted you were signed in is gone: the app now knows the difference between signed in, signed out, and a session that simply expired, and an expired session shows one clear message with a one tap sign-in that remembers your email and never touches your notes. Editing got calmer too: if a note changes on disk while you're editing it (another app, a script, a sync from another device), Jotura now merges the two versions and moves on instead of interrupting you with a banner asking which version to keep. Sharing gained a batch of hardening: being switched to view-only access on a shared folder no longer makes it vanish from your phone, deleting a note in a share while sync is paused now sticks instead of the note reappearing, invitations with identical folder names can no longer be mixed up, and the app is honest when an invitation email could not be delivered. The command line grew real sharing awareness: a new "jotura shares list" command, protection against editing view-only shares, and edits in shared folders now queue for sync properly. And a first: Jotura now ships native Linux ARM64 builds, so a Raspberry Pi 5 can run it, available from the download page alongside the others.

A reliability release, built from a day of real-world testing across four devices. The biggest change is invisible until you need it: shared notes now recover with your sync password. Previously a new device could only join your shares after another of your devices came online to hand over a key, and losing every device meant losing share access for good. Now any device that can unlock your vault unlocks your shares too, and opening Jotura on any signed-in device quietly repairs the others. Sync got two fixes: editing the same line on two devices no longer duplicates it (finishing a sentence on your laptop that you started on your phone now merges into one line), and synced notes keep the date you actually edited them instead of showing as freshly modified on every device. Restoring a vault on a new machine now opens it properly when the download finishes, with progress shown instead of a blank sidebar. On Android, links in notes are finally tappable (web links open your browser, note links jump to the note) and task checkboxes line up with their text. Removing a device from your account now signs it out properly too.

Every synced note now has a full version history. In shared vaults, it shows who wrote what. Right-click any note and choose Version history (or find it in the command palette) to open a new full-screen view: a timeline of every change on the left, grouped into tidy editing sessions rather than one line per save, and a proper comparison on the right: additions in green, deletions in red, down to the exact words that changed, side-by-side or unified. In a shared vault each session is stamped with the person who made it, so "who changed this paragraph?" finally has an answer. Restoring is one click and never destructive: the restored version is simply added as the newest change, attributed to you, so nothing is ever lost. You can even restore a note that was deleted. History is rebuilt automatically from your encrypted sync data, which means it works on a fresh install too: sign in on a new machine and your whole edit history comes with you. Versions are kept for three years, and like everything in Jotura the server only ever sees encrypted bytes: your edit history, and who made each edit, stays as private as the notes themselves. Older vaults index their existing history in the background the first time you open them; Android quietly records history for every edit from this release on, with a phone-side history view to follow.

Shares arrive on Android. Invite someone to a folder or note from your desktop and it now shows up on their phone too: an invitation banner appears in the app, one tap accepts it, and the shared notes mount in a new "Shared with me" section: readable and editable on the go, with the same end-to-end encryption and the same clean merging when both of you edit at once. Viewer-role shares open read-only, and leaving a share moves your local copy to the trash rather than deleting anything. Sharing something out still happens from the desktop app (the phone is for receiving and editing), and the desktop's Share window now says so. Both sides still need a Jotura Sync subscription.

Jotura can now share. Right-click any folder (or a single note) and choose Share to invite someone by email. What you share stays exactly where it is in your vault; the other person sees it in a new Shared section, and you both edit the same notes with changes syncing and merging cleanly, even when you're editing at the same time. Sharing keeps Jotura's end-to-end encryption: notes are encrypted on your device with keys only the people you invite can unlock, so the server never sees a word. Editors can write, viewers can only read, and removing someone cuts their access immediately. Both sides need a Jotura Sync subscription.

Fixes a ghost in the editor: a note mixing ordinary bullets and checkboxes in one run could display an empty bullet or empty checkbox that wasn't really in your file. Because it wasn't real, deleting it did nothing and it came straight back. The editor now reads mixed lists correctly, so what you see is exactly what's in the file. Desktop and Android both carry the fix; your notes themselves were always fine.

Two fixes that make everyday editing calmer. First: deleted content now stays deleted. Vaults from before v0.2.0 could see a deleted line quietly return after syncing: the merge engine lacked a baseline for notes created before it existed, and without one it couldn't tell a deletion from an addition. On first open this update seeds that baseline for your whole vault in one pass, and from then on every merge knows exactly what you removed. Second: a note can no longer be open in two tabs at once. Opening a note you already have open (from search, the calendar, a task, a wikilink, anywhere) now switches to the existing tab, and any duplicates you already have fold into one (keeping unsaved changes safe). Update your phone too: Android carries the same fixes.

An Android-only release: Jotura on your phone no longer needs an account to be useful. The first screen now offers "Create a vault on this phone": a real, private vault that lives on your device, works completely offline, and is free, with optional example notes to start from. When you're ready for your notes on every device, one tap turns sync on for that same vault: set a sync password, save your recovery phrase, and everything you've written uploads. Nothing is lost, nothing to move. Desktop is unchanged in this release.

Jotura comes to Android, and sync conflicts are gone for good. The new Android app brings your vault to your phone: sign in, pick your vault, and your notes download in seconds and stay in sync automatically. No push button, no manual anything. It's built on the exact same engine as desktop, with the same end-to-end encryption and the same WYSIWYG editor; complex blocks like tables display beautifully and are marked "edit on desktop" so nothing gets mangled on a small screen. A quick-capture button drops a thought straight into today's daily note, and you can switch between vaults or sign out from the account screen. Grab the APK from the download page. The Play Store listing is on its way. Just as big: you will never deal with a sync conflict again. When the same note changes on two devices, Jotura now merges the changes and keeps everything. Write on your phone over lunch and on your desktop in the evening, and the note simply contains both. No conflict copies, no dialogs, no decisions. The same applies on your phone when an edit races an incoming change: it merges, nothing is lost, nothing asks. Syncing an old device that's been offline is much faster too: Jotura now skips straight to the newest version of each note instead of replaying every intermediate edit. And on Windows, saving is now immune to the brief file locks that antivirus scans can cause.

A hardening release, driven by an external security and reliability audit. Saving is now airtight against outside interference: if another program deletes or moves a note you're editing, Jotura no longer silently recreates it. You get a clear choice to recreate the note with your version or close the tab, and autosave holds off until you decide. Simultaneous edits from the app and the command line can no longer race each other; exactly one writer wins and the other is told why. Document conversion now runs fully sandboxed on every platform with strict limits on time, memory, and output, so a malformed document can never hang or bloat the app. Account sign-in got the same treatment server-side: codes and sessions are strictly single-use even under simultaneous requests. Also fixed: when sync is waiting on a subscription, the app now shows one steady "Subscription needed" state instead of flickering while retrying, and it resumes on its own the moment your subscription is active.

Jotura Sync is now a subscription: £4 a month or £40 a year (two months free), charged in your local currency where supported, managed entirely at jotura.io/account. The app itself stays free and fully local: notes, search, and editing never need an account, and if a subscription lapses your notes remain untouched on your devices. Sync pauses, and downloads always work so you can restore your data on any machine. In the app, sync setup now shows a clear "Get Jotura Sync" panel until you're subscribed, Settings shows your plan and renewal date with a Manage billing link, and if sync ever stops because a payment failed the status pill says exactly that instead of a vague error. Payments run on Stripe through the new pricing and account pages on the website; the app never sees your card. This release also fixes keyboard navigation in the sync dialogs (Tab now moves between the password and recovery-word fields properly), restores the numbered recovery phrase when copying (1. word, 2. word…) so counting to the ninth word is no longer a memory game, and stops document conversion from picking up Word's temporary lock files.

If you're on v0.1.60, this update should have arrived the new way: a quiet "Update ready" prompt in the status bar, one click, done. The first Jotura release delivered by the app itself. Inside it: sync now runs on Jotura's production service at api.jotura.io (if sync shows as needing setup after the update, re-enable it: your notes re-upload once and nothing local is touched); a fix for a crash that could blank the editor the first time you opened a note in a session; and pasted images now display correctly in daily notes and any note inside folders (previously an image pasted into a nested note was saved fine but silently refused to render).

This is the last version of Jotura you'll ever install by hand: the app now updates itself. When a new release ships, a quiet "Update ready" prompt appears in the sidebar's status bar: one click downloads, verifies the cryptographic signature, and relaunches. No downloads page, no reinstalling. And there's a lot in the rest of this release. Every edit is now recoverable: Jotura keeps a local history of your notes as you work, and a new History panel in the right sidebar lets you view any earlier version and restore it. Restoring is itself recorded, so you can always change your mind. Search got a home of its own: it now opens as a pinned tab at the front of the tab bar, so you can flick between results and notes without losing your place, and the search box finally has a single, tidy focus outline. Your frontmatter tags are visible at last: a new Tags tab in the sidebar lists every tag with counts and drills into the notes carrying it. Templates went from CLI-only to first-class: create and edit templates in Settings, then start notes from them via the command palette or a folder's right-click menu, with automatic date and title variables. Notes can now leave the app too: export any note as a standalone HTML file, or print / save to PDF with clean, chrome-free output. Settings itself was reorganized: the essentials up front, diagnostics, logs, and maintenance tucked into tidy expandable groups that still surface anything urgent. Typing task syntax like "- [ ]" now turns into a real checkbox as you type, completed tasks are easier to read with a much subtler strikethrough, and files in the sidebar wear VS Code-style colored type badges (MD, TS, PDF and friends) so a note never gets mistaken for a spreadsheet. Under the hood the app starts noticeably faster (the editor now loads in the background after first paint), the interface can no longer go blank if a component fails to load, narrow side panels collapse their labels to icons, and both the app and the jotura command line now report their real version numbers.

Setting up sync no longer keeps you waiting. Previously, the setup wizard stayed on "Enabling sync…" until your entire vault had finished its first upload. On a big vault that took long enough that you might reasonably give up and close the app, and if you did, you missed your recovery phrase, which is only ever shown once. Now enabling sync takes seconds: your keys are created, the vault is registered, the recovery phrase appears immediately, and the first upload continues quietly in the background with its progress in the sidebar's status bar. That progress readout also stopped jumping around: the total no longer bounces as work is discovered, it only counts up. And if you've already been bitten (you enabled sync on an earlier version and never saw a recovery phrase), there's now a fix: Settings → Sync → New recovery phrase generates a fresh one from your sync password, shows it once, and asks you to confirm you've saved it. The sidebar also got a proper polish: notes now carry their own distinct icon so markdown files stand apart from PDFs, spreadsheets, and images at a glance; rows, hover states, and the Files/Search toggle match the refined look of the settings screen; and search results (in the sidebar, the search page, and Quick Open) now show each note's folder within your vault, so three files with the same name in different folders are finally tellable apart. Quick Open showing long system file paths is gone too, as is the path readout under the tab bar. Cleaner everywhere.

Jotura can now search by meaning. Press Ctrl/Cmd+Shift+F for the new search page and ask for what you remember ("that note about boiling pasta") instead of the exact words you wrote. Behind it is a small AI model that runs entirely on your computer: enable it once in Settings → Semantic search (a one-time 34 MB download) and Jotura indexes your notes in the background, with live progress and a time estimate in the sidebar's new status bar, which replaces the old activity popup and now shows everything Jotura is doing in one quiet place: indexing, document conversion, and sync. Search has three modes, each explained right in the app: Keyword is the classic exact-words search, Semantic finds meaning, and Smart, the default, blends both rankings so you get the best of each. Privacy is unchanged and absolute: the model runs locally, the index lives in your vault folder, and nothing about your notes is sent anywhere. The feature is entirely optional and can be switched off (deleting its index) at any time. If your computer has a GPU, Jotura uses it automatically. A typical vault indexes in a couple of minutes, and editing a note re-indexes only the parts you changed. Indexing survives restarts and picks up where it left off, so even a big vault on an older machine gets there in the background. The command line learned the same trick: jotura search --mode smart "your question" gives scripts and AI agents the exact same ranking as the app, and the bundled agent skill documents when to use each mode.

Copying a folder of files into your vault no longer freezes the app. A large import used to lock the window for minutes: every incoming file triggered a full vault re-scan, a search-index write to disk, and a sidebar rebuild, all on the thread that draws the window. That whole pipeline is fixed: heavy work now runs off the interface thread, search indexing batches its disk writes, task scanning only re-reads files that actually changed, and the sidebar updates once per burst of changes instead of once per file. Documents also work the way you'd expect now: drop a PDF or Word file into your vault and it converts to a Markdown note right next to the original (report.pdf gets report.pdf.md), automatically, whether the app was open or not. The converted note is a real note: editable, searchable, synced. If you've edited it, Jotura will never overwrite your version when the original changes. The hidden Converted folder is gone; existing converted copies move next to their documents on their own. In the sidebar, documents and images are visually distinct (dimmed, with a file-type icon) so they aren't mistaken for notes, and clicking a document opens its converted note (converting on the spot if needed; right-click still opens the original in its own app). Settings got a full redesign: cleaner grouped controls in the style of macOS System Settings, with each section showing its detail only when the feature is actually on. No more wall of sync options while sync is off. And one small fix that mattered if you leave Jotura running overnight: the calendar's Today button and the task list's Today section now follow the real date past midnight instead of the day the app was opened.

Windows: the false "note changed on disk" warning is finally gone. Jotura saves notes safely by writing to a temporary file and swapping it into place. Windows reports that swap as a rename, where macOS reports it as an ordinary modification. The rename path was the one place that still didn't check whether a change was the app's own doing, so on Windows every single autosave looked like an outside edit and raised the warning. Saves are now recognised identically on every platform, the rename and delete notification paths honour the app's own-write markers, and Windows no longer refreshes the file tree on every save (a nice little speed-up for large vaults). If you saw the warning constantly on Windows in earlier versions, this is the release that ends it.

One more false-conflict source closed: opening today's daily note and typing straight away could still raise the "note changed on disk" warning. The previous release taught the file watcher to recognise the app's own writes. But the write that creates a daily note was the one code path that didn't announce itself, so its change event looked external and collided with your first autosave. Every write the app performs now goes through a single announce-then-write gate, so no write can be mistaken for an outside change again: not by oversight, not in future features. Each writing operation (saving, creating notes and folders, renaming, trashing, importing files, ticking off tasks, and daily notes) now carries its own regression test proving it announces itself.

The false "note changed on disk" warning is gone for good. The file watcher reports every change to a note (including the ones Jotura's own autosave just made), and the app was left guessing which changes were its own. During fast typing that guess could lose a race and raise the conflict warning against your own save, over and over. The app no longer guesses: every write Jotura makes is tagged at the source, the watcher recognises its own changes with certainty, and a change notification while you're editing can now only mean what it says: another program really did modify the file. Edits made by other apps and by the CLI still show up instantly, and the underlying save-time safety check that protects against genuine concurrent edits is unchanged.

Editing is rock-solid again. Three bugs made writing frustrating, and all three are gone. First, the cursor could jump away mid-sentence: whenever an autosave finished while you kept typing, the editor reloaded itself from the just-saved copy and threw your cursor across the note. The editor is now the single source of truth while a note is open: saves never rewrite what you're looking at. Second, writing near the bottom of a long note could collapse the blank lines you'd placed between sections: adding a paragraph made the app re-generate the whole document from scratch, normalising your spacing away. Saving is now byte-stable: only the block you actually touched is rewritten, and every other character in the file, including your spacing, survives exactly as you typed it (this also fixes a subtle case where making text bold could fail to save). Third, a note could get stuck behind a false "changed on disk" warning where "Keep my version" did nothing: the app was racing its own autosave and then swallowing the error. Saves now run strictly one at a time, the warning only appears for genuine outside edits, and both banner buttons report clearly if anything goes wrong. Also fixed: typing in the sync password confirmation box no longer bounces the cursor back to the first field.

Your vault is now a plain folder of Markdown files, and here's why. Encrypting notes on your own disk sounded protective, but in practice it bought very little: once the vault was unlocked for use (which was almost always), the encryption protected nothing, and the stolen-laptop case is covered far better by full-disk encryption (FileVault, BitLocker), which guards everything on the machine, not just your notes. What it cost, on the other hand, was real: your notes were opaque blobs no other app could open, every read and write paid an encryption toll, backups and scripts couldn't see your files, and everything (search, sync, the CLI, even automations) had to thread through an unlock step. That's a lot of machinery for a lock that was open whenever it mattered. So the trade is gone: notes on disk are now ordinary files you can open, grep, back up, and script against, with nothing to unlock, ever. Encryption stays exactly where it earns its keep: on servers you don't control. Cloud sync still encrypts every note on your device before upload, the server still only ever sees ciphertext, and your sync password and recovery phrase work as before. If sync is waiting for its password, nothing blocks. You keep reading, writing, and searching while sync resumes when you're ready. The jotura CLI is simpler to match: the unlock and lock commands are gone (they had nothing left to do), and a new jotura sync status / login / logout manages the sync key, shared automatically with the desktop app.

Sync conflicts fixed for good. A bug could make a note conflict with itself on a single device: after certain sync hiccups (a dropped connection mid-sync, or a force resync), Jotura would mistake your own earlier save for a change from another device, roll the note back under your cursor, and leave behind .conflict files. That can no longer happen: the sync engine now recognises its own history and never conflicts a device against itself. Real conflicts (the same note edited on two devices at once) are handled more gracefully too: the version you're actively editing always stays put, and the other device's version is saved alongside it as a clearly named conflict copy: no interruptions, no rollbacks, and nothing is ever lost. Sync activity and any conflict events are now also recorded in the local diagnostics log, so if anything ever looks off, the "Copy diagnostics" report will show exactly what happened.

Reliability and diagnostics. Jotura now keeps a small local log of background activity (conversion and sync errors), and Settings has a "Copy diagnostics" button that gathers a shareable report (app version, system, converter status, and recent log lines) so if something goes wrong you can paste the details into a bug report. As always, it stays entirely on your machine; nothing is sent anywhere. Under the hood, the encrypted vault's database is now integrity-checked when it opens, so a damaged vault is caught and reported clearly (and can be restored from your cloud copy) instead of failing in confusing ways later.

Better handling and visibility for documents that can't be converted. Files that genuinely can't be read (corrupt PDFs, password-protected documents) are no longer retried over and over in the background, which was quietly wasting CPU and battery; they're attempted, and then left alone unless the converter is upgraded or the file changes. Settings → Documents now shows a clear breakdown of how many documents are converted, failed, and still pending, lists the ones that failed, and gives you a "Retry failed conversions" button to force another attempt whenever you want.

Converted folder now fills in properly on large vaults. Previously, if you had hundreds of documents, the background converter worked through them in small batches spaced minutes apart, so the Converted folder could take hours to catch up and looked like it was missing files. It now works through the entire backlog continuously in the background, and always converts documents it hasn't seen yet before re-trying ones that previously failed, so everything shows up far sooner. The manual "Convert pending documents" button in Settings now kicks off the whole backlog at once too.

Windows fix: documents now convert reliably. Conversion was failing on Windows for almost any real document: anything containing a curly quote, an em-dash, an accented letter, or an emoji would error out and never become searchable, because the converter was writing its output using an older Windows text format that can't represent those characters. Conversions now use full Unicode (UTF-8) throughout, so PDFs, Word docs, spreadsheets, and presentations convert correctly regardless of the characters they contain.

Windows fix: no more flashing terminal windows. On Windows, a black console window briefly popped up when Jotura started and again every time it converted a document: the bundled converter runs as a small background program, and Windows was showing its window each time it launched. Those windows are now hidden, so conversion and startup happen quietly in the background as they should. No change to how anything works; the flicker is just gone.

Document conversion now actually works on macOS. The bundled converter could never load on a Mac: a code-signing rule (library validation) blocked its embedded Python runtime, so every PDF, Word, and PowerPoint quietly failed to convert and stayed unsearchable. The converter is now signed correctly and runs as intended. Two related fixes: Jotura only converts real document types now (Word, PowerPoint, PDF, Excel, and similar) instead of trying to "convert" images and other files that have no text to extract; and any junk entries an earlier version created for images are cleaned up automatically the next time you open your vault, so the Converted folder shows only genuine documents.

You can now see what your documents were converted into. When Jotura imports a PDF, Word doc, or spreadsheet, it builds a searchable text version behind the scenes. Until now that lived entirely out of sight. A new read-only "Converted" folder in the sidebar mirrors your document folders and lets you open and read the extracted text of any document, so you can confirm a file was picked up and see exactly what search is matching against. These views are clearly badged and read-only (you edit the original document, not the converted copy), and they appear automatically for every document already in your vault, with nothing to migrate.

A big responsiveness fix for vaults with documents. After the documents release, unlocking a vault or converting files could make the app feel frozen: heavy background work (building the search index, converting documents, syncing) was holding a lock that everything else had to wait behind. That's fixed: the app is now usable the instant you unlock, while indexing and conversions fill in quietly in the background. Search works immediately on what's already indexed and tells you when it's still catching up, filename quick-open is instant, and document conversion never blocks your typing. A new activity indicator next to the sync status shows what's happening in the background (indexing, converting, or syncing) so you always know the app is working, never stuck.

Documents come to Jotura. Drop a PDF, Word doc, spreadsheet, or other file into your vault. It's encrypted exactly like your notes, and Jotura automatically builds a searchable markdown mirror of it so you can find it by its contents, not just its filename. Add documents however suits you: drag them into the app, paste them into a note, run jotura import from the terminal, or turn on the optional OS folder where dropping a file in Finder/Explorer imports it. Open any document in its native application (Word, Preview, Excel…) straight from the vault. When you save, your changes re-encrypt back into the vault automatically, and if the app ever closes mid-edit it offers to recover your changes on next unlock. Everything works offline and syncs across your devices: the document converter ships inside the app, so there's nothing extra to install, it runs sandboxed with no network access for safety, and a document converted on one device arrives already-converted on the others. Your AI agents can search and read documents too: the jotura CLI's new search-documents command searches the converted text and hands back the original document paths.

Small visual polish. Scrollbars throughout the app now match Jotura's dark and light themes (slim, rounded, and translucent) instead of the chunky OS-default ones, with the ember accent showing through when you drag. Table headers in the editor also tighten up vertically so they read more like column labels and less like another row of body content.

The jotura command-line tool now installs itself on Windows. Previously the CLI shipped inside the Windows installer but nothing put it on your PATH, so typing jotura in a terminal turned up "not recognized". The macOS and Linux AppImage builds had a first-launch prompt that handled this, and Windows did not. On first launch the desktop app now offers to add Jotura's install directory to your user PATH (no admin prompt, no setx-style PATH truncation: it writes the registry via the proper Windows API and broadcasts the change so new terminals pick it up immediately). The same Install button is available later in Settings → Command-line tool, so users who declined the prompt or upgraded from an earlier version can opt in any time.

Vault-shape features for the jotura CLI. jotura backlinks <path> lists every note that links to a given note via [[wikilinks]] or [markdown](links); jotura links <path> lists outgoing links. jotura trash <path> soft-deletes a note (recoverable via jotura trash restore / list / empty), backed by a new trashed_entries table in the manifest. Your AI agent can no longer permanently lose a note by mistake. jotura templates list/show/create/delete manages reusable note templates stored encrypted alongside your notes; jotura create --template meeting <name> spins up a new note from a template with {{date}}, {{datetime}}, {{filename}}, {{title}} variables substituted. jotura grep <pattern> runs ripgrep-style regex search over decrypted bodies with --ignore-case, --line-regexp, --include, --files-with-matches, and the rest of the familiar flags. All four are documented in the CLI skill file your AI agents read.

Batch operations for the jotura CLI, aimed at AI agents that need to make multiple changes at once. jotura edit --apply <edits.json> applies several edits to one note sequentially with a single hash check and one atomic write: rewrite five sections in one call instead of five round-trips. jotura batch <ops.json> does the same across multiple notes: all preconditions verified up front, then changes apply together or not at all. Both compose with --dry-run for previews and a new --diff flag that returns unified-diff output (also added to every other mutating command). When a hash conflict happens, the error response now includes a diff between what the CLI was about to write and what's actually on disk, so your agent sees exactly what changed under it and can decide whether to retry, merge, or abort instead of guessing.

Major polish pass on the jotura command-line tool. Every mutating command (write, edit, create, rename, delete, frontmatter, tag) gains --dry-run, which previews the exact change with before/after content and the resulting hash without writing to disk. Your AI agent can verify an edit looks right before committing it. A new jotura doctor command runs nine diagnostic checks (PATH, vault detection, session cache, version skew with the desktop) and reports JSON pass/fail per check. jotura skill install <claude|codex|gemini|all> writes the agent skill file directly to the right place in each AI tool's config, replacing the manual curl step entirely. jotura today opens or creates today's daily note (matching the desktop's Daily/YYYY/MM convention). jotura watch streams vault change events to stdout one JSON line per event, so scripts can react to anything that touches the vault: yours, the desktop's, or sync's. Plus shell completion for bash/zsh/fish (including vault-aware path completion when unlocked), and a CI fix that lipos the macOS aarch64 + x86_64 CLI builds into the universal sidecar that Tauri expects.

The jotura command-line tool now ships inside the Jotura desktop installer. On Linux (deb) and Windows the CLI lands on your PATH automatically at install time. On macOS, a new Settings → Command-line tool section adds a one-click "Install" button that symlinks /usr/local/bin/jotura to the bundled binary (asks for admin password once); the AppImage flow on Linux offers an equivalent first-launch prompt to copy the CLI into ~/.local/bin. Once installed, jotura works in any terminal, and shares your unlocked vault with the desktop app via the same session cache, so one passphrase covers both surfaces. Also fixes the CI workflow paths that broke after the workspace refactor and caused v0.1.35's macOS build to fail at the ad-hoc signature verification step.

Build-tooling fix: the v0.1.33 and v0.1.34 installer builds never completed because the Tauri JS package (@tauri-apps/api) and the Rust tauri crate drifted onto different minor versions, and Tauri's CLI refuses to build on that mismatch. This release pins the JS side to match the Rust crate's 2.11.x line, so the CLI + cooperative-unlock work from v0.1.33 and the /agents documentation page from v0.1.34 finally ship in real downloadable installers.

The website now has a dedicated agents page at /agents that walks through installing the v0.1.33 jotura CLI and teaching Claude Code, OpenAI Codex, or Gemini CLI to talk to your encrypted vault. The same skill file every agent reads is shown inline on the page and offered as a download, so you can drop it straight into your AI tool's config and your agent immediately understands the safe-edit workflow: unlock once, read with a hash, edit with --if-hash, and never silently clobber a note you have open in the desktop.

Jotura now ships a companion command-line tool, jotura, for reading, searching, and editing your vault from a terminal. It's useful for shell scripting, custom workflows, and AI-agent integrations like Claude Code. The CLI shares the desktop's encrypted vault, atomic writes, and conflict detection; unlocking the vault in the desktop also unlocks it for the CLI in the same session, so your passphrase is asked once. Changes made through either surface now propagate to the other within a second, so a note edited in the terminal updates the desktop's tree, search, and any open tab automatically. The desktop also gained a visible warning when you're signed out on a sync-enabled vault (both as a titlebar indicator and a banner above the editor) so you can no longer silently miss a sync because you forgot to sign in.

Images now display inside encrypted vaults. Because an encrypted vault stores every file as a sealed blob, pasted, dropped, and inserted images were saved correctly but rendered blank. Jotura now decrypts vault images on demand as it draws them, so they appear inline just as they do in an unencrypted vault.

Pasting images just works now. Drop or paste an image straight into a note and Jotura copies it into the vault's assets folder and inserts it inline, the same as choosing Insert image from the slash or selection menu. However an image arrives, it is stored alongside your notes (keeping its original filename, de-duplicated if a name is already taken), so your vault stays self-contained and portable. An image you pick that already lives inside the vault is linked in place rather than copied again.

Sign-in email delivery is sturdier. Auth emails now send from the verified jotura.io domain, and if the mail provider rejects a message the app gets a clear retryable error instead of a generic internal-server failure. Undelivered sign-in codes are cleaned up immediately so stale codes do not linger after a failed send.

Sync now recovers when another device has already advanced the vault. If one machine pushes first, the next device pulls those remote changes, preserves any true local divergence as a conflict file, and retries its queued edits instead of getting stuck behind a version_conflict error.

Jotura has a proper identity now. The app and the website share one look: a geometric "jot" mark (a dot resting on a baseline), a warm near-black and cream palette with an ember-orange accent, and a Newsreader serif wordmark. Inside the app the mark appears on the welcome screen, the sidebar, and the unlock and sign-in dialogs, Settings gains an About panel, and the desktop and taskbar icons are refreshed. This release is purely cosmetic: nothing about how your notes are stored, synced, or edited has changed.

Task lists now roll up across your vault in the right sidebar. The new Tasks tab finds ordinary markdown checkboxes, groups open work by overdue, today, upcoming, and undated, lets you filter and toggle tasks in place, and links daily-note tasks to the calendar. Tasks inside `Daily/YYYY/MM/YYYY-MM-DD.md` inherit that date automatically; tasks anywhere can use `@due(YYYY-MM-DD)` to appear on the calendar without leaving plain markdown. A configurable task window keeps the list focused on recently modified notes and recent daily notes, while future-dated tasks always stay visible and the pane shows recent past-task completion.

Tables behave like real editor furniture now. Hovering a table reliably reveals the row and column gutters, cells stay clickable across the full table, and column resizing is saved into the editor document instead of disappearing when the view reloads. Unsized columns still size to their contents; once you drag a column to a fixed width, that column wraps long content cleanly inside the chosen size.

Notion-grade tables. Type `/table` (or pick Table from the slash menu) to drop a 3×3 with a header row; click any cell to edit, Tab and Shift-Tab move between cells, Tab on the last cell adds a new row, and Mod+Enter inserts a row below. Hover the table to reveal row and column gutters with drag handles, alignment dropdowns (left, center, right, default), one-click insert + and × delete buttons, and a session-only column-resize grip that never writes to your file. Right-click a row or column gutter for a full insert / delete / align context menu. Saved tables are strict GFM markdown: the same `:---:` alignment markers and pipe escapes that render identically in Obsidian, GitHub, and VS Code preview.

Daily notes. A right-side calendar sidebar opens or creates a markdown note for any date you click. Daily files live flat at `Daily/YYYY/MM/YYYY-MM-DD.md`, with the next two weeks pre-created when you open the vault. Settings has a toggle and a knob for the auto-create window; the sidebar starts collapsed with a thin always-visible icon rail and remembers its width. Also: sync now auto-recovers from `ref_count_underflow` errors that could previously deadlock the push queue after a large batch of renames: the client drops the stale Delete op the server has already rejected and retries silently.

Push queue scrubber now drops orphan-blob ops too. v0.1.21 cleared oversized pending ops but left Put ops whose backing blob is missing from local storage. Those still jammed sync with an ENOENT. Both kinds are now scrubbed before each push.

Re-release of v0.1.21's queue-scrubbing fix. The v0.1.21 build failed in macOS release CI because a stray rustup-init shim was reappearing between workflow steps; the build step now pins cargo explicitly via PATH + the CARGO env var so it can't get shadowed again.

Sync no longer gets stuck behind a queue full of legacy oversized blobs. If you upgraded from a build before the size filter, you may have had hundreds of pending ops jamming on a guaranteed 413 every push cycle. Push now scrubs any Put op whose local blob exceeds the server cap before sending, so the rest of the queue drains. Files still live locally. Only the dead sync ops are removed.

Republishes v0.1.19's oversized-file sync filter. The v0.1.19 release workflow died on the macOS runner because a rustup-init shim shadowing `cargo` got reintroduced after a runner image refresh; the release CI now deletes any system-level cargo/rustc/rustup that isn't the rustup-installed one, so this won't bite us each image rotation.

Files above the server's 16 MiB upload limit no longer hammer sync with repeated 413 errors. They're still stored locally (encrypted, visible in the sidebar, openable), just not queued for the next push. Re-enabling sync for bigger files needs a server deploy plus a client cap bump (the constant is documented inline).

Task list checkboxes redesigned: larger, rounded-square, custom-rendered (no more native OS chrome) with proper hover and focus states, and a crisp white checkmark on the accent fill when ticked. Completed task text now fades and strikes through.

Bigger files sync. The client-side 25 MiB cap is gone: large presentations, PDFs, and similar files now appear in the sidebar, migrate into encrypted vaults, and push through sync. The server's blob limit is bumped from 16 MiB to 100 MiB (the practical Cloudflare Workers request ceiling); oversize uploads surface as a clear 413 in the Sync diagnostics panel instead of silently being skipped. The file-type allowlist still gates what's eligible for sync.

Sync hardening. Two real bugs were keeping changes from propagating: pulling a folder from another device never refreshed the file tree, and pushing a folder broke the entire push batch because we tried to upload a non-existent blob for it. Both fixed, with regression tests. New Sync diagnostics panel in Settings shows your signed-in email, device ID, vault ID, pending op count, last push/pull timestamps, and any recent errors. It's the first place to look when sync isn't behaving. Includes a Copy diagnostics button for bug reports and a Force re-sync button that re-fetches the entire manifest from the server when local state has drifted. Auto push/pull loops now record errors instead of silently swallowing them.

Paste or drop images straight into a note. Clipboard images land in an `assets/` folder next to your vault root as `pasted-<timestamp>.<ext>`; files dropped from Finder or Explorer keep their original filename. The markdown reference is inserted at the cursor with the correct relative path. Sync no longer creates spurious `.conflict-*` files on routine remote updates: conflicts now only get written when both devices have unsynced edits to the same file. The version number in the sidebar finally renders on macOS bundles too.

Sync any common document or image, not just markdown. PDFs, Word, Excel, PowerPoint, OpenDocument, RTF, EPUB, and all major image formats are now encrypted and synced alongside your notes. Video, audio, and archives are deliberately excluded; individual files over 25 MiB are skipped. Click a non-markdown file in the sidebar and it opens with your OS's default app. Version number now shows in the bottom-left of the sidebar. Cleaner tab overflow when many notes are open: hidden scrollbar, mouse wheel scrolls horizontally, the active tab auto-scrolls into view. Recovery-phrase screens no longer overflow the modal on small windows.

Multi-device sync polish. Editor now refreshes when another device's edits arrive (no more close-and-reopen). Always-keep conflict semantics: any divergent version becomes a sibling .conflict-* file rather than being silently overwritten. Saved an `[object Object]` error from leaking into the UI when an autosave hit a hash conflict.

Fixed two sync bugs: server-side ops_blob encoding and client-side own-device echo suppression. Required for fresh-restore on a second device.

Restore folder check accepts non-empty folders (only refuses if a Jotura vault is already there). Pull failures during restore clean up partial state. More specific decrypt error messages.

First release. Encrypted local-first markdown editor with cross-device sync.