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 — rewind to a known-good checkpoint when an agent goes sideways and resume seamlessly
• Keep Git history clean — preserve agent context on a separate branch
• 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.
• Rewind and 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

• Why Entire
• Quick Start
• Typical Workflow
• Key Concepts
• How It Works
• Strategy
• Local Device Auth Testing
• Commands Reference
• Configuration
• Security & Privacy
• Troubleshooting
• Development
• Getting Help
• License

Requirements

• Git
• macOS, Linux or Windows
• Supported agent installed and authenticated

Quick Start

# To use Homebrew, first tap:
brew tap entireio/tap
brew trust entireio/tap

# Install stable via Homebrew
brew install --cask entire

# Or install nightly via Homebrew
brew install --cask entire@nightly

# Or install stable via install.sh
curl -fsSL https://entire.io/install.sh | bash

# Or install nightly via install.sh
curl -fsSL https://entire.io/install.sh | bash -s -- --channel nightly

# Or install stable via Scoop (Windows)
scoop bucket add entire https://github.com/entireio/scoop-bucket.git
scoop install entire/cli

# Or install via Go (development/manual setup)
go install github.com/entireio/cli/cmd/entire@latest

# Linux: Add Go binaries to PATH (add to ~/.zshrc or ~/.bashrc if not already configured)
export PATH="$HOME/go/bin:$PATH"

# 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 | bash
• install.sh nightly: curl -fsSL https://entire.io/install.sh | bash -s -- --channel nightly
• Scoop: currently supports stable only via scoop install entire/cli

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. All session metadata is stored on a separate entire/checkpoints/v1 branch.

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. Rewind to a Previous Checkpoint (deprecated)

Deprecated: entire checkpoint rewind will be removed in a future release.

If you want to undo some changes and go back to an earlier checkpoint:

entire checkpoint rewind

This shows all available checkpoints in the current session. Select one to restore your code to that exact state.

4. 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.

5. 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.

Session ID format: YYYY-MM-DD-<UUID> (e.g., 2026-01-08-abc123de-f456-7890-abcd-ef1234567890)

Sessions are stored separately from your code commits on the entire/checkpoints/v1 branch.

Checkpoints

A checkpoint is a snapshot within a session that you can rewind to—a "save point" in your work.

Checkpoints are created when you or the agent make a git commit. Checkpoint IDs are 12-character hex strings (e.g., a3b2c4d5e6f7).

How It Works

Your Branch                    entire/checkpoints/v1
     │                                  │
     ▼                                  │
[Base Commit]                           │
     │                                  │
     │  ┌─── Agent works ───┐           │
     │  │  Step 1           │           │
     │  │  Step 2           │           │
     │  │  Step 3           │           │
     │  └───────────────────┘           │
     │                                  │
     ▼                                  ▼
[Your Commit] ─────────────────► [Session Metadata]
     │                           (transcript, prompts,
     │                            files touched)
     ▼

Checkpoints are saved as you work. When you commit, session metadata is permanently stored on the entire/checkpoints/v1 branch and linked to your commit.

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
• Non-destructive rewind — restore files from any checkpoint without altering commit history
• Metadata stored separately — all session data lives on the entire/checkpoints/v1 branch

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 can be rewound independently.

Local Device Auth Testing

If you're working on the CLI device auth flow against a local entire.io checkout:

# In your app repo
cd ../entire.io-1
mise run dev

# In this repo, point the CLI at the local API. The login flow targets
# the local server via --server (the default is the production
# us.auth.entire.io).
cd ../cli
export ENTIRE_API_BASE_URL=http://localhost:8787
entire login --server https://localhost:8180

# Run the smoke test
./scripts/local-device-auth-smoke.sh

Useful commands while developing:

# Run the login flow against a local server (prompts to press Enter before opening the browser)
go run ./cmd/entire login --server https://localhost:8180

# Run the focused integration coverage for login
go test -tags=integration ./cmd/entire/cli/integration_test -run TestLogin

Commands Reference

entire blame and entire why are experimental Labs commands. Run entire labs to discover them. entire blame <file> shows which current file lines came from an Entire checkpoint, and entire why <file>:<line> jumps from a specific line back to the prompt, session, and checkpoint that created it. Use entire blame <file> --long for the full agent, model, author, and session table.

entire enable Flags

Examples:

# First-time setup with a specific agent
entire enable --agent claude-code

# Re-enable a disabled repo
entire enable

# Re-enable and refresh hooks
entire enable --force

# Save settings locally (not committed to git)
entire enable --local

entire enable is primarily for turning Entire on. On an unconfigured repo it will also bootstrap setup. Use entire agent for adding or removing agents, and entire configure for non-agent settings.

entire configure

Use entire configure to update non-agent settings on a repo that's already set up. Agent installation lives under entire agent.

Typical uses:

• Toggle telemetry
• Reinstall the Entire git hook (--force, --absolute-git-hook-path)
• Update strategy options such as --checkpoint-remote or --skip-push-sessions
• Pick a summary provider for entire explain --generate

Examples:

```bash

Show help and the hint pointing to 'entire agent'

entire configure

Opt out of telemetry

entire con