Continuity / Slipstream
Hand off mid-task.Land mid-thought.Continuity you can show.
A Continuity Format v1.1 packet that travels between agents and tools. Ed25519 source signature, destination-bound HMAC, verify-before-import, one-time consume that revokes itself — and the corrupt-a-byte scene below is the proof that continuity is verifiable, not just promised.
> zephr handoff --file handoff.json
> sign with ed25519:9f4c...d013
> bind to destination: cursor
> zephr resume handoff.json
> verify signature, hmac, scope
> import once - consume 1/1
Every handoff is a trust boundary.
The usual answers are to paste a summary into the next chat, or to start over and re-earn the same context. Neither preserves the claims, their anchors, the review state they had reached, or the scope under which they were admitted.
The layer underneath holds the answer.
The fix
Carry the signed packet.
Ed25519 over the whole envelope. HMAC to the destination. Atomic consume. That is the only path that survives a tool boundary.
illustrative example - not live data
Opened, every field is a guarantee.
A signed Continuity Format v1.1 envelope. The fields are the real guarantees — the destination verifies them before reading a single claim.
- signature
- ed25519:9f4c…
- Signed at the origin over the claims and their citations together, so neither can be edited without breaking the other.
- citations
- sha256:2b81…
- A digest of the sources the claims rest on. A receiver that cannot resolve them knows so before it reasons, not after.
- replay
- consumed 1/1
- The consumption record is an atomic compare-and-swap. A second presentation of the same ticket is refused, not deduplicated.
Presented a second time, the envelope is refused rather than replayed.
illustrative example - not live data
The seal covers the whole envelope.
Ed25519 over the payload and the anchors. HMAC to the destination that is allowed to open it. The destination re-runs the same computation before it reasons.
Signed
ed25519:9f4c2ab7…d013
hmac-sha256:5b81e0c7…a4f3
Just now
0ms
The signature is computed over the whole envelope. The destination re-runs the same computation before it reasons — that is the entire check.
The destination authenticates before it parses.
Four checks, in order. If any of them fails, the receiver refuses the packet before reading a single claim.
What the destination checks
Ed25519 signature
the source signed the whole envelope
Destination HMAC
binds it to the receiving tool
Scope proof
matches the worktree it claims to be from
Allowed-tool contract
declares what the destination may do with it
What happens if one fails
Refused before a claim is read.
The destination emits a short refusal — what failed and why — and does not surface the packet to the agent. There is no partial import.
Change one byte and import refuses.
The signature covers the whole envelope. Flip one character and the HMAC, the signature, and the digest all disagree. The destination refuses before reading a single claim.
The packet (lens active)
sha-256: 9f2a - e7c1 - 3b4d - a8e6 signed.by: [email protected]
Break one character
Watch the lens.
Consume once, then it is gone.
Import is atomic and compare-and-swap. A second resume of the same packet returns already_consumed, not a replay.
The consume record shows 1 of 1. A second presentation of the same packet is refused as already_consumed.
Wrong note in every tool at once.
Pull it back and Claude Code, Cursor, and Codex lose it together. Not a silent delete — you, just now, and why.
you, just now - wrong note - reason logged
Hand off a real packet.
The CLI is the surface that ships. Run a handoff, then a resume. Watch the packet travel; watch it refuse a replay.
zephr handoff --file handoff.jsonpackages the session
zephr resume handoff.jsonverifies, then imports
zephr receipts exportaudits the handoff