issue-tracker.changes reads each issue's moves over a window from the tracker's own log, so progress since says from what each issue moved, not only where it is

modules/mesh-knowledge/cmd/mesh-knowledge/progress_since.go

@@ -5,16 +5,17 @@ package main
 // call: the knowledge base keeps no state of its own, so it reads what the other seats keep, each a request and reply
 // over the bus:
 //
+//   - the issue tracker's moves over the window, from its own log (`issue-tracker.changes`): each issue opened or
+//     moved, from what to what, by whom and when;
 //   - the issue tracker's milestones with their last move, and a moved one's history (`issue-tracker.milestones`
 //     with one): what it was before, what it is now, who moved it and when;
 //   - each issue that moved in the window whole (`issue-tracker.get`): when it was opened, its notes and links with who
 //     and when, its worker since when, and when it was closed;
 //   - mesh-delivery's deliveries and each one's transitions and its check (`mesh-delivery.deliveries`, `.show`).
 //
-// Two things the window needs are kept by neither seat, and each answer that meets one says so: the tracker keeps an
-// issue's moves only in its log, which no verb reads, so a move is said by the status it reached (with its worker's
-// since or its closed time), not from what it moved; and mesh-delivery keeps no time a merge reached its machines, so
-// "on the machines" is as it reads now.
+// When the tracker cannot say its moves (a tracker without `changes`), a move is said by the status it reached, with its
+// worker's since or its closed time, not from what it moved, and the answer says so. mesh-delivery keeps no time a
+// merge reached its machines, so "on the machines" is as it reads now, said too.
 
 import (
 	"encoding/json"
@@ -217,10 +218,13 @@ func (k *KB) issueChanges(p *Progress, w window) []change {
 		}
 	}
 	sort.Slice(moved, func(i, j int) bool { return moved[i].Moved.After(*moved[j].Moved) })
+	var moves map[int][]trackerMove
+	var merr error
 	if len(moved) > 0 {
-		p.Warnings = append(p.Warnings, "the issue tracker keeps no history of an issue's moves that a verb reads (only its "+
-			"log changes holds them): a move is said by the status it reached, its worker's since and its closed time, not "+
-			"from what it moved")
+		if moves, merr = k.trackerMoves(w); merr != nil {
+			p.Warnings = append(p.Warnings, fmt.Sprintf("issue-tracker.changes: %v; a move is said by the status it reached, "+
+				"its worker's since and its closed time, not from what it moved", merr))
+		}
 	}
 	var out []change
 	for i, r := range moved {
@@ -253,16 +257,35 @@ func (k *KB) issueChanges(p *Progress, w window) []change {
 		}
 		var evs []event
 		var says []string
-		if w.holds(g.Opened) {
+		if merr == nil {
+			for _, m := range moves[r.Number] {
+				if m.Kind == "opened" || m.Kind == "imported" {
+					evs = append(evs, event{at: m.At, line: fmt.Sprintf("%s %s by %s", m.Kind, when(&m.At), m.By)})
+					says = append(says, m.Kind+" by "+m.By+" "+when(&m.At))
+					continue
+				}
+				who, line := m.By, fmt.Sprintf("%s → %s %s by %s", m.From, m.To, when(&m.At), m.By)
+				if m.Worker != "" {
+					who, line = m.Worker, line+", worker "+m.Worker
+				}
+				short := fmt.Sprintf("%s → %s by %s %s", m.From, m.To, who, when(&m.At))
+				if (m.To == "resolved" || m.To == "wontfix") && len(g.FixedBy) > 0 {
+					short += ", fixed by " + strings.Join(g.FixedBy, ", ")
+				}
+				evs = append(evs, event{at: m.At, line: line})
+				says = append(says, short)
+			}
+		}
+		if merr != nil && w.holds(g.Opened) {
 			evs = append(evs, event{at: g.Opened, line: fmt.Sprintf("opened %s by %s", when(&g.Opened), g.OpenedBy)})
 			says = append(says, "opened by "+g.OpenedBy+" "+when(&g.Opened))
 		}
-		if g.Worker != nil && w.holds(g.Worker.Since) && (g.Status == "diagnosing" || g.Status == "fixing") {
+		if merr != nil && g.Worker != nil && w.holds(g.Worker.Since) && (g.Status == "diagnosing" || g.Status == "fixing") {
 			s := fmt.Sprintf("→ %s by %s %s", g.Status, g.Worker.By, when(&g.Worker.Since))
 			evs = append(evs, event{at: g.Worker.Since, line: s})
 			says = append(says, s)
 		}
-		if g.Closed != nil && w.holds(*g.Closed) {
+		if merr != nil && g.Closed != nil && w.holds(*g.Closed) {
 			s := fmt.Sprintf("→ %s %s", g.Status, when(g.Closed))
 			if len(g.FixedBy) > 0 {
 				s += ", fixed by " + strings.Join(g.FixedBy, ", ")
@@ -438,3 +461,38 @@ func (k *KB) pullChanges(p *Progress, w window) []change {
 	}
 	return out
 }
+
+// trackerMove is one change of `issue-tracker.changes`: an issue opened or moved, from what to what, by whom and when.
+type trackerMove struct {
+	Number int       `json:"number"`
+	Kind   string    `json:"kind"`
+	From   string    `json:"from"`
+	To     string    `json:"to"`
+	By     string    `json:"by"`
+	Worker string    `json:"worker"`
+	At     time.Time `json:"at"`
+}
+
+// trackerMoves asks the tracker for every issue's moves in the window, from its own log, by issue, oldest first.
+func (k *KB) trackerMoves(w window) (map[int][]trackerMove, error) {
+	raw, err := k.Seats(ChangesVerb, map[string]any{"since": w.to.Sub(w.from).String()})
+	if err != nil {
+		return nil, err
+	}
+	var r struct {
+		Changes []trackerMove `json:"changes"`
+	}
+	if err := json.Unmarshal(raw, &r); err != nil {
+		return nil, fmt.Errorf("answered something else: %v", err)
+	}
+	out := map[int][]trackerMove{}
+	for _, m := range r.Changes {
+		if w.holds(m.At) {
+			out[m.Number] = append(out[m.Number], m)
+		}
+	}
+	return out, nil
+}
+
+// ChangesVerb is the tracker's verb that answers its issues' moves over a window.
+const ChangesVerb = "seat:issue-tracker.changes"