fix remote unsupported checkpoint resume

24df573→main·

pfleidi·3w ago·4 files·+60 added/-5 removed

Preserve unsupported checkpoint-version errors while checking remote metadata during resume.

This keeps remote-only checkpoints consistent with local reads: if the checkpoint exists but uses a format this CLI cannot decode, resume returns the explicit compatibility error instead of falling through to a generic missing-metadata message.

Sessions

fb873cd67d32View transcript

?\Implement Checkpoint Policy Management SystemCodex·GPT-5.5·2 steps

Changes

4

• cmd/entire/cli

• Mexplain_export_test.go+4/-4

• Mexplain_test.go+1/-1

• Mresume.go+13

• Mresume_test.go+42

78 unmodified lines

79
80
81
82
82
83
84
85
11 unmodified lines

97
98
99
100
100
101
102
103
48 unmodified lines

152
153
154
155
155
156
157
158
149 unmodified lines

308
309
310
311
311
312
313
314

78 unmodified lines

require.NoError(t, store.WriteCommitted(context.Background(), opts))
}

func rewriteExportCheckpointVersion(t *testing.T, repo *git.Repository, cpID id.CheckpointID, version string) {
func rewriteExportCheckpointVersionToRefsV1(t *testing.T, repo *git.Repository, cpID id.CheckpointID) {
    t.Helper()
    ctx := context.Background()
    refName := plumbing.NewBranchReferenceName(paths.MetadataBranchName)
11 unmodified lines

require.NoError(t, err)
    var summary checkpoint.CheckpointSummary
    require.NoError(t, json.Unmarshal([]byte(content), &summary))
    summary.CheckpointVersion = version
    summary.CheckpointVersion = "refs-v1"
    metadataJSON, err := json.Marshal(summary)
    require.NoError(t, err)
    metadataHash, err := checkpoint.CreateBlobFromContent(repo, metadataJSON)
48 unmodified lines

SessionID:  "session-json-unsupported",
    Transcript: redact.AlreadyRedacted([]byte(`{"type":"user","message":{"content":[{"type":"text","text":"hi"}]}}` + "\n")),
    })
    rewriteExportCheckpointVersion(t, repo, cpID, "refs-v1")
    rewriteExportCheckpointVersionToRefsV1(t, repo, cpID)

var stdout, stderr bytes.Buffer
    err := runExplainExport(context.Background(), &stdout, &stderr, explainExportOptions{
149 unmodified lines

SessionID:  "session-unsupported-transcript",
        Transcript: redact.AlreadyRedacted(raw),
        })
        rewriteExportCheckpointVersion(t, repo, cpID, "refs-v1")
        rewriteExportCheckpointVersionToRefsV1(t, repo, cpID)

var stdout, stderr bytes.Buffer
        err := runExplainExport(context.Background(), &stdout, &stderr, tt.opts)

Mcmd/entire/cli/explain_export_test.go+4/-4

1001 unmodified lines

1002
1003
1004
1005
1005
1006
1007
1008

1001 unmodified lines

SessionID:  "session-explain-unsupported",
    Transcript: redact.AlreadyRedacted([]byte(`{"type":"user","message":{"content":[{"type":"text","text":"hi"}]}}` + "\n")),
    })
    rewriteExportCheckpointVersion(t, repo, cpID, "refs-v1")
    rewriteExportCheckpointVersionToRefsV1(t, repo, cpID)

lookup, err := newExplainCheckpointLookup(context.Background())
    require.NoError(t, err)

Mcmd/entire/cli/explain_test.go+1/-1

739 unmodified lines

740
741
742
743
744
745
746
11 unmodified lines

758
759
760
761
762
763
764
765
766
16 unmodified lines

783
784
785
786
787
788
789
790
791
9 unmodified lines

801
802
803
804
805
806
807
808
809
7 unmodified lines

817
818
819
820
821
822
823
824
825

739 unmodified lines

// Resolve checkpoint remote URL once; reuse for both fetch and error message.
    hasCheckpointRemote := remote.Configured(ctx)
    var unsupportedVersionErr error

// Try checkpoint_remote first if configured and resolved (that's where checkpoints are stored)
    var checkpointURL string
11 unmodified lines

defer freshRepo.Close()
        metadata, err := readCheckpointInfoFromRef(ctx, freshRepo, refs, checkpointID)
        if err != nil {
            if checkpointpolicy.IsUnsupportedVersion(err) {
                unsupportedVersionErr = err
            }
            logging.Debug(logCtx, "checkpoint remote: fetch succeeded but checkpoint metadata read failed",
                slog.String("checkpoint_id", checkpointID.String()),
                slog.String("error", err.Error()),
            )
16 unmodified lines

if metadataErr == nil {
        return resumeSession(ctx, w, errW, metadata, false)
    }
    if checkpointpolicy.IsUnsupportedVersion(metadataErr) {
        unsupportedVersionErr = metadataErr
    }
    logging.Debug(logCtx, "remote-tracking metadata read failed",
                              slog.String("checkpoint_id", checkpointID.String()),
                              slog.String("error", metadataErr.Error()),
            )
9 unmodified lines

defer freshRepo.Close()
        metadata, err := readCheckpointInfoFromRef(ctx, freshRepo, refs, checkpointID)
        if err != nil {
            if checkpointpolicy.IsUnsupportedVersion(err) && unsupportedVersionErr == nil {
                unsupportedVersionErr = err
            }
            logging.Debug(logCtx, "origin metadata fetch succeeded but checkpoint metadata read failed",
                slog.String("checkpoint_id", checkpointID.String()),
                slog.String("error", err.Error()),
            )
7 unmodified lines

slog.String("error", fetchErr.Error()),
    )
    }
    if unsupportedVersionErr != nil {
        return unsupportedVersionErr
    }

// Nothing worked — print helpful error message
    if hasCheckpointRemote {

Mcmd/entire/cli/resume.go+13

1063 unmodified lines

1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111

1063 unmodified lines

}

func TestCheckRemoteMetadata_ReturnsUnsupportedVersionFromRemote(t *testing.T) {
    tmpDir := t.TempDir()
    t.Chdir(tmpDir)

repo, _, _ := setupResumeTestRepo(t, tmpDir, false)

checkpointID := id.MustCheckpointID("abc123def456")
    writeCommittedResumeCheckpointWithAgent(
        t,
        repo,
        checkpointID,
        "2025-01-01-test-session",
        time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
        agent.AgentTypeClaudeCode,
    )
    rewriteExportCheckpointVersionToRefsV1(t, repo, checkpointID)

localRef, err := repo.Reference(plumbing.NewBranchReferenceName(paths.MetadataBranchName), true)
    if err != nil {
        t.Fatalf("Failed to get local metadata branch: %%v", err)
    }
    remoteRef := plumbing.NewHashReference(
        plumbing.NewRemoteReferenceName("origin", paths.MetadataBranchName),
        localRef.Hash(),
    )
    if err := repo.Storer.SetReference(remoteRef); err != nil {
        t.Fatalf("Failed to create remote ref: %%v", err)
    }
    if err := repo.Storer.RemoveReference(plumbing.NewBranchReferenceName(paths.MetadataBranchName)); err != nil {
        t.Fatalf("Failed to remove local metadata branch: %%v", err)
    }

var stdout, stderr bytes.Buffer
    err = checkRemoteMetadata(context.Background(), &stdout, &stderr, checkpointID, checkpoint.DefaultV1Refs())
    if err == nil {
        t.Fatal("checkRemoteMetadata() error = nil, want unsupported checkpoint version")
    }
    if !checkpointpolicy.IsUnsupportedVersion(err) {
        t.Fatalf("checkRemoteMetadata() error = %%v, want unsupported checkpoint version", err)
    }
}

func TestCheckRemoteMetadata_NoRemoteMetadataBranch(t *testing.T) {
    tmpDir := t.TempDir()
    t.Chdir(tmpDir)