Use cases / Solo developer
You work alone, across Claude Code and Cursor, on a project that has accumulated a year of decisions you can no longer hold in your head. One SQLite file, no account, and continuity that survives closing the window and switching the tool.
Use PKCE for the public client — decided in PR #312.
zephr recall "why did I choose PKCE?"
→ the same sentence, with the source attached
next tuesday, in a different editor — the answer is still there
Illustrative example — not live data
You made an auth decision a week ago in a Claude Code session you have since closed. You reopen the file in Cursor, ask why it looks the way it does, and get a fluent answer that may or may not be the reason you had. The answer sounds the same either way, and that is the actual problem — not that the tool forgot, but that you cannot tell when it did. So you do the thing everyone does: you re-derive the decision from the code in front of you, land somewhere close to the original, and carry a small unpayable debt about whether the constraint you were working around still exists. Multiply that by a year of decisions and the project stops being something you know and becomes something you keep re-reading.
On the left, what a week-old decision looks like without a ledger. On the right, the record Zephr keeps — the claim, the file it rests on, the date, and the review state, all still attached.
The answer is somewhere in a Claude session you closed, or a Cursor thread you did not save, or a note you meant to write. Whatever the next agent tells you about it will sound equally confident either way.
The implicit flow was rejected because the client cannot hold a secret, so a code interception without PKCE is trivially replayable.
Any connected tool can recall this, and ifsrc/auth.md changes, the anchor is reclassified before the claim is served again.
Illustrative example — not live data
Scrub the timeline. The question, the decision, the capture, the closed window, and next Tuesday's recall in a different editor — each beat shows the real artifact Zephr leaves behind, because the story is the artifacts, not the adjectives.
Tuesday · 09:14
You open the auth flow in Claude Code and ask how the public client should hold its token. The answer matters and you will not remember why in a week.
> how should the public client hold its token?
illustrative day — the commands and record shape mirror the shipped local mode
Three steps, each leaving a real artefact behind: a cited record in your graph, a signed packet between tools, and a recall that shows its sources or says plainly that it has none. None of the three asks you to keep a second set of notes. The record is written where the work already happens, which is the only kind of bookkeeping that survives a bad week.
zephr remember "Use PKCE for the public client" --source src/auth.md#L41zephr recall "why did I choose PKCE?"Hand a decision to zephr_remember with its source and anchor. It enters your local evidence graph as a dated, cited record — not a summary in a black box.
Open Cursor against the same admitted worktree. The continuity packet carries the decision across, and the receiving agent verifies the signature before trusting it.
zephr_recall shows why a result came back: which files, which commit, which review state. When nothing clears the bar it abstains and says what is missing.
Continuity is a storage decision here, not a personality. The two sessions never speak to each other; they both speak to one SQLite file on your disk, and that file is the only thing that survives closing the window.
Without it, the second session starts from nothing and reconstructs an answer that sounds exactly as confident as the one you actually had.
Illustrative example — not live data
Clone the repo, build from source, connect a client, and start capturing cited memories. The shipped capabilities come first. The two that are not built are named here rather than discovered later, because finding out during setup that the install path does not exist is a worse experience than reading it on the page that sold you on it.
SQLite-backed beliefs with provenance, confidence, and revision chains. One file on disk, no account, no egress.
core evidence graph · ADR-012
An Ed25519-signed, single-use continuity packet carries a decision between sessions and tools. The signature covers the citations, not just the claim.
Slipstream v1 · E2E-proven on main
Deterministic, CI-blocking tests for retrieval, scope, and contradiction behavior. You can run the trust claims yourself rather than take them on faith.
deterministic suite · ADR-013
Consented MCP configuration for both clients. Zephr reads what it is handed; it does not scrape private editor state.
client-adapters package
The one-line install path does not exist yet. Today the entry point is cloning the repo and building from source.
golden path designed in the Connect cluster; not built
Resuming on a second machine under the same account requires the managed cloud, which is still gathering evidence.
gated on the ADR-010 tenancy gate
npx distribution and cross-device sync are documented in the roadmap and are not available today.
You stop opening a session by re-explaining the project. You ask the question you actually have, and what comes back either carries the file and the date it rests on or tells you it has nothing. Both answers are useful; only one of them was available before. The work of remembering moves out of your head and into a file you can read, and it stays on your machine.
Build from source, connect your first client, and capture one decision. Nothing on the roadmap has to land before this is useful to one person on one machine.