Add Go v2 checkpoint migration tool

cmd/entire/cli/checkpoint/checkpoint.go

@@ -212,6 +212,10 @@ type WriteCommittedOptions struct {
 	// the original v1 checkpoint time in v2 metadata.
 	CreatedAt time.Time
 
+	// CommitTime is the optional git author/committer timestamp for the
+	// metadata-branch commit. When zero, writers use the current time.
+	CommitTime time.Time
+
 	// Strategy is the name of the strategy that created this checkpoint
 	Strategy string
 

cmd/entire/cli/checkpoint/committed.go

@@ -118,7 +118,11 @@ func (s *GitStore) WriteCommitted(ctx context.Context, opts WriteCommittedOption
 	}
 
 	commitMsg := s.buildCommitMessage(opts, taskMetadataPath)
-	newCommitHash, err := s.createCommit(ctx, newTreeHash, parentHash, commitMsg, opts.AuthorName, opts.AuthorEmail)
+	commitTime := opts.CommitTime
+	if commitTime.IsZero() {
+		commitTime = time.Now()
+	}
+	newCommitHash, err := s.createCommitAt(ctx, newTreeHash, parentHash, commitMsg, opts.AuthorName, opts.AuthorEmail, commitTime)
 	if err != nil {
 		return err
 	}
@@ -1933,11 +1937,14 @@ func GetGitAuthorFromRepo(repo *git.Repository) (name, email string) {
 // CreateCommit creates a git commit object with the given tree, parent, message, and author.
 // If parentHash is ZeroHash, the commit is created without a parent (orphan commit).
 func CreateCommit(ctx context.Context, repo *git.Repository, treeHash, parentHash plumbing.Hash, message, authorName, authorEmail string) (plumbing.Hash, error) {
-	now := time.Now()
+	return createCommitObject(ctx, repo, treeHash, parentHash, message, authorName, authorEmail, time.Now())
+}
+
+func createCommitObject(ctx context.Context, repo *git.Repository, treeHash, parentHash plumbing.Hash, message, authorName, authorEmail string, commitTime time.Time) (plumbing.Hash, error) {
 	sig := object.Signature{
 		Name:  authorName,
 		Email: authorEmail,
-		When:  now,
+		When:  commitTime,
 	}
 
 	commit := &object.Commit{

cmd/entire/cli/checkpoint/committed_commit_time_test.go

@@ -0,0 +1,100 @@
+package checkpoint
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/entireio/cli/cmd/entire/cli/checkpoint/id"
+	"github.com/entireio/cli/cmd/entire/cli/paths"
+	"github.com/entireio/cli/cmd/entire/cli/testutil"
+	"github.com/entireio/cli/redact"
+
+	"github.com/go-git/go-git/v6"
+	"github.com/go-git/go-git/v6/plumbing"
+	"github.com/go-git/go-git/v6/plumbing/object"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	commitTimeStrategy   = "manual-commit"
+	commitTimeTestAuthor = "Test"
+	commitTimeTestEmail  = "test@example.com"
+)
+
+func TestWriteCommitted_CommitTime(t *testing.T) {
+	t.Parallel()
+
+	repo, store := setupCommittedCommitTimeRepo(t)
+	commitTime := time.Date(2024, 3, 2, 1, 2, 3, 0, time.UTC)
+
+	err := store.WriteCommitted(context.Background(), WriteCommittedOptions{
+		CheckpointID: id.MustCheckpointID("a1b2c3d4e5f6"),
+		SessionID:    "session-commit-time",
+		CreatedAt:    time.Date(2024, 3, 1, 1, 2, 3, 0, time.UTC),
+		CommitTime:   commitTime,
+		Strategy:     commitTimeStrategy,
+		Transcript:   redact.AlreadyRedacted([]byte("transcript line\n")),
+		AuthorName:   "Migration",
+		AuthorEmail:  "migration@example.com",
+	})
+	require.NoError(t, err)
+
+	commit := metadataHeadCommit(t, repo)
+	require.True(t, commit.Author.When.Equal(commitTime), "author time = %s, want %s", commit.Author.When, commitTime)
+	require.True(t, commit.Committer.When.Equal(commitTime), "committer time = %s, want %s", commit.Committer.When, commitTime)
+}
+
+func TestWriteCommitted_ZeroCommitTimeUsesCurrentTime(t *testing.T) {
+	t.Parallel()
+
+	repo, store := setupCommittedCommitTimeRepo(t)
+	createdAt := time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC)
+	before := time.Now().Add(-time.Second)
+
+	err := store.WriteCommitted(context.Background(), WriteCommittedOptions{
+		CheckpointID: id.MustCheckpointID("b2c3d4e5f6a1"),
+		SessionID:    "session-current-time",
+		CreatedAt:    createdAt,
+		Strategy:     commitTimeStrategy,
+		Transcript:   redact.AlreadyRedacted([]byte("transcript line\n")),
+		AuthorName:   commitTimeTestAuthor,
+		AuthorEmail:  commitTimeTestEmail,
+	})
+	require.NoError(t, err)
+	after := time.Now().Add(time.Second)
+
+	commit := metadataHeadCommit(t, repo)
+	require.False(t, commit.Author.When.Equal(createdAt), "zero CommitTime should not reuse CreatedAt as the commit timestamp")
+	require.False(t, commit.Author.When.Before(before), "author time = %s, want no earlier than %s", commit.Author.When, before)
+	require.False(t, commit.Author.When.After(after), "author time = %s, want no later than %s", commit.Author.When, after)
+	require.True(t, commit.Committer.When.Equal(commit.Author.When), "committer time = %s, want author time %s", commit.Committer.When, commit.Author.When)
+}
+
+func setupCommittedCommitTimeRepo(t *testing.T) (*git.Repository, *GitStore) {
+	t.Helper()
+
+	dir := t.TempDir()
+	testutil.InitRepo(t, dir)
+
+	repo, err := git.PlainOpen(dir)
+	require.NoError(t, err)
+
+	testutil.WriteFile(t, dir, "README.md", "# Test\n")
+	testutil.GitAdd(t, dir, "README.md")
+	testutil.GitCommit(t, dir, "initial commit")
+
+	return repo, NewGitStore(repo)
+}
+
+func metadataHeadCommit(t *testing.T, repo *git.Repository) *object.Commit {
+	t.Helper()
+
+	ref, err := repo.Reference(plumbing.NewBranchReferenceName(paths.MetadataBranchName), true)
+	require.NoError(t, err)
+
+	commit, err := repo.CommitObject(ref.Hash())
+	require.NoError(t, err)
+
+	return commit
+}

cmd/entire/cli/checkpoint/temporary.go

@@ -849,6 +849,10 @@ func (s *GitStore) createCommit(ctx context.Context, treeHash, parentHash plumbi
 	return CreateCommit(ctx, s.repo, treeHash, parentHash, message, authorName, authorEmail)
 }
 
+func (s *GitStore) createCommitAt(ctx context.Context, treeHash, parentHash plumbing.Hash, message, authorName, authorEmail string, commitTime time.Time) (plumbing.Hash, error) {
+	return createCommitObject(ctx, s.repo, treeHash, parentHash, message, authorName, authorEmail, commitTime)
+}
+
 // Helper functions extracted from strategy/common.go
 // These are exported for use by strategy package (push_common.go, session_test.go)
 

cmd/entire/cli/checkpoint/v2_read.go

@@ -266,7 +266,7 @@ func (s *V2GitStore) GetCheckpointAuthor(ctx context.Context, checkpointID id.Ch
 }
 
 // ReadSessionContent reads a session's metadata and prompts from the v2 /main ref,
-// and the raw transcript (raw_transcript) from /full/current.
+// and the raw transcript (raw_transcript) from local or remote /full refs.
 // This is the v2 equivalent of GitStore.ReadSessionContent — it reads the raw agent
 // transcript, not the compact transcript.jsonl. Used by resume and RestoreLogsOnly.
 // Returns ErrNoTranscript if the session exists but no raw transcript is available.

cmd/entire/cli/strategy/push_common.go

@@ -212,7 +212,7 @@ func tryPushSessionsCommon(ctx context.Context, remoteName, branchName string) (
 	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
 	defer cancel()
 
-	result, err := remote.Push(ctx, remoteName, branchName)
+	result, err := remote.Push(ctx, remoteName, branchPushRefSpec(branchName))
 	outputStr := result.Output
 	if err != nil {
 		return pushResult{}, classifyPushFailure(ctx, outputStr, err)
@@ -221,6 +221,11 @@ func tryPushSessionsCommon(ctx context.Context, remoteName, branchName string) (
 	return parsePushResult(outputStr), nil
 }
 
+func branchPushRefSpec(branchName string) string {
+	branchRef := plumbing.NewBranchReferenceName(branchName).String()
+	return branchRef + ":" + branchRef
+}
+
 // protectedRefError means the remote is blocking writes to the ref itself.
 type protectedRefError struct {
 	output string

cmd/entire/cli/strategy/push_common_test.go

@@ -1416,6 +1416,49 @@ func TestDoPushBranch_NewContent_SaysDone(t *testing.T) {
 	assert.NotContains(t, output, "already up-to-date", "should not say 'already up-to-date' when content was pushed")
 }
 
+// TestDoPushBranch_AmbiguousLocalRefs verifies that checkpoint pushes qualify
+// the branch refspec. A stale refs/entire/checkpoints/v1 ref can otherwise make
+// git reject the unqualified source ref as ambiguous.
+//
+// Not parallel: uses t.Chdir() and os.Stderr redirection.
+func TestDoPushBranch_AmbiguousLocalRefs(t *testing.T) {
+	workDir := setupRepoWithCheckpointBranch(t)
+
+	headCmd := exec.CommandContext(context.Background(), "git", "rev-parse", "HEAD")
+	headCmd.Dir = workDir
+	headCmd.Env = testutil.GitIsolatedEnv()
+	headOut, err := headCmd.Output()
+	require.NoError(t, err)
+
+	staleRefCmd := exec.CommandContext(
+		context.Background(),
+		"git",
+		"update-ref",
+		"refs/entire/checkpoints/v1",
+		strings.TrimSpace(string(headOut)),
+	)
+	staleRefCmd.Dir = workDir
+	staleRefCmd.Env = testutil.GitIsolatedEnv()
+	out, err := staleRefCmd.CombinedOutput()
+	require.NoError(t, err, "stale ref setup failed: %s", out)
+
+	bareDir := t.TempDir()
+	initCmd := exec.CommandContext(context.Background(), "git", "init", "--bare")
+	initCmd.Dir = bareDir
+	initCmd.Env = testutil.GitIsolatedEnv()
+	out, err = initCmd.CombinedOutput()
+	require.NoError(t, err, "git init --bare failed: %s", out)
+
+	t.Chdir(workDir)
+
+	restore := captureStderr(t)
+	err = doPushBranch(context.Background(), bareDir, paths.MetadataBranchName)
+	output := restore()
+
+	require.NoError(t, err)
+	assert.Contains(t, output, " done", "should push despite ambiguous local refs")
+}
+
 func TestIsProtectedRefRejection(t *testing.T) {
 	t.Parallel()