The team's store is a bucket, a folder on a server, a Git remote or a database. Never ours.
A team shares its work through storage it already owns. The store is plain files: it runs no code and holds no secret, because every document in it is signed by its writer and every sealed part is encrypted to the people allowed to read it. Take a reader off a project and its key turns. LockFlare is not in the path and could not read a byte if it were.
Where it can live
Signed by the writer. Sealed to the readers.
The store cannot tell a stale write from a fresh one, so Sonda never trusts it to: the signatures, the keys and the commit points are the Sondas', and the store only holds files.
Every file is an Ed25519 envelope around AES-256-GCM. The project's key is wrapped once for each reader; take a reader off and the key turns, so nothing published after that is sealed under a key the person holds. Every revision is a file of its own, and the head, written last, is the commit point.
Sonda Server, the store on a box of yoursThe store holds files. The Sondas hold the trust.
The store keeps the files and refuses a stale write. Everything else — who wrote it, who may read it, which version counts — is checked by the Sondas reading it.
Every document signed by its writer.
An Ed25519 envelope around every file; a reader accepts only the signers that collection allows. Rosters, roles, project metadata, locks, approvals and secrets each carry their own signed prefix.
A key per project, wrapped for each reader.
Thirty-two random bytes, sealed with AES-256-GCM and the file's path as associated data. Wrapped separately for each reader with X25519 and HKDF-SHA256. Access to the bucket alone decrypts nothing.
A reader removed turns the key.
Old keys retire so earlier revisions still open; the next administrator publish reseals everything under the new key. Nothing published after that is sealed under a key the person holds. A revoke pauses first, re-signs, turns, and revokes last.
A file per revision. The head, last.
Every folder and item is written once as rev-hash.sonda and never overwritten; the head is written last and is the commit point. Two to a hundred revisions kept per item, twenty by default; the last ten minutes never pruned.
A commit point on every store.
S3 If-Match, GCS generation match, Azure If-Match, Git's push, SSH compare-and-rename under a lock, WebDAV ETags, MongoDB's update filtered on the version read. A write based on a stale version is refused, and a store that ignores the condition is reported on the activity line.
What never goes up.
A flow's runs, a load test's reports, an MCP server's last arguments, the values of secret rows, your "My values", a tunnel's login, the local sync marks. FTP and plain folders were removed as stores because they cannot refuse a stale write.
Save writes this computer. Publish sends.
Every item is edited on its tab's copy. Save & Publish sends one item; Publish sends everything waiting. The sync reads the store about once a minute.
Beside it, one publish as the store receives it: the new revisions first, each signed and sealed, and the head last — written only if nobody moved it since it was read. The same head, sent a moment later from a computer that read it earlier, is refused.