Undo reported "nothing left to undo" after a successful undo

Found by running the real thing: the agent replaced a bed of garlic with
cucumbers, Undo restored the garlic correctly — and then said "Nothing left to
undo — this was already reversed."

The revert response carries the change set commitScope just inserted, and that
row has no per-op tally: Counts is populated by the history LIST query, not by
the insert. describeUndo treated a zero tally as "nothing happened", so a real
undo with eight revisions behind it reported itself as a no-op. Telling someone
an action did nothing when it just worked is about the worst thing a safety
feature can say, because the obvious next move is to do it again.

Fixed on both sides. The client now treats a NULL change set as the no-op
signal, which is what the server actually means by it — an empty tally is not
the same thing and must not be read as one. And RevertChangeSet now fills in the
counts, so the revert response and the list read describe the same change set
the same way, and a partial revert can say "2 of 3" from either.

The unit test missed it because the fixture I wrote populated counts, so it was
testing my assumption about the response rather than its actual shape. The new
tests pin the real thing: the service asserts a revert's counts match the fill
it undid AND match what the list read reports, and the client asserts an empty
tally still reads as "Undone."

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01H3zbym8Doka2d7D48maSgZ

internal/service/revisions.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
+	"sort"
 	"sync"
 
 	"gitea.stevedudenhoeffer.com/steve/pansy/internal/domain"
@@ -334,9 +335,44 @@ func (s *Service) RevertChangeSet(ctx context.Context, actorID, changeSetID int6
 	if err != nil {
 		return nil, nil, err
 	}
+	// Fill in the per-op counts. commitScope returns the freshly inserted row,
+	// which carries no tally — and a caller receiving a change set with an empty
+	// Counts cannot tell "nothing was reverted" from "the tally wasn't loaded".
+	// That ambiguity is not theoretical: it made the chat panel report a
+	// successful undo as "nothing left to undo".
+	if cs != nil {
+		cs.Counts = countRevisions(sc.taken())
+	}
 	return cs, conflicts, nil
 }
 
+// countRevisions tallies revisions by (entity type, op), matching what the
+// history list read produces so both sides of the API describe a change set the
+// same way.
+func countRevisions(revs []domain.Revision) []domain.ChangeCount {
+	type key struct{ entityType, op string }
+	seen := map[key]int{}
+	order := []key{}
+	for _, r := range revs {
+		k := key{r.EntityType, r.Op}
+		if _, ok := seen[k]; !ok {
+			order = append(order, k)
+		}
+		seen[k]++
+	}
+	sort.Slice(order, func(i, j int) bool {
+		if order[i].entityType != order[j].entityType {
+			return order[i].entityType < order[j].entityType
+		}
+		return order[i].op < order[j].op
+	})
+	counts := make([]domain.ChangeCount, 0, len(order))
+	for _, k := range order {
+		counts = append(counts, domain.ChangeCount{EntityType: k.entityType, Op: k.op, N: seen[k]})
+	}
+	return counts
+}
+
 // entityKey identifies a row across the entity types a revision can name.
 type entityKey struct {
 	entityType string