# surface checkpoint policy fallbacks

`c3f89a9`→[main](/content/gh/entireio/cli/commits/main/index.html)·  
  
pfleidi·2w ago·3 files·+33 added/-2 removed

Show when unsupported configured checkpoint versions write the default and log policy read failures before falling back.

## Sessions

27c77d50dda9View transcript

[?\  
Enforce Checkpoint Policies in CLICodex·GPT-5.5·2 steps](/content/gh/entireio/cli/session/019f05ad-eea0-7202-a508-ec34d069a2d2#timeline-27c77d50dda9/index.html)

## Changes

3

- cmd/entire/cli
  
  - Mcheckpoint_policy.go+11/-1
  
  - Mcheckpoint_policy_test.go+14
  
  - Mcheckpoint_policy_write.go+8/-1

```
93 unmodified lines

94
95
96
97
97
98
99
100
10 unmodified lines

111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

93 unmodified lines

}

effectivePolicy := checkpointpolicy.Normalize(state.Policy)
	fmt.Fprintf(cmd.OutOrStdout(), "checkpoint_version: %s\n", formatCheckpointPolicyValue(state.Policy.CheckpointVersion, effectivePolicy.CheckpointVersion))
	fmt.Fprintf(cmd.OutOrStdout(), "checkpoint_version: %s\n", formatCheckpointVersionPolicyValue(state.Policy.CheckpointVersion, checkpointpolicy.CheckpointVersion(state.Policy)))
	fmt.Fprintf(cmd.OutOrStdout(), "checkpoint_min_version: %s\n", formatCheckpointPolicyValue(state.Policy.CheckpointMinVersion, effectivePolicy.CheckpointMinVersion))
	fmt.Fprintf(cmd.OutOrStdout(), "source: %s\n", state.Source)
	return nil
10 unmodified lines

return configured
}

func formatCheckpointVersionPolicyValue(configured, writeVersion string) string {
	if configured == "" {
		return writeVersion + " (default)"
	}
	if configured != writeVersion {
		return fmt.Sprintf("%s (unsupported; writing %s)", configured, writeVersion)
	}
	return configured
}

func checkpointPolicyError(message string, err error) error {
	wrapped := fmt.Errorf("%s: %w", message, err)
	if errors.Is(wrapped, context.Canceled) {
```

Mcmd/entire/cli/checkpoint_policy.go+11/-1

```
68 unmodified lines

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

68 unmodified lines

}
}

func TestCheckpointPolicyCmd_PrintsWriteFallbackForUnsupportedConfiguredVersion(t *testing.T) {
	dir, bareDir := setupCheckpointPolicyRepo(t)
	seedCheckpointPolicyForCommand(t, dir, checkpointpolicy.Policy{
		CheckpointVersion:    "refs-v1",
		CheckpointMinVersion: "branch-v1",
	})
	pushCheckpointPolicyRefForCommandTest(t, dir, bareDir)

stdout, err := executeCheckpointPolicyCmd(t)
	require.NoError(t, err)
	require.Contains(t, stdout, "checkpoint_version: refs-v1 (unsupported; writing branch-v1)")
	require.Contains(t, stdout, "checkpoint_min_version: branch-v1")
}

func TestCheckpointPolicyCmd_RejectsDowngradeWithoutForce(t *testing.T) {
	dir, bareDir := setupCheckpointPolicyRepo(t)
	seedCheckpointPolicyForCommand(t, dir, checkpointpolicy.Policy{
```

Mcmd/entire/cli/checkpoint_policy_test.go+14

```
1 unmodified line

2
3
4
5
6
7
8
9
10
11
12
13
14
13
15
16
17
18
19
20
21
22
23

1 unmodified line

import (
	"context"
	"log/slog"

"github.com/entireio/cli/cmd/entire/cli/checkpointpolicy"
	"github.com/entireio/cli/cmd/entire/cli/logging"
	"github.com/go-git/go-git/v6"
)

func committedCheckpointVersion(ctx context.Context, repo *git.Repository) string {
	state, err := checkpointpolicy.ReadLocal(ctx, repo)
	if err != nil {
		return checkpointpolicy.DefaultCheckpointVersion()
		version := checkpointpolicy.DefaultCheckpointVersion()
		logging.Warn(ctx, "checkpoint policy read failed; using default checkpoint version",
			slog.String("error", err.Error()),
			slog.String("using_checkpoint_version", version),
		)
		return version
	}
	return checkpointpolicy.CheckpointVersion(state.Policy)
}
```

Mcmd/entire/cli/checkpoint_policy_write.go+8/-1

```