
Release notes.
2026-11-16
format 1 · unchanged
An audit log grows for as long as the vault lives, so a question about one moment should not cost a walk through all of it. And a search can be for a username or an address, so the log should say what the search found, never what it asked. VaultDB 3.1.1 does both. The API and the file format do not change.
A time window reads only that window
audit_query and audit_count with since or until used to read the log from the newest event down and drop what fell outside the window. Now a window of up to 4,096 events, or up to 64k events and under an eighth of the log, is one read over the time index. A wider window, and a read without one, walks newest first as before, which is the cheaper way when the window is most of the log. The results are the same events in the same order, both edges included. On a log of 500,000 events, the lookup for a one-millisecond window went from 50–100 ms to under 2 ms. In Clavitor’s vault, the History panel looks up each version’s writer this way, so a ten-version history opens in milliseconds instead of about a second.
A search records what it found
search and search_type used to seal the query text into the audit event. Now a search with one hit names that entry, so the event also shows in that entry’s own audit trail; with no hit or several it records only the count. The reason keeps the field, the type and the number of hits, never what the user typed. Events sealed before 3.1.1 keep what they were written with: the chain is append-only.
For developers
- Nothing to upgrade. Every signature, error and result shape is as in 3.1.0, and a 3.1.0 store opens unchanged. No migration.
- Bundled SQLite is 3.54, through rusqlite 0.41.1.
- First in production inside Clavitor’s vault on 16 November 2026.
2026-11-04
format 1 · unchanged
An audit chain is only as good as the names in it, and a list is only as complete as what it tells you it left out. VaultDB 3.1.0 tightens both, and adds a direct way from an index hit to its record.
Every write names who asked
A host that writes on its clients' behalf, as Clavitor's vault does, used to have every create, edit and delete sealed into the chain as system. Now every write, refusal and failure carries the actor the host names for the request, such as an AI agent or the web app, and a grant records the same actor as its grantor. Events sealed before 3.1.0 keep the system they were written with: the chain is append-only.
A list that says what it could not open
list_checked returns what list returns, plus every row the caller can reach that would not decrypt, with its id and the reason. A caller that must never pass off a partial list as complete can stop and name what is missing. Clavitor's vault export uses it: an export now stops and names the unreadable entries instead of writing a file that looks whole.
From an index hit to its record
query_index_records takes the same arguments as query_index and returns the record id behind each hit, so a caller goes straight from a match to the record. The access filter, the order and the audit event are the same.
For developers
- Nothing to upgrade. Every addition is new API beside the old: list and query_index keep their signatures and behaviour, Error has no new variants, and a 3.0.0 store opens unchanged.
- New calls: Store::list_checked (with the new type Unreadable) and Store::query_index_records.
- 208 tests pass across the workspace, 1 ignored, 0 failed. First in production inside Clavitor's vault on 4 November 2026.
October 2026
format 1 · unchanged
A record was never the whole story. A patient record has its scans. A contract has the signed PDF. A credential has the certificate it belongs to. Until now those files lived somewhere else, under someone else's rules: a bucket with its own permissions, its own logs, its own idea of deletion.
VaultDB 3.0.0 brings them inside: with the record they belong to, under the same seal, the same access and the same audit chain. The engine now holds the attachments too, sealed like everything else. A medical imaging platform built on VaultDB keeps its documents, photos, thumbnails and DICOM image slices this way.
Objects: files under the record's own rules
Every file lives in one of three buckets, chosen when you store it:
- secure-full: belongs to a record, sealed, and every read and every write goes on the audit chain. For what must leave a trace each time it is opened.
- secure-writes: belongs to a record, sealed, every write on the chain, reads left quiet. For what is written once and read often, like image slices.
- plain: addressed by name, compressed, and sealed under your key whenever you give one. For what needs no ceremony.
Nothing is overwritten. Every put is a new version, and a delete leaves a marker, not a hole. Files run up to 64 MB, read whole or by range, and list by prefix and delimiter with paging, the way object stores taught everyone to expect.
Bound, not just stored
Each sealed file is bound to its bucket, its owner, its file id and its version. Move it to another record or bucket, or pass one version off as another, and it no longer opens. Its SHA-256, which doubles as its ETag, and its content type are sealed with it.
Erasure that reaches the attachments
Crypto-shred a record and its files become unreadable in the same breath. sweep() then removes them; cleanup_files() clears what an interrupted write left behind. No forgotten scan in a folder nobody remembers. verify_deep checks every file as well as every record.
Your events, on the same chain
Your application can now write its own events into the audit log: a document opened, an approval given, a series viewed. The engine records who did it. The caller never gets to say.
Running where it counts
VaultDB is the store behind Clavitor, the credential vault for people and their AI agents. With this release, Clavitor's servers moved together to a post-quantum channel: classical P-256 alongside ML-KEM-768, the key agreement standardised as FIPS 203. Traffic recorded today stays sealed against a quantum computer built later, as long as the server's long-term key is not also stolen. All of the servers' cryptography now comes from one FIPS 140-3 validated module, AWS-LC FIPS 3.1 (CMVP #5314), the same module VaultDB uses at rest, and a check in every build refuses anything else.
Inside the vault, an AI agent with a scoped key now touches what it was handed and nothing else: writes, deletes and searches all stay inside its scopes. And when an account is recovered, the recovery goes on the record, on the chain anyone can verify without a key.
For developers
- Objects runs in-process, in the engine you link. Point a store at its files with Store::set_files_home; the files sit beside the .vault file, in one directory for the secure buckets and one for plain.
- New engine-owned table: vdb_files, the files manifest. The file format does not change: still format 1.
- New calls: put_file, get_file, head_file, delete_file, list_files, list_file_versions, sweep, cleanup_files on Store; files::plain_put and its siblings for the plain bucket; Store::log_event; Store::grants_in, every active grant in a dossier in one read.
- New error variants: BadEvent, ReadOnlyStore, FilesNotConfigured, FileTooLarge, FileDamaged, BadName, WrongBucket, NeedsKey, BadRange.
2026-10-17
format 1 · unchanged
The secure part is unchanged: encrypted, audited, shreddable. New is a plain part for ordinary tables with clean, guarded SQL: query for one read-only statement, and transaction for several statements that commit together or not at all, each able to carry an expectation of the rows it must return or change. Use it for data that is not about a person and needs ordinary queries: a schedule's slots, settings, counters, catalogues. Same file format.
The guard
SQLite's authorizer, asked about every table, function, pragma and schema change a statement touches. VaultDB's own tables can be read and are never written; every other table can be created, altered, indexed, read, written and dropped inside a transaction. ATTACH, writing pragmas, extensions, virtual tables, VACUUM and nested transactions are refused, and a statement the guard was never asked about is refused too. Each call is capped at 10,000 rows and 2 seconds.
Fixed
It includes the three fixes prepared as 2.0.1, never released on its own: folded denial counts now reach the audit chain, a new file is keyed in one transaction, and writes wait for another writer's lock instead of failing at once.