@@ -16,6 +16,9 @@
 package attribution
 
 import (
+	"maps"
+	"slices"
+
 	"github.com/chainloop-dev/chainloop/app/cli/internal/trace"
 	tracegit "github.com/chainloop-dev/chainloop/app/cli/internal/trace/git"
 	"github.com/chainloop-dev/chainloop/app/cli/internal/trace/state"
@@ -63,6 +66,12 @@ type CommitLines struct {
 // (R-003). A file that tip does not hold keeps the AI ranges at edit time,
 // with no attribution, as older CLIs write them (R-005).
 //
+// A file that was renamed after a commit of the session has the lines of its
+// new path in tip (R-007). A line there counts for the path that its commit
+// changed, so a session that changed the file under both paths counts each
+// line once. A commit that renamed a file matches the ledger of the new path,
+// then of the old one.
+//
 // A file with an edit recorded before line fingerprints existed keeps the
 // earlier rule: AI lines are the recorded ranges, capped at the file's diff.
 func Enrich(sessionID string, ledgers map[string]*state.AILineAttribution, commits []CommitLines, tip map[string][]tracegit.BlameLine, changes *aicodingsession.CodeChanges) {
@@ -83,15 +92,25 @@ func Enrich(sessionID string, ledgers map[string]*state.AILineAttribution, commi
 		positioned[path] = net.ranges
 	}
 
+	oldPaths := make(map[string][]string)
+	for _, c := range commits {
+		for _, fl := range c.Files {
+			if fl.OldPath != "" && !slices.Contains(oldPaths[fl.Path], fl.OldPath) {
+				oldPaths[fl.Path] = append(oldPaths[fl.Path], fl.OldPath)
+			}
+		}
+	}
+
 	changes.AILinesAdded, changes.AILinesRemoved = 0, 0
 	changes.HumanLinesAdded, changes.HumanLinesRemoved = 0, 0
 	for i := range changes.Files {
 		f := &changes.Files[i]
 
 		// The marker keeps its earlier meaning, a file that the session
-		// edited, for platforms that do not read the split (R-009). An empty
-		// ranges slice is valid: the agent only deleted lines.
-		if aiRanges, ok := self.Files[f.Path]; ok {
+		// edited, also under the path that a commit renamed, for platforms
+		// that do not read the split (R-009). An empty ranges slice is valid:
+		// the agent only deleted lines.
+		if aiRanges, ok := editedRanges(self, f.Path, oldPaths[f.Path]); ok {
 			f.Attribution = trace.AttributionAI
 			f.LineRanges = aiRanges
 			f.SessionIDs = []string{sessionID}
@@ -141,6 +160,18 @@ func (s *fileSplit) addLine(n int, owner string) {
 	s.ranges = append(s.ranges, aicodingsession.LineRange{Start: n, End: n, Attribution: owner})
 }
 
+// editedRanges returns the recorded ranges of the session's edits of a file,
+// under its path or, when a commit renamed it, under an old path.
+func editedRanges(l *state.AILineAttribution, path string, oldPaths []string) ([]aicodingsession.LineRange, bool) {
+	for _, p := range append([]string{path}, oldPaths...) {
+		if ranges, ok := l.Files[p]; ok {
+			return ranges, true
+		}
+	}
+
+	return nil, false
+}
+
 // splitByPath matches the lines of each commit against the ledgers, and
 // returns the split of each file that the commits changed.
 func splitByPath(sessionID string, self *state.AILineAttribution, ledgers map[string]*state.AILineAttribution, commits []CommitLines) map[string]*fileSplit {
@@ -166,19 +197,19 @@ func splitByPath(sessionID string, self *state.AILineAttribution, ledgers map[st
 			for _, line := range fl.Added {
 				fp := Fingerprint(line)
 				switch {
-				case written.take(self, fl.Path, fp):
+				case written.takeFile(self, fl, fp):
 					s.aiAdded++
-				case written.takeAny(others, fl.Path, fp):
+				case written.takeAny(others, fl, fp):
 				default:
 					s.humanAdded++
 				}
 			}
 			for _, line := range fl.Removed {
 				fp := Fingerprint(line)
 				switch {
-				case erased.take(self, fl.Path, fp):
+				case erased.takeFile(self, fl, fp):
 					s.aiRemoved++
-				case erased.takeAny(others, fl.Path, fp):
+				case erased.takeAny(others, fl, fp):
 				default:
 					s.humanRemoved++
 				}
@@ -202,39 +233,41 @@ func netAdded(sessionID string, self *state.AILineAttribution, ledgers map[strin
 	written := linePool{pick: func(a *state.AILineAttribution) map[string]state.LineCounts { return a.Written }}
 	joined := make(map[[2]string]state.LineCounts)
 
+	// Two paths of the session can have the same lines in tip, after a
+	// rename. The order makes the split of such lines the same on each push.
 	out := make(map[string]*fileSplit, len(tip))
-	for path, lines := range tip {
+	for _, path := range slices.Sorted(maps.Keys(tip)) {
 		s := &fileSplit{}
 		out[path] = s
 
-		for i, l := range lines {
+		for i, l := range tip[path] {
 			commit, ok := bySHA[l.SHA]
 			if !ok {
 				continue
 			}
 			fp := Fingerprint(l.Text)
 
 			if commit.Joined != nil {
-				key := [2]string{commit.SHA, path}
-				pool, ok := joined[key]
-				if !ok {
-					pool = state.LineCounts{}
-					pool.Add(commit.Joined[path]...)
-					joined[key] = pool
-				}
-				if pool.Take(fp) {
+				if joinedPool(joined, commit, path, tip).Take(fp) {
 					s.humanAdded++
 					s.addLine(i+1, trace.AttributionHuman)
 				}
 
 				continue
 			}
 
+			// A line that the commit wrote under another path of the
+			// session counts for that path.
+			fl, ok := commit.file(path)
+			if !ok {
+				continue
+			}
+
 			switch {
-			case written.take(self, path, fp):
+			case written.takeFile(self, fl, fp):
 				s.aiAdded++
 				s.addLine(i+1, trace.AttributionAI)
-			case written.takeAny(otherLedgers(sessionID, ledgers, commit.SessionIDs), path, fp):
+			case written.takeAny(otherLedgers(sessionID, ledgers, commit.SessionIDs), fl, fp):
 			default:
 				s.humanAdded++
 				s.addLine(i+1, trace.AttributionHuman)
@@ -245,6 +278,47 @@ func netAdded(sessionID string, self *state.AILineAttribution, ledgers map[strin
 	return out
 }
 
+// file returns the lines that the commit changed in path.
+func (c CommitLines) file(path string) (tracegit.FileLines, bool) {
+	for _, fl := range c.Files {
+		if fl.Path == path {
+			return fl, true
+		}
+	}
+
+	return tracegit.FileLines{}, false
+}
+
+// joinedPool returns the human lines that a joined commit added to path, one
+// copy per match. A joined commit that changed the file under a path that tip
+// does not hold, because a later commit renamed it, shares one pool of those
+// lines across the paths of tip.
+func joinedPool(pools map[[2]string]state.LineCounts, commit CommitLines, path string, tip map[string][]tracegit.BlameLine) state.LineCounts {
+	key := [2]string{commit.SHA, path}
+	if _, direct := commit.Joined[path]; !direct {
+		key[1] = ""
+	}
+
+	pool, ok := pools[key]
+	if ok {
+		return pool
+	}
+
+	pool = state.LineCounts{}
+	if key[1] != "" {
+		pool.Add(commit.Joined[path]...)
+	} else {
+		for p, fps := range commit.Joined {
+			if _, inTip := tip[p]; !inTip {
+				pool.Add(fps...)
+			}
+		}
+	}
+	pools[key] = pool
+
+	return pool
+}
+
 // otherLedgers returns the ledgers of the sessions in ids other than
 // sessionID.
 func otherLedgers(sessionID string, ledgers map[string]*state.AILineAttribution, ids []string) []*state.AILineAttribution {
@@ -283,10 +357,16 @@ func (p *linePool) take(l *state.AILineAttribution, path, fp string) bool {
 	return c.Take(fp)
 }
 
-// takeAny takes fp from the first ledger that holds it.
-func (p *linePool) takeAny(ledgers []*state.AILineAttribution, path, fp string) bool {
+// takeFile takes fp from the lines of ledger l for the file, under its path,
+// and then under its old path when the commit renamed it.
+func (p *linePool) takeFile(l *state.AILineAttribution, fl tracegit.FileLines, fp string) bool {
+	return p.take(l, fl.Path, fp) || (fl.OldPath != "" && p.take(l, fl.OldPath, fp))
+}
+
+// takeAny takes fp from the first ledger that holds it for the file.
+func (p *linePool) takeAny(ledgers []*state.AILineAttribution, fl tracegit.FileLines, fp string) bool {
 	for _, l := range ledgers {
-		if p.take(l, path, fp) {
+		if p.takeFile(l, fl, fp) {
 			return true
 		}
 	}
 
@@ -58,6 +58,17 @@ func ledger(sessionID, file string, written, erased []string) *state.AILineAttri
 	}
 }
 
+// oldFile is the path of testFile before a rename.
+const oldFile = "old.go"
+
+// counts holds the fingerprints of lines.
+func counts(lines ...string) state.LineCounts {
+	c := state.LineCounts{}
+	c.Add(fps(lines...)...)
+
+	return c
+}
+
 func TestEnrich_Legacy(t *testing.T) {
 	t.Run("no AI data attributes all changes to human", func(t *testing.T) {
 		changes := &aicodingsession.CodeChanges{
@@ -255,6 +266,16 @@ func TestEnrich_Lines(t *testing.T) {
 			},
 			want: split{aiAdded: 2, humanAdded: 1, humanRemoved: 1},
 		},
+		{
+			// R-007: the agent edited the file under its old name, and the
+			// commit renamed it.
+			name:    "a renamed file matches the ledger of its old path",
+			ledgers: map[string]*state.AILineAttribution{testSession: ledger(testSession, oldFile, []string{"a"}, []string{"x"})},
+			commits: []CommitLines{{SessionIDs: []string{testSession}, Files: []tracegit.FileLines{
+				{Path: testFile, OldPath: oldFile, Added: []string{"a", "b"}, Removed: []string{"x", "y"}},
+			}}},
+			want: split{aiAdded: 1, aiRemoved: 1, humanAdded: 1, humanRemoved: 1},
+		},
 	}
 
 	for _, tc := range testCases {
@@ -378,6 +399,44 @@ func TestEnrich_Net(t *testing.T) {
 			want:    split{humanAdded: 2},
 			ranges:  []aicodingsession.LineRange{human(2, 3)},
 		},
+		{
+			// R-007: the session wrote old.go, a commit renamed it to the
+			// file, and a later commit of the session changed the file. The
+			// tip of both paths is the file at HEAD, and each line counts for
+			// the path that its commit changed.
+			name: "a line counts for the path that its commit changed",
+			ledgers: map[string]*state.AILineAttribution{testSession: {
+				SessionID: testSession,
+				Written: map[string]state.LineCounts{
+					oldFile:  counts(five...),
+					testFile: counts("f"),
+				},
+			}},
+			commits: []CommitLines{
+				{SHA: c1, SessionIDs: []string{testSession}, Files: []tracegit.FileLines{{Path: oldFile, Added: five}}},
+				ownCommit(c2, []string{"f"}, nil),
+			},
+			tip: map[string][]tracegit.BlameLine{
+				oldFile:  tipOf(c1+":a", c1+":b", c1+":c", c1+":d", c1+":e", c2+":f"),
+				testFile: tipOf(c1+":a", c1+":b", c1+":c", c1+":d", c1+":e", c2+":f"),
+			},
+			want:   split{aiAdded: 1},
+			ranges: []aicodingsession.LineRange{ai(6, 6)},
+		},
+		{
+			// R-007: a commit in no session renamed the file and replaced a
+			// line of the session in it.
+			name:    "a joined commit counts in a renamed file",
+			ledgers: map[string]*state.AILineAttribution{testSession: ledger(testSession, testFile, five, nil)},
+			commits: []CommitLines{
+				ownCommit(c1, five, nil),
+				{SHA: c2, Files: []tracegit.FileLines{{Path: "new.go", OldPath: testFile, Added: []string{"C"}, Removed: []string{"c"}}},
+					Joined: map[string][]string{"new.go": fps("C")}},
+			},
+			tip:    map[string][]tracegit.BlameLine{testFile: tipOf(c1+":a", c1+":b", c2+":C", c1+":d", c1+":e")},
+			want:   split{aiAdded: 4, humanAdded: 1},
+			ranges: []aicodingsession.LineRange{ai(1, 2), human(3, 3), ai(4, 5)},
+		},
 	}
 
 	for _, tc := range testCases {
 
@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"io/fs"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 
@@ -166,7 +167,11 @@ func checkModel(s *Session) error {
 	if m == nil || m.Primary == "" {
 		return errors.New("the evidence has no primary model")
 	}
-	if !strings.Contains(strings.ToLower(m.Primary), strings.ToLower(s.Model)) {
+	// A model can have a provider prefix, for example
+	// amazon-bedrock/eu.anthropic.claude-haiku-5-5, that the evidence leaves
+	// out, and a short name, for example haiku, that the evidence spells out.
+	primary, want := strings.ToLower(m.Primary), strings.ToLower(path.Base(s.Model))
+	if !strings.Contains(primary, want) && !strings.Contains(want, primary) {
 		return fmt.Errorf("primary model %q is not the model of the session %q", m.Primary, s.Model)
 	}
 	return nil
@@ -357,15 +362,23 @@ func checkSecretRedacted(s *Session) error {
 // secret, as internal/redaction writes it.
 const redactedPlaceholder = "[CHAINLOOP_TRACE_REDACTED"
 
+// checkAllowedSecretKept checks that the secret on the line with an allow
+// marker is in the stored session. The line comes from the output of the
+// tool that read the fixture. A transcript with no tool outputs holds no
+// copy of the line, so it cannot show the feature.
 func checkAllowedSecretKept(s *Session) error {
 	found, err := storedContains(s, fakeAllowedSecret)
+	if err != nil || found {
+		return err
+	}
+	marked, err := storedContains(s, allowMarker)
 	if err != nil {
 		return err
 	}
-	if !found {
-		return errors.New("the secret on the line with an allow marker was redacted, or the session did not read it")
+	if !marked {
+		return fmt.Errorf("%w: the stored session holds no copy of the fixture line, for example because the transcript has no tool outputs", errNotCovered)
 	}
-	return nil
+	return errors.New("the secret on the line with an allow marker was redacted")
 }
 
 func checkCommitTrailer(s *Session) error {