mesh-delivery-checker: a failed test's verdict keeps its last lines and the status line names its error (issue 1901)

modules/mesh-delivery-assigner/cmd/mesh-delivery-assigner/integration_test.go

@@ -181,10 +181,8 @@ func TestAChangeIsComposedOnTheBus(t *testing.T) {
 	b.putJSON(t, provider.AssignmentsBucket, "ace.other", []byte(`{"node":"ace","module":"other","build":"build-2"}`))
 	heads := []delivery.Head{{Repository: "novox/web", Number: 7, Head: strings.Repeat("2", 40)}}
 	hash, _ := delivery.HeadsHash(heads)
-	// 1927/AC1: the candidate carries the fingerprint set the SDK computes, as the indexer writes it.
+	cand, err := delivery.EncodeCandidate(delivery.Candidate{Group: "feat/x", HeadsHash: hash, Pulls: []delivery.CandidatePull{{Head: heads[0],
-	pulls := []delivery.CandidatePull{{Head: heads[0],
+		Modules: []string{"web"}, Fps: map[string]delivery.CandidateModule{"web": {FP2: delivery.SourcePrefix2 + strings.Repeat("b", 64), Manifest: changed}}}}})
-		Modules: []string{"web"}, Fps: map[string]delivery.CandidateModule{"web": {FP2: delivery.SourcePrefix2 + strings.Repeat("b", 64), Manifest: changed}}}}
-	cand, err := delivery.EncodeCandidate(delivery.Candidate{Group: "feat/x", HeadsHash: hash, Pulls: pulls, FPSet: delivery.FingerprintSet(pulls)})
 	if err != nil {
 		t.Fatal(err)
 	}

modules/mesh-delivery-builder/cmd/mesh-delivery-builder/integration_test.go

@@ -179,11 +179,7 @@ type bed struct {
 // startBed starts the bus, the buckets the controller makes from the builder's and the build modules' manifests, the
 // build modules' streams and the builder's durable consumers on them, two nodes' toolchains, the indexer's manifests, and
 // the fake build modules. It runs no builder.
-func startBed(t *testing.T) *bed { return startBedWith(t, false) }
+func startBed(t *testing.T) *bed {
-
-// startBedWith is startBed with the nodes' capacity 0 from the start when closed: a puller that reads its capacity before a
-// test could close the nodes may be in a pull already and takes the first ask put (issue 1928).
-func startBedWith(t *testing.T, closed bool) *bed {
 	dir, err := os.MkdirTemp(os.Getenv("TMPDIR"), "b")
 	if err != nil {
 		t.Fatal(err)
@@ -247,7 +243,6 @@ func startBedWith(t *testing.T, closed bool) *bed {
 	b.builds = mk(delivery.BuilderBuildsBucket, delivery.BuilderBuildsHistory)
 	b.instances = mk(instancesBucket, 1)
 	b.fake = &fakeBuildModules{js: js, ctx: ctx, calls: map[string]int{}}
-	b.fake.closed.Store(closed)
 	b.fake.serve(t, "mesh-build-go", "n1", "n2")
 	b.fake.serve(t, "mesh-build-node", "n1", "n2")
 	b.fake.serve(t, "mesh-build-image", "n1") // the image build module runs on n1 only
@@ -786,7 +781,8 @@ func (b *bed) asksPut(t *testing.T, nc *nats.Conn) func() []delivery.StepAsk {
 // 1887/AC3: a builder that started again while its asks waited in the streams (no node had a free slot) puts no second
 // ask: it waits for the asks its building key names, and the key is done once a node took them.
 func TestARestartedBuilderPutsNoSecondAsk(t *testing.T) {
-	b := startBedWith(t, true) // 1928/AC1: no node can take an ask from the start, so no pull in hand takes the first one
+	b := startBed(t)
+	b.fake.closed.Store(true)
 	b.module(t, "netcheck", "catalogue-a67f0196-netcheck.module.json", "modules/netcheck")
 	sub, err := nats.Connect(b.srvURL, nats.UserInfo("ctl", "pw"))
 	if err != nil {
@@ -796,13 +792,11 @@ func TestARestartedBuilderPutsNoSecondAsk(t *testing.T) {
 	asked := b.asksPut(t, sub)
 	b.start(t, "n1", nil)
 	v := b.await(t, "netcheck", func(v delivery.BuilderBuild) bool { return v.State == delivery.BuildBuilding && len(v.Asks) == 2 })
-	for deadline := time.Now().Add(20 * time.Second); len(asked()) < 2; time.Sleep(20 * time.Millisecond) {
+	for deadline := time.Now().Add(5 * time.Second); len(asked()) < 2 && time.Now().Before(deadline); time.Sleep(20 * time.Millisecond) {
-		if time.Now().After(deadline) {
-			t.Fatalf("asks put = %+v within 20 s, want the two the key names", asked())
-		}
 	}
 	b.stop()
 	b.start(t, "n1", nil) // the same builder, started again, while both asks wait
+	time.Sleep(500 * time.Millisecond)
 	b.fake.open()
 	done := b.await(t, "netcheck", isState(delivery.BuildDone))
 	if got := asked(); len(got) != 2 {

modules/mesh-delivery-checker/cmd/mesh-delivery-checker/integration_test.go

@@ -10,7 +10,6 @@ import (
 	"io"
 	"os"
 	"path/filepath"
-	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -82,9 +81,6 @@ type fakeBuildModules struct {
 	mu       sync.Mutex
 	calls    map[string]int // by `<module>.<tool>`
 	testTool *testing.T
-	// beside is, by workspace, the siblings the fetch placed in it as `<owner/repo> <commit>`, sorted: a digest echoes them
-	// (1929/AC2; mesh-sdk buildstep.besideOf), or the level runs whole and keeps nothing.
-	beside map[string][]string
 }
 
 func (f *fakeBuildModules) count(tool string) int {
@@ -104,30 +100,10 @@ func (f *fakeBuildModules) result(t *testing.T, tool string, args map[string]any
 		}
 		fetched := readCaptured(t, name)
 		fetched["commit"], fetched["base"] = args["commit"], args["base"]
-		var refs []struct {
-			Repository string `json:"repository"`
-			Commit     string `json:"commit"`
-		}
-		raw, _ := json.Marshal(args["beside"])
-		_ = json.Unmarshal(raw, &refs)
-		var lines []string
-		for _, r := range refs {
-			lines = append(lines, r.Repository+" "+r.Commit)
-		}
-		sort.Strings(lines)
-		f.mu.Lock()
-		if f.beside == nil {
-			f.beside = map[string][]string{}
-		}
-		f.beside[fmt.Sprint(fetched["workspace"])] = lines
-		f.mu.Unlock()
 		v = fetched
 	case strings.HasSuffix(tool, "_digest"):
 		d := map[string]string{"unit": digU, "integration": digI}[level]
-		f.mu.Lock()
+		v = map[string]any{"level": level, "packages": map[string]string{"fixture/slow": d}}
-		beside := f.beside[fmt.Sprint(args["workspace"])]
-		f.mu.Unlock()
-		v = map[string]any{"level": level, "packages": map[string]string{"fixture/slow": d}, "beside": beside}
 	case strings.HasSuffix(tool, "_test"):
 		r := readCaptured(t, "go-test-slow")
 		r["level"] = level
@@ -312,15 +288,6 @@ func startBed(t *testing.T) *bed {
 		}
 		b.buckets[name] = kv
 	}
-	// 1929/AC1: the indexer's value of the repository's module, with no TypeScript manifest, so the Go build module alone
-	// judges the repository (an unknown repository is judged by both, issue 1887 A12).
-	known, err := delivery.EncodeModule(delivery.Module{Repository: repo, Commit: trunk, Path: "modules/m", None2: "the fingerprint is computed with its chain"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := b.buckets[delivery.ModulesBucket].Put(ctx, "m", known); err != nil {
-		t.Fatal(err)
-	}
 	b.setOnline(t, "n1", true)
 	for _, module := range []string{"mesh-build-go", "mesh-build-node"} {
 		b.setHealth(t, "n1", module)
@@ -469,7 +436,7 @@ func (b *bed) owed(t *testing.T, number int, head, state string) delivery.Owed {
 // TestCheckerJudgesACandidateAndOwesItsStatus: a candidate the indexer wrote, one pull request of mesh-delivery, is fetched
 // merged onto the trunk the gate names, digested and tested at both levels on the node, kept, previewed; the verdict passes
 // with the counts of both levels and the composition not run, and the status mesh/check is owed on the head as success.
-func TestCheckerJudgesACandidateAndOwesItsStatus(t *testing.T) { // N6/AC5, 1300/AC5, 1445/AC1, 1929/AC1
+func TestCheckerJudgesACandidateAndOwesItsStatus(t *testing.T) { // N6/AC5, 1300/AC5, 1445/AC1
 	b := startBed(t)
 	key := b.candidate(t, "feat/x", pull(repo, 7, head1))
 	b.start(t, nil)
@@ -509,7 +476,7 @@ func TestCheckerJudgesACandidateAndOwesItsStatus(t *testing.T) { // N6/AC5, 1300
 
 // TestACheckOfEqualInputsRunsNothing: a second candidate (another head, the same digests) is checked with every package
 // taken from the first's kept verdicts: no test step runs and no second kept key appears.
-func TestACheckOfEqualInputsRunsNothing(t *testing.T) { // 1287/AC5, 1288/AC6, 1929/AC2
+func TestACheckOfEqualInputsRunsNothing(t *testing.T) { // 1287/AC5, 1288/AC6
 	b := startBed(t)
 	first := b.candidate(t, "feat/x", pull(repo, 7, head1))
 	b.start(t, nil)
@@ -607,7 +574,7 @@ func TestACheckLeftRunningIsTakenOverWhenTheCheckerStarts(t *testing.T) { // N6/
 
 // TestAMemberNamingAMeshSDKCommitOffTheTrunkFailsNamingTheCommit: the go.mod the forge answers names a commit that main does not
 // hold; the verdict fails naming the member and the commit and no test runs (ADR 0484 clause 9).
-func TestAMemberNamingAMeshSDKCommitOffTheTrunkFailsNamingTheCommit(t *testing.T) { // 1624/AC2, 1929/AC3
+func TestAMemberNamingAMeshSDKCommitOffTheTrunkFailsNamingTheCommit(t *testing.T) { // 1624/AC2
 	b := startBed(t)
 	b.stalePin.Store(true)
 	key := b.candidate(t, "feat/x", pull(repo, 7, head1))
@@ -616,7 +583,9 @@ func TestAMemberNamingAMeshSDKCommitOffTheTrunkFailsNamingTheCommit(t *testing.T
 	if v.State != delivery.VerdictFail || !strings.Contains(v.Failed.Words, "9aaa5c80ac5c") || !strings.Contains(v.Failed.Words, repo+"#7") {
 		t.Fatalf("verdict = %+v", v)
 	}
-	// 1929/AC3: no assertion that no test ran: one ask runs fetch, digest and tests (ADR 0525 §3).
+	if n := b.fake.count("mesh-build-go.build_go_test"); n != 0 {
+		t.Errorf("%d test steps ran after a stale pin", n)
+	}
 }
 
 // triesStore is the tries bucket as the tools write it.
@@ -702,7 +671,7 @@ func TestTheCheckerSaysOwedReadableOnTheBus(t *testing.T) { // R2-1
 		break
 	}
 	if said.Module != "mesh-delivery-checker" || said.Node != "n1" || !said.Keeps("owed") || !said.Readable("owed") ||
-		!said.Readable("previews") || !said.Readable("verdicts") || !said.Readable("kept") || said.Readable("tries") || len(said.States) != 5 {
+		!said.Readable("previews") || !said.Readable("verdicts") || said.Readable("kept") || said.Readable("tries") || len(said.States) != 5 {
-		t.Fatalf("the checker said %+v, want its five states with kept, owed, previews and verdicts readable (1929/AC4; 1887 A5b)", said)
+		t.Fatalf("the checker said %+v, want its five states with owed, previews and verdicts readable", said)
 	}
 }

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.20261023213200-403a5d72ab93
+	git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261023150321-a2c813a6b468
 	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.20261023213200-403a5d72ab93 h1:FAiFY2KBKEoZSH49OZTt7/zRBIQxyl5g/KhYrpggbN4=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261023150321-a2c813a6b468 h1:UcMee+IV2ii5E4dRZdQUaSaeh9IedTFYumuQbBiB0k0=
-git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261023213200-403a5d72ab93/go.mod h1:ouERNpZizzwZ0HLEtAypsY9FR20FyUgUYRni6J7kVCY=
+git.novox.be/novox/mesh-sdk/go v0.1.14-0.20261023150321-a2c813a6b468/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/beside.go

@@ -26,7 +26,7 @@ const (
 // checks/deps). Which commit of each is besideCommit's rule.
 var besideRules = map[string][]string{
 	controllerRepo:        {catalogueRepository, nodeEngineRepo, SDKRepository},
-	nodeEngineRepo:        {catalogueRepository, SDKRepository, controllerRepo},
+	nodeEngineRepo:        {catalogueRepository, SDKRepository},
 	SDKRepository:         {catalogueRepository, nodeEngineRepo},
 	catalogueRepository:   {SDKRepository, controllerRepo},
 	"novox/mesh-delivery": {SDKRepository, catalogueRepository},

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

@@ -1,83 +0,0 @@
-package check
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-// 1930/AC3: given a check ask whose stored end keeps the digest's packages as a list of {package, digest} (issue 1930),
-// or one stored before it with the packages a map keyed by package path, when the same heads are checked a second time,
-// then the kept verdicts the first check wrote are read from it: every package it passed is kept, none run again.
-func TestKeptVerdictsAreReadFromTheDigestsListForm(t *testing.T) {
-	for _, tc := range []struct {
-		name string
-		old  bool
-	}{{"the list form", false}, {"a map stored before issue 1930", true}} {
-		t.Run(tc.name, func(t *testing.T) {
-			b := newBench(t)
-			var stored []string
-			b.asks.Answer = func(a delivery.StepAsk) delivery.Step {
-				s := b.answer(a)
-				if tc.old && s.State == delivery.StepPassed {
-					s.Result = oldDigestForm(t, s.Result)
-				}
-				stored = append(stored, string(s.Result))
-				return s
-			}
-			first := b.judge(t, caseOf(t, pullOf(repoA, 7, head1))).Verdict
-			u := first.Levels[delivery.LevelUnit]
-			if first.State != delivery.VerdictPass || u.Run == 0 || u.Kept != 0 {
-				t.Fatalf("the first check = %+v", first)
-			}
-			if len(stored) == 0 {
-				t.Fatal("no ask's end was stored")
-			}
-			list := strings.Contains(stored[0], `"packages":[{"package":"fixture/slow"`)
-			if list == tc.old || strings.Contains(stored[0], `"fixture/slow":"`) != tc.old {
-				t.Fatalf("the stored end is not in the form under test: %s", stored[0])
-			}
-			b.steps.calls = nil
-			second := b.judge(t, caseOf(t, pullOf(repoA, 7, head1))).Verdict
-			if s := second.Levels[delivery.LevelUnit]; second.State != delivery.VerdictPass || s.Kept != u.Run || s.Run != 0 {
-				t.Fatalf("the second check's unit level = %+v, want %d kept and none run", s, u.Run)
-			}
-			if n := len(b.steps.tool("test")); n != 0 {
-				t.Errorf("%d test steps ran on the second check", n)
-			}
-		})
-	}
-}
-
-// oldDigestForm rewrites a check answer's level digests to the form stored before issue 1930: packages as a map keyed by
-// package path.
-func oldDigestForm(t *testing.T, result json.RawMessage) json.RawMessage {
-	t.Helper()
-	var a struct {
-		Fetch  json.RawMessage  `json:"fetch"`
-		Levels []map[string]any `json:"levels"`
-	}
-	if err := json.Unmarshal(result, &a); err != nil {
-		t.Fatal(err)
-	}
-	for _, l := range a.Levels {
-		d, ok := l["digest"].(map[string]any)
-		if !ok {
-			continue
-		}
-		m := map[string]any{}
-		list, _ := d["packages"].([]any)
-		for _, p := range list {
-			pd := p.(map[string]any)
-			m[pd["package"].(string)] = pd["digest"]
-		}
-		d["packages"] = m
-	}
-	raw, err := json.Marshal(a)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return raw
-}

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

@@ -1,7 +1,6 @@
 package check
 
 import (
-	"encoding/json"
 	"strings"
 	"testing"
 
@@ -55,19 +54,3 @@ 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
-	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" {
-		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)
-	}
-}

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

@@ -447,11 +447,13 @@ func (st *state) level(ctx context.Context, t *target, la delivery.LevelAnswer)
 		return fail(t.node, fmt.Sprintf("the check of %s#%d answered the level %q, which is no level", t.pull.Repository, t.pull.Number, level)), 0
 	}
 	var digests map[string]string
-	if t.module == buildrun.GoBuildModule && la.Digest != nil {
+	if t.module == buildrun.GoBuildModule && len(la.Digest) > 0 {
-		// The packages come as a list, never keyed by a package path (issue 1930); an answer stored before reads too.
+		var d Digested
-		digests = la.Digest.Map()
+		if err := json.Unmarshal(la.Digest, &d); err == nil {
-		if t.runner != "" {
+			digests = d.Packages
-			t.judgedBy(la.Digest.JudgedBy) // the installed module judged it: the runner is not used again
+			if t.runner != "" {
+				t.judgedBy(d.JudgedBy) // the installed module judged it: the runner is not used again
+			}
 		}
 	}
 	if t.runner != "" && la.Judged != "" {

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

@@ -244,39 +244,6 @@ func TestTheSiblingsAreWhereTheTestsStateThem(t *testing.T) { // review D2, ADR
 	}
 }
 
-// 1295/R4g: the node-engine's tests read the controller's manifest, so a mesh-host pull request has mesh-controller beside it:
-// at the group member's head when the group holds one, else at its trunk.
-func hostCase(t *testing.T, pulls ...delivery.CandidatePull) *Case {
-	t.Helper()
-	c, err := delivery.DecodeCandidate(candidateOf(t, "feat/x", pulls...))
-	if err != nil {
-		t.Fatal(err)
-	}
-	cs := CaseOf(c, map[string]string{"novox/mesh-host": trunkA, controllerRepo: trunkA2})
-	if cs == nil {
-		t.Fatal("no case")
-	}
-	return cs
-}
-
-func TestTheNodeEnginesTestsHaveTheControllerBesideThem(t *testing.T) {
-	const host = "novox/mesh-host"
-	b := newBench(t)
-	b.ex.Trunks = trunksOf(t, map[string]string{host: trunkA, controllerRepo: trunkA2, catalogueRepository: trunkS, SDKRepository: trunkS})
-	b.judge(t, hostCase(t, pullOf(host, 5, head1)))
-	if c := besideOf(t, b, host)[controllerRepo]; c.Commit != trunkA2 || c.Ref != "" {
-		t.Errorf("the controller beside the node-engine alone = %+v, want its trunk %s", c, trunkA2)
-	}
-	b = newBench(t)
-	b.ex.Trunks = trunksOf(t, map[string]string{host: trunkA, controllerRepo: trunkA2, catalogueRepository: trunkS, SDKRepository: trunkS})
-	b.ex.Forge = &fakeForge{goMods: map[string]string{controllerRepo + " go.mod " + head2: capturedGoMod(t, "cb54756c3865")},
-		onTrunk: map[string]bool{"cb54756c3865": true}}
-	b.judge(t, hostCase(t, pullOf(host, 5, head1), pullOf(controllerRepo, 9, head2)))
-	if c := besideOf(t, b, host)[controllerRepo]; c.Commit != head2 || c.Ref != "refs/pull/9/head" {
-		t.Errorf("the controller beside the node-engine in a group = %+v, want the member's head %s", c, head2)
-	}
-}
-
 func TestThePinOfTheControllerThatCannotBeReadFailsTheCheck(t *testing.T) { // review D2
 	b := newBench(t)
 	b.ex.Trunks = trunksOf(t, map[string]string{"novox/mesh-controller": trunkA})

modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/integration_test.go

@@ -478,74 +478,3 @@ func TestAMergeOfMeshSDKChangingOnlyGoLeavesItsNamedTreeEqual(t *testing.T) {
 		t.Errorf("the new form moved: %q/%q, then %q/%q", first.FP2, first.None2, second.FP2, second.None2)
 	}
 }
-
-// TestIndexerJudgesAnUnreadableVerdictAgainAtStart: the modules bucket holds avahi as an older SDK wrote it, with the reason
-// 'the manifest cannot be read', the inputs the merge carried (the tree, the lock hash by file name) and the digest of its
-// manifest, which manifests.<digest> holds and the running SDK reads; the go toolchain is reported. Within 5 s of the start
-// and with no repository merge the value carries a fingerprint and no reason (issue 1923).
-func TestIndexerJudgesAnUnreadableVerdictAgainAtStart(t *testing.T) { // 1923/AC3
-	manifest, err := os.ReadFile("../../internal/index/testdata/catalogue-a67f0196-avahi.module.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-	const goSum = "3b5028f0c1e9bde04dd766abd63eb5931bc516bae695cf46f00abcd8510b0381"
-	digest := delivery.ManifestDigest(manifest)
-	_, ctx, _, modules := startIndexer(t, func(context.Context, jetstream.KeyValue) {}, func(ctx context.Context, js jetstream.JetStream) {
-		mkey, err := delivery.ManifestsKey(digest)
-		if err != nil {
-			t.Fatal(err)
-		}
-		mdata, err := delivery.EncodeManifest(delivery.Manifest{Module: "avahi", JSON: string(manifest)})
-		if err != nil {
-			t.Fatal(err)
-		}
-		manifests, err := js.KeyValue(ctx, delivery.ManifestsBucket)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := manifests.Put(ctx, mkey, mdata); err != nil {
-			t.Fatal(err)
-		}
-		stale, err := delivery.EncodeModule(delivery.Module{Repository: "novox/mesh-catalog", Commit: "89abcdef0123456789abcdef0123456789abcdef", Path: "modules/avahi",
-			Manifest: digest, None2: "the manifest cannot be read: claims node-build-go, which is a seat in the mesh's own namespace that it does not define",
-			Inputs2: &delivery.KeptInputs2{Tree: "tree-avahi", Locks: map[string]string{"go.sum": goSum}}})
-		if err != nil {
-			t.Fatal(err)
-		}
-		held, err := js.KeyValue(ctx, delivery.ModulesBucket)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := held.Put(ctx, "avahi", stale); err != nil {
-			t.Fatal(err)
-		}
-		kv, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: delivery.ToolchainsBucket("mesh-build-go"), History: 1})
-		if err != nil {
-			t.Fatal(err)
-		}
-		key, err := delivery.ToolchainKey("n1", "go")
-		if err != nil {
-			t.Fatal(err)
-		}
-		value, err := delivery.EncodeToolchain(delivery.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "1", At: time.Now()})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := kv.Put(ctx, key, value); err != nil {
-			t.Fatal(err)
-		}
-	})
-	var got delivery.Module
-	for deadline := time.Now().Add(5 * time.Second); time.Now().Before(deadline); time.Sleep(50 * time.Millisecond) {
-		if e, err := modules.Get(ctx, "avahi"); err == nil {
-			if m, err := delivery.DecodeModule(e.Value()); err == nil {
-				if got = m; got.FP2 != "" {
-					break
-				}
-			}
-		}
-	}
-	if got.FP2 == "" || got.None2 != "" {
-		t.Errorf("avahi = fp2 %q none2 %q within 5 s of the start, want a fingerprint and no reason", got.FP2, got.None2)
-	}
-}

modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/main.go

@@ -2,9 +2,6 @@
 // bridge's messages on the stream FORGE and keeps the candidate groups (candidates.<group>): the pull requests that share
 // a branch, their heads and the modules each touches. It reads the controller's builds to know which module a changed
 // directory is. It serves no request subject and holds no timer: every reaction is a message or a watch (ADR 0437 §8).
-//
-// Its build of 2026-10-24 00:37 named a program whose push never reached the artifact store, and a retry sends that
-// same build again; this paragraph was added only to give the indexer a new build (issue 1933).
 package main
 
 import (
@@ -291,7 +288,7 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	}
 	defer calls.Close()
 	ix := &index.Indexer{Store: kvStore{candidates}, Modules: kvStore{modules}, Manifests: kvStore{manifests}, Builds: known, Logf: logger.Printf,
-		Named: namedVia(calls.Call), Trunk: trunkVia(calls.Call), Contains: containsVia(calls.Call)}
+		Named: namedVia(calls.Call)}
 	// The gate's source bucket (mesh-delivery-gate_source) comes with the gate (release 3e, novox/hq ADR 0450 §1): its key
 	// main is the mesh's source revision, which stamps the modules (issue 1344). Where it does not exist yet the indexer does
 	// not wait for it (that needs a timer, ADR 0437 §8): it says so, and is started again with the gate.
@@ -328,10 +325,6 @@ func run(ctx context.Context, getenv func(string) string, logOut io.Writer) erro
 	if err := ix.RecomputeAtStart(ctx); err != nil {
 		logger.Printf("computing the new-form fingerprints at start: %v", err)
 	}
-	// The modules the trunk no longer holds go from the bucket (issue 1900); a merge does the same from its own message.
-	if err := ix.Reconcile(ctx); err != nil {
-		logger.Printf("dropping the modules the trunk does not hold at start: %v", err)
-	}
 	// A build module says each time it wrote its toolchains key: its stream, and the indexer's durable consumer on it, are
 	// made by the controller as the forge's are. Where the stream is not there yet the indexer says so and is started again
 	// with the build module, as with the gate's source.

modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/named.go

@@ -46,50 +46,3 @@ func namedVia(call toolCaller) func(ctx context.Context, repository, sha string,
 		return a.Paths, nil
 	}
 }
-
-// trunkVia asks the forge for the module directories of a commit (issue 1900): the keys of the `trees` the same tool
-// answers without paths, one per directory that holds a module.json (the root as ""; the tool lists no other).
-func trunkVia(call toolCaller) func(ctx context.Context, repository, sha string) ([]string, error) {
-	return func(_ context.Context, repository, sha string) ([]string, error) {
-		owner, repo, ok := strings.Cut(delivery.RepositoryName(repository), "/")
-		if !ok {
-			return nil, fmt.Errorf("%q is not <owner>/<name>", repository)
-		}
-		raw, err := call(commitTreesTool, map[string]any{"owner": owner, "repo": repo, "sha": sha})
-		if err != nil {
-			return nil, err
-		}
-		var a struct {
-			Trees map[string]string `json:"trees"`
-		}
-		if err := json.Unmarshal(raw, &a); err != nil {
-			return nil, fmt.Errorf("the answer of %s is not {root, trees}: %w", commitTreesTool, err)
-		}
-		dirs := make([]string, 0, len(a.Trees))
-		for dir := range a.Trees {
-			dirs = append(dirs, dir)
-		}
-		return dirs, nil
-	}
-}
-
-// containsVia asks the forge whether a commit is in another (gitea.gitea_contains: contains is true for the same commit or an ancestor).
-func containsVia(call toolCaller) func(ctx context.Context, repository, commit, in string) (bool, error) {
-	return func(_ context.Context, repository, commit, in string) (bool, error) {
-		owner, repo, ok := strings.Cut(delivery.RepositoryName(repository), "/")
-		if !ok {
-			return false, fmt.Errorf("%q is not <owner>/<name>", repository)
-		}
-		raw, err := call("gitea.gitea_contains", map[string]any{"owner": owner, "repo": repo, "commit": commit, "in": in})
-		if err != nil {
-			return false, err
-		}
-		var a struct {
-			Contains *bool `json:"contains"`
-		}
-		if err := json.Unmarshal(raw, &a); err != nil || a.Contains == nil {
-			return false, fmt.Errorf("the answer of gitea.gitea_contains names no contains: %v", err)
-		}
-		return *a.Contains, nil
-	}
-}

modules/mesh-delivery-indexer/cmd/mesh-delivery-indexer/named_test.go

@@ -3,8 +3,6 @@ package main
 import (
 	"context"
 	"encoding/json"
-	"slices"
-	"strings"
 	"testing"
 )
 
@@ -31,22 +29,3 @@ func TestNamedViaAsksTheTreesToolWithThePathsAndTakesTheirObjects(t *testing.T)
 		t.Error("an answer missing a path asked was taken")
 	}
 }
-
-func TestTheTrunkIsTheDirectoriesTheForgeListsTrees(t *testing.T) { // 1900/AC3
-	var gotArgs any
-	call := func(key string, body any) (json.RawMessage, error) {
-		gotArgs = body
-		return json.RawMessage(`{"root":"r","trees":{"modules/a":"x","modules/b":"y"}}`), nil
-	}
-	dirs, err := trunkVia(call)(context.Background(), "novox/mesh-catalog", strings.Repeat("a", 40))
-	if err != nil {
-		t.Fatal(err)
-	}
-	slices.Sort(dirs)
-	if !slices.Equal(dirs, []string{"modules/a", "modules/b"}) {
-		t.Errorf("dirs = %v", dirs)
-	}
-	if _, has := gotArgs.(map[string]any)["paths"]; has {
-		t.Error("the trunk asked for paths")
-	}
-}

modules/mesh-delivery-indexer/internal/index/candidates.go

@@ -52,10 +52,7 @@ type Indexer struct {
 	// manifest's paths (ADR 0495 clause 1, the lead's decision L8 of R4e). Nil asks nothing, and a module naming paths
 	// has none.
 	Named func(ctx context.Context, repository, sha string, paths map[string][]string) (map[string]map[string]string, error)
-	Trunk func(ctx context.Context, repository, sha string) ([]string, error)
+	Logf  func(format string, args ...any)
-	// Contains says whether a commit is the second or an ancestor of it (gitea.gitea_contains).
-	Contains func(ctx context.Context, repository, commit, in string) (bool, error)
-	Logf     func(format string, args ...any)
 
 	mu         sync.Mutex // guards source, toolchains and previews, which the watches and the forge messages all reach
 	source     sourceNow

modules/mesh-delivery-indexer/internal/index/inputs.go

@@ -69,7 +69,7 @@ func inputsOf(module, raw, tree string, locks map[string]string, base baseFP) mo
 func inputsOfNamed(module, raw, tree string, locks, objects map[string]string, base baseFP) moduleInputs {
 	m, err := catalogue.ParseManifestForInputs([]byte(raw))
 	if err != nil {
-		return moduleInputs{None2: None2Unreadable + err.Error()}
+		return moduleInputs{None2: "the manifest cannot be read: " + err.Error()}
 	}
 	if m.Module != module {
 		return moduleInputs{None2: fmt.Sprintf("the manifest is of module %q, not %q", m.Module, module)}

modules/mesh-delivery-indexer/internal/index/inputs_test.go

@@ -111,8 +111,7 @@ func TestABaseEntersByTheFingerprintOfItsModuleOrNamesItsAbsence(t *testing.T) {
 	}
 	// Through the indexer: modules.mesh-tools holds a fingerprint of the new form (a record written by a later release).
 	ix, mods, _ := manifestsIndexer(t, rec(t, "build-1", "avahi", catalogueRepo, "modules/avahi", "main", "", "2026-10-19T09:00:00Z", aInputs))
-	mods.put("mesh-tools", mustEncode(t, delivery.Module{Repository: "novox/mesh-tools", // a base held of another repository stays when the catalogue merges (issue 1900)
+	mods.put("mesh-tools", mustEncode(t, delivery.Module{Repository: catalogueRepo, Commit: merge, None: "x", FP2: fp, Manifest: strings.Repeat("a", 64)}))
-		Commit: merge, None: "x", FP2: fp, Manifest: strings.Repeat("a", 64)}))
 	f := withManifests(mergedMsg(catalogueRepo, map[string]string{"modules/avahi": "t"}), map[string]string{"modules/avahi": aModuleWithABase(t)}, nil)
 	if err := ix.Apply(context.Background(), f); err != nil {
 		t.Fatal(err)

modules/mesh-delivery-indexer/internal/index/modules.go

@@ -2,10 +2,8 @@ package index
 
 import (
 	"context"
-	"fmt"
 	"maps"
 	"slices"
-	"strings"
 
 	"git.novox.be/novox/mesh-sdk/go/catalogue"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
@@ -35,22 +33,18 @@ func (ix *Indexer) applyMerged(ctx context.Context, f delivery.Forge) error {
 	objects, namedErr := ix.namedObjects(ctx, f)
 	overlay := map[string]delivery.Module{}
 	dirOf := map[string]string{}
-	named, every := map[string]bool{}, true // every module the message's manifests name, and whether each names one
 	for _, dir := range slices.Sorted(maps.Keys(f.Manifests)) {
 		raw := f.Manifests[dir]
 		name := manifestModule(raw)
 		if name == "" {
 			ix.logf("%s at %s: the manifest in %q names no module, so no module is written for it", f.Repository, f.Merge, dir)
-			every = false
 			continue
 		}
 		key, err := delivery.ModulesKey(name)
 		if err != nil {
-			every = false
 			ix.logf("%s: the module %q has no usable key, skipped: %v", f.Repository, name, err)
 			continue
 		}
-		named[key] = true
 		cur, has := held[key]
 		if has && cur.Repository != "" && !delivery.SameRepository(cur.Repository, f.Repository) {
 			ix.logf("%s at %s: %q names the module %s, which the indexer holds of %s; left as it is (a move between repositories is the operator's)", f.Repository, f.Merge, dir, name, cur.Repository)
@@ -70,24 +64,12 @@ func (ix *Indexer) applyMerged(ctx context.Context, f delivery.Forge) error {
 		} else {
 			in := inputsOfNamed(name, raw, f.Trees[dir], f.Locks[dir], objects[dir], ix.baseFP(ctx))
 			next.Inputs2, next.None2, next.ArtifactPaths = in.Kept, in.None2, in.ArtifactPaths
-			if in.Kept == nil && strings.HasPrefix(in.None2, None2Unreadable) {
-				// The manifest cannot be read by this SDK; the inputs the merge carried are kept all the same, so a later SDK
-				// that reads it judges the module again at start with no merge (issue 1923).
-				next.Inputs2 = unreadInputs(f.Trees[dir], f.Locks[dir], f.Paths[dir])
-			}
 			if in.Kept == nil && namedErr[dir] != "" {
 				next.None2 = in.None2 + ": the forge could not say them: " + namedErr[dir]
 			}
 		}
 		overlay[key] = next
 	}
-	// A module of this repository the merge commit holds no module.json for is gone from the trunk, and so is its key
-	// (issue 1900). A message that carries no manifests (an older writer) or one that cannot be read whole says nothing.
-	if len(f.Manifests) > 0 && every {
-		if err := ix.dropRemoved(ctx, f.Repository, held, func(key string, _ delivery.Module) bool { return named[key] }); err != nil {
-			return err
-		}
-	}
 	// What this merge moved reaches the modules standing on it (a base's tree, build-agent's fingerprint), in the graph's order.
 	return ix.recomputeWith(ctx, overlay)
 }
@@ -167,115 +149,3 @@ func (ix *Indexer) namedObjects(ctx context.Context, f delivery.Forge) (map[stri
 	}
 	return objects, nil
 }
-
-// dropRemoved deletes, from the modules the bucket holds of the repository, each one the trunk no longer holds (issue 1900):
-// held(key, module) says whether the trunk holds it. A module of another repository, or of none known, is never touched.
-func (ix *Indexer) dropRemoved(ctx context.Context, repository string, held map[string]delivery.Module, trunkHolds func(key string, m delivery.Module) bool) error {
-	for _, key := range slices.Sorted(maps.Keys(held)) {
-		cur := held[key]
-		if cur.Repository == "" || !delivery.SameRepository(cur.Repository, repository) || trunkHolds(key, cur) {
-			continue
-		}
-		err := write(ctx, ix.Modules, key, func(value []byte, found bool) ([]byte, bool, error) {
-			if !found {
-				return nil, false, nil
-			}
-			if m, err := delivery.DecodeModule(value); err != nil || !delivery.SameRepository(m.Repository, repository) {
-				return nil, false, nil
-			}
-			return nil, true, nil
-		})
-		if err != nil {
-			return fmt.Errorf("modules.%s: %w", key, err)
-		}
-		ix.logf("modules.%s deleted: %s holds no module of that name at its trunk (issue 1900)", key, repository)
-	}
-	return nil
-}
-
-// Reconcile deletes the modules keys whose module the trunk does not hold, for each repository the latest source names a
-// head of: the module directories at that head are asked of the forge (Trunk), and a module of the repository whose
-// directory is not among them goes (issue 1900). It is run at the indexer's start; a merge does the same from its own
-// message (applyMerged). A repository whose trunk cannot be read, or reads as holding no module at all, is left as it is
-// and said: a failure never empties the bucket.
-func (ix *Indexer) Reconcile(ctx context.Context) error {
-	if ix.Modules == nil || ix.Trunk == nil {
-		return nil
-	}
-	ix.mu.Lock()
-	heads := maps.Clone(ix.source.heads)
-	ix.mu.Unlock()
-	held, err := ix.heldModules(ctx)
-	if err != nil {
-		return err
-	}
-	for _, repository := range slices.Sorted(maps.Keys(heads)) {
-		mine := map[string]delivery.Module{}
-		for key, m := range held {
-			if m.Repository != "" && delivery.SameRepository(m.Repository, repository) {
-				mine[key] = m
-			}
-		}
-		if len(mine) == 0 {
-			continue
-		}
-		dirs, err := ix.Trunk(ctx, repository, heads[repository])
-		if err != nil {
-			ix.logf("%s at %s: the modules of the trunk cannot be read, so none is dropped: %v", repository, heads[repository], err)
-			continue
-		}
-		if len(dirs) == 0 {
-			ix.logf("%s at %s: the trunk reads as holding no module, so none is dropped", repository, heads[repository])
-			continue
-		}
-		there := map[string]bool{}
-		for _, d := range dirs {
-			there[pathOf(strings.Trim(d, "/"))] = true
-		}
-		head := heads[repository]
-		// The source can lag a merge already applied: a key written at a commit the head read does not hold (a merge heard
-		// first) is not read as removed, only one whose commit the head is, or contains.
-		stays := func(_ string, m delivery.Module) bool {
-			if m.Path == "" || there[m.Path] {
-				return true
-			}
-			if m.Commit == head {
-				return false
-			}
-			if m.Commit == "" || ix.Contains == nil {
-				return true
-			}
-			in, err := ix.Contains(ctx, repository, m.Commit, head)
-			if err != nil {
-				ix.logf("%s: whether %s is in %s cannot be read, so the module at %s is kept: %v", repository, m.Commit, head, m.Path, err)
-				return true
-			}
-			return !in
-		}
-		if err := ix.dropRemoved(ctx, repository, mine, stays); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// None2Unreadable begins the reason of a module whose manifest the running SDK cannot read.
-const None2Unreadable = "the manifest cannot be read: "
-
-// unreadInputs are the inputs a merge carried for a module whose manifest cannot be read: the directory's tree, the lock
-// hashes by file name (the artifacts that own them are not known without the manifest) and the objects of the named
-// paths the message carried; nil when the message carried no tree. Judging the manifest again (rejudged) turns them into
-// the inputs of the module (issue 1923).
-func unreadInputs(tree string, locks, paths map[string]string) *delivery.KeptInputs2 {
-	if tree == "" {
-		return nil
-	}
-	in := &delivery.KeptInputs2{Tree: tree}
-	if len(locks) > 0 {
-		in.Locks = maps.Clone(locks)
-	}
-	if len(paths) > 0 {
-		in.Paths = maps.Clone(paths)
-	}
-	return in
-}

modules/mesh-delivery-indexer/internal/index/remove_test.go

@@ -1,144 +0,0 @@
-package index
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	"git.novox.be/novox/mesh-sdk/go/delivery"
-)
-
-func twoModules(t *testing.T) (*Indexer, *memStore) {
-	t.Helper()
-	ix, mods := modulesIndexer(t)
-	if err := ix.Apply(context.Background(), mergedMsg(catalogueRepo, map[string]string{"modules/a": "t", "modules/b": "t"})); err != nil {
-		t.Fatal(err)
-	}
-	for _, k := range []string{"a", "b"} {
-		if _, ok := mods.vals[k]; !ok {
-			t.Fatalf("setup: modules.%s not written", k)
-		}
-	}
-	return ix, mods
-}
-
-func TestAMergeThatRemovesAModuleDeletesItsKey(t *testing.T) { // 1900/AC1
-	ix, mods := twoModules(t)
-	if err := ix.Apply(context.Background(), mergedMsg(catalogueRepo, map[string]string{"modules/a": "t2"})); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := mods.vals["b"]; ok {
-		t.Error("modules.b is still held after a merge whose trunk has no module b")
-	}
-	if _, ok := mods.vals["a"]; !ok {
-		t.Error("modules.a, which the trunk still holds, was deleted")
-	}
-}
-
-func TestAMergeLeavesTheModulesOfAnotherRepository(t *testing.T) { // 1900/AC1 (scope)
-	ix, mods := twoModules(t)
-	if err := ix.Apply(context.Background(), mergedMsg("novox/mesh-delivery", map[string]string{"modules/c": "t"})); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := mods.vals["a"]; !ok {
-		t.Error("a merge of another repository deleted modules.a")
-	}
-	if _, ok := mods.vals["b"]; !ok {
-		t.Error("a merge of another repository deleted modules.b")
-	}
-}
-
-func TestAMergeWithoutManifestsDeletesNothing(t *testing.T) { // 1900/AC1: older writers send none, which does not say the trunk is empty
-	ix, mods := twoModules(t)
-	f := mergedMsg(catalogueRepo, map[string]string{"modules/a": "t2"})
-	f.Manifests = nil
-	if err := ix.Apply(context.Background(), f); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := mods.vals["b"]; !ok {
-		t.Error("a merge message with no manifests deleted modules.b")
-	}
-}
-
-func TestAPathWithoutAModuleJSONIsNeverAModule(t *testing.T) { // 1900/AC2: testdata such as fixture-build
-	ix, mods := twoModules(t)
-	f := mergedMsg(catalogueRepo, map[string]string{"modules/a": "t2"})
-	f.Trees["testdata/fixture-build"] = "t" // a directory in the tree whose module.json the message does not carry
-	if err := ix.Apply(context.Background(), f); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := mods.vals["fixture-build"]; ok {
-		t.Error("modules.fixture-build written for a path without a module.json")
-	}
-}
-
-func TestStartingDeletesTheKeysTheTrunkDoesNotHold(t *testing.T) { // 1900/AC3
-	ix, mods := twoModules(t)
-	ctx := context.Background()
-	if err := ix.ApplySource(ctx, 3, sourceOf(catalogueRepo, merge)); err != nil {
-		t.Fatal(err)
-	}
-	var asked string
-	ix.Trunk = func(_ context.Context, repository, sha string) ([]string, error) {
-		asked = repository + "@" + sha
-		return []string{"modules/a"}, nil
-	}
-	ix.Contains = func(context.Context, string, string, string) (bool, error) { return true, nil }
-	if err := ix.Reconcile(ctx); err != nil {
-		t.Fatal(err)
-	}
-	if asked != catalogueRepo+"@"+merge {
-		t.Errorf("the trunk was asked as %q, want the source's head of the repository", asked)
-	}
-	if _, ok := mods.vals["b"]; ok {
-		t.Error("modules.b is still held though the trunk holds no module at modules/b")
-	}
-	if _, ok := mods.vals["a"]; !ok {
-		t.Error("modules.a was deleted")
-	}
-}
-
-func TestStartingDeletesNothingWhenTheTrunkCannotBeRead(t *testing.T) { // 1900/AC3: failure is loud, never a mass delete
-	ix, mods := twoModules(t)
-	ctx := context.Background()
-	if err := ix.ApplySource(ctx, 3, sourceOf(catalogueRepo, merge)); err != nil {
-		t.Fatal(err)
-	}
-	for name, trunk := range map[string]func(context.Context, string, string) ([]string, error){
-		"an error":         func(context.Context, string, string) ([]string, error) { return nil, errors.New("forge down") },
-		"no module at all": func(context.Context, string, string) ([]string, error) { return nil, nil },
-	} {
-		ix.Trunk = trunk
-		_ = ix.Reconcile(ctx)
-		if len(mods.vals) != 2 {
-			t.Errorf("%s: %d keys held, want 2 untouched", name, len(mods.vals))
-		}
-	}
-	_ = delivery.RootPath
-}
-
-func TestAKeyWrittenAheadOfTheSourceHeadStaysAndOneWithoutAPathIsSkipped(t *testing.T) { // 1900/AC3 (review): the source lags a merge already applied
-	ix, mods := twoModules(t) // written at the merge commit C
-	ctx := context.Background()
-	const older = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
-	if err := ix.ApplySource(ctx, 3, sourceOf(catalogueRepo, older)); err != nil {
-		t.Fatal(err)
-	}
-	mods.put("nopath", mustEncode(t, delivery.Module{Repository: catalogueRepo, Commit: older, None2: "x", Manifest: strings.Repeat("a", 64)}))
-	ix.Trunk = func(context.Context, string, string) ([]string, error) { return []string{"modules/a"}, nil }
-	ix.Contains = func(_ context.Context, _, commit, in string) (bool, error) { return commit == in, nil } // C is not in B
-	if err := ix.Reconcile(ctx); err != nil {
-		t.Fatal(err)
-	}
-	for _, k := range []string{"a", "b", "nopath"} {
-		if _, ok := mods.vals[k]; !ok {
-			t.Errorf("modules.%s was deleted", k)
-		}
-	}
-	ix.Contains = func(context.Context, string, string, string) (bool, error) { return false, errors.New("forge down") }
-	_ = ix.Reconcile(ctx)
-	if _, ok := mods.vals["b"]; !ok {
-		t.Error("modules.b deleted though whether its commit is in the head cannot be read")
-	}
-}

modules/mesh-delivery-indexer/internal/index/stale_none2_test.go

@@ -1,77 +0,0 @@
-package index
-
-import (
-	"context"
-	"strings"
-	"testing"
-)
-
-// unreadableAvahi is avahi's manifest with a field the running parser refuses: the shape of a manifest an older SDK could
-// not read.
-func unreadableAvahi(t *testing.T) string {
-	t.Helper()
-	raw := strings.Replace(catalogueManifest(t, "avahi"), `"version": "1",`, `"version": "1", "scope": "everything",`, 1)
-	if raw == catalogueManifest(t, "avahi") {
-		t.Fatal("the fixture has no version line")
-	}
-	return raw
-}
-
-func TestAMergeOfAnUnreadableManifestKeepsTheInputsBesideTheReason(t *testing.T) { // 1923/AC1
-	_, mods := newFormIndexer(t, mod{"avahi", unreadableAvahi(t)})
-	m, ok := moduleOf(t, mods, "avahi")
-	if !ok || !strings.HasPrefix(m.None2, "the manifest cannot be read: ") || m.FP2 != "" {
-		t.Fatalf("module = %+v, want the reason 'the manifest cannot be read' and no fingerprint", m)
-	}
-	if m.Inputs2 == nil || m.Inputs2.Tree != "tree-avahi" || m.Inputs2.Locks["go.sum"] != avahiGoSum {
-		t.Errorf("inputs = %+v, want the directory's tree and its lock hashes kept", m.Inputs2)
-	}
-}
-
-func TestAStaleUnreadableVerdictIsJudgedAgainAtStartAndAnotherReasonIsLeft(t *testing.T) { // 1923/AC2
-	ctx := context.Background()
-	// The fingerprint a merge of the readable manifest gives.
-	ixGood, good := newFormIndexer(t, mod{"avahi", catalogueManifest(t, "avahi")})
-	reportToolchain(t, ixGood, "mesh-build-go", "novox", "go", "go1.27.1")
-	reportToolchain(t, ixGood, "mesh-build-go", "ace", "go", "go1.27.1")
-	want, _ := moduleOf(t, good, "avahi")
-	if want.FP2 == "" {
-		t.Fatalf("the readable manifest gives no fingerprint: %+v", want)
-	}
-
-	// The same module as an older SDK wrote it: the reason, the inputs kept at the merge, the manifest stored by digest.
-	ix, mods := newFormIndexer(t, mod{"avahi", unreadableAvahi(t)})
-	reportToolchain(t, ix, "mesh-build-go", "novox", "go", "go1.27.1")
-	reportToolchain(t, ix, "mesh-build-go", "ace", "go", "go1.27.1")
-	stale, _ := moduleOf(t, mods, "avahi")
-	stale.Manifest = want.Manifest
-	ix.Manifests.(*memStore).put(want.Manifest, good2(t, ixGood, want.Manifest))
-	mods.put("avahi", mustEncode(t, stale))
-	if err := ix.Recompute(ctx); err != nil {
-		t.Fatal(err)
-	}
-	got, _ := moduleOf(t, mods, "avahi")
-	if got.FP2 != want.FP2 || got.None2 != "" {
-		t.Errorf("after the start: fp2 %q none2 %q, want %q and no reason", got.FP2, got.None2, want.FP2)
-	}
-
-	// A manifest still unreadable keeps its value as it was.
-	ix2, mods2 := newFormIndexer(t, mod{"avahi", unreadableAvahi(t)})
-	before := string(mods2.vals["avahi"])
-	if err := ix2.Recompute(ctx); err != nil {
-		t.Fatal(err)
-	}
-	if after := string(mods2.vals["avahi"]); after != before {
-		t.Errorf("a manifest still unreadable changed the value:\n%s\n%s", before, after)
-	}
-}
-
-// good2 is the stored manifest value of the digest in the indexer that merged the readable manifest.
-func good2(t *testing.T, ix *Indexer, digest string) []byte {
-	t.Helper()
-	v, _, found, err := ix.Manifests.Get(context.Background(), digest)
-	if err != nil || !found {
-		t.Fatalf("manifests.%s: %v %v", digest, found, err)
-	}
-	return v
-}

modules/mesh-delivery-indexer/internal/index/toolchains.go

@@ -156,7 +156,6 @@ func (ix *Indexer) recomputeModules(ctx context.Context, overlay map[string]deli
 	}
 	slices.Sort(keys)
 	held := map[string]delivery.Module{}
-	stale := map[string]bool{} // values an SDK that could not read their manifest wrote, judged again (issue 1923)
 	all := map[string]*known{}
 	for _, key := range keys {
 		cur, ok := overlay[key]
@@ -177,15 +176,11 @@ func (ix *Indexer) recomputeModules(ctx context.Context, overlay map[string]deli
 		if cur.Manifest == "" || cur.Inputs2 == nil {
 			continue
 		}
-		raw, m, err := ix.manifestRaw(ctx, cur.Manifest)
+		m, err := ix.manifestOf(ctx, cur.Manifest)
 		if err != nil {
 			ix.logf("modules.%s: its manifest %s cannot be read, left: %v", key, cur.Manifest, err)
 			continue
 		}
-		if again, ok := ix.rejudged(ctx, m, cur, raw); ok {
-			cur, stale[key] = again, true
-			held[key] = cur
-		}
 		all[key] = &known{key: key, cur: cur, languages: languagesOf(m), bases: basesOf(m), contexts: hasContext(m)}
 	}
 	tools := ix.agreed()
@@ -280,10 +275,10 @@ func (ix *Indexer) recomputeModules(ctx context.Context, overlay map[string]deli
 			finals[key] = final
 			continue
 		}
-		if !stale[key] && k.cur.FP2 == r.fp && k.cur.None2 == r.none && reflect.DeepEqual(k.cur.Toolchains, r.tcs) {
+		if k.cur.FP2 == r.fp && k.cur.None2 == r.none && reflect.DeepEqual(k.cur.Toolchains, r.tcs) {
 			continue
 		}
-		digest, inputs, paths := k.cur.Manifest, k.cur.Inputs2, k.cur.ArtifactPaths
+		digest, inputs := k.cur.Manifest, k.cur.Inputs2
 		err := write(ctx, ix.Modules, key, func(value []byte, found bool) ([]byte, bool, error) {
 			if !found {
 				return nil, false, nil
@@ -296,7 +291,7 @@ func (ix *Indexer) recomputeModules(ctx context.Context, overlay map[string]deli
 				return nil, false, nil
 			}
 			cur.FP2, cur.None2, cur.Toolchains = r.fp, r.none, r.tcs
-			cur.Inputs2, cur.ArtifactPaths = inputs, paths
+			cur.Inputs2 = inputs
 			data, err := delivery.EncodeModule(cur)
 			return data, false, err
 		})
@@ -331,41 +326,24 @@ func (ix *Indexer) writeOverlay(ctx context.Context, overlay, finals map[string]
 	return nil
 }
 
-// manifestRaw is manifests.<digest>: the manifest as stored and parsed by the running SDK.
+// manifestOf is the parsed manifest manifests.<digest> holds.
-func (ix *Indexer) manifestRaw(ctx context.Context, digest string) (string, catalogue.Manifest, error) {
+func (ix *Indexer) manifestOf(ctx context.Context, digest string) (catalogue.Manifest, error) {
 	key, err := delivery.ManifestsKey(digest)
 	if err != nil {
-		return "", catalogue.Manifest{}, err
+		return catalogue.Manifest{}, err
 	}
 	value, _, found, err := ix.Manifests.Get(ctx, key)
 	if err != nil {
-		return "", catalogue.Manifest{}, err
+		return catalogue.Manifest{}, err
 	}
 	if !found {
-		return "", catalogue.Manifest{}, fmt.Errorf("manifests.%s is not there", key)
+		return catalogue.Manifest{}, fmt.Errorf("manifests.%s is not there", key)
 	}
 	kept, err := delivery.DecodeManifest(value)
 	if err != nil {
-		return "", catalogue.Manifest{}, err
+		return catalogue.Manifest{}, err
 	}
-	m, err := catalogue.ParseManifestForInputs([]byte(kept.JSON))
+	return catalogue.ParseManifestForInputs([]byte(kept.JSON))
-	return kept.JSON, m, err
-}
-
-// rejudged is a value an SDK that could not read its manifest wrote, as the running SDK judges it: its kept inputs (the
-// tree, the lock hashes by file name, the named paths' objects) taken through the manifest as a merge takes them, and the
-// reason that gives. It answers false for any other value, and for one whose manifest the running SDK still cannot make
-// inputs of (issue 1923).
-func (ix *Indexer) rejudged(ctx context.Context, m catalogue.Manifest, cur delivery.Module, raw string) (delivery.Module, bool) {
-	if cur.FP2 != "" || cur.Inputs2 == nil || !strings.HasPrefix(cur.None2, None2Unreadable) {
-		return cur, false
-	}
-	in := inputsOfNamed(m.Module, raw, cur.Inputs2.Tree, cur.Inputs2.Locks, cur.Inputs2.Paths, ix.baseFP(ctx))
-	if in.Kept == nil {
-		return cur, false
-	}
-	cur.Inputs2, cur.None2, cur.ArtifactPaths = in.Kept, in.None2, in.ArtifactPaths
-	return cur, true
 }
 
 // hasContext is whether an artifact of the manifest reads another repository's tree.

modules/mesh-delivery-indexer/manifest_test.go

@@ -7,7 +7,6 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
-	"regexp"
 	"slices"
 	"strings"
 	"testing"
@@ -95,10 +94,9 @@ func TestManifestDeclarations(t *testing.T) { // 1238/AC1, 1444 (reads the build
 	if m.SecretsOwner != "mesh-delivery-indexer" {
 		t.Errorf("secrets-owner = %q", m.SecretsOwner)
 	}
-	// Two invokes: the forge's trees (the named paths' objects, since the indexer is the one reader of a manifest's paths:
+	// One invoke: the forge's trees with the named paths' objects, since the indexer is the one reader of a manifest's paths
-	// ADR 0499 clauses 2 and 3, ADR 0495 clause 1; and the module directories of the trunk, issue 1900) and whether a
+	// (ADR 0499 clauses 2 and 3, ADR 0495 clause 1, the lead's decision L8 of R4e).
-	// commit is in another (issue 1900).
+	if want := []string{"gitea.gitea_commit_trees"}; !reflect.DeepEqual(m.Invokes, want) {
-	if want := []string{"gitea.gitea_commit_trees", "gitea.gitea_contains"}; !reflect.DeepEqual(m.Invokes, want) {
 		t.Errorf("invokes = %v, want %v", m.Invokes, want)
 	}
 	// No emits, no streams, no bus, no seat, no tool (ADR 0437 §4).
@@ -171,32 +169,3 @@ func TestServesNoRequestSubjectAndHoldsNoTicker(t *testing.T) { // 1238/AC9 (ADR
 		t.Fatalf("read %d source files, want the program's", files)
 	}
 }
-
-// Every forge tool the program calls is granted in invokes, or the bus refuses the call (issue 1900).
-func TestEveryGiteaToolTheCodeCallsIsInInvokes(t *testing.T) {
-	m, _ := load(t)
-	files, err := filepath.Glob("cmd/mesh-delivery-indexer/*.go")
-	if err != nil || len(files) == 0 {
-		t.Fatalf("no program files: %v", err)
-	}
-	re := regexp.MustCompile(`gitea\.gitea_[a-z_]+`)
-	seen := 0
-	for _, f := range files {
-		if strings.HasSuffix(f, "_test.go") {
-			continue
-		}
-		src, err := os.ReadFile(f)
-		if err != nil {
-			t.Fatal(err)
-		}
-		for _, tool := range re.FindAllString(string(src), -1) {
-			seen++
-			if !slices.Contains(m.Invokes, tool) {
-				t.Errorf("%s calls %s, which invokes does not grant", f, tool)
-			}
-		}
-	}
-	if seen < 2 {
-		t.Errorf("found %d tool names in the program, want at least the two it calls", seen)
-	}
-}

modules/mesh-delivery-indexer/module.json

@@ -21,8 +21,7 @@
     "mesh-delivery-gate.source"
   ],
   "invokes": [
-    "gitea.gitea_commit_trees",
+    "gitea.gitea_commit_trees"
-    "gitea.gitea_contains"
   ],
   "own-secrets": {
     "broker": "${dir:state}/broker"