# fix checkpoint reader edge cases `c17199d`→[main](/content/gh/entireio/cli/commits/main/index.html)· pfleidi·4w ago·4 files·+76 added/-3 removed Keep empty-session checkpoints distinct from missing checkpoints when reading latest session content. Also narrow resume checkpoint metadata resolution to the methods it actually uses so the split store interfaces stay precise. ## Sessions 8e67ab6c5252View transcript [?\ Refactor Checkpoint Storage Interfaces and Domain AdaptersCodex·GPT-5.5·6 steps](/content/gh/entireio/cli/session/019edcc1-ea65-7431-89c5-c3bfe3140f75#timeline-8e67ab6c5252/index.html) ## Changes 4 - cmd/entire/cli - checkpoint - Mcommitted_reader_resolve.go+4/-1 - Mcommitted_reader_resolve_test.go+13 - Mresume.go+7/-2 - Mresume_test.go+52 ``` 60 unmodified lines 61 62 63 64 64 65 66 67 68 69 70 71 72 60 unmodified lines // ReadLatestSessionContent reads the latest session from an already-resolved // committed reader and summary. func ReadLatestSessionContent(ctx context.Context, reader CommittedReader, checkpointID id.CheckpointID, summary *CheckpointSummary) (*SessionContent, error) { if summary == nil || len(summary.Sessions) == 0 { if summary == nil { return nil, ErrCheckpointNotFound } if len(summary.Sessions) == 0 { return nil, fmt.Errorf("checkpoint has no sessions: %s", checkpointID) } latestIndex := len(summary.Sessions) - 1 content, err := reader.ReadSessionContent(ctx, checkpointID, latestIndex) if err != nil { ``` Mcmd/entire/cli/checkpoint/committed_reader_resolve.go+4/-1 ``` 31 unmodified lines 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 31 unmodified lines require.ErrorContains(t, err, "read committed checkpoint") } func TestReadLatestSessionContentEmptySummaryReturnsDistinctError(t *testing.T) { t.Parallel() cpID := id.MustCheckpointID("111111111111") summary := &CheckpointSummary{} reader := &committedReaderStub{summary: summary} content, err := ReadLatestSessionContent(context.Background(), reader, cpID, summary) require.Nil(t, content) require.ErrorContains(t, err, "checkpoint has no sessions") require.NotErrorIs(t, err, ErrCheckpointNotFound) } func TestReadRawSessionLogForCheckpointReadsLatestV1Session(t *testing.T) { t.Parallel() ``` Mcmd/entire/cli/checkpoint/committed_reader_resolve_test.go+13 ``` 328 unmodified lines 329 330 331 332 332 333 334 335 13 unmodified lines 349 350 351 352 352 353 354 355 356 357 358 359 360 328 unmodified lines // resolveLatestCheckpoint reads metadata for each checkpoint ID and returns // the checkpoint with the latest CreatedAt. func resolveLatestCheckpoint(ctx context.Context, store checkpoint.CommittedListReader, checkpointIDs []id.CheckpointID) (*strategy.CheckpointInfo, error) { func resolveLatestCheckpoint(ctx context.Context, store checkpointInfoReader, checkpointIDs []id.CheckpointID) (*strategy.CheckpointInfo, error) { infoMap := make(map[id.CheckpointID]strategy.CheckpointInfo, len(checkpointIDs)) for _, cpID := range checkpointIDs { metadata, readErr := readCheckpointInfoFromStore(ctx, store, cpID) 13 unmodified lines return &latest, nil } func readCheckpointInfoFromStore(ctx context.Context, store checkpoint.CommittedListReader, checkpointID id.CheckpointID) (*strategy.CheckpointInfo, error) { type checkpointInfoReader interface { checkpoint.CommittedReader ReadSessionMetadata(ctx context.Context, checkpointID id.CheckpointID, sessionIndex int) (*checkpoint.CommittedMetadata, error) } func readCheckpointInfoFromStore(ctx context.Context, store checkpointInfoReader, checkpointID id.CheckpointID) (*strategy.CheckpointInfo, error) { summary, err := checkpoint.ReadCommittedCheckpoint(ctx, store, checkpointID) if err != nil { return nil, fmt.Errorf("read checkpoint: %w", err) ``` Mcmd/entire/cli/resume.go+7/-2 ``` 591 unmodified lines 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 591 unmodified lines } } func TestResolveLatestCheckpointUsesCheckpointInfoReader(t *testing.T) { t.Parallel() oldID := id.MustCheckpointID("aaa111bbb222") newID := id.MustCheckpointID("ccc333ddd444") reader := &resumeCheckpointInfoReaderStub{ summaries: map[id.CheckpointID]*checkpoint.CheckpointSummary{ oldID: {Sessions: []checkpoint.SessionFilePaths{{Metadata: "old"}}}, newID: {Sessions: []checkpoint.SessionFilePaths{{Metadata: "new"}}}, }, metadata: map[id.CheckpointID][]checkpoint.CommittedMetadata{ oldID: {{ SessionID: "old-session", CreatedAt: time.Date(2025, 1, 1, 10, 0, 0, 0, time.UTC), }}, newID: {{ SessionID: "new-session", CreatedAt: time.Date(2025, 1, 1, 11, 0, 0, 0, time.UTC), }}, }, } latest, err := resolveLatestCheckpoint(context.Background(), reader, []id.CheckpointID{oldID, newID}) if err != nil { t.Fatalf("resolveLatestCheckpoint() error = %v", err) } if latest.CheckpointID != newID { t.Errorf("resolveLatestCheckpoint() = %s, want %s", latest.CheckpointID, newID) } } type resumeCheckpointInfoReaderStub struct { summaries map[id.CheckpointID]*checkpoint.CheckpointSummary metadata map[id.CheckpointID][]checkpoint.CommittedMetadata } func (r *resumeCheckpointInfoReaderStub) ReadCommitted(_ context.Context, checkpointID id.CheckpointID) (*checkpoint.CheckpointSummary, error) { return r.summaries[checkpointID], nil } func (r *resumeCheckpointInfoReaderStub) ReadSessionContent(_ context.Context, _ id.CheckpointID, _ int) (*checkpoint.SessionContent, error) { return nil, checkpoint.ErrCheckpointNotFound } func (r *resumeCheckpointInfoReaderStub) ReadSessionMetadata(_ context.Context, checkpointID id.CheckpointID, sessionIndex int) (*checkpoint.CommittedMetadata, error) { sessions := r.metadata[checkpointID] if sessionIndex < 0 || sessionIndex >= len(sessions) { return nil, checkpoint.ErrCheckpointNotFound } return &sessions[sessionIndex], nil } func TestReadCheckpointInfoFromStoreUsesLatestSessionMetadata(t *testing.T) { tmpDir := t.TempDir() t.Chdir(tmpDir)