feat: push logic for checkpoints v2 refs

cmd/entire/cli/checkpoint/committed.go

@@ -894,76 +894,49 @@ func (s *GitStore) ListCommitted(ctx context.Context) ([]CommittedInfo, error) {
 	var checkpoints []CommittedInfo
 
 	// Scan sharded structure: <2-char-prefix>/<remaining-id>/metadata.json
-	for _, bucketEntry := range tree.Entries {
-		if bucketEntry.Mode != filemode.Dir {
-			continue
-		}
-		// Bucket should be 2 hex chars
-		if len(bucketEntry.Name) != 2 {
-			continue
+	_ = WalkCheckpointShards(s.repo, tree, func(checkpointID id.CheckpointID, cpTreeHash plumbing.Hash) error { //nolint:errcheck // callback never returns errors
+		checkpointTree, cpTreeErr := s.repo.TreeObject(cpTreeHash)
+		if cpTreeErr != nil {
+			return nil //nolint:nilerr // skip unreadable entries, continue walking
 		}
 
-		bucketTree, treeErr := s.repo.TreeObject(bucketEntry.Hash)
-		if treeErr != nil {
-			continue
+		info := CommittedInfo{
+			CheckpointID: checkpointID,
 		}
 
-		// Each entry in the bucket is the remaining part of the checkpoint ID
-		for _, checkpointEntry := range bucketTree.Entries {
-			if checkpointEntry.Mode != filemode.Dir {
-				continue
-			}
-
-			checkpointTree, cpTreeErr := s.repo.TreeObject(checkpointEntry.Hash)
-			if cpTreeErr != nil {
-				continue
-			}
-
-			// Reconstruct checkpoint ID: <bucket><remaining>
-			checkpointIDStr := bucketEntry.Name + checkpointEntry.Name
-			checkpointID, cpIDErr := id.NewCheckpointID(checkpointIDStr)
-			if cpIDErr != nil {
-				// Skip invalid checkpoint IDs (shouldn't happen with our own data)
-				continue
-			}
-
-			info := CommittedInfo{
-				CheckpointID: checkpointID,
-			}
-
-			// Get details from root metadata file (CheckpointSummary format)
-			if metadataFile, fileErr := checkpointTree.File(paths.MetadataFileName); fileErr == nil {
-				if content, contentErr := metadataFile.Contents(); contentErr == nil {
-					var summary CheckpointSummary
-					if err := json.Unmarshal([]byte(content), &summary); err == nil {
-						info.CheckpointsCount = summary.CheckpointsCount
-						info.FilesTouched = summary.FilesTouched
-						info.SessionCount = len(summary.Sessions)
-
-						// Read session metadata from latest session to get Agent, SessionID, CreatedAt
-						if len(summary.Sessions) > 0 {
-							latestIndex := len(summary.Sessions) - 1
-							latestDir := strconv.Itoa(latestIndex)
-							if sessionTree, treeErr := checkpointTree.Tree(latestDir); treeErr == nil {
-								if sessionMetadataFile, smErr := sessionTree.File(paths.MetadataFileName); smErr == nil {
-									if sessionContent, scErr := sessionMetadataFile.Contents(); scErr == nil {
-										var sessionMetadata CommittedMetadata
-										if json.Unmarshal([]byte(sessionContent), &sessionMetadata) == nil {
-											info.Agent = sessionMetadata.Agent
-											info.SessionID = sessionMetadata.SessionID
-											info.CreatedAt = sessionMetadata.CreatedAt
-										}
+		// Get details from root metadata file (CheckpointSummary format)
+		if metadataFile, fileErr := checkpointTree.File(paths.MetadataFileName); fileErr == nil {
+			if content, contentErr := metadataFile.Contents(); contentErr == nil {
+				var summary CheckpointSummary
+				if err := json.Unmarshal([]byte(content), &summary); err == nil {
+					info.CheckpointsCount = summary.CheckpointsCount
+					info.FilesTouched = summary.FilesTouched
+					info.SessionCount = len(summary.Sessions)
+
+					// Read session metadata from latest session to get Agent, SessionID, CreatedAt
+					if len(summary.Sessions) > 0 {
+						latestIndex := len(summary.Sessions) - 1
+						latestDir := strconv.Itoa(latestIndex)
+						if sessionTree, treeErr := checkpointTree.Tree(latestDir); treeErr == nil {
+							if sessionMetadataFile, smErr := sessionTree.File(paths.MetadataFileName); smErr == nil {
+								if sessionContent, scErr := sessionMetadataFile.Contents(); scErr == nil {
+									var sessionMetadata CommittedMetadata
+									if json.Unmarshal([]byte(sessionContent), &sessionMetadata) == nil {
+										info.Agent = sessionMetadata.Agent
+										info.SessionID = sessionMetadata.SessionID
+										info.CreatedAt = sessionMetadata.CreatedAt
 									}
 								}
 							}
 						}
 					}
 				}
 			}
-
-			checkpoints = append(checkpoints, info)
 		}
-	}
+
+		checkpoints = append(checkpoints, info)
+		return nil
+	})
 
 	// Sort by time (most recent first)
 	sort.Slice(checkpoints, func(i, j int) bool {

cmd/entire/cli/checkpoint/parse_tree.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/entireio/cli/cmd/entire/cli/checkpoint/id"
 	"github.com/entireio/cli/cmd/entire/cli/paths"
 
 	"github.com/go-git/go-git/v6"
@@ -282,6 +283,42 @@ func ApplyTreeChanges(
 	return storeTree(repo, result)
 }
 
+// WalkCheckpointShards iterates over the two-level shard structure (<id[:2]>/<id[2:]>/)
+// in a checkpoint tree, calling fn for each checkpoint found. Skips non-directory entries
+// at both levels (e.g., generation.json at the root). The callback receives the parsed
+// checkpoint ID and the tree hash of the checkpoint subtree.
+func WalkCheckpointShards(repo *git.Repository, tree *object.Tree, fn func(cpID id.CheckpointID, cpTreeHash plumbing.Hash) error) error {
+	for _, bucketEntry := range tree.Entries {
+		if bucketEntry.Mode != filemode.Dir {
+			continue
+		}
+		if len(bucketEntry.Name) != 2 {
+			continue
+		}
+
+		bucketTree, err := repo.TreeObject(bucketEntry.Hash)
+		if err != nil {
+			continue
+		}
+
+		for _, cpEntry := range bucketTree.Entries {
+			if cpEntry.Mode != filemode.Dir {
+				continue
+			}
+
+			cpID, err := id.NewCheckpointID(bucketEntry.Name + cpEntry.Name)
+			if err != nil {
+				continue
+			}
+
+			if err := fn(cpID, cpEntry.Hash); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // splitFirstSegment splits "a/b/c" into ("a", "b/c"), and "file.txt" into ("file.txt", "").
 func splitFirstSegment(path string) (first, rest string) {
 	parts := strings.SplitN(path, "/", 2)

cmd/entire/cli/checkpoint/v2_committed.go

@@ -79,7 +79,7 @@ func (s *V2GitStore) UpdateCommitted(ctx context.Context, opts UpdateCommittedOp
 // Returns the session index for coordination with /full/current.
 func (s *V2GitStore) updateCommittedMain(ctx context.Context, opts UpdateCommittedOptions) (int, error) {
 	refName := plumbing.ReferenceName(paths.V2MainRefName)
-	parentHash, rootTreeHash, err := s.getRefState(refName)
+	parentHash, rootTreeHash, err := s.GetRefState(refName)
 	if err != nil {
 		return 0, ErrCheckpointNotFound
 	}
@@ -192,7 +192,7 @@ func (s *V2GitStore) updateCommittedFullTranscript(ctx context.Context, opts Upd
 		return fmt.Errorf("failed to ensure /full/current ref: %w", err)
 	}
 
-	parentHash, rootTreeHash, err := s.getRefState(refName)
+	parentHash, rootTreeHash, err := s.GetRefState(refName)
 	if err != nil {
 		return err
 	}
@@ -244,7 +244,7 @@ func (s *V2GitStore) writeCommittedMain(ctx context.Context, opts WriteCommitted
 		return 0, fmt.Errorf("failed to ensure /main ref: %w", err)
 	}
 
-	parentHash, rootTreeHash, err := s.getRefState(refName)
+	parentHash, rootTreeHash, err := s.GetRefState(refName)
 	if err != nil {
 		return 0, err
 	}
@@ -463,7 +463,7 @@ func (s *V2GitStore) writeCommittedFullTranscript(ctx context.Context, opts Writ
 		return fmt.Errorf("failed to ensure /full/current ref: %w", err)
 	}
 
-	parentHash, rootTreeHash, err := s.getRefState(refName)
+	parentHash, rootTreeHash, err := s.GetRefState(refName)
 	if err != nil {
 		return err
 	}
@@ -500,29 +500,25 @@ func (s *V2GitStore) writeCommittedFullTranscript(ctx context.Context, opts Writ
 		return err
 	}
 
-	// Update generation.json at the tree root with the new checkpoint ID and timestamps.
-	// This reads from the pre-splice root tree (to get existing metadata) and writes
-	// into the post-splice tree (which already has the shard directories).
-	gen, err := s.updateGenerationForWrite(rootTreeHash, opts.CheckpointID, time.Now().UTC())
-	if err != nil {
-		return fmt.Errorf("failed to update generation metadata: %w", err)
-	}
-	newTreeHash, err = s.addGenerationToRootTree(newTreeHash, gen)
-	if err != nil {
-		return fmt.Errorf("failed to add generation.json to tree: %w", err)
-	}
-
 	commitMsg := fmt.Sprintf("Checkpoint: %s\n", opts.CheckpointID)
 	if err := s.updateRef(refName, newTreeHash, parentHash, commitMsg, opts.AuthorName, opts.AuthorEmail); err != nil {
 		return err
 	}
 
 	// Check if rotation is needed after successful write.
-	if len(gen.Checkpoints) >= s.maxCheckpoints() {
+	// Count checkpoints by walking the tree (no generation.json on /full/current).
+	checkpointCount, countErr := s.CountCheckpointsInTree(newTreeHash)
+	if countErr != nil {
+		logging.Warn(ctx, "failed to count checkpoints for rotation check",
+			slog.String("error", countErr.Error()),
+		)
+		return nil
+	}
+	if checkpointCount >= s.maxCheckpoints() {
 		if rotErr := s.rotateGeneration(ctx); rotErr != nil {
 			logging.Warn(ctx, "generation rotation failed",
 				slog.String("error", rotErr.Error()),
-				slog.Int("checkpoint_count", len(gen.Checkpoints)),
+				slog.Int("checkpoint_count", checkpointCount),
 			)
 			// Non-fatal: rotation failure doesn't invalidate the write
 		}