Everett 2.0.0

Everett 2.0.0

Everett 2.0 adds a guided first run, native Cloudflare account and relay support, signed device discovery, and an OAuth resource-server mode for the Rust gateway. Local and SSH workflows remain available without an Everett account.

Install or update

curl -fsSL https://raw.githubusercontent.com/raitoxlol/everett/main/install.sh | sh
everett doctor

The installer verifies the archive checksum. Set EVERETT_VERSION=v2.0.0 to pin this release. To build from source, run cargo install --git https://github.com/raitoxlol/everett everett.

What changed

• Guided setup and native account approval. First run offers local, cloud, and VM choices. Cloud and VM connections remain pending until configured. The native Cloudflare flow uses GitHub to identify the account owner and approve a device; it does not sign in to an agent provider. Cloudflare credentials and relay state are separate from OIDC/Convex state.
• Native Cloudflare relay. Add outbound HTTPS polling, encrypted message delivery, durable ciphertext staging, retry handling, and explicit peer fingerprint pins. A physical Mac/NUC fixture passed. Public cross-device message delivery has not yet been verified.
• OAuth resource server. The Rust gateway can authorize allowlisted external clients with PKCE, rotating refresh tokens, introspection, and revocation. Dynamic client registration is not supported. Live ChatGPT OAuth has not yet been verified.
• Device discovery and revocation. everett devices pages signed registry metadata used by peer add NAME. Pairing still requires out-of-band fingerprint checks. Revocations propagate when an offline peer next fetches them; existing SSH connections are not terminated.
• MCP identity and routing. Bind calls to host or per-call session identity, return identity failures as tool errors, and fall back to local routing when Jev rejects a request. Track reply depth separately from forward hops and install hooks only for harnesses Everett detects or the user selects.

Upgrade from 1.6.0

• The 1.6.0 release already uses encrypted relay v2. This CLI version bump does not change that wire protocol. A deployment still using relay v1 needs a reviewed migration that preserves revocation and replay records; do not delete the data and re-enroll.
• Native Cloudflare credentials and state are separate from OIDC/Convex credentials and state; there is no automatic import between them. Existing OIDC configuration remains available.
• Native Cloudflare device authorization is a custom protocol, not RFC 8628. Local and SSH workflows remain usable without account sign-in.

Verification and release scope

The public first-run GitHub account flow automatically advanced to the agent chooser, and a repeat bare everett invocation passed. A physical Mac/NUC fixture passed. Public cross-device delivery and live ChatGPT OAuth remain unverified.

The tagged CLI workflow runs Rust tests and Clippy on macOS and Linux, then builds four platform targets. Publishing the CLI does not deploy the Cloudflare Worker; Worker deployment and the Homebrew tap are separate operations.

See CHANGELOG.md for the complete history.

Everett 1.6.0

Everett 1.6.0

Everett now reaches your agents on your other machines. Two independent transports ship in this
release, manual SSH and an end-to-end encrypted Convex relay. Neither one wakes or resumes a remote
session.

Install or update

curl -fsSL https://raw.githubusercontent.com/raitoxlol/everett/main/install.sh | sh
everett install-hooks --apply && everett install-mcp --apply
everett doctor

install.sh installs or updates everett in ~/.local/bin (override with EVERETT_INSTALL_DIR,
pin with EVERETT_VERSION=v1.6.0) and verifies the archive's SHA-256 before installing.
To build from source: cargo install --git https://github.com/raitoxlol/everett everett.

What changed

• Cross-device peers over SSH. everett peer add, serve, ls, card, status, identity,
  list, remove and revoke, plus ls --peer and explicit remote inbox sends. Pairing verifies
  host and device fingerprints, pins host keys, and installs a tagged restricted forced command in
  the receiver's real ~/.ssh/authorized_keys. Replies return through status polling, with
  idempotent send/reply recovery, observed queued/delivered/replied states, a three-hop end-to-end
  limit, 64 KiB request frames and 20-second deadlines. An offline peer fails fast with no local
  retry queue. SSH needs no registry, sign-in, Convex relay or Everett listener.
• Encrypted relay v2. Same-owner/account or same-org agent chat over live Convex WebSocket
  subscriptions, behind NAT, with no SSH or Tailscale dependency. Message and reply bodies use
  independent X25519 + HKDF-SHA256 + ChaCha20Poly1305 keys; envelopes and bundles are signed with
  independent relay Ed25519 keys. Cross-org chat needs bilateral org-admin grants through
  relay grant invite / accept / reconfirm / revoke / get / list, and a changed key blocks traffic
  until both admins reconfirm and peers re-pin.
• Breaking: relay v2 is incompatible with v1 envelopes, pins and schema. The v2 protocol requires
  verified OIDC ID tokens with issuer-controlled agent, org and role claims, authoritative active
  membership, and a distinct per-agent revocable credential on every public function. An existing v1
  deployment needs a reviewed migration that preserves revocation and replay records, not deletion
  and re-enrollment. Operator provisioning is required; there is no public enrollment API.
• Host-bound MCP caller identity for delivery and replies. Conflicting model session IDs are
  rejected instead of replacing provenance or hop lineage. Harnesses without native detection must
  bind EVERETT_SESSION_ID in their MCP launch environment.
• Bounded state and explicit repair. Rejected-message diagnostics are bounded, peer remove NAME --transport ssh|convex repairs ambiguous legacy aliases, and ambiguous routing or removal now
  fails closed. Signed delivery deletes the live ciphertext row, and undelivered messages expire
  after one hour with bounded cron cleanup.

See CHANGELOG.md for the full list.

Verification

GitHub Actions runs clippy (-D warnings), cargo test and the release journey (all 10 MCP tools
over isolated stores) on macOS and Linux, plus the Convex backend typecheck and tests, before
building the release targets. A live Convex deployment, live OIDC, real sshd enforcement on two
machines, real T3 hook pickup and live dots/Grok connections remain owner checks, not implied by the
offline coverage.

Everett 1.5.0

Everett 1.5.0

Everett is now Rust only. The Python package is gone; the everett binary carries every command.

Install or update

curl -fsSL https://raw.githubusercontent.com/raitoxlol/everett/main/install.sh | sh
everett install-hooks --apply && everett install-mcp --apply
everett doctor

install.sh installs or updates everett in ~/.local/bin (override with EVERETT_INSTALL_DIR,
pin with EVERETT_VERSION=v1.5.0) and verifies the archive's SHA-256 before installing.
To build from source: cargo install --git https://github.com/raitoxlol/everett everett.

Upgrading from pipx: install-hooks --apply and install-mcp --apply back up your config and
point the old Python hooks, -m everett mcp launchers and the OMP extension at the native binary.
Then pipx uninstall everett-sessions. pipx install no longer works.

What changed

• Breaking: the Python package, pyproject.toml, bin/everett and the Python tests are removed.
  Its test coverage is ported to everett-rs/tests/; CI runs the release journey against a release build.
• New harnesses: current T3 Code projections (inbox-only continuation, no fake hook pickup),
  Devin CLI MCP registration via install-mcp --devin, and OpenAI dots / Grok Bot as durable external
  sessions (everett external add|list|remove).
• everett gateway: owner-bound MCP gateway for dots and Grok Bot with a fixed identity, explicit
  destination grants, private stdio or bearer-authenticated loopback HTTP, and exact-ID-only delivery.
  No automatic wake-ups or cross-device transport.
• everett dashboard: read-only, loopback-only local HTML dashboard with recent sessions,
  Everett cards, filters and copyable CLI actions.
• everett login / whoami / logout: optional OIDC device-code sign-in (docs/auth.md).
• Audit hardening: stale hook/MCP detection and repair, per-session inbox locking and compaction,
  atomic config/subscription writes, MCP panic containment, full-mtime auto-card freshness, hop-limit
  enforcement for live sessions, and many adapter parity fixes. See CHANGELOG.md for the full list.

Verification

GitHub Actions runs clippy (-D warnings), cargo test and the release journey (all 10 MCP tools over
isolated stores, no Python on PATH) on macOS and Linux before building the release targets.
Live dots/Grok connections, real T3 hook pickup and GUI client trust prompts remain owner checks.

Everett 1.4.0

Everett 1.4.0

Everett now ships as a standalone Rust binary for macOS and Linux. No Python is needed to run it.

Install or update

curl -fsSL https://raw.githubusercontent.com/raitoxlol/everett/main/install.sh | sh
everett doctor

install.sh installs or updates everett in ~/.local/bin (override with EVERETT_INSTALL_DIR,
pin with EVERETT_VERSION=v1.4.0) and verifies the archive's SHA-256 before installing.
To build from source: cargo install --git https://github.com/raitoxlol/everett everett.

The Python package stays available during the transition (pipx upgrade everett-sessions).

What changed

• Rust binary releases: everett-<target>.tar.gz + .sha256 for macOS arm64/x86_64 and
  static Linux musl x86_64/aarch64, plus a rendered binary Homebrew formula (everett.rb).
• Parity: the Rust CLI and stdio MCP server expose the same commands and 10 tools as the
  Python implementation, including the ratatui onboarding wizard.
• Devin CLI adapter: everett ls, routing and send include Devin CLI sessions
  (sessions.db plus ATIF transcripts). send resumes with devin --resume <id> --print.
• Linux: the crate builds and tests on Linux. doctor's MCP probe inherits the caller's
  environment, so it no longer writes .everett/mcp.log into the working directory.

Verification

GitHub Actions runs cargo test on macOS and Linux before building the release targets.
The Rust end-to-end journey exercises all 10 MCP tools over isolated session stores.
Live model resumes and GUI client trust prompts remain separate checks.

Everett 1.3.0

Everett 1.3.0

Route requests, messages, and shared memory across your coding-agent sessions—from a CLI or MCP client.

This relaunch focuses on first-run setup, useful diagnosis, and reliable memory updates.
Everett is MIT licensed and supports Claude Code, Codex, OMP, Pi, Hermes Agent, and Grok CLI.

Get started

Have Python 3.10+, pipx, Git and at least one harness CLI installed on macOS or Linux:

pipx install git+https://github.com/raitoxlol/everett
everett onboard --yes --no-backfill
everett doctor

Restart configured harness clients after onboarding. Start a session and run everett ls.
No router key or model call is needed for setup. The package is not published on PyPI.

What changed

• First-run setup: detect installed CLIs before any session exists; include Grok MCP; cancel safely on EOF; explain missing harnesses before waiting.
• MCP diagnosis: doctor checks actual stdio initialization and all 10 tools, then probes registered launchers. Stale or disabled registrations get exact repair commands with backups.
• Delivery: isolate harness stdin from the MCP connection, resolve exact titles, and let MCP routing/sending use a larger session window. Interrupted Codex delivery gets a check-before-retry hint.
• Memory reliability: new facts stay pending while a merge is running, simultaneous mergers are refused, and failed merges retain queued facts. Use everett trunk merge --llm none for a local deterministic merge.
• Release checks and protocol: isolated routing, two-way messages, status and memory journeys; a macOS/Linux CI matrix; fresh wheel verification; validated arguments and logs without their values; a shorter quickstart.

The server advertises 10 tools: everett_ls, everett_route, everett_send, everett_inbox,
everett_event, everett_subscribe, everett_learn, everett_core, everett_card, and everett_whoami.

Upgrade

pipx upgrade everett-sessions
everett doctor

If doctor identifies a stale Claude registration:

everett install-mcp --claude --repair --apply

Use --codex, --omp or --grok for that client, then restart/enable its server. Old log entries
are preserved; only new entries omit argument values. No stored sessions or features are removed.
Python 3.10 gets the small tomli dependency; Python 3.11+ uses the standard library at runtime.

Practical limits

Pi and Hermes need manual MCP configuration and inbox polling. Hook injection requires client
support and enabled/trusted hooks; a queued message is not a read receipt. T3 Code uses underlying
harness hooks for inbox delivery and cannot be resumed through Everett's CLI. Automatic launchd
scheduling and default desktop notifications require macOS; manual merging works on Linux.

Local routing needs no network. Jev routing and harness resumes/LLM merges use their configured
providers. Fresh-install verification uses synthetic stores and no paid model calls; it does not
claim live model-resume or GUI hook/trust verification for every harness.

Codex's Interrupted system call (os error 4) means delivery is unconfirmed. Check the target
before retrying, or use inbox delivery for an open session with Everett hooks. The cause of
reported interruptions remains unconfirmed; failed resumes are not retried automatically.

Verification

281 tests pass on macOS with Python 3.10 and 3.14. Fresh Python 3.10/3.14 wheel installs,
a source-distribution install, pipx, and a locally staged Homebrew recipe all pass the real CLI
and 10-tool stdio journey. Local source-package pipx install → onboarding → doctor completes
in under two minutes with Python, pipx and a detection-only harness stub already available.
The refreshed journey uses a fake Codex to verify resume/spawn stdin and continued MCP traffic.

A separate approved live check used Codex 0.160.0 with its configured model in a read-only sandbox.
Both creation and resume ran through the installed stdio server; the resumed session recalled
its marker, both children received EOF on stdin, and MCP answered pings after each call.
The temporary workspace was unchanged. This verifies current Codex delivery; the cause of the
previous interruption errors remains unconfirmed.

The Homebrew recipe needs the published 1.3.0 tag/archive before it can be updated.
Publication requires passing macOS/Linux unit tests and fresh wheel checks in GitHub Actions
at the release head. Other harness model resumes and GUI client trust prompts remain separate checks.

Everett v1.2.0

1.2.0 — 2026-09-25

Install: brew install raitoxlol/tap/everett or pipx install git+https://github.com/raitoxlol/everett

Onboarding: Jev key + nightly merge

• everett onboard adds a "Smarter routing (optional)" step (curses TUI, plain fallback, and --yes), between MCP and backfill: two lines explain that Jev (typesafe.ai) picks the right session when many are running, and that without it Everett uses local matching.
• Paste a key or skip. If a key is already found (TYPESAFE_API_KEY, ~/.everett/config.toml, or ~/.hermes/.env), the screen shows "Jev key found ✓ (source)" and defaults to skip.
• A pasted key is validated with one test route call (5 s timeout); on success it's saved, on failure you're offered "keep it anyway" or "skip". The key is masked while typing (curses *, plain getpass) and is never echoed or logged — only the saved/validated status appears in the summary.
• The key is written as typesafe_api_key in ~/.everett/config.toml (created chmod 600; every other key and [section] is preserved). --yes --jev-key-env VAR reads the key from an env var for scripted setup.
• The same step carries an optional "merge shared memory nightly" toggle (see below); --yes --schedule-merge opts in non-interactively. The onboarding step count and progress rail updated (6 → 7 steps).

Nightly auto-merge for the shared core

• everett trunk schedule [--at HH:MM] [--remove] [--llm claude|codex|none] prints (default) or, with --apply, installs/removes a macOS LaunchAgent (~/Library/LaunchAgents/dev.everett.core-merge.plist) that runs everett trunk merge --llm <x> nightly (default 04:00, default claude). everett trunk merge already skips cleanly when the inbox is empty. Logs go to ~/.everett/logs/merge.log.
• --apply writes the plist and runs launchctl bootstrap; --remove --apply runs launchctl bootout and deletes the plist. Every path and the launchctl call are injectable (trunk_schedule.install/remove(path=, runner=)), so tests never touch the real ~/Library or launchctl.
• everett doctor reports whether nightly merge is scheduled.

Includes everything in 1.1.0.

Install

brew install raitoxlol/tap/everett
pipx install git+https://github.com/raitoxlol/everett
uv tool install git+https://github.com/raitoxlol/everett
pip install git+https://github.com/raitoxlol/everett   # inside a virtualenv

Everett v1.1.0

First public release. It includes the 1.0.0 work prepared on 2026-09-24, which was never published on its own.

Sessions

• Lists Claude Code, Codex, OMP, Pi, Hermes Agent, and Grok CLI sessions from the stores those harnesses already write. Everett never writes to them. It reads only the first and last 64 KB of transcript files and opens SQLite stores with mode=ro.
• Hermes: ~/.hermes/state.db and ~/.hermes/profiles/*/state.db. The profile name is kept. Chat-platform sessions (Telegram, Discord, and so on) are list/route only. Cron, oneshot, and webhook runs are hidden as automated.
• Pi: ~/.pi/agent/sessions/<cwd-slug>/*.jsonl, in the same format as OMP.
• Grok CLI: ~/.grok/sessions/<url-encoded cwd>/<id>/. Everett reads summary.json for the id, folder, title, and session_kind, and prompt_history.jsonl for the typed requests, falling back to <user_query> blocks in chat_history.jsonl. A session is running while ~/.grok/active_sessions.json names it with a live pid. Headless runs are hidden as automated.
• T3 Code: each thread runs Codex, Claude Code, or Grok underneath, and ~/.t3/userdata/state.sqlite names the underlying session. Those sessions are marked source t3code ([t3code] in ls) and take the thread title when they have none, so nothing is listed twice. Codex sessions started by T3 are also recognized by their t3code_desktop originator.
• everett ls [--json] [--all] [--harness H]. --harness filters before the 40-session cap.

Jev first

• everett_send (and everett send) route by default: omit to and Everett picks the session (jev when a key is configured, else the local matcher) instead of an agent eyeballing everett_ls and sending straight to an id. to is now documented as for a named session or a reply only. The MCP server instructions and the everett_ls / everett_route / everett_send tool descriptions say so explicitly, and everett_ls's says it is for overview, not for picking a send target.
• The everett_send response and the everett send CLI report the routing decision (router jev/local, chosen session, confidence): the CLI prints routed by jev → [claude] ~/src/api — ... (0.87) before delivering. On an ASK decision nothing is sent; the response now carries candidates (up to 3 close sessions) instead of a single suggested guess.

Routing and delivery

• Local router (default without a Jev key): BM25 over each session's card, title, first and last requests, and project folder, weighted by recency. The Jev router is used when a key is set. Both return SESSION / NEW / ASK with a confidence.
• everett send waits for the target to go idle (up to 2 minutes), then resumes it headless and prints the reply. --to <id-prefix|name> skips routing. --spawn starts a new headless session on a confident NEW and records it in ~/.everett/spawned.jsonl.
• Resume and spawn commands: claude --resume / --session-id, codex exec resume / codex exec, omp -r, pi --session, hermes -p <profile> chat --resume, and grok --resume <id> -p / grok --session-id <uuid> -p. send refuses T3 Code sessions, because T3 keeps its own resume point and a CLI resume would fork the thread.
• Safety: a hop guard (EVERETT_HOPS, max 3, exit 7), refusal to send to the calling session, and spawning only on request.

Live delivery

• Running sessions are reachable. send --mode auto (the default) puts a request for a session with a live harness process into ~/.everett/inbox/<session-id>.jsonl instead of refusing it or forking it with a headless resume; idle sessions are still resumed headless. --mode resume|inbox forces a path. T3 Code sessions now take inbox delivery instead of being refused.
• The session's own hooks inject pending messages (at most 5 per hook, 6,000 characters) marked as coming from Everett with the sender's session and card: Claude Code and Codex at UserPromptSubmit and PostToolUse (hookSpecificOutput.additionalContext; the Codex contract checked against the 0.155.1 binary's embedded schemas), Grok at PostToolUse only (it discards UserPromptSubmit context), and OMP through its extension (before_agent_start, plus tool_result steering). About 40 ms per hook, silent on every error.
• Replies: everett reply <id> "<text>" or everett_send(reply_to=…) deliver to the sender's inbox. send --wait S / everett_send(wait=S) wait for the reply. everett inbox and the everett_inbox MCP tool read an inbox directly (for Pi, Hermes, and humans). Reply chains stop at 3 hops.
• install-hooks adds the new hooks (backup first, idempotent). install-mcp --grok registers the MCP server in ~/.grok/config.toml. everett onboard offers the new hooks.
• Not used: Claude Code's own <cross-session-message> socket channel, which has no public way to send.

Events

• everett event done|blocked|needs-input|info "<msg>" [--project P] and everett_event. Stored in ~/.everett/events.jsonl, with each session's current state (and since when) in ~/.everett/state/. everett ls flags blocked and waiting sessions (⚠ blocked 32h: waiting on Max prompt), everett_ls returns state for each session, and everett events [--since 24h] lists them.
• Stop hooks detect events deterministically from the turn's last assistant message: a closing question or an ask ("need you to", "should I", "please confirm") → needs-input; "blocked" / "stuck" / "waiting on" / "can't proceed" (not negated, not asked) → blocked; otherwise done. Repeats of the current state within 10 minutes are dropped.
• everett subscribe <session|project> / everett_subscribe route events into the subscriber's inbox. blocked and needs-input notify the human: a macOS notification by default, plus notify_command (config or EVERETT_NOTIFY_COMMAND) for your own channel, and one escalation after escalate_minutes (default 30). everett events --check runs the escalation from cron.

Cards and shared core

• Session cards in ~/.everett/cards/: the SessionStart hook asks the agent to write one, and the Stop hook writes a deterministic fallback. everett install-hooks [--claude] [--codex] [--omp] [--grok] [--apply] backs up the config first and merges idempotently. Grok gets the Stop hook only (~/.grok/hooks/everett.json), because Grok ignores SessionStart output.
• Shared core: everett learn (secret-filtered, capped at 500 characters), everett trunk merge [--llm claude|codex|none] (capped at 300 words, with history snapshots), and everett core. SessionStart hooks for Claude Code, Codex, and OMP inject the global and project core, at most 350 words.

For agents

• everett mcp: a stdio MCP server built on the standard library, with the tools everett_ls, everett_route, everett_send, everett_learn, everett_core, everett_card, and everett_whoami. Calls are logged to ~/.everett/mcp.log. everett install-mcp registers it for Claude Code, Codex, and OMP.
• Caller identity comes from CLAUDE_CODE_SESSION_ID, CODEX_THREAD_ID, HERMES_SESSION_ID, PI_SESSION_FILE, or GROK_SESSION_ID, and EVERETT_SESSION_ID overrides them all.

Setup

• everett onboard: a friendly first-time-setup TUI (curses, with a plain-prompt fallback when not a TTY) -- welcome, detected harnesses, per-hook toggles with the exact files that will change, MCP registration toggles, and an optional card-backfill step (deterministic AUTO cards, no LLM calls) with a progress bar. Nothing is written before the final confirm. --yes [--span-days N] [--no-backfill] [--no-mcp] runs it non-interactively.
• ~/.everett/config.toml (vault, vault_dir, default_harness, router, merge_llm, Jev key), with environment overrides. No vault path is hardcoded.
• everett doctor shows the Python version, session stores (including Grok and T3 Code), hooks, MCP registration, card coverage, router, and vault.
• brew install raitoxlol/tap/everett or pipx install git+https://github.com/raitoxlol/everett, python -m everett, and everett --version. No runtime dependencies. MIT license.

Verified

Live round trips on throwaway sessions (2026-09-24):

• Claude Code send replied in 10.3 s. Codex send replied in 43.8 s, including the idle wait; an earlier attempt was correctly refused as busy. OMP send replied in 60.5 s.
• spawn('claude', ...) replied in 5.6 s, and the new session appeared in everett ls.
• Not live-checked: the Hermes, Pi, and Grok resume and spawn commands, which come from each CLI's --help and docs. Pi was not installed on the test machine. The Grok and T3 Code listings were checked read-only against real stores.