Use cases.
Storage, verification, stream capture, and pipeline workflows.
Before: an incident report sits in a folder. The file modification time is whatever it was when you last saved it. If anyone asks when it was created or whether it has been altered, you have no answer that doesn't depend on trusting you.
After: a signed receipt proves the exact byte content was committed at a specific time. The continuity ledger proves receipt ordering and makes silent removal or insertion detectable. The original content can stay private.
Before: a build output sits in S3. The timestamp is the upload time. Nothing proves what the bytes were when the job ran, or that the object hasn't been overwritten since.
After: a receipt is issued at upload time, tied to the SHA-256 of the ciphertext. The object ID is deterministic — the same bytes always produce the same ID. Proving a specific binary existed at a specific pipeline step is a receipt check.
Before: a model was trained on "version 3 of the dataset." Version 3 is a directory. Nobody wrote down its exact contents at training time. Reproducing the result requires trusting that nothing has changed.
After: the dataset snapshot is committed before training begins. The receipt proves which exact bytes were present. The content commitment hides the dataset hash from the storage server while still binding the receipt to that specific version.
Before: controls exports and audit artifacts live in a shared drive. The audit trail is a spreadsheet. Proving what was submitted when, and that nothing was added retroactively, requires trusting whoever manages the drive.
After: each artifact is committed with a receipt. Receipts are anchored into the continuity ledger in order. The ledger is a hash chain — inserting, removing, or reordering entries breaks the chain. Sequence proof is structural, not administrative.
Before: a log file is rotated nightly. A config directory is git-committed whenever someone remembers. The history exists in fragments across different systems. Reconstructing what a file looked like at 14:30 on a specific date is archaeology.
After: vault stream snapshots the target on an interval. Each snapshot is a full vault put — encrypted, receipted, ledger-anchored. The stream builds a per-stream hash chain across all snapshots. Any specific version is retrievable by index.
Before: sensitive files are backed up to cloud storage. The provider can read them. If the provider is subpoenaed, acquired, or breached, the content is exposed. Encrypting before upload means managing keys separately with no standard workflow.
After: vault handles client-side encryption, key storage, and receipt issuance in one command. The provider sees only opaque ciphertext addressed by SHA-256. The decryption key never leaves your machine.
Before: a preprint is posted with a date. The date is whatever the server says. If a priority dispute arises, you have a timestamp and a claim. You do not have independent proof that the file existed in that form before the dispute began.
After: a receipt is issued at commit time, signed by a server key whose public key is independently verifiable. The receipt can be shared with reviewers or a journal. The content stays encrypted — the proof does not require disclosure.
Before: CI stores artifacts to S3 with no receipt. Cron jobs run and produce output that disappears into logs. Proving what ran, when, and with what result means parsing log files and hoping the timestamps are trustworthy.
After: vault's machine mode emits stable key=value output on stdout for supported commands. Scripts capture the object ID and receipt path. Standard UNIX tools compose with it directly. Scripts should ignore unknown future keys — the output contract is stable and additive. --machine and --quiet never prompt; missing required input fails immediately.