Install

One command:

curl -fsSL https://dxcli.com/install.sh | bash

The installer checks the download against SHA256SUMS from the same site before it unpacks anything, and stops if they differ. That catches a corrupt or truncated download. SHA256SUMS is signed too: the first install keeps the signing keys that came with it, and from then on dx update and the installer refuse a release that none of those keys signed, so taking over dxcli.com isn't enough to change what runs on your machine. The very first install can't check the keys it brings, so it trusts the site once; verify a release yourself to close that gap. DX_SKIP_VERIFY=1 skips the checks, for a mirror that doesn't carry the signed list.

Or download a tarball for your platform and install manually:

tar xzf dx-0.12.2-linux-amd64.tar.gz
bash dx-0.12.2/install.sh

Available: linux-amd64 · linux-arm64 · darwin-arm64 · darwin-amd64 · windows-amd64

Then enable in any git repo:

cd my-project
dx enable

That's it. Make a commit and a session appears.

Verify a release

Every release has a checksum list, SHA256SUMS, and its signature, SHA256SUMS.sig, at the root of this site. The list holds the checksum of install.sh and of each tarball. The signature is an OpenSSH one, in the dx-release namespace, from one of two keys:

The same fingerprints are published on a second site, axiomdxlab.com/security. If the two ever disagree, don't install.

To check one by hand you need OpenSSH 8.0 or newer. Save the public keys as release-keys:

dx-release namespaces="dx-release" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOxHo6ht+0Zge/5AADXIRRWIb6OBmv9+qQhoqPz2sCdo
dx-release namespaces="dx-release" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIGezj7d/ZjoeurMIcsYR6bWXd1fyDyucwDpMbbeUZjGQ

Then:

curl -fsSLO https://dxcli.com/SHA256SUMS
curl -fsSLO https://dxcli.com/SHA256SUMS.sig
ssh-keygen -Y verify -f release-keys -I dx-release -n dx-release -s SHA256SUMS.sig < SHA256SUMS
# Good "dx-release" signature for dx-release with ED25519 key SHA256:...

grep dx-0.12.2-linux-amd64.tar.gz SHA256SUMS     # the checksum it should have
sha256sum dx-0.12.2-linux-amd64.tar.gz           # shasum -a 256 on macOS

ssh-keygen prints Good "dx-release" signature only for a key on that list. A change of keys is only ever published in a release that a key already on the list signed.

Commands

dx enable             # Install post-commit hook in current repo
dx disable            # Remove hook from current repo
dx init               # Create a .dx config file with defaults
dx snap [-y] [id|name] # Save a Claude session; by name or id from any folder (aliases: slap, yoink)
dx resume [-a] [id]   # Resume a saved session (-a = include other repos)
dx fork   [-a] [id]   # Clone a session: the copy remembers everything so far, then goes its own way (alias: branch)
dx open <id>          # Open a session in a new terminal tab and return
dx drop [id]          # Remove a snapped session from dx
dx name <id> [name]   # Name a session; the name sticks (--clear removes it; alias: rename)
dx ui                 # Open session viewer in browser (--no-open: build the page only)
dx log                # Your snapped and named sessions (default)
dx log -t auto        # Per-commit auto sessions
dx log -t all         # Both
dx log -a             # Show all sessions
dx log -r             # Filter to current repo
dx log -g             # Grouped by project; --group <g> shows one, --groups lists them
dx log -n 50          # Show last 50 sessions
dx tidy --older-than 90d   # Prune old auto sessions (snaps never touched)
dx sync setup         # One-step cross-device setup (auto-detects gh CLI)
dx sync push [dst]    # Push sessions to a private GitHub repo, local path, or rsync remote
dx sync pull [src]    # Pull and merge sessions from the same
dx connect            # Your devices: who is online, what is open where
dx connect pair       # Pair another device (prints a string to paste there)
dx send <s> [device]  # Push one session to a device now
dx share <s> [who]    # Hand a session to a friend (or --file for a bundle)
dx receive <str|file> # Take a session a friend shared; dx resume continues it as your fork
dx wake [-y] [n]      # Reopen sessions closed by a reboot or a closed tab (alias: restore)
dx color <id> [c]     # Pin a tab color to a session — dx wake reopens it colored
dx color -g <grp> [c] # Color every session in a group at once (--clear removes)
dx group <id> [g]     # Put a session in a project group (aliases: project, tenant, herd, bucket)
dx update [version]   # Update dx (e.g. `dx update 0.7.2` to pin, --force to reinstall)
dx feedback <note>    # A note to the maintainer — one command, no account (also: dx bug, dx idea)
dx help [<command>]   # The commands, or one command's usage (also: dx <command> --help)

Snap & Resume

Save your current interactive Claude session at any point:

dx snap
# => Snapped! Session d29c9dca (27 messages)
#      repo:   my-project
#      branch: main
#      commit: b56e1a6
#      resume: claude --resume d29c9dca-4f49-459a-9a01-7241213d3db0

To snap a session other than the latest one, name it: dx snap d29c9dca takes a uuid or any fragment of one, and dx snap es-issue takes the name you gave the session with /rename — the same name Claude prints in claude --resume "es-issue" when the session exits. Name matching is case-insensitive; an exact name wins, a partial name is accepted only when it matches a single session. dx never guesses: an id fragment several sessions share (unless a session's exact name settles it), or a partial name several sessions match, is an error that lists them.

You don't have to be in the session's folder. When no session here matches, dx looks through every folder Claude has sessions in, shows where it found one, and snaps it after you confirm (dx snap -y <name> skips the question; without a terminal to ask, dx won't snap it and prints that command). The snap records that folder's repo, branch and commit, as if you had run it there. A name that two different sessions share in different folders is listed for you to pick by uuid; a session dx resume linked into several folders counts once.

Resume from any checkout of the same repo — even across different clones or from WSL when the session was created on Windows:

dx resume
# => Recent sessions for my-project:
#   * [1] 5m ago   b56e1a6  claude  main      d29c9dca...
#     [2] 1h ago   463be4a  claude  feature-x  463be4ab...
#
# => Use: dx resume <number> or dx resume <uuid>

dx resume 1
# => Resuming session d29c9dca...

Running dx resume with no arguments opens an interactive picker with search, arrow-key navigation, and keyboard shortcuts:

• Ctrl+A — toggle between current repo and all projects
• Ctrl+T — cycle session types: your snaps → all types → autos
• Ctrl+B — toggle branch badge and folder paths
• Ctrl+R — rename the selected session (the name sticks, like dx name)
• Type to search by branch, commit, folder or name
• Tab toggles between search and list focus

If the session was created on a commit ahead of your current checkout, dx warns you before resuming.

Snaps and auto sessions

dx records two kinds of sessions: snaps you save with dx snap, and auto sessions the post-commit hook records for every commit in an enabled repo. Snaps are the ones you manage day to day, so dx log and the resume picker show them by default — autos stay one Ctrl+T (or dx log -t auto) away.

Renaming an auto session in the picker, or coloring it with dx color, claims it: from then on it counts as one of your snaps. Searching in the picker never dead-ends — if nothing matches in the current view, the search quietly widens to all types.

Old auto sessions pile up over time. Prune them without touching a single snap (or any Claude transcript):

dx tidy --older-than 90d --dry-run   # preview
dx tidy --older-than 90d             # prompt, then prune
dx tidy --older-than 90d -y          # no prompt

Resume across repos

By default, dx resume and dx fork only surface sessions that belong to the current repo. Pass -a/--all to include sessions from every repo — handy when you want to continue a Claude conversation started in repo A while working inside repo B:

dx resume -a       # picker opens pre-toggled to all-projects
dx resume -a 3     # 3rd most recent across all sessions
dx fork -a         # same flag works for fork

Inside the picker, Ctrl+A still toggles between current-repo and all-projects views. dx warns when the session's commit isn't in the current checkout's history.

A session you never snapped works too. When no snap matches the name or uuid, dx resume and dx fork look through Claude's sessions the way dx snap <name> does — this folder first, then every folder — and ask before snapping the one they find:

$ dx fork dx-soc2
'dx-soc2' isn't snapped yet — Claude has it in this folder:
  dx-soc2 · 3d8325ab · 1478 messages · last active 2h ago
Snap it and fork it? [Y/n]

Enter snaps it and goes on; -y skips the question. With no terminal to ask, dx doesn't snap it and prints the dx fork -y … command instead.

Aliases: dx slap and dx yoink do the same as dx snap. Aliases: dx hop and dx zap do the same as dx resume.

Group sessions by project

Twenty sessions, six projects. Every session belongs to a group: by default the repo it was snapped in (the same name dx log shows under REPO), so grouping works with no setup. A label moves a session somewhere else — two repos into one project, or one repo split into several:

dx log -g                        # your snaps, grouped, newest group first
dx group viewer-fixes client-x   # move a session into the "client-x" group
dx group viewer-fixes            # show its group
dx group viewer-fixes --clear    # back to its repo's group
dx log --group client-x          # one group (case-insensitive)
dx log --groups                  # one line per group: sessions, last activity
dx group                         # the same list, plus usage

Groups sync across your devices like names and colors, travel with dx send, dx share and .dxsession bundles, and the resume picker shows a #group badge on labelled sessions and searches by group. Grouping an auto session claims it, like naming or coloring it. -g combines with -t, -r and -n.

Aliases: dx project, dx tenant, dx herd and dx bucket do the same as dx group, and so do the plurals (dx groups, dx projects, dx tenants — bare, they list the groups). In dx log, --project and --tenant stand in for --group, --projects and --tenants for --groups, and --by-project and --by-tenant for -g; dx color takes --project and --tenant for --group.

Wake after a reboot

Windows Update restarts your machine. Ten Claude sessions die with it. dx wake brings them all back — each in its own tab, in its own folder, resumed where you left off.

dx wake
# => Sessions you can reopen:
# =>    1. api-auth-refactor    ~/work/api        before reboot (2h)
# =>    2. viewer-ui-v3         ~/work/viewer     before reboot (2h)
# =>    3. changelog-pass       ~/work/dx         closed 14m ago
# => Reopen all 3 in new tabs? [Y/n]

Press Enter and three tabs open. It also catches the everyday case: a tab you closed by accident five minutes ago is right there in the list.

How dx knows

Claude Code registers each running session under ~/.claude/sessions/, but clears the entry when the session exits — so after a clean reboot there is nothing left to read. dx therefore keeps its own ledger: whenever it runs, it records which sessions are currently open. That happens on every commit (through the dx hook), on dx snap, dx resume, dx fork, and on every tick of the sync daemon.

The more dx runs, the fresher the list. Running dx sync enable keeps it under ~30 seconds old. You can also refresh it by hand:

dx wake --scan     # refresh the ledger, reopen nothing

Flags

dx wake              # list, then ask
dx wake -y           # reopen everything, no questions
dx wake 2            # reopen just number 2
dx wake --list       # show what would reopen, do nothing
dx wake --dry-run    # print the exact commands instead of spawning
dx wake --since 12h  # only sessions seen in the last 12h (default 72h)
dx wake --terminal print   # force an adapter (see below)

Terminals

dx opens tabs with whatever you are already using. It picks the first that applies, and you can override it with --terminal or the DX_TERMINAL environment variable.

Session colors

Pin a color to a session and dx wake reopens it colored — Windows Terminal tabs via --tabColor, iTerm2 via its tab-color escape sequence (Terminal.app has no tab colors):

dx color viewer-fixes tan       # palette name, or #rrggbb
dx color viewer-fixes --clear   # remove
dx color                        # palette + everything colored

dx color --group html5-viewer blue   # every session in a group, in one go
dx color --group html5-viewer        # the members and their colors
dx color --group html5-viewer --clear

A group color is applied to each member — the sessions dx log -g shows for that group — so every one of them wakes, replicates and shares like a session colored by hand. A session added to the group later isn't recolored until you run it again. Plain dx color html5-viewer blue works too when no session has that name (a session always wins a name clash; --group forces the group).

Colors are stored by dx and sync across devices like session names. Colors set through the terminal's own UI can't be captured — set them through dx instead.

A session whose folder has been deleted is listed as [folder missing] and skipped rather than opened somewhere random. If claude turns out not to be on the PATH inside a new tab, the tab says so and stays open so you can read the message instead of watching it vanish.

What it does not do

dx wake restores sessions, not window layout. Your conversations come back; pane geometry, split positions, and scrollback do not. The ledger lives in ~/.dx/run/ and is never synced — project paths and session names stay on the machine that recorded them.

Session Viewer

dx ui

Opens a local web viewer showing all your sessions — both auto-created (from commits) and manually snapped. Click any session with a chat icon to see the full Claude conversation with messages, thinking blocks, and tool calls. Filter by repo or type. A session shows by its name (the one dx log and the picker show) with its branch beside it, and the search box finds it by name.

Send feedback

Something broke, something is missing, something is great — say so in one command:

$ dx feedback the picker is slow with 500 sessions
=> Sending with dx 0.10.1, Linux x86_64, bash 5.2.21, vscode, Claude Code 2.1.287…
✓ Sent — thanks! (ref #42)

Nothing to log in to, nothing to install. dx bug … and dx idea … send the same note and say which it is; bare dx feedback asks for one line; dx feedback < notes.md sends a longer note. Add your email to the note if you would like a reply.

The line printed before sending is exactly what goes along: the dx version, OS, bash and Claude Code versions, the terminal. Never paths, host or user names, or anything from a session. --bare sends the note alone; --dry-run shows the whole thing and sends nothing.

The note lands as an issue in the dx repo through a small relay. When the relay cannot be reached, dx keeps the note in ~/.dx/feedback/outbox/ and retries in the background — the next dx says when it went through, and dx feedback --retry tries on demand.

What happens to a note, who handles it and how long it is kept: see the privacy policy.

Supported Tools

dx is built and tested for Claude Code.

Configuration

.dx file

Run dx init to create one, or add it manually to your repo root:

# .dx
agents=claude
# claude_args=--model opus

dx works with Claude Code; hook scripts for other tools exist but are untested and unsupported.

Environment variable override

DX_AGENTS overrides the .dx file. DX_CLAUDE_ARGS passes extra arguments to claude, like claude_args:

DX_CLAUDE_ARGS="--model opus" git commit -m "test"

Quiet update check: dx and dx version print a one-line "dx X.Y.Z is available" nudge when a newer release is published — at most once every 7 days, silent on every failure (no curl, offline, etc.). Set DX_NO_UPDATE_CHECK=1 in your shell to disable.

Priority: DX_AGENTS env var > .dx file > default (claude).

Connect your devices

Pair your laptop with your desktop once, and every session you snap on one shows up on the other — peer to peer, no repo or account in the middle. The transport is rsntr: a small node per device with its own identity and an encrypted QUIC endpoint. dx downloads it for you and keeps its own data model; the node only carries messages.

Pairing: one paste

# on a device you already use
$ dx connect install          # once: downloads rsntr (~18 MB, sha256-verified) into ~/.dx/bin
$ dx connect pair
This device: mac-mini  (a6060096…)
On the other device, run:

    dx connect join endpointaal7p73…qaaabvlkqg.7KQ2M9XA

Waiting for it (10 min)… ✓ macbook joined
Introduced macbook to 1 other device: office-pc

# on the new device
$ dx connect install
$ dx connect join endpointaal7p73…qaaabvlkqg.7KQ2M9XA
Knocking on mac-mini…  ✓ admitted
Connected to 2 devices: mac-mini, office-pc
Sent 14 sessions.

The string is the other node's ticket plus a one-time code (good for ten minutes, once). The joining device knocks with its own ticket and the code; the existing device admits it when the code matches. Every device that already knows mac-mini is introduced to macbook and vice versa, so one pairing joins the whole network.

What travels

• Every snap, name, color and drop replicates to every device.
• Sessions open on a device are mirrored live to the others as they grow, and show as type live until they are snapped (dx log -t live). dx resume works on any of them; the device where a session is open owns it while it is open.
• Presence: dx connect shows which sessions are open on each device right now.

$ dx connect
dx connect — 3 devices
  * macbook     this device                        14 sessions
    mac-mini    online   3s ago                    27 sessions   2 open: api-auth-refactor, viewer-ui-v3
    office-pc   seen     2d ago                     9 sessions

dx log gains a DEVICE column once a session from another device exists (and --device <name>); the resume picker shows an @device badge and searches by it; dx ui gets a Device filter and shows transcripts that arrived from other devices.

With and without the daemon

With dx sync enable replication is continuous: each push cycle sends what changed, each pull tick receives and reports presence. A git sync target is optional — the daemon runs on paired devices alone. Without the daemon, dx snap, dx drop, dx color and dx send push on the spot, and receiving is instant (the node runs a dx hook when a message lands); live mirroring waits for the next push.

dx send viewer-fixes mac-mini    # push one session now, to one device
dx send viewer-fixes             # …or to every device (--full resends from scratch)
dx connect name office-pc        # rename this device (default: your hostname)
dx connect forget old-laptop     # unpair a device
dx connect status                # node, endpoint id, ticket, last receive

Security notes

• Only a paired device can send anything; an unknown node can do nothing but knock, and a knock is admitted only with the armed one-time code.
• Traffic is end-to-end encrypted (iroh QUIC). Devices dial each other directly; when NAT blocks that, a public relay forwards the encrypted bytes and sees connection metadata only. connect_lan=1 in ~/.dx/config turns relays off.
• ~/.dx/node holds this device's private key: never copy it to another machine, never put it in a synced folder. It is not part of dx sync.
• Everything a device sends is treated as untrusted input; a session file only ever lands in ~/.dx/data/blobs/. Windows (Git Bash) is best-effort in 0.9.0.

Share a session with a friend

Anyone with dx can continue your session on their machine. A friend is a contact, never a device: they get only what you share, and nothing they send but a share is ever applied on your side. Between your own paired devices there is nothing to share — they already replicate every session, and dx send pushes one on the spot — so dx receive refuses a string that comes from one of them.

# you
$ dx share viewer-fixes
Share viewer-fixes (1.2 MB, 27 messages, repo dx)?
The full transcript goes — including any file contents and secrets it quotes. [y/N] y
Share string for viewer-fixes — good for 24 hours, once. Your friend runs:

    dx receive endpointaal7p73…qaaabvlkqg.7KQ2M9XA

Waiting for them… sending… ✓ alice received it

# your friend
$ dx receive endpointaal7p73…qaaabvlkqg.7KQ2M9XA
Received viewer-fixes from gurgen (1.2 MB).
Resume with: dx resume viewer-fixes   (it continues as your own fork)

Their dx resume continues it as their own fork: the received transcript stays as received, their continuation gets a new id, and sharing back never collides. After the first share you are contacts — dx share other-session alice needs no code, and they can share back the same way. dx share list shows your contacts, dx share forget alice revokes.

No direct path between the two machines? dx share viewer-fixes --file writes a .dxsession bundle for email, chat or a USB stick; dx receive viewer-fixes.dxsession imports it. Nothing else is needed on either side.

Sync

Keep your snapped sessions in sync across machines — laptop, Mac mini, workstation. dx uses a private git repo you already own as the transport, so there's no server to run, no account to create, and no ongoing cost. Since it's git, sync is store-and-forward: push while the other device is offline, pull whenever it comes back online.

One-step setup (recommended)

On each device, run:

dx sync setup

If you have the gh CLI installed and logged in, dx auto-creates a private <you>/dx-sessions repo on the first device and offers to reuse it on the others:

# Device 1 (laptop)
$ dx sync setup
=> Detected gh CLI logged in as @alice
? Create private repo github.com/alice/dx-sessions for sync? [Y/n] Y
=> Created github.com/alice/dx-sessions (private)
=> Saved sync target to ~/.dx/config
=> Done.

# Device 2 (Mac mini), same GitHub account
$ dx sync setup
=> Detected gh CLI logged in as @alice
Found existing repo github.com/alice/dx-sessions
? Sync from it? [Y/n] Y
=> Fetching existing sessions...
=> Saved sync target to ~/.dx/config
=> Done.

From then on, on any device:

dx sync push    # upload local sessions
dx sync pull    # download remote sessions and merge

Without gh — any git URL

If you don't have gh, dx sync setup asks for a git URL. Any private git repo you can push to works — GitHub, GitLab, Bitbucket, Codeberg, Gitea, self-hosted. Paste either form:

https://github.com/you/dx-sessions.git
git@github.com:you/dx-sessions.git

Auth uses whatever you already have set up — SSH keys, credential helpers, Keychain, Windows Credential Manager, or a PAT. dx doesn't manage credentials itself.

Cross-device walkthrough

# On the laptop
dx snap                   # save the current Claude session
dx sync push              # upload it

# Later, on the Mac mini
dx sync pull              # fetch and merge
dx resume                 # picker shows the session — hit Enter to resume

Continuous sync (daemon)

dx sync push and dx sync pull are manual. For background sync, run a small daemon that watches your snaps and Claude session files and pushes on change:

dx sync enable      # start the daemon
dx sync status      # show what it's doing
dx sync disable     # stop it

Defaults: push debounced to 10s after the last write, pull every 30s. Override on start:

dx sync enable --push-debounce 5 --pull-interval 15

Aliases: dx watch, dx unwatch, dx watch-status, and dx auto-sync on|off|status all dispatch to the same handlers.

The daemon force-pushes a single squashed commit each cycle, so the sync repo stays at one commit — no history bloat. Conflicts with another device's push trigger an automatic fetch-merge-retry on the next tick. Logs go to ~/.dx/log/sync.log; the daemon is silent on stdout.

File watching uses inotifywait on Linux, fswatch on macOS, and a 2-second polling fallback on Git-Bash / MSYS and anywhere else missing the native tools. Install the native watcher for instant push:

apt install inotify-tools       # Linux
brew install fswatch            # macOS

dx enable also installs a pre-push hook alongside the existing post-commit hook. Both run dx sync trigger, which tells a running daemon to push+pull immediately instead of waiting for the next debounce window. So your latest commit and session always ride along with your next git push. The trigger is a silent no-op when the daemon isn't running, so the hooks cost nothing if you don't use auto-sync.

The daemon doesn't survive reboot. Add dx sync enable to your shell rc if you want it to auto-start across sessions.

Conflicts and merges

When two devices push independently, dx fetches and re-integrates remote changes before committing, then retries the push. Merges are non-destructive:

• Session list — unioned by UUID; both devices' sessions are kept.
• Names — remote wins on TSV conflict (last push wins).
• Blobs — UUID-named, never collide; existing local blobs are never overwritten.
• Drops — dx drop writes a tombstone that propagates to other devices on the next pull, removing the session there too.

Target resolution

dx picks the sync target in this order (first match wins):

1. Explicit arg: dx sync push <target>
2. DX_SYNC environment variable
3. sync=<url> in ~/.dx/config (written by dx sync setup)
4. sync=<path> in the current repo's .dx config

Alternative targets (no git)

If you'd rather not use git, dx sync push|pull still works with:

dx sync push /mnt/backup           # local path (USB, NAS, shared folder)
dx sync push user@host:~/dx-data   # rsync over SSH

You can also point DX_SYNC at a folder synced by iCloud, Dropbox, or Syncthing — those services handle the transport, dx handles the merge.

Security notes

The repo is private, TLS in transit, and encrypted at rest by your git host. dx doesn't add client-side encryption, so sessions are readable by anyone with repo access (including, in principle, the git host's staff). For most threat models this is fine; if you need stronger guarantees, host on your own server or wrap blobs in age or gpg before snapping.

How It Works

A git post-commit hook runs after every commit. It:

1. Extracts the commit message and hash
2. Generates a slug: fix-login-redirect-bug-a1b2c3d
3. Launches each configured tool (Claude Code by default) in the background with the slug as prompt
4. Logs the session to ~/.dx/data/sessions.tsv

dx snap finds the most recently modified Claude session file in ~/.claude/projects/ and records it. dx ui reads the session data and Claude's JSONL conversation files, builds a self-contained HTML viewer, and opens it in your browser.

The hook never blocks git. It skips during rebase, merge, and other non-interactive operations.

Requirements

• git and bash (always required)
• node (required for dx ui, the resume picker and dx connect)
• rsntr (required for dx connect only; dx connect install downloads it)

Platform Support

Uninstall

Remove from a repo:

dx disable

Remove globally: first run dx disable in each repo where you ran dx enable, then remove dx's files:

rm -rf ~/.dx ~/.local/bin/dx

A repo you miss keeps dx's two lines in its post-commit hook. From dx 0.12.1 on they do nothing once dx is gone (dx updates an older repo's lines at its next commit), and dx disable removes them if you install dx again.

If you added the PATH export to ~/.bashrc, remove that line too.