feat(import): anchor turns to their recorded commits when available

Extends the import commit_sha anchor (PR #1825) to be per-turn: when a
Claude Code transcript records the commit(s) a turn made via gitOperation
records, the turn's checkpoint anchors to the last such commit that
resolves and is an ancestor of the default-branch fallback, instead of
always pointing at the default-branch head. Older transcripts (or
recorded commits that were squashed/rebased away) keep the existing
fallback behavior unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Entire-Checkpoint: 01KY5P3CT3T2K4KGK4QCTBGMA6

Author: peyton-alt

cmd/entire/cli/agentimport/agentimport.go

@@ -54,6 +54,12 @@ type Turn struct {
 	// subagent's tokens are counted exactly once rather than re-added on every
 	// turn after it is discovered.
 	Tokens *types.TokenUsage
+	// CommitSHAs are the commits this turn recorded making, in transcript
+	// order, as written by the agent's gitOperation transcript records
+	// (kind "committed" only). SHAs may be SHORT — callers must resolve them
+	// against the repo before use. Nil for agents/transcripts without the
+	// feature; the anchor then falls back to Options.LinkCommitSHA.
+	CommitSHAs []string
 }
 
 // Importer is the per-agent seam: it locates an agent's transcripts for a repo
@@ -99,10 +105,12 @@ type Options struct {
 	Now           time.Time
 	DryRun        bool
 
-	// LinkCommitSHA, when non-empty, is written to each imported checkpoint's
-	// metadata as commit_sha — the anchor commit the UI shows imported sessions
-	// against. The caller resolves it (default branch head when resolvable;
-	// see resolveImportLinkCommitSHA); Run does not.
+	// LinkCommitSHA, when non-empty, is the fallback anchor written to each
+	// imported checkpoint's metadata as commit_sha — the commit the UI shows
+	// imported sessions against. The caller resolves it (default branch head
+	// when resolvable; see resolveImportLinkCommitSHA); Run does not. A turn
+	// whose transcript records a resolvable commit that is an ancestor of this
+	// fallback anchors to that real commit instead (see turnAnchorResolver).
 	LinkCommitSHA string
 }
 
@@ -142,6 +150,11 @@ func Run(ctx context.Context, repo *git.Repository, imp Importer, opts Options)
 		}
 	}
 
+	// One resolver per Run: it lazily walks and memoizes opts.LinkCommitSHA's
+	// ancestor set the first time a turn actually carries a candidate, so a
+	// whole import run pays for at most one history walk, not one per turn.
+	anchorResolver := newTurnAnchorResolver(repo, opts.LinkCommitSHA)
+
 	for _, sf := range files {
 		res.SessionsScanned++
 		full, readErr := os.ReadFile(sf.Path)
@@ -176,7 +189,8 @@ func Run(ctx context.Context, repo *git.Repository, imp Importer, opts Options)
 				red = r
 				redacted = true
 			}
-			if err := writeTurn(ctx, stores, imp, cid, sf, red, turn, opts.LinkCommitSHA); err != nil {
+			anchor := anchorResolver.resolve(turn.CommitSHAs)
+			if err := writeTurn(ctx, stores, imp, cid, sf, red, turn, anchor); err != nil {
 				return res, err
 			}
 			existing[cid.String()] = true

cmd/entire/cli/agentimport/agentimport_test.go

@@ -213,6 +213,77 @@ func TestRun_StampsLinkCommitSHA(t *testing.T) {
 	}
 }
 
+// TestRun_AnchorsTurnToRecordedCommit proves a turn whose transcript records a
+// resolvable, default-branch-reachable commit anchors to that real commit
+// instead of the LinkCommitSHA fallback, while a turn with no recorded commit
+// still falls back exactly as before.
+func TestRun_AnchorsTurnToRecordedCommit(t *testing.T) {
+	t.Parallel()
+	repo, repoDir := initRepoWithCommit(t)
+	firstCommit, err := repo.Head()
+	if err != nil {
+		t.Fatal(err)
+	}
+	firstSHA := firstCommit.Hash().String()
+
+	// Second commit on the default branch, so tip != first commit.
+	wt, err := repo.Worktree()
+	if err != nil {
+		t.Fatal(err)
+	}
+	writeAndCommit(t, wt, repoDir, "f.txt", "y", "second")
+	tipHead, err := repo.Head()
+	if err != nil {
+		t.Fatal(err)
+	}
+	tipSHA := tipHead.Hash().String()
+
+	claudeDir := t.TempDir()
+	content := strings.Join([]string{
+		`{"type":"user","uuid":"u1","timestamp":"2026-06-20T00:00:00Z","message":{"role":"user","content":"first"}}`,
+		`{"type":"assistant","uuid":"a1","message":{"id":"m1","model":"claude-x","content":[{"type":"text","text":"ok"}],"usage":{"output_tokens":5}}}`,
+		`{"type":"user","uuid":"tr1","toolUseResult":{"gitOperation":{"commit":{"sha":"` + firstSHA[:7] + `","kind":"committed"}}}}`,
+		`{"type":"user","uuid":"u2","timestamp":"2026-06-20T00:01:00Z","message":{"role":"user","content":"second"}}`,
+	}, "\n") + "\n"
+	if err := os.WriteFile(filepath.Join(claudeDir, "sess-anchor.jsonl"), []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	res, err := Run(context.Background(), repo, claudeImporter{}, Options{
+		RepoRoot: repoDir, OverridePath: claudeDir,
+		Now:           time.Date(2026, 6, 25, 0, 0, 0, 0, time.UTC),
+		LinkCommitSHA: tipSHA,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.TurnsImported != 2 {
+		t.Fatalf("want 2 imported, got %+v", res)
+	}
+
+	stores, err := cp.Open(context.Background(), repo, cp.OpenOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cid1 := DeriveCheckpointID("sess-anchor", "u1")
+	md1, err := stores.Persistent.ReadSessionMetadata(context.Background(), cid1, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if md1.CommitSHA != firstSHA {
+		t.Fatalf("turn1 CommitSHA = %q, want recorded commit %q", md1.CommitSHA, firstSHA)
+	}
+
+	cid2 := DeriveCheckpointID("sess-anchor", "u2")
+	md2, err := stores.Persistent.ReadSessionMetadata(context.Background(), cid2, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if md2.CommitSHA != tipSHA {
+		t.Fatalf("turn2 CommitSHA = %q, want fallback %q", md2.CommitSHA, tipSHA)
+	}
+}
+
 // TestRun_AppliesConfiguredCustomRedaction proves imported transcripts honor
 // repo/user-configured custom_redactions (loaded at the command via
 // strategy.EnsureRedactionConfigured), not just always-on secret scanning.

cmd/entire/cli/agentimport/claude.go

@@ -57,11 +57,12 @@ func (claudeImporter) SplitTurns(sf SessionFile, full []byte) ([]Turn, error) {
 				return nil, nil
 			}
 			return &Turn{
-				UUID:      rec.UUID,
-				Prompt:    transcript.ExtractUserContent(rec.Message),
-				Model:     modelInRange(rawLines, start, end),
-				CreatedAt: parseTimestamp(rec.Timestamp),
-				Tokens:    tokens,
+				UUID:       rec.UUID,
+				Prompt:     transcript.ExtractUserContent(rec.Message),
+				Model:      modelInRange(rawLines, start, end),
+				CreatedAt:  parseTimestamp(rec.Timestamp),
+				Tokens:     tokens,
+				CommitSHAs: commitSHAsInRange(rawLines, start, end),
 			}, nil
 		})
 }
@@ -98,6 +99,34 @@ func modelInRange(rawLines [][]byte, start, end int) string {
 	return ""
 }
 
+// commitSHAsInRange returns the commit SHAs recorded by gitOperation
+// tool-result records within [start, end), in order. Only kind "committed"
+// is collected — other kinds (or commit-less gitOperation records like
+// push/branch/pr) are ignored. SHAs are short; resolution happens in Run.
+func commitSHAsInRange(rawLines [][]byte, start, end int) []string {
+	var shas []string
+	for i := start; i < end && i < len(rawLines); i++ {
+		var rec struct {
+			ToolUseResult struct {
+				GitOperation struct {
+					Commit struct {
+						SHA  string `json:"sha"`
+						Kind string `json:"kind"`
+					} `json:"commit"`
+				} `json:"gitOperation"`
+			} `json:"toolUseResult"`
+		}
+		if err := json.Unmarshal(rawLines[i], &rec); err != nil {
+			continue
+		}
+		c := rec.ToolUseResult.GitOperation.Commit
+		if c.SHA != "" && c.Kind == "committed" {
+			shas = append(shas, c.SHA)
+		}
+	}
+	return shas
+}
+
 // isUserPromptLine reports whether a raw JSONL line is a genuine user-prompt
 // turn start: type "user" (or role "user") with non-empty extractable text.
 // tool_result lines are type "user" but carry no text, so they return false.

cmd/entire/cli/agentimport/claude_test.go

@@ -89,6 +89,44 @@ func TestClaudeSplitTurns_TwoPromptsBoundedByNext(t *testing.T) {
 	}
 }
 
+// TestClaudeSplitTurns_ExtractsCommitSHAs proves gitOperation tool-result
+// records are collected into Turn.CommitSHAs in transcript order, only for
+// kind "committed" — a tool_result line carrying a commit is not itself a
+// turn boundary (isUserPromptLine already rejects it), so it just attaches to
+// the enclosing turn.
+func TestClaudeSplitTurns_ExtractsCommitSHAs(t *testing.T) {
+	t.Parallel()
+	full := []byte(strings.Join([]string{
+		`{"type":"user","uuid":"u1","timestamp":"2026-06-20T00:00:00Z","message":{"role":"user","content":"first"}}`,
+		`{"type":"assistant","uuid":"a1","message":{"id":"m1","model":"claude-x","content":[{"type":"text","text":"ok"}],"usage":{"output_tokens":5}}}`,
+		`{"type":"user","uuid":"tr1","toolUseResult":{"gitOperation":{"commit":{"sha":"fe71aa6","kind":"committed"},"push":{"ok":true}}}}`,
+		`{"type":"user","uuid":"tr2","toolUseResult":{"gitOperation":{"commit":{"sha":"aabbccd","kind":"committed"}}}}`,
+		`{"type":"user","uuid":"tr3","toolUseResult":{"gitOperation":{"commit":{"sha":"ddeeff0","kind":"amended"}}}}`,
+		`{"type":"user","uuid":"tr4","toolUseResult":{"gitOperation":{"push":{"ok":true}}}}`,
+		`{"type":"user","uuid":"u2","timestamp":"2026-06-20T00:01:00Z","message":{"role":"user","content":"second"}}`,
+	}, "\n") + "\n")
+
+	turns, err := claudeImporter{}.SplitTurns(SessionFile{Path: filepath.Join(t.TempDir(), "s.jsonl"), SessionID: "s"}, full)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(turns) != 2 {
+		t.Fatalf("want 2 turns, got %d", len(turns))
+	}
+	wantSHAs := []string{"fe71aa6", "aabbccd"}
+	if len(turns[0].CommitSHAs) != len(wantSHAs) {
+		t.Fatalf("turn0 CommitSHAs = %v, want %v", turns[0].CommitSHAs, wantSHAs)
+	}
+	for i, want := range wantSHAs {
+		if turns[0].CommitSHAs[i] != want {
+			t.Errorf("turn0 CommitSHAs[%d] = %q, want %q", i, turns[0].CommitSHAs[i], want)
+		}
+	}
+	if len(turns[1].CommitSHAs) != 0 {
+		t.Errorf("turn1 CommitSHAs = %v, want empty", turns[1].CommitSHAs)
+	}
+}
+
 func TestClaudeSplitTurns_ToolResultIsNotATurn(t *testing.T) {
 	t.Parallel()
 	full := []byte(strings.Join([]string{

cmd/entire/cli/agentimport/turn_anchor.go

@@ -0,0 +1,95 @@
+package agentimport
+
+import (
+	"regexp"
+
+	"github.com/go-git/go-git/v6"
+	"github.com/go-git/go-git/v6/plumbing"
+	"github.com/go-git/go-git/v6/plumbing/object"
+)
+
+// shaCandidatePattern enforces the "candidates are SHAs" contract: a hex
+// string of plausible short-to-full sha length. Rejects revision syntax like
+// "HEAD" or "HEAD~2" from ever reaching ResolveRevision, where it would
+// otherwise resolve as a ref/expression rather than a commit sha.
+var shaCandidatePattern = regexp.MustCompile(`^[0-9a-f]{4,64}$`)
+
+// turnAnchorResolver picks the commit_sha anchor for each imported turn in one
+// Run: the LAST candidate (transcript order — the turn's end state) that both
+// resolves in the repo and is an ancestor of fallback, else fallback itself.
+// fallback is the caller-resolved default-branch tip (Options.LinkCommitSHA);
+// ancestry against it doubles as the reachability check, so this needs no
+// branch-name logic. Candidates are short SHAs from transcript gitOperation
+// records; squash-merged or rebased-away commits simply fail to resolve or
+// fail ancestry and fall through, as does any candidate that isn't a
+// hex sha (e.g. revision syntax like "HEAD") or that resolves ambiguously.
+//
+// The fallback's ancestor set is walked and memoized once, lazily, on the
+// first turn that actually carries a candidate — a single
+// object.NewCommitPreorderIter walk per import run rather than one IsAncestor
+// walk per candidate. Turns/sessions with no recorded commits (the common
+// case for older transcripts) never trigger the walk. Not safe for concurrent
+// use — Run calls resolve from a single goroutine.
+type turnAnchorResolver struct {
+	repo      *git.Repository
+	fallback  string
+	ancestors map[plumbing.Hash]struct{} // nil until first candidate-bearing call
+}
+
+// newTurnAnchorResolver builds a resolver for one Run. It does no repo work
+// until resolve is first called with a non-empty candidate list.
+func newTurnAnchorResolver(repo *git.Repository, fallback string) *turnAnchorResolver {
+	return &turnAnchorResolver{repo: repo, fallback: fallback}
+}
+
+// resolve returns the anchor for one turn's candidates. Empty fallback or no
+// candidates return fallback unchanged (empty fallback → "" — unanchorable
+// repo imports unlinked, matching resolveImportLinkCommitSHA's contract).
+func (r *turnAnchorResolver) resolve(candidates []string) string {
+	if r.fallback == "" || len(candidates) == 0 {
+		return r.fallback
+	}
+	if r.ancestors == nil {
+		r.ancestors = r.buildAncestors()
+	}
+	for i := len(candidates) - 1; i >= 0; i-- {
+		c := candidates[i]
+		if !shaCandidatePattern.MatchString(c) {
+			continue
+		}
+		hash, err := r.repo.ResolveRevision(plumbing.Revision(c))
+		if err != nil || hash == nil {
+			continue
+		}
+		if _, ok := r.ancestors[*hash]; ok {
+			return hash.String()
+		}
+	}
+	return r.fallback
+}
+
+// buildAncestors walks fallback's history exactly once, collecting every
+// reachable commit hash (including fallback itself — a commit is its own
+// ancestor, matching go-git's IsAncestor semantics). If the fallback commit
+// doesn't resolve or the history can't be walked, it returns an empty set —
+// every candidate then falls through to the fallback in resolve, same as the
+// original per-call error handling this replaces.
+func (r *turnAnchorResolver) buildAncestors() map[plumbing.Hash]struct{} {
+	ancestors := make(map[plumbing.Hash]struct{})
+	fbCommit, err := r.repo.CommitObject(plumbing.NewHash(r.fallback))
+	if err != nil {
+		return ancestors
+	}
+	iter := object.NewCommitPreorderIter(fbCommit, nil, nil)
+	defer iter.Close()
+	if err := iter.ForEach(func(c *object.Commit) error {
+		ancestors[c.Hash] = struct{}{}
+		return nil
+	}); err != nil {
+		// Best-effort: return whatever was collected before the walk broke
+		// (e.g. a missing object deep in history). Any candidate not already
+		// in this partial set falls through to the fallback in resolve.
+		return ancestors
+	}
+	return ancestors
+}