The checker pins the SDK of review round 1, and its hid-the-failure cases join the older build module's test (issue 1901)

A failed test with no cause, or a passing line as its cause, was worded as if it were the failure: a try of mesh-catalog
failed with a passing '✔' line of the first test file. Under mesh-sdk's failure contract the verdict's words and its
status line now start with 'the build module hid the failure (<module> at <version>)', and the check still fails.

modules/mesh-delivery-checker/cmd/mesh-delivery-checker-tools/main.go

@@ -105,7 +105,7 @@ func TryTools(tr Trying) []stdio.Tool {
 		{Name: check.TryTool,
 			Description: "Try a pushed head before its pull request is opened: the checker judges it as it judges a pull request's head, merged onto its trunk's head, " +
 				"its unit and integration levels through the build modules, and owes the forge nothing. Answers the try's id at once; " + check.TryReadTool + " reads " +
-				"where it stands. A try of the same head that waits or runs is the answer to a second ask; a new try is refused while 4 tries run on a build node or 8 wait for one, mesh-wide; tries let in while waiting may later all run at once, and each node's build capacity bounds what runs on it. A repository " +
+				"where it stands. A try of the same head that waits or runs is the answer to a second ask; at most 4 wait or run at once, mesh-wide. A repository " +
 				"the checker checks no level of (one whose trunk the gate does not name) is refused. A try whose ask no build node took within the step " +
 				"bound ends as error; its ask stays in the build seat's stream and may still run later, judged by nobody (issue 734).",
 			Input: map[string]any{"type": "object", "required": []string{"repository", "head"}, "properties": map[string]any{
@@ -135,8 +135,7 @@ func TryTools(tr Trying) []stdio.Tool {
 			}},
 		{Name: check.TryReadTool,
 			Description: "Where a try stands, as stored: queued, running, or its end (pass, fail, or error when it could not run), with what was said of it, " +
-				"the head and the trunk commit it was merged onto, the time it took and what failed first; while it runs, each ask it put as soon as it is put, " +
-				"with the node that took it, its state and the phase its step says (fetch and merge, a level's digest, lint, tests) and since when. Read-only.",
+				"the head and the trunk commit it was merged onto, the time it took and what failed first. Read-only.",
 			Input: map[string]any{"type": "object", "required": []string{"id"}, "properties": map[string]any{
 				"id": map[string]any{"type": "string", "description": "the try's id, try-<digits>"}}},
 			Run: func(args map[string]any) (any, error) {

modules/mesh-delivery-checker/go.mod

@@ -3,7 +3,7 @@ module mesh-delivery-checker
 go 1.26.0
 
 require (
-	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026202658-805b4d9a3536
+	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026191742-47a66e3c0dc8
 	github.com/nats-io/nats-server/v2 v2.11.17
 	github.com/nats-io/nats.go v1.54.0
 )

modules/mesh-delivery-checker/go.sum

@@ -1,5 +1,5 @@
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026202658-805b4d9a3536 h1:+SoDdDXF7Tgj38WP4kRpUSps6DJVl6P+w5u/KfdtwnQ=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026202658-805b4d9a3536/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026191742-47a66e3c0dc8 h1:6OaUWIjcpXOtnu70zeqH0VEaF4oGykrxGpFkaFOzCmY=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026191742-47a66e3c0dc8/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
 github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op h1:Z/MZK75wC/NSrkgqeNIa7jexam9uWzhLmFTSCPI/kn0=
 github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI=
 github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=

modules/mesh-delivery-checker/internal/check/binaries.go

@@ -1,42 +0,0 @@
-package check
-
-import (
-	"fmt"
-	"strings"
-)
-
-// A change that adds or modifies a compiled program fails (issue 1577): it is build output, `go build` in a module's folder
-// writes one beside go.mod, and `git add -A` takes it. The build module's fetch step, which holds the merged clone, reads the
-// first bytes of each changed file and reports the programs (mesh-sdk buildstep.MergeInto); the checker judges the answer.
-
-// NoProgramsReported is the warning of a build module whose fetch answered no programs field: an older module, which cannot
-// tell, so the check does not refuse a program it did not look for.
-const NoProgramsReported = "the build module did not report programs: a compiled program in the change is not refused"
-
-// checkBinariesOf fails a pull request whose change adds or modifies a compiled program, naming each file. It judges the
-// first fetch answer of the pull request, whichever build module gave it; a build module that reports no programs leaves a
-// warning on the check and passes it.
-func (st *state) checkBinariesOf(t *target) verdictPtr {
-	key := fmt.Sprintf("%s#%d", t.pull.Repository, t.pull.Number)
-	if t.fetched.Merge == "" {
-		return nil // no merge was made: nothing was changed to judge
-	}
-	if t.fetched.Programs == nil {
-		st.c.note(fmt.Sprintf("%s: %s (%s)", key, NoProgramsReported, t.module))
-		st.c.warn(key, fmt.Sprintf("a compiled program is not refused: %s reported no programs", t.module))
-		st.j.logf("%s: %s (%s)", key, NoProgramsReported, t.module)
-		return nil
-	}
-	var found []string
-	for _, p := range *t.fetched.Programs {
-		if p.Commit != "" {
-			found = append(found, fmt.Sprintf("%s: a compiled program added in %s and removed later: it stays in history; squash the branch (issue 1577)", p.Path, short12(p.Commit)))
-			continue
-		}
-		found = append(found, p.Path+": a compiled program is build output: remove it and add it to .gitignore (issue 1577)")
-	}
-	if len(found) > 0 {
-		return failed(t.node, fmt.Sprintf("%s: %s", key, strings.Join(found, "; ")))
-	}
-	return nil
-}

modules/mesh-delivery-checker/internal/check/binaries_test.go

@@ -1,63 +0,0 @@
-package check
-
-import (
-	"slices"
-	"strings"
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-func TestAChangeWhoseFetchReportsProgramsFailsNamingEachFile(t *testing.T) { // 1577
-	prog := func(p ...string) *[]ProgramFile {
-		out := []ProgramFile{}
-		for _, f := range p {
-			path, commit, _ := strings.Cut(f, "@") // `path@commit`: added by a commit of the branch and removed later
-			out = append(out, ProgramFile{Path: path, Kind: "ELF", Commit: commit})
-		}
-		return &out
-	}
-	for _, c := range []struct {
-		name     string
-		programs *[]ProgramFile
-		fail     []string // paths named; none passes
-		warned   bool     // the build module reported no programs field
-	}{
-		{"none found", prog(), nil, false},
-		{"one program", prog("modules/m/m"), []string{"modules/m/m"}, false},
-		{"two programs", prog("a/x", "b/y"), []string{"a/x", "b/y"}, false},
-		{"added and removed in the branch", prog("gone/prog@0123456789abcdef0123"), []string{"gone/prog: a compiled program added in 0123456789ab and removed later: it stays in history; squash the branch (issue 1577)"}, false},
-		{"an older build module reports nothing", nil, nil, true},
-	} {
-		b := newBench(t)
-		b.fetch.Merge, b.fetch.Programs = "mmmm", c.programs
-		cs := caseOf(t, pullOf(repoA, 7, head1))
-		v := b.judge(t, cs).Verdict
-		if got := slices.ContainsFunc(cs.Notes(), func(n string) bool { return strings.Contains(n, NoProgramsReported) }); got != c.warned {
-			t.Errorf("%s: warned = %v, want %v (%v)", c.name, got, c.warned, cs.Notes())
-		}
-		line := Line(v, cs, cs.Pulls[0], nil, nil, nil)
-		if got := strings.Contains(line, "a compiled program is not refused: mesh-build-go reported no programs"); got != c.warned {
-			t.Errorf("%s: the status line holds the warning = %v, want %v: %s", c.name, got, c.warned, line)
-		}
-		if len(c.fail) == 0 {
-			if v.State != delivery.VerdictPass {
-				t.Errorf("%s: verdict = %+v", c.name, v)
-			}
-			continue
-		}
-		if v.State != delivery.VerdictFail {
-			t.Errorf("%s: verdict = %+v, want a failure", c.name, v)
-			continue
-		}
-		for _, p := range c.fail {
-			want := p
-			if !strings.Contains(p, " added in ") {
-				want = p + ": a compiled program is build output: remove it and add it to .gitignore (issue 1577)"
-			}
-			if !strings.Contains(v.Failed.Words, want) {
-				t.Errorf("%s: words %q do not name %s", c.name, v.Failed.Words, p)
-			}
-		}
-	}
-}

modules/mesh-delivery-checker/internal/check/case.go

@@ -43,16 +43,9 @@ type Case struct {
 	Try *TryOptions
 
 	notesMu sync.Mutex
-	// warnings are, by pull request, what part of its check did not run (Case.warn).
-	warnings map[string]string
-	notes    []string
+	notes   []string
 	// asks are the ids of the asks the check put on the build seats' streams, in order: a try names them (Try.Asks).
 	asks []string
-	// Watch, when set, hears each ask the check puts, as it is put (step nil), and each value its step key takes while
-	// the check waits for it: the node that took it, the phase it says, its end. A try writes them into its record, so a
-	// running try names its asks and where each stands (issue 1890). Called from the check's goroutines; it must not block
-	// for long.
-	Watch func(askID string, step *delivery.Step)
 	// Progress says what the check is doing, so a check that ran past its bound names the step it was stuck at.
 	Progress *Progress
 	// Kind is what asked the check (KindNew, KindNodes, KindTrunk): a carry after a trunk or sibling move is asked on the
@@ -193,23 +186,6 @@ func (c *Case) note(s string) {
 	}
 }
 
-// warn says of a pull request (pullKey) that a part of its check did not run, in words for its status line (issue 1577).
-func (c *Case) warn(key, words string) {
-	c.notesMu.Lock()
-	defer c.notesMu.Unlock()
-	if c.warnings == nil {
-		c.warnings = map[string]string{}
-	}
-	c.warnings[key] = words
-}
-
-// Warning is what warn said of a pull request, or "".
-func (c *Case) Warning(key string) string {
-	c.notesMu.Lock()
-	defer c.notesMu.Unlock()
-	return c.warnings[key]
-}
-
 // Notes are the words noted on the case, in the order they were noted.
 func (c *Case) Notes() []string {
 	c.notesMu.Lock()

modules/mesh-delivery-checker/internal/check/failure_words_test.go

@@ -42,7 +42,7 @@ func TestTheStatusLineNamesTheFailureNotTheFirstLoggedLine(t *testing.T) { // 19
 	f := fatalAfterLog()
 	f.Cause = ""
 	v = levelFailure(&target{}, "unit", Tested{Failed: []Failure{f}})
-	if !strings.HasPrefix(v.Failed.Words, "agreement_catalogue_test.go:130") {
+	if !strings.HasPrefix(afterHid(v.Failed.Words), "agreement_catalogue_test.go:130") {
 		t.Errorf("words = %q", v.Failed.Words)
 	}
 }
@@ -56,18 +56,45 @@ func TestWordsLongerThanTheBoundKeepTheirLastLines(t *testing.T) { // 1901/AC1
 	_ = delivery.VerdictFail
 }
 
-// An older build module sends no "cause": its answer is still accepted and the verdict's words are its output, as before.
-func TestAnOlderBuildModulesFailureIsAcceptedWithItsWholeOutput(t *testing.T) { // 1901/AC3
+// An older build module sends no "cause": its answer is still accepted and the verdict's words are its output, as before
+// (1901/AC3). A failure that hides its cause (none, or a passing line) is said loudly first in the words and in the status
+// line, naming the build module and the version it says it is, and the level still fails; a failure that keeps the
+// contract is worded as before (1901/AC8).
+func TestAnOlderBuildModulesFailureIsAcceptedWithItsWholeOutput(t *testing.T) { // 1901/AC3, AC8
 	old := `{"package":"p","test":"TestX","output":"x_test.go:1: logged\nx_test.go:2: the old kept lines"}`
 	var f Failure
 	if err := json.Unmarshal([]byte(old), &f); err != nil || f.Cause != "" {
 		t.Fatalf("1901/AC3: err = %v, cause = %q", err, f.Cause)
 	}
 	v := levelFailure(&target{}, "unit", Tested{Failed: []Failure{f}})
-	if v.Failed.Words != "x_test.go:1: logged\nx_test.go:2: the old kept lines" {
+	if afterHid(v.Failed.Words) != "x_test.go:1: logged\nx_test.go:2: the old kept lines" {
 		t.Errorf("1901/AC3: words = %q", v.Failed.Words)
 	}
-	if got := firstFailed(*v); !strings.Contains(got, "logged") || strings.Contains(got, "\n") {
-		t.Errorf("1901/AC3: status = %q", got)
+	if got := firstFailed(*v); !strings.Contains(got, "the build module hid the failure") || strings.Contains(got, "\n") {
+		t.Errorf("1901/AC3, AC8: status = %q", got)
+	}
+
+	by := "mesh-build-node with mesh-sdk v0.1.14-0.20261026184535-e40dd0f56a78"
+	for _, c := range []struct {
+		name, module, by, cause, output, loud string
+	}{
+		{"no cause", "mesh-build-node", by, "", "test/b.test.ts: something", "the build module hid the failure (mesh-build-node at mesh-sdk v0.1.14-0.20261026184535-e40dd0f56a78): it sent no cause"},
+		{"a passing line as its cause", "mesh-build-node", by, "\u2714 the same merge has the same id (8.006913ms)", "", "the build module hid the failure (mesh-build-node at mesh-sdk v0.1.14-0.20261026184535-e40dd0f56a78): its cause is a passing line"},
+		{"from before the contract", "mesh-build-node", "", "", "\u2714 the same merge has the same id (8.006913ms)", "the build module hid the failure (mesh-build-node at a version before the failure contract): it sent no cause"},
+		{"a real cause", "mesh-build-node", by, "one plus one is not three", "not ok 3 - fails", ""},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			v := levelFailure(&target{module: c.module}, "unit", Tested{By: c.by, Failed: []Failure{{Package: "modules/gitea", Test: "fails", Cause: c.cause, Output: c.output}}})
+			if v.State != delivery.VerdictFail {
+				t.Errorf("1901/AC8: the verdict is %q, want it failed", v.State)
+			}
+			line := firstFailed(*v)
+			switch {
+			case c.loud == "" && strings.Contains(v.Failed.Words, "hid the failure"):
+				t.Errorf("1901/AC8: a failure that keeps the contract is said hidden: %q", v.Failed.Words)
+			case c.loud != "" && (!strings.HasPrefix(v.Failed.Words, c.loud) || !strings.Contains(line, c.loud) || !strings.Contains(v.Failures[0].Words, "hid the failure")):
+				t.Errorf("1901/AC8: words %q, status %q, want both to start with %q", v.Failed.Words, line, c.loud)
+			}
+		})
 	}
 }

modules/mesh-delivery-checker/internal/check/judge.go

@@ -427,14 +427,8 @@ func (st *state) askNeeding(ctx context.Context, t *target, merged *[]Fetched, l
 		if err := st.j.Asks.Put(ctx, a); err != nil {
 			return fail(t.module, fmt.Sprintf("the check of %s#%d could not be asked: %v", p.Repository, p.Number, err))
 		}
-		waiting := ctx
-		if watch := st.c.Watch; watch != nil {
-			id := a.ID
-			watch(id, nil) // put: a try names it at once, not only when it ends (issue 1890)
-			waiting = buildrun.WithStepSeen(ctx, func(s delivery.Step) { watch(id, &s) })
-		}
 		var err error
-		step, err = st.j.Asks.Wait(waiting, a)
+		step, err = st.j.Asks.Wait(ctx, a)
 		if err != nil {
 			if ctx.Err() != nil {
 				return fail(t.module, ctx.Err().Error())
@@ -495,9 +489,6 @@ func (st *state) askNeeding(ctx context.Context, t *target, merged *[]Fetched, l
 		if v := st.checkPinsOf(ctx, t); v != nil {
 			return v
 		}
-		if v := st.checkBinariesOf(t); v != nil {
-			return v
-		}
 	}
 	ran := 0.0
 	for _, la := range answer.Levels {
@@ -663,6 +654,12 @@ const MaxWords = 4096
 // no cause told apart (an older build module) the cause is the output's first "panic:", "fatal error:" or "signal:"
 // line, read before the output is cut, or the words say the tests passed and the program failed after them.
 func failureWords(f Failure) string {
+	return failureWordsAfter(f, "")
+}
+
+// failureWordsAfter is failureWords with the line loud put first, within the same MaxWords: what the checker itself says of
+// the failure (that the build module hid it), which the status line then names.
+func failureWordsAfter(f Failure, loud string) string {
 	out, passed := dropSummary(strings.TrimSpace(f.Output))
 	cause := strings.TrimSpace(f.Cause)
 	if cause == "" {
@@ -678,11 +675,14 @@ func failureWords(f Failure) string {
 	if len(cause) > MaxCause {
 		cause = strings.ToValidUTF8(cause[:MaxCause], "") + "..."
 	}
-	// The words keep MaxWords exactly: the cause and its newline, the marker and the kept lines (review round 1).
+	// The words keep MaxWords exactly: the loud line, the cause and their newlines, the marker and the kept lines.
 	budget := MaxWords
 	if cause != "" {
 		budget -= len(cause) + 1
 	}
+	if loud != "" {
+		budget -= len(loud) + 1
+	}
 	if len(out) > budget {
 		const marker = "... "
 		tail := out[len(out)-(budget-len(marker)):]
@@ -695,9 +695,31 @@ func failureWords(f Failure) string {
 	if cause != "" && !strings.HasPrefix(firstLine(out), cause) {
 		out = strings.TrimRight(cause+"\n"+out, "\n")
 	}
+	if loud != "" {
+		out = strings.TrimRight(loud+"\n"+out, "\n")
+	}
 	return out
 }
 
+// hidWords is the checker's loud line for a failure the build module sent hiding its cause (issue 1901, its thorough
+// fix): with no cause, or a passing line as its cause, under the failure contract (buildstep.Hidden). It names the build
+// module and the version it says it is (Tested.By, "<module> with mesh-sdk <version>"); one from before the contract
+// says nothing of itself. "" when the failure keeps the contract. The check fails either way: only its words change.
+func hidWords(module, by string, f Failure) string {
+	why := buildstep.Hidden(f)
+	if why == "" {
+		return ""
+	}
+	version := "a version before the failure contract"
+	if module == "" {
+		module = "an unnamed build module"
+	}
+	if m, v, ok := strings.Cut(by, " with "); ok && m != "" {
+		module, version = m, v
+	}
+	return fmt.Sprintf("the build module hid the failure (%s at %s): %s", module, version, why)
+}
+
 // MaxCause is the most a cause in a failure's words holds: one long line (the 1901 review: a cause of a kilobyte could
 // push the words past MaxWords).
 const MaxCause = 1024
@@ -784,7 +806,7 @@ func levelFailure(t *target, level string, results ...Tested) *delivery.Verdict
 			if t.module == buildrun.NodeBuildModule && f.Package == "" {
 				name = res.Module
 			}
-			all = append(all, delivery.FailedFirst{Test: level + ": " + name, Words: failureWords(f)})
+			all = append(all, delivery.FailedFirst{Test: level + ": " + name, Words: failureWordsAfter(f, hidWords(t.module, res.By, f))})
 		}
 	}
 	if len(all) == 0 { // no result: a level said failed with nothing to name

modules/mesh-delivery-checker/internal/check/line.go

@@ -87,20 +87,18 @@ type pieces struct {
 	judged string
 	// carried says, of a carried verdict, the commits it was carried from (ADR 0548 §8); never dropped.
 	carried string
-	// warning says that a part of the check did not run, for instance that an older build module could not refuse a compiled program; never dropped.
-	warning string
 }
 
 // pullKey names a pull request of a case: `<owner/repo>#<number>`.
 func pullKey(p Pull) string { return fmt.Sprintf("%s#%d", p.Repository, p.Number) }
 
 func (p pieces) join(drop int) string {
-	parts := []string{p.head, p.commits, p.carried, p.warning, p.counts, p.judged}
+	parts := []string{p.head, p.commits, p.carried, p.counts, p.judged}
 	switch {
 	case drop < 3 && p.times != "":
 		parts = append(parts, p.times)
 	case drop == 3 && p.shortTimes != "":
-		parts = []string{p.head, p.commits, p.carried, p.warning, p.shortCounts, p.judged, p.shortTimes}
+		parts = []string{p.head, p.commits, p.carried, p.shortCounts, p.judged, p.shortTimes}
 	}
 	if p.over != "" {
 		parts = append(parts, p.over)
@@ -212,9 +210,6 @@ func carriedWords(from map[string]string, v delivery.Verdict, cs *Case, p Pull)
 func parts(v delivery.Verdict, cs *Case, p Pull, builds []BuildNote, slowest []string, judged map[string]string) pieces {
 	var pc pieces
 	pc.judged = judged[pullKey(p)]
-	if cs != nil {
-		pc.warning = cs.Warning(pullKey(p))
-	}
 	commits := short12(p.Head) + " on " + short12(p.Trunk)
 	switch v.State {
 	case delivery.VerdictRunning:

modules/mesh-delivery-checker/internal/check/package_cause_test.go

@@ -38,11 +38,11 @@ func TestAPackageFailureIsNeverWordedPass(t *testing.T) { // 1901/AC5
 					t.Errorf("1901/AC5: the words keep %q: %q", l, v.Failed.Words)
 				}
 			}
-			if !strings.HasPrefix(v.Failed.Words, c.want) {
-				t.Errorf("1901/AC5: words start %q, want %q", firstLine(v.Failed.Words), c.want)
+			if !strings.HasPrefix(afterHid(v.Failed.Words), c.want) {
+				t.Errorf("1901/AC5: words after the loud line start %q, want %q", firstLine(afterHid(v.Failed.Words)), c.want)
 			}
-			if got := firstFailed(*v); !strings.Contains(got, c.want) || strings.HasSuffix(got, ": PASS") {
-				t.Errorf("1901/AC5: status = %q", got)
+			if got := firstFailed(*v); !strings.Contains(got, "the build module hid the failure") || strings.HasSuffix(got, ": PASS") {
+				t.Errorf("1901/AC5, AC8: status = %q", got)
 			}
 		})
 	}
@@ -63,7 +63,7 @@ func TestALongCauseIsCutToALinesBound(t *testing.T) { // 1901/AC5
 func TestAPackageStoppedWithOnlyItsFailLineIsStillWorded(t *testing.T) { // 1901/AC5
 	for _, out := range []string{"FAIL\texample.com/timeout\t2.017s", "FAIL\texample.com/exiting\t0.006s", "FAIL\texample.com/killed\t0.006s"} {
 		v := levelFailure(&target{}, "integration", Tested{Failed: []Failure{{Package: "example.com/x", Output: out}}})
-		if !strings.HasPrefix(v.Failed.Words, "the package failed with no test to name and no panic, signal or build error in its output") {
+		if !strings.HasPrefix(afterHid(v.Failed.Words), "the package failed with no test to name and no panic, signal or build error in its output") {
 			t.Errorf("1901/AC5: %q is worded %q", out, v.Failed.Words)
 		}
 	}
@@ -74,7 +74,7 @@ func TestAPackageStoppedWithOnlyItsFailLineIsStillWorded(t *testing.T) { // 1901
 func TestOnlyGosExactFormsAreSummaryOrCause(t *testing.T) { // 1901/AC5
 	out := "    x_test.go:3: ok so far\nok then: the seat is free\n        panic: child retried and recovered\npanic: the real one\nFAIL\tp\t1.0s"
 	v := levelFailure(&target{}, "unit", Tested{Failed: []Failure{{Package: "p", Output: out}}})
-	if !strings.HasPrefix(v.Failed.Words, "panic: the real one") || !strings.Contains(v.Failed.Words, "ok then: the seat is free") {
+	if !strings.HasPrefix(afterHid(v.Failed.Words), "panic: the real one") || !strings.Contains(v.Failed.Words, "ok then: the seat is free") {
 		t.Errorf("1901/AC5: words = %q", v.Failed.Words)
 	}
 }
@@ -90,3 +90,13 @@ func TestTheWordsKeepTheirBoundExactly(t *testing.T) { // 1901/AC5
 		}
 	}
 }
+
+// afterHid is a verdict's words after the checker's loud line, which a failure with no cause from an older build module
+// now starts with (1901/AC8).
+func afterHid(w string) string {
+	if strings.HasPrefix(w, "the build module hid the failure") {
+		_, rest, _ := strings.Cut(w, "\n")
+		return rest
+	}
+	return w
+}

modules/mesh-delivery-checker/internal/check/results.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"strings"
 
+	"git.novox.be/novox/mesh-sdk/go/buildstep"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 )
 
@@ -44,17 +45,6 @@ type Fetched struct {
 	Conflicts []string             `json:"conflicts,omitempty"`
 	Changed   []string             `json:"changed,omitempty"`
 	Trees     map[string]MergeTree `json:"trees,omitempty"`
-	// Programs are the changed files whose first bytes are an executable binary, read by the build module in its workspace
-	// (issue 1577); nil for a build module that does not report it, a pointer to an empty list for one that found none.
-	Programs *[]ProgramFile `json:"programs,omitempty"`
-}
-
-// ProgramFile is a changed file that is a compiled program, and its format (ELF, Mach-O or PE).
-type ProgramFile struct {
-	Path string `json:"path"`
-	Kind string `json:"kind"`
-	// Commit is set for a program a commit of the branch added and a later one removed: it stays in history once merged.
-	Commit string `json:"commit,omitempty"`
 }
 
 // GoPackage is one package of a Go test result.
@@ -69,14 +59,9 @@ type GoPackage struct {
 	Skipped int `json:"skipped,omitempty"`
 }
 
-// Failure is a test that failed, or a package that failed with no test to name.
-type Failure struct {
-	Package string `json:"package"`
-	Test    string `json:"test,omitempty"`
-	Output  string `json:"output,omitempty"`
-	// Cause is the first line of what the test reported as its error, when the build module told it apart (issue 1901).
-	Cause string `json:"cause,omitempty"`
-}
+// Failure is a test that failed, or a package that failed with no test to name: the build modules' failure contract
+// (buildstep.Failure, issue 1901), its cause never empty and never a passing line from a build module that keeps it.
+type Failure = buildstep.Failure
 
 // TestTime is one test and the seconds it took.
 type TestTime struct {
@@ -109,6 +94,9 @@ type Tested struct {
 	// JudgedBy is the program that ran the step (ADR 0535 §5): "installed", or "candidate <merge commit>" under runner
 	// workspace; absent from a build module that does not take the runner.
 	JudgedBy string `json:"judged_by,omitempty"`
+	// By is the build module that answered and the SDK it was built with (buildstep.By); absent from a build module from
+	// before the failure contract.
+	By string `json:"by,omitempty"`
 }
 
 // Digested is the answer of the Go build module's digest step: one digest per package that has tests at the level, by import

modules/mesh-delivery-checker/internal/check/testdata/captured/README

@@ -10,7 +10,7 @@ TestFetchWithABaseMergesAndAnswersThePreview and TestFetchWithAConflictEndsPasse
 into a throwaway test that wrote them out, at mesh-catalog feat/r4c5-checker d5804927 (the git commands are the test's fake,
 so the shas are its constants; the shape and the field names are the module's own marshalling). node-fetch-clean.json is the
 FetchResult json.Marshal of mesh-build-node's fetch (fetch.go, preview.go) in its test TestFetchWithABaseMergesAndAnswersThePreview
-(cmd/mesh-build-node/preview_test.go) at the same commit. Captured on 2026-10-21 for issue 1679. Both clean fetches carry `"programs":[]`, which a merging fetch of the build modules answers since issue 1577 (mesh-sdk buildstep.MergeInto's Programs), added by hand to the captured bytes: a fixture without it is an older build module's, and its line warns that no compiled program is refused.
+(cmd/mesh-build-node/preview_test.go) at the same commit. Captured on 2026-10-21 for issue 1679.
 
 forge-get-file-go-mod.json is the answer of the forge's gitea_get_file (mesh-catalog modules/gitea, tools/index.ts) for modules/mesh-delivery-builder/go.mod of
 novox/mesh-delivery at main, and forge-compare-trunk.json the answer of gitea_compare for novox/mesh-sdk base main, head cb54756c3865 (a commit on the

modules/mesh-delivery-checker/internal/check/testdata/captured/go-fetch-clean.json

@@ -1 +1 @@
-{"workspace":"mvii1iwu5414e4","commit":"0123456789abcdef0123456789abcdef01234567","modules":["."],"base":"abcdef0123456789abcdef0123456789abcdef01","merge":"fedcba9876543210fedcba9876543210fedcba98","changed":["a.go","modules/m/main.go"],"programs":[],"trees":{"modules/m":{"tree":"1111111111111111111111111111111111111111","manifest":"ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356","locks":{"go.sum":"c5fc83c01e92404452b986527d239140ccf9a48b88e0c268fbf38c2e1429e9c9"}}}}
+{"workspace":"mvii1iwu5414e4","commit":"0123456789abcdef0123456789abcdef01234567","modules":["."],"base":"abcdef0123456789abcdef0123456789abcdef01","merge":"fedcba9876543210fedcba9876543210fedcba98","changed":["a.go","modules/m/main.go"],"trees":{"modules/m":{"tree":"1111111111111111111111111111111111111111","manifest":"ca3d163bab055381827226140568f3bef7eaac187cebd76878e0b63e9e442356","locks":{"go.sum":"c5fc83c01e92404452b986527d239140ccf9a48b88e0c268fbf38c2e1429e9c9"}}}}

modules/mesh-delivery-checker/internal/check/testdata/captured/node-fetch-clean.json

@@ -1 +1 @@
-{"workspace":"mvii1sxt979f67","commit":"0123456789abcdef0123456789abcdef01234567","modules":["modules/m"],"installed":[],"refused":[],"base":"abcdef0123456789abcdef0123456789abcdef01","merge":"0123456789abcdef0123456789abcdef01234567","changed":["modules/m/package.json"],"programs":[],"trees":{"modules/m":{"tree":"0123456789abcdef0123456789abcdef01234567","manifest":"0581b699d9d05517e69b21f5cedbeb2eee8aba2b205280b561be731594d7feef"}}}
+{"workspace":"mvii1sxt979f67","commit":"0123456789abcdef0123456789abcdef01234567","modules":["modules/m"],"installed":[],"refused":[],"base":"abcdef0123456789abcdef0123456789abcdef01","merge":"0123456789abcdef0123456789abcdef01234567","changed":["modules/m/package.json"],"trees":{"modules/m":{"tree":"0123456789abcdef0123456789abcdef01234567","manifest":"0581b699d9d05517e69b21f5cedbeb2eee8aba2b205280b561be731594d7feef"}}}

modules/mesh-delivery-checker/internal/check/try.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"regexp"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -30,13 +29,8 @@ const (
 	// TriesState is the checker's state of tries: the bucket mesh-delivery-checker_tries, keys try-<unix nanoseconds>.
 	TriesState  = "tries"
 	TriesBucket = delivery.CheckerModule + "_" + TriesState
-	// MaxTries and MaxTriesWaiting are checked when a try is asked, mesh-wide: a new try is refused while MaxTries tries run
-	// on a build node or MaxTriesWaiting wait for one (queued, or their asks not yet taken by a node). It is no bound on
-	// what runs later: tries let in while waiting may later all run at once, and each node's build capacity bounds what
-	// runs on it. A try waiting behind the seat's other asks holds no node, so it no longer blocks the next try (issue
-	// 1890: at 19:53 on 2026-10-26 four tries sat queued behind 44 checks for up to 47 minutes and no fifth could be asked).
-	MaxTries        = 4
-	MaxTriesWaiting = 8
+	// MaxTries is how many tries may wait or run at once, mesh-wide: each holds a build node for minutes.
+	MaxTries = 4
 	// TryScan is how many of the newest tries a new ask reads to find the ones that wait or run (issue 1827).
 	TryScan = 64
 	// TryKeep is how long an ended try's key is kept before the checker removes it.
@@ -85,104 +79,12 @@ type Try struct {
 	Machines []string                        `json:"machines,omitempty"`
 	// Asks are the ids of the asks the try put on the build seats' streams, each ending on the step key <node>.<id> of its
 	// build module: the delivery view counts those steps as a try's, not a candidate's check (build_usage).
-	Asks []string `json:"asks,omitempty"`
-	// Steps say where each ask stands while the try runs and after: asked until a node takes it, then the node, its
-	// state, the phase its step says and when (issue 1890: a 31-minute try could not be told queued from running).
-	Steps   []TryStep `json:"steps,omitempty"`
+	Asks    []string  `json:"asks,omitempty"`
 	Asked   time.Time `json:"asked"`
 	Started time.Time `json:"started,omitzero"`
 	Ended   time.Time `json:"ended,omitzero"`
 }
 
-// TryAsked is a TryStep's state before a build node took its ask: it waits in the seat's stream.
-const TryAsked = "asked"
-
-// TryStep is one ask of a try as its step key last said it.
-type TryStep struct {
-	Ask     string    `json:"ask"`
-	Node    string    `json:"node,omitempty"`
-	State   string    `json:"state"`
-	Phase   string    `json:"phase,omitempty"`
-	Started time.Time `json:"started,omitzero"`
-	PhaseAt time.Time `json:"phase-at,omitzero"`
-	Ended   time.Time `json:"ended,omitzero"`
-}
-
-// tryWriter writes a running try's record again as its asks are put and their steps move: one writer per try, holding
-// the revision it wrote last, so the try's end is written at that revision. A write refused (the try ended by hand)
-// stops the writes; the end's own write then says it.
-type tryWriter struct {
-	mu      sync.Mutex
-	tr      *Tryer
-	ctx     context.Context
-	key     string
-	t       Try
-	rev     uint64
-	stopped bool
-}
-
-// heard takes an ask put (step nil) or a value of its step key in, and writes the record when it changed.
-func (w *tryWriter) heard(askID string, step *delivery.Step) {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	if w.stopped {
-		return
-	}
-	changed := false
-	if !slices.Contains(w.t.Asks, askID) {
-		w.t.Asks, changed = append(w.t.Asks, askID), true
-	}
-	i := slices.IndexFunc(w.t.Steps, func(s TryStep) bool { return s.Ask == askID })
-	if i < 0 {
-		w.t.Steps, changed = append(w.t.Steps, TryStep{Ask: askID, State: TryAsked}), true
-		i = len(w.t.Steps) - 1
-	}
-	if step != nil {
-		now := TryStep{Ask: askID, Node: step.Node, State: step.State, Phase: step.Phase, Started: step.Started,
-			PhaseAt: step.PhaseAt, Ended: step.Ended}
-		changed = changed || now != w.t.Steps[i]
-		w.t.Steps[i] = now
-	}
-	if changed {
-		w.write()
-	}
-}
-
-// write writes the record at the revision written last; a refusal stops the writes.
-func (w *tryWriter) write() {
-	data, err := encodeTry(w.t)
-	if err != nil {
-		return
-	}
-	rev, err := w.tr.Tries.Update(w.ctx, w.key, data, w.rev)
-	if err != nil {
-		w.stopped = true
-		w.tr.logf("%s: its asks' progress is no longer written: %v", w.key, err)
-		return
-	}
-	w.rev = rev
-}
-
-// end stops the writes and answers the record and its revision, for the try's end.
-func (w *tryWriter) end() (Try, uint64) {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	w.stopped = true
-	return w.t, w.rev
-}
-
-// HoldsANode says whether the try holds a build node now: it runs, and a step of its asks runs on a node, or it names
-// no step (a checker that writes its asks only at the end, or one about to put its first).
-func (t Try) HoldsANode() bool {
-	if t.State != TryRunning {
-		return false
-	}
-	if len(t.Steps) == 0 {
-		return true
-	}
-	return slices.ContainsFunc(t.Steps, func(s TryStep) bool { return s.State == delivery.StepRunning })
-}
-
 // Over says whether the try came to its end.
 func (t Try) Over() bool { return t.State == TryPass || t.State == TryFail || t.State == TryError }
 
@@ -222,8 +124,8 @@ func NotChecked(repository string) error {
 }
 
 // AskTry writes a new try, queued, and answers its id: a try of the same head that waits or runs is the answer to a second
-// ask, and a new try is refused while MaxTries tries run on a build node or MaxTriesWaiting wait for one. trunks are the
-// gate's trunk heads of every repository (source.main): a repository with none is no repository the checker checks. A trunk asked by name is its trunk head now.
+// ask, and at most MaxTries wait or run at once. trunks are the gate's trunk heads of every repository (source.main): a
+// repository with none is no repository the checker checks. A trunk asked by name is its trunk head now.
 func AskTry(store TryStore, trunks map[string]string, a TryAsk, now time.Time) (string, error) {
 	repo := strings.ToLower(strings.TrimSuffix(strings.TrimSpace(a.Repository), ".git"))
 	head := strings.ToLower(strings.TrimSpace(a.Head))
@@ -286,7 +188,7 @@ func AskTry(store TryStore, trunks map[string]string, a TryAsk, now time.Time) (
 	}); err != nil {
 		return "", err
 	}
-	var holding, waiting []string
+	var open []string
 	for i, cur := range tries {
 		if !live[i] {
 			continue
@@ -294,18 +196,10 @@ func AskTry(store TryStore, trunks map[string]string, a TryAsk, now time.Time) (
 		if cur.Repository == t.Repository && cur.Head == t.Head && cur.Trunk == t.Trunk && cur.Tests == t.Tests && cur.Level == t.Level {
 			return cur.ID, nil
 		}
-		said := fmt.Sprintf("%s (%s@%.12s, %s)", cur.ID, cur.Repository, cur.Head, cur.State)
-		if cur.HoldsANode() {
-			holding = append(holding, said)
-		} else {
-			waiting = append(waiting, said)
-		}
+		open = append(open, fmt.Sprintf("%s (%s@%.12s, %s)", cur.ID, cur.Repository, cur.Head, cur.State))
 	}
-	// Checked at this ask only: a try queued behind the seat's checks holds no node; tries let in while waiting may later
-	// all run at once, and each node's build capacity bounds what runs on it.
-	if len(holding) >= MaxTries || len(waiting) >= MaxTriesWaiting {
-		return "", fmt.Errorf("a new try is refused while %d tries run on a build node or %d wait for one; now %d run and %d wait: running %s; waiting %s; ask again when one ends",
-			MaxTries, MaxTriesWaiting, len(holding), len(waiting), orNone(holding), orNone(waiting))
+	if len(open) >= MaxTries {
+		return "", fmt.Errorf("%d tries wait or run, the most at once: %s; ask again when one ends", len(open), strings.Join(open, ", "))
 	}
 	t.ID = "try-" + strconv.FormatInt(now.UnixNano(), 10)
 	data, err := encodeTry(t)
@@ -501,8 +395,7 @@ func (tr *Tryer) run(ctx context.Context, key string) {
 		}
 		return
 	}
-	progress := &tryWriter{tr: tr, ctx: ctx, key: key, t: t, rev: rev}
-	cs := &Case{Key: key, Group: key, Watch: progress.heard,
+	cs := &Case{Key: key, Group: key,
 		Pulls:    []Pull{{Repository: t.Repository, Head: t.Head, Trunk: t.Trunk}},
 		Trunk:    map[string]string{t.Repository: t.Trunk},
 		Queued:   t.Asked,
@@ -516,7 +409,6 @@ func (tr *Tryer) run(ctx context.Context, key string) {
 	if ctx.Err() != nil {
 		return // left running: the checker takes it over when it starts; or ended by hand, which wrote its end
 	}
-	t, rev = progress.end()
 	v := out.Verdict
 	t.Ended = tr.now().UTC()
 	t.Took = t.Ended.Sub(t.Started).Round(time.Second).String()
@@ -578,11 +470,3 @@ func judgeWithin(ctx context.Context, j Judge, cs *Case, bound time.Duration) (O
 	}
 	return out, true
 }
-
-// orNone joins the tries said, or says none.
-func orNone(said []string) string {
-	if len(said) == 0 {
-		return "none"
-	}
-	return strings.Join(said, ", ")
-}

modules/mesh-delivery-checker/internal/check/try_test.go

@@ -3,7 +3,6 @@ package check
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"strings"
 	"testing"
 	"time"
@@ -24,19 +23,6 @@ func (m memTries) Create(key string, value []byte) error {
 	return err
 }
 
-// writtenTries is a memKV that keeps every running try it was given to write, in order.
-type writtenTries struct {
-	*memKV
-	running []Try
-}
-
-func (w *writtenTries) Update(ctx context.Context, key string, value []byte, rev uint64) (uint64, error) {
-	if t, err := DecodeTry(value); err == nil && !t.Over() {
-		w.running = append(w.running, t)
-	}
-	return w.memKV.Update(ctx, key, value, rev)
-}
-
 var tryTrunks = map[string]string{repoA: trunkA, repoSDK: trunkS, hqRepo: trunkA}
 
 func readTry(t testing.TB, kv *memKV, id string) Try {
@@ -68,39 +54,15 @@ func TestATryIsAskedQueuedOncePerHeadAndAtMostFourAtOnce(t *testing.T) { // ADR
 	if err != nil || again != id {
 		t.Errorf("a second ask of the same head answered %q, %v, want %q", again, err, id)
 	}
-	// Issue 1890: tries on a build node (a step of theirs running, or none named yet) and tries waiting for one (queued, or
-	// their asks not taken) are bounded apart, MaxTries and MaxTriesWaiting; the refusal names both counts.
-	onNode := func(i int) Try {
-		return Try{ID: fmt.Sprintf("try-%d", i), Repository: repoA, Head: fmt.Sprintf("%040x", i), Trunk: trunkA, State: TryRunning,
-			Steps: []TryStep{{Ask: "a", State: delivery.StepRunning}}}
-	}
-	waitingFor := func(i int) Try {
-		return Try{ID: fmt.Sprintf("try-%d", i), Repository: repoA, Head: fmt.Sprintf("%040x", i), Trunk: trunkA, State: TryRunning,
-			Steps: []TryStep{{Ask: "a", State: TryAsked}}}
-	}
-	for _, c := range []struct {
-		what          string
-		holding, wait int
-		refused       string
-	}{
-		{"four queued behind the checks, none on a node: a fifth is taken", 0, 4, ""},
-		{"four on a node", MaxTries, 0, "now 4 run and 0 wait"},
-		{"three on a node, eight waiting", 3, MaxTriesWaiting, "a new try is refused while 4 tries run on a build node or 8 wait for one; now 3 run and 8 wait"},
-	} {
-		kv := newMemKV()
-		for i := range c.holding + c.wait {
-			tr := waitingFor(i + 1)
-			if i < c.holding {
-				tr = onNode(i + 1)
-			}
-			data, _ := encodeTry(tr)
-			_, _ = kv.Create(context.Background(), tr.ID, data)
-		}
-		_, err := AskTry(memTries{kv}, tryTrunks, TryAsk{Repository: repoSDK, Head: head1}, at.Add(time.Minute))
-		if (c.refused == "") != (err == nil) || (err != nil && !strings.Contains(err.Error(), c.refused)) {
-			t.Errorf("%s: answered %v, want refused %q", c.what, err, c.refused)
+	heads := []string{head2, trunkA2, trunkS2}
+	for i, h := range heads {
+		if _, err := AskTry(store, tryTrunks, TryAsk{Repository: repoA, Head: h, Trunk: trunkA}, at.Add(time.Duration(i+2)*time.Second)); err != nil {
+			t.Fatalf("try %d: %v", i+2, err)
 		}
 	}
+	if _, err := AskTry(store, tryTrunks, TryAsk{Repository: repoSDK, Head: head1}, at.Add(time.Minute)); err == nil || !strings.Contains(err.Error(), "4 tries wait or run") {
+		t.Errorf("a fifth try answered %v, want refused naming the four", err)
+	}
 }
 
 func TestATryOfARepositoryWithNoCheckedLevelIsRefused(t *testing.T) { // the agreed error of the try
@@ -127,8 +89,7 @@ func TestATryIsJudgedAsAPullRequestsHeadAndOwesTheForgeNothing(t *testing.T) { /
 		t.Fatal(err)
 	}
 	b := newBench(t)
-	written := &writtenTries{memKV: kv}
-	tr := &Tryer{Tries: written, Judge: b.ex}
+	tr := &Tryer{Tries: kv, Judge: b.ex}
 	raw, _, _, _ := kv.Get(ctx, id)
 	tr.Put(ctx, id, raw)
 	tr.Wait()
@@ -136,15 +97,6 @@ func TestATryIsJudgedAsAPullRequestsHeadAndOwesTheForgeNothing(t *testing.T) { /
 	if got.State != TryPass || got.Took == "" || got.Head != head1 || got.Trunk != trunkA || got.Said == "" || got.Levels[delivery.LevelUnit].Run != 2 {
 		t.Fatalf("try = %+v", got)
 	}
-	// Issue 1890: while it runs, the try names its ask as soon as it is put, and then where its step stands; the end
-	// keeps each ask's node and state.
-	if len(written.running) < 3 || len(written.running[1].Asks) != 1 || written.running[1].Steps[0].State != TryAsked ||
-		written.running[2].Steps[0].Node != "shanks" {
-		t.Errorf("the running try's writes = %+v, want its ask named while it ran, then its node", written.running)
-	}
-	if len(got.Steps) != 1 || got.Steps[0].Node != "shanks" || got.Steps[0].State != delivery.StepPassed {
-		t.Errorf("the ended try's steps = %+v", got.Steps)
-	}
 	// The try names the asks it put, so the delivery view counts their steps as a try's (build_usage).
 	if len(got.Asks) != 1 {
 		t.Errorf("asks = %v, want the one check ask the try put", got.Asks)

modules/mesh-delivery-view/go.mod

@@ -3,7 +3,7 @@ module mesh-delivery-view
 go 1.26.0
 
 require (
-	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026202658-805b4d9a3536
+	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026125731-2aae6f5580f2
 	github.com/nats-io/nats-server/v2 v2.11.17
 	github.com/nats-io/nats.go v1.54.0
 )

modules/mesh-delivery-view/go.sum

@@ -1,5 +1,5 @@
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026202658-805b4d9a3536 h1:+SoDdDXF7Tgj38WP4kRpUSps6DJVl6P+w5u/KfdtwnQ=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026202658-805b4d9a3536/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026125731-2aae6f5580f2 h1:s1WcG7Ll1OkEwwvMKEabdWvPvTiFCHghlXiY1LoIJDA=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261026125731-2aae6f5580f2/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
 github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op h1:Z/MZK75wC/NSrkgqeNIa7jexam9uWzhLmFTSCPI/kn0=
 github.com/antithesishq/antithesis-sdk-go v0.7.0-default-no-op/go.mod h1:FQyySiasQQM8735Ddel3MRojmy4dA1IqCeyJ5jmPMbI=
 github.com/google/go-tpm v0.9.8 h1:slArAR9Ft+1ybZu0lBwpSmpwhRXaa85hWtMinMyRAWo=

modules/mesh-delivery-view/internal/view/usage.go

@@ -67,8 +67,7 @@ type UsageAnswer struct {
 	At      time.Time    `json:"at"`
 	Nodes   []NodeUsage  `json:"nodes"`
 	Backlog []BacklogRow `json:"backlog"`
-	// TriesRunning are the tries the checker runs now, each with its asks and where each stands (a checker that names its
-	// asks as they are put, issue 1890; an older one names them only at the end, and they are counted under check until then).
+	// TriesRunning are the tries the checker runs now; their asks are counted under check until the try ends and names them.
 	TriesRunning []TryRunning `json:"tries_running"`
 	Notes        []string     `json:"notes,omitempty"`
 }
@@ -78,9 +77,6 @@ type TryRunning struct {
 	ID         string    `json:"id"`
 	Repository string    `json:"repository"`
 	Started    time.Time `json:"started,omitzero"`
-	Asks       []string  `json:"asks,omitempty"`
-	// Steps are the try's own words for each ask: asked, or the node that took it, its state and the phase its step says.
-	Steps json.RawMessage `json:"steps,omitempty"`
 }
 
 // NodeUsage is one node: each build seat it holds or is set to build for, whether it is eligible to build, and its CPU.
@@ -105,17 +101,7 @@ type SeatUsage struct {
 	// Capacity is the asks it runs at once; CapacityFrom where that came from.
 	Capacity     int    `json:"capacity"`
 	CapacityFrom string `json:"capacity_from"`
-	// Configured is mesh-config's capacity when the module says it judges by a lower one (capacity.<node> of its pauses
-	// state: the configured capacity bounded by its node's build CPU, issue 1806's follow-up); Capacity is then the
-	// module's and CapacityFrom its why.
-	Configured int `json:"configured,omitempty"`
-	// BuildHours is the node's build window as the module says it (HH:MM-HH:MM and its zone), absent when it builds at any
-	// hour; OutsideHours says the module judged the time outside it, so it takes nothing new (the operator, 2026-10-26).
-	BuildHours   string `json:"build_hours,omitempty"`
-	OutsideHours bool   `json:"outside_hours,omitempty"`
-	// BuildHoursFault is why the module cannot read its node's build-hours value, naming it: it then builds at any hour.
-	BuildHoursFault string `json:"build_hours_fault,omitempty"`
-	Paused          bool   `json:"paused"`
+	Paused       bool   `json:"paused"`
 	// Eligible says it takes asks: it holds the seat, has a capacity above 0 and is not paused; WhyNot says why not.
 	// EligibleKnown is false when this tool cannot tell (it cannot read mesh-config's capacities): Eligible is then
 	// absent, never false, and WhyNot starts "not known: ".
@@ -398,9 +384,8 @@ func (u UsageReader) Usage() UsageAnswer {
 		}
 	}
 
-	// Pauses: paused.<node> of each module; and capacity.<node>, the capacity the module says it judges by.
+	// Pauses: paused.<node> of each module.
 	paused := map[string]bool{} // <node>.<language>
-	judged := map[string]delivery.Capacity{}
 	for _, lang := range delivery.AskLanguages {
 		module, _ := delivery.BuildModuleOf(lang)
 		pr, ok := u.Pauses[lang]
@@ -426,13 +411,6 @@ func (u UsageReader) Usage() UsageAnswer {
 					paused[node+"."+lang] = p.Paused
 				}
 			}
-			if key, err := delivery.CapacityKey(node); err == nil {
-				if raw, err := pr.Get(key); err == nil && len(raw) > 0 {
-					if c, err := delivery.DecodeCapacity(raw); err == nil {
-						judged[node+"."+lang] = c
-					}
-				}
-			}
 		}
 	}
 
@@ -474,18 +452,6 @@ func (u UsageReader) Usage() UsageAnswer {
 				s.Capacity = (&buildrun.Places{Capacity: caps}).CapacityOf(node)
 				s.CapacityFrom = fmt.Sprintf("the modules' default %q: mesh-config holds no resolved value for %s on %s", buildstep.DefaultCapacities, s.Module, node)
 			}
-			if c, ok := judged[node+"."+lang]; ok && s.Holds && unknown == "" && !isBad && c.Configured == s.Capacity {
-				// The module running on the node says its build hours, and judges by less than mesh-config gives when its
-				// node's build CPU bounds it or the time is outside its build hours.
-				s.BuildHours, s.OutsideHours = c.BuildHours, c.OutsideHours
-				if c.BuildHoursFault != "" {
-					s.BuildHours, s.BuildHoursFault = "any hour", c.BuildHoursFault
-				}
-				if c.Effective != c.Configured {
-					s.Configured, s.Capacity = s.Capacity, c.Effective
-					s.CapacityFrom = fmt.Sprintf("%s, as %s on %s judges it (said %s)", c.Why, s.Module, node, c.At.UTC().Format(time.RFC3339))
-				}
-			}
 			s.Paused = paused[node+"."+lang]
 			s.EligibleKnown = true
 			switch {
@@ -500,8 +466,6 @@ func (u UsageReader) Usage() UsageAnswer {
 				s.WhyNot = "not known: this tool cannot read its capacity (" + unknown + ")"
 			case isBad:
 				s.WhyNot = "its capacity on " + node + " cannot be read, so its puller uses 0"
-			case s.OutsideHours:
-				s.WhyNot = "outside its build hours " + s.BuildHours + " on " + node + ": it takes nothing new until they open"
 			case s.Capacity == 0:
 				s.WhyNot = "its capacity on " + node + " is 0"
 			}
@@ -553,7 +517,6 @@ func (u UsageReader) tries(now time.Time, ans *UsageAnswer, note func(string, ..
 			want = append(want, k)
 		}
 	}
-	unnamed := 0
 	raws, err := u.Tries.values(want)
 	if err != nil {
 		note("the checker's tries cannot all be read: %v", err)
@@ -563,12 +526,11 @@ func (u UsageReader) tries(now time.Time, ans *UsageAnswer, note func(string, ..
 			continue
 		}
 		var t struct {
-			ID         string          `json:"id"`
-			Repository string          `json:"repository"`
-			State      string          `json:"state"`
-			Started    time.Time       `json:"started"`
-			Asks       []string        `json:"asks"`
-			Steps      json.RawMessage `json:"steps"`
+			ID         string    `json:"id"`
+			Repository string    `json:"repository"`
+			State      string    `json:"state"`
+			Started    time.Time `json:"started"`
+			Asks       []string  `json:"asks"`
 		}
 		if json.Unmarshal(raws[i], &t) != nil {
 			continue
@@ -577,14 +539,11 @@ func (u UsageReader) tries(now time.Time, ans *UsageAnswer, note func(string, ..
 			asks[a] = true
 		}
 		if t.State == "running" {
-			ans.TriesRunning = append(ans.TriesRunning, TryRunning{ID: t.ID, Repository: t.Repository, Started: t.Started, Asks: t.Asks, Steps: t.Steps})
-			if len(t.Asks) == 0 {
-				unnamed++
-			}
+			ans.TriesRunning = append(ans.TriesRunning, TryRunning{ID: t.ID, Repository: t.Repository, Started: t.Started})
 		}
 	}
-	if unnamed > 0 {
-		note("%d running tries name no ask yet (none put yet, or a checker that names them only at the end): their asks are counted under check until then", unnamed)
+	if len(ans.TriesRunning) > 0 {
+		note("a running try's asks are counted under check until the try ends and names them")
 	}
 	return asks
 }

modules/mesh-delivery-view/internal/view/usage_test.go

@@ -191,36 +191,4 @@ func TestBuildUsageAnswersEveryNodesUseFromTheStates(t *testing.T) {
 	if verdict["shanks"] != "not known" || verdict["ace"] != "not eligible" {
 		t.Errorf("verdicts with mesh-config unreadable = %v, want shanks not known, ace not eligible (paused)", verdict)
 	}
-
-	// Issue 1806's follow-up: the module on shanks says it judges by 1 of mesh-config's 2 (its build CPU bounds it); the
-	// seat says the module's capacity and why. And issue 1890: a running try that names its asks is said with them.
-	u = usageFixture()
-	u.Pauses["go"] = states(map[string]string{"capacity.shanks": `{"v":1,"effective":1,"configured":2,"quota-from":"the cpu.max of /meshyield.slice","quota-cores":6,"cores-per-step":6,"by-cpu":1,"why":"1, bounded by the CPU","at":"2026-10-26T11:00:00Z"}`,
-		"capacity.ace": `{"v":1,"effective":2,"configured":3,"why":"stale: mesh-config says 2 now"}`})
-	u.Tries = states(map[string]string{"try-" + strconv.FormatInt(at("11:58").UnixNano(), 10): `{"id":"try-2","repository":"novox/mesh-delivery","head":"h","trunk":"t","state":"running","asks":["` + tryAsk0 + `"],"steps":[{"ask":"` + tryAsk0 + `","node":"shanks","state":"running","phase":"unit: tests of 3 packages"}]}`})
-	bound := u.Usage()
-	sc := seatOf(t, bound, "shanks", "node-build-go")
-	if sc.Capacity != 1 || sc.Configured != 2 || !strings.HasPrefix(sc.CapacityFrom, "1, bounded by the CPU, as mesh-build-go on shanks judges it") {
-		t.Errorf("a seat its CPU bounds: capacity %d of %d, from %q", sc.Capacity, sc.Configured, sc.CapacityFrom)
-	}
-	if sa := seatOf(t, bound, "ace", "node-build-go"); sa.Capacity != 2 || sa.Configured != 0 {
-		t.Errorf("a module's word older than mesh-config's value is not taken: %+v", sa)
-	}
-	// The operator, 2026-10-26: outside its build hours the seat takes nothing new, and says so.
-	u.Pauses["go"] = states(map[string]string{"capacity.shanks": `{"v":1,"effective":0,"configured":2,"build-hours":"18:00-06:00 CET","outside-hours":true,"why":"0, outside its build hours 18:00-06:00 CET until 18:00 (otherwise 2)","at":"2026-10-26T11:00:00Z"}`})
-	if so := seatOf(t, u.Usage(), "shanks", "node-build-go"); so.Capacity != 0 || !so.OutsideHours || so.Eligible == nil || *so.Eligible ||
-		so.WhyNot != "outside its build hours 18:00-06:00 CET on shanks: it takes nothing new until they open" {
-		t.Errorf("a seat outside its build hours: %+v", so)
-	}
-	// A build-hours value the module cannot read: it builds at any hour, and the seat says the value and why.
-	u.Pauses["go"] = states(map[string]string{"capacity.shanks": `{"v":1,"effective":2,"configured":2,"build-hours-fault":"the build hours \"shanks=18:00-6\": \"6\" is not a time HH:MM","why":"2; at any hour, because its build hours cannot be read","at":"2026-10-26T11:00:00Z"}`})
-	if sf := seatOf(t, u.Usage(), "shanks", "node-build-go"); sf.BuildHours != "any hour" || !strings.Contains(sf.BuildHoursFault, "shanks=18:00-6") || sf.Eligible == nil || !*sf.Eligible {
-		t.Errorf("a seat whose build hours cannot be read: %+v", sf)
-	}
-	if len(bound.TriesRunning) != 1 || len(bound.TriesRunning[0].Asks) != 1 || !strings.Contains(string(bound.TriesRunning[0].Steps), "unit: tests") ||
-		strings.Contains(strings.Join(bound.Notes, " | "), "name no ask yet") {
-		t.Errorf("a running try naming its asks: %+v, notes %v", bound.TriesRunning, bound.Notes)
-	}
 }
-
-var tryAsk0 = stepID(at("11:58"), "a00010")