Zephr

The golden path

Five stages, anda record at every one.

Install, connect, admit a scope, recall, hand off. Each stage below shows the artifact it actually produces — an evidence card you can select and copy, not a picture of one — and says plainly what is shipped and what is still moving.

npm publication not shippedLinux x64Windows / macOSSigned handoff proven end to end
Stage 1 of 5Install

Get the interface onto the machine.

One command is the designed entry point. It is not on the public registry yet, so the build-from-source path is shown next to it — the commands underneath are the same either way.

npm publication not shippedLinux x64Windows / macOS
Install · designed entry pointNot published

The one-liner we are building toward

npx zephr connect

The one-liner is the designed entry point and is not published to the public registry yet. The build-from-source path beside it is the one that works today.

npm publication not shippedshown as a contract, not a working path
Install · working path todayVerified

Build from source

git clone https://github.com/DigitalSoftDistribution/zephr.git
cd zephr
pnpm install --frozen-lockfile
pnpm --filter @zephr/protocol build && pnpm --filter @zephr/core build
pnpm --filter @zephr/mcp-server build && pnpm --filter @zephr/mcp build

This is the install path the maintainers use. Once the package publishes, the one-liner replaces these five lines and nothing else about the journey changes.

Node.js 24.x · pnpm · linux x64

Illustrative example — not live data

Continuous integration runs on Linux x64 only. Binaries are packaged upstream for macOS and Windows, and they stay unclaimed until a runner proves them here.

Stage 2 of 5Connect

Authenticate, then pick where the work lives.

A device flow puts a code on the terminal and the approval in the browser. Once it returns, an organization and a project exist — the two containers everything else is scoped by.

Device flowManaged cloud
Connect · device flowVerified

Approved in the browser, not the terminal

The terminal prints a short user code and a verification URL. You approve it in a browser session that already knows who you are, and the terminal picks up the grant.

Grant
Device authorization
Stored
Access and refresh tokens, locally, with an expiry
Not stored
Any password, ever
RFC 8628 · expiring credentials
Connect · organization + projectVerified

acme · billing-service

A project is the outermost container for memory. It gets an immutable identifier, and every belief, admission, and handoff that follows names it.

Org
acme
Project
billing-service
Repository
origin/main
created on first run

Illustrative example — not live data

No password is ever typed into a terminal prompt. Credentials land locally with an expiry and refresh on their own; re-running the connect command with a force flag re-authenticates from scratch.

Stage 3 of 5Admit

Admit the scope, and consent to indexing separately.

Admission happens before the first tool call, never on it. The connection is bound to one project, one repository, one worktree — immutably, for its whole life. Code indexing is a second, separate yes.

Immutable scope bindingExplicit indexing consent
Admit · bindingVerified

One project, one repo, one worktree

Project
billing-service
Repository
origin/main
Worktree
/home/dev/billing-service
Path
Revocable metadata — not the identity
epoch 1 · immutable
Admit · indexing consentVerified

A separate, explicit yes

Admitting a scope does not give Zephr permission to read the code in it. Code intelligence is a distinct consent with its own record, and declining it leaves memory and handoff fully working.

Lexical
Consented
Structural
Consented
Semantic
Declined — no embeddings generated
opt in · never inferred
Admit · out of scopeNot admitted

What this connection cannot reach

A second worktree on the same machine is not covered by this binding. The connection cannot read from it or write to it, and asking does not silently widen the scope.

Worktree
/tmp/billing-hotfix
Verdict
Outside the binding
requires a new admission

Illustrative example — not live data

Changing scope is not an edit — it requires a newly admitted connection with a new binding epoch. That is what makes a stale or over-broad binding impossible to inherit by accident.

Stage 4 of 5Recall

Write one memory, then ask a real question.

The run does not stop at “configuration written”. It records a decision, then asks where authentication is enforced — and the answer arrives with its sources, or it abstains and says why.

Remember + recallStructured abstentionHosted code intelligence
Recall · first captureUnreviewed

Auth is enforced in the gateway middleware, not per-route.

The first thing written is a decision, not a summary of the session. It is captured explicitly, and it enters the ledger as unreviewed because no human has confirmed it yet.

Scope
billing-service
Confidence
Provisional — single source, unreviewed
Recall · answeredVerified

“Where is auth enforced?”

The answer names the files it came from, at the revision it read them, with the review state of each supporting claim. The provenance is the answer as much as the sentence is.

  • apps/gateway/src/middleware/auth.ts L34–L71
  • apps/gateway/src/server.ts L18–L24
  • docs/adr/ADR-009-scope-admission.md §2
Sources verifiedEd25519
Recall · abstainedUnavailable

“What is the rate limit on the webhook endpoint?”

Nothing in this scope supports a number, and the one document that mentions one changed after it was cited. Recall returns an explicit unavailable with that reason rather than guessing.

Reason
Insufficient evidence · 1 cited file changed since capture
Suggested
Re-verify the citation, or capture the current value
no answer is an answer

Illustrative example — not live data

Abstention is the part worth watching. When the evidence is thin, recall returns an explicit unavailable with the reason attached rather than a confident sentence with nothing behind it.

Stage 5 of 5Handoff

Seal the session and open it somewhere else.

A handoff is a signed, one-time envelope. The receiving tool verifies the signature and the scope binding before it parses a single claim, and a consumed envelope cannot be replayed.

Signed handoff proven end to endOne-time consumptionCross-device resume
Slipstream · envelopeVerified

Sealed in Claude Code

The claims, their citations, the scope binding, and the review states are serialized into one envelope and signed. A destination-bound one-time code rides along with it.

Payload
2 claims · 5 citations · 1 commit
Scope
billing-service · origin/main
Replay
One-time — consumption is atomic
SignedEd25519
Cursor · resumedVerified before parse

Opened in a second tool

The receiving client checks the signature, then the one-time destination code, then recomputes the manifest — all before any content is read. Same claims, same review states, same scope, same rules.

Review state
Carried intact, with its origin recorded
Mismatch
A contract mismatch downgrades visibly, never silently
Revoked
A revoked handoff fails closed
Signature validEd25519

Illustrative example — not live data

Authenticate before parse, not parse then check. The signature covers the citations as well as the claims, so a receiving agent can tell whether the supporting files were swapped in transit.

Walk it yourself.

The install documentation carries the build-from-source path that works today. The trust page explains what the review states and abstentions above actually mean.