Merge the trunk (B0) into the registry group: one invokes list in mesh-build-go's manifest, the manifest asked of its owner and the checker's input asked of the seat (issue 1921, issue 1966)

Claude-Session: https://claude.ai/code/session_01NcbgfFSnn24M3GcqttoU7i

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

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"context"
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -189,6 +191,33 @@ func TestAChangesVerdictLeavesTheServedVersionServedAndGraduatingNeedsABecameLin
 		e.Current.Status != StatusActive || e.Current.Section("01-findings.md") != "" {
 		t.Fatalf("after changes: pending %v, current %+v", e.Pending != nil, e.Current.Sections)
 	}
+	// 1970/AC1: get with no version shows the pending version's findings, and says where the version stands.
+	g, err := w.k.Get(GetAsk{Kind: KindResearch, Number: r.Number})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(g.PendingReviews) != 1 || g.PendingReviews[0].Verdict != VerdictChanges || g.PendingReviews[0].Version == 0 ||
+		!strings.Contains(g.PendingReviews[0].Findings, "say where the finding comes from") || len(g.Reviews) != 1 ||
+		!strings.Contains(g.Pending, "changes asked") || !strings.Contains(g.Pending, "pending-reviews") {
+		t.Fatalf("pending findings not shown: %+v, pending %q, reviews %+v", g.PendingReviews, g.Pending, g.Reviews)
+	}
+	// 1970/AC3: under a small bound the last pending review is kept, and the cut is said.
+	e2 := mustGet(t, w.k.Store, key)
+	more := e2.Pending.Clone()
+	for i := 0; i < 3; i++ {
+		more.Reviews = append(more.Reviews, Review{By: "r", Verdict: VerdictChanges, Version: 9, Findings: strings.Repeat("a long finding ", 60) + fmt.Sprint(i)})
+	}
+	if err := w.k.Store.Save(context.Background(), Version{By: "author@g14", Why: "test", Record: more}, false, false, e2.Revision); err != nil {
+		t.Fatal(err)
+	}
+	g, err = w.k.Get(GetAsk{Kind: KindResearch, Number: r.Number, Bound: LeastBound})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(g.PendingReviews) != 1 || !strings.HasSuffix(g.PendingReviews[0].Findings, "2") ||
+		!strings.Contains(g.Cut, "earlier pending review") {
+		t.Fatalf("pending cut: %d kept, cut %q", len(g.PendingReviews), g.Cut)
+	}
 	grad := effortAsk(r.Number, StatusGraduated, overview)
 	if _, err := w.k.Propose("author@g14", grad); err == nil || !strings.Contains(err.Error(), "became") {
 		t.Fatalf("graduated without a became link: %v", err)

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

@@ -312,14 +312,17 @@ type Got struct {
 	Idea    string `json:"idea,omitempty"`
 	Waiting string `json:"waiting,omitempty"`
 	// Retracted are the retractions the operator approved; Retracting, one waiting for the operator.
-	Retracted   []RetractionRow `json:"retracted,omitempty"`
-	Retracting  string          `json:"retracting,omitempty"`
-	Reviews     []Review        `json:"reviews,omitempty"`
-	Drafting    *Drafting       `json:"drafting,omitempty"`
-	Review      string          `json:"review,omitempty"`
-	Source      string          `json:"source,omitempty"`
-	Reserved    string          `json:"reserved,omitempty"`
-	NeedsOperat bool            `json:"needs-operator,omitempty"`
+	Retracted  []RetractionRow `json:"retracted,omitempty"`
+	Retracting string          `json:"retracting,omitempty"`
+	Reviews    []Review        `json:"reviews,omitempty"`
+	// PendingReviews are the reviews of the pending version, with their findings, when get is asked without a
+	// version (issue 1970): the version waits for its author, and these are what it must answer.
+	PendingReviews []Review  `json:"pending-reviews,omitempty"`
+	Drafting       *Drafting `json:"drafting,omitempty"`
+	Review         string    `json:"review,omitempty"`
+	Source         string    `json:"source,omitempty"`
+	Reserved       string    `json:"reserved,omitempty"`
+	NeedsOperat    bool      `json:"needs-operator,omitempty"`
 	// Brief is what the operator's ask shows of it (issue 639).
 	Brief *Brief `json:"brief,omitempty"`
 	Cut   string `json:"cut,omitempty"`
@@ -371,7 +374,17 @@ func (k *KB) Get(a GetAsk) (*Got, error) {
 		g.Idea = "an idea: research it again before anything rests on it"
 	}
 	if e.Pending != nil && a.Version == 0 {
+		g.PendingReviews = e.Pending.Reviews
 		g.Pending = fmt.Sprintf("version %d, a progressive insight or a new version of an active effort, waits for its review: history shows what it changes", e.PendingVersion)
+		if n := len(e.Pending.Reviews); n > 0 && e.Pending.Reviews[n-1].Verdict == VerdictChanges {
+			last := e.Pending.Reviews[n-1]
+			k := len(strings.Split(strings.TrimSpace(last.Findings), "\n"))
+			if strings.TrimSpace(last.Findings) == "" {
+				k = 0
+			}
+			g.Pending = fmt.Sprintf("version %d: changes asked (%d finding(s)) on version %d, shown in pending-reviews; it waits for its author's revision",
+				e.PendingVersion, k, last.Version)
+		}
 	}
 	if r.Ask != nil {
 		g.Waiting = "the operator's ask: " + r.Ask.Said
@@ -452,6 +465,10 @@ func (k *KB) Get(a GetAsk) (*Got, error) {
 		cut = append(cut, fmt.Sprintf("%d earlier review(s) are not shown: history lists every version", len(g.Reviews)-1))
 		g.Reviews = g.Reviews[len(g.Reviews)-1:]
 	}
+	if size(g) > room && len(g.PendingReviews) > 1 {
+		cut = append(cut, fmt.Sprintf("%d earlier pending review(s) are not shown: get with the pending version's number shows them", len(g.PendingReviews)-1))
+		g.PendingReviews = g.PendingReviews[len(g.PendingReviews)-1:]
+	}
 	for _, which := range []string{"linked-from", "links"} {
 		if size(g) <= room {
 			break

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

@@ -107,9 +107,12 @@ func newBusWorld(t *testing.T) *busWorld {
 		return map[string]any{"folders": f, "documents": d}, err
 	})
 	answer("records.records_read", func(body json.RawMessage) (any, error) {
-		var a struct{ Path string }
+		var a struct {
+			Path string
+			Head int
+		}
 		_ = json.Unmarshal(body, &a)
-		c, commit, err := records.Read(a.Path)
+		c, commit, err := records.ReadHead(a.Path, a.Head)
 		return map[string]any{"content": c, "commit": commit}, err
 	})
 	j := &judge{}

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

@@ -24,8 +24,26 @@ type Design struct {
 	Status     string
 	Decisions  []string
 	Milestones []Milestone
+	// Unread says why the design's frontmatter and title could not be read, when they could not (novox/hq issue
+	// 1947); the progress answer carries it as a warning beside a tree built from the tracker's milestone records.
+	Unread string
 }
 
+// unreadWarnings says each design whose head was not read, so none drops out of an answer silently.
+func unreadWarnings(ds []*Design) []string {
+	var out []string
+	for _, d := range ds {
+		if d.Unread != "" {
+			out = append(out, d.Unread)
+		}
+	}
+	return out
+}
+
+// DesignHeadBytes is how much of a design is read: its frontmatter and its title lead it, and its milestones are the
+// tracker's records, so the rest is never needed.
+const DesignHeadBytes = 16 << 10
+
 // Milestone is one milestone of a design, as the issue tracker keeps it.
 type Milestone struct {
 	ID      string
@@ -51,12 +69,13 @@ func parseDesign(path, content string) *Design {
 		d.Number, _ = strconv.Atoi(m[1])
 	}
 	lines := strings.Split(content, "\n")
-	body := 0
+	body, closed := 0, false
 	if len(lines) > 0 && strings.TrimSpace(lines[0]) == "---" {
 		for i := 1; i < len(lines); i++ {
 			l := lines[i]
 			if strings.TrimSpace(l) == "---" {
 				body = i + 1
+				closed = true
 				break
 			}
 			if v, ok := strings.CutPrefix(l, "status:"); ok {
@@ -67,6 +86,9 @@ func parseDesign(path, content string) *Design {
 			}
 		}
 	}
+	if len(lines) > 0 && strings.TrimSpace(lines[0]) == "---" && !closed {
+		d.Unread = fmt.Sprintf("the frontmatter of %s does not close in the part read: its state and decisions are not known here", path)
+	}
 	for i := body; i < len(lines) && d.Title == ""; i++ {
 		if m := titleLine.FindStringSubmatch(strings.TrimSpace(lines[i])); m != nil {
 			d.Title = strings.TrimSpace(m[1])
@@ -151,12 +173,22 @@ func (k *KB) designs(all bool, number int) ([]*Design, string, error) {
 		}
 		d := c.byPath[p]
 		if d == nil {
-			content, _, err := k.Records.Read(p)
+			var content string
+			var err error
+			if h, ok := k.Records.(HeadReader); ok {
+				content, _, err = h.ReadHead(p, DesignHeadBytes)
+			} else {
+				content, _, err = k.Records.Read(p)
+			}
 			if err != nil {
-				return nil, "", fmt.Errorf("the records module does not read %s: %v", p, err)
+				d = parseDesign(p, "")
+				d.Unread = fmt.Sprintf("the records module does not read %s (%v): its title and state are not known here", p, err)
+			} else {
+				d = parseDesign(p, content)
+			}
+			if d.Unread == "" {
+				c.byPath[p] = d
 			}
-			d = parseDesign(p, content)
-			c.byPath[p] = d
 			k.progReads++
 		}
 		out = append(out, d)

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

@@ -22,6 +22,12 @@ type Records interface {
 	Read(path string) (content, commit string, err error)
 }
 
+// HeadReader is Records that can read only the first part of a document: a caller that needs a frontmatter or a
+// title reads a long document through it, bounded, never whole (novox/hq issue 1947).
+type HeadReader interface {
+	ReadHead(path string, bytes int) (content, commit string, err error)
+}
+
 // busRecords is Records over the bus: the records module's tools, called as this module.
 type busRecords struct{}
 
@@ -58,8 +64,18 @@ func (busRecords) List(folder string) ([]string, []string, error) {
 	return f.Folders, f.Documents, nil
 }
 
-func (busRecords) Read(path string) (string, string, error) {
-	raw, err := stdio.Ask("records.records_read", map[string]any{"path": path})
+func (busRecords) Read(path string) (string, string, error) { return busRead(path, 0) }
+
+func (busRecords) ReadHead(path string, bytes int) (string, string, error) {
+	return busRead(path, bytes)
+}
+
+func busRead(path string, head int) (string, string, error) {
+	args := map[string]any{"path": path}
+	if head > 0 {
+		args["head"] = head
+	}
+	raw, err := stdio.Ask("records.records_read", args)
 	if err != nil {
 		return "", "", err
 	}
@@ -118,11 +134,19 @@ func (d dirRecords) List(folder string) ([]string, []string, error) {
 	return folders, docs, nil
 }
 
-func (d dirRecords) Read(path string) (string, string, error) {
+func (d dirRecords) Read(path string) (string, string, error) { return d.ReadHead(path, 0) }
+
+func (d dirRecords) ReadHead(path string, head int) (string, string, error) {
 	raw, err := os.ReadFile(filepath.Join(d.dir, filepath.FromSlash(path)))
 	if err != nil {
 		return "", "", err
 	}
+	if head > 0 && head < len(raw) {
+		raw = raw[:head]
+		if i := strings.LastIndexByte(string(raw), '\n'); i > 0 {
+			raw = raw[:i+1]
+		}
+	}
 	commit, _ := d.Standing()
 	return string(raw), commit, nil
 }

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

@@ -841,7 +841,7 @@ func verbTools(k *KB, caller func(map[string]any) string) []stdio.Tool {
 			}},
 		{Name: Seat + ".get",
 			Description: "One record by its number: its title, status, topic, date and deciders; its clauses, each with whether it holds; " +
-				"its links both ways; what changed it since; its versions; its reviews, and the operator's ask when it waits for one. " +
+				"its links both ways; what changed it since; its versions; its reviews, and the findings of the pending version's reviews (pending-reviews) when one waits for its author; the operator's ask when it waits for one. " +
 				"Its reasoning (context, options, consequences, how it is checked; a research effort's documents) only with reasoning, " +
 				"or one section by name; an earlier version with version. Within a bound it states, 4 KiB unless asked for more, " +
 				"saying what it cut.",

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

@@ -329,6 +329,12 @@ func (k *KB) progressDesign(p *Progress, number int, milestone string) error {
 		return err
 	}
 	d := ds[0]
+	if d.Unread != "" {
+		p.Warnings = append(p.Warnings, d.Unread)
+		if d.Title == "" {
+			d.Title = fmt.Sprintf("design %d", d.Number)
+		}
+	}
 	if len(d.Milestones) == 0 {
 		return fmt.Errorf("design %d has no milestone records in the issue tracker: seed them from its table with "+
 			"issue-tracker.import milestones %d", number, number)
@@ -387,6 +393,7 @@ func (k *KB) progressMesh(p *Progress) error {
 		return err
 	}
 	p.Source = fmt.Sprintf("the issue tracker's milestone records, and the designs in %s at hq %s", DesignsFolder, short(commit))
+	p.Warnings = append(p.Warnings, unreadWarnings(ds)...)
 	var with []*Design
 	var without []string
 	for _, d := range ds {
@@ -514,6 +521,7 @@ func (k *KB) progressRecord(p *Progress, kind string, n int) error {
 		return err
 	}
 	p.Source = fmt.Sprintf("the knowledge base, the designs at hq %s and the issue tracker's links", short(commit))
+	p.Warnings = append(p.Warnings, unreadWarnings(ds)...)
 	var designs []string
 	for _, d := range ds {
 		for _, dn := range d.Decisions {

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

@@ -42,6 +42,15 @@ func (w withDesigns) Read(path string) (string, string, error) {
 	return c, commit, err
 }
 
+func (w withDesigns) ReadHead(path string, n int) (string, string, error) {
+	if c, commit, err := w.base.ReadHead(path, n); err == nil {
+		return c, commit, nil
+	}
+	c, _, err := w.designs.ReadHead(path, n)
+	commit, _ := w.base.Standing()
+	return c, commit, err
+}
+
 // seatsWorld plays the issue tracker and mesh-delivery from the captured answers, and counts what it is asked.
 type seatsWorld struct {
 	mu     sync.Mutex
@@ -142,6 +151,19 @@ func (c *countingRecords) Read(p string) (string, string, error) {
 	return content, c.commit, err
 }
 
+func (c *countingRecords) ReadHead(p string, n int) (string, string, error) {
+	c.reads++
+	content, _, err := c.dirRecords.ReadHead(p, n)
+	return content, c.commit, err
+}
+
+// brokenRead is Records whose reads fail as the records module's do for a document longer than it answers whole.
+type brokenRead struct{ dirRecords }
+
+func (brokenRead) ReadHead(p string, n int) (string, string, error) {
+	return "", "", fmt.Errorf("%s is longer than the records module answers whole", p)
+}
+
 // 1947/AC2, as issue 1781 changed it: a design's title, state and decisions are hq's; its milestones are the issue
 // tracker's records, ordered as its table, an id found with spaces or hyphens, and a closed one holding no issue done.
 func TestADesignsMilestonesAreTheTrackersRecords(t *testing.T) {
@@ -316,6 +338,18 @@ func TestProgressOfADesignMinimalAndDetailed(t *testing.T) {
 	if big, _ := k.Progress(ProgressAsk{Of: "design 47", Bound: 8192}); big.Cut != "" || big.Tree != p.Tree {
 		t.Errorf("a minimal answer at bound 8192 is cut: %q", big.Cut)
 	}
+	// A design whose head the records module cannot read is said in a warning beside the tracker-built tree, never a failure.
+	kb := &KB{Records: brokenRead{progressRecords()}, Seats: newSeatsWorld(t).ask, Now: k.Now}
+	if bp, err := kb.Progress(ProgressAsk{Of: "design 47"}); err != nil || !strings.Contains(strings.Join(bp.Warnings, "\n"), "does not read") ||
+		!strings.Contains(bp.Tree, "design 47") || !strings.Contains(bp.Tree, "R6") {
+		t.Fatalf("an unreadable design: %v %+v", err, bp)
+	}
+	if mp, err := kb.Progress(ProgressAsk{Of: "mesh"}); err != nil || !strings.Contains(strings.Join(mp.Warnings, "\n"), "does not read") {
+		t.Fatalf("the mesh level drops an unread design silently: %v %v", err, mp.Warnings)
+	}
+	if d := parseDesign(DesignsFolder+"/47-x.md", "---\nstatus: in-progress\n"); d.Unread == "" {
+		t.Errorf("a frontmatter cut before its close is not said")
+	}
 	lines := strings.Split(p.Tree, "\n")
 	if !strings.HasPrefix(lines[0], "✗ design 47 · Delivery: from a commit to delivered — ") {
 		t.Fatalf("first line %q", lines[0])

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

@@ -361,6 +361,15 @@ func TestAnAcceptedRecordChangesOnlyByAnInsightReviewedLikeAProposal(t *testing.
 		e.Pending.Reviews[0].Verdict != VerdictChanges {
 		t.Fatalf("the insight was served before its review approved it: %+v", e.Current.Sections)
 	}
+	// 1970/AC2: the same for a pending insight.
+	g, err := w.k.Get(GetAsk{Kind: KindDecision, Number: n})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(g.PendingReviews) != 1 || !strings.Contains(g.PendingReviews[0].Findings, "what a minute is measured from") ||
+		!strings.Contains(g.Pending, "changes asked") {
+		t.Fatalf("pending insight findings not shown: %+v, %q", g.PendingReviews, g.Pending)
+	}
 	w.judge.review = ""
 	p.Sections[2].Text = "Merges land sooner, by about a minute from the last merge."
 	if _, err := w.k.Propose("author@g14", p); err != nil {