## What this config affects

Checkpoint storage configuration controls:

- whether Entire pushes checkpoint data when you run `git push`
- whether checkpoint data goes to the code repository or a separate repository
- whether checkpoint history stays local to your machine
- whether generated summaries are stored with checkpoint metadata

## Configure checkpoint storage

- Source code repository (default)
- Separate checkpoint repo
- Local-only checkpoints

## Store checkpoints with your code

By default, Entire stores checkpoint data in the same Git repository as your code on the `entire/checkpoints/v1` branch. No configuration is required for the default setup. The effective default is:

Effective default

```
{
  "strategy_options": {
    "push_sessions": true
  }
}
```

Use this when checkpoint history should stay with the repository it describes.

## Checkpoint remote

Use a checkpoint remote when checkpoint data should live in a separate repository from the code.

```
entire configure --checkpoint-remote github:owner/repo
```

This writes the checkpoint remote to `.entire/settings.json`:

```json
{
  "strategy_options": {
    "checkpoint_remote": {
      "provider": "github",
      "repo": "owner/repo"
    }
  }
}
```

Commit and push `.entire/settings.json` when the checkpoint remote should apply to the whole project. Entire.io uses that setting to locate checkpoint data. Currently, `github` is the supported checkpoint remote provider.

### Keep checkpoint remotes under the same owner

Use a checkpoint repository with the same owner or organization as your code repository.

- **Same owner**: checkpoints push normally. If your code is at `github.com/acme/app`, a checkpoint repo like `github:acme/app-checkpoints` works because both are owned by `acme`.
- **Different owner**: Entire won’t push checkpoint data to that repository.

The different-owner case protects fork workflows, so contributors do not need write access to the upstream project’s checkpoint repository.

## Keep checkpoints local

When checkpoint history should stay on your current machine, disable automatic checkpoint pushes in local settings:

```
entire configure --local --skip-push-sessions
```

This writes:

```json
{
  "strategy_options": {
    "push_sessions": false
  }
}
```

Use project settings instead when the whole repository should avoid pushing checkpoint data:

```
entire configure --project --skip-push-sessions
```

Project settings are written to `.entire/settings.json` and should be committed only when the behavior should apply to everyone.

## Auto-generate checkpoint summaries

In addition to choosing where checkpoint data is pushed, you can configure Entire to add generated summaries to checkpoint metadata. Enable generated summaries at commit time with `strategy_options.summarize.enabled`:

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

To choose the AI provider or model used for summaries, configure those values separately:

```
entire configure --summarize-provider PROVIDER
entire configure --summarize-model MODEL
```

## Verify checkpoint storage

After changing checkpoint storage settings, run:

```
entire status --detailed
```

Check the effective settings for the values you changed:

- `strategy_options.push_sessions`
- `strategy_options.checkpoint_remote`
- `strategy_options.summarize.enabled`

Then run a normal push:

```
git push
```

What happens next depends on the storage option:

- **Source code repository**: Entire pushes checkpoint data to the same remote as your source code.
- **Separate checkpoint repo**: Entire pushes checkpoint data to the configured `checkpoint_remote`.
- **Local-only checkpoints**: Entire does not push checkpoint data because `push_sessions` is `false`.

If checkpoint data is not appearing where expected, see [checkpoint troubleshooting](https://docs.entire.io/guides/checkpoints/troubleshooting#checkpoint-data-is-going-to-the-wrong-place).