## Documentation Index

Fetch the complete documentation index at: [/llms.txt](https://docs.entire.io/llms.txt)

Use this file to discover all available pages before exploring further.

This tutorial shows how to use `entire recap` to understand recent agent activity, then use [`entire review`](https://docs.entire.io/cli-reference/review) to run a cross-agent review before you merge. In this tutorial, you will create a small app, make a few agent-assisted commits, recap the work, run a review with more than one agent, and use the findings to decide what to fix.

## Prerequisites
Before you start, make sure you have:

- [Entire installed](https://docs.entire.io/installation)
- An AI coding agent installed
- Git configured for the project
- An Entire account
- Node.js installed

Log in to Entire:

```
entire login
```

## Create a New Project
Create a Vite project:

```
mkdir flight-control-review-demo
cd flight-control-review-demo
npm create vite@latest . -- --template vanilla-ts
npm install
```

Enable Entire for your agent. This example uses Codex:

```
entire enable -y --agent codex
```

Replace `codex` with the agent you use. Install another review agent so the review can compare more than one reviewer:

```
entire agent add claude-code
```

This tutorial uses Codex and Claude Code as the review agents. You can use the review agents your team has installed. Create a feature branch:

```
git switch -c add-flight-control-board
```

## Build Reviewable History
Open the project in your AI coding agent and ask it to build a small app:

```
Build a browser app called Flight Control.

It should show a departure board for a fictional airport using local sample data.

Requirements:
- show flight number, destination, gate, departure time, status, and delay risk
- include at least 8 sample flights
- make the UI feel like an airport operations screen
- keep the data local and deterministic
- keep the code simple enough to review
```

Commit and push the work:

```
git add .
git commit -m "Build flight control board"
git push -u origin add-flight-control-board
```

If Entire asks whether to link the commit to session context, choose `a`:

```
Link this commit to session context?
  [Y]es / [n]o / [a]lways (remember my choice): a
```

## Add More Agent Work
Ask your agent to add delay-risk logic:

```
Add deterministic delay-risk scoring to Flight Control.

The score should consider departure time, weather severity, gate changes, connection pressure, and current status.

Show a short reason for each score.
```

Commit and push:

```
git add .
git commit -m "Add delay risk scoring"
git push
```

Ask your agent to add one more feature:

```
Add a "Simulate next 30 minutes" button.

Each click should apply one deterministic airport update, such as a gate change, a boarding status update, a delay increase, or a cancellation.

Keep the update sequence deterministic so the behavior is easy to review.
```

Commit and push:

```
git add .
git commit -m "Add flight update simulation"
git push
```

## Recap the Work
Run `entire recap` from the project:

```
entire recap
```

Use `--static` when you want plain terminal output:

```
entire recap --static
```

The recap should show recent activity for this repository, including sessions, checkpoints, agent activity, and token usage when available.

Try a longer range:

```
entire recap --week --static
```

## Configure Cross-Agent Review
Create a review profile with Codex and Claude Code as reviewers, and Codex as the judge:

```
entire review --configure \
  --set-agents codex,claude-code \
  --set-judge codex \
  --set-output local
```

Entire saves the profile and tells you how to start it. To see configured profiles:

```
entire review --list
```

To see the reviewers in the selected profile:

```
entire review --agents
```

## Run the Review
Run the review:

```
entire review general
```

By default, Entire scopes the review against the first available mainline ref, such as `origin/main`. For stacked branches, pass the parent branch with `--base`:

```
entire review general --base origin/my-parent-branch
```

To add one-off instructions for a single run, use `--prompt`:

```
entire review general --prompt "Focus on risky state transitions and missing tests."
```

## Read the Verdict
When the review finishes, Entire shows each reviewer’s result and then consolidates the reports into a final verdict. Compare:

- Which issues did multiple agents find?
- Which issues were unique to one reviewer?
- Which findings are blockers before merge?
- Which findings are follow-up work?

If you want to inspect saved findings locally, run:

```
entire review --findings
```

Fix the issues you agree with, then commit and push:

```
git add .
git commit -m "Address review feedback"
git push
```

## Recap the Review Loop
Run recap again:

```
entire recap --static
```

The recap should now include the original build work, the review run, and any follow-up fixes. This is the core workflow:

1. Build with an agent
2. Commit and push useful chunks of work
3. Use `entire recap` to understand what happened
4. Use `entire review` to review the branch before merging
5. Fix the findings that matter

## Troubleshooting
`entire recap` looks empty

Make sure you ran agent work in an Entire-enabled repository, linked commits to session context, pushed the branch, and gave hosted analysis a few minutes to catch up. You can also check local checkpoint history:

```
entire checkpoint list
```

`entire review` asks me to configure review

Create a review profile:

```
entire review --configure --set-agents codex,claude-code --set-judge codex
```

You can also run `entire review --configure` without flags to use the interactive setup.

One reviewer is missing

Confirm the review agent is installed in this repository:

```
entire agent list
entire agent add AGENT_NAME
```

Then check the configured reviewers:

```
entire review --agents
```

The review uses the wrong base branch

Pass the branch you want to review against:

```
entire review general --base origin/main
```

For stacked work, use the parent feature branch instead of `origin/main`.
