Entire CLI
Entire hooks into your Git workflow to capture AI agent sessions as you work. Sessions are indexed alongside commits, creating a searchable record of how code was written in your repo.
With Entire, you can:
- Understand why code changed — see the full prompt/response transcript and files touched
- Recover instantly — resume from a known-good checkpoint when an agent goes sideways
- Keep Git history clean — agent context lives outside your branch's history
- Onboard faster — show the path from prompt → change → commit
- Maintain traceability — support audit and compliance requirements when needed
Why Entire
- Understand why code changed, not just what — Transcripts, prompts, files touched, token usage, tool calls, and more are captured alongside every commit.
- Resume from any checkpoint — Go back to any previous agent session and pick up exactly where you or a coworker left off.
- Full context preserved and searchable — A versioned record of every AI interaction tied to your git history, with nothing lost.
- Zero context switching — Git-native, two-step setup, works with Claude Code, Codex, Gemini, Pi, and more.
Table of Contents
Requirements
- Git
- macOS, Linux or Windows
- Supported agent installed and authenticated
- Go 1.26+ only if you install with
go install (the packaged installs bundle their own runtime)
Quick Start
macOS and Linux
Install with Homebrew:
brew tap entireio/tap
brew trust entireio/tap
brew install --cask entire # stable
# brew install --cask entire@nightly # or nightly
Or with the install script:
curl -fsSL https://entire.io/install.sh | bash # stable
# curl -fsSL https://entire.io/install.sh | bash -s -- --channel nightly # or nightly
Windows
Install with Windows PowerShell 5.1 or later:
irm https://entire.io/install.ps1 | iex # stable
# or nightly:
# iex "& {$(irm https://entire.io/install.ps1)} -Channel nightly"
For stable releases, the PowerShell installer uses Scoop when it is available,
adding the Entire bucket if needed. Without Scoop — and for nightly releases —
it verifies the release checksum and installs both entire.exe and
git-remote-entire.exe to %USERPROFILE%\.local\bin, adding that directory to
your user PATH if needed.
Or install the stable release with Scoop:
scoop bucket add entire https://github.com/entireio/scoop-bucket.git
scoop install entire/entire
Migrating an old cli Scoop install (package rename)
The Scoop package was renamed from cli to entire. If your install is still registered as the old cli package, run the migration below. It installs the new package before removing the old one, so the old install is only removed once the new one is in place (scoop reset re-links the shared entire.exe and git-remote-entire.exe shims). Run it where entire is not running — a live entire.exe locks its own shim, so Scoop can't relink or uninstall it mid-run:
cmd.exe /D /C "scoop install entire/entire && scoop uninstall entire/cli && scoop reset entire"
If the first step fails with "couldn't find manifest", your bucket clone predates the renamed package — run scoop update to refresh it, then retry the command above. Nothing is removed until the install succeeds, so a failed attempt leaves your existing install working.
Go (development/manual setup)
go install github.com/entireio/cli/cmd/entire@latest
# The git remote helper that resolves entire:// URLs, needed for `entire repo clone`
# and `git clone entire://…`. The packaged installs above bundle it.
go install github.com/entireio/cli/cmd/git-remote-entire@latest
# Add Go binaries to PATH (add to ~/.zshrc or ~/.bashrc if not already configured)
export PATH="$HOME/go/bin:$PATH"
Install both, or just entire if you never clone over entire://. Git finds the helper by name on $PATH, which is what go install produces, so nothing else needs configuring.
One difference from a stable release: a go install build leaves experimental commands visible in entire help, the same as a nightly or a local build.
Enable in your project
cd your-project && entire enable
# Check status
entire status
After the initial setup, use entire agent to add or remove agents, entire configure to update non-agent settings, and entire enable / entire disable to toggle Entire on or off.
Release Channels
Entire currently ships two release channels:
stable: recommended for most users. Stable releases change less often and are the default for Homebrew, Scoop, and install.sh.nightly: prerelease builds for users who want the latest changes earlier. Nightlies are published more frequently and may include newer, less-proven changes than stable.
How to use each channel:
- Homebrew (one-time setup):
brew tap entireio/tap && brew trust entireio/tap
- Homebrew stable:
brew install --cask entire
- Homebrew nightly:
brew install --cask entire@nightly
install.sh stable: curl -fsSL https://entire.io/install.sh | bashinstall.sh nightly: curl -fsSL https://entire.io/install.sh | bash -s -- --channel nightlyinstall.ps1 stable (uses Scoop when available): irm https://entire.io/install.ps1 | iexinstall.ps1 nightly: iex "& {$(irm https://entire.io/install.ps1)} -Channel nightly"- Scoop: currently supports
stable only via scoop install entire/entire
Typical Workflow
1. Enable Entire in Your Repository
entire enable
On a repo that has not been enabled yet, entire enable runs the initial enable flow: it creates Entire settings, installs git hooks, and prompts you to choose which agent hooks to install. To enable a specific agent non-interactively, use entire enable --agent <name> (for example, entire enable --agent cursor).
After setup:
- Use
entire enable to turn Entire back on if the repo is currently disabled.
- Use
entire agent to add or remove agents.
- Use
entire configure to update non-agent settings (telemetry, hooks, checkpoint remote, summary provider).
The hooks capture session data as you work. Checkpoints are created when you or the agent make a git commit. Your code commits stay clean, Entire never creates commits on your active branch. Session metadata is stored outside your branch's history, in the checkpoint storage described under Checkpoint Storage.
2. Work with Your AI Agent
Just use one of your AI agents as before. Entire runs in the background, tracking your session:
entire status # Check current session status anytime
3. Resume a Previous Session
To restore the latest checkpointed session metadata for a branch:
entire session resume <branch>
Entire checks out the branch, restores the latest checkpointed session metadata (one or more sessions), and prints command(s) to continue.
4. Disable Entire (Optional)
entire disable
Removes the git hooks. Your code and commit history remain untouched.
Key Concepts
Sessions
A session represents a complete interaction with your AI agent, from start to finish. Each session captures all prompts, responses, files modified, and timestamps.
The session ID is the unique identifier the agent itself provides — Entire never mints its own — so an ID you see in entire session list is the same one the agent uses. The format is the agent's to choose: most supply a UUID (e.g. 019efea2-b46a-7cbc-be01-4c13460f5019), while OpenCode uses ses_-prefixed IDs.
Sessions are stored separately from your code commits, in the repo's checkpoint storage.
Checkpoints
A checkpoint is a snapshot within a session—a "save point" in your work.
Checkpoints are created when you or the agent make a git commit, and the commit carries an Entire-Checkpoint: <id> trailer linking the two.
Checkpoint IDs are 26-character ULIDs (e.g. 01K9TQ8ZP7X3F5M2WVJ4CNRB6D), which sort by creation time. Checkpoints written by older versions of Entire carry a legacy 12-character hex ID (e.g. a3b2c4d5e6f7); both formats stay readable in the same repo, and you can pass either to any command that takes a checkpoint ID.
Checkpoint Storage
Checkpoints live in your repository's own git object store, never in your branch's history. Each checkpoint is its own git ref:
refs/entire/checkpoints/<shard>/<id>
The ref points at a commit whose tree is that checkpoint — metadata.json, the per-session transcript files, and any subagent task records. <shard> is the last two characters of the ID, which keeps the refs evenly distributed.
Because checkpoints are independent refs, they are written, pushed, and fetched independently. There is no shared branch tip for concurrent sessions to contend on, and a reader can fetch exactly the one checkpoint it needs instead of a whole history. A checkpoint written on another machine is fetched on demand the first time you read it.
entire enable sets this up; there is nothing to configure. It is recorded in .entire/settings.json as:
{
"checkpoints": {
"primary": { "type": "git-refs" }
}
}
Inspect what a repo has locally with plain git, or through Entire:
git for-each-ref refs/entire/checkpoints # the raw refs
entire checkpoint list # checkpoints on this branch
entire checkpoint explain <id> # one checkpoint in full
How It Works
Your Branch Checkpoint storage
│ │
▼ │
[Base Commit] │
│ │
│ ┌─── Agent works ───┐ │
│ │ Turn 1 │ │
│ │ Turn 2 │ │
│ │ Turn 3 │ │
│ └───────────────────┘ │
│ │
▼ ▼
[Your Commit] ─────────────────► [Checkpoint]
Entire-Checkpoint: <id> (transcript, prompts,
│ files touched, tokens)
▼
Work in progress is held on a short-lived shadow branch as you go. When you commit, that work is condensed into a permanent checkpoint and linked to your commit by an Entire-Checkpoint trailer.
Strategy
Entire uses a manual-commit strategy that keeps your git history clean:
- No commits on your branch — Entire never creates commits on the active branch
- Safe on any branch — works on main, master, and feature branches alike
- Metadata stored separately — session data lives in per-checkpoint refs, never in your branch's history
Git Worktrees
Entire works seamlessly with git worktrees. Each worktree has independent session tracking, so you can run multiple AI sessions in different worktrees without conflicts.
Concurrent Sessions
Multiple AI sessions can run on the same commit. If you start a second session while another has uncommitted work, Entire warns you and tracks them separately. Both sessions' checkpoints are preserved, and a commit condenses every session with pending work in that worktree.
Headless & CI Authentication
By default entire login opens a browser to sign in and stores tokens in the OS keyring (macOS Keychain, Linux Secret Service, Windows Credential Manager). Machines without a usable browser or keyring — headless servers, containers, minimal VMs, CI runners — have two supported paths:
Interactive login on a headless machine
Sign-in itself already handles this: with no interactive terminal, or over SSH, entire login switches to the device-code flow on its own and prints an approval URL you can open on any machine. entire login --device forces that flow explicitly. Only token storage needs an override — use the file-backed store:
ENTIRE_TOKEN_STORE=file entire login
Tokens are written with 0600 permissions to tokens.json in your Entire config directory (~/.config/entire by default). Override the location with ENTIRE_TOKEN_STORE_PATH. Set ENTIRE_TOKEN_STORE=file persistently (e.g. in your shell profile) so later commands read from the same store.
Non-interactive automation (CI, workload identity)
Skip login and storage entirely by injecting a token per invocation:
ENTIRE_TOKEN=<login-or-sa-session-JWT> entire ...
ENTIRE_TOKEN bypasses stored credentials; the CLI derives the control-plane endpoint from the token itself. Nothing is written to disk. This is the right path for CI pipelines and service accounts.
Seeing save login / failed to unlock correct collection errors from entire login? That's the OS keyring being unavailable — use one of the two paths above.
Commands Reference
Descriptions below are the commands' own summaries. entire help always reflects the installed binary; entire agent-help is the machine-readable version agents read.
Setup
| Command |
Description |
entire enable |
Enable Entire in current repository |
entire disable |
Disable Entire in current repository |
entire status |
Show Entire status (--json for structured output) |
entire agent |
Manage agent integrations (add, remove, list) |
entire configure |
Update non-agent Entire settings in the current repository |
entire doctor |
Diagnose and fix session issues (trace, logs, bundle, migrate-checkpoints) |
entire clean |
Clean up Entire session data (--all for repo-wide cleanup) |
entire plugin |
Manage Entire plugins (see Plugins) |
Sessions & Checkpoints
| Command |
Description |
entire session |
Manage agent sessions (list, info, current, stop, attach, adopt, resume, tokens) |
entire session resume |
Resume a stopped session — interactive picker, or by branch |
entire checkpoint |
Inspect and search checkpoints (list, explain, tokens, search) |
entire checkpoint explain |
Explain a checkpoint, commit, or session |
entire search |
Search checkpoints, commits, and sessions using semantic and keyword matching |
entire activity |
Show your activity overview |
entire recap |
Summarize recent checkpoint activity |
entire dispatch |
Generate a dispatch summarizing recent agent work |
Account
| Command |
Description |
entire login |
Log in to Entire (browser by default; --device for the device-code flow) |
entire logout |
Log out of Entire |
entire auth |
Manage authentication (status, contexts, use, token, login, logout) |
Control Plane
| Command |
Description |
entire org |
Manage Entire organizations (create, list, get, delete) |
entire project |
Manage Entire projects (create, list, get, delete) |
entire repo |
Manage Entire repositories (create, list, get, delete, clone, mirror, visibility) |
entire grant |
Manage Entire access grants and org membership (org, project, repo) |
entire api |
Make an authenticated request to an Entire API and print the response |
Other
| Command |
Description |
entire agent-help |
Machine-readable usage for coding agents (always matches the installed CLI) |
entire labs |
Explore experimental Entire workflows |
entire version |
Show build information |
Experimental Commands
These are visible in developer and nightly builds and hidden in stable releases, but always runnable in every build. Run entire labs to discover them.
| Command |
Description |
entire review |
Run a multi-agent review against a branch |
entire investigate |
Run a multi-agent investigation against the current branch |
entire tokens |
Analyze token usage across sessions and checkpoints |
entire blame |
Show which lines came from Entire checkpoints |
entire why |
Show why a line exists |
entire experts |
Rank agent provenance for code scopes |
entire import |
Import pre-existing agent history into Entire |
entire runner |
Set up and tune trail runners for this repository |
entire blame <file> shows which current file lines came from an Entire checkpoint (--long for the full agent, model, author, and session table), and entire why <file>:<line> jumps from a specific line back to the prompt, session, and checkpoint that created it.
entire enable Flags
| Flag |
Description |
| `--agent <name |
|
Entire is a CLI that hooks into your Git workflow to capture AI coding agent sessions (prompts, responses, files touched) and indexes them alongside your commits, creating a searchable record of how code was written.