Entire hooks into your git workflow to capture AI agent sessions on every push. Sessions are indexed alongside commits, creating a searchable record of how code was written in your repo.

• Quick Start
• Typical Workflow
• Key Concepts
  • How It Works
  • Strategies
• Commands Reference
• Configuration
• Troubleshooting
• Development
• Getting Help
• License

• Git
• macOS or Linux (Windows via WSL)
• Claude Code or Gemini CLI installed and authenticated

# Install via Homebrew
brew tap entireio/tap
brew install entireio/tap/entire

# Or install via Go
go install github.com/entireio/cli/cmd/entire@latest

# Enable in your project
cd your-project && entire enable

# Check status
entire status

entire enable

This installs agent and git hooks to work with your AI agent (Claude Code or Gemini CLI). The hooks capture session data at specific points in your workflow. Your code commits stay clean—all session metadata is stored on a separate entire/checkpoints/v1 branch.

When checkpoints are created depends on your chosen strategy (default is manual-commit):

• Manual-commit: Checkpoints are created when you or the agent make a git commit
• Auto-commit: Checkpoints are created after each agent response

Just use Claude Code or Gemini CLI normally. Entire runs in the background, tracking your session:

entire status  # Check current session status anytime

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

entire rewind

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

To restore the latest checkpointed session metadata for a branch:

entire resume <branch>

Entire checks out the branch, restores the latest checkpointed session metadata (one or more sessions), and prints command(s) to continue.

entire disable

Removes the git hooks. Your code and commit history remain untouched.

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.

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

When checkpoints are created:

• Manual-commit strategy: When you or the agent make a git commit
• Auto-commit strategy: After each agent response

Checkpoint IDs are 12-character hex strings (e.g., a3b2c4d5e6f7).

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.

Entire offers two strategies for capturing your work:

Entire works seamlessly with git worktrees. Each worktree has independent session tracking, so you can run multiple AI sessions in different worktrees without conflicts.

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.

Examples:

# Use auto-commit strategy
entire enable --strategy auto-commit

# Force reinstall hooks
entire enable --force

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

Entire uses two configuration files in the .entire/ directory:

Shared across the team, typically committed to git:

{
  "strategy": "manual-commit",
  "agent": "claude-code",
  "enabled": true
}

Personal overrides, gitignored by default:

{
  "enabled": false,
  "log_level": "debug"
}

When enabled, Entire automatically generates AI summaries for checkpoints at commit time. Summaries capture intent, outcome, learnings, friction points, and open items from the session.

{
  "strategy_options": {
    "summarize": {
      "enabled": true
    }
  }
}

Requirements:

• Claude CLI must be installed and authenticated (claude command available in PATH)
• Summary generation is non-blocking: failures are logged but don't prevent commits

Note: Currently uses Claude CLI for summary generation. Other AI backends may be supported in future versions.

Local settings override project settings field-by-field. When you run entire status, it shows both project and local (effective) settings.

Gemini CLI support is currently in preview. Entire can work with Gemini CLI as an alternative to Claude Code, or alongside it — you can have both agents' hooks enabled at the same time.

To enable:

entire enable --agent gemini

All commands (rewind, status, doctor, etc.) work the same regardless of which agent is configured.

If you run into any issues with Gemini CLI integration, please open an issue.

If you see an error like this when running entire resume:

Failed to fetch metadata: failed to fetch entire/checkpoints/v1 from origin: ssh: handshake failed: ssh: unable to authenticate, attempted methods [none publickey], no supported methods remain

This is a known issue with go-git's SSH handling. Fix it by adding GitHub's host keys to your known_hosts file:

ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
ssh-keyscan -t ecdsa github.com >> ~/.ssh/known_hosts

# Via environment variable
ENTIRE_LOG_LEVEL=debug entire status

# Or via settings.local.json
{
  "log_level": "debug"
}

# Reset shadow branch for current commit
entire reset --force

# Disable and re-enable
entire disable && entire enable --force

For screen reader users, enable accessible mode:

export ACCESSIBLE=1
entire enable

This uses simpler text prompts instead of interactive TUI elements.

This project uses mise for task automation and dependency management.

• mise - Install with curl https://mise.run | sh

# Clone the repository
git clone <repo-url>
cd cli

# Install dependencies (including Go)
mise install

# Trust the mise configuration (required on first setup)
mise trust

# Build the CLI
mise run build

# Run tests
mise run test

# Run integration tests
mise run test:integration

# Run all tests (unit + integration, CI mode)
mise run test:ci

# Lint the code
mise run lint

# Format the code
mise run fmt

entire --help              # General help
entire <command> --help    # Command-specific help

• GitHub Issues: Report bugs or request features at https://github.com/entireio/cli/issues
• Contributing: See CONTRIBUTING.md for guidelines

MIT License - see LICENSE for details.