Name no node in the last residuals: asus-zephyrus-g14's denylist, lab's and mosquitto's comments, mesh-issues's help texts, mesh-knowledge's decision fixture and ssh-client's forge-URL fixture (issue 1838)

novox/hq is the name of the software's own record, whatever follows it; asus-g14 is the laptop's name in
its vendor trigger file, declared in particulars as hardware asus-g14 (1838/AC2).

checks/particulars/covered

@@ -1,3 +0,0 @@
-# The modules the check covers (novox/hq ADR 0507 §9, issue 1838), one a line; issue 1838 widens it.
-pacman
-kernel

checks/particulars/main.go

@@ -1,12 +1,23 @@
 // Command particulars keeps this mesh's node names out of the modules it covers (novox/hq ADR 0507 §9,
 // issue 1838): a module is for any mesh, so no manifest, file, code string, identifier, comment, test name or
-// fixture of a covered module names a node of this one.
+// fixture of any module names a node of this one.
 //
 // The names are in the file `particulars` at the catalogue's root, one a line, `#` comments — the one place
-// they may be written. The modules covered are in `covered` at checks/particulars/covered, one a line. A name is matched
-// whole and in any case; a hyphen, an underscore or a CamelCase boundary parts one, so a longer word holding a name is another word.
-// The forge is not a node name: its host (git.novox.be) and the organisation path (novox/<repo>) are blanked
-// before a line is read.
+// they may be written. Every directory under modules/ is read, with no list of covered modules, so a new module
+// is covered from its first commit. A name is matched whole and in any case; a hyphen, an underscore or a
+// CamelCase boundary parts one, so a longer word holding a name is another word.
+// Some text holds a node name and is not one, so it is blanked before a line is read, each form exact: the
+// software's module path (git.novox.be/novox/<repo>), the name of the software's record (novox/hq, followed by
+// anything), the hardware model (asus-zephyrus-g14, ROG Zephyrus G14), and the software's own
+// name and npm scope (Novox Mesh, novox-mesh, @novox/mesh-sdk with nothing before the @). Any other novox/<x>,
+// the forge's host alone and a node after a word's @ (database@novox/postgres) are findings.
+//
+// A module may declare its hardware model's word in `particulars`, as a line `model <module> <word>`: the word,
+// one of the names, is then no finding in that module's directory and still one in every other
+// (asus-zephyrus-g14's adopted paths such as /etc/modprobe.d/g14-nvidia-power.conf). A declaration naming no
+// module or no listed name makes the list unreadable.
+// A hardware's own name holding a name is declared as a line `hardware <word>` (asus-g14): that exact word, in
+// any case and not part of a longer hyphened word, is no finding in any module.
 //
 //	go run . <catalogue root>
 //
@@ -21,13 +32,22 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"
 )
 
-// forge is the forge's host and organisation path, blanked before a line is read; a path segment novox/ elsewhere
-// (testdata/novox/x, /srv/novox/data) is not blanked.
-var forge = regexp.MustCompile(`(?i)git\.novox\.be(?:/novox/[\w.-]+)?|(?:^|[^/\w.-])novox/[\w.-]+`)
+// forge is the software's module path on its forge and the name of its record (novox/hq, in any form: a citation,
+// a review, a URL path), blanked before a line is read; any other novox/<x> (a repository in a fixture,
+// testdata/novox/x) is not blanked, nor novox/hqx.
+var forge = regexp.MustCompile(`(?i:git\.novox\.be/novox/[\w.-]+)|novox/hq(?:$|[^\w-])`)
+
+// ownNames are the hardware model's and the software's own names, blanked before a line is read: the model
+// in any separator and case (asus-zephyrus-g14, ASUS_ZEPHYRUS_G14, ROG Zephyrus G14), the software as two
+// words or hyphened, whole (Novox Mesh, novox mesh, novox-mesh), so novox-mesh-vault stays a node name joined;
+// and the software's npm scope (@novox/mesh-sdk, @novox:registry=), its package path as the Go module path is,
+// where no word stands before the @, so a session's who@node (fix-1@novox) is still a node name.
+var ownNames = regexp.MustCompile(`(?i)(?:asus[-_ ])?zephyrus[-_ ]g14|(?:^|[^\w-])novox[- ]mesh(?:$|[^\w-])|(?:^|[^\w.-])@novox(?:$|[^\w-])`)
 
 func main() {
 	root := "."
@@ -39,22 +59,30 @@ func main() {
 
 // check runs the check over a catalogue and returns the exit code: 0 clean, 1 a finding, 2 a list unreadable.
 func check(root string) int {
-	names, err := readList(filepath.Join(root, "particulars"))
+	entries, err := readList(filepath.Join(root, "particulars"))
+	names, models, hardware := splitModels(entries)
 	if err == nil && len(names) == 0 {
 		err = fmt.Errorf("particulars lists no name — the check would pass on anything")
 	}
-	var covered []string
+	var modules []string
 	if err == nil {
-		covered, err = readList(filepath.Join(root, "checks/particulars/covered"))
-		if err == nil && len(covered) == 0 {
-			err = fmt.Errorf("covered lists no module — the check would pass on anything")
+		modules, err = moduleDirs(root)
+		if err == nil && len(modules) == 0 {
+			err = fmt.Errorf("modules/ holds no module — the check would pass on anything")
 		}
 	}
+	if err == nil {
+		err = checkModels(models, names, modules)
+	}
+	var blanks *regexp.Regexp
+	if err == nil {
+		blanks, err = hardwareWords(hardware)
+	}
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "particulars:", err)
 		return 2
 	}
-	findings, err := run(root, names, covered)
+	findings, err := run(root, names, modules, models, blanks)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "particulars:", err)
 		return 2
@@ -66,7 +94,7 @@ func check(root string) int {
 		fmt.Printf("particulars: %d node name(s) in a module for any mesh (novox/hq ADR 0507 §9) — say what it shows, not where it was seen\n", len(findings))
 		return 1
 	}
-	fmt.Printf("particulars: none of %d node names in the %d covered modules\n", len(names), len(covered))
+	fmt.Printf("particulars: none of %d node names in the %d modules\n", len(names), len(modules))
 	return 0
 }
 
@@ -89,10 +117,104 @@ func readList(path string) ([]string, error) {
 	return out, sc.Err()
 }
 
-// run reads every text file of each covered module and returns the findings, sorted.
-func run(root string, names, covered []string) ([]string, error) {
+// splitModels parts the list's entries into the names, the models' words by module (`model <module> <word>`)
+// and the hardware's words (`hardware <word>`, kept whole to be checked).
+func splitModels(entries []string) (names []string, models map[string][]string, hardware []string) {
+	models = map[string][]string{}
+	for _, e := range entries {
+		f := strings.Fields(e)
+		if len(f) > 0 && f[0] == "hardware" {
+			hardware = append(hardware, e)
+			continue
+		}
+		if len(f) > 0 && f[0] == "model" {
+			if len(f) != 3 {
+				models[""] = append(models[""], e)
+				continue
+			}
+			models[f[1]] = append(models[f[1]], f[2])
+			continue
+		}
+		names = append(names, e)
+	}
+	return names, models, hardware
+}
+
+// hardwareWords is the matcher of the declared hardware words, nil when none is declared; a line that is not
+// `hardware <word>` makes the list unreadable.
+func hardwareWords(lines []string) (*regexp.Regexp, error) {
+	var words []string
+	for _, l := range lines {
+		f := strings.Fields(l)
+		if len(f) != 2 {
+			return nil, fmt.Errorf("particulars: %q is not `hardware <word>`", l)
+		}
+		words = append(words, regexp.QuoteMeta(f[1]))
+	}
+	if len(words) == 0 {
+		return nil, nil
+	}
+	return regexp.MustCompile(`(?i)(?:^|[^A-Za-z0-9-])(?:` + strings.Join(words, "|") + `)(?:$|[^A-Za-z0-9-])`), nil
+}
+
+// blankWith blanks what rx matches in s, keeping every other byte where it was.
+func blankWith(rx *regexp.Regexp, s string) string {
+	if rx == nil {
+		return s
+	}
+	return rx.ReplaceAllStringFunc(s, func(m string) string { return strings.Repeat(" ", len(m)) })
+}
+
+// checkModels refuses a model declaration that is malformed, names no module or names a word that is no name.
+func checkModels(models map[string][]string, names, modules []string) error {
+	for m, words := range models {
+		if m == "" {
+			return fmt.Errorf("particulars: %q is not `model <module> <word>`", words[0])
+		}
+		if !slices.Contains(modules, m) {
+			return fmt.Errorf("particulars: model %s %s names no module under modules/", m, words[0])
+		}
+		for _, w := range words {
+			if !slices.ContainsFunc(names, func(n string) bool { return strings.EqualFold(n, w) }) {
+				return fmt.Errorf("particulars: model %s %s: %q is not a listed name", m, w, w)
+			}
+		}
+	}
+	return nil
+}
+
+// without returns the names but the words, in any case.
+func without(names, words []string) []string {
 	var out []string
-	for _, m := range covered {
+	for _, n := range names {
+		if !slices.ContainsFunc(words, func(w string) bool { return strings.EqualFold(n, w) }) {
+			out = append(out, n)
+		}
+	}
+	return out
+}
+
+// moduleDirs returns every directory under the catalogue's modules/, sorted.
+func moduleDirs(root string) ([]string, error) {
+	entries, err := os.ReadDir(filepath.Join(root, "modules"))
+	if err != nil {
+		return nil, err
+	}
+	var out []string
+	for _, e := range entries {
+		if e.IsDir() {
+			out = append(out, e.Name())
+		}
+	}
+	return out, nil
+}
+
+// run reads every text file of each module named and returns the findings, sorted; a module's model words are
+// not read as names in it.
+func run(root string, all, modules []string, models map[string][]string, hardware *regexp.Regexp) ([]string, error) {
+	var out []string
+	for _, m := range modules {
+		names := without(all, models[m])
 		dir := filepath.Join(root, "modules", m)
 		err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
 			if err != nil {
@@ -107,7 +229,7 @@ func run(root string, names, covered []string) ([]string, error) {
 			}
 			rel, _ := filepath.Rel(root, path)
 			// A path is read too: a testdata directory named after a node is a finding.
-			for _, n := range hits(filepath.ToSlash(rel), names) {
+			for _, n := range hits(blankWith(hardware, filepath.ToSlash(rel)), names) {
 				out = append(out, fmt.Sprintf("%s:0: node name %q in the path", filepath.ToSlash(rel), n))
 			}
 			if d.Name() == "go.sum" {
@@ -120,7 +242,7 @@ func run(root string, names, covered []string) ([]string, error) {
 			if bytes.IndexByte(b, 0) >= 0 {
 				return nil
 			}
-			out = append(out, scan(filepath.ToSlash(rel), string(b), names)...)
+			out = append(out, scan(filepath.ToSlash(rel), blankWith(hardware, string(b)), names)...)
 			return nil
 		})
 		if err != nil {
@@ -143,17 +265,32 @@ func scan(file, src string, names []string) []string {
 }
 
 // hits returns the node names one line holds: as a word (a hyphen or underscore parts it), as a part of a
-// CamelCase identifier (TestAce, novoxTree), the forge's host and organisation path blanked first.
+// CamelCase identifier (TestAce, novoxTree), the forge's host and organisation path and the hardware's and the
+// software's own names blanked first.
 func hits(line string, names []string) []string {
-	line = forge.ReplaceAllStringFunc(line, func(s string) string { return strings.Repeat(" ", len(s)) })
+	blank := func(s string) string { return strings.Repeat(" ", len(s)) }
+	line = forge.ReplaceAllStringFunc(line, blank)
+	line = ownNames.ReplaceAllStringFunc(line, blank)
 	var out []string
 	for _, n := range names {
-		q := regexp.QuoteMeta(n)
-		camel := regexp.QuoteMeta(strings.ToUpper(n[:1]) + n[1:])
-		rx := regexp.MustCompile(`(?i:(?:^|[^A-Za-z0-9])` + q + `(?:$|[^A-Za-z0-9]))|[a-z0-9]` + camel + `(?:$|[^a-z])|(?:^|[^A-Za-z0-9])` + q + `[A-Z0-9]`)
-		if rx.MatchString(line) {
+		if matcher(n).MatchString(line) {
 			out = append(out, strings.ToLower(n))
 		}
 	}
 	return out
 }
+
+// matchers holds each name's matcher, compiled once: the check reads every line of every module.
+var matchers = map[string]*regexp.Regexp{}
+
+// matcher is the matcher of one name: as a word, or as a part of a CamelCase identifier.
+func matcher(n string) *regexp.Regexp {
+	if rx, ok := matchers[n]; ok {
+		return rx
+	}
+	q := regexp.QuoteMeta(n)
+	camel := regexp.QuoteMeta(strings.ToUpper(n[:1]) + n[1:])
+	rx := regexp.MustCompile(`(?i:(?:^|[^A-Za-z0-9])` + q + `(?:$|[^A-Za-z0-9]))|[a-z0-9]` + camel + `(?:$|[^a-z])|(?:^|[^A-Za-z0-9])` + q + `[A-Z0-9]`)
+	matchers[n] = rx
+	return rx
+}

checks/particulars/main_test.go

@@ -35,7 +35,6 @@ func TestTheForgeIsNotANodeName(t *testing.T) {
 		"see novox/hq issue 5",
 		"module git.novox.be/novox/mesh-sdk/go v1.2.3",
 		"https://git.novox.be/novox/mesh-catalog",
-		"git.novox.be",
 		"space trace surface grace g14x",
 	} {
 		if got := scan("f", s, names); len(got) != 0 {
@@ -68,7 +67,7 @@ func TestANodeNamedPathIsRefusedThroughRun(t *testing.T) {
 	p := filepath.Join(root, "modules/kernel/testdata/ace/x")
 	os.MkdirAll(filepath.Dir(p), 0o755)
 	os.WriteFile(p, []byte("clean\n"), 0o644)
-	got, err := run(root, names, []string{"kernel"})
+	got, err := run(root, names, []string{"kernel"}, nil, nil)
 	if err != nil || len(got) != 1 || !strings.HasPrefix(got[0], "modules/kernel/testdata/ace/x:0: ") {
 		t.Errorf("got %v, %v", got, err)
 	}
@@ -82,7 +81,6 @@ func TestCheckReturnsOneOnAFindingAndTwoOnAnUnreadableList(t *testing.T) {
 		os.WriteFile(p, []byte(s), 0o644)
 	}
 	write("particulars", "ace\n")
-	write("checks/particulars/covered", "kernel\n")
 	write("modules/kernel/a", "clean\n")
 	if got := check(root); got != 0 {
 		t.Errorf("clean = %d, want 0", got)
@@ -97,7 +95,7 @@ func TestCheckReturnsOneOnAFindingAndTwoOnAnUnreadableList(t *testing.T) {
 	}
 }
 
-func TestOnlyCoveredModulesAreRead(t *testing.T) {
+func TestRunReadsOnlyTheModulesItIsGiven(t *testing.T) {
 	root := t.TempDir()
 	write := func(p, s string) {
 		p = filepath.Join(root, p)
@@ -106,7 +104,7 @@ func TestOnlyCoveredModulesAreRead(t *testing.T) {
 	}
 	write("modules/kernel/files/a", "on novox\n")
 	write("modules/other/files/a", "on novox\n")
-	got, err := run(root, names, []string{"kernel"})
+	got, err := run(root, names, []string{"kernel"}, nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -114,3 +112,201 @@ func TestOnlyCoveredModulesAreRead(t *testing.T) {
 		t.Errorf("got %v", got)
 	}
 }
+
+// 1838/AC1: the check reads every directory under modules/ and no list of covered modules, so a module is
+// covered from its first commit.
+func TestEveryModuleIsReadWithoutAList(t *testing.T) {
+	root := t.TempDir()
+	write := func(p, s string) {
+		p = filepath.Join(root, p)
+		os.MkdirAll(filepath.Dir(p), 0o755)
+		os.WriteFile(p, []byte(s), 0o644)
+	}
+	write("particulars", "novox\n")
+	write("modules/kernel/files/a", "clean\n")
+	if got := check(root); got != 0 {
+		t.Errorf("clean, no covered list = %d, want 0", got)
+	}
+	write("modules/new-module/files/a", "on novox\n")
+	if got := check(root); got != 1 {
+		t.Errorf("a finding in a module no list names = %d, want 1", got)
+	}
+}
+
+// 1838/AC2: the hardware model's own name and the software's own name are not node names.
+func TestTheHardwareModelAndTheSoftwareAreNotNodeNames(t *testing.T) {
+	for _, s := range []string{
+		"modules/asus-zephyrus-g14/README.md",
+		"the asus-zephyrus-g14 module",
+		"ASUS_ZEPHYRUS_G14=1",
+		"product_family: ROG Zephyrus G14",
+		"# This machine is a node of a Novox mesh",
+		"Novox Mesh turns a handful of personal machines into one system",
+		"<!-- novox mesh: this file was changed on two nodes",
+		`const sealInfo = "novox-mesh sealed box v1"`,
+		"module git.novox.be/novox/mesh-catalog/modules/kernel",
+	} {
+		if got := scan("f", s, names); len(got) != 0 {
+			t.Errorf("%q refused: %v", s, got)
+		}
+	}
+}
+
+// 1838/AC2: a node name standing alone is still one, beside the hardware's or the software's name too.
+func TestANodeNameBesideTheHardwareOrTheSoftwareIsRefused(t *testing.T) {
+	cases := map[string]string{
+		"g14":            "the asus-zephyrus-g14 module on g14",
+		"shanks":         "Novox Mesh on shanks",
+		"novox":          "resolves under novox.internal",
+		"ace":            "ROG Zephyrus G14 beside ace",
+		"novox mesh-ish": "mesh.mod.gitea.call.x.novox-mesh-vault",
+	}
+	for want, s := range cases {
+		got := scan("modules/m/a.go", s, names)
+		if len(got) != 1 || !strings.HasPrefix(got[0], "modules/m/a.go:1: ") {
+			t.Errorf("%s: %q gave %v, want one finding naming file:line", want, s, got)
+		}
+	}
+}
+
+// 1838/AC2: the software's npm scope (@novox/mesh-sdk, @novox:registry=) is its package path, as the Go module
+// path is; a session's who@node naming a node is still a node name.
+func TestTheSoftwaresNpmScopeIsNotANodeName(t *testing.T) {
+	for _, s := range []string{
+		"printf '%s\\n' ${shellQuote(`@novox:registry=${registry}`)}",
+		"const url = `${asked}@novox%2fmesh-sdk`;",
+		"# The @novox scope resolves from the mesh's own package registry",
+		`"dependencies": { "@novox/mesh-sdk": "^0.1.0" }`,
+	} {
+		if got := scan("f", s, names); len(got) != 0 {
+			t.Errorf("%q refused: %v", s, got)
+		}
+	}
+	for _, s := range []string{"by fix-1@novox", "jochen@novox:"} {
+		if got := scan("f", s, names); len(got) != 1 {
+			t.Errorf("%q gave %v, want one finding", s, got)
+		}
+	}
+}
+
+// 1838/AC1: reading every module, the check compiles its matchers once, not once a line: a line read costs a
+// few allocations, not a regexp compiled per name (the whole catalogue took 41 s with one per line).
+func TestALineIsReadWithoutCompilingAMatcher(t *testing.T) {
+	line := "a line of code that names nothing at all, with git.novox.be/novox/mesh-sdk in it"
+	if n := testing.AllocsPerRun(100, func() { hits(line, names) }); n > 20 {
+		t.Errorf("a line costs %.0f allocations, want at most 20", n)
+	}
+}
+
+// 1838/AC2: a module may declare its hardware model's word in `particulars` (model <module> <word>); the word is
+// then no finding in that module, and still one in every other.
+func TestAModelsWordIsAllowedInItsModuleOnly(t *testing.T) {
+	root := t.TempDir()
+	write := func(p, s string) {
+		p = filepath.Join(root, p)
+		os.MkdirAll(filepath.Dir(p), 0o755)
+		os.WriteFile(p, []byte(s), 0o644)
+	}
+	write("particulars", "ace\ng14\nmodel asus-zephyrus-g14 g14\n")
+	write("modules/asus-zephyrus-g14/README.md", "the adopted /etc/modprobe.d/g14-nvidia-power.conf; a second G14\n")
+	write("modules/kernel/a", "clean\n")
+	if got := check(root); got != 0 {
+		t.Errorf("the model's word in its own module = %d, want 0", got)
+	}
+	write("modules/asus-zephyrus-g14/a", "on ace\n")
+	if got := check(root); got != 1 {
+		t.Errorf("another node name in the model's module = %d, want 1", got)
+	}
+	write("modules/asus-zephyrus-g14/a", "clean\n")
+	write("modules/kernel/a", "i3's 20-g14.conf\n")
+	if got := check(root); got != 1 {
+		t.Errorf("the model's word in another module = %d, want 1", got)
+	}
+	write("modules/kernel/a", "clean\n")
+	write("particulars", "ace\ng14\nmodel no-such-module g14\n")
+	if got := check(root); got != 2 {
+		t.Errorf("a model of a module that does not exist = %d, want 2", got)
+	}
+	write("particulars", "ace\ng14\nmodel asus-zephyrus-g14 shanks\n")
+	if got := check(root); got != 2 {
+		t.Errorf("a model's word that is no listed name = %d, want 2", got)
+	}
+}
+
+// 1838/AC2: only the module path git.novox.be/novox/<repo>, a package name or scope with nothing before its @, and
+// the exact record citation novox/hq ADR|issue|design|to-be|research are the forge's or the software's; any
+// other novox/<x>, the forge's host alone, and a node after a word's @ are findings.
+func TestOnlyTheModulePathThePackageAndTheCitationAreNotNodeNames(t *testing.T) {
+	for _, s := range []string{
+		"module git.novox.be/novox/mesh-sdk/go v1.2.3",
+		"https://git.novox.be/novox/mesh-catalog",
+		`import { registerModuleTools } from "@novox/mesh-sdk/tools";`,
+		`"dependencies": { "@novox/ui": "^2.0.0" }`,
+		"// novox/hq ADR 0507 §9",
+		"(novox/hq issue 1838)",
+		"novox/hq design 47 and novox/hq to-be 53, novox/hq research 12",
+	} {
+		if got := scan("f", s, names); len(got) != 0 {
+			t.Errorf("%q refused: %v", s, got)
+		}
+	}
+	for _, s := range []string{
+		`handedWith("node-b", "gitea", "postgres-database@novox/postgres+pair")`,
+		"delivery.novox/mesh-controller",
+		"see novox/mesh-catalog #441",
+		"git.novox.be",
+	} {
+		if got := scan("f", s, names); len(got) != 1 {
+			t.Errorf("%q gave %v, want one finding", s, got)
+		}
+	}
+}
+
+// 1838/AC2: novox/hq is the name of the software's own record, no finding in any form; another novox/<repo> is.
+func TestTheRecordsNameIsNoFindingInAnyForm(t *testing.T) {
+	for _, s := range []string{
+		"novox/hq review round 2",
+		"novox/hq issues 1665 and 1666",
+		"repository: novox/hq",
+		"[the record](https://forge.example.org/novox/hq/src/branch/main/00-META/glossary.md)",
+		"novox/hq#7 at aaa",
+		"git.anchor.internal:222/novox/hq.git",
+	} {
+		if got := scan("f", s, names); len(got) != 0 {
+			t.Errorf("%q refused: %v", s, got)
+		}
+	}
+	for _, s := range []string{`repo := "novox/mesh-catalog"`, "novox/hqx", "novox/hq-mirror"} {
+		if got := scan("f", s, names); len(got) != 1 {
+			t.Errorf("%q gave %v, want one finding", s, got)
+		}
+	}
+}
+
+// 1838/AC2: a hardware word declared in particulars (hardware <word>) is no finding anywhere; a name standing
+// alone still is.
+func TestAHardwareWordIsNoFindingAnywhere(t *testing.T) {
+	root := t.TempDir()
+	write := func(p, s string) {
+		p = filepath.Join(root, p)
+		os.MkdirAll(filepath.Dir(p), 0o755)
+		os.WriteFile(p, []byte(s), 0o644)
+	}
+	write("particulars", "g14\nhardware asus-g14\n")
+	write("modules/triggerhappy/a", "/etc/triggerhappy/triggers.d/asus-g14.conf and ASUS-G14\n")
+	if got := check(root); got != 0 {
+		t.Errorf("the hardware word = %d, want 0", got)
+	}
+	write("modules/triggerhappy/a", "asus-g14.conf on g14\n")
+	if got := check(root); got != 1 {
+		t.Errorf("g14 standing alone beside it = %d, want 1", got)
+	}
+	write("modules/triggerhappy/a", "my-asus-g14-x\n")
+	if got := check(root); got != 1 {
+		t.Errorf("a longer word holding it = %d, want 1", got)
+	}
+	write("particulars", "g14\nhardware\n")
+	if got := check(root); got != 2 {
+		t.Errorf("a hardware line with no word = %d, want 2", got)
+	}
+}

merge-check.sh

@@ -55,8 +55,8 @@
 set -eu
 
 (cd checks/words && go test -count=1 . && go run . ../..)
-# Node names (novox/hq ADR 0507 §9, issue 1838): no node name of this mesh in a covered module; the names are in
-# `particulars`, the covered modules in checks/particulars/covered.
+# Node names (novox/hq ADR 0507 §9, issue 1838): no node name of this mesh in any module (every directory under
+# modules/ is covered, with no list); the names, and a module's hardware model word, are in `particulars`.
 (cd checks/particulars && go test -count=1 . && go run . ../..)
 # The toolchains (novox/hq ADR 0477 clause 4): the package go only in modules/go, nodejs and npm only in modules/nodejs.
 (cd checks/toolchains && go test -count=1 . && go run . ../..)

modules/adwaita/README.md

@@ -86,7 +86,7 @@ login.
 
 ## What changes when it is assigned
 
-| | g14 | shanks |
+| | node-b | node-d |
 |---|---|---|
 | packages | none (all present) | the same |
 | GTK settings, `portals.conf` | the found files kept once, then the module's: adds the cursor and Inter, keeps Adwaita dark; `portals.conf` adds the Secret line | the same |

modules/asus-zephyrus-g14/cmd/zephyrus/manifest_test.go

@@ -94,7 +94,8 @@ func TestTheManifestNamesNoMachineAndItsTriggersExist(t *testing.T) {
 		ids[r["id"].(string)] = true
 	}
 	raw, _ := os.ReadFile("../../module.json")
-	for _, banned := range []string{"jochen", "/home/", "/run/user/1000", "\"g14\"", "shanks"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, banned := range []string{"jochen", "/home/", "/run/user/1000"} {
 		if strings.Contains(string(raw), banned) {
 			t.Errorf("the manifest says %q", banned)
 		}

modules/betterbird/README.md

@@ -1,6 +1,6 @@
 # betterbird
 
-Betterbird, the mail and calendar client of g14 and shanks (a Thunderbird fork, with the operator's
+Betterbird, the mail and calendar client of node-b and node-d (a Thunderbird fork, with the operator's
 Exchange calendar through the Owl add-on), as a module (novox/hq issue 345, issue 586, ADR 0208, ADR 0316,
 ADR 0317, ADR 0329, to-be 56). It requires `x11-display`, so it is assigned only where a display server is held
 on the same machine. It installs Betterbird from a pinned upstream release, ships Owl with it through
@@ -58,7 +58,7 @@ reading the new range there (ADR 0316 §8).
 **The policy** turns Betterbird's own updater off (`DisableAppUpdate`, which Betterbird's update check
 honours) and installs Owl into every profile from `file:///opt/betterbird/owl/owl.xpi` as
 `force_installed`, with `updates_disabled`. A profile that already runs another Owl keeps it: the policy
-installs the pinned one where Owl is missing. A newer Owl in the profile (g14 runs 1.5.7) is said as a
+installs the pinned one where Owl is missing. A newer Owl in the profile (node-b runs 1.5.7) is said as a
 fact by `betterbird_status`; Owl installed by policy cannot be removed in Betterbird, so the remedy is
 moving the pin. An older one is a finding of `betterbird_check`, with the same remedy.
 
@@ -323,10 +323,10 @@ question.
 
 ## What changes when it is pushed
 
-The module is assigned to shanks today (look-only, from issue 345's first part); g14 runs Betterbird
+The module is assigned to node-d today (look-only, from issue 345's first part); node-b runs Betterbird
 outside the mesh. With this version, a push to a node (each waits for the operator: `upgrade: record`):
 
-| | on a node with the community package (g14, shanks) |
+| | on a node with the community package (node-b, node-d) |
 |---|---|
 | the package | `betterbird-bin` removed (quit Betterbird first) |
 | `/opt/betterbird` | the mesh's 153.4.0esr-bb10, in the same place, so the same profile opens |

modules/betterbird/cmd/betterbird-tools/config_test.go

@@ -412,13 +412,13 @@ func TestKeepProposesANodeLayerThroughTheController(t *testing.T) {
 	f.write(profileDir+"/prefs.js", `user_pref("mail.uifontsize", 16);`+"\n"+`user_pref("mail.spam.manualMark", true);`+"\n")
 	oldNode, oldAsk := nodeName, asker
 	t.Cleanup(func() { nodeName, asker = oldNode, oldAsk })
-	nodeName = func() string { return "shanks" }
+	nodeName = func() string { return "node-d" }
 	var asked []map[string]any
 	asker = func(v string, a any) (json.RawMessage, error) {
 		args := a.(map[string]any)
 		asked = append(asked, args)
 		if args["propose"] == nil {
-			return json.RawMessage(`{"ok": true, "output": "{\"prefs\": {\"calendar.alarms.playsound\": false}, \"identities\": {\"mail\": {\"account\": \"mail\"}}}\n  set at the terminal\nbetterbird on shanks, every value"}`), nil
+			return json.RawMessage(`{"ok": true, "output": "{\"prefs\": {\"calendar.alarms.playsound\": false}, \"identities\": {\"mail\": {\"account\": \"mail\"}}}\n  set at the terminal\nbetterbird on node-d, every value"}`), nil
 		}
 		return json.RawMessage(`{"ok": true, "output": "proposed: p-1"}`), nil
 	}
@@ -427,7 +427,7 @@ func TestKeepProposesANodeLayerThroughTheController(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(asked) != 2 || asked[0]["node"] != "shanks" || asked[1]["node"] != "shanks" || asked[1]["propose"] != "true" ||
+	if len(asked) != 2 || asked[0]["node"] != "node-d" || asked[1]["node"] != "node-d" || asked[1]["propose"] != "true" ||
 		asked[1]["module"] != "betterbird" {
 		t.Fatalf("the node's layer read, then proposed: %v", asked)
 	}

modules/betterbird/cmd/betterbird-tools/derive_test.go

@@ -12,11 +12,11 @@ import (
 // ADR 0329 §10, §12: derived from every desktop node's profile, laid out per layer, and proposed one layer at a
 // time, carrying the layer as it stands.
 
-// derivingMesh is two desktop nodes, g14 (this one, f) and shanks (f2), and a server that holds no Betterbird, as the
+// derivingMesh is two desktop nodes, node-b (this one, f) and node-d (f2), and a server that holds no Betterbird, as the
 // controller answers them; layers are the controller's layers, open the proposals that wait.
 type derivingMesh struct {
 	t        *testing.T
-	shanks   *fake
+	nodeD    *fake
 	layers   map[string]map[string]any
 	open     bool
 	proposed []map[string]any
@@ -35,17 +35,17 @@ func (d *derivingMesh) ask(key string, body any) (json.RawMessage, error) {
 	}
 	switch {
 	case key == "seat:mesh-controller.nodes":
-		return answer(true, `[{"name": "g14"}, {"name": "novox"}, {"name": "shanks"}]`)
+		return answer(true, `[{"name": "node-b"}, {"name": "node-c"}, {"name": "node-d"}]`)
 	case key == "seat:mesh-controller.node":
-		if args["node"] == "novox" {
-			return answer(true, "novox\n  assigned: postgres, nats\n")
+		if args["node"] == "node-c" {
+			return answer(true, "node-c\n  assigned: postgres, nats\n")
 		}
 		return answer(true, fmt.Sprintf("%s\n  last heard from   here\n  assigned: adwaita, betterbird, dunst\n", args["node"]))
-	case key == "betterbird.betterbird_derive@shanks":
+	case key == "betterbird.betterbird_derive@node-d":
 		if d.asleep {
 			return nil, errors.New("nats: no responders available for request")
 		}
-		here, err := d.shanks.deriveHere(stringsOf(args["kinds"]))
+		here, err := d.nodeD.deriveHere(stringsOf(args["kinds"]))
 		if err != nil {
 			d.t.Fatal(err)
 		}
@@ -53,10 +53,10 @@ func (d *derivingMesh) ask(key string, body any) (json.RawMessage, error) {
 		return json.Marshal(map[string]any{"content": []any{map[string]any{"type": "text", "text": string(text)}}})
 	case key == "seat:mesh-controller.settings" && args["proposals"] == "true":
 		if d.open {
-			return answer(true, "sab12  set betterbird on the whole mesh  (accounts, identities)\n    by g14.node-tools at 2026-10-13 01:00; fingerprint ab12\n    waiting for the operator until 2026-10-14 01:00\n"+
-				"scd34  set mounts on shanks  (sources)\n    by g14.node-tools at 2026-10-11 00:05; fingerprint dd0b\n    chosen: done\n")
+			return answer(true, "sab12  set betterbird on the whole mesh  (accounts, identities)\n    by node-b.node-tools at 2026-10-13 01:00; fingerprint ab12\n    waiting for the operator until 2026-10-14 01:00\n"+
+				"scd34  set mounts on node-d  (sources)\n    by node-b.node-tools at 2026-10-11 00:05; fingerprint dd0b\n    chosen: done\n")
 		}
-		return answer(true, "scd34  set mounts on shanks  (sources)\n    by g14.node-tools; fingerprint dd0b\n    chosen: done\n")
+		return answer(true, "scd34  set mounts on node-d  (sources)\n    by node-b.node-tools; fingerprint dd0b\n    chosen: done\n")
 	case key == "seat:mesh-controller.settings" && args["propose"] == "true":
 		d.proposed = append(d.proposed, args)
 		return answer(true, "proposal sab12: Set the settings of betterbird?\n  fingerprint ab12")
@@ -107,23 +107,23 @@ func TestDeriveLaysEachEntryOutPerLayerAndProposesOneLayerAtATime(t *testing.T)
 	f2 := newFake(t)
 	f2.profileWithAccounts()
 	f2.profileWithConfiguration()
-	// shanks holds the same accounts and calendars, another signature, another tag colour and a calendar of its own.
+	// node-d holds the same accounts and calendars, another signature, another tag colour and a calendar of its own.
 	f2.write(profileDir+"/prefs.js", strings.NewReplacer(`"Regards"`, `"Cheers"`, `"#FF0000"`, `"#CC0000"`).Replace(f2.read(profileDir+"/prefs.js"))+
 		`user_pref("calendar.registry.s1.type", "caldav");`+"\n"+
 		`user_pref("calendar.registry.s1.uri", "https://dav.example.org/cal/standup/");`+"\n"+
 		`user_pref("calendar.registry.s1.name", "Standup");`+"\n")
 	f2.declareAccounts(adoptable)
-	mesh := &derivingMesh{t: t, shanks: f2, layers: map[string]map[string]any{"": {"accounts": map[string]any{"mail": "as approved"}}}}
+	mesh := &derivingMesh{t: t, nodeD: f2, layers: map[string]map[string]any{"": {"accounts": map[string]any{"mail": "as approved"}}}}
 	oldNode, oldAsk := nodeName, asker
 	t.Cleanup(func() { nodeName, asker = oldNode, oldAsk })
-	nodeName = func() string { return "g14" }
+	nodeName = func() string { return "node-b" }
 	asker = mesh.ask
 
 	a, err := f.Derive(nil, false, false, nil, "")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !reflect.DeepEqual(a.From, []string{"g14", "shanks"}) || len(a.NotHeard) != 0 {
+	if !reflect.DeepEqual(a.From, []string{"node-b", "node-d"}) || len(a.NotHeard) != 0 {
 		t.Fatalf("derived from the nodes holding Betterbird: %v %v", a.From, a.NotHeard)
 	}
 	whole := mustJSON(a)
@@ -134,9 +134,9 @@ func TestDeriveLaysEachEntryOutPerLayerAndProposesOneLayerAtATime(t *testing.T)
 	}
 	cals, _ := mw[kindCalendars].(map[string]any)
 	if cals["home"] == nil || cals["standup"] != nil {
-		t.Errorf("a calendar both hold is mesh-wide, one only shanks holds is not: %v", cals)
+		t.Errorf("a calendar both hold is mesh-wide, one only node-d holds is not: %v", cals)
 	}
-	if sh := mustJSON(a.Layers["shanks"]); !strings.Contains(sh, "https://dav.example.org/cal/standup/") {
+	if sh := mustJSON(a.Layers["node-d"]); !strings.Contains(sh, "https://dav.example.org/cal/standup/") {
 		t.Errorf("an entry on one node only goes into that node's layer: %s", sh)
 	}
 	tags, _ := mw[kindTags].(map[string]any)
@@ -147,8 +147,8 @@ func TestDeriveLaysEachEntryOutPerLayerAndProposesOneLayerAtATime(t *testing.T)
 	for _, d := range a.Differences {
 		diffs[d.Kind+"/"+d.Entry+"/"+d.Field] = d
 	}
-	if d := diffs["identities/mail/signature"]; d.Node != "shanks" || mustJSON(d.There) != `["Cheers"]` {
-		t.Errorf("the answer lists the field shanks holds differently: %+v", a.Differences)
+	if d := diffs["identities/mail/signature"]; d.Node != "node-d" || mustJSON(d.There) != `["Cheers"]` {
+		t.Errorf("the answer lists the field node-d holds differently: %+v", a.Differences)
 	}
 	if d := diffs["tags/$label1/color"]; d.There != "#CC0000" || d.MeshWide != "#FF0000" {
 		t.Errorf("%+v", a.Differences)
@@ -195,22 +195,22 @@ func TestDeriveLaysEachEntryOutPerLayerAndProposesOneLayerAtATime(t *testing.T)
 	if _, err := f.Derive(nil, false, true, nil, ""); err == nil || !strings.Contains(err.Error(), "sab12 (the whole mesh)") || len(mesh.proposed) != 1 {
 		t.Fatalf("one open proposal of the module's at a time: %v", err)
 	}
-	// Approved: the mesh-wide layer holds it, so the next layer is shanks's own.
+	// Approved: the mesh-wide layer holds it, so the next layer is node-d's own.
 	mesh.open = false
 	mesh.layers[""] = values
 	a, err = f.Derive(nil, false, true, prefs, "")
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(mesh.proposed) != 2 || mesh.proposed[1]["node"] != "shanks" || a.Next != "shanks" ||
+	if len(mesh.proposed) != 2 || mesh.proposed[1]["node"] != "node-d" || a.Next != "node-d" ||
 		!strings.Contains(mesh.proposed[1]["values"].(string), "standup") {
 		t.Fatalf("then the node's own layer: %v", mesh.proposed)
 	}
-	var shanks map[string]any
-	if err := json.Unmarshal([]byte(mesh.proposed[1]["values"].(string)), &shanks); err != nil {
+	var nodeD map[string]any
+	if err := json.Unmarshal([]byte(mesh.proposed[1]["values"].(string)), &nodeD); err != nil {
 		t.Fatal(err)
 	}
-	mesh.layers["shanks"] = shanks
+	mesh.layers["node-d"] = nodeD
 	if a, err = f.Derive(nil, false, true, prefs, ""); err != nil || len(mesh.proposed) != 2 || !strings.HasPrefix(a.Next, "none") {
 		t.Fatalf("nothing left to propose: %v %s", err, a.Next)
 	}
@@ -240,10 +240,10 @@ func TestALayerThatCannotBeReadRefusesTheProposal(t *testing.T) {
 	f2 := newFake(t)
 	f2.profileWithAccounts()
 	f2.declareAccounts(adoptable)
-	mesh := &derivingMesh{t: t, shanks: f2, garbled: true}
+	mesh := &derivingMesh{t: t, nodeD: f2, garbled: true}
 	oldNode, oldAsk := nodeName, asker
 	t.Cleanup(func() { nodeName, asker = oldNode, oldAsk })
-	nodeName = func() string { return "g14" }
+	nodeName = func() string { return "node-b" }
 	asker = mesh.ask
 	if _, err := f.Derive(nil, false, true, nil, ""); err == nil || !strings.Contains(err.Error(), "cannot be read as the layer") ||
 		len(mesh.proposed) != 0 {
@@ -257,7 +257,7 @@ func TestALayerThatCannotBeReadRefusesTheProposal(t *testing.T) {
 		t.Fatal("an unreadable layer is an error, never an empty layer")
 	}
 	mesh.garbled = false
-	if got, err := readLayer("shanks"); err != nil || len(got) != 0 {
+	if got, err := readLayer("node-d"); err != nil || len(got) != 0 {
 		t.Fatalf("no layer, in the controller's words, is an empty layer: %v %v", got, err)
 	}
 }

modules/betterbird/cmd/betterbird-tools/manifest_test.go

@@ -107,7 +107,8 @@ func TestItPlacesBetterbirdWhereTheCommunityPackageDidAndOnlyAfterItIsGone(t *te
 		}
 	}
 	s := strings.ToLower(raw)
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "http://", "mediahuis"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "http://", "mediahuis"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/blueman/README.md

@@ -52,7 +52,7 @@ through an injected runner and a fake root in the tests.
 
 ## What changes when it is assigned
 
-| | g14 | shanks |
+| | node-b | node-d |
 |---|---|---|
 | package | none: `blueman` 2.4.6 is installed, explicitly, from `extra` | the same |
 | start | none: dex starts the applet from the package's entry, in the login session's scope; the tray icon with it | none on disk. **The applet running now came from the predecessor's window-manager line** (a child of i3, since the session of 2026-10-04 16:00). That session began before the `i3` module dropped the line and installed `dex`, so the next login is the first that starts it from the entry |
@@ -62,7 +62,7 @@ The workstations are already in the state this module describes.
 
 ## Migration (ADR 0182)
 
-Nothing is required on either machine. On shanks, log out and in once, or run `blueman_restart`, and
+Nothing is required on either machine. On node-d, log out and in once, or run `blueman_restart`, and
 the applet runs from its one start. `blueman_check` then answers `ok`.
 
 ## Leaves as found

modules/blueman/cmd/blueman-tools/manifest_test.go

@@ -101,7 +101,8 @@ func TestTheToolsAgreeWithTheManifest(t *testing.T) {
 		t.Errorf("the Go tools bundle: %v", b)
 	}
 	s := strings.ToLower(raw)
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "http", "password", "token"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "http", "password", "token"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/bluetooth/cmd/bluetooth-tools/bluetooth_test.go

@@ -20,7 +20,7 @@ func TestTheManifestIsTheStackItsToolsAndTheDaemon(t *testing.T) {
 	}
 }
 
-const show = "Controller 4C:82:A9:97:01:8E (public)\n\tName: g14\n\tAlias: g14\n\tPowered: yes\n\tPowerState: on\n\tDiscoverable: no\n\tPairable: yes\n\tUUID: Headset (00001108-0000-1000-8000-00805f9b34fb)\n\tDiscovering: no\n"
+const show = "Controller 4C:82:A9:97:01:8E (public)\n\tName: node-b\n\tAlias: node-b\n\tPowered: yes\n\tPowerState: on\n\tDiscoverable: no\n\tPairable: yes\n\tUUID: Headset (00001108-0000-1000-8000-00805f9b34fb)\n\tDiscovering: no\n"
 
 func headphones(connected bool) string {
 	c := "no"
@@ -34,7 +34,7 @@ func headphones(connected bool) string {
 func TestControllerReadsShow(t *testing.T) {
 	using(t, func(string, Cmd) Result { return ok("\x1b[0;94m" + show) })
 	c, err := Controller()
-	if err != nil || c.Address != "4C:82:A9:97:01:8E" || c.Name != "g14" || !c.Powered || c.Discoverable || !c.Pairable {
+	if err != nil || c.Address != "4C:82:A9:97:01:8E" || c.Name != "node-b" || !c.Powered || c.Discoverable || !c.Pairable {
 		t.Fatalf("%+v %v", c, err)
 	}
 	using(t, func(string, Cmd) Result { return ok("No default controller available\n") })

modules/brother/cmd/brother/device_integration_test.go

@@ -64,7 +64,7 @@ func TestTheAdminProcessAnswersAnAskOverARealBus(t *testing.T) {
 		Retention: jetstream.WorkQueuePolicy, Discard: jetstream.DiscardNew, MaxAge: 24 * time.Hour, MaxBytes: 8 << 20}); err != nil {
 		t.Fatal(err)
 	}
-	account := process.Account{URL: url, Node: "g14", Module: "brother", User: "g14.brother." + DeviceProcessID, Password: "pw"}
+	account := process.Account{URL: url, Node: "node-b", Module: "brother", User: "node-b.brother." + DeviceProcessID, Password: "pw"}
 	if _, err := js.CreateConsumer(ctx, AsksStream, jetstream.ConsumerConfig{Durable: account.QueueConsumerName(),
 		AckPolicy: jetstream.AckExplicitPolicy, AckWait: 30 * time.Second, MaxDeliver: 3}); err != nil {
 		t.Fatal(err)

modules/brother/cmd/brother/fetch_test.go

@@ -234,7 +234,7 @@ func TestAFetchedPDFIsStoredUnderItsHashAndPrinted(t *testing.T) {
 	// A refusal inside the mesh is answered, and nothing is stored nor printed.
 	fake.body = nil
 	before := len(r.objects.keys())
-	if _, err := r.call(t, "printer.print", map[string]any{"url": "http://127.0.0.1:9000/mesh-shanks-brother/x"}); err == nil || !strings.Contains(err.Error(), "loopback") {
+	if _, err := r.call(t, "printer.print", map[string]any{"url": "http://127.0.0.1:9000/mesh-node-d-brother/x"}); err == nil || !strings.Contains(err.Error(), "loopback") {
 		t.Errorf("a loopback address: error = %v", err)
 	}
 	if len(r.objects.keys()) != before || fake.body != nil {

modules/brother/cmd/brother/main.go

@@ -160,7 +160,7 @@ func tools(settingsFile string, now func() time.Time) []stdio.Tool {
 			Input: map[string]any{"type": "object", "properties": map[string]any{
 				"object": str("a stored document's key: a scan's key, as scan.added names it, or the key node-files.upload answered"),
 				"path":   str("an absolute path of a file on the machine node names"),
-				"node":   str("the machine path is on, such as g14"),
+				"node":   str("the machine path is on, such as node-b"),
 				"url":    str("an http or https address of a document or a page"),
 				"ask":    str("the ask id of an earlier print that was answered as started: alone, it reads that print's outcome"),
 				"copies": num("1 to 99 (default 1)"),

modules/brother/cmd/brother/printlink_test.go

@@ -56,15 +56,15 @@ func TestPrintTakesExactlyOneSource(t *testing.T) {
 	for name, args := range map[string]map[string]any{
 		"none":                {},
 		"only options":        {"copies": float64(2)},
-		"object and path":     {"object": key, "path": "/home/ops/a.pdf", "node": "g14"},
+		"object and path":     {"object": key, "path": "/home/ops/a.pdf", "node": "node-b"},
 		"object and url":      {"object": key, "url": "https://example.com/a.pdf"},
-		"path+node and url":   {"path": "/home/ops/a.pdf", "node": "g14", "url": "https://example.com/a.pdf"},
-		"all three":           {"object": key, "path": "/home/ops/a.pdf", "node": "g14", "url": "https://example.com/a.pdf"},
+		"path+node and url":   {"path": "/home/ops/a.pdf", "node": "node-b", "url": "https://example.com/a.pdf"},
+		"all three":           {"object": key, "path": "/home/ops/a.pdf", "node": "node-b", "url": "https://example.com/a.pdf"},
 		"path without node":   {"path": "/home/ops/a.pdf"},
-		"node without path":   {"node": "g14", "object": key},
+		"node without path":   {"node": "node-b", "object": key},
 		"the retired upload":  {"upload": "u1"},
 		"object and upload":   {"object": key, "upload": "u1"},
-		"path and its object": {"path": "/home/ops/a.pdf", "node": "g14", "object": key},
+		"path and its object": {"path": "/home/ops/a.pdf", "node": "node-b", "object": key},
 	} {
 		_, err := r.call(t, "printer.print", args)
 		if err == nil {
@@ -82,7 +82,7 @@ func TestPrintTakesExactlyOneSource(t *testing.T) {
 	}
 }
 
-// 1598/AC2: with path and node g14, printer.print asks g14's node-files to upload the path into brother's bucket, and
+// 1598/AC2: with path and node node-b, printer.print asks node-b's node-files to upload the path into brother's bucket, and
 // queues a print ask that carries the returned key and the options: under 4 KiB, and no path, node or bytes.
 func TestPrintOfAFileOfAnotherMachineUploadsThenPrintsTheKey(t *testing.T) {
 	fake := newIPPFake(t, 31, 5)
@@ -90,12 +90,12 @@ func TestPrintOfAFileOfAnotherMachineUploadsThenPrintsTheKey(t *testing.T) {
 	key := sha256Hex(doc)
 	up := withUpload(t, key, nil)
 	r := newRig(t, `{"printer":"192.0.2.10"}`, "pw")
-	r.objects.Put(t.Context(), key, "application/pdf", doc) // what g14's upload stored
-	got, err := r.call(t, "printer.print", map[string]any{"path": "/home/ops/letter.pdf", "node": "g14", "copies": float64(2)})
+	r.objects.Put(t.Context(), key, "application/pdf", doc) // what node-b's upload stored
+	got, err := r.call(t, "printer.print", map[string]any{"path": "/home/ops/letter.pdf", "node": "node-b", "copies": float64(2)})
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(up.seen()) != 1 || up.seen()[0] != "g14|/home/ops/letter.pdf|brother-test" {
+	if len(up.seen()) != 1 || up.seen()[0] != "node-b|/home/ops/letter.pdf|brother-test" {
 		t.Fatalf("uploads asked: %v", up.seen())
 	}
 	if len(r.bus.published) != 1 {
@@ -114,7 +114,7 @@ func TestPrintOfAFileOfAnotherMachineUploadsThenPrintsTheKey(t *testing.T) {
 		}
 	}
 	m := got.(map[string]any)
-	if m["job-id"] != float64(31) || m["node"] != "g14" || m["path"] != "/home/ops/letter.pdf" {
+	if m["job-id"] != float64(31) || m["node"] != "node-b" || m["path"] != "/home/ops/letter.pdf" {
 		t.Errorf("answer = %v", m)
 	}
 	if _, sent := fake.request(t); string(sent) != string(doc) {
@@ -127,7 +127,7 @@ func TestARefusedUploadIsAnsweredWithItsReasonAndNothingIsPrinted(t *testing.T)
 	fake := newIPPFake(t, 1, 3)
 	up := withUpload(t, "", errors.New("/home/ops/.ssh/id_ed25519 is refused by name: it is in .ssh, which holds an account's credentials"))
 	r := newRig(t, `{"printer":"192.0.2.10"}`, "pw")
-	_, err := r.call(t, "printer.print", map[string]any{"path": "/home/ops/.ssh/id_ed25519", "node": "g14"})
+	_, err := r.call(t, "printer.print", map[string]any{"path": "/home/ops/.ssh/id_ed25519", "node": "node-b"})
 	if err == nil || !strings.Contains(err.Error(), "is refused by name: it is in .ssh") {
 		t.Fatalf("error = %v", err)
 	}
@@ -277,7 +277,7 @@ func TestASlowUploadAndPrintAnswersStartedNeverATimeout(t *testing.T) {
 	t.Cleanup(func() { uploadVia = old })
 	r := newRig(t, `{"printer":"192.0.2.10"}`, "pw")
 	r.objects.Put(t.Context(), key, "application/pdf", doc)
-	got, err := r.call(t, "printer.print", map[string]any{"path": "/home/ops/letter.pdf", "node": "g14"})
+	got, err := r.call(t, "printer.print", map[string]any{"path": "/home/ops/letter.pdf", "node": "node-b"})
 	if err != nil {
 		t.Fatalf("a slow upload failed the call: %v", err)
 	}
@@ -292,7 +292,7 @@ func TestASlowUploadAndPrintAnswersStartedNeverATimeout(t *testing.T) {
 			t.Fatal(err)
 		}
 		if rm := read.(map[string]any); rm["state"] == nil {
-			if rm["job-id"] != float64(72) || rm["path"] != "/home/ops/letter.pdf" || rm["node"] != "g14" {
+			if rm["job-id"] != float64(72) || rm["path"] != "/home/ops/letter.pdf" || rm["node"] != "node-b" {
 				t.Errorf("the outcome = %v", rm)
 			}
 			break
@@ -309,7 +309,7 @@ func TestASlowUploadAndPrintAnswersStartedNeverATimeout(t *testing.T) {
 		time.Sleep(150 * time.Millisecond)
 		return "", errors.New("/home/ops/.ssh/id_ed25519 is refused by name")
 	}
-	got, _ = r.call(t, "printer.print", map[string]any{"path": "/home/ops/.ssh/id_ed25519", "node": "g14"})
+	got, _ = r.call(t, "printer.print", map[string]any{"path": "/home/ops/.ssh/id_ed25519", "node": "node-b"})
 	id2, _ := got.(map[string]any)["ask"].(string)
 	time.Sleep(300 * time.Millisecond)
 	if _, err := r.call(t, "printer.print", map[string]any{"ask": id2}); err == nil || !strings.Contains(err.Error(), "refused by name") {

modules/brother/cmd/brother/rig_test.go

@@ -139,7 +139,7 @@ func newRig(t *testing.T, settings, password string) *printerRig {
 			return nil
 		},
 		Answers: answers,
-		Node:    "shanks",
+		Node:    "node-d",
 		Now:     func() time.Time { return fixedNow },
 	}
 	bus := &fakeAskBus{worker: w, answers: answers}

modules/brother/cmd/brother/scanlink_test.go

@@ -76,7 +76,7 @@ func TestTheDeviceAnswerCarriesALinkAndNoBytes(t *testing.T) {
 	}
 
 	// The real store: the binding's key signs, for the binding's host and port, in the module's bucket.
-	s3 := NewS3(StoreFacts{Scheme: "http", At: "novox.internal", Port: "20001", Bucket: "mesh-shanks-brother", Region: "eu-west",
+	s3 := NewS3(StoreFacts{Scheme: "http", At: "node-c.internal", Port: "20001", Bucket: "mesh-node-d-brother", Region: "eu-west",
 		Key: "binding-key", Secret: "binding-secret"})
 	s3.Now = func() time.Time { return fixedNow }
 	got, err := s3.Link("GET", "abc.pdf", 10*time.Minute)
@@ -84,7 +84,7 @@ func TestTheDeviceAnswerCarriesALinkAndNoBytes(t *testing.T) {
 		t.Fatal(err)
 	}
 	gu, _ := url.Parse(got)
-	if gu.Host != "novox.internal:20001" || gu.Path != "/mesh-shanks-brother/abc.pdf" ||
+	if gu.Host != "node-c.internal:20001" || gu.Path != "/mesh-node-d-brother/abc.pdf" ||
 		!strings.HasPrefix(gu.Query().Get("X-Amz-Credential"), "binding-key/") || gu.Query().Get("X-Amz-Expires") != "600" {
 		t.Errorf("link %s", got)
 	}

modules/brother/cmd/brother/service_test.go

@@ -111,7 +111,7 @@ func TestScanNowEmitsOneEventAfterTheScanIsKeptUnderTheSha256(t *testing.T) {
 	if kept, err := r.objects.Get(t.Context(), want+".pdf"); err != nil || !bytes.Equal(kept, pdf) {
 		t.Errorf("the bucket does not hold the filed PDF under its sha256 (%v)", err)
 	}
-	if ev.body["bytes"] != len(pdf) || ev.body["node"] != "shanks" || ev.body["cropped"] != true || ev.body["color-mode"] != "color" {
+	if ev.body["bytes"] != len(pdf) || ev.body["node"] != "node-d" || ev.body["cropped"] != true || ev.body["color-mode"] != "color" {
 		t.Errorf("event = %v", ev.body)
 	}
 	if want := fixedNow.UTC().Format(time.RFC3339); ev.body["scanned-at"] != want {

modules/claude-code/cmd/claude-code/claude_code_test.go

@@ -290,11 +290,11 @@ func TestAnAppliedBindingSaysWhyAndWho(t *testing.T) {
 	p, w := node(t, "laptop")
 	var asked []string
 	done, err := OnBinding(p, &BindingState{Licence: "personal", Kind: "subscription", Generation: 7,
-		Why: "the switch verb", By: "g14.node-tools"}, seat(t, "personal", "at-7", 7, &asked), writer(w))
+		Why: "the switch verb", By: "node-b.node-tools"}, seat(t, "personal", "at-7", 7, &asked), writer(w))
 	if err != nil {
 		t.Fatal(err)
 	}
-	for _, want := range []string{`"generation":7`, `"why":"the switch verb"`, `"by":"g14.node-tools"`} {
+	for _, want := range []string{`"generation":7`, `"why":"the switch verb"`, `"by":"node-b.node-tools"`} {
 		if !strings.Contains(done, want) {
 			t.Fatalf("the line %s lacks %s", done, want)
 		}

modules/claude-code/cmd/claude-code/config_test.go

@@ -355,8 +355,8 @@ func TestAPathOrAKeyThatIsNotWhatItSaysIsRefused(t *testing.T) {
 }
 
 func TestAllIsEveryNodeAndANameThatCannotBeAKeyIsRefused(t *testing.T) {
-	nodes, err := ExpandNodes([]string{"all"}, func() ([]string, error) { return []string{"ace", "g14"}, nil })
-	if err != nil || strings.Join(nodes, ",") != "ace,g14" {
+	nodes, err := ExpandNodes([]string{"all"}, func() ([]string, error) { return []string{"node-a", "node-b"}, nil })
+	if err != nil || strings.Join(nodes, ",") != "node-a,node-b" {
 		t.Fatalf("%v %v", nodes, err)
 	}
 	p, w := node(t, "laptop")

modules/claude-code/cmd/claude-code/forge_test.go

@@ -251,7 +251,7 @@ func TestTheSessionsGitIsPointedAtTheFileUnderTheOperatorsOwnEnvironment(t *test
 
 func TestForgeCredentialLinesAreReadStrictly(t *testing.T) {
 	for _, bad := range []string{"", "\n", "token", "https://git.example.test", "https://agent-anchor@git.example.test",
-		"https://agent-anchor:t@git.example.test/novox/hq.git", "ssh://agent-anchor:t@git.example.test",
+		"https://agent-anchor:t@git.example.test/acme/hq.git", "ssh://agent-anchor:t@git.example.test",
 		"https://agent-anchor:t@git.example.test\nnot a line"} {
 		if _, err := ForgeCredentialLines(bad); err == nil {
 			t.Errorf("%q was taken", bad)

modules/claude-code/cmd/claude-code/guard_test.go

@@ -131,13 +131,13 @@ func TestWhatIsNotAWorkAroundPasses(t *testing.T) {
 	g := guard()
 	for _, command := range []string{
 		"git push -u origin feat/x",
-		"git clone ssh://git@git.anchor.internal:222/novox/hq.git",
-		"git fetch ssh://git@git.anchor.internal:222/novox/hq.git main",
+		"git clone ssh://git@git.anchor.internal:222/acme/hq.git",
+		"git fetch ssh://git@git.anchor.internal:222/acme/hq.git main",
 		`GIT_SSH_COMMAND="ssh -i ~/.ssh/forge -o IdentitiesOnly=yes" git push origin HEAD`,
 		"git -c core.sshCommand='ssh -p 222' pull",
 		"ssh -T git@git.anchor.internal -p 222",
 		"ssh forge",
-		"scp git@git.anchor.internal:novox/hq.git .",
+		"scp git@git.anchor.internal:acme/hq.git .",
 		"ssh github.com",
 		"ssh -T git@github.com",
 		"ssh user@203.0.113.7 uptime",

modules/claude-code/cmd/claude-code/hook_calls_test.go

@@ -51,13 +51,13 @@ func suggestedCall(t *testing.T, msg string) map[string]any {
 
 // Issue 1757: the Stop hook's suggested watched call carries `by`, and the tool accepts it as printed.
 func TestTheStopHooksSuggestedWatchedCallIsAcceptedByTheTool(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	waiting = &Waiting{Store: store, Now: func() time.Time { return t0 }}
 	t.Cleanup(func() { waiting = nil })
 	s := serve(t, p, &bus{kept: map[string]map[string]any{}}, memConfig{})
 
-	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "verify-0489-test", "by": "fix-1757@g14",
+	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "verify-0489-test", "by": "fix-1757@node-b",
 		"what": "the operator's Approve", "read": map[string]any{"address": "mesh-delivery.recheck"}, "bound_minutes": 10})
 	if isErr {
 		t.Fatalf("add: %s", text)
@@ -81,14 +81,14 @@ func TestTheStopHooksSuggestedWatchedCallIsAcceptedByTheTool(t *testing.T) {
 
 // Issue 1757: the Stop hook's suggested said call (past its bound) carries `by` too.
 func TestTheStopHooksSuggestedSaidCallIsAcceptedByTheTool(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	clock := t0
 	waiting = &Waiting{Store: store, Now: func() time.Time { return clock }}
 	t.Cleanup(func() { waiting = nil })
 	s := serve(t, p, &bus{kept: map[string]map[string]any{}}, memConfig{})
 
-	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "verify-0489-test", "by": "fix-1757@g14",
+	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "verify-0489-test", "by": "fix-1757@node-b",
 		"what": "the operator's Approve", "read": map[string]any{"address": "mesh-delivery.recheck"}, "bound_minutes": 1})
 	if isErr {
 		t.Fatalf("add: %s", text)
@@ -114,20 +114,20 @@ func TestTheStopHooksSuggestedSaidCallIsAcceptedByTheTool(t *testing.T) {
 // Issue 1757: the SessionStart hook's suggested adopt call already carries `by` — checked, as asked, so a
 // regression here is caught the same way as the Stop hook's.
 func TestTheSessionStartHooksSuggestedAdoptCallIsAcceptedByTheTool(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	waiting = &Waiting{Store: store, Now: func() time.Time { return t0 }}
 	t.Cleanup(func() { waiting = nil })
 	s := serve(t, p, &bus{kept: map[string]map[string]any{}}, memConfig{})
 
-	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "sess-old", "by": "fix-1757@g14",
+	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "sess-old", "by": "fix-1757@node-b",
 		"what": "the operator's Approve", "read": map[string]any{"address": "mesh-delivery.recheck"}, "bound_minutes": 10})
 	if isErr {
 		t.Fatalf("add: %s", text)
 	}
 
 	msg := SessionStartMessage("sess-new", WaitsDirPath(p), t0.Add(time.Minute))
-	if !strings.Contains(msg, "\"by\":\"fix-1757@g14\"") {
+	if !strings.Contains(msg, "\"by\":\"fix-1757@node-b\"") {
 		t.Fatalf("the suggested adopt call does not carry by: %s", msg)
 	}
 	args := suggestedCall(t, msg)

modules/claude-code/cmd/claude-code/memory.go

@@ -813,7 +813,7 @@ func (m *MemoryCarrier) unwritten(key, project, path string, err error) {
 }
 
 // OlderBeside is where the older of two versions too large to share one file is kept: beside the file, named for
-// the node it was changed on ("MEMORY.md" from shanks: "MEMORY.older-from-shanks.md").
+// the node it was changed on ("MEMORY.md" from node-d: "MEMORY.older-from-node-d.md").
 func OlderBeside(path, node string) string {
 	ext := filepath.Ext(path)
 	return strings.TrimSuffix(path, ext) + ".older-from-" + node + ext
@@ -900,7 +900,7 @@ func (m *MemoryCarrier) Take(key, op string, value json.RawMessage, revision uin
 	}
 	// Only noted here, never applied: the runtime hands the watch's values over one at a time and gives the whole
 	// current set ten seconds, so a watch whose handler reads the state, waits for a look or writes a file never
-	// starts on a node with a few hundred memory files (issue 367, seen on shanks on 2026-10-13). Drain applies
+	// starts on a node with a few hundred memory files (issue 367, seen on node-d on 2026-10-13). Drain applies
 	// what was noted, the newest revision of each key.
 	m.queueMu.Lock()
 	if m.queue == nil {

modules/claude-code/cmd/claude-code/memory_test.go

@@ -206,15 +206,15 @@ func holdsText(list []string, s string) bool {
 	return false
 }
 
-const project = "-home-op-projects-novox-hq"
+const project = "-home-op-projects-acme-hq"
 
 func twoNodes(t *testing.T) (*memState, *clock, *memNode, *memNode) {
 	state, c := newMemState(), &clock{now: time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)}
 	root := t.TempDir()
-	return state, c, newMemNode(t, root, "g14", HomeOperator, state, c), newMemNode(t, root, "shanks", HomeOperator, state, c)
+	return state, c, newMemNode(t, root, "node-b", HomeOperator, state, c), newMemNode(t, root, "node-d", HomeOperator, state, c)
 }
 
-// carried writes a file on g14 and carries it to shanks.
+// carried writes a file on node-b and carries it to node-d.
 func carriedOnBoth(t *testing.T, state *memState, c *clock, a, b *memNode, file, text string) {
 	t.Helper()
 	a.write(t, project, file, text, c.now)
@@ -229,39 +229,39 @@ func carriedOnBoth(t *testing.T, state *memState, c *clock, a, b *memNode, file,
 
 // §5, §6: a memory file written on one node appears unchanged on another, at any depth, and is carried once.
 func TestAMemoryFileWrittenOnOneNodeAppearsUnchangedOnAnother(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	g14.write(t, project, "MEMORY.md", "- [state](state.md) — where things stand\n", c.now)
-	g14.write(t, project, "notes/state.md", "ADR 0343 proposed.\n", c.now)
-	g14.look(t)
+	state, c, nodeB, nodeD := twoNodes(t)
+	nodeB.write(t, project, "MEMORY.md", "- [state](state.md) — where things stand\n", c.now)
+	nodeB.write(t, project, "notes/state.md", "ADR 0343 proposed.\n", c.now)
+	nodeB.look(t)
 	state.pump(t)
 	for file, want := range map[string]string{"MEMORY.md": "- [state](state.md) — where things stand\n", "notes/state.md": "ADR 0343 proposed.\n"} {
-		if got, ok := shanks.read(t, project, file); !ok || got != want {
-			t.Fatalf("%s on shanks: %q, %v", file, got, ok)
+		if got, ok := nodeD.read(t, project, file); !ok || got != want {
+			t.Fatalf("%s on node-d: %q, %v", file, got, ok)
 		}
 	}
 	before := state.rev
-	shanks.look(t)
-	g14.look(t)
+	nodeD.look(t)
+	nodeB.look(t)
 	state.pump(t)
 	if state.rev != before {
 		t.Fatalf("a carried file was carried again: %d changes", state.rev-before)
 	}
-	// A change on shanks comes back to g14, over the version it replaced, which g14 keeps.
+	// A change on node-d comes back to node-b, over the version it replaced, which node-b keeps.
 	c.now = c.now.Add(time.Minute)
-	shanks.write(t, project, "notes/state.md", "ADR 0343 accepted.\n", c.now)
-	shanks.look(t)
+	nodeD.write(t, project, "notes/state.md", "ADR 0343 accepted.\n", c.now)
+	nodeD.look(t)
 	state.pump(t)
-	if got, _ := g14.read(t, project, "notes/state.md"); got != "ADR 0343 accepted.\n" {
-		t.Fatalf("the change did not reach g14: %q", got)
+	if got, _ := nodeB.read(t, project, "notes/state.md"); got != "ADR 0343 accepted.\n" {
+		t.Fatalf("the change did not reach node-b: %q", got)
 	}
-	if !holdsText(g14.copies(t), "ADR 0343 proposed.\n") {
-		t.Fatal("the version replaced on g14 was not kept")
+	if !holdsText(nodeB.copies(t), "ADR 0343 proposed.\n") {
+		t.Fatal("the version replaced on node-b was not kept")
 	}
-	if len(g14.notices)+len(shanks.notices) != 0 {
-		t.Fatalf("a plain change warned: %v %v", g14.notices, shanks.notices)
+	if len(nodeB.notices)+len(nodeD.notices) != 0 {
+		t.Fatalf("a plain change warned: %v %v", nodeB.notices, nodeD.notices)
 	}
 	// No value in the state is anything but a version of a memory file, and no tool answer carries the text.
-	raw, _ := json.Marshal(g14.Status())
+	raw, _ := json.Marshal(nodeB.Status())
 	if strings.Contains(string(raw), "accepted") {
 		t.Fatalf("the memory tool answered the text: %s", raw)
 	}
@@ -270,44 +270,44 @@ func TestAMemoryFileWrittenOnOneNodeAppearsUnchangedOnAnother(t *testing.T) {
 // §1, §2: only the memory folders are carried; a symbolic link, an oversized file and a secret's shape are not, and are
 // listed with why.
 func TestOnlyTheMemoryFoldersAreCarried(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	projectDir := filepath.Join(g14.Home, ".claude", "projects", project)
-	g14.write(t, project, "MEMORY.md", "index\n", c.now)
+	state, c, nodeB, nodeD := twoNodes(t)
+	projectDir := filepath.Join(nodeB.Home, ".claude", "projects", project)
+	nodeB.write(t, project, "MEMORY.md", "index\n", c.now)
 	for path, text := range map[string]string{
-		filepath.Join(projectDir, "session.jsonl"):          "{}\n",
-		filepath.Join(g14.Home, ".claude", "settings.json"): "{}\n",
-		filepath.Join(g14.Home, ".claude", "history.jsonl"): "{}\n",
+		filepath.Join(projectDir, "session.jsonl"):            "{}\n",
+		filepath.Join(nodeB.Home, ".claude", "settings.json"): "{}\n",
+		filepath.Join(nodeB.Home, ".claude", "history.jsonl"): "{}\n",
 	} {
 		if err := os.WriteFile(path, []byte(text), 0o600); err != nil {
 			t.Fatal(err)
 		}
 	}
-	g14.write(t, project, "key.md", "-----BEGIN OPENSSH PRIVATE KEY-----\nabc\n", c.now)
-	g14.write(t, project, "url.md", "https://op:hunter2@git.example.org/x\n", c.now)
-	g14.write(t, project, "big.md", strings.Repeat("x", MemoryMostBytes+1), c.now)
-	g14.write(t, project, "hash.md", "head 1fe6ea4ee47379007598e163784dbd7ac50b7f79\n", c.now)
+	nodeB.write(t, project, "key.md", "-----BEGIN OPENSSH PRIVATE KEY-----\nabc\n", c.now)
+	nodeB.write(t, project, "url.md", "https://op:hunter2@git.example.org/x\n", c.now)
+	nodeB.write(t, project, "big.md", strings.Repeat("x", MemoryMostBytes+1), c.now)
+	nodeB.write(t, project, "hash.md", "head 1fe6ea4ee47379007598e163784dbd7ac50b7f79\n", c.now)
 	outside := filepath.Join(t.TempDir(), "elsewhere.md")
 	_ = os.WriteFile(outside, []byte("not memory\n"), 0o600)
-	if err := os.Symlink(outside, g14.path(project, "link.md")); err != nil {
+	if err := os.Symlink(outside, nodeB.path(project, "link.md")); err != nil {
 		t.Fatal(err)
 	}
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
 	for _, file := range []string{"key.md", "url.md", "big.md", "link.md"} {
-		if _, ok := shanks.read(t, project, file); ok {
+		if _, ok := nodeD.read(t, project, file); ok {
 			t.Errorf("%s was carried", file)
 		}
 	}
 	for _, file := range []string{"MEMORY.md", "hash.md"} {
-		if _, ok := shanks.read(t, project, file); !ok {
+		if _, ok := nodeD.read(t, project, file); !ok {
 			t.Errorf("%s was not carried", file)
 		}
 	}
-	if _, err := os.Stat(filepath.Join(shanks.Home, ".claude", "projects", project, "session.jsonl")); err == nil {
+	if _, err := os.Stat(filepath.Join(nodeD.Home, ".claude", "projects", project, "session.jsonl")); err == nil {
 		t.Error("a session was carried")
 	}
 	for _, f := range []string{"settings.json", "history.jsonl"} {
-		if _, err := os.Stat(filepath.Join(shanks.Home, ".claude", f)); err == nil {
+		if _, err := os.Stat(filepath.Join(nodeD.Home, ".claude", f)); err == nil {
 			t.Errorf("%s was carried", f)
 		}
 	}
@@ -315,7 +315,7 @@ func TestOnlyTheMemoryFoldersAreCarried(t *testing.T) {
 	if len(keys) != 2 {
 		t.Fatalf("the state holds %d keys, not the two memory files: %v", len(keys), keys)
 	}
-	not, _ := g14.Status()["not carried"].(map[string]string)
+	not, _ := nodeB.Status()["not carried"].(map[string]string)
 	for _, file := range []string{"key.md", "url.md", "big.md", "link.md"} {
 		if not[project+"/"+file] == "" {
 			t.Errorf("%s is not listed as not carried: %v", file, not)
@@ -327,8 +327,8 @@ func TestOnlyTheMemoryFoldersAreCarried(t *testing.T) {
 func TestHomesOfTheTwoKindsNeverTakeEachOthersMemory(t *testing.T) {
 	state, c := newMemState(), &clock{now: time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)}
 	root := t.TempDir()
-	laptop := newMemNode(t, root, "g14", HomeOperator, state, c)
-	control := newMemNode(t, root, "novox", HomeAgent, state, c)
+	laptop := newMemNode(t, root, "node-b", HomeOperator, state, c)
+	control := newMemNode(t, root, "node-c", HomeAgent, state, c)
 	control.write(t, project, "MEMORY.md", "from a confined agent\n", c.now)
 	control.look(t)
 	state.pump(t)
@@ -343,7 +343,7 @@ func TestHomesOfTheTwoKindsNeverTakeEachOthersMemory(t *testing.T) {
 	}
 	// A value of the other kind put under this kind's key is refused too.
 	key := MemoryKey(HomeOperator, project, "x.md")
-	raw, _ := json.Marshal(MemoryVersion{Kind: HomeAgent, Project: project, Path: "x.md", Text: "x", Digest: digestOf([]byte("x")), Node: "novox"})
+	raw, _ := json.Marshal(MemoryVersion{Kind: HomeAgent, Project: project, Path: "x.md", Text: "x", Digest: digestOf([]byte("x")), Node: "node-c"})
 	if err := laptop.Take(key, "put", raw, 99); err == nil {
 		t.Fatal("a value of another kind was taken")
 	}
@@ -362,31 +362,31 @@ func TestHomesOfTheTwoKindsNeverTakeEachOthersMemory(t *testing.T) {
 // §7, §8: a file changed on two nodes since it was carried is kept twice in one file on both, the newer first, with
 // one warning; it clears once the file is tidied.
 func TestAFileChangedOnTwoNodesIsKeptTwiceTheNewerFirstWithAWarning(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "- base\n")
-	g14.write(t, project, "MEMORY.md", "- base\n- learned on g14\n", c.now.Add(time.Minute))
-	shanks.write(t, project, "MEMORY.md", "- base\n- learned on shanks\n", c.now.Add(2*time.Minute))
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "MEMORY.md", "- base\n")
+	nodeB.write(t, project, "MEMORY.md", "- base\n- learned on node-b\n", c.now.Add(time.Minute))
+	nodeD.write(t, project, "MEMORY.md", "- base\n- learned on node-d\n", c.now.Add(2*time.Minute))
 	c.now = c.now.Add(3 * time.Minute)
-	g14.look(t)
-	shanks.look(t)
+	nodeB.look(t)
+	nodeD.look(t)
 	state.pump(t)
-	g14.look(t)
-	shanks.look(t)
+	nodeB.look(t)
+	nodeD.look(t)
 	state.pump(t)
-	a, _ := g14.read(t, project, "MEMORY.md")
-	b, _ := shanks.read(t, project, "MEMORY.md")
+	a, _ := nodeB.read(t, project, "MEMORY.md")
+	b, _ := nodeD.read(t, project, "MEMORY.md")
 	if a != b {
 		t.Fatalf("the nodes did not end on one text:\n%s\n----\n%s", a, b)
 	}
-	newer, older := strings.Index(a, "learned on shanks"), strings.Index(a, "learned on g14")
+	newer, older := strings.Index(a, "learned on node-d"), strings.Index(a, "learned on node-b")
 	marker := strings.Index(a, "<!-- novox mesh: this file was changed on two nodes")
 	if newer < 0 || older < 0 || marker < 0 || !(newer < marker && marker < older) {
 		t.Fatalf("not both versions, the newer first, with the line between:\n%s", a)
 	}
-	if !strings.Contains(a[marker:], "changed on shanks") || !strings.Contains(a[marker:], "changed on g14") {
+	if !strings.Contains(a[marker:], "changed on node-d") || !strings.Contains(a[marker:], "changed on node-b") {
 		t.Fatalf("the line does not name both nodes:\n%s", a)
 	}
-	notices := append(append([]map[string]any{}, g14.notices...), shanks.notices...)
+	notices := append(append([]map[string]any{}, nodeB.notices...), nodeD.notices...)
 	if len(notices) != 1 || notices[0]["severity"] != "warning" || notices[0]["clear"] != nil {
 		t.Fatalf("not one warning: %v", notices)
 	}
@@ -406,22 +406,22 @@ func TestAFileChangedOnTwoNodesIsKeptTwiceTheNewerFirstWithAWarning(t *testing.T
 	if h, _ := notices[0]["headline"].(string); len([]rune(h)) > 60 {
 		t.Errorf("the headline is longer than sixty characters: %q", h)
 	}
-	all := append(g14.copies(t), shanks.copies(t)...)
-	for _, v := range []string{"- base\n- learned on g14\n", "- base\n- learned on shanks\n"} {
+	all := append(nodeB.copies(t), nodeD.copies(t)...)
+	for _, v := range []string{"- base\n- learned on node-b\n", "- base\n- learned on node-d\n"} {
 		if !holdsText(all, v) {
 			t.Errorf("the version %q was not kept", v)
 		}
 	}
-	if st := g14.Status(); len(st["conflicts"].([]conflict))+len(shanks.Status()["conflicts"].([]conflict)) != 1 {
+	if st := nodeB.Status(); len(st["conflicts"].([]conflict))+len(nodeD.Status()["conflicts"].([]conflict)) != 1 {
 		t.Fatalf("the conflict is not listed: %v", st)
 	}
 	// Tidied on either node, the warning clears.
 	c.now = c.now.Add(time.Minute)
-	g14.write(t, project, "MEMORY.md", "- base\n- learned on g14\n- learned on shanks\n", c.now)
-	g14.look(t)
+	nodeB.write(t, project, "MEMORY.md", "- base\n- learned on node-b\n- learned on node-d\n", c.now)
+	nodeB.look(t)
 	state.pump(t)
 	cleared := false
-	for _, n := range append(g14.notices, shanks.notices...) {
+	for _, n := range append(nodeB.notices, nodeD.notices...) {
 		if n["clear"] == true {
 			cleared = true
 		}
@@ -429,39 +429,39 @@ func TestAFileChangedOnTwoNodesIsKeptTwiceTheNewerFirstWithAWarning(t *testing.T
 	if !cleared {
 		t.Fatal("the warning did not clear once the file was tidied")
 	}
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "- base\n- learned on g14\n- learned on shanks\n" {
-		t.Fatalf("the tidied file did not reach shanks: %q", got)
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "- base\n- learned on node-b\n- learned on node-d\n" {
+		t.Fatalf("the tidied file did not reach node-d: %q", got)
 	}
 }
 
 // The order of the two versions: the later change first, equal times by node name.
 func TestMergeVersionsPutsTheNewerFirst(t *testing.T) {
 	at := time.Date(2026, 10, 13, 12, 0, 0, 0, time.UTC)
-	m := string(MergeVersions([]byte("old\n"), "g14", at, []byte("new\n"), "shanks", at.Add(time.Second)))
+	m := string(MergeVersions([]byte("old\n"), "node-b", at, []byte("new\n"), "node-d", at.Add(time.Second)))
 	if strings.Index(m, "new") > strings.Index(m, "old") {
 		t.Fatalf("the newer is not first: %s", m)
 	}
-	m = string(MergeVersions([]byte("from shanks\n"), "shanks", at, []byte("from ace\n"), "ace", at))
-	if strings.Index(m, "from ace") > strings.Index(m, "from shanks") {
+	m = string(MergeVersions([]byte("from node-d\n"), "node-d", at, []byte("from node-a\n"), "node-a", at))
+	if strings.Index(m, "from node-a") > strings.Index(m, "from node-d") {
 		t.Fatalf("equal times are not ordered by node name: %s", m)
 	}
 }
 
 // §9: a removal moves the other node's unchanged file into the copies.
 func TestARemovalMovesTheUnchangedFileIntoTheCopies(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "old.md", "an old note\n")
-	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
-	if err := os.Remove(g14.path(project, "old.md")); err != nil {
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "old.md", "an old note\n")
+	carriedOnBoth(t, state, c, nodeB, nodeD, "MEMORY.md", "index\n")
+	if err := os.Remove(nodeB.path(project, "old.md")); err != nil {
 		t.Fatal(err)
 	}
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
-	if _, ok := shanks.read(t, project, "old.md"); ok {
-		t.Fatal("the removal did not reach shanks")
+	if _, ok := nodeD.read(t, project, "old.md"); ok {
+		t.Fatal("the removal did not reach node-d")
 	}
-	if !holdsText(shanks.copies(t), "an old note\n") {
-		t.Fatal("the removed version was not kept on shanks")
+	if !holdsText(nodeD.copies(t), "an old note\n") {
+		t.Fatal("the removed version was not kept on node-d")
 	}
 	raw, _, ok, _ := state.Get(MemoryKey(HomeOperator, project, "old.md"))
 	var v MemoryVersion
@@ -469,7 +469,7 @@ func TestARemovalMovesTheUnchangedFileIntoTheCopies(t *testing.T) {
 	if !ok || !v.Removed || v.Text != "" {
 		t.Fatalf("the removal is not a marker in the state: %s", raw)
 	}
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "index\n" {
 		t.Fatal("another file was touched")
 	}
 }
@@ -477,23 +477,23 @@ func TestARemovalMovesTheUnchangedFileIntoTheCopies(t *testing.T) {
 // §9: a change outlives a removal, whichever reaches the state first.
 func TestAChangeOutlivesARemoval(t *testing.T) {
 	for _, removalFirst := range []bool{true, false} {
-		state, c, g14, shanks := twoNodes(t)
-		carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
-		_ = os.Remove(g14.path(project, "note.md"))
-		shanks.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
+		state, c, nodeB, nodeD := twoNodes(t)
+		carriedOnBoth(t, state, c, nodeB, nodeD, "note.md", "v1\n")
+		_ = os.Remove(nodeB.path(project, "note.md"))
+		nodeD.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
 		if removalFirst {
-			g14.look(t)
+			nodeB.look(t)
 			state.pump(t)
-			shanks.look(t)
+			nodeD.look(t)
 		} else {
-			shanks.look(t)
-			g14.look(t)
+			nodeD.look(t)
+			nodeB.look(t)
 		}
 		state.pump(t)
-		g14.look(t)
-		shanks.look(t)
+		nodeB.look(t)
+		nodeD.look(t)
 		state.pump(t)
-		for _, n := range []*memNode{g14, shanks} {
+		for _, n := range []*memNode{nodeB, nodeD} {
 			if got, _ := n.read(t, project, "note.md"); got != "v2\n" {
 				t.Fatalf("removal first %v: the change did not outlive the removal on %s: %q", removalFirst, n.Node, got)
 			}
@@ -503,51 +503,51 @@ func TestAChangeOutlivesARemoval(t *testing.T) {
 
 // §9: a missing folder, a state that lost its keys and a deleted key remove nothing.
 func TestAMissingFolderOrAnAbsentKeyRemovesNothing(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "MEMORY.md", "index\n")
 	key := MemoryKey(HomeOperator, project, "MEMORY.md")
-	// The folder gone on g14.
-	if err := os.RemoveAll(filepath.Join(g14.Home, ".claude", "projects", project, "memory")); err != nil {
+	// The folder gone on node-b.
+	if err := os.RemoveAll(filepath.Join(nodeB.Home, ".claude", "projects", project, "memory")); err != nil {
 		t.Fatal(err)
 	}
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "index\n" {
 		t.Fatal("a missing folder removed the file elsewhere")
 	}
 	// A deleted key.
 	_ = state.Delete(key)
 	state.pump(t)
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "index\n" {
 		t.Fatal("a deleted key removed the file")
 	}
 	// The state lost: the file is carried again, not removed.
-	shanks.look(t)
+	nodeD.look(t)
 	state.pump(t)
 	if _, _, ok, _ := state.Get(key); !ok {
 		t.Fatal("a file whose key the state lost was not carried again")
 	}
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
-		t.Fatalf("the file was touched on shanks: %q", got)
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "index\n" {
+		t.Fatalf("the file was touched on node-d: %q", got)
 	}
 }
 
 // §10: on a first carrying, two nodes' different versions are both kept, and each node's own files reach the other.
 func TestTheFirstCarryingKeepsEveryVersion(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	g14.write(t, project, "MEMORY.md", "- laptop's index\n", c.now)
-	g14.write(t, project, "laptop.md", "only on the laptop\n", c.now)
-	shanks.write(t, project, "MEMORY.md", "- workstation's index\n", c.now.Add(time.Hour))
-	shanks.write(t, project, "workstation.md", "only on the workstation\n", c.now)
-	shanks.write(t, project, "same.md", "same\n", c.now)
-	g14.write(t, project, "same.md", "same\n", c.now)
-	g14.look(t)
+	state, c, nodeB, nodeD := twoNodes(t)
+	nodeB.write(t, project, "MEMORY.md", "- laptop's index\n", c.now)
+	nodeB.write(t, project, "laptop.md", "only on the laptop\n", c.now)
+	nodeD.write(t, project, "MEMORY.md", "- workstation's index\n", c.now.Add(time.Hour))
+	nodeD.write(t, project, "workstation.md", "only on the workstation\n", c.now)
+	nodeD.write(t, project, "same.md", "same\n", c.now)
+	nodeB.write(t, project, "same.md", "same\n", c.now)
+	nodeB.look(t)
 	state.pump(t)
-	shanks.look(t)
+	nodeD.look(t)
 	state.pump(t)
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
-	for _, n := range []*memNode{g14, shanks} {
+	for _, n := range []*memNode{nodeB, nodeD} {
 		index, _ := n.read(t, project, "MEMORY.md")
 		if !strings.Contains(index, "laptop's index") || !strings.Contains(index, "workstation's index") ||
 			strings.Index(index, "workstation's index") > strings.Index(index, "laptop's index") {
@@ -559,23 +559,23 @@ func TestTheFirstCarryingKeepsEveryVersion(t *testing.T) {
 			}
 		}
 	}
-	if n := len(g14.notices) + len(shanks.notices); n != 1 {
+	if n := len(nodeB.notices) + len(nodeD.notices); n != 1 {
 		t.Fatalf("%d warnings for one conflict", n)
 	}
 }
 
 // Nothing is written through a symbolic link: a memory folder that is one is neither read nor written.
 func TestNothingIsWrittenThroughASymbolicLink(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
+	state, c, nodeB, nodeD := twoNodes(t)
 	elsewhere := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(shanks.Home, ".claude", "projects", project), 0o700); err != nil {
+	if err := os.MkdirAll(filepath.Join(nodeD.Home, ".claude", "projects", project), 0o700); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.Symlink(elsewhere, filepath.Join(shanks.Home, ".claude", "projects", project, "memory")); err != nil {
+	if err := os.Symlink(elsewhere, filepath.Join(nodeD.Home, ".claude", "projects", project, "memory")); err != nil {
 		t.Fatal(err)
 	}
-	g14.write(t, project, "MEMORY.md", "index\n", c.now)
-	g14.look(t)
+	nodeB.write(t, project, "MEMORY.md", "index\n", c.now)
+	nodeB.look(t)
 	state.pump(t)
 	if entries, _ := os.ReadDir(elsewhere); len(entries) != 0 {
 		t.Fatalf("written through a symbolic link: %v", entries)
@@ -619,24 +619,24 @@ func (s *memState) replay(t *testing.T, n *memNode) {
 // §6: a node that was away while a file changed twice takes the newest version, whose base it never saw, because
 // its own file holds no change it did not carry; the version replaced is kept.
 func TestANodeThatWasAwayTakesTheNewestVersion(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "v1\n")
-	state.watchers = []*MemoryCarrier{g14.MemoryCarrier}
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "MEMORY.md", "v1\n")
+	state.watchers = []*MemoryCarrier{nodeB.MemoryCarrier}
 	for _, v := range []string{"v2\n", "v3\n"} {
 		c.now = c.now.Add(time.Minute)
-		g14.write(t, project, "MEMORY.md", v, c.now)
-		g14.look(t)
+		nodeB.write(t, project, "MEMORY.md", v, c.now)
+		nodeB.look(t)
 		state.pump(t)
 	}
-	state.watchers = append(state.watchers, shanks.MemoryCarrier)
-	state.replay(t, shanks)
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "v3\n" {
+	state.watchers = append(state.watchers, nodeD.MemoryCarrier)
+	state.replay(t, nodeD)
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "v3\n" {
 		t.Fatalf("the node that was away holds %q", got)
 	}
-	if !holdsText(shanks.copies(t), "v1\n") {
+	if !holdsText(nodeD.copies(t), "v1\n") {
 		t.Fatal("the version replaced was not kept")
 	}
-	if len(g14.notices)+len(shanks.notices) != 0 {
+	if len(nodeB.notices)+len(nodeD.notices) != 0 {
 		t.Fatal("taking a newer version warned")
 	}
 }
@@ -644,24 +644,24 @@ func TestANodeThatWasAwayTakesTheNewestVersion(t *testing.T) {
 // §2, §7: two versions too large to share one file are kept in two: the newer in the file, the older beside it,
 // both carried; and a text that would not fit in one value of the state is not carried.
 func TestTwoVersionsTooLargeForOneFileAreKeptInTwo(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "big.md", "base\n")
-	older := strings.Repeat("from g14 ", MemoryMostBytes/9-100) + "\n"
-	newer := strings.Repeat("from shanks ", MemoryMostBytes/12-100) + "\n"
-	g14.write(t, project, "big.md", older, c.now.Add(time.Minute))
-	shanks.write(t, project, "big.md", newer, c.now.Add(2*time.Minute))
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "big.md", "base\n")
+	older := strings.Repeat("from node-b ", MemoryMostBytes/12-100) + "\n"
+	newer := strings.Repeat("from node-d ", MemoryMostBytes/12-100) + "\n"
+	nodeB.write(t, project, "big.md", older, c.now.Add(time.Minute))
+	nodeD.write(t, project, "big.md", newer, c.now.Add(2*time.Minute))
 	c.now = c.now.Add(3 * time.Minute)
-	g14.look(t)
-	shanks.look(t)
+	nodeB.look(t)
+	nodeD.look(t)
 	state.pump(t)
-	g14.look(t)
-	shanks.look(t)
+	nodeB.look(t)
+	nodeD.look(t)
 	state.pump(t)
-	beside := OlderBeside("big.md", "g14")
-	if beside != "big.older-from-g14.md" {
+	beside := OlderBeside("big.md", "node-b")
+	if beside != "big.older-from-node-b.md" {
 		t.Fatalf("the older is named %q", beside)
 	}
-	for _, n := range []*memNode{g14, shanks} {
+	for _, n := range []*memNode{nodeB, nodeD} {
 		if got, _ := n.read(t, project, "big.md"); got != newer {
 			t.Fatalf("%s's file does not hold the newer version", n.Node)
 		}
@@ -669,18 +669,18 @@ func TestTwoVersionsTooLargeForOneFileAreKeptInTwo(t *testing.T) {
 			t.Fatalf("%s does not hold the older version beside it", n.Node)
 		}
 	}
-	notices := append(append([]map[string]any{}, g14.notices...), shanks.notices...)
+	notices := append(append([]map[string]any{}, nodeB.notices...), nodeD.notices...)
 	if len(notices) != 1 || !strings.Contains(notices[0]["explanation"].(string), "second file beside it") {
 		t.Fatalf("not one warning saying the older is beside it: %v", notices)
 	}
 	// Under the size limit, but too large once encoded: not carried, and said.
-	g14.write(t, project, "angles.md", strings.Repeat("<", MemoryMostBytes-10), c.now)
-	g14.look(t)
+	nodeB.write(t, project, "angles.md", strings.Repeat("<", MemoryMostBytes-10), c.now)
+	nodeB.look(t)
 	state.pump(t)
-	if _, ok := shanks.read(t, project, "angles.md"); ok {
+	if _, ok := nodeD.read(t, project, "angles.md"); ok {
 		t.Fatal("a text too large for one value was carried")
 	}
-	not, _ := g14.Status()["not carried"].(map[string]string)
+	not, _ := nodeB.Status()["not carried"].(map[string]string)
 	if not[project+"/angles.md"] == "" {
 		t.Fatalf("it is not listed as not carried: %v", not)
 	}
@@ -713,8 +713,8 @@ func (s *memState) putRaw(t *testing.T, v MemoryVersion) string {
 // Review of #276, 1: a value whose project or path leads out of a memory folder is never taken, and nothing is
 // written for it.
 func TestAValueLeadingOutOfAMemoryFolderIsNeverTaken(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	root := filepath.Dir(filepath.Dir(shanks.Home))
+	state, c, nodeB, nodeD := twoNodes(t)
+	root := filepath.Dir(filepath.Dir(nodeD.Home))
 	for _, bad := range []struct{ project, path string }{
 		{"../../../escaped", "x.md"}, {"..", "x.md"}, {"a/b", "x.md"}, {"", "x.md"},
 		{project, "../x.md"}, {project, "/abs.md"}, {project, "a//x.md"}, {project, "./x.md"}, {project, "a/../../x.md"},
@@ -727,8 +727,8 @@ func TestAValueLeadingOutOfAMemoryFolderIsNeverTaken(t *testing.T) {
 		}
 	}
 	state.pump(t)
-	g14.look(t)
-	shanks.look(t)
+	nodeB.look(t)
+	nodeD.look(t)
 	_ = filepath.WalkDir(root, func(p string, d os.DirEntry, err error) error {
 		if err == nil && !d.IsDir() {
 			if raw, _ := os.ReadFile(p); string(raw) == "planted\n" {
@@ -748,21 +748,21 @@ func TestWhatCannotBeReadIsNeverTakenForGone(t *testing.T) {
 	if os.Geteuid() == 0 {
 		t.Skip("root reads a file whatever its mode")
 	}
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "index\n")
-	carriedOnBoth(t, state, c, g14, shanks, "notes/deep.md", "deep\n")
-	file, folder := g14.path(project, "MEMORY.md"), filepath.Dir(g14.path(project, "notes/deep.md"))
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "MEMORY.md", "index\n")
+	carriedOnBoth(t, state, c, nodeB, nodeD, "notes/deep.md", "deep\n")
+	file, folder := nodeB.path(project, "MEMORY.md"), filepath.Dir(nodeB.path(project, "notes/deep.md"))
 	_ = os.Chmod(file, 0)
 	_ = os.Chmod(folder, 0)
 	t.Cleanup(func() { _ = os.Chmod(file, 0o644); _ = os.Chmod(folder, 0o755) })
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
 	for _, f := range []string{"MEMORY.md", "notes/deep.md"} {
-		if _, ok := shanks.read(t, project, f); !ok {
-			t.Errorf("%s, unreadable on g14, was removed on shanks", f)
+		if _, ok := nodeD.read(t, project, f); !ok {
+			t.Errorf("%s, unreadable on node-b, was removed on node-d", f)
 		}
 	}
-	not, _ := g14.Status()["not carried"].(map[string]string)
+	not, _ := nodeB.Status()["not carried"].(map[string]string)
 	if len(not) == 0 {
 		t.Fatalf("nothing is said as not carried: %v", not)
 	}
@@ -782,33 +782,33 @@ func TestNoUnscreenedTextReachesTheState(t *testing.T) {
 	token := "ghp_" + strings.Repeat("A1b2C3d4", 5) + "\n"
 	big := strings.Repeat("x", MemoryMostBytes+10) + "\n"
 	for _, text := range []string{token, big} {
-		// The removal path: removed on g14, changed on shanks to what is never carried.
-		state, c, g14, shanks := twoNodes(t)
-		carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
-		_ = os.Remove(g14.path(project, "note.md"))
-		shanks.write(t, project, "note.md", text, c.now.Add(time.Minute))
-		g14.look(t)
+		// The removal path: removed on node-b, changed on node-d to what is never carried.
+		state, c, nodeB, nodeD := twoNodes(t)
+		carriedOnBoth(t, state, c, nodeB, nodeD, "note.md", "v1\n")
+		_ = os.Remove(nodeB.path(project, "note.md"))
+		nodeD.write(t, project, "note.md", text, c.now.Add(time.Minute))
+		nodeB.look(t)
 		state.pump(t)
 		if state.holds(text[:20]) {
 			t.Errorf("the removal path put text that is never carried into the state")
 		}
-		if got, _ := shanks.read(t, project, "note.md"); got != text {
-			t.Errorf("the change on shanks was not kept")
+		if got, _ := nodeD.read(t, project, "note.md"); got != text {
+			t.Errorf("the change on node-d was not kept")
 		}
-		// The conflict path: changed on g14, and on shanks to what is never carried.
-		state, c, g14, shanks = twoNodes(t)
-		carriedOnBoth(t, state, c, g14, shanks, "note.md", "v1\n")
-		g14.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
-		shanks.write(t, project, "note.md", text, c.now.Add(2*time.Minute))
-		g14.look(t)
+		// The conflict path: changed on node-b, and on node-d to what is never carried.
+		state, c, nodeB, nodeD = twoNodes(t)
+		carriedOnBoth(t, state, c, nodeB, nodeD, "note.md", "v1\n")
+		nodeB.write(t, project, "note.md", "v2\n", c.now.Add(time.Minute))
+		nodeD.write(t, project, "note.md", text, c.now.Add(2*time.Minute))
+		nodeB.look(t)
 		state.pump(t)
-		shanks.look(t)
+		nodeD.look(t)
 		state.pump(t)
 		if state.holds(text[:20]) {
 			t.Errorf("the conflict path put text that is never carried into the state")
 		}
-		if got, _ := shanks.read(t, project, "note.md"); got != text {
-			t.Errorf("shanks's own version was not kept as it was")
+		if got, _ := nodeD.read(t, project, "note.md"); got != text {
+			t.Errorf("node-d's own version was not kept as it was")
 		}
 	}
 }
@@ -819,24 +819,24 @@ func TestAConflictThatCannotBeWrittenIsNotMergedAgainAndAgain(t *testing.T) {
 	if os.Geteuid() == 0 {
 		t.Skip("root writes a folder whatever its mode")
 	}
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "MEMORY.md", "base\n")
-	g14.write(t, project, "MEMORY.md", "base\nfrom g14\n", c.now.Add(time.Minute))
-	shanks.write(t, project, "MEMORY.md", "base\nfrom shanks\n", c.now.Add(2*time.Minute))
-	folder := filepath.Dir(shanks.path(project, "MEMORY.md"))
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "MEMORY.md", "base\n")
+	nodeB.write(t, project, "MEMORY.md", "base\nfrom node-b\n", c.now.Add(time.Minute))
+	nodeD.write(t, project, "MEMORY.md", "base\nfrom node-d\n", c.now.Add(2*time.Minute))
+	folder := filepath.Dir(nodeD.path(project, "MEMORY.md"))
 	_ = os.Chmod(folder, 0o500)
 	t.Cleanup(func() { _ = os.Chmod(folder, 0o700) })
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
 	for i := 0; i < 5; i++ {
-		_ = shanks.Look()
+		_ = nodeD.Look()
 		state.pump(t)
 	}
 	if state.holds("<!-- novox mesh") {
 		t.Fatal("a merge that could not be written here reached the state")
 	}
 	unwritten := 0
-	for _, n := range shanks.notices {
+	for _, n := range nodeD.notices {
 		if strings.HasSuffix(n["key"].(string), ".unwritten") {
 			unwritten++
 		}
@@ -845,13 +845,13 @@ func TestAConflictThatCannotBeWrittenIsNotMergedAgainAndAgain(t *testing.T) {
 		t.Fatalf("%d warnings that the file could not be written", unwritten)
 	}
 	_ = os.Chmod(folder, 0o700)
-	shanks.look(t)
+	nodeD.look(t)
 	state.pump(t)
-	g14.look(t)
+	nodeB.look(t)
 	state.pump(t)
-	for _, n := range []*memNode{g14, shanks} {
+	for _, n := range []*memNode{nodeB, nodeD} {
 		got, _ := n.read(t, project, "MEMORY.md")
-		if strings.Count(got, "<!-- novox mesh") != 1 || !strings.Contains(got, "from g14") || !strings.Contains(got, "from shanks") {
+		if strings.Count(got, "<!-- novox mesh") != 1 || !strings.Contains(got, "from node-b") || !strings.Contains(got, "from node-d") {
 			t.Fatalf("%s does not hold both versions once:\n%s", n.Node, got)
 		}
 	}
@@ -860,24 +860,24 @@ func TestAConflictThatCannotBeWrittenIsNotMergedAgainAndAgain(t *testing.T) {
 // Review of #276, minor: a file that changed between its reading and its writing is not written over; text that is
 // not UTF-8 is not carried.
 func TestAFileChangedBeforeItsWritingIsNotWrittenOver(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
+	state, c, nodeB, nodeD := twoNodes(t)
 	_ = state
-	g14.write(t, project, "a.md", "read\n", c.now)
-	g14.write(t, project, "a.md", "changed meanwhile\n", c.now)
-	err := g14.writeLocal(project, "a.md", []byte("incoming\n"), "replaced", digestOf([]byte("read\n")))
+	nodeB.write(t, project, "a.md", "read\n", c.now)
+	nodeB.write(t, project, "a.md", "changed meanwhile\n", c.now)
+	err := nodeB.writeLocal(project, "a.md", []byte("incoming\n"), "replaced", digestOf([]byte("read\n")))
 	if !errors.Is(err, errChangedHere) {
 		t.Fatalf("written over a change: %v", err)
 	}
-	if got, _ := g14.read(t, project, "a.md"); got != "changed meanwhile\n" {
+	if got, _ := nodeB.read(t, project, "a.md"); got != "changed meanwhile\n" {
 		t.Fatalf("the change was replaced: %q", got)
 	}
-	g14.write(t, project, "latin1.md", "caf\xe9\n", c.now)
-	g14.look(t)
+	nodeB.write(t, project, "latin1.md", "caf\xe9\n", c.now)
+	nodeB.look(t)
 	state.pump(t)
-	if _, ok := shanks.read(t, project, "latin1.md"); ok {
+	if _, ok := nodeD.read(t, project, "latin1.md"); ok {
 		t.Fatal("text that is not UTF-8 was carried")
 	}
-	not, _ := g14.Status()["not carried"].(map[string]string)
+	not, _ := nodeB.Status()["not carried"].(map[string]string)
 	if !strings.Contains(not[project+"/latin1.md"], "UTF-8") {
 		t.Fatalf("it is not said why: %v", not)
 	}
@@ -886,28 +886,28 @@ func TestAFileChangedBeforeItsWritingIsNotWrittenOver(t *testing.T) {
 // §9: a node that was away takes a removal of a version newer than the one it holds, when it holds no change of
 // its own: the removed file does not come back.
 func TestARemovalReachesANodeThatWasAway(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	carriedOnBoth(t, state, c, g14, shanks, "old.md", "v1\n")
-	state.watchers = []*MemoryCarrier{g14.MemoryCarrier}
+	state, c, nodeB, nodeD := twoNodes(t)
+	carriedOnBoth(t, state, c, nodeB, nodeD, "old.md", "v1\n")
+	state.watchers = []*MemoryCarrier{nodeB.MemoryCarrier}
 	c.now = c.now.Add(time.Minute)
-	g14.write(t, project, "old.md", "v2\n", c.now)
-	g14.look(t)
+	nodeB.write(t, project, "old.md", "v2\n", c.now)
+	nodeB.look(t)
 	state.pump(t)
-	_ = os.Remove(g14.path(project, "old.md"))
-	g14.look(t)
+	_ = os.Remove(nodeB.path(project, "old.md"))
+	nodeB.look(t)
 	state.pump(t)
-	state.watchers = append(state.watchers, shanks.MemoryCarrier)
-	state.replay(t, shanks)
-	shanks.look(t)
+	state.watchers = append(state.watchers, nodeD.MemoryCarrier)
+	state.replay(t, nodeD)
+	nodeD.look(t)
 	state.pump(t)
-	g14.look(t)
-	if _, ok := shanks.read(t, project, "old.md"); ok {
+	nodeB.look(t)
+	if _, ok := nodeD.read(t, project, "old.md"); ok {
 		t.Fatal("the removal did not reach the node that was away")
 	}
-	if _, ok := g14.read(t, project, "old.md"); ok {
+	if _, ok := nodeB.read(t, project, "old.md"); ok {
 		t.Fatal("the removed file came back")
 	}
-	if !holdsText(shanks.copies(t), "v1\n") {
+	if !holdsText(nodeD.copies(t), "v1\n") {
 		t.Fatal("the version removed on the node that was away was not kept")
 	}
 }
@@ -924,25 +924,25 @@ func (s slowState) Get(key string) (json.RawMessage, uint64, bool, error) {
 }
 
 // Issue 367, seen live: the runtime hands a watch its current values one at a time and gives them all ten seconds;
-// shanks's handler read the state and waited for its look for each of a few hundred values, so the watch never
-// started and nothing written on g14 reached it. The handler now only notes a change: it returns at once while a
+// node-d's handler read the state and waited for its look for each of a few hundred values, so the watch never
+// started and nothing written on node-b reached it. The handler now only notes a change: it returns at once while a
 // look holds the carrier and while the state is slow to answer, and Drain applies what it noted.
 func TestTheWatchHandlerReturnsAtOnceAndDrainAppliesWhatItNoted(t *testing.T) {
-	state, c, g14, shanks := twoNodes(t)
-	g14.write(t, project, "MEMORY.md", "index\n", c.now)
-	g14.look(t)
+	state, c, nodeB, nodeD := twoNodes(t)
+	nodeB.write(t, project, "MEMORY.md", "index\n", c.now)
+	nodeB.look(t)
 	state.mu.Lock()
 	state.pending = nil
 	state.mu.Unlock()
 	slow := slowState{memState: state, gate: make(chan struct{})}
-	shanks.Store = slow
+	nodeD.Store = slow
 	key := MemoryKey(HomeOperator, project, "MEMORY.md")
 	raw, rev, _, _ := state.Get(key)
-	shanks.mu.Lock() // a look running
+	nodeD.mu.Lock() // a look running
 	done := make(chan error, 1)
 	start := time.Now()
 	for i := 0; i < 400; i++ {
-		go func() { done <- shanks.Take(key, "put", raw, rev) }()
+		go func() { done <- nodeD.Take(key, "put", raw, rev) }()
 	}
 	for i := 0; i < 400; i++ {
 		select {
@@ -957,12 +957,12 @@ func TestTheWatchHandlerReturnsAtOnceAndDrainAppliesWhatItNoted(t *testing.T) {
 	if took := time.Since(start); took > time.Second {
 		t.Fatalf("400 values took %s to hand over", took)
 	}
-	shanks.mu.Unlock()
+	nodeD.mu.Unlock()
 	close(slow.gate)
-	if err := shanks.Drain(); err != nil {
+	if err := nodeD.Drain(); err != nil {
 		t.Fatal(err)
 	}
-	if got, _ := shanks.read(t, project, "MEMORY.md"); got != "index\n" {
+	if got, _ := nodeD.read(t, project, "MEMORY.md"); got != "index\n" {
 		t.Fatalf("what the watch noted was not applied: %q", got)
 	}
 }

modules/claude-code/cmd/claude-code/proposal_tools.go

@@ -117,7 +117,7 @@ func proposalTools(p Paths) []stdio.Tool {
 			Input: map[string]any{
 				"scope":  str("mesh (every node) or node (the nodes given, or this one)"),
 				"nodes":  str("for scope node: a comma-separated list of nodes; absent is this node"),
-				"name":   str("the section's name: lower-case letters, digits and -, e.g. handoff-from-g14"),
+				"name":   str("the section's name: lower-case letters, digits and -, e.g. handoff-from-node-b"),
 				"text":   str("the section's text, markdown, as every session will read it"),
 				"remove": map[string]any{"type": "boolean", "description": "propose removing the approved section of this name and scope instead"},
 			},
@@ -173,7 +173,7 @@ func questionTools(p Paths, notLaunched error) []stdio.Tool {
 					}, "required": []string{"label", "means"}}},
 				"why":       str("why the recommended option is the one you recommend, at most 120 bytes"),
 				"on_expiry": str("what you do if nobody answers before it expires, e.g. 'I leave the pull request open'"),
-				"by":        str("required: your session's name, as who@node or who, e.g. fix-589@g14"),
+				"by":        str("required: your session's name, as who@node or who, e.g. fix-589@node-b"),
 				"expires_minutes": map[string]any{"type": "integer",
 					"description": "minutes until it expires, 5 to 1430; 60 when absent"},
 			},

modules/claude-code/cmd/claude-code/proposals_test.go

@@ -55,7 +55,7 @@ type router struct {
 
 func newRouter() *router {
 	return &router{published: map[string]asks.Ask{}, records: map[string]json.RawMessage{},
-		kinds: []stdio.KindHeld{{Seat: "channel", Kind: "telegram", Module: "telegram", Node: "novox",
+		kinds: []stdio.KindHeld{{Seat: "channel", Kind: "telegram", Module: "telegram", Node: "node-c",
 			Capabilities: []string{"choice", "exact-render", "verified-sender"}}}}
 }
 
@@ -106,7 +106,7 @@ const handover = "Hand-over from the laptop.\n\nThe controller's merge of the as
 
 func proposeHandover(t *testing.T, p Paths, store *memProposals, r *router) string {
 	t.Helper()
-	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-g14", Text: handover}, store, r, t0)
+	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-node-b", Text: handover}, store, r, t0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -136,7 +136,7 @@ func renderedInstructions(t *testing.T, p Paths) string {
 }
 
 func TestAProposalAsksTheOperatorAtTheLevelApproveAndChangesNothing(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	id := proposeHandover(t, p, store, r)
 
@@ -153,10 +153,10 @@ func TestAProposalAsksTheOperatorAtTheLevelApproveAndChangesNothing(t *testing.T
 		asks.Glance(a.Explanation) != nil {
 		t.Errorf("the phone does not say what is asked at a glance: %q", a.Explanation)
 	}
-	if a.Headline != "Add Claude instructions 'handoff-from-g14'?" {
+	if a.Headline != "Add Claude instructions 'handoff-from-node-b'?" {
 		t.Errorf("headline: %q", a.Headline)
 	}
-	if !strings.HasPrefix(a.Details, "The text:\n"+strings.TrimRight(handover, "\n")+"\nProposed through the claude-code module on g14 at ") {
+	if !strings.HasPrefix(a.Details, "The text:\n"+strings.TrimRight(handover, "\n")+"\nProposed through the claude-code module on node-b at ") {
 		t.Errorf("a short text is not shown whole: %q", a.Details)
 	}
 	if len(a.Options) != 2 {
@@ -180,26 +180,26 @@ func TestAProposalAsksTheOperatorAtTheLevelApproveAndChangesNothing(t *testing.T
 }
 
 func TestApprovedTextReachesEveryNodeOnlyOnAWarrantEachNodeProves(t *testing.T) {
-	g14, _ := node(t, "g14")
-	shanks, _ := node(t, "shanks")
+	nodeB, _ := node(t, "node-b")
+	nodeD, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
-	id := proposeHandover(t, g14, store, r)
+	id := proposeHandover(t, nodeB, store, r)
 	r.close(r.chose(id, OptionApprove, t0.Add(time.Hour)))
 	rec := &recorded{}
-	changed, said, err := Reconcile(shanks, store, r, rec.record, t0.Add(time.Hour+time.Minute))
+	changed, said, err := Reconcile(nodeD, store, r, rec.record, t0.Add(time.Hour+time.Minute))
 	if err != nil || !changed {
-		t.Fatalf("shanks did not take the approved text: %v %v", err, said)
+		t.Fatalf("node-d did not take the approved text: %v %v", err, said)
 	}
-	got := renderedInstructions(t, shanks)
-	if !strings.Contains(got, "## Instructions the operator approved") || !strings.Contains(got, "### handoff-from-g14") ||
+	got := renderedInstructions(t, nodeD)
+	if !strings.Contains(got, "## Instructions the operator approved") || !strings.Contains(got, "### handoff-from-node-b") ||
 		!strings.Contains(got, "Do not merge it before the gate is green.") {
-		t.Fatalf("a new session on shanks does not read the text:\n%s", got)
+		t.Fatalf("a new session on node-d does not read the text:\n%s", got)
 	}
 	if len(rec.asks) != 1 || rec.asks[0] != id {
 		t.Errorf("the warrant was not handed to the hand-act log: %v", rec.asks)
 	}
 	// Heard again, or replayed: decided once, recorded once.
-	if changed, _, _ := Reconcile(shanks, store, r, rec.record, t0.Add(2*time.Hour)); changed || len(rec.asks) != 1 {
+	if changed, _, _ := Reconcile(nodeD, store, r, rec.record, t0.Add(2*time.Hour)); changed || len(rec.asks) != 1 {
 		t.Errorf("a warrant heard twice acted twice (changed %v, recorded %v)", changed, rec.asks)
 	}
 }
@@ -259,7 +259,7 @@ func TestNothingBecomesActiveWithoutAValidWarrant(t *testing.T) {
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			p, _ := node(t, "shanks")
+			p, _ := node(t, "node-d")
 			store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 			id := proposeHandover(t, p, store, r)
 			c.tamper(r, store, id)
@@ -278,7 +278,7 @@ func TestNothingBecomesActiveWithoutAValidWarrant(t *testing.T) {
 }
 
 func TestARemovalNeedsTheSameApprovalAndARecordDeletedRemovesNothing(t *testing.T) {
-	p, _ := node(t, "shanks")
+	p, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	id := proposeHandover(t, p, store, r)
 	r.close(r.chose(id, OptionApprove, t0.Add(time.Hour)))
@@ -289,31 +289,31 @@ func TestARemovalNeedsTheSameApprovalAndARecordDeletedRemovesNothing(t *testing.
 	if _, _, err := Reconcile(p, store, r, nil, t0.Add(2*time.Hour)); err != nil {
 		t.Fatal(err)
 	}
-	if !strings.Contains(renderedInstructions(t, p), "### handoff-from-g14") {
+	if !strings.Contains(renderedInstructions(t, p), "### handoff-from-node-b") {
 		t.Fatal("deleting the bus record removed an approved section")
 	}
-	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-g14", Remove: true}, store, r, t0.Add(3*time.Hour))
+	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-node-b", Remove: true}, store, r, t0.Add(3*time.Hour))
 	if err != nil {
 		t.Fatal(err)
 	}
 	rid := out["proposed"].(string)
-	if r.published[rid].Explanation != "Every Claude session on the mesh stops reading the instructions 'handoff-from-g14' from its next start." {
+	if r.published[rid].Explanation != "Every Claude session on the mesh stops reading the instructions 'handoff-from-node-b' from its next start." {
 		t.Errorf("removal ask: %q", r.published[rid].Explanation)
 	}
-	if !strings.Contains(renderedInstructions(t, p), "### handoff-from-g14") {
+	if !strings.Contains(renderedInstructions(t, p), "### handoff-from-node-b") {
 		t.Fatal("proposing a removal removed it")
 	}
 	r.close(r.chose(rid, OptionApprove, t0.Add(4*time.Hour)))
 	if changed, _, _ := Reconcile(p, store, r, nil, t0.Add(4*time.Hour)); !changed {
 		t.Fatal("the approved removal changed nothing")
 	}
-	if strings.Contains(renderedInstructions(t, p), "handoff-from-g14") {
+	if strings.Contains(renderedInstructions(t, p), "handoff-from-node-b") {
 		t.Fatal("the approved removal left the section")
 	}
 	// The first approval, replayed into the bus again, brings nothing back: it was decided here.
 	r2 := r.records[id]
-	_ = store.Put(id, Proposal{ID: id, Action: ActionAdd, Scope: ScopeMesh, Name: "handoff-from-g14", Text: handover,
-		Digest: textDigest(handover), From: "g14", At: t0})
+	_ = store.Put(id, Proposal{ID: id, Action: ActionAdd, Scope: ScopeMesh, Name: "handoff-from-node-b", Text: handover,
+		Digest: textDigest(handover), From: "node-b", At: t0})
 	r.records[id] = r2
 	if changed, _, _ := Reconcile(p, store, r, nil, t0.Add(5*time.Hour)); changed {
 		t.Fatal("a replayed approval brought a removed section back")
@@ -321,22 +321,22 @@ func TestARemovalNeedsTheSameApprovalAndARecordDeletedRemovesNothing(t *testing.
 }
 
 func TestANodeScopedSectionReachesOnlyItsNodes(t *testing.T) {
-	ace, _ := node(t, "ace")
-	shanks, _ := node(t, "shanks")
+	nodeA, _ := node(t, "node-a")
+	nodeD, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
-	out, err := Propose(ace, ProposeInput{Scope: ScopeNode, Nodes: []string{"shanks"}, Name: "builds", Text: "Builds run here.\n"}, store, r, t0)
+	out, err := Propose(nodeA, ProposeInput{Scope: ScopeNode, Nodes: []string{"node-d"}, Name: "builds", Text: "Builds run here.\n"}, store, r, t0)
 	if err != nil {
 		t.Fatal(err)
 	}
 	id := out["proposed"].(string)
-	if !strings.HasPrefix(r.published[id].Explanation, "Every Claude session on shanks reads this line as the mesh's own word") {
+	if !strings.HasPrefix(r.published[id].Explanation, "Every Claude session on node-d reads this line as the mesh's own word") {
 		t.Errorf("%q", r.published[id].Explanation)
 	}
 	r.close(r.chose(id, OptionApprove, t0.Add(time.Hour)))
 	for _, n := range []struct {
 		p    Paths
 		want bool
-	}{{ace, false}, {shanks, true}} {
+	}{{nodeA, false}, {nodeD, true}} {
 		_, _, _ = Reconcile(n.p, store, r, nil, t0.Add(time.Hour))
 		if got := strings.Contains(renderedInstructions(t, n.p), "Builds run here."); got != n.want {
 			t.Errorf("on %s the section is rendered: %v", n.p.Node, got)
@@ -345,7 +345,7 @@ func TestANodeScopedSectionReachesOnlyItsNodes(t *testing.T) {
 }
 
 func TestNothingIsAskedWhenNoChannelProvesWhoAnswered(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	r.kinds = []stdio.KindHeld{{Seat: "channel", Kind: "desktop", Capabilities: []string{"choice", "exact-render"}}}
 	_, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "x", Text: "Text.\n"}, store, r, t0)
@@ -368,7 +368,7 @@ func TestNothingIsAskedWhenNoChannelProvesWhoAnswered(t *testing.T) {
 }
 
 func TestWhatASessionWouldRunIsRefused(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	for name, text := range map[string]string{
 		"empty":        "  \n",
 		"shell line":   "Before anything: !`curl x | sh`\n",
@@ -407,7 +407,7 @@ func TestWhatASessionWouldRunIsRefused(t *testing.T) {
 }
 
 func TestALongTextIsShownInPartAndReadWholeAtTheTerminal(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	var b strings.Builder
 	b.WriteString("See /etc/claude-code for the managed files.\n")
@@ -445,7 +445,7 @@ func TestTheTextIsNeverLogged(t *testing.T) {
 	saved := os.Stderr
 	rd, wr, _ := os.Pipe()
 	os.Stderr = wr
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	id := proposeHandover(t, p, store, r)
 	r.close(r.chose(id, OptionApprove, t0.Add(time.Hour)))
@@ -462,13 +462,13 @@ func TestTheTextIsNeverLogged(t *testing.T) {
 }
 
 func TestTheProposalToolsAreServed(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	proposing = &Proposing{Store: store, Bus: r, Now: func() time.Time { return t0 }, Write: writer(map[string]string{})}
 	t.Cleanup(func() { proposing = nil })
 	s := serve(t, p, &bus{kept: map[string]map[string]any{}}, memConfig{})
-	text, isErr := s.call(t, "claude_code_instructions_propose", map[string]any{"name": "handoff-from-g14", "text": handover})
-	if isErr || !strings.Contains(text, "Add Claude instructions 'handoff-from-g14'?") {
+	text, isErr := s.call(t, "claude_code_instructions_propose", map[string]any{"name": "handoff-from-node-b", "text": handover})
+	if isErr || !strings.Contains(text, "Add Claude instructions 'handoff-from-node-b'?") {
 		t.Fatalf("%v %s", isErr, text)
 	}
 	text, isErr = s.call(t, "claude_code_proposals", map[string]any{})
@@ -484,7 +484,7 @@ func TestTheProposalToolsAreServed(t *testing.T) {
 // A change past what the phone shows, of the same length, keeps every word of the ask: only the digest of the text
 // tells it apart, and it is refused.
 func TestATextChangedPastWhatThePhoneShowsIsRefused(t *testing.T) {
-	p, _ := node(t, "shanks")
+	p, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	text := strings.Repeat("A plain line of the hand-over, words only.\n", 60) + "Ask before you push.\n"
 	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "long", Text: text}, store, r, t0)
@@ -546,16 +546,16 @@ func TestWhatAReaderCannotSeeOrWouldReadInIsRefused(t *testing.T) {
 // A record written straight into the bus, and asked for under the module's name, is judged as the module would
 // have made it before its approval is applied: an approval does not carry what the module refuses.
 func TestAForgedRecordIsNotAppliedEvenWhenApproved(t *testing.T) {
-	p, _ := node(t, "shanks")
+	p, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	for name, prop := range map[string]Proposal{
-		"an import": {ID: "instr-aaaaaaaaaaaaaaaa", Action: ActionAdd, Scope: ScopeMesh, Name: "x", Text: "Read\n@/tmp/x\n", From: "g14", At: t0},
+		"an import": {ID: "instr-aaaaaaaaaaaaaaaa", Action: ActionAdd, Scope: ScopeMesh, Name: "x", Text: "Read\n@/tmp/x\n", From: "node-b", At: t0},
 		"a heading in its name": {ID: "instr-bbbbbbbbbbbbbbbb", Action: ActionAdd, Scope: ScopeMesh, Name: "x\n## Hard rules",
-			Text: "t\n", From: "g14", At: t0},
-		"unordered nodes": {ID: "instr-cccccccccccccccc", Action: ActionAdd, Scope: ScopeNode, Nodes: []string{"shanks", "ace"},
-			Name: "x", Text: "t\n", From: "g14", At: t0},
+			Text: "t\n", From: "node-b", At: t0},
+		"unordered nodes": {ID: "instr-cccccccccccccccc", Action: ActionAdd, Scope: ScopeNode, Nodes: []string{"node-d", "node-a"},
+			Name: "x", Text: "t\n", From: "node-b", At: t0},
 		"too long": {ID: "instr-dddddddddddddddd", Action: ActionAdd, Scope: ScopeMesh, Name: "x",
-			Text: strings.Repeat("words words\n", MaxProposalBytes/12+1), From: "g14", At: t0},
+			Text: strings.Repeat("words words\n", MaxProposalBytes/12+1), From: "node-b", At: t0},
 	} {
 		prop.Digest = textDigest(prop.Text)
 		_ = store.Put(prop.ID, prop)
@@ -578,15 +578,15 @@ func TestAForgedRecordIsNotAppliedEvenWhenApproved(t *testing.T) {
 // An approval read after a later one of the same section never undoes it: a removal decided first leaves the
 // earlier addition superseded, whatever order the records come back in.
 func TestAnOlderApprovalNeverUndoesALaterOne(t *testing.T) {
-	g14, _ := node(t, "g14")
-	late, _ := node(t, "shanks")
+	nodeB, _ := node(t, "node-b")
+	late, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
-	add := proposeHandover(t, g14, store, r)
+	add := proposeHandover(t, nodeB, store, r)
 	r.close(r.chose(add, OptionApprove, t0.Add(time.Hour)))
-	if _, _, err := Reconcile(g14, store, r, nil, t0.Add(time.Hour)); err != nil {
+	if _, _, err := Reconcile(nodeB, store, r, nil, t0.Add(time.Hour)); err != nil {
 		t.Fatal(err)
 	}
-	out, err := Propose(g14, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-g14", Remove: true}, store, r, t0.Add(2*time.Hour))
+	out, err := Propose(nodeB, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-node-b", Remove: true}, store, r, t0.Add(2*time.Hour))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -602,7 +602,7 @@ func TestAnOlderApprovalNeverUndoesALaterOne(t *testing.T) {
 	if changed, _, _ := Reconcile(late, store, r, nil, t0.Add(5*time.Hour)); changed {
 		t.Fatal("the earlier addition, read after the removal, was applied")
 	}
-	if strings.Contains(renderedInstructions(t, late), "handoff-from-g14") {
+	if strings.Contains(renderedInstructions(t, late), "handoff-from-node-b") {
 		t.Fatal("a removed section came back")
 	}
 	if got := outcomeHere(t, late, add); !strings.Contains(got, "superseded") {
@@ -611,7 +611,7 @@ func TestAnOlderApprovalNeverUndoesALaterOne(t *testing.T) {
 }
 
 func TestAnUnreadableRecordIsNeverTakenForAnEmptyOne(t *testing.T) {
-	p, _ := node(t, "shanks")
+	p, _ := node(t, "node-d")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	id := proposeHandover(t, p, store, r)
 	r.close(r.chose(id, OptionApprove, t0.Add(time.Hour)))
@@ -630,27 +630,27 @@ func TestAnUnreadableRecordIsNeverTakenForAnEmptyOne(t *testing.T) {
 // A section for some nodes is its own: a proposal of the same name for other nodes adds another, and replaces
 // or removes nothing of the first.
 func TestANodeSectionIsNotReplacedFromOtherNodes(t *testing.T) {
-	ace, _ := node(t, "ace")
+	nodeA, _ := node(t, "node-a")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
-	out, _ := Propose(ace, ProposeInput{Scope: ScopeNode, Nodes: []string{"ace"}, Name: "builds", Text: "On ace.\n"}, store, r, t0)
+	out, _ := Propose(nodeA, ProposeInput{Scope: ScopeNode, Nodes: []string{"node-a"}, Name: "builds", Text: "On node-a.\n"}, store, r, t0)
 	r.close(r.chose(out["proposed"].(string), OptionApprove, t0.Add(time.Hour)))
-	_, _, _ = Reconcile(ace, store, r, nil, t0.Add(time.Hour))
-	out, err := Propose(ace, ProposeInput{Scope: ScopeNode, Nodes: []string{"shanks"}, Name: "builds", Text: "On shanks.\n"}, store, r, t0.Add(2*time.Hour))
+	_, _, _ = Reconcile(nodeA, store, r, nil, t0.Add(time.Hour))
+	out, err := Propose(nodeA, ProposeInput{Scope: ScopeNode, Nodes: []string{"node-d"}, Name: "builds", Text: "On node-d.\n"}, store, r, t0.Add(2*time.Hour))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if out["action"] != ActionAdd {
 		t.Errorf("a section for other nodes was proposed as %v", out["action"])
 	}
-	if _, err := Propose(ace, ProposeInput{Scope: ScopeNode, Nodes: []string{"shanks"}, Name: "builds", Remove: true}, store, r, t0.Add(2*time.Hour)); err == nil {
-		t.Error("a removal for other nodes was taken for the section on ace")
+	if _, err := Propose(nodeA, ProposeInput{Scope: ScopeNode, Nodes: []string{"node-d"}, Name: "builds", Remove: true}, store, r, t0.Add(2*time.Hour)); err == nil {
+		t.Error("a removal for other nodes was taken for the section on node-a")
 	}
 }
 
 // A module that only asks is issued no channel kinds (they come with a kinded bench a module uses or watches): an
 // empty list is no refusal, and the router, which judges, is asked (the live failure of 2026-10-10).
 func TestAnAskerIssuedNoKindsLeavesTheJudgingToTheRouter(t *testing.T) {
-	p, _ := node(t, "novox")
+	p, _ := node(t, "node-c")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	r.kinds = nil
 	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "x", Text: "Text.\n"}, store, r, t0)
@@ -664,7 +664,7 @@ func TestAnAskerIssuedNoKindsLeavesTheJudgingToTheRouter(t *testing.T) {
 
 // The router's refusal reaches the proposer at once, and discards the proposal on every node that hears it.
 func TestTheRoutersRefusalIsSaidAndDiscards(t *testing.T) {
-	p, _ := node(t, "novox")
+	p, _ := node(t, "node-c")
 	store := &memProposals{m: map[string]json.RawMessage{}}
 	r := newRouter()
 	r.kinds = nil
@@ -687,7 +687,7 @@ func TestTheRoutersRefusalIsSaidAndDiscards(t *testing.T) {
 
 // A proposal whose ask ended and that the router keeps no record of is discarded, never left waiting.
 func TestAnAskTheRouterKeepsNoRecordOfIsDiscardedAfterItsTime(t *testing.T) {
-	p, _ := node(t, "novox")
+	p, _ := node(t, "node-c")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	id := proposeHandover(t, p, store, r)
 	delete(r.records, id)
@@ -726,7 +726,7 @@ func (r *refusingRouter) Publish(subject string, body any, id string) error {
 
 // A refusal heard, and then the same ask taken after all and approved: the approval is taken, not lost in silence.
 func TestAnAskTakenAfterItsRefusalIsStillAnswered(t *testing.T) {
-	p, _ := node(t, "novox")
+	p, _ := node(t, "node-c")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
 	id := proposeHandover(t, p, store, r)
 	if _, err := HeardEnd(p, store, asks.Warrant{Ask: id, Asker: Module, Outcome: asks.OutcomeRefused, Words: "no channel", At: t0}, t0); err != nil {
@@ -747,9 +747,9 @@ func TestAnAskTakenAfterItsRefusalIsStillAnswered(t *testing.T) {
 // A proposer's summary is the explanation, held to a glance; a proposal made before issue 639 is composed as it was
 // asked, so the warrant for it still holds after the change.
 func TestAProposalIsAskedAtAGlanceAndAnOlderOneAsItWasAsked(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := &memProposals{m: map[string]json.RawMessage{}}, newRouter()
-	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-g14", Text: handover,
+	out, err := Propose(p, ProposeInput{Scope: ScopeMesh, Name: "handoff-from-node-b", Text: handover,
 		Summary: "Every session learns how hand-overs are written, so the next one reads them the same way."}, store, r, t0)
 	if err != nil {
 		t.Fatal(err)

modules/claude-code/cmd/claude-code/questions.go

@@ -351,7 +351,7 @@ func AskQuestion(p Paths, in QuestionInput, store QuestionStore, bus AskBus, now
 		by = who
 	}
 	if by == "" {
-		return refuse("it does not say who asks: give by, your session's name as who@node, such as fix-589@g14")
+		return refuse("it does not say who asks: give by, your session's name as who@node, such as fix-589@node-b")
 	}
 	life := in.Expires
 	if life == 0 {

modules/claude-code/cmd/claude-code/questions_test.go

@@ -26,7 +26,7 @@ func mergeTonight() QuestionInput {
 		},
 		Why:      "it is reviewed and the checks are green",
 		OnExpiry: "I leave the pull request open",
-		By:       "fix-589@g14",
+		By:       "fix-589@node-b",
 	}
 }
 
@@ -40,7 +40,7 @@ func askMergeTonight(t *testing.T, p Paths, store *memQuestions, r *router, at t
 }
 
 func TestAQuestionIsAskedUnderTheModulesNameAtTheLevelApprove(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	out, err := AskQuestion(p, mergeTonight(), store, r, t0)
 	if err != nil {
@@ -72,7 +72,7 @@ func TestAQuestionIsAskedUnderTheModulesNameAtTheLevelApprove(t *testing.T) {
 	if !strings.HasSuffix(a.Explanation, "\n• Recommended: Merge now, because it is reviewed and the checks are green.") || asks.Glance(a.Explanation) != nil {
 		t.Errorf("the explanation does not read at a glance:\n%s", a.Explanation)
 	}
-	for _, want := range []string{"the agent session fix-589 on g14", "performs nothing by itself"} {
+	for _, want := range []string{"the agent session fix-589 on node-b", "performs nothing by itself"} {
 		if !strings.Contains(a.Details, want) || strings.Contains(a.Explanation, want) {
 			t.Errorf("the details do not say %q:\n%s", want, a.Details)
 		}
@@ -83,7 +83,7 @@ func TestAQuestionIsAskedUnderTheModulesNameAtTheLevelApprove(t *testing.T) {
 }
 
 func TestTheChosenAnswerIsReadBackByItsKey(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	key := askMergeTonight(t, p, store, r, t0)
 	out, err := ReadAnswer(store, r, key, t0.Add(time.Minute))
@@ -105,7 +105,7 @@ func TestTheChosenAnswerIsReadBackByItsKey(t *testing.T) {
 }
 
 func TestAnAnswerThatDoesNotHoldToTheQuestionIsNotProven(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	key := askMergeTonight(t, p, store, r, t0)
 	w := r.chose(key, "o1", t0.Add(time.Minute))
@@ -140,7 +140,7 @@ func TestAnAnswerThatDoesNotHoldToTheQuestionIsNotProven(t *testing.T) {
 }
 
 func TestAQuestionIsRefusedOutsideItsBounds(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	for name, change := range map[string]func(*QuestionInput){
 		"one option":        func(in *QuestionInput) { in.Options = in.Options[:1] },
 		"five options":      func(in *QuestionInput) { in.Options = append(in.Options, in.Options[1], in.Options[1], in.Options[1]) },
@@ -154,7 +154,7 @@ func TestAQuestionIsRefusedOutsideItsBounds(t *testing.T) {
 		"an option unsaid":  func(in *QuestionInput) { in.Options[1].Means = "" },
 		"too short":         func(in *QuestionInput) { in.Expires = time.Minute },
 		"too long":          func(in *QuestionInput) { in.Expires = 2 * 24 * time.Hour },
-		"another node":      func(in *QuestionInput) { in.By = "fix-589@shanks" },
+		"another node":      func(in *QuestionInput) { in.By = "fix-589@node-d" },
 		"an invisible char": func(in *QuestionInput) { in.Context += "\u200b" },
 		"invisible label":   func(in *QuestionInput) { in.Options[0].Label = "Merge\u200bnow" },
 		"invisible means":   func(in *QuestionInput) { in.Options[1].Means += "\u202e" },
@@ -182,7 +182,7 @@ func TestAQuestionIsRefusedOutsideItsBounds(t *testing.T) {
 }
 
 func TestAtMostTwoQuestionsWaitSoAProposalFindsRoom(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	first := askMergeTonight(t, p, store, r, t0)
 	askMergeTonight(t, p, store, r, t0)
@@ -219,7 +219,7 @@ func (r *questionRefusingRouter) Publish(subject string, body any, id string) er
 }
 
 func TestTheRoutersRefusalIsSaidAndKept(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemQuestions()
 	refusing := &questionRefusingRouter{router: newRouter(), store: store}
 	within, every := RouterAnswersWithin, RouterAnswersEvery
@@ -244,7 +244,7 @@ func TestTheRoutersRefusalIsSaidAndKept(t *testing.T) {
 }
 
 func TestAnExpiredQuestionSaysWhatTheSessionDoes(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	key := askMergeTonight(t, p, store, r, t0)
 	r.close(asks.Warrant{Ask: key, Outcome: asks.OutcomeExpired, At: t0.Add(QuestionDefault)})
@@ -255,7 +255,7 @@ func TestAnExpiredQuestionSaysWhatTheSessionDoes(t *testing.T) {
 }
 
 func TestTheQuestionToolsAreServed(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	r := newRouter()
 	questions := newMemQuestions()
 	proposing = &Proposing{Store: &memProposals{m: map[string]json.RawMessage{}}, Bus: r, Now: func() time.Time { return t0 },
@@ -268,7 +268,7 @@ func TestTheQuestionToolsAreServed(t *testing.T) {
 			map[string]any{"label": "Merge now", "means": "I merge it", "recommended": true},
 			map[string]any{"label": "Wait", "means": "I leave it open"},
 		},
-		"why": "it is reviewed", "on_expiry": "I leave it open", "by": "fix-589@g14", "expires_minutes": 30,
+		"why": "it is reviewed", "on_expiry": "I leave it open", "by": "fix-589@node-b", "expires_minutes": 30,
 	})
 	if isErr || !strings.Contains(text, `"key"`) {
 		t.Fatalf("%v %s", isErr, text)
@@ -292,7 +292,7 @@ func TestAReadWaitsNoLongerThanItsBound(t *testing.T) {
 	if AnswerWaitsAtMost != 60*time.Second {
 		t.Fatalf("a read may wait %s; ADR 0332 says 60 s", AnswerWaitsAtMost)
 	}
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	key := askMergeTonight(t, p, store, r, t0)
 	most, every := AnswerWaitsAtMost, AnswerLooksEvery
@@ -369,7 +369,7 @@ func (s *memQuestions) Put(key string, value any) error {
 
 // The edges of ADR 0332 §2 that are allowed: a 60-character headline and 1430 minutes.
 func TestTheEdgesOfAQuestionAreAsked(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	in := mergeTonight()
 	in.Headline = strings.Repeat("x", 59) + "?"
 	in.Expires = 1430 * time.Minute
@@ -380,7 +380,7 @@ func TestTheEdgesOfAQuestionAreAsked(t *testing.T) {
 
 // A warrant naming another asker or another ask, or an option the question did not offer, is no answer to it.
 func TestAWarrantForAnotherAskOrOptionIsNotProven(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	for name, change := range map[string]func(*asks.Warrant){
 		"another asker":       func(w *asks.Warrant) { w.Asker = "mesh-controller" },
 		"another ask":         func(w *asks.Warrant) { w.Ask = "q-0000000000000000" },
@@ -400,7 +400,7 @@ func TestAWarrantForAnotherAskOrOptionIsNotProven(t *testing.T) {
 // Two nodes asking at the same moment take two slots at most: of three sessions racing, one is refused.
 func TestTheCapHoldsAcrossNodesAskingAtOnce(t *testing.T) {
 	store, r := newMemQuestions(), &lockedRouter{router: newRouter()}
-	nodes := []string{"g14", "shanks", "ace"}
+	nodes := []string{"node-b", "node-d", "node-a"}
 	var wg sync.WaitGroup
 	errs := make([]error, len(nodes))
 	for i, name := range nodes {
@@ -430,7 +430,7 @@ func TestTheCapHoldsAcrossNodesAskingAtOnce(t *testing.T) {
 
 // A slot that cannot be read refuses the question: the cap fails closed.
 func TestTheCapFailsClosed(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	store.failGet = "slot-"
 	if _, err := AskQuestion(p, mergeTonight(), store, r, t0); err == nil || !strings.Contains(err.Error(), "could not be counted") {
@@ -444,7 +444,7 @@ func TestTheCapFailsClosed(t *testing.T) {
 // A question whose refusal was not heard here, and of which the router holds no record, keeps its slot and reads as
 // waiting until it expires — the router may still take it from its queue — and only then frees its slot and ends.
 func TestAQuestionTheRouterHasNotRecordedHoldsItsSlotUntilItExpires(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	first := askMergeTonight(t, p, store, r, t0)
 	askMergeTonight(t, p, store, r, t0)
@@ -470,13 +470,13 @@ func TestAQuestionTheRouterHasNotRecordedHoldsItsSlotUntilItExpires(t *testing.T
 // A slot is taken only at the revision read: when another node takes both slots between this node's read and its
 // write, this node's writes are refused and the question is refused — a plain write would take a slot it lost.
 func TestASlotIsTakenOnlyAtTheRevisionRead(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store, r := newMemQuestions(), newRouter()
 	// Two questions that ended: their slots are free to take again.
 	for _, id := range []string{askMergeTonight(t, p, store, r, t0), askMergeTonight(t, p, store, r, t0)} {
 		r.close(asks.Warrant{Ask: id, Outcome: asks.OutcomeExpired, At: t0.Add(time.Minute)})
 	}
-	shanks, _ := node(t, "shanks")
+	nodeD, _ := node(t, "node-d")
 	other := newRouter()
 	store.afterGet = func(key string) {
 		if !strings.HasPrefix(key, "slot-") {
@@ -484,7 +484,7 @@ func TestASlotIsTakenOnlyAtTheRevisionRead(t *testing.T) {
 		}
 		// Another node asks between this node's read of the slot and its write: its question waits.
 		q := Question{ID: newQuestionID(), Headline: "Another", Context: "c", Why: "w", OnExpiry: "e", By: "other",
-			From: shanks.Node, At: t0, Expires: t0.Add(time.Hour),
+			From: nodeD.Node, At: t0, Expires: t0.Add(time.Hour),
 			Options: []QuestionOption{{ID: "o1", Label: "A", Means: "a", Recommended: true}, {ID: "o2", Label: "B", Means: "b"}}}
 		_ = store.Put(q.ID, q)
 		_ = other.Publish(asks.AskSubject(Module), q.Ask(), q.ID)

modules/claude-code/cmd/claude-code/session_start_test.go

@@ -122,7 +122,7 @@ func TestSessionStartRejectsAnUnsafeSessionID(t *testing.T) {
 func TestSessionStartListsEveryNameOnTheNodeWithOpenWaits(t *testing.T) {
 	waitsDir := t.TempDir()
 	lastCall := time.Date(2026, 10, 21, 9, 55, 0, 0, time.UTC)
-	idx := NodeIndex{Node: "g14", At: lastCall, Names: []NodeIndexEntry{
+	idx := NodeIndex{Node: "node-b", At: lastCall, Names: []NodeIndexEntry{
 		{Name: "fix-1629", Open: 2, CurrentSession: "sess-old", LastCall: lastCall},
 	}}
 	raw, err := indented(idx)
@@ -135,7 +135,7 @@ func TestSessionStartListsEveryNameOnTheNodeWithOpenWaits(t *testing.T) {
 	if !strings.Contains(msg, "fix-1629") || !strings.Contains(msg, "2 open wait") {
 		t.Fatalf("the name and its count are not listed:\n%s", msg)
 	}
-	want := `claude_code_wait {"op":"adopt","by":"fix-1629@g14","session":"sess-brand-new"}`
+	want := `claude_code_wait {"op":"adopt","by":"fix-1629@node-b","session":"sess-brand-new"}`
 	if !strings.Contains(msg, want) {
 		t.Fatalf("the exact adopt call is not given:\n%s\nwant it to contain:\n%s", msg, want)
 	}

modules/claude-code/cmd/claude-code/waits_test.go

@@ -77,13 +77,13 @@ func addApproveWait(t *testing.T, p Paths, store WaitStore, name, session string
 
 // 1629/AC1: add answers an id; list answers the open waits with their age and whether each is past its bound.
 func TestAddAnswersAnIDAndListShowsItsAgeAndPastBound(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	id := addApproveWait(t, p, store, "fix-1629", "sess-1", t0)
 	if !strings.HasPrefix(id, WaitPrefix) {
 		t.Fatalf("id %q does not start with %q", id, WaitPrefix)
 	}
-	out, err := ListWaits(p, "sess-1", "fix-1629@g14", store, t0.Add(time.Minute))
+	out, err := ListWaits(p, "sess-1", "fix-1629@node-b", store, t0.Add(time.Minute))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -91,7 +91,7 @@ func TestAddAnswersAnIDAndListShowsItsAgeAndPastBound(t *testing.T) {
 	if len(open) != 1 || open[0]["id"] != id || open[0]["past_bound"] != false || open[0]["age_seconds"] != 60 {
 		t.Fatalf("%+v", open)
 	}
-	out, err = ListWaits(p, "sess-1", "fix-1629@g14", store, t0.Add(11*time.Minute))
+	out, err = ListWaits(p, "sess-1", "fix-1629@node-b", store, t0.Add(11*time.Minute))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -104,9 +104,9 @@ func TestAddAnswersAnIDAndListShowsItsAgeAndPastBound(t *testing.T) {
 // 1629/AC2: watched, done and said change the wait; said is refused for a wait not past its bound; done removes
 // it from the open list.
 func TestWatchedDoneAndSaidChangeTheWait(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	id := addApproveWait(t, p, store, "fix-1629", "sess-2", t0)
 
 	if _, err := SaidWait(p, "sess-2", by, id, store, t0.Add(time.Minute)); err == nil || !strings.Contains(err.Error(), "not past its bound") {
@@ -143,9 +143,9 @@ func TestWatchedDoneAndSaidChangeTheWait(t *testing.T) {
 // 1629/AC3: every change rewrites the session's waits file whole, atomically; it holds exactly the open waits
 // and the write time.
 func TestEveryChangeRewritesTheWaitsFileWhole(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	id1 := addApproveWait(t, p, store, "fix-1629", "sess-3", t0)
 	f, err := readWaitsFile(waitsFilePath(p, "sess-3"))
 	if err != nil {
@@ -179,9 +179,9 @@ func TestEveryChangeRewritesTheWaitsFileWhole(t *testing.T) {
 // 1629/AC4: the waits are read again after the module "restarts" (the state is kept) and for the same name
 // after a /clear that keeps calling with the same session id; a different name lists none of them.
 func TestWaitsSurviveARestartAndAreNeverSeenByAnotherName(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	addApproveWait(t, p, store, "fix-1629", "sess-4", t0)
 
 	// A restart: a fresh Waiting over the same store reads the same waits.
@@ -199,7 +199,7 @@ func TestWaitsSurviveARestartAndAreNeverSeenByAnotherName(t *testing.T) {
 	}
 
 	// A different name, same node: none of them.
-	out, err = ListWaits(p, "sess-other", "fix-other@g14", store, t0.Add(2*time.Minute))
+	out, err = ListWaits(p, "sess-other", "fix-other@node-b", store, t0.Add(2*time.Minute))
 	if err != nil || len(out["open"].([]map[string]any)) != 0 {
 		t.Fatalf("another name saw them: %v %v", out, err)
 	}
@@ -208,7 +208,7 @@ func TestWaitsSurviveARestartAndAreNeverSeenByAnotherName(t *testing.T) {
 // 1629/AC5: add refuses an empty what, a bound under 1 or over 1440 minutes, a read address that is not an
 // address, and more than 50 open waits per name, naming the argument.
 func TestAddRefusesOutsideItsBounds(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	base := func() WaitInput {
 		return WaitInput{Session: "sess-5", By: "fix-1629@" + p.Node, What: "something", Read: WaitRead{Address: "mesh-delivery.recheck"}, Bound: 10}
 	}
@@ -247,8 +247,8 @@ func TestAddRefusesOutsideItsBounds(t *testing.T) {
 // Review round 1 item (b): list, watched, done and said refuse a session id that is not a plain one (the
 // same waitSessionID add already holds to), naming "session" — not silently treating it as just-another-key.
 func TestListWatchedDoneAndSaidRefuseABadSessionID(t *testing.T) {
-	p, _ := node(t, "g14")
-	by := "fix-1629@g14"
+	p, _ := node(t, "node-b")
+	by := "fix-1629@node-b"
 	for _, bad := range []string{"", "a/b", "../x"} {
 		store := newMemWaits()
 		if _, err := ListWaits(p, bad, by, store, t0); err == nil || !strings.Contains(err.Error(), "session") {
@@ -268,13 +268,13 @@ func TestListWatchedDoneAndSaidRefuseABadSessionID(t *testing.T) {
 
 // 1629/AC6: the tool is served through the module's own dispatch.
 func TestTheWaitToolIsServedThroughTheModulesDispatch(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	waiting = &Waiting{Store: store, Now: func() time.Time { return t0 }}
 	t.Cleanup(func() { waiting = nil })
 	s := serve(t, p, &bus{kept: map[string]map[string]any{}}, memConfig{})
 
-	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "sess-6", "by": "fix-1629@g14",
+	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "sess-6", "by": "fix-1629@node-b",
 		"what": "the operator's Approve", "read": map[string]any{"address": "mesh-delivery.recheck"}, "bound_minutes": 10})
 	if isErr {
 		t.Fatalf("add: %s", text)
@@ -288,12 +288,12 @@ func TestTheWaitToolIsServedThroughTheModulesDispatch(t *testing.T) {
 		t.Fatalf("no id answered: %s", text)
 	}
 
-	text, isErr = s.call(t, "claude_code_wait", map[string]any{"op": "list", "session": "sess-6", "by": "fix-1629@g14"})
+	text, isErr = s.call(t, "claude_code_wait", map[string]any{"op": "list", "session": "sess-6", "by": "fix-1629@node-b"})
 	if isErr || !strings.Contains(text, id) {
 		t.Fatalf("list: %v %s", isErr, text)
 	}
 
-	text, isErr = s.call(t, "claude_code_wait", map[string]any{"op": "done", "session": "sess-6", "by": "fix-1629@g14",
+	text, isErr = s.call(t, "claude_code_wait", map[string]any{"op": "done", "session": "sess-6", "by": "fix-1629@node-b",
 		"id": id, "outcome": "approved"})
 	if isErr {
 		t.Fatalf("done: %s", text)
@@ -305,10 +305,10 @@ func TestTheWaitToolIsServedThroughTheModulesDispatch(t *testing.T) {
 // ADR 0490 §1: a name nothing has bound yet is claimed by the first session that calls for it (add), without
 // a separate adopt first.
 func TestAFirstAddBindsAnUnboundNameAtOnce(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	id := addApproveWait(t, p, store, "fix-1629", "sess-a", t0)
-	out, err := ListWaits(p, "sess-a", "fix-1629@g14", store, t0)
+	out, err := ListWaits(p, "sess-a", "fix-1629@node-b", store, t0)
 	if err != nil || len(out["open"].([]map[string]any)) != 1 || out["open"].([]map[string]any)[0]["id"] != id {
 		t.Fatalf("%v %v", out, err)
 	}
@@ -317,9 +317,9 @@ func TestAFirstAddBindsAnUnboundNameAtOnce(t *testing.T) {
 // ADR 0490 §1/§3: once a name is bound to a session, a different, non-adopted session calling for the same
 // name (any op) is refused, naming the session that holds it and when it last called.
 func TestADifferentSessionIsRefusedWithoutAdopting(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	addApproveWait(t, p, store, "fix-1629", "sess-old", t0)
 
 	if _, err := AddWait(p, WaitInput{Session: "sess-new", By: by, What: "another", Read: WaitRead{Address: "mesh-delivery.recheck"},
@@ -341,9 +341,9 @@ func TestADifferentSessionIsRefusedWithoutAdopting(t *testing.T) {
 // ADR 0490 §2/§3: adopt right after a simulated /clear binds the name to the new session id at once; the
 // mirrored file of the old session id is emptied and the new one holds the waits, with no delay.
 func TestAdoptRightAfterAClearBindsAtOnce(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	id := addApproveWait(t, p, store, "fix-1629", "sess-old", t0)
 
 	out, err := AdoptName(p, by, "sess-new", store, t0.Add(time.Minute))
@@ -376,9 +376,9 @@ func TestAdoptRightAfterAClearBindsAtOnce(t *testing.T) {
 // ADR 0490 §3: adopt of a name bound to another id always takes it over, however recently that id called —
 // no bound protects it.
 func TestAdoptAlwaysTakesOverEvenJustCalled(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	addApproveWait(t, p, store, "fix-1629", "sess-fresh", t0)
 	// sess-fresh calls again right before being adopted away from.
 	if _, err := ListWaits(p, "sess-fresh", by, store, t0.Add(10*time.Second)); err != nil {
@@ -396,9 +396,9 @@ func TestAdoptAlwaysTakesOverEvenJustCalled(t *testing.T) {
 // ADR 0490 §3: the earlier id's next claude_code_wait call (any op) answers that its name now answers to
 // another session, naming it.
 func TestTheEarlierIDIsToldOnItsNextCall(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	addApproveWait(t, p, store, "fix-1629", "sess-old", t0)
 	if _, err := AdoptName(p, by, "sess-new", store, t0.Add(time.Minute)); err != nil {
 		t.Fatal(err)
@@ -413,11 +413,11 @@ func TestTheEarlierIDIsToldOnItsNextCall(t *testing.T) {
 // ADR 0490 §2: the node-wide index lists every name on this node with an open wait, for the SessionStart
 // hook to read directly.
 func TestTheNodeWideIndexListsEveryNameWithOpenWaits(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	addApproveWait(t, p, store, "fix-1629", "sess-x", t0)
 	addApproveWait(t, p, store, "fix-1744", "sess-y", t0)
-	if _, err := DoneWait(p, "sess-x", "fix-1629@g14", wantsOnlyWait(t, store, p, "fix-1629", "sess-x"), "done",
+	if _, err := DoneWait(p, "sess-x", "fix-1629@node-b", wantsOnlyWait(t, store, p, "fix-1629", "sess-x"), "done",
 		store, t0.Add(time.Minute)); err != nil {
 		t.Fatal(err)
 	}
@@ -426,7 +426,7 @@ func TestTheNodeWideIndexListsEveryNameWithOpenWaits(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if idx.Node != "g14" || len(idx.Names) != 1 || idx.Names[0].Name != "fix-1744" || idx.Names[0].Open != 1 ||
+	if idx.Node != "node-b" || len(idx.Names) != 1 || idx.Names[0].Name != "fix-1744" || idx.Names[0].Open != 1 ||
 		idx.Names[0].CurrentSession != "sess-y" {
 		t.Fatalf("%+v", idx)
 	}
@@ -448,18 +448,18 @@ func wantsOnlyWait(t *testing.T, store WaitStore, p Paths, name, session string)
 
 // claude_code_wait op=adopt, served through the module's own dispatch (1629/AC6, ADR 0490).
 func TestAdoptIsServedThroughTheModulesDispatch(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	waiting = &Waiting{Store: store, Now: func() time.Time { return t0 }}
 	t.Cleanup(func() { waiting = nil })
 	s := serve(t, p, &bus{kept: map[string]map[string]any{}}, memConfig{})
 
-	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "sess-old", "by": "fix-1629@g14",
+	text, isErr := s.call(t, "claude_code_wait", map[string]any{"op": "add", "session": "sess-old", "by": "fix-1629@node-b",
 		"what": "the operator's Approve", "read": map[string]any{"address": "mesh-delivery.recheck"}, "bound_minutes": 10})
 	if isErr {
 		t.Fatalf("add: %s", text)
 	}
-	text, isErr = s.call(t, "claude_code_wait", map[string]any{"op": "adopt", "session": "sess-new", "by": "fix-1629@g14"})
+	text, isErr = s.call(t, "claude_code_wait", map[string]any{"op": "adopt", "session": "sess-new", "by": "fix-1629@node-b"})
 	if isErr || !strings.Contains(text, "sess-old") {
 		t.Fatalf("adopt: %v %s", isErr, text)
 	}
@@ -470,7 +470,7 @@ func TestAdoptIsServedThroughTheModulesDispatch(t *testing.T) {
 // Review round 2, item 2 (ADR 0490 §1): one session id with two different names bound to it holds both
 // names' waits in its one mirrored file, not only the name an op last acted on.
 func TestASessionsFileHoldsEveryNameBoundToIt(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	idX := addApproveWait(t, p, store, "fix-x", "sess-shared", t0)
 	idY := addApproveWait(t, p, store, "fix-y", "sess-shared", t0.Add(time.Minute))
@@ -491,12 +491,12 @@ func TestASessionsFileHoldsEveryNameBoundToIt(t *testing.T) {
 // Review round 2, item 2: adopting one of two names bound to the same session away keeps that session's
 // file holding the other name's waits — it is never emptied wholesale.
 func TestAdoptingOneNameAwayKeepsTheSessionsOtherNamesWaits(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
 	idX := addApproveWait(t, p, store, "fix-x", "sess-shared", t0)
 	idY := addApproveWait(t, p, store, "fix-y", "sess-shared", t0.Add(time.Minute))
 
-	if _, err := AdoptName(p, "fix-y@g14", "sess-y-new", store, t0.Add(2*time.Minute)); err != nil {
+	if _, err := AdoptName(p, "fix-y@node-b", "sess-y-new", store, t0.Add(2*time.Minute)); err != nil {
 		t.Fatal(err)
 	}
 
@@ -513,9 +513,9 @@ func TestAdoptingOneNameAwayKeepsTheSessionsOtherNamesWaits(t *testing.T) {
 // Review round 2, item b: adopt clears the refusal counter of both the earlier id and the new one, so a
 // fresh three-strikes count starts under the new binding.
 func TestAdoptClearsTheRefusalCounterOfBothIDs(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 	addApproveWait(t, p, store, "fix-1629", "sess-old", t0)
 	waitsDir := WaitsDirPath(p)
 	if err := writeRefusalCounters(waitsDir, "sess-old", map[string]int{"w-1": 2}); err != nil {
@@ -538,9 +538,9 @@ func TestAdoptClearsTheRefusalCounterOfBothIDs(t *testing.T) {
 // Review round 2, item c: list is read-only — it never binds an unbound name, and never refuses a
 // mismatched session; it answers the name's waits and who currently holds it.
 func TestListNeverBindsAndAnswersWhoHoldsTheName(t *testing.T) {
-	p, _ := node(t, "g14")
+	p, _ := node(t, "node-b")
 	store := newMemWaits()
-	by := "fix-1629@g14"
+	by := "fix-1629@node-b"
 
 	// An unbound name: list answers no waits, and binds nothing (a later add from a different session still
 	// succeeds, as the first caller for an unbound name).

modules/claude-licence-manager/cmd/claude-licence-manager/manager_test.go

@@ -347,7 +347,7 @@ func TestAReportIsReadAsTheAgentModuleWritesIt(t *testing.T) {
 func TestANodeReportingAnAdoptedAccountLaterIsBoundToIt(t *testing.T) {
 	mm := newMesh(t)
 	ctx := context.Background()
-	_, _ = mm.m.Consider(ctx, []Holdings{mm.login("novox", "rt-new", true, t0)})
+	_, _ = mm.m.Consider(ctx, []Holdings{mm.login("node-c", "rt-new", true, t0)})
 	late := mm.login("laptop", "rt-older", true, t0.Add(-24*time.Hour))
 	_, _ = mm.m.Consider(ctx, []Holdings{late})
 	if mm.state["laptop"].Licence != licence1 {
@@ -477,16 +477,16 @@ func TestEveryMoveSaysWhatWhyAndWho(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	asked := WithCause(ctx, Cause{Why: "the switch verb", By: "g14.node-tools"})
+	asked := WithCause(ctx, Cause{Why: "the switch verb", By: "node-b.node-tools"})
 	if _, err := mm.m.Bind(asked, "laptop", "api"); err != nil {
 		t.Fatal(err)
 	}
-	if s := mm.state["laptop"]; s.Why != "the switch verb" || s.By != "g14.node-tools" {
+	if s := mm.state["laptop"]; s.Why != "the switch verb" || s.By != "node-b.node-tools" {
 		t.Fatalf("the node is told %+v", s)
 	}
 	said := strings.Join(lines, "\n")
 	if !strings.Contains(said, "switched laptop from "+licence1+" to api (generation ") ||
-		!strings.Contains(said, "the switch verb; asked by g14.node-tools") {
+		!strings.Contains(said, "the switch verb; asked by node-b.node-tools") {
 		t.Fatalf("the journal said:\n%s", said)
 	}
 	var switched string
@@ -495,18 +495,18 @@ func TestEveryMoveSaysWhatWhyAndWho(t *testing.T) {
 			switched = e
 		}
 	}
-	for _, want := range []string{`"by":"g14.node-tools"`, `"from":"` + licence1 + `"`, `"licence":"api"`, `"consumer":"laptop"`, `"generation":`} {
+	for _, want := range []string{`"by":"node-b.node-tools"`, `"from":"` + licence1 + `"`, `"licence":"api"`, `"consumer":"laptop"`, `"generation":`} {
 		if !strings.Contains(switched, want) {
 			t.Fatalf("the event %q lacks %s; events %v", switched, want, mm.events)
 		}
 	}
 	last := mm.store.Audits[len(mm.store.Audits)-1]
-	if raw, _ := json.Marshal(last); !strings.Contains(string(raw), `"by":"g14.node-tools"`) || !strings.Contains(string(raw), "switched") {
+	if raw, _ := json.Marshal(last); !strings.Contains(string(raw), `"by":"node-b.node-tools"`) || !strings.Contains(string(raw), "switched") {
 		t.Fatalf("the audit kept %s", raw)
 	}
 
-	_, _ = mm.m.Rotate(WithCause(ctx, Cause{Why: "the refresh verb", By: "novox.node-tools"}), licence1, true)
-	if !strings.Contains(strings.Join(mm.events, "|"), `licence.rotated {"by":"novox.node-tools"`) {
+	_, _ = mm.m.Rotate(WithCause(ctx, Cause{Why: "the refresh verb", By: "node-c.node-tools"}), licence1, true)
+	if !strings.Contains(strings.Join(mm.events, "|"), `licence.rotated {"by":"node-c.node-tools"`) {
 		t.Fatalf("a rotation asked for said no caller: %v", mm.events)
 	}
 

modules/cups/README.md

@@ -22,7 +22,7 @@ Research 027 asked for "`cups` with the printer's driver". Measured on 2026-10-0
 | workstation | queue | device | prints through | driver package installed |
 |---|---|---|---|---|
 | laptop | `Brother` (MFC-L8690CDW) | `ipp://` on the LAN | **IPP Everywhere, driverless** | `brother-mfc-l8690cdw` (AUR), unused |
-| desktop | `Brother_MFC_Novox` (default) | `ipp://` on the LAN | **IPP Everywhere, driverless** | `brother-mfc-l8390cdw` and its `-debug` (AUR), unused |
+| desktop | `Brother_MFC_NodeC` (default) | `ipp://` on the LAN | **IPP Everywhere, driverless** | `brother-mfc-l8390cdw` and its `-debug` (AUR), unused |
 | desktop | `Kanjuro` (Canon PIXMA MG4200) | `cnijnet:` | the vendor's PPD and filter | `cnijfilter-mg4200` 3.80 (AUR) |
 
 **Both Brother queues already print without a vendor driver.** CUPS's own IPP Everywhere support,

modules/cups/cmd/cups-tools/cups_test.go

@@ -36,13 +36,13 @@ func theDesktop(t *testing.T, more func(line string, c Cmd) (Result, bool)) *fak
 		case "lpstat -r":
 			return ok("scheduler is running\n")
 		case "lpstat -d":
-			return ok("system default destination: Brother_MFC_Novox\n")
+			return ok("system default destination: Brother_MFC_NodeC\n")
 		case "lpstat -p":
-			return ok("printer Brother_MFC_Novox is idle.  enabled since Mon Jun 29 21:34:30 2026\n" +
+			return ok("printer Brother_MFC_NodeC is idle.  enabled since Mon Jun 29 21:34:30 2026\n" +
 				"printer Kanjuro disabled since Sun Jun  9 11:16:03 2024 -\n\tPaused\n")
 		case "lpstat -a":
-			return ok("Brother_MFC_Novox accepting requests since Mon Jun 29 21:34:30 2026\nKanjuro not accepting requests since Sun Jun  9 11:16:03 2024 -\n\tRejecting Jobs\n")
-		case "lpoptions -p Brother_MFC_Novox":
+			return ok("Brother_MFC_NodeC accepting requests since Mon Jun 29 21:34:30 2026\nKanjuro not accepting requests since Sun Jun  9 11:16:03 2024 -\n\tRejecting Jobs\n")
+		case "lpoptions -p Brother_MFC_NodeC":
 			return ok(`copies=1 device-uri=ipp://192.0.2.171/ipp/port1 finishings=3 marker-levels=70,100,8,100 marker-low-levels=10,10,10,10 marker-names='Black\ Toner\ Cartridge,Cyan\ Toner\ Cartridge,Magenta\ Toner\ Cartridge,Yellow\ Toner\ Cartridge' marker-types=toner,toner,toner,toner printer-is-shared=false printer-make-and-model='Printer - IPP Everywhere' printer-state-reasons=none`)
 		case "lpoptions -p Kanjuro":
 			return ok(`device-uri=cnijnet:/18-0C-AC-B0-62-83 printer-is-shared=false printer-make-and-model='Canon MG4200 series Ver.3.80' printer-state-reasons=paused`)
@@ -54,7 +54,7 @@ func theDesktop(t *testing.T, more func(line string, c Cmd) (Result, bool)) *fak
 func TestPrintersReadsStateDeviceModelAndSupplies(t *testing.T) {
 	theDesktop(t, nil)
 	got, err := Printers()
-	if err != nil || len(got.Printers) != 2 || got.Default != "Brother_MFC_Novox" || got.Scheduler != "scheduler is running" {
+	if err != nil || len(got.Printers) != 2 || got.Default != "Brother_MFC_NodeC" || got.Scheduler != "scheduler is running" {
 		t.Fatalf("%+v %v", got, err)
 	}
 	b, k := got.Printers[0], got.Printers[1]
@@ -186,11 +186,11 @@ func TestDefaultReadsAndSetsThroughSudo(t *testing.T) {
 		return Result{}, false
 	})
 	got, err := Default("")
-	if err != nil || got["default"] != "Brother_MFC_Novox" {
+	if err != nil || got["default"] != "Brother_MFC_NodeC" {
 		t.Fatalf("%v %v", got, err)
 	}
 	got, err = Default("Kanjuro")
-	if err != nil || got["default"] != "Kanjuro" || got["was"] != "Brother_MFC_Novox" {
+	if err != nil || got["default"] != "Kanjuro" || got["was"] != "Brother_MFC_NodeC" {
 		t.Fatalf("%v %v", got, err)
 	}
 	if l := f.lines(); l[len(l)-1] != "sudo -n lpadmin -d Kanjuro" {

modules/desk-channel/cmd/desk-channel/desk_test.go

@@ -133,7 +133,7 @@ func TestANotifierThatStartedAgainIsShownNothingFromMemory(t *testing.T) {
 	d, shown, said, store := newDesk(t, "laptop")
 	d.Paused("laptop", false)
 	d.SayStanding()
-	take(t, d, asks.Show, asks.Message{Handle: "open", Title: "2 failed services on shanks",
+	take(t, d, asks.Show, asks.Message{Handle: "open", Title: "2 failed services on node-d",
 		Buttons: []asks.Button{{Label: "Silence for a week", Ticket: "t-open"}}})
 	take(t, d, asks.Show, asks.Message{Handle: "silenced", Title: "Agent-home shrank",
 		Buttons: []asks.Button{{Label: "Silence for a week", Ticket: "t-silenced"}}})
@@ -162,7 +162,7 @@ func TestANotifierThatStartedAgainIsShownNothingFromMemory(t *testing.T) {
 		t.Fatalf("the standing after the start: %d said, last %s", len(got)-standings, got[len(got)-1])
 	}
 	// The router says the open one again under its handle: in place of its notification, with its answers.
-	take(t, d, asks.Show, asks.Message{Handle: "open", Title: "2 failed services on shanks",
+	take(t, d, asks.Show, asks.Message{Handle: "open", Title: "2 failed services on node-d",
 		Buttons: []asks.Button{{Label: "Silence for a week", Ticket: "t-open"}}})
 	last := (*shown)[len(*shown)-1]
 	if len(*shown) != before+1 || last.args["replace_id"] != openID || last.args["actions"] == nil {
@@ -329,7 +329,7 @@ func TestItRunsAsItsOwnAccount(t *testing.T) {
 // was not shown; a message under a new handle replaces nothing.
 func TestAMessageSaidAgainUnderItsHandleReplacesItsNotification(t *testing.T) {
 	d, shown, _, store := newDesk(t, "laptop", "desktop")
-	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "2 failed services on shanks"})
+	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "2 failed services on node-d"})
 	take(t, d, asks.Send, asks.Message{Handle: "m2", Title: "another problem"})
 	if len(*shown) != 4 {
 		t.Fatalf("shown %d", len(*shown))
@@ -342,7 +342,7 @@ func TestAMessageSaidAgainUnderItsHandleReplacesItsNotification(t *testing.T) {
 	first := store["m1"].On
 	// The desk now names a third machine as well.
 	d.Machines = func() []string { return []string{"laptop", "desktop", "third"} }
-	take(t, d, asks.Show, asks.Message{Handle: "m1", Title: "Still open: 2 failed services on shanks", Urgent: true,
+	take(t, d, asks.Show, asks.Message{Handle: "m1", Title: "Still open: 2 failed services on node-d", Urgent: true,
 		Buttons: []asks.Button{{Label: "Silence for a week", Ticket: "t1"}}})
 	again := (*shown)[4:]
 	if len(again) != 3 {
@@ -367,7 +367,7 @@ func TestAMessageSaidAgainUnderItsHandleReplacesItsNotification(t *testing.T) {
 // later edit or clearing still reaches it; failing everywhere, it is said to the router as failed.
 func TestAFailedReplaceKeepsTheNotificationItWasToReplace(t *testing.T) {
 	d, shown, said, store := newDesk(t, "laptop", "desktop")
-	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "2 failed services on shanks"})
+	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "2 failed services on node-d"})
 	first := store["m1"].On
 	notify := d.Notify
 	d.Notify = func(machine string, args map[string]any) (json.RawMessage, error) {
@@ -376,12 +376,12 @@ func TestAFailedReplaceKeepsTheNotificationItWasToReplace(t *testing.T) {
 		}
 		return notify(machine, args)
 	}
-	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "Still open: 2 failed services on shanks"})
+	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "Still open: 2 failed services on node-d"})
 	if got := store["m1"].On["desktop"]; got != first["desktop"] {
 		t.Fatalf("the desktop's notification %d was forgotten: %v", first["desktop"], store["m1"].On)
 	}
 	d.Notify = func(string, map[string]any) (json.RawMessage, error) { return nil, errors.New("away") }
-	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "Now urgent: 2 failed services on shanks"})
+	take(t, d, asks.Send, asks.Message{Handle: "m1", Title: "Now urgent: 2 failed services on node-d"})
 	if len(said[asks.IntakeSubject(asks.FailedWhat, Kind)]) != 1 {
 		t.Fatalf("shown nowhere, and not said as failed")
 	}

modules/disk-load/cmd/disk-load/tools_test.go

@@ -49,7 +49,8 @@ func TestTheManifestNamesExactlyTheToolsTheBundleServesAndNoMachine(t *testing.T
 	if len(m.Resources) != 0 {
 		t.Errorf("the module only reads, and declares %d resources", len(m.Resources))
 	}
-	for _, banned := range []string{"g14", "novox", "ace", "shanks", "jochen", "/home/"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, banned := range []string{"jochen", "/home/"} {
 		if strings.Contains(string(raw), banned) {
 			t.Errorf("the manifest says %q", banned)
 		}

modules/dnsmasq/cmd/dnsmasq-tools/dnsmasq_test.go

@@ -134,8 +134,8 @@ func aResolverMachine(t *testing.T, port string, now func() time.Time) *Machine
 		}
 	}
 	write(ConfigFile, "bind-interfaces\nlisten-address=127.0.0.2\nlisten-address=127.0.0.1\nno-resolv\n")
-	write(NodesFile, "local=/internal/\naddress=/novox.internal/127.0.0.2\nhost-record=novox.internal,127.0.0.2\n"+
-		"address=/ace.internal/10.77.0.2\nhost-record=ace.internal,10.77.0.2\n")
+	write(NodesFile, "local=/internal/\naddress=/node-c.internal/127.0.0.2\nhost-record=node-c.internal,127.0.0.2\n"+
+		"address=/node-a.internal/10.77.0.2\nhost-record=node-a.internal,10.77.0.2\n")
 	if err := os.MkdirAll(filepath.Join(root, filepath.Dir(StateFile)), 0o755); err != nil {
 		t.Fatal(err)
 	}
@@ -147,13 +147,13 @@ func TestTheConfigurationAndTheRosterSayWhereAndWhatToAsk(t *testing.T) {
 	if strings.Join(listen, " ") != "10.77.0.1 127.0.0.1" {
 		t.Fatalf("listen addresses %v", listen)
 	}
-	names := AnsweredNames("local=/internal/\naddress=/ace.internal/10.77.0.2\nhost-record=ace.internal,10.77.0.2\n" +
-		"host-record=novox.internal,10.77.0.1\n")
+	names := AnsweredNames("local=/internal/\naddress=/node-a.internal/10.77.0.2\nhost-record=node-a.internal,10.77.0.2\n" +
+		"host-record=node-c.internal,10.77.0.1\n")
 	q, ok := Question(listen, names)
-	if !ok || q.Name != "novox.internal" || q.Address != "10.77.0.1" {
+	if !ok || q.Name != "node-c.internal" || q.Address != "10.77.0.1" {
 		t.Fatalf("asks %+v", q)
 	}
-	if q, _ := Question([]string{"127.0.0.1"}, names); q.Name != "ace.internal" {
+	if q, _ := Question([]string{"127.0.0.1"}, names); q.Name != "node-a.internal" {
 		t.Fatalf("with no own name in the roster, asks %+v", q)
 	}
 }
@@ -165,7 +165,7 @@ func TestALookFindsAResolverThatStoppedAnsweringOnOneAddress(t *testing.T) {
 	m := aResolverMachine(t, port, time.Now)
 	private := startStandIn(t, "127.0.0.2", port, "127.0.0.2")
 	startStandIn(t, "127.0.0.1", port, "127.0.0.2")
-	if l := m.Look(t.Context()); !l.Healthy || len(l.Answers) != 4 || l.Asked.Name != "novox.internal" {
+	if l := m.Look(t.Context()); !l.Healthy || len(l.Answers) != 4 || l.Asked.Name != "node-c.internal" {
 		t.Fatalf("a resolver answering everywhere: %+v", l)
 	}
 	private.stop()
@@ -173,14 +173,14 @@ func TestALookFindsAResolverThatStoppedAnsweringOnOneAddress(t *testing.T) {
 	if l.Healthy || len(l.Wrong) != 2 {
 		t.Fatalf("a resolver that stopped answering on its private address: %+v", l)
 	}
-	if why := l.Why(); !strings.Contains(why, "127.0.0.2:"+port+" over udp did not answer novox.internal: refused") ||
+	if why := l.Why(); !strings.Contains(why, "127.0.0.2:"+port+" over udp did not answer node-c.internal: refused") ||
 		!strings.Contains(why, "over tcp") || strings.Contains(why, "127.0.0.1:") {
 		t.Fatalf("said as %q", why)
 	}
 }
 
 func TestAWrongAnswerIsNotAnAnswer(t *testing.T) {
-	q := Named{Name: "novox.internal", Address: "10.77.0.1"}
+	q := Named{Name: "node-c.internal", Address: "10.77.0.1"}
 	for _, c := range []struct {
 		a    Answer
 		want string
@@ -198,7 +198,7 @@ func TestAWrongAnswerIsNotAnAnswer(t *testing.T) {
 
 func failing(at time.Time) Look {
 	return Look{At: at, Answers: []Answer{{Server: "10.77.0.1:53", Over: "udp", Failed: "refused: nothing listens there"}},
-		Wrong: []string{"10.77.0.1:53 over udp did not answer novox.internal: refused: nothing listens there"}}
+		Wrong: []string{"10.77.0.1:53 over udp did not answer node-c.internal: refused: nothing listens there"}}
 }
 
 func healthy(at time.Time) Look { return Look{At: at, Healthy: true} }
@@ -323,7 +323,7 @@ func TestTheWatchRestartsAResolverThatStoppedAnsweringAndHealthSaysWhetherItHelp
 		look()
 	}
 	h := m.Health(t.Context())
-	if h.Healthy || !strings.Contains(h.Why, "did not answer novox.internal: refused") ||
+	if h.Healthy || !strings.Contains(h.Why, "did not answer node-c.internal: refused") ||
 		!strings.Contains(h.Why, "which did not help") {
 		t.Fatalf("a restart that did not help: %q", h.Why)
 	}
@@ -482,10 +482,10 @@ func TestResolveAsksOnlyAListenAddress(t *testing.T) {
 	m := aResolverMachine(t, port, time.Now)
 	startStandIn(t, "127.0.0.2", port, "127.0.0.2")
 	startStandIn(t, "127.0.0.1", port, "127.0.0.2")
-	if _, err := m.Resolve(t.Context(), "novox.internal", "8.8.8.8", ""); err == nil || !strings.Contains(err.Error(), "not one the resolver listens on") {
+	if _, err := m.Resolve(t.Context(), "node-c.internal", "8.8.8.8", ""); err == nil || !strings.Contains(err.Error(), "not one the resolver listens on") {
 		t.Fatalf("another address was asked: %v", err)
 	}
-	got, err := m.Resolve(t.Context(), "novox.internal", "127.0.0.2", "tcp")
+	got, err := m.Resolve(t.Context(), "node-c.internal", "127.0.0.2", "tcp")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -493,10 +493,10 @@ func TestResolveAsksOnlyAListenAddress(t *testing.T) {
 	if len(answers) != 1 || answers[0].Over != "tcp" || answers[0].Code != "NOERROR" || answers[0].Addresses[0] != "127.0.0.2" {
 		t.Fatalf("%+v", answers)
 	}
-	if got, _ := m.Resolve(t.Context(), "novox.internal", "", ""); len(got.(map[string]any)["answers"].([]Answer)) != 4 {
+	if got, _ := m.Resolve(t.Context(), "node-c.internal", "", ""); len(got.(map[string]any)["answers"].([]Answer)) != 4 {
 		t.Fatalf("every listen address over both: %+v", got)
 	}
-	if _, err := m.Resolve(t.Context(), "novox.internal", "", "quic"); err == nil {
+	if _, err := m.Resolve(t.Context(), "node-c.internal", "", "quic"); err == nil {
 		t.Fatal("over quic was accepted")
 	}
 	if _, err := m.Resolve(t.Context(), "", "", ""); err == nil {
@@ -540,12 +540,12 @@ func TestTheAnnouncerSaysWhatChangedAndRemembersOnlyWhatWasSaid(t *testing.T) {
 	}
 	// The roster changes: one machine added, one gone. An unreadable roster says nothing.
 	nodes := filepath.Join(m.Root, NodesFile)
-	if err := os.WriteFile(nodes, []byte("host-record=novox.internal,127.0.0.2\nhost-record=shanks.internal,10.77.0.4\n"), 0o644); err != nil {
+	if err := os.WriteFile(nodes, []byte("host-record=node-c.internal,127.0.0.2\nhost-record=node-d.internal,10.77.0.4\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	Tell(m, &a, emit)
-	if got := strings.Join(said, "|"); !strings.Contains(got, "name.added shanks.internal") ||
-		!strings.Contains(got, "name.removed ace.internal") || len(said) != 2 {
+	if got := strings.Join(said, "|"); !strings.Contains(got, "name.added node-d.internal") ||
+		!strings.Contains(got, "name.removed node-a.internal") || len(said) != 2 {
 		t.Fatalf("the roster's change: %v", said)
 	}
 	said = nil

modules/docker/cmd/docker-tools/resolv_test.go

@@ -32,7 +32,7 @@ func archiveOf(t *testing.T, h tar.Header, body string) string {
 // Issue 348: route-proxy asked 10.10.0.1 alone while the machine listed both mesh resolvers; its copy
 // of the file could not be read by anything on the mesh.
 func TestAContainersResolverFileIsReadThroughTheArchiveAndComparedWithTheMachines(t *testing.T) {
-	inside := "# Generated by Docker Engine.\nnameserver 10.10.0.1\nsearch novox.internal\noptions timeout:1 attempts:2\n"
+	inside := "# Generated by Docker Engine.\nnameserver 10.10.0.1\nsearch node-c.internal\noptions timeout:1 attempts:2\n"
 	f := (&fake{}).on("docker cp route-proxy:/etc/resolv.conf -",
 		Ran{Stdout: archiveOf(t, tar.Header{Name: "resolv.conf", Typeflag: tar.TypeReg, Mode: 0o644}, inside)})
 	c := client(f, 1000)
@@ -47,7 +47,7 @@ func TestAContainersResolverFileIsReadThroughTheArchiveAndComparedWithTheMachine
 		t.Fatal(err)
 	}
 	rc := got["resolv_conf"].(ResolvConf)
-	if strings.Join(rc.Nameservers, ",") != "10.10.0.1" || strings.Join(rc.Search, ",") != "novox.internal" ||
+	if strings.Join(rc.Nameservers, ",") != "10.10.0.1" || strings.Join(rc.Search, ",") != "node-c.internal" ||
 		strings.Join(rc.Options, ",") != "timeout:1,attempts:2" || rc.Raw != inside {
 		t.Fatalf("parsed: %+v", rc)
 	}

modules/dunst/cmd/dunst-tools/actions_test.go

@@ -17,7 +17,7 @@ func TestANotificationsChosenAnswerIsSaidAsAnEvent(t *testing.T) {
 	withBus(t)
 	bin := fakeBinaries(t, map[string]string{"notify-send": `for a in "$@"; do printf '[%s]' "$a"; done > "$LOG"; echo 42; sleep 0.2; echo "$CHOSEN"`})
 	t.Setenv("LOG", filepath.Join(bin, "log"))
-	t.Setenv("MESH_NODE", "g14")
+	t.Setenv("MESH_NODE", "node-b")
 	var mu sync.Mutex
 	var said []map[string]any
 	before := emit
@@ -58,7 +58,7 @@ func TestANotificationsChosenAnswerIsSaidAsAnEvent(t *testing.T) {
 		time.Sleep(20 * time.Millisecond)
 	}
 	mu.Lock()
-	if len(said) != 1 || said[0]["token"] != "c3d4" || said[0]["id"] != 42 || said[0]["machine"] != "g14" {
+	if len(said) != 1 || said[0]["token"] != "c3d4" || said[0]["id"] != 42 || said[0]["machine"] != "node-b" {
 		t.Fatalf("said %v", said)
 	}
 	said = nil
@@ -96,7 +96,7 @@ func TestActionsAreRefusedForWhatTheyCannotBe(t *testing.T) {
 // **A bundle that started says so**, so the operator channel shows again the answers lost with the one
 // before.
 func TestABundleThatStartedSaysSo(t *testing.T) {
-	t.Setenv("MESH_NODE", "g14")
+	t.Setenv("MESH_NODE", "node-b")
 	var said []string
 	before := emit
 	emit = func(event string, body any) error {
@@ -105,7 +105,7 @@ func TestABundleThatStartedSaysSo(t *testing.T) {
 	}
 	t.Cleanup(func() { emit = before })
 	sayStarted()
-	if len(said) != 1 || said[0] != "started map[machine:g14]" {
+	if len(said) != 1 || said[0] != "started map[machine:node-b]" {
 		t.Fatalf("%v", said)
 	}
 }

modules/dunst/cmd/dunst-tools/manifest_helpers_test.go

@@ -227,7 +227,8 @@ func checkNoSecretsOrInstallationNames(t *testing.T) {
 		t.Fatal(err)
 	}
 	s := strings.ToLower(string(raw))
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "api_key", ".hal/", "greenclip daemon"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "api_key", ".hal/", "greenclip daemon"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/fail2ban/cmd/fail2ban-tools/own.go

@@ -48,7 +48,7 @@ const (
 // the operator's own addresses. fail2ban keeps a file entry in its own form, not as written: it reads
 // `file:/var/lib/…` and prints it back as `file://var/lib/…` (server/ipdns.py, FileIPAddrSet.__repr__, in 1.1),
 // in `get <jail> ignoreip` and in its `Ignore … by …` lines alike. So the path is compared, with fail2ban's own
-// reading of the slashes after `file:`, never the text (seen on ace on 2026-10-13: every jail held the list
+// reading of the slashes after `file:`, never the text (seen on node-a on 2026-10-13: every jail held the list
 // and the watch said none did).
 func isOurList(word string) bool {
 	path, ok := strings.CutPrefix(strings.TrimSpace(word), "file:")

modules/fail2ban/cmd/fail2ban-tools/own_test.go

@@ -16,7 +16,7 @@ import (
 )
 
 // asPrinted is the list's entry as fail2ban 1.1 prints it back, in `get <jail> ignoreip` and in its log: it reads
-// `file:/var/lib/…` and keeps it as `file://var/lib/…` (FileIPAddrSet.__repr__), as ace's daemon printed it on
+// `file:/var/lib/…` and keeps it as `file://var/lib/…` (FileIPAddrSet.__repr__), as node-a's daemon printed it on
 // 2026-10-13.
 const asPrinted = "file://var/lib/mesh-fail2ban/own-addresses"
 

modules/feh/cmd/feh-tools/manifest_helpers_test.go

@@ -259,7 +259,8 @@ func checkNoSecretsOrInstallationNames(t *testing.T) {
 		t.Fatal(err)
 	}
 	s := strings.ToLower(string(raw))
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "api_key", ".hal/", "greenclip daemon"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "api_key", ".hal/", "greenclip daemon"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/forticlient/cmd/forticlient-tools/manifest_test.go

@@ -82,7 +82,8 @@ func TestTheToolsAgreeWithTheManifest(t *testing.T) {
 		t.Errorf("the Go tools bundle: %v", b)
 	}
 	s := strings.ToLower(raw)
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "http", "password", "token"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "http", "password", "token"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/gnome-keyring/cmd/gnome-keyring-tools/manifest_helpers_test.go

@@ -257,7 +257,8 @@ func checkNoSecretsOrInstallationNames(t *testing.T) {
 		t.Fatal(err)
 	}
 	s := strings.ToLower(string(raw))
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "api_key", ".hal/", "greenclip daemon"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "api_key", ".hal/", "greenclip daemon"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/home-assistant/provisions/connections.ts

@@ -105,7 +105,7 @@ export function hasField(schema: readonly SchemaField[] | null | undefined, name
 // **Nothing loses its connection without someone seeing it.** Before Home Assistant is touched the
 // broker itself is asked whether it takes the delivered login (the provisioner creates it within
 // seconds of the grant): if not, nothing is written and the step fails saying why, and Home
-// Assistant keeps the login it has — the carried `luffy` on ace, which mosquitto keeps. If Home
+// Assistant keeps the login it has — the carried `luffy` on node-a, which mosquitto keeps. If Home
 // Assistant's own connection test refuses the new settings, the flow saves nothing, and the step
 // fails with Home Assistant's reason. A login that may not subscribe to the discovery topics is said
 // as a warning: discovery would find nothing.
@@ -299,8 +299,8 @@ export function describe(r: { type: string; reason?: string; errors?: Record<str
 //      is the bound one and which is loaded: already as the mesh says. The key needs no digest here:
 //      a Servarr app has one key, so an entry loaded against the app holds the key the app took.
 //   5. A working entry at a different URL that reaches **the same app** — the same process, by the
-//      app's own status (start time, data folder, version) — is left as it is and said: ace's entries
-//      say `127.0.0.1:<port>` and the binding says `ace.internal:<port>`, one Sonarr either way.
+//      app's own status (start time, data folder, version) — is left as it is and said: node-a's entries
+//      say `127.0.0.1:<port>` and the binding says `node-a.internal:<port>`, one Sonarr either way.
 //   6. Anything else is refused, loudly, with what the operator can do; nothing is removed.
 
 

modules/home-assistant/test/provisions.test.ts

@@ -6,7 +6,7 @@
 // minted value before the operator accepts the app's) is never written.
 //
 // Home Assistant and the apps are fakes answering as the real ones do (flow shapes checked against
-// ghcr.io/home-assistant/home-assistant 2026.9.3, the build ace runs).
+// ghcr.io/home-assistant/home-assistant 2026.9.3, the build node-a runs).
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
@@ -21,7 +21,7 @@ const PWD_NOT_CHANGED = "__**password_not_changed**__";
 const MINTED = "mesh-minted-password";
 
 function mqttBinding(): Binding {
-  return { provision: "mqtt-topic", from: "ace", at: "ace.internal", as: "mesh_ace_hass", serves: { scheme: "mqtt", port: 1883 } };
+  return { provision: "mqtt-topic", from: "node-a", at: "node-a.internal", as: "mesh_node-a_hass", serves: { scheme: "mqtt", port: 1883 } };
 }
 
 /** The MQTT reconfigure form as Home Assistant serializes it, pre-filled from an entry. */
@@ -138,29 +138,29 @@ function memoryMarks(): Marks & { store: Map<string, string> } {
   return { store, get: async (k) => store.get(k), set: async (k, v) => void store.set(k, v) };
 }
 
-const takes = (suback = 0): Probe => async (_h, _p, user, pass) => ({ connack: user === "mesh_ace_hass" && pass === MINTED ? 0 : 5, suback });
+const takes = (suback = 0): Probe => async (_h, _p, user, pass) => ({ connack: user === "mesh_node-a_hass" && pass === MINTED ? 0 : 5, suback });
 
-const aceMqttEntry = () => ({
+const nodeAMqttEntry = () => ({
   entry_id: "7d1e", domain: "mqtt", state: "loaded",
   data: { broker: "127.0.0.1", port: 1883, protocol: "5", username: "luffy", password: "luffys-password" },
 });
 
 test("mqtt: the broker is asked first; a login it does not take is never written", async () => {
-  const f = fakeHass({ entries: { mqtt: [aceMqttEntry()] } });
+  const f = fakeHass({ entries: { mqtt: [nodeAMqttEntry()] } });
   const out = await reconcileMqtt({ hass: f.hass, probe: async () => ({ connack: 5 }), marks: memoryMarks() }, mqttBinding(), MINTED);
   assert.equal(out.result, "refused");
-  assert.match((out as { problem: string }).problem, /does not \(yet\) take the login mesh_ace_hass/);
+  assert.match((out as { problem: string }).problem, /does not \(yet\) take the login mesh_node-a_hass/);
   assert.deepEqual(f.calls, []); // Home Assistant not even asked
   assert.equal(f.entries.mqtt[0].data.username, "luffy");
 });
 
-test("mqtt: ace's entry (127.0.0.1, luffy) is moved to the bound broker and login, every other setting kept", async () => {
-  const f = fakeHass({ entries: { mqtt: [aceMqttEntry()] } });
+test("mqtt: node-a's entry (127.0.0.1, luffy) is moved to the bound broker and login, every other setting kept", async () => {
+  const f = fakeHass({ entries: { mqtt: [nodeAMqttEntry()] } });
   const marks = memoryMarks();
   const out = await reconcileMqtt({ hass: f.hass, probe: takes(), marks }, mqttBinding(), `${MINTED}\n`);
   assert.deepEqual(out, { what: "mqtt", result: "written", fields: ["broker", "username", "password"] });
   assert.deepEqual(f.entries.mqtt[0].data, {
-    broker: "ace.internal", port: 1883, protocol: "5", username: "mesh_ace_hass", password: MINTED,
+    broker: "node-a.internal", port: 1883, protocol: "5", username: "mesh_node-a_hass", password: MINTED,
     other_settings: { keepalive: 60, transport: "tcp", set_ca_cert: "off", set_client_cert: false },
   });
   assert.ok(marks.store.get("mqtt"));
@@ -175,7 +175,7 @@ test("mqtt: ace's entry (127.0.0.1, luffy) is moved to the bound broker and logi
 });
 
 test("mqtt: a new password alone is written (the digest tells)", async () => {
-  const f = fakeHass({ entries: { mqtt: [aceMqttEntry()] } });
+  const f = fakeHass({ entries: { mqtt: [nodeAMqttEntry()] } });
   const marks = memoryMarks();
   await reconcileMqtt({ hass: f.hass, probe: takes(), marks }, mqttBinding(), MINTED);
   const rotated: Probe = async () => ({ connack: 0, suback: 0 });
@@ -185,7 +185,7 @@ test("mqtt: a new password alone is written (the digest tells)", async () => {
 });
 
 test("mqtt: Home Assistant's own connection test refusing saves nothing and fails loudly", async () => {
-  const f = fakeHass({ entries: { mqtt: [aceMqttEntry()] }, accepts: () => false });
+  const f = fakeHass({ entries: { mqtt: [nodeAMqttEntry()] }, accepts: () => false });
   const marks = memoryMarks();
   const out = await reconcileMqtt({ hass: f.hass, probe: takes(), marks }, mqttBinding(), MINTED);
   assert.equal(out.result, "refused");
@@ -199,11 +199,11 @@ test("mqtt: a fresh Home Assistant gets an entry; a grant without the discovery
   const out = await reconcileMqtt({ hass: f.hass, probe: takes(0x80), marks: memoryMarks() }, mqttBinding(), MINTED);
   assert.equal(out.result, "written");
   assert.match((out as { note?: string }).note ?? "", /may not subscribe to homeassistant\/#/);
-  assert.equal(f.entries.mqtt[0].data.broker, "ace.internal");
+  assert.equal(f.entries.mqtt[0].data.broker, "node-a.internal");
 });
 
 test("mqtt: two entries, or a binding without a port, are refused rather than guessed", async () => {
-  const f = fakeHass({ entries: { mqtt: [aceMqttEntry(), { ...aceMqttEntry(), entry_id: "other" }] } });
+  const f = fakeHass({ entries: { mqtt: [nodeAMqttEntry(), { ...nodeAMqttEntry(), entry_id: "other" }] } });
   assert.equal((await reconcileMqtt({ hass: f.hass, probe: takes(), marks: memoryMarks() }, mqttBinding(), MINTED)).result, "refused");
   const noPort = { ...mqttBinding(), serves: {} };
   assert.match(((await reconcileMqtt({ hass: f.hass, probe: takes(), marks: memoryMarks() }, noPort, MINTED)) as { problem: string }).problem, /no usable port/);
@@ -214,9 +214,9 @@ test("mqtt: two entries, or a binding without a port, are refused rather than gu
 const SONARR = APPS.find((a) => a.domain === "sonarr") as ServarrApp;
 const RADARR = APPS.find((a) => a.domain === "radarr") as ServarrApp;
 const KEY = "the-apps-own-key";
-const servarrBinding = (port: number, at = "ace.internal"): Binding => ({ provision: "sonarr-api", from: "ace", at, as: "mesh_ace_hass", serves: { scheme: "http", port, "url-base": "" } });
+const servarrBinding = (port: number, at = "node-a.internal"): Binding => ({ provision: "sonarr-api", from: "node-a", at, as: "mesh_node-a_hass", serves: { scheme: "http", port, "url-base": "" } });
 
-/** One running Sonarr, answering on several addresses (127.0.0.1 and ace.internal are one host). */
+/** One running Sonarr, answering on several addresses (127.0.0.1 and node-a.internal are one host). */
 function apps(instances: Record<string, { startTime: string }>): Http & { asked: string[] } {
   const asked: string[] = [];
   return {
@@ -231,18 +231,18 @@ function apps(instances: Record<string, { startTime: string }>): Http & { asked:
     },
   };
 }
-const oneSonarr = () => apps({ "ace.internal:8989": { startTime: "t1" }, "127.0.0.1:8989": { startTime: "t1" } });
+const oneSonarr = () => apps({ "node-a.internal:8989": { startTime: "t1" }, "127.0.0.1:8989": { startTime: "t1" } });
 const sonarrEntry = (state = "loaded") => ({ entry_id: "5a1d", domain: "sonarr", state, data: { url: "http://127.0.0.1:8989", api_key: KEY } });
 
 test("servarr: the mesh's minted key is never written; the remedy names the accept", async () => {
   const f = fakeHass({ entries: { sonarr: [sonarrEntry()] } });
   const out = await reconcileApp({ hass: f.hass, http: oneSonarr() }, SONARR, servarrBinding(8989), "minted-by-the-mesh");
   assert.equal(out.result, "refused");
-  assert.match((out as { problem: string }).problem, /secret accept <this node> home-assistant sonarr-api --provider ace/);
+  assert.match((out as { problem: string }).problem, /secret accept <this node> home-assistant sonarr-api --provider node-a/);
   assert.deepEqual(f.calls, []);
 });
 
-test("servarr: ace's entry at 127.0.0.1 reaches the same Sonarr the mesh bound at ace.internal — left, and said", async () => {
+test("servarr: node-a's entry at 127.0.0.1 reaches the same Sonarr the mesh bound at node-a.internal — left, and said", async () => {
   const f = fakeHass({ entries: { sonarr: [sonarrEntry()] }, devices: [{ id: "d", config_entries: ["5a1d"], configuration_url: "http://127.0.0.1:8989" }] });
   const out = await reconcileApp({ hass: f.hass, http: oneSonarr() }, SONARR, servarrBinding(8989), KEY);
   assert.equal(out.result, "equivalent");
@@ -250,13 +250,13 @@ test("servarr: ace's entry at 127.0.0.1 reaches the same Sonarr the mesh bound a
 });
 
 test("servarr: an entry already at the bound URL is unchanged", async () => {
-  const f = fakeHass({ entries: { sonarr: [sonarrEntry()] }, devices: [{ id: "d", config_entries: ["5a1d"], configuration_url: "http://ace.internal:8989" }] });
+  const f = fakeHass({ entries: { sonarr: [sonarrEntry()] }, devices: [{ id: "d", config_entries: ["5a1d"], configuration_url: "http://node-a.internal:8989" }] });
   assert.deepEqual(await reconcileApp({ hass: f.hass, http: oneSonarr() }, SONARR, servarrBinding(8989), KEY), { what: "sonarr", result: "unchanged" });
 });
 
 test("servarr: a working entry that reaches a different app is refused, and nothing is removed", async () => {
   const f = fakeHass({ entries: { sonarr: [sonarrEntry()] }, devices: [{ id: "d", config_entries: ["5a1d"], configuration_url: "http://127.0.0.1:8989" }] });
-  const two = apps({ "ace.internal:8989": { startTime: "t1" }, "127.0.0.1:8989": { startTime: "another" } });
+  const two = apps({ "node-a.internal:8989": { startTime: "t1" }, "127.0.0.1:8989": { startTime: "another" } });
   const out = await reconcileApp({ hass: f.hass, http: two }, SONARR, servarrBinding(8989), KEY);
   assert.equal(out.result, "refused");
   assert.match((out as { problem: string }).problem, /never does/);
@@ -267,7 +267,7 @@ test("servarr: no entry — one is made at the bound URL through the user flow",
   const f = fakeHass({ entries: {} });
   const out = await reconcileApp({ hass: f.hass, http: oneSonarr() }, SONARR, servarrBinding(8989), KEY);
   assert.deepEqual(out, { what: "sonarr", result: "written", fields: ["entry"] });
-  assert.deepEqual(f.submitted[0], { url: "http://ace.internal:8989", api_key: KEY, more_options: { verify_ssl: false } });
+  assert.deepEqual(f.submitted[0], { url: "http://node-a.internal:8989", api_key: KEY, more_options: { verify_ssl: false } });
 });
 
 test("servarr: a reauth Home Assistant started is finished with the bound URL and key", async () => {
@@ -276,10 +276,10 @@ test("servarr: a reauth Home Assistant started is finished with the bound URL an
     entries: { radarr: [entry] },
     reauth: [{ flow_id: "r1", handler: "radarr", step_id: "reauth_confirm", context: { source: "reauth", entry_id: "1955" } }],
   });
-  const radarr = apps({ "ace.internal:7878": { startTime: "t" } });
+  const radarr = apps({ "node-a.internal:7878": { startTime: "t" } });
   const out = await reconcileApp({ hass: f.hass, http: radarr }, RADARR, { ...servarrBinding(7878), provision: "radarr-api" }, KEY);
   assert.deepEqual(out, { what: "radarr", result: "written", fields: ["api_key", "url"] });
-  assert.deepEqual(f.submitted[0], { url: "http://ace.internal:7878", api_key: KEY, verify_ssl: false });
+  assert.deepEqual(f.submitted[0], { url: "http://node-a.internal:7878", api_key: KEY, verify_ssl: false });
 });
 
 test("form values: suggested first, then default, sections nested", () => {
@@ -287,7 +287,7 @@ test("form values: suggested first, then default, sections nested", () => {
     broker: "b", port: 1, protocol: "5", username: "u", password: PWD_NOT_CHANGED,
     other_settings: { keepalive: 60, transport: "tcp", set_ca_cert: "off", set_client_cert: false },
   });
-  assert.ok(sameUrl("http://ace.internal:8989/", "http://ace.internal:8989"));
-  assert.ok(sameUrl("http://ACE.internal", "http://ace.internal:80"));
-  assert.ok(!sameUrl("http://127.0.0.1:8989", "http://ace.internal:8989"));
+  assert.ok(sameUrl("http://node-a.internal:8989/", "http://node-a.internal:8989"));
+  assert.ok(sameUrl("http://NODE-A.internal", "http://node-a.internal:80"));
+  assert.ok(!sameUrl("http://127.0.0.1:8989", "http://node-a.internal:8989"));
 });

modules/i3status-rust/cmd/i3status-rust-tools/manifest_helpers_test.go

@@ -261,7 +261,8 @@ func checkNoSecretsOrInstallationNames(t *testing.T) {
 		t.Fatal(err)
 	}
 	s := strings.ToLower(string(raw))
-	for _, never := range []string{"/home/", "jochen", "g14", "shanks", "novox.be", "api_key", ".hal/", "greenclip daemon"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, never := range []string{"/home/", "jochen", "api_key", ".hal/", "greenclip daemon"} {
 		if strings.Contains(s, never) {
 			t.Errorf("module.json names %q", never)
 		}

modules/influxdb/test/grants.test.ts

@@ -108,13 +108,13 @@ const grants = new ApiGrants(new InfluxDBClient(`http://127.0.0.1:${port}`, ADMI
 
 const PW = "mesh-minted-password-of-forty-characters";
 
-/** Grafana on ace, as the mesh hands it to the provisioner. */
+/** Grafana on node-a, as the mesh hands it to the provisioner. */
 function grafana(password = PW, values: Record<string, unknown> = { access: "read" }) {
-  return { as: "mesh_ace_grafana", password, consumer: "ace", values };
+  return { as: "mesh_node-a_grafana", password, consumer: "node-a", values };
 }
-/** Node-RED on ace: writes one bucket. */
+/** Node-RED on node-a: writes one bucket. */
 function nodered(password = PW, values: Record<string, unknown> = { access: "write", buckets: ["zurag"] }) {
-  return { as: "mesh_ace_nodered", password, consumer: "ace", values };
+  return { as: "mesh_node-a_nodered", password, consumer: "node-a", values };
 }
 
 function only(token: string): Rec {
@@ -144,7 +144,7 @@ test("what a contribution may ask for, and what is refused", () => {
 
 test("a reader is given one authorization, reading every bucket of the org, under the mesh's password", async () => {
   assert.equal(await grants.ensure(grafana()), "created");
-  const a = only("mesh_ace_grafana");
+  const a = only("mesh_node-a_grafana");
   assert.equal(a.orgID, "org1");
   assert.equal(a.status, "active");
   assert.ok(a.description.startsWith(MARK));
@@ -158,8 +158,8 @@ test("a writer is allowed its own buckets only, and a missing one is made — ne
   const made = buckets.find((b) => b.name === "printer");
   assert.ok(made, "the missing bucket was created");
   assert.deepEqual(made!.retentionRules, [], "kept for ever: retention is the operator's choice");
-  assert.deepEqual(perms(only("mesh_ace_nodered")), [`write:buckets:${made!.id}`, "write:buckets:zb"]);
-  assert.equal(await grants.remove("mesh_ace_nodered"), "removed");
+  assert.deepEqual(perms(only("mesh_node-a_nodered")), [`write:buckets:${made!.id}`, "write:buckets:zb"]);
+  assert.equal(await grants.remove("mesh_node-a_nodered"), "removed");
   assert.equal(buckets.length, 2, "withdrawing the consumer leaves every bucket and its data");
 });
 
@@ -168,30 +168,30 @@ test("applying the same grant again writes nothing", async () => {
   calls = [];
   assert.equal(await grants.ensure(grafana()), "unchanged");
   assert.ok(calls.every((c) => c.startsWith("GET")), `only reads: ${calls.join(", ")}`);
-  only("mesh_ace_grafana");
+  only("mesh_node-a_grafana");
 });
 
 test("a rotated password is set in place; a changed access remakes only the mesh's own", async () => {
   await grants.ensure(nodered());
-  const id = only("mesh_ace_nodered").id;
+  const id = only("mesh_node-a_nodered").id;
   assert.equal(await grants.holds(nodered("rotated-password-0123456789")), false);
   assert.equal(await grants.ensure(nodered("rotated-password-0123456789")), "updated");
-  assert.equal(only("mesh_ace_nodered").id, id, "updated, not replaced");
+  assert.equal(only("mesh_node-a_nodered").id, id, "updated, not replaced");
   assert.equal(await grants.holds(nodered("rotated-password-0123456789")), true);
 
   await grants.ensure(nodered(PW, { access: "read-write", buckets: ["zurag"] }));
-  assert.deepEqual(perms(only("mesh_ace_nodered")), ["read:buckets:zb", "write:buckets:zb"]);
+  assert.deepEqual(perms(only("mesh_node-a_nodered")), ["read:buckets:zb", "write:buckets:zb"]);
   assert.equal(await grants.holds(nodered(PW, { access: "read-write", buckets: ["zurag"] })), true);
 });
 
 test("an authorization disabled, re-passworded or deleted behind the mesh's back is not held, and is made whole", async () => {
   await grants.ensure(grafana());
-  only("mesh_ace_grafana").status = "inactive";
+  only("mesh_node-a_grafana").status = "inactive";
   assert.equal(await grants.holds(grafana()), false);
   assert.equal(await grants.ensure(grafana()), "updated");
   assert.equal(await grants.holds(grafana()), true);
 
-  only("mesh_ace_grafana").password = "somebody-else-set-this";
+  only("mesh_node-a_grafana").password = "somebody-else-set-this";
   assert.equal(await grants.holds(grafana()), false);
   await grants.ensure(grafana());
   assert.equal(await grants.holds(grafana()), true);
@@ -211,14 +211,14 @@ test("holds only reads, and a bucket gone missing is not held rather than made",
 });
 
 test("an authorization of the same name the mesh did not make is refused, and left exactly as it was", async () => {
-  auths = [{ id: "theirs", token: "mesh_ace_grafana", orgID: "org1", status: "active", description: "hand-made",
+  auths = [{ id: "theirs", token: "mesh_node-a_grafana", orgID: "org1", status: "active", description: "hand-made",
     permissions: [{ action: "write", resource: { type: "buckets", orgID: "org1" } }], password: "their-password" }];
   const before = JSON.stringify(auths);
   await assert.rejects(grants.ensure(grafana()), /did not make/);
   assert.equal(JSON.stringify(auths), before);
   assert.ok(calls.every((c) => c.startsWith("GET")), `only reads: ${calls.join(", ")}`);
   assert.equal(await grants.holds(grafana()), false);
-  assert.equal(await grants.remove("mesh_ace_grafana"), "not ours");
+  assert.equal(await grants.remove("mesh_node-a_grafana"), "not ours");
   assert.equal(auths.length, 1, "never deleted");
 });
 
@@ -240,7 +240,7 @@ test("an org the instance does not have, or a non-mesh name, makes nothing", asy
 
 test("a withdrawn consumer's authorization is removed, and an absent one is not an error", async () => {
   await grants.ensure(grafana());
-  assert.equal(await grants.remove("mesh_ace_grafana"), "removed");
+  assert.equal(await grants.remove("mesh_node-a_grafana"), "removed");
   assert.equal(auths.length, 0);
-  assert.equal(await grants.remove("mesh_ace_grafana"), "absent");
+  assert.equal(await grants.remove("mesh_node-a_grafana"), "absent");
 });

modules/keycloak/cmd/keycloak-provider/admin_test.go

@@ -52,7 +52,7 @@ type guardWorld struct {
 
 func newGuardWorld(t *testing.T) *guardWorld {
 	w := &guardWorld{now: time.Date(2026, 10, 5, 23, 55, 0, 0, time.UTC)}
-	w.f = newFakeKeycloak(t, "Novox", "old-password-from-2022")
+	w.f = newFakeKeycloak(t, "NodeC", "old-password-from-2022")
 	w.x = &fakeExec{f: w.f}
 	w.g = &Guard{KC: w.f.client("the-mesh-minted-this"), Exec: w.x,
 		Now:      func() time.Time { return w.now },
@@ -195,7 +195,7 @@ func TestWhileTheAdminIsRefusedTheProvisionerDoesNotAskKeycloak(t *testing.T) {
 	w := newGuardWorld(t)
 	w.x.fails = true
 	w.g.Ensure(ctx, true, false)
-	a := provisioner{clients: OidcClients{KC: w.g.KC, Realm: "Novox"}, guard: w.g,
+	a := provisioner{clients: OidcClients{KC: w.g.KC, Realm: "NodeC"}, guard: w.g,
 		announce: func(string, map[string]any) {}, log: func(string, ...any) {}}
 	logins := w.f.logins
 	err := a.Create(ctx, grafana("s", nil))

modules/keycloak/cmd/keycloak-provider/grant_moved_test.go

@@ -91,13 +91,13 @@ func movedWorld(t *testing.T, h *harness.Harness) (f *fakeKeycloak, start func()
 	}
 }
 
-// 1332/AC1: a consumer only the grant file gives (oidc-client for novox.mesh-mail-web, not moved) is wanted and
+// 1332/AC1: a consumer only the grant file gives (oidc-client for node-c.mesh-mail-web, not moved) is wanted and
 // Adapter.Create is asked for its client, though keycloak runs on the moved path.
 func TestAGrantFileConsumerNotMovedIsMadeOnTheMovedPath(t *testing.T) {
-	mailWeb := "mesh_novox_mail_web"
-	receives := grantGives(t, map[string]any{"as": mailWeb, "node": "novox", "values": map[string]any{
+	mailWeb := "mesh_node_c_mail_web"
+	receives := grantGives(t, map[string]any{"as": mailWeb, "node": "node-c", "values": map[string]any{
 		"label": "mail-web", "endpoint": "web", "callback": "/login/generic_oauth", "name": "mail.example.org"}})
-	h := &harness.Harness{Resource: ProvisionName, Receives: receives, Node: "novox"}
+	h := &harness.Harness{Resource: ProvisionName, Receives: receives, Node: "node-c"}
 	f, start := movedWorld(t, h)
 	start()
 	waitUntil(t, time.Second, func() bool {
@@ -113,13 +113,13 @@ func TestAGrantFileConsumerNotMovedIsMadeOnTheMovedPath(t *testing.T) {
 	})
 }
 
-// 1332/AC2: a grant-file consumer whose client already exists in the backend (mesh_ace_grafana) counts as asked and
+// 1332/AC2: a grant-file consumer whose client already exists in the backend (mesh_node_a_grafana) counts as asked and
 // is not held for retirement on the moved path.
 func TestAGrantFileConsumerAlreadyInKeycloakIsNotRetiredOnTheMovedPath(t *testing.T) {
-	grafana := "mesh_ace_grafana"
-	receives := grantGives(t, map[string]any{"as": grafana, "node": "ace", "values": map[string]any{
+	grafana := "mesh_node_a_grafana"
+	receives := grantGives(t, map[string]any{"as": grafana, "node": "node-a", "values": map[string]any{
 		"label": "grafana", "endpoint": "web", "callback": "/login/generic_oauth", "name": "grafana.example.org"}})
-	h := &harness.Harness{Resource: ProvisionName, Receives: receives, Node: "ace",
+	h := &harness.Harness{Resource: ProvisionName, Receives: receives, Node: "node-a",
 		StablePasses: 1, StableFor: time.Millisecond}
 	f, start := movedWorld(t, h)
 	// Seed the backend with the client the mesh made earlier, exactly as grafana's already is — before anything

modules/keycloak/cmd/keycloak-provider/main_test.go

@@ -8,7 +8,7 @@ import "testing"
 // 1332/AC3: the moved-path harness, built from the environment, reads MESH_RECEIVES the way the grant path does
 // (main.go's other branch, line 67), as postgres's moved harness does (postgres-provider/main.go:43).
 func TestTheMovedPathHarnessReadsMESH_RECEIVESAsTheGrantPathDoes(t *testing.T) {
-	env := map[string]string{"MESH_RECEIVES": "/grants/mesh.json", "MESH_NODE": "novox"}
+	env := map[string]string{"MESH_RECEIVES": "/grants/mesh.json", "MESH_NODE": "node-c"}
 	getenv := func(k string) string { return env[k] }
 	h := movedHarness(getenv, provisioner{})
 	if h.Receives != env["MESH_RECEIVES"] {

modules/keycloak/cmd/keycloak-provider/moved_test.go

@@ -14,7 +14,7 @@ import (
 	"git.novox.be/novox/mesh-sdk/go/provider/harness"
 )
 
-const testIssuer = "https://id.example.org/realms/Novox"
+const testIssuer = "https://id.example.org/realms/NodeC"
 
 // keycloak's own part of the moved path (issue 849): the shared driving of it is proven in the SDK's harness package.
 
@@ -143,12 +143,12 @@ func TestBothPathsLeaveTheSameClientInKeycloak(t *testing.T) {
 	})
 	viaFile := made(func(p provisioner) {
 		list, _ := json.Marshal([]provider.ConsumerCredential{{Consumer: "home", Module: "grafana",
-			Credential: provider.PairName("novox", ProvisionName, "home", "grafana", ""), Value: "pw-" + grafana}})
+			Credential: provider.PairName("node-c", ProvisionName, "home", "grafana", ""), Value: "pw-" + grafana}})
 		file := filepath.Join(t.TempDir(), "consumers.json")
 		if err := os.WriteFile(file, list, 0o600); err != nil {
 			t.Fatal(err)
 		}
-		h := &harness.Harness{Resource: ProvisionName, Adapter: p, Node: "novox",
+		h := &harness.Harness{Resource: ProvisionName, Adapter: p, Node: "node-c",
 			Now: func() time.Time { return now }, Log: func(string, ...any) {}}
 		run, _, _, err := moved(file, h, testIssuer)
 		if err != nil {
@@ -156,10 +156,10 @@ func TestBothPathsLeaveTheSameClientInKeycloak(t *testing.T) {
 		}
 		bus := &bucketBus{buckets: map[string]map[string][]byte{}}
 		plan, _ := json.Marshal(map[string]any{"node": "home", "module": "grafana", "provisioning": map[string]any{
-			"provisions": []any{map[string]any{"provision": ProvisionName, "provider": "novox",
+			"provisions": []any{map[string]any{"provision": ProvisionName, "provider": "node-c",
 				"provider-module": "keycloak", "contributes": grafanaContributes, "names": grafanaNames}}}})
 		_ = bus.Put(ctx, provider.AssignmentsBucket, "home.grafana", plan)
-		pr := provider.New(provider.Options{Node: "novox", Module: "keycloak", Bus: bus,
+		pr := provider.New(provider.Options{Node: "node-c", Module: "keycloak", Bus: bus,
 			Vault: provider.ConsumersFile{Paths: []string{file}},
 			Offers: map[string]provider.Offer{ProvisionName: {Credential: provider.PerConsumer,
 				Serves: servedValues(testIssuer)}},

modules/keycloak/cmd/keycloak-provider/oidc.go

@@ -64,7 +64,7 @@ func RolesMapper() Rep {
 
 var realmPath = regexp.MustCompile(`/realms/([^/]+)/?$`)
 
-// RealmOf is the realm named by an issuer URL — `https://id.example/realms/Novox` is realm `Novox`.
+// RealmOf is the realm named by an issuer URL — `https://id.example/realms/NodeC` is realm `NodeC`.
 // The issuer is the one value an assignment sets, so the realm is read out of it rather than set a
 // second time where the two could disagree.
 func RealmOf(issuer string) (string, error) {

modules/keycloak/cmd/keycloak-provider/oidc_test.go

@@ -15,8 +15,8 @@ import (
 )
 
 func oidcWorld(t *testing.T) (*fakeKeycloak, OidcClients) {
-	f := newFakeKeycloak(t, "Novox", "pw")
-	return f, OidcClients{KC: f.client("pw"), Realm: "Novox"}
+	f := newFakeKeycloak(t, "NodeC", "pw")
+	return f, OidcClients{KC: f.client("pw"), Realm: "NodeC"}
 }
 
 // grafana is a dashboard on the home server, as the mesh hands it to the provisioner.
@@ -53,8 +53,8 @@ func mustHold(t *testing.T, o OidcClients, p harness.Provision, want bool) {
 
 func TestTheRealmIsReadOutOfTheIssuer(t *testing.T) {
 	for issuer, want := range map[string]string{
-		"https://id.example.org/realms/Novox":  "Novox",
-		"https://id.example.org/realms/Novox/": "Novox",
+		"https://id.example.org/realms/NodeC":  "NodeC",
+		"https://id.example.org/realms/NodeC/": "NodeC",
 		"http://127.0.0.1:18500/realms/master": "master",
 	} {
 		if got, err := RealmOf(issuer); err != nil || got != want {

modules/lab/files/lab.env

@@ -1,3 +1,4 @@
 MESH_LAB_FORGE=${config:forge}
+MESH_LAB_FORGE_OWNER=${config:forge-owner}
 MESH_LAB_FORGE_BINDING=${dir:state}/package-registry.json
 MESH_LAB_FORGE_SECRET=${dir:state}/package-registry.secret

modules/lab/module.json

@@ -37,6 +37,12 @@
         "description": "The forge the lab's machines take their packages from, as its address: the operator's, with no default (novox/hq ADR 0112).",
         "trusted": true,
         "required": true
+      },
+      "forge-owner": {
+        "type": "string",
+        "description": "The owner on the forge the mesh's repositories and npm packages are under, such as the organisation that holds them: the operator's, with no default (novox/hq ADR 0507 §9).",
+        "trusted": true,
+        "required": true
       }
     },
   "resources": [

modules/lab/test/base.test.ts

@@ -60,8 +60,8 @@ test("no run starts while the base image is rebuilt", () => {
 });
 
 test("a rebuild is mesh-lab's base build from the forge's main, with no secret in its script", () => {
-  const s = baseScript("/work/base-x", "https://forge.invalid", "/work/.base-x.git-credentials");
-  assert.match(s, /clone --quiet --depth 1 'https:\/\/forge.invalid\/novox\/mesh-lab.git'/);
+  const s = baseScript("/work/base-x", "https://forge.invalid", "mesh-org", "/work/.base-x.git-credentials");
+  assert.match(s, /clone --quiet --depth 1 'https:\/\/forge.invalid\/mesh-org\/mesh-lab.git'/);
   assert.match(s, /src\/cli.ts base build/);
   assert.ok(s.indexOf("rm -f '/work/.base-x.git-credentials'") < s.indexOf("npm ci"), "the credential outlives the clone");
 });

modules/lab/test/owner.test.ts

@@ -0,0 +1,26 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// The forge's owner differs between meshes (novox/hq ADR 0507 §9, issue 1838): the lab takes it as a config value
+// the operator gives, with no default, and no file of the lab names it.
+// 1838/AC4
+
+const here = join(import.meta.dirname, "..");
+
+test("the forge's owner is a required config value with no default, and reaches the lab's env-file", () => {
+  const manifest = JSON.parse(readFileSync(join(here, "module.json"), "utf8")) as { config: Record<string, Record<string, unknown>> };
+  const owner = manifest.config["forge-owner"];
+  assert.ok(owner, "the manifest declares no forge-owner");
+  assert.equal(owner.required, true);
+  assert.ok(!("default" in owner), `forge-owner has the default ${JSON.stringify(owner.default)}`);
+  assert.match(readFileSync(join(here, "files", "lab.env"), "utf8"), /^MESH_LAB_FORGE_OWNER=\$\{config:forge-owner\}$/m);
+});
+
+test("no file of the lab's code names an owner on the forge", () => {
+  for (const f of readdirSync(join(here, "tools")).filter((f) => f.endsWith(".ts"))) {
+    const src = readFileSync(join(here, "tools", f), "utf8");
+    assert.doesNotMatch(src, /\}\/[a-z][\w.-]*\/\$\{repo\}|\}\/[a-z][\w.-]*\/mesh-lab\.git|\/api\/packages\/[a-z][\w.-]*\/npm\//, f);
+  }
+});

modules/lab/test/runs.test.ts

@@ -92,8 +92,8 @@ test("a run fails at its setup, naming the checkout, when nothing of it can be i
 // checkouts are.
 test("a run checks out mesh-tools-go and says where its checkouts are", () => {
   assert.ok(REPOSITORIES.includes("mesh-tools-go"));
-  const s = script("/work", "run-x", "http://forge", ["test/integration/genesis-keeps-its-bus.test.ts"], {});
-  assert.match(s, /novox\/mesh-tools-go\.git' '\/work\/run-x\/mesh-tools-go'/);
+  const s = script("/work", "run-x", "http://forge", "mesh-org", ["test/integration/genesis-keeps-its-bus.test.ts"], {});
+  assert.match(s, /mesh-org\/mesh-tools-go\.git' '\/work\/run-x\/mesh-tools-go'/);
   assert.match(s, /export MESH_LAB_REPOS='\/work\/run-x'/);
   assert.doesNotMatch(s, /cd '\/work\/run-x'\/\$repo && npm ci/);
   for (const repo of NPM_REPOSITORIES) assert.ok(s.includes(`'/work/run-x/${repo}'/package-lock.json`), repo);
@@ -113,22 +113,22 @@ function aBinding(as: string, secret: string): { binding: string; secret: string
 }
 
 test("the forge credential is the bound account and its sealed secret, for the forge's own origin", () => {
-  const b = aBinding("lab-shanks", "s3cret-of-forty-characters");
-  assert.equal(forgeCredential("http://novox.internal:20000", b.binding, b.secret),
-    "http://lab-shanks:s3cret-of-forty-characters@novox.internal:20000");
-  assert.equal(forgeCredential("http://novox.internal:20000/", b.binding, ""), undefined);
+  const b = aBinding("lab-node-d", "s3cret-of-forty-characters");
+  assert.equal(forgeCredential("http://node-c.internal:20000", b.binding, b.secret),
+    "http://lab-node-d:s3cret-of-forty-characters@node-c.internal:20000");
+  assert.equal(forgeCredential("http://node-c.internal:20000/", b.binding, ""), undefined);
   assert.equal(forgeCredential("", b.binding, b.secret), undefined);
-  assert.equal(forgeCredential("http://novox.internal:20000", "/nowhere", b.secret), undefined);
+  assert.equal(forgeCredential("http://node-c.internal:20000", "/nowhere", b.secret), undefined);
 });
 
 test("a run clones through git's credential store, and its script carries no secret", () => {
-  const b = aBinding("lab-shanks", "s3cret-of-forty-characters");
-  const credential = forgeCredential("http://novox.internal:20000", b.binding, b.secret);
+  const b = aBinding("lab-node-d", "s3cret-of-forty-characters");
+  const credential = forgeCredential("http://node-c.internal:20000", b.binding, b.secret);
   const path = credentialPath("/work", "run-x");
-  const s = script("/work", "run-x", "http://novox.internal:20000", ["t.test.ts"], {}, path);
+  const s = script("/work", "run-x", "http://node-c.internal:20000", "mesh-org", ["t.test.ts"], {}, path);
   assert.ok(credential);
   assert.doesNotMatch(s, /s3cret/);
-  assert.match(s, /git -c credential\.helper= -c 'credential\.helper=store --file=\/work\/\.run-x\.git-credentials' clone --quiet --depth 50 --branch 'main' 'http:\/\/novox\.internal:20000\/novox\/mesh-tools-go\.git'/);
+  assert.match(s, /git -c credential\.helper= -c 'credential\.helper=store --file=\/work\/\.run-x\.git-credentials' clone --quiet --depth 50 --branch 'main' 'http:\/\/node-c\.internal:20000\/mesh-org\/mesh-tools-go\.git'/);
   assert.match(s, /export GIT_TERMINAL_PROMPT=0/);
   assert.equal(path.startsWith("/work/run-x/"), false, "the credential is kept out of the run's own directory");
   assert.equal(credentialArgs(undefined), "");
@@ -139,10 +139,10 @@ test("a run clones through git's credential store, and its script carries no sec
 test("git presents the stored credential to the forge, and only when one is given", () => {
   const dir = mkdtempSync(join(tmpdir(), "lab-git-"));
   const store = join(dir, "git-credentials");
-  writeFileSync(store, "http://lab-shanks:pw@forge.invalid:20000\n", { mode: 0o600 });
+  writeFileSync(store, "http://lab-node-d:pw@forge.invalid:20000\n", { mode: 0o600 });
   const fill = spawnSync("sh", ["-c", `printf 'protocol=http\\nhost=forge.invalid:20000\\n\\n' | git ${credentialArgs(store)}credential fill`],
     { encoding: "utf8", env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
-  assert.match(fill.stdout, /username=lab-shanks/);
+  assert.match(fill.stdout, /username=lab-node-d/);
   assert.match(fill.stdout, /password=pw/);
   const other = spawnSync("sh", ["-c", `printf 'protocol=http\\nhost=elsewhere.invalid\\n\\n' | git ${credentialArgs(store)}credential fill`],
     { encoding: "utf8", env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
@@ -168,7 +168,7 @@ test("a stopped script removes the credential, whatever ends it", () => {
 });
 
 test("the script removes the credential as soon as its clones are done", () => {
-  const s = script("/work", "run-x", "http://forge", ["t.test.ts"], {}, "/work/.run-x.git-credentials");
+  const s = script("/work", "run-x", "http://forge", "mesh-org", ["t.test.ts"], {}, "/work/.run-x.git-credentials");
   const lastClone = s.lastIndexOf("clone --quiet");
   const removed = s.indexOf("rm -f '/work/.run-x.git-credentials'", lastClone);
   const building = s.indexOf("npm ci");
@@ -252,10 +252,10 @@ test("the lab's tools bundle names its bound credential and binding in its env",
   assert.equal(env.MESH_LAB_FORGE_BINDING, m.binds["npm-package-registry"]);
 });
 
-// The next setup failure of novox/hq issue 624 (run-2026-10-13T13-15-26-634Z on shanks): npm 12 refused
+// The next setup failure of novox/hq issue 624 (run-2026-10-13T13-15-26-634Z on node-d): npm 12 refused
 // mesh-tools' locked @novox/mesh-sdk with EALLOWREMOTE. The lab named the registry by its forge setting's
-// address (http://novox.internal:20000/…), the lock file holds the address the forge writes every tarball
-// URL at (https://git.novox.be/…), and npm 12 installs a locked tarball only from its configured registry.
+// address (http://node-c.internal:20000/…), the lock file holds the address the forge writes every tarball
+// the forge's URL, and npm 12 installs a locked tarball only from its configured registry.
 // A run names the registry by the address the registry names itself by.
 import { npmRegistry } from "../tools/runs.ts";
 
@@ -270,54 +270,54 @@ function aRegistry(answer: () => Response | Promise<Response>): { get: typeof fe
 
 const packument = (tarball: string) => new Response(JSON.stringify({
   name: "@novox/mesh-sdk", "dist-tags": { latest: "0.1.14" },
-  versions: { "0.1.1": { dist: { tarball: "http://old.example/api/packages/novox/npm/x.tgz" } }, "0.1.14": { dist: { tarball } } },
+  versions: { "0.1.1": { dist: { tarball: "http://old.example/api/packages/mesh-org/npm/x.tgz" } }, "0.1.14": { dist: { tarball } } },
 }), { status: 200, headers: { "content-type": "application/json" } });
 
 test("a run names the package registry by the address the registry gives its tarballs", async () => {
-  const r = aRegistry(() => packument("https://forge.example.org/api/packages/novox/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz"));
-  const got = await npmRegistry("http://forge.example.org:3000/", r.get, "https://forge.example.org/api/packages/novox/npm/");
-  assert.deepEqual(got, { registry: "https://forge.example.org/api/packages/novox/npm/" });
-  assert.deepEqual(r.asked, ["http://forge.example.org:3000/api/packages/novox/npm/@novox%2fmesh-sdk"]);
+  const r = aRegistry(() => packument("https://forge.example.org/api/packages/mesh-org/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz"));
+  const got = await npmRegistry("http://forge.example.org:3000/", "mesh-org", r.get, "https://forge.example.org/api/packages/mesh-org/npm/");
+  assert.deepEqual(got, { registry: "https://forge.example.org/api/packages/mesh-org/npm/" });
+  assert.deepEqual(r.asked, ["http://forge.example.org:3000/api/packages/mesh-org/npm/@novox%2fmesh-sdk"]);
   // The forge's own scheme is taken too, with its port.
-  const plain = await npmRegistry("http://forge.example.org:3000",
-    aRegistry(() => packument("http://forge.example.org:3000/api/packages/novox/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz")).get);
-  assert.deepEqual(plain, { registry: "http://forge.example.org:3000/api/packages/novox/npm/" });
+  const plain = await npmRegistry("http://forge.example.org:3000", "mesh-org",
+    aRegistry(() => packument("http://forge.example.org:3000/api/packages/mesh-org/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz")).get);
+  assert.deepEqual(plain, { registry: "http://forge.example.org:3000/api/packages/mesh-org/npm/" });
 });
 
 // What the registry answers may come over plain HTTP, so it never decides where packages come from: only
 // the forge's public root or its own address, scheme, host and port, under the npm path, with nothing after
 // it (review of mesh-catalog #275, ADR 0346).
 test("a registry that does not give an address the lab takes leaves the forge's, and the reason is said", async () => {
-  const sdk = "/api/packages/novox/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz";
+  const sdk = "/api/packages/mesh-org/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz";
   for (const [answer, why] of [
     [() => new Response("not found", { status: 404 }), /it answered 404/],
     [() => new Response("{}", { status: 200 }), /no tarball/],
     [() => { throw new Error("connect ECONNREFUSED"); }, /ECONNREFUSED/],
-    [() => packument(`https://forge.example.org/elsewhere/mesh-sdk-0.1.14.tgz`), /not under \/api\/packages\/novox\/npm\//],
+    [() => packument(`https://forge.example.org/elsewhere/mesh-sdk-0.1.14.tgz`), /not under \/api\/packages\/mesh-org\/npm\//],
     [() => packument(`https://attacker.example.net${sdk}`), /at https:\/\/attacker\.example\.net, which is neither the forge's public root nor its own address/],
-    [() => packument(`https://attacker.example.net/x?u=https://novox.internal${sdk}`), /query or a fragment/],
-    [() => packument(`https://novox.internal${sdk}?x=1`), /query or a fragment/],
-    [() => packument(`https://novox.internal${sdk}#frag`), /query or a fragment/],
-    [() => packument(`https://attacker.example.net/#https://novox.internal${sdk}`), /query or a fragment/],
-    [() => packument(`ftp://novox.internal${sdk}`), /at ftp:\/\/novox\.internal, which is neither/],
-    [() => packument(`file:///api/packages/novox/npm/x.tgz`), /which is neither/],
-    [() => packument(`https://novox.internal/api/packages/novox/npm/\nregistry=https://attacker.example.net/\nallow-remote=all`), /whitespace or a control character/],
-    [() => packument(`https://user:pw@novox.internal${sdk}`), /user or password/],
+    [() => packument(`https://attacker.example.net/x?u=https://node-c.internal${sdk}`), /query or a fragment/],
+    [() => packument(`https://node-c.internal${sdk}?x=1`), /query or a fragment/],
+    [() => packument(`https://node-c.internal${sdk}#frag`), /query or a fragment/],
+    [() => packument(`https://attacker.example.net/#https://node-c.internal${sdk}`), /query or a fragment/],
+    [() => packument(`ftp://node-c.internal${sdk}`), /at ftp:\/\/node-c\.internal, which is neither/],
+    [() => packument(`file:///api/packages/mesh-org/npm/x.tgz`), /which is neither/],
+    [() => packument(`https://node-c.internal/api/packages/mesh-org/npm/\nregistry=https://attacker.example.net/\nallow-remote=all`), /whitespace or a control character/],
+    [() => packument(`https://user:pw@node-c.internal${sdk}`), /user or password/],
   ] as [() => Response, RegExp][]) {
-    const got = await npmRegistry("http://novox.internal:20000", aRegistry(answer).get);
-    assert.equal(got.registry, "http://novox.internal:20000/api/packages/novox/npm/", String(why));
+    const got = await npmRegistry("http://node-c.internal:20000", "mesh-org", aRegistry(answer).get);
+    assert.equal(got.registry, "http://node-c.internal:20000/api/packages/mesh-org/npm/", String(why));
     assert.match(got.problem ?? "", /did not give an address the lab takes/);
     assert.match(got.problem ?? "", why);
   }
 });
 
 test("a run's npm configuration names the registry it was given, and the forge's own address only without one", () => {
-  const given = script("/work", "run-x", "http://novox.internal:20000", ["t.test.ts"], {}, undefined,
-    "https://forge.example.org/api/packages/novox/npm/");
-  assert.match(given, / '@novox:registry=https:\/\/forge\.example\.org\/api\/packages\/novox\/npm\/' > '\/work\/run-x\/\.npmrc'\n/);
-  assert.doesNotMatch(given, /@novox:registry=http:\/\/novox\.internal/);
-  const none = script("/work", "run-x", "http://novox.internal:20000", ["t.test.ts"], {});
-  assert.match(none, /'@novox:registry=http:\/\/novox\.internal:20000\/api\/packages\/novox\/npm\/'/);
+  const given = script("/work", "run-x", "http://node-c.internal:20000", "mesh-org", ["t.test.ts"], {}, undefined,
+    "https://forge.example.org/api/packages/mesh-org/npm/");
+  assert.match(given, / '@novox:registry=https:\/\/forge\.example\.org\/api\/packages\/mesh-org\/npm\/' > '\/work\/run-x\/\.npmrc'\n/);
+  assert.doesNotMatch(given, /@novox:registry=http:\/\/node-c\.internal/);
+  const none = script("/work", "run-x", "http://node-c.internal:20000", "mesh-org", ["t.test.ts"], {});
+  assert.match(none, /'@novox:registry=http:\/\/node-c\.internal:20000\/api\/packages\/mesh-org\/npm\/'/);
 });
 
 // The public root the forge serves in the lab's binding (novox/hq ADR 0346) is the one other origin a
@@ -325,20 +325,20 @@ test("a run's npm configuration names the registry it was given, and the forge's
 import { publicRootOf } from "../tools/runs.ts";
 
 test("a tarball is taken at the forge's public root, and at no other port or scheme of its host", async () => {
-  const sdk = "/api/packages/novox/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz";
-  const root = "https://git.example.org/api/packages/novox/npm/";
+  const sdk = "/api/packages/mesh-org/npm/%40novox%2Fmesh-sdk/-/0.1.14/mesh-sdk-0.1.14.tgz";
+  const root = "https://git.example.org/api/packages/mesh-org/npm/";
   const at = (tarball: string, publicRoot?: string) =>
-    npmRegistry("http://novox.internal:20000", aRegistry(() => packument(tarball)).get, publicRoot);
+    npmRegistry("http://node-c.internal:20000", "mesh-org", aRegistry(() => packument(tarball)).get, publicRoot);
   assert.deepEqual(await at(`https://git.example.org${sdk}`, root), { registry: root });
   for (const tarball of [`https://git.example.org:8443${sdk}`, `http://git.example.org${sdk}`, `https://example.org${sdk}`]) {
     const got = await at(tarball, root);
-    assert.equal(got.registry, "http://novox.internal:20000/api/packages/novox/npm/", tarball);
+    assert.equal(got.registry, "http://node-c.internal:20000/api/packages/mesh-org/npm/", tarball);
     assert.match(got.problem ?? "", /neither the forge's public root nor its own address/, tarball);
   }
   // Without a public root, the forge's public name is not trusted on its own word.
   assert.match((await at(`https://git.example.org${sdk}`)).problem ?? "", /neither/);
   // And the forge's own address only at its own port.
-  assert.match((await at(`http://novox.internal${sdk}`, root)).problem ?? "", /neither/);
+  assert.match((await at(`http://node-c.internal${sdk}`, root)).problem ?? "", /neither/);
 });
 
 test("the public root is read from the binding, and only an https root at the npm path is taken", () => {
@@ -346,39 +346,39 @@ test("the public root is read from the binding, and only an https root at the np
   const binding = (root: unknown) => {
     const f = join(dir, `b-${Math.random()}.json`);
     writeFileSync(f, JSON.stringify({ provision: "npm-package-registry", at: "home", serves: { scheme: "http", port: 3000,
-      "npm-path": "/api/packages/novox/npm/", ...(root === undefined ? {} : { "public-root": root }) } }));
+      "npm-path": "/api/packages/mesh-org/npm/", ...(root === undefined ? {} : { "public-root": root }) } }));
     return f;
   };
-  assert.deepEqual(publicRootOf(binding("https://git.example.org/api/packages/novox/npm/")),
-    { root: "https://git.example.org/api/packages/novox/npm/" });
-  assert.deepEqual(publicRootOf(binding("https://git.example.org:8443/api/packages/novox/npm/")),
-    { root: "https://git.example.org:8443/api/packages/novox/npm/" });
+  assert.deepEqual(publicRootOf(binding("https://git.example.org/api/packages/mesh-org/npm/"), "mesh-org"),
+    { root: "https://git.example.org/api/packages/mesh-org/npm/" });
+  assert.deepEqual(publicRootOf(binding("https://git.example.org:8443/api/packages/mesh-org/npm/"), "mesh-org"),
+    { root: "https://git.example.org:8443/api/packages/mesh-org/npm/" });
   for (const [root, why] of [
     [undefined, /serves no public-root/],
-    ["http://git.example.org/api/packages/novox/npm/", /is not https:\/\/<host>/],
+    ["http://git.example.org/api/packages/mesh-org/npm/", /is not https:\/\/<host>/],
     ["https://git.example.org/elsewhere/", /is not https:\/\/<host>/],
-    ["https://git.example.org/api/packages/novox/npm/?x=1", /is not https:\/\/<host>/],
-    ["https://u:p@git.example.org/api/packages/novox/npm/", /is not https:\/\/<host>/],
-    ["https://git.example.org/api/packages/novox/npm/\nallow-remote=all", /whitespace or a control character/],
-    ["https://${bound:route:name-web}/api/packages/novox/npm/", /not a URL|is not https/],
+    ["https://git.example.org/api/packages/mesh-org/npm/?x=1", /is not https:\/\/<host>/],
+    ["https://u:p@git.example.org/api/packages/mesh-org/npm/", /is not https:\/\/<host>/],
+    ["https://git.example.org/api/packages/mesh-org/npm/\nallow-remote=all", /whitespace or a control character/],
+    ["https://${bound:route:name-web}/api/packages/mesh-org/npm/", /not a URL|is not https/],
   ] as [unknown, RegExp][]) {
-    const got = publicRootOf(binding(root));
+    const got = publicRootOf(binding(root), "mesh-org");
     assert.equal(got.root, undefined, String(root));
     assert.match(got.problem ?? "", why, String(root));
   }
-  assert.match(publicRootOf(join(dir, "none.json")).problem ?? "", /could not be read/);
-  assert.match(publicRootOf(undefined).problem ?? "", /no npm-package-registry binding/);
+  assert.match(publicRootOf(join(dir, "none.json"), "mesh-org").problem ?? "", /could not be read/);
+  assert.match(publicRootOf(undefined, "mesh-org").problem ?? "", /no npm-package-registry binding/);
   rmSync(dir, { recursive: true, force: true });
 });
 
 // A forge setting that is not http(s) is never a trusted origin (review of #280): a `file:` tarball's origin
 // is "null", as is a `file:` forge's, and the two must not match.
 test("a forge setting that is not http(s) trusts no origin of its own", async () => {
-  const got = await npmRegistry("file:///srv/forge", aRegistry(() => packument("file:///api/packages/novox/npm/x.tgz")).get);
+  const got = await npmRegistry("file:///srv/forge", "mesh-org", aRegistry(() => packument("file:///api/packages/mesh-org/npm/x.tgz")).get);
   assert.match(got.problem ?? "", /neither the forge's public root nor its own address/);
-  const root = "https://git.example.org/api/packages/novox/npm/";
-  const viaRoot = await npmRegistry("ftp://novox.internal", aRegistry(() =>
-    packument("ftp://novox.internal/api/packages/novox/npm/x.tgz")).get, root);
+  const root = "https://git.example.org/api/packages/mesh-org/npm/";
+  const viaRoot = await npmRegistry("ftp://node-c.internal", "mesh-org", aRegistry(() =>
+    packument("ftp://node-c.internal/api/packages/mesh-org/npm/x.tgz")).get, root);
   assert.match(viaRoot.problem ?? "", /neither/);
 });
 
@@ -401,7 +401,7 @@ test("every file takes its text from a template in files/", () => {
 });
 
 // Defends novox/hq issue 693: a run whose only test skipped as NOT REACHED read "0 passed, 0 failed", exit 0,
-// and lab_status said passed. The log's tail, as run-2026-10-14T00-21-44-014Z on shanks wrote it.
+// and lab_status said passed. The log's tail, as run-2026-10-14T00-21-44-014Z on node-d wrote it.
 const oldLog = [
   "STOPPED at step 16 of 24, base:          \t\t\t\tMake sure you have all the referenced content and try again.",
   "\ufe63 genesis adopts its bus as the nats module in place: one bus, its streams kept, the node connected (588152.016874ms) # ADR 0333 §5 NOT REACHED: the first run stopped at step 16 of 24, base, before the broker step:",

modules/lab/tools/index.ts

@@ -8,7 +8,7 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
-  checkDir, cleanCredentials, clearChecks, credentialArgs, forgeCredential, installPlan, listRuns, npmRegistry, NPM_REPOSITORIES, publicRootOf, readStatus, REPOSITORIES, running, start,
+  checkDir, repositoryURL, cleanCredentials, clearChecks, credentialArgs, forgeCredential, installPlan, listRuns, npmRegistry, NPM_REPOSITORIES, publicRootOf, readStatus, REPOSITORIES, running, start,
   stop, tail, writeCredential, baseBuildLog, buildingBase, listBaseBuilds, startBaseBuild, credentialPath, launchRun,
   launchRebuild, BASE_MAX_AGE_DAYS, describeBase, readBaseImage, baseProblem,
 } from "./runs.js";
@@ -19,13 +19,17 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
   // ADR 0192): read from the env-file the mesh fills, at each call, so a changed setting is used
   // without restarting the runtime. MESH_LAB_FORGE itself still wins, for a hand-run instance.
   const forgeOf = (): string => (env.MESH_LAB_FORGE ?? wordIn(env.MESH_LAB_ENV_FILE, "MESH_LAB_FORGE")).replace(/\/+$/, "");
+  // The owner on the forge the mesh's repositories and packages are under, the operator's too (novox/hq ADR 0507
+  // §9), read the same way.
+  const ownerOf = (): string => (env.MESH_LAB_FORGE_OWNER ?? wordIn(env.MESH_LAB_ENV_FILE, "MESH_LAB_FORGE_OWNER")).trim();
+  const noOwner = "the lab's forge owner is not set: config for lab, {\"forge-owner\": \"<owner>\"}";
   // The forge credential the mesh binds and seals to the lab (novox/hq issue 624), read at each call.
   // The registry's public root the forge serves in the lab's binding (novox/hq ADR 0346), read at each call.
   const bindingOf = (): string | undefined =>
     env.MESH_LAB_FORGE_BINDING ?? (wordIn(env.MESH_LAB_ENV_FILE, "MESH_LAB_FORGE_BINDING") || undefined);
-  const registryOf = async (forge: string) => {
-    const root = publicRootOf(bindingOf());
-    const registry = await npmRegistry(forge, fetch, root.root);
+  const registryOf = async (forge: string, owner: string) => {
+    const root = publicRootOf(bindingOf(), owner);
+    const registry = await npmRegistry(forge, owner, fetch, root.root);
     return registry.problem && root.problem ? { ...registry, problem: `${registry.problem}; ${root.problem}` } : registry;
   };
   const credentialOf = (forge: string): string | undefined => forgeCredential(forge,
@@ -39,6 +43,8 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
       run: async () => {
         const forge = forgeOf();
         if (!forge) return { ok: false, output: "the lab's forge is not set: settings for lab, {\"forge\": \"<url>\"}" };
+        const owner = ownerOf();
+        if (!owner) return { ok: false, output: noOwner };
         // What earlier checks left is cleared, and what could not be is said; this check works in a fresh
         // directory of its own either way, and removes it when it is done.
         const leftovers = clearChecks(work);
@@ -46,13 +52,13 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
         let check: ReturnType<typeof spawnSync>;
         let problems: string[];
         try {
-          const clone = spawnSync("git", ["clone", "--quiet", "--depth", "1", `${forge}/novox/mesh-lab.git`, dir], { encoding: "utf8" });
+          const clone = spawnSync("git", ["clone", "--quiet", "--depth", "1", repositoryURL(forge, owner, "mesh-lab"), dir], { encoding: "utf8" });
           if (clone.status !== 0) return { ok: false, output: [String(clone.stderr).trim(), ...leftovers].join("\n") };
           spawnSync("npm", ["ci", "--no-audit", "--no-fund", "--loglevel=error"], { cwd: dir, encoding: "utf8" });
           check = spawnSync("node", ["--experimental-strip-types", "src/cli.ts", "check"], { cwd: dir, encoding: "utf8" });
-          problems = setupProblems(forge, `${dir}/setup`, credentialOf(forge));
+          problems = setupProblems(forge, owner, `${dir}/setup`, credentialOf(forge));
           // And the address a run names the package registry by (npmRegistry): said when the registry does not say it.
-          const registry = await registryOf(forge);
+          const registry = await registryOf(forge, owner);
           if (registry.problem) problems.push(registry.problem);
         } finally {
           rmSync(dir, { recursive: true, force: true });
@@ -91,6 +97,8 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
       run: async (args) => {
         const forge = forgeOf();
         if (!forge) return { started: false, reason: "the lab's forge is not set: settings for lab, {\"forge\": \"<url>\"}" };
+        const owner = ownerOf();
+        if (!owner) return { started: false, reason: noOwner };
         const tests = String(args.tests ?? "").split(",").map((s) => s.trim()).filter(Boolean);
         if (tests.length === 0) return { started: false, reason: "name at least one bed test file" };
         let refs: Record<string, string> = {};
@@ -105,8 +113,8 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
         if (stranger.length > 0) return { started: false, reason: `the lab does not build ${stranger.join(", ")}` };
         // **One job at a time, not on a base image past its bound, nor while it is rebuilt** (novox/hq issue 698,
         // review 256): the registry asked first, then the check and the start with nothing awaited between.
-        const launched = await launchRun(work, { registry: () => registryOf(forge), base: () => readBaseImage() },
-          (registry) => start(work, forge, tests, refs, credentialOf(forge), registry));
+        const launched = await launchRun(work, { registry: () => registryOf(forge, owner), base: () => readBaseImage() },
+          (registry) => start(work, forge, owner, tests, refs, credentialOf(forge), registry));
         if (!launched.started) return launched;
         return { started: true, run: launched.job, base: describeBase(launched.base), registry: launched.registry,
           ...(launched.problem ? { problem: launched.problem } : {}) };
@@ -134,10 +142,12 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
         if (args.rebuild !== true) return reading;
         const forge = forgeOf();
         if (!forge) return { ...reading, started: false, reason: "the lab's forge is not set: settings for lab, {\"forge\": \"<url>\"}" };
+        const owner = ownerOf();
+        if (!owner) return { ...reading, started: false, reason: noOwner };
         // Not under a run, nor beside another rebuild: the registry asked first, then the check and the start with
         // nothing awaited between (review 256).
-        const launched = await launchRebuild(work, { registry: () => registryOf(forge), base: () => before },
-          (registry) => startBaseBuild(work, forge, credentialOf(forge), registry));
+        const launched = await launchRebuild(work, { registry: () => registryOf(forge, owner), base: () => before },
+          (registry) => startBaseBuild(work, forge, owner, credentialOf(forge), registry));
         if (launched.started === false) return { ...reading, started: false, reason: launched.reason };
         return { ...reading, started: true, build: launched.job };
       },
@@ -174,7 +184,7 @@ export function getLabTools(env: NodeJS.ProcessEnv): ToolDefinition[] {
  * answer for, and a checkout it installs with nothing installable (installPlan). Empty when a run's setup
  * would go through.
  */
-export function setupProblems(forge: string, dir: string, credential?: string): string[] {
+export function setupProblems(forge: string, owner: string, dir: string, credential?: string): string[] {
   const problems: string[] = [];
   spawnSync("rm", ["-rf", dir]);
   // The credential a run would offer, in a file of its own outside the check's clones, removed after.
@@ -186,7 +196,7 @@ export function setupProblems(forge: string, dir: string, credential?: string):
     });
   try {
     for (const repo of REPOSITORIES) {
-      const url = `${forge}/novox/${repo}.git`;
+      const url = repositoryURL(forge, owner, repo);
       const remote = git(["ls-remote", "--heads", url, "main"]);
       if (remote.status !== 0 || !remote.stdout.includes("refs/heads/main")) {
         const said = remote.stderr.trim().split("\n")[0] ?? "";

modules/lab/tools/runs.ts

@@ -60,8 +60,11 @@ export function installStep(root: string, build: boolean): string {
 fi`;
 }
 
-/** Where the forge serves the mesh's npm packages, under its own address (gitea's npm registry for the novox org). */
-export const NPM_PATH = "/api/packages/novox/npm/";
+/**
+ * Where the forge serves the mesh's npm packages, under its own address: gitea's npm registry for the owner the
+ * mesh's repositories are under, the operator's config value (novox/hq ADR 0507 §9).
+ */
+export const npmPath = (owner: string): string => `/api/packages/${encodeURIComponent(owner)}/npm/`;
 
 /**
  * The registry's public root, as the forge serves it in the lab's npm-package-registry binding
@@ -70,7 +73,8 @@ export const NPM_PATH = "/api/packages/novox/npm/";
  * nothing else. Undefined, with why, when the binding has none or it is not that shape — a forge on a
  * machine with no public domain serves none (ADR 0346 §3).
  */
-export function publicRootOf(bindingFile: string | undefined): { root?: string; problem?: string } {
+export function publicRootOf(bindingFile: string | undefined, owner: string): { root?: string; problem?: string } {
+  const NPM_PATH = npmPath(owner);
   if (!bindingFile) return { problem: "the lab has no npm-package-registry binding" };
   let said: unknown;
   try {
@@ -112,8 +116,9 @@ export function publicRootOf(bindingFile: string | undefined): { root?: string;
  * reaches the run's npm configuration but a scheme, a host and a port. Anything else falls back to the
  * forge's own address and says why, so a run still starts and lab_check names it.
  */
-export async function npmRegistry(forge: string, get: typeof fetch = fetch, publicRoot?: string):
+export async function npmRegistry(forge: string, owner: string, get: typeof fetch = fetch, publicRoot?: string):
   Promise<{ registry: string; problem?: string }> {
+  const NPM_PATH = npmPath(owner);
   const asked = `${forge.replace(/\/+$/, "")}${NPM_PATH}`;
   const url = `${asked}@novox%2fmesh-sdk`;
   const fallback = (why: string) => ({
@@ -453,6 +458,10 @@ export function running(work: string): RunStatus | undefined {
   return listRuns(work).find((s) => !["passed", "failed", "stopped", "lost"].includes(s.state));
 }
 
+/** A repository's clone address on the forge: under the owner the mesh's repositories are under (ADR 0507 §9). */
+export const repositoryURL = (forge: string, owner: string, repo: string): string =>
+  `${forge}/${encodeURIComponent(owner)}/${repo}.git`;
+
 const shellQuote = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
 
 /**
@@ -461,8 +470,8 @@ const shellQuote = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
  * The environment is the one the lab's README describes for a run against sibling checkouts, pointed
  * at this run's own tree, so what is built and claimed is exactly what was checked out.
  */
-export function script(work: string, id: string, forge: string, tests: string[], refs: Record<string, string>,
-  credential?: string, registry = `${forge}${NPM_PATH}`): string {
+export function script(work: string, id: string, forge: string, owner: string, tests: string[], refs: Record<string, string>,
+  credential?: string, registry = `${forge}${npmPath(owner)}`): string {
   const dir = runDir(work, id);
   const setState = (state: string) =>
     `node -e ${shellQuote(
@@ -471,7 +480,7 @@ export function script(work: string, id: string, forge: string, tests: string[],
   const clones = REPOSITORIES.map((repo) => {
     const ref = refs[repo] ?? "main";
     return [
-      `git ${credentialArgs(credential)}clone --quiet --depth 50 --branch ${shellQuote(ref)} ${shellQuote(`${forge}/novox/${repo}.git`)} ${shellQuote(join(dir, repo))}`,
+      `git ${credentialArgs(credential)}clone --quiet --depth 50 --branch ${shellQuote(ref)} ${shellQuote(repositoryURL(forge, owner, repo))} ${shellQuote(join(dir, repo))}`,
       `echo "${repo} $(git -C ${shellQuote(join(dir, repo))} rev-parse HEAD)" >> ${shellQuote(join(dir, "commits.txt"))}`,
     ].join("\n");
   }).join("\n");
@@ -515,7 +524,7 @@ node --experimental-strip-types src/cli.ts suite ${tests.map(shellQuote).join("
 }
 
 /** start begins a run and returns at once with its status. */
-export function start(work: string, forge: string, tests: string[], refs: Record<string, string>,
+export function start(work: string, forge: string, owner: string, tests: string[], refs: Record<string, string>,
   credential?: string, registry?: string): RunStatus {
   const id = `run-${new Date().toISOString().replace(/[:.]/g, "-")}`;
   const dir = runDir(work, id);
@@ -525,7 +534,7 @@ export function start(work: string, forge: string, tests: string[], refs: Record
   // What a crashed or rebooted run left behind goes before this run writes its own.
   cleanCredentials(work);
   const credentials = writeCredential(credentialPath(work, id), credential);
-  writeFileSync(join(dir, "run.sh"), script(work, id, forge, tests, refs, credentials, registry), { mode: 0o700 });
+  writeFileSync(join(dir, "run.sh"), script(work, id, forge, owner, tests, refs, credentials, registry), { mode: 0o700 });
 
   // The wrapper records how the run ended, then removes the checkouts and keeps the log and status: a
   // run's tree is its own, and the next run starts from fresh ones (novox/hq ADR 0172).
@@ -715,13 +724,13 @@ export function baseBuildLog(work: string, id: string, lines = 40): string {
  * baseScript is what one rebuild runs: mesh-lab's main from the forge, installed the way a run installs it,
  * then its `base build`, which replaces the image and reads back that it works before publishing it.
  */
-export function baseScript(dir: string, forge: string, credential?: string, registry = `${forge}${NPM_PATH}`): string {
+export function baseScript(dir: string, forge: string, owner: string, credential?: string, registry = `${forge}${npmPath(owner)}`): string {
   const lab = join(dir, "mesh-lab");
   return `set -euo pipefail
 export GIT_TERMINAL_PROMPT=0
 ${credentialGuard(credential)}
 cd ${shellQuote(dir)}
-git ${credentialArgs(credential)}clone --quiet --depth 1 ${shellQuote(`${forge}/novox/mesh-lab.git`)} ${shellQuote(lab)}
+git ${credentialArgs(credential)}clone --quiet --depth 1 ${shellQuote(repositoryURL(forge, owner, "mesh-lab"))} ${shellQuote(lab)}
 ${credential ? `rm -f ${shellQuote(credential)}` : ""}
 echo "mesh-lab $(git -C ${shellQuote(lab)} rev-parse HEAD)"
 printf '%s\\n' ${shellQuote(`@novox:registry=${registry}`)} > ${shellQuote(join(dir, ".npmrc"))}
@@ -733,7 +742,7 @@ node --experimental-strip-types src/cli.ts base build
 }
 
 /** startBaseBuild rebuilds the base image in the background and answers at once with the build. */
-export function startBaseBuild(work: string, forge: string, credential?: string, registry?: string): BaseBuild {
+export function startBaseBuild(work: string, forge: string, owner: string, credential?: string, registry?: string): BaseBuild {
   const id = `base-${new Date().toISOString().replace(/[:.]/g, "-")}`;
   const dir = join(work, id);
   mkdirSync(dir, { recursive: true });
@@ -742,7 +751,7 @@ export function startBaseBuild(work: string, forge: string, credential?: string,
   // What a crashed or rebooted run or rebuild left behind goes before this one writes its own.
   cleanCredentials(work);
   const credentials = writeCredential(credentialPath(work, id), credential);
-  writeFileSync(join(dir, "build.sh"), baseScript(dir, forge, credentials, registry), { mode: 0o700 });
+  writeFileSync(join(dir, "build.sh"), baseScript(dir, forge, owner, credentials, registry), { mode: 0o700 });
   const wrapper = `bash ${shellQuote(join(dir, "build.sh"))} > ${shellQuote(join(dir, "build.log"))} 2>&1; code=$?
 node -e ${shellQuote(
     `const f=${JSON.stringify(buildStatusPath(work, id))};const s=JSON.parse(require("fs").readFileSync(f,"utf8"));s.state=process.argv[1]==="0"?"built":"failed";s.exit=Number(process.argv[1]);s.ended=new Date().toISOString();require("fs").writeFileSync(f,JSON.stringify(s,null,2))`,

modules/lemurs/README.md

@@ -82,7 +82,7 @@ Steps 1, 2 and 3 are harmless in any order. Step 4 waits for `i3`.
 
 ## What changes when it is assigned
 
-| | g14 | shanks |
+| | node-b | node-d |
 |---|---|---|
 | package | nothing until step 1 (`lemurs-git` reads as installed) | the same |
 | `/etc/lemurs/config.toml` | the found file kept once, then the module's written | the same |

modules/mailu/cmd/automx/automx_test.go

@@ -14,13 +14,13 @@ import (
 	"testing"
 )
 
-// The environment mailu gives automx on novox when the fixtures were captured (files/mailu.env): the mail domain,
+// The environment mailu gives automx on node-c when the fixtures were captured (files/mailu.env): the mail domain,
 // the route name for both servers, the ports.
 var capturedEnvironment = map[string]string{
-	"AMX_MAIL_DOMAINS": "novox.be",
-	"AMX_IMAP_ADDRESS": "mail.novox.be",
+	"AMX_MAIL_DOMAINS": "example.org",
+	"AMX_IMAP_ADDRESS": "mail.example.org",
 	"AMX_IMAP_PORT":    "143",
-	"AMX_SMTP_ADDRESS": "mail.novox.be",
+	"AMX_SMTP_ADDRESS": "mail.example.org",
 	"AMX_SMTP_PORT":    "587",
 	"AUTOMX_PORT":      "4243",
 }
@@ -176,7 +176,7 @@ func TestTheOnlyCorrectedAnswerIsTheImapServersName(t *testing.T) {
 	}
 	for _, c := range corrected {
 		orig := readFile(t, strings.TrimSuffix(c, ".corrected.body")+".body")
-		want := strings.Replace(orig, "<hostname />", "<hostname>mail.novox.be</hostname>", 1)
+		want := strings.Replace(orig, "<hostname />", "<hostname>mail.example.org</hostname>", 1)
 		if strings.Contains(want, "<hostname />") || want == orig {
 			t.Fatalf("%s: the capture has no single empty hostname to correct", c)
 		}
@@ -198,12 +198,12 @@ func TestTheImapServerIsNamedFromTheImapAddress(t *testing.T) {
 		t.Fatal(err)
 	}
 	rec := httptest.NewRecorder()
-	newHandler(cfg).ServeHTTP(rec, httptest.NewRequest("GET", "/mail/config-v1.1.xml?emailaddress=a@novox.be", nil))
+	newHandler(cfg).ServeHTTP(rec, httptest.NewRequest("GET", "/mail/config-v1.1.xml?emailaddress=a@example.org", nil))
 	body := rec.Body.String()
 	if !strings.Contains(body, `<incomingServer type="imap"><hostname>imap.example.test</hostname><port>993</port>`) {
 		t.Errorf("incoming server not named from AMX_IMAP_ADDRESS and AMX_IMAP_PORT: %s", body)
 	}
-	if !strings.Contains(body, `<outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port>`) {
+	if !strings.Contains(body, `<outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port>`) {
 		t.Errorf("outgoing server changed: %s", body)
 	}
 }
@@ -213,13 +213,13 @@ func TestEveryDomainOfTheEnvironmentIsServed(t *testing.T) {
 	for k, v := range capturedEnvironment {
 		env[k] = v
 	}
-	env["AMX_MAIL_DOMAINS"] = "novox.be, example.test"
+	env["AMX_MAIL_DOMAINS"] = "example.org, example.test"
 	cfg, err := configFrom(getenvOf(env))
 	if err != nil {
 		t.Fatal(err)
 	}
 	h := newHandler(cfg)
-	for _, d := range []string{"novox.be", "example.test"} {
+	for _, d := range []string{"example.org", "example.test"} {
 		rec := httptest.NewRecorder()
 		h.ServeHTTP(rec, httptest.NewRequest("GET", "/mail/config-v1.1.xml?emailaddress=a@"+d, nil))
 		if rec.Code != 200 || !strings.Contains(rec.Body.String(), "<domain>"+d+"</domain>") {

modules/mailu/cmd/automx/testdata/captured/01-thunderbird-autoconfig-ok.body

@@ -1 +1 @@
-<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>novox.be</domain><displayName>novox.be</displayName><displayShortName>novox.be</displayShortName><incomingServer type="imap"><hostname /><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>
+<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>example.org</domain><displayName>example.org</displayName><displayShortName>example.org</displayShortName><incomingServer type="imap"><hostname /><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>

modules/mailu/cmd/automx/testdata/captured/01-thunderbird-autoconfig-ok.corrected.body

@@ -1 +1 @@
-<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>novox.be</domain><displayName>novox.be</displayName><displayShortName>novox.be</displayShortName><incomingServer type="imap"><hostname>mail.novox.be</hostname><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>
+<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>example.org</domain><displayName>example.org</displayName><displayShortName>example.org</displayShortName><incomingServer type="imap"><hostname>mail.example.org</hostname><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>

modules/mailu/cmd/automx/testdata/captured/01-thunderbird-autoconfig-ok.headers

@@ -1,3 +1,3 @@
-Content-Length: 612
+Content-Length: 624
 Content-Type: application/xml
 Server: Werkzeug/3.1.9 Python/3.9.5

modules/mailu/cmd/automx/testdata/captured/01-thunderbird-autoconfig-ok.request

@@ -1,3 +1,3 @@
-GET https://autoconfig.novox.be/mail/config-v1.1.xml?emailaddress=jochen@novox.be
+GET https://autoconfig.example.org/mail/config-v1.1.xml?emailaddress=jochen@example.org
 User-Agent: Thunderbird
 Accept: */*

modules/mailu/cmd/automx/testdata/captured/02-thunderbird-on-automx-name.body

@@ -1 +1 @@
-<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>novox.be</domain><displayName>novox.be</displayName><displayShortName>novox.be</displayShortName><incomingServer type="imap"><hostname /><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>
+<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>example.org</domain><displayName>example.org</displayName><displayShortName>example.org</displayShortName><incomingServer type="imap"><hostname /><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>

modules/mailu/cmd/automx/testdata/captured/02-thunderbird-on-automx-name.corrected.body

@@ -1 +1 @@
-<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>novox.be</domain><displayName>novox.be</displayName><displayShortName>novox.be</displayShortName><incomingServer type="imap"><hostname>mail.novox.be</hostname><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>
+<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>example.org</domain><displayName>example.org</displayName><displayShortName>example.org</displayShortName><incomingServer type="imap"><hostname>mail.example.org</hostname><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>

modules/mailu/cmd/automx/testdata/captured/02-thunderbird-on-automx-name.headers

@@ -1,3 +1,3 @@
-Content-Length: 612
+Content-Length: 624
 Content-Type: application/xml
 Server: Werkzeug/3.1.9 Python/3.9.5

modules/mailu/cmd/automx/testdata/captured/02-thunderbird-on-automx-name.request

@@ -1,2 +1,2 @@
-GET https://automx.novox.be/mail/config-v1.1.xml?emailaddress=jochen@novox.be
+GET https://automx.example.org/mail/config-v1.1.xml?emailaddress=jochen@example.org
 User-Agent: Thunderbird

modules/mailu/cmd/automx/testdata/captured/03-thunderbird-on-autodiscover-name.body

@@ -1 +1 @@
-<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>novox.be</domain><displayName>novox.be</displayName><displayShortName>novox.be</displayShortName><incomingServer type="imap"><hostname /><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>
+<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>example.org</domain><displayName>example.org</displayName><displayShortName>example.org</displayShortName><incomingServer type="imap"><hostname /><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>

modules/mailu/cmd/automx/testdata/captured/03-thunderbird-on-autodiscover-name.corrected.body

@@ -1 +1 @@
-<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>novox.be</domain><displayName>novox.be</displayName><displayShortName>novox.be</displayShortName><incomingServer type="imap"><hostname>mail.novox.be</hostname><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.novox.be</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>
+<clientConfig version="1.1"><emailProvider id="automx2-1"><identity /><domain>example.org</domain><displayName>example.org</displayName><displayShortName>example.org</displayShortName><incomingServer type="imap"><hostname>mail.example.org</hostname><port>143</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></incomingServer><outgoingServer type="smtp"><hostname>mail.example.org</hostname><port>587</port><socketType>STARTTLS</socketType><username>%EMAILADDRESS%</username><authentication>password-cleartext</authentication></outgoingServer></emailProvider></clientConfig>

modules/mailu/cmd/automx/testdata/captured/03-thunderbird-on-autodiscover-name.headers

@@ -1,3 +1,3 @@
-Content-Length: 612
+Content-Length: 624
 Content-Type: application/xml
 Server: Werkzeug/3.1.9 Python/3.9.5

modules/mailu/cmd/automx/testdata/captured/03-thunderbird-on-autodiscover-name.request

@@ -1,2 +1,2 @@
-GET https://autodiscover.novox.be/mail/config-v1.1.xml?emailaddress=jochen@novox.be
+GET https://autodiscover.example.org/mail/config-v1.1.xml?emailaddress=jochen@example.org
 User-Agent: Thunderbird

modules/mailu/cmd/automx/testdata/captured/04-thunderbird-unknown-domain.request

@@ -1,2 +1,2 @@
-GET https://autoconfig.novox.be/mail/config-v1.1.xml?emailaddress=nobody@unknown.example
+GET https://autoconfig.example.org/mail/config-v1.1.xml?emailaddress=nobody@unknown.example
 User-Agent: Thunderbird

modules/mailu/cmd/automx/testdata/captured/05-thunderbird-missing-emailaddress.request

@@ -1,2 +1,2 @@
-GET https://autoconfig.novox.be/mail/config-v1.1.xml
+GET https://autoconfig.example.org/mail/config-v1.1.xml
 User-Agent: Thunderbird

modules/mailu/cmd/automx/testdata/captured/06-autoconfig-root.request

@@ -1,2 +1,2 @@
-GET https://autoconfig.novox.be/
+GET https://autoconfig.example.org/
 User-Agent: Mozilla/5.0

modules/mailu/cmd/automx/testdata/captured/07-wellknown-autoconfig-path.request

@@ -1 +1 @@
-GET https://autoconfig.novox.be/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress=jochen@novox.be
+GET https://autoconfig.example.org/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress=jochen@example.org

modules/mailu/cmd/automx/testdata/captured/08-outlook-post-known-domain.request

@@ -1,4 +1,4 @@
-POST https://autodiscover.novox.be/autodiscover/autodiscover.xml
+POST https://autodiscover.example.org/autodiscover/autodiscover.xml
 User-Agent: Microsoft Office/16.0 (Windows NT 10.0; Microsoft Outlook 16.0.14326; Pro)
 Content-Type: text/xml
 Accept: */*
@@ -6,7 +6,7 @@ Accept: */*
 <?xml version="1.0" encoding="utf-8"?>
 <Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006">
   <Request>
-    <EMailAddress>jochen@novox.be</EMailAddress>
+    <EMailAddress>jochen@example.org</EMailAddress>
     <AcceptableResponseSchema>http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a</AcceptableResponseSchema>
   </Request>
 </Autodiscover>

modules/mailu/cmd/automx/testdata/captured/09-outlook-post-unknown-domain.request

@@ -1,4 +1,4 @@
-POST https://autodiscover.novox.be/autodiscover/autodiscover.xml
+POST https://autodiscover.example.org/autodiscover/autodiscover.xml
 User-Agent: Microsoft Office/16.0
 Content-Type: text/xml
 

modules/mailu/cmd/automx/testdata/captured/10-outlook-post-malformed-body.request

@@ -1,4 +1,4 @@
-POST https://autodiscover.novox.be/autodiscover/autodiscover.xml
+POST https://autodiscover.example.org/autodiscover/autodiscover.xml
 User-Agent: Microsoft Office/16.0
 Content-Type: text/xml
 

modules/mailu/cmd/automx/testdata/captured/11-outlook-post-missing-emailaddress.request

@@ -1,4 +1,4 @@
-POST https://autodiscover.novox.be/autodiscover/autodiscover.xml
+POST https://autodiscover.example.org/autodiscover/autodiscover.xml
 User-Agent: Microsoft Office/16.0
 Content-Type: text/xml
 

modules/mailu/cmd/automx/testdata/captured/12-outlook-get-not-allowed.request

@@ -1,2 +1,2 @@
-GET https://autodiscover.novox.be/autodiscover/autodiscover.xml
+GET https://autodiscover.example.org/autodiscover/autodiscover.xml
 User-Agent: Microsoft Office/16.0

modules/mailu/cmd/automx/testdata/captured/13-outlook-post-capitalised-path.request

@@ -1,6 +1,6 @@
-POST https://autodiscover.novox.be/Autodiscover/Autodiscover.xml
+POST https://autodiscover.example.org/Autodiscover/Autodiscover.xml
 User-Agent: Microsoft Office/16.0
 Content-Type: text/xml
 
 <?xml version="1.0" encoding="utf-8"?>
-<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006"><Request><EMailAddress>jochen@novox.be</EMailAddress><AcceptableResponseSchema>http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a</AcceptableResponseSchema></Request></Autodiscover>
+<Autodiscover xmlns="http://schemas.microsoft.com/exchange/autodiscover/outlook/requestschema/2006"><Request><EMailAddress>jochen@example.org</EMailAddress><AcceptableResponseSchema>http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a</AcceptableResponseSchema></Request></Autodiscover>

modules/mailu/cmd/automx/testdata/captured/14-mobileconfig-no-slash.body

@@ -2,4 +2,4 @@
 <html lang=en>
 <title>Redirecting...</title>
 <h1>Redirecting...</h1>
-<p>You should be redirected automatically to the target URL: <a href="https://automx.novox.be/mobileconfig/?emailaddress=jochen@novox.be">https://automx.novox.be/mobileconfig/?emailaddress=jochen@novox.be</a>. If not, click the link.
+<p>You should be redirected automatically to the target URL: <a href="https://automx.example.org/mobileconfig/?emailaddress=jochen@example.org">https://automx.example.org/mobileconfig/?emailaddress=jochen@example.org</a>. If not, click the link.

modules/mailu/cmd/automx/testdata/captured/14-mobileconfig-no-slash.headers

@@ -1,4 +1,4 @@
-Content-Length: 319
+Content-Length: 331
 Content-Type: text/html; charset=utf-8
-Location: https://automx.novox.be/mobileconfig/?emailaddress=jochen@novox.be
+Location: https://automx.example.org/mobileconfig/?emailaddress=jochen@example.org
 Server: Werkzeug/3.1.9 Python/3.9.5

modules/mailu/cmd/automx/testdata/captured/14-mobileconfig-no-slash.request

@@ -1,3 +1,3 @@
-GET https://automx.novox.be/mobileconfig?emailaddress=jochen@novox.be
+GET https://automx.example.org/mobileconfig?emailaddress=jochen@example.org
 User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari
 Accept: */*

modules/mailu/cmd/automx/testdata/captured/15-mobileconfig-known-domain.request

@@ -1,3 +1,3 @@
-GET https://automx.novox.be/mobileconfig/?emailaddress=jochen@novox.be
+GET https://automx.example.org/mobileconfig/?emailaddress=jochen@example.org
 User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari
 Accept: */*

modules/mailu/cmd/automx/testdata/captured/16-mobileconfig-unknown-domain.request

@@ -1,2 +1,2 @@
-GET https://automx.novox.be/mobileconfig/?emailaddress=nobody@unknown.example
+GET https://automx.example.org/mobileconfig/?emailaddress=nobody@unknown.example
 User-Agent: Mozilla/5.0 (iPhone)

modules/mailu/cmd/automx/testdata/captured/17-mobileconfig-missing-emailaddress.request

@@ -1,2 +1,2 @@
-GET https://automx.novox.be/mobileconfig/
+GET https://automx.example.org/mobileconfig/
 User-Agent: Mozilla/5.0 (iPhone)

modules/mailu/cmd/automx/testdata/captured/CAPTURED

@@ -1,10 +1,10 @@
-What mailu's autoconfiguration module (automx2 2021.6, container mailu-automx on novox, Werkzeug/3.1.9 Python/3.9.5)
+What mailu's autoconfiguration module (automx2 2021.6, container mailu-automx on node-c, Werkzeug/3.1.9 Python/3.9.5)
 answers to the requests mail clients make (R4d step AMX-1, issue 1630, ADR 0480).
 
 Captured 2026-10-21 between 13:58:25 and 13:58:52 (CEST; the Date headers said 11:58 GMT) with the mesh tool
-shanks/netcheck.netcheck_request, called from shanks, through the names clients use (autoconfig.novox.be,
-autodiscover.novox.be, automx.novox.be: HTTPS, the mesh's route), no ssh. A redirect is reported, never followed.
-Mail domain served: novox.be. Mailbox used: jochen@novox.be; unknown domain: nobody@unknown.example.
+node-d/netcheck.netcheck_request, called from node-d, through the names clients use (autoconfig.example.org,
+autodiscover.example.org, automx.example.org: HTTPS, the mesh's route), no ssh. A redirect is reported, never followed.
+Mail domain served: example.org. Mailbox used: jochen@example.org; unknown domain: nobody@unknown.example.
 
 Each capture is four files with the same stem:
   <stem>.request   method and URL, then the request headers sent, then (after a blank line) the body sent
@@ -24,7 +24,7 @@ A fixture is not the bytes on the wire in four ways (issue 1701):
 What the answers show (read, not guessed):
   - GET /mail/config-v1.1.xml?emailaddress=... answers 200 application/xml on all three names; same body on each.
   - The incoming (IMAP) server has an EMPTY hostname (<hostname />), port 143, STARTTLS. The outgoing server is
-    mail.novox.be:587 STARTTLS. Cause (from reading the module, not from the database): automx/files/add-domains:35
+    mail.example.org:587 STARTTLS. Cause (from reading the module, not from the database): automx/files/add-domains:35
     reads AMX_IMAP_SERVER, files/mailu.env:58 sets AMX_IMAP_ADDRESS, so the IMAP name was never written.
     A client given this answer cannot find its IMAP server.
   - POST /autodiscover/autodiscover.xml with a valid request for the served domain answers 500 (the Outlook

modules/mailu/cmd/automx/testdata/captured/DIFFERENCES

@@ -6,8 +6,8 @@ whole list of where the two differ.
    server because its setup script read AMX_IMAP_SERVER, which mailu's environment does not set (it sets
    AMX_IMAP_ADDRESS). The program names it from AMX_IMAP_ADDRESS (and the port from AMX_IMAP_PORT).
    Fixtures 01, 02 and 03 each have a <stem>.corrected.body: the capture with <hostname /> replaced by
-   <hostname>mail.novox.be</hostname> and nothing else (a test checks that). Their Content-Length is that file's
-   size, 634, not the captured 612.
+   <hostname>mail.example.org</hostname> and nothing else (a test checks that). Their Content-Length is that file's
+   size, 649, not the captured 624.
 
 2. The Server header. The capture has "Server: Werkzeug/3.1.9 Python/3.9.5". The program sends no Server header, and
    Date, which the captured .headers leave out, is sent as net/http sends it.

modules/memory-pressure/README.md

@@ -99,8 +99,8 @@ On the laptop:
 
 1. `systemctl --user disable --now mem-guard.service`, then delete
    `~/.config/systemd/user/mem-guard.service` and `~/scripts/mem-guard.sh`.
-2. `/etc/systemd/oomd.conf.d/g14-oomd.conf`: the same values as the module's drop-in.
-3. `/etc/sysctl.d/90-g14-zram.conf`: the same key as the module's file.
+2. `/etc/systemd/oomd.conf.d/node-b-oomd.conf`: the same values as the module's drop-in.
+3. `/etc/sysctl.d/90-node-b-zram.conf`: the same key as the module's file.
 
 The desktop had none of these.
 

modules/memory-pressure/cmd/memory-pressure/manifest_test.go

@@ -34,7 +34,8 @@ func TestTheManifestNamesExactlyTheToolsTheBundleServesAndNoMachine(t *testing.T
 	if strings.Join(m.Emits, ",") != "pressure.cleared,pressure.high" {
 		t.Fatalf("emits %v", m.Emits)
 	}
-	for _, banned := range []string{"g14", "jochen", "/home/", "shanks", "/run/user/1000"} {
+	// 1838/AC1: the catalogue-wide check covers a node's name now; this list keeps what it does not.
+	for _, banned := range []string{"jochen", "/home/", "/run/user/1000"} {
 		if strings.Contains(string(raw), banned) {
 			t.Errorf("the manifest says %q", banned)
 		}

modules/mesh-catalog/test/heard.test.ts

@@ -7,10 +7,10 @@ import { BUILD_EVENTS, placeable } from "../heard.js";
 // A walk's build as the build seat says it (mesh-controller's link.BuildResult), here mailu's of novox/hq issue 712.
 const walkBuild = {
   id: "build-1791997333800041716",
-  repository: "http://novox.internal:20000/novox/mesh-catalog.git",
+  repository: "http://node-c.internal:20000/node-c/mesh-catalog.git",
   path: "modules/mailu",
   ref: "main",
-  on: "shanks",
+  on: "node-d",
   trunk: "main",
   "on-trunk": true,
   branches: ["main"],

modules/mesh-config/cmd/mesh-config/config_test.go

@@ -159,11 +159,11 @@ func aMesh(t *testing.T) (*Config, *memStore) {
 		"managed":{"kind":"","default":{},"why":"","type":"object","description":"managed settings","trusted":true,"predefined":"agent-managed-settings"}}}`)
 	m.mirror(t, DeclaredConfigRead, "old", `{"module":"old","settings":{"workers":{"kind":"preference","default":4,"why":"two per core"}}}`)
 	m.mirror(t, PredefinedRead, PredefinedMirrorKey, theList)
-	for _, node := range []string{"g14", "novox"} {
+	for _, node := range []string{"node-b", "node-c"} {
 		m.assign(t, node, "dunst")
 	}
-	m.assign(t, "g14", "claude-code")
-	m.assign(t, "g14", "old")
+	m.assign(t, "node-b", "claude-code")
+	m.assign(t, "node-b", "old")
 	clock := time.Date(2026, 10, 14, 19, 0, 0, 0, time.UTC)
 	c := &Config{Store: m, Now: func() time.Time { clock = clock.Add(time.Second); return clock }, Logf: t.Logf}
 	if _, err := c.Reconcile(); err != nil {
@@ -179,7 +179,7 @@ func set(t *testing.T, c *Config, call Call) *SetAnswer {
 		call.Action = "set"
 	}
 	if call.Caller == "" {
-		call.Caller = "g14.node-tools"
+		call.Caller = "node-b.node-tools"
 	}
 	if call.Why == "" {
 		call.Why = "the operator asked for it"
@@ -204,42 +204,42 @@ func expect(t *testing.T, m *memStore, node string, value, source string) {
 // cleared falls back to the one below.
 func TestEachOfTheFourSourcesResolvesInTurnAndEachClearedFallsBack(t *testing.T) {
 	c, m := aMesh(t)
-	expect(t, m, "g14", "10", SourceDefault)
-	expect(t, m, "novox", "10", SourceDefault)
+	expect(t, m, "node-b", "10", SourceDefault)
+	expect(t, m, "node-c", "10", SourceDefault)
 
 	a := set(t, c, Call{Key: "font-size", Value: 12.0})
-	expect(t, m, "g14", "12", SourceMesh)
-	expect(t, m, "novox", "12", SourceMesh)
+	expect(t, m, "node-b", "12", SourceMesh)
+	expect(t, m, "node-c", "12", SourceMesh)
 	if len(a.Moved) != 2 || a.Level.Kind != LevelMesh {
 		t.Errorf("a mesh value moved %+v", a.Moved)
 	}
 
-	a = set(t, c, Call{Key: "font-size", Value: 14.0, Node: "g14"})
-	expect(t, m, "g14", "14", SourceNode)
-	expect(t, m, "novox", "12", SourceMesh)
-	if len(a.Moved) != 1 || a.Moved[0].Node != "g14" || string(a.Moved[0].From) != "12" || string(a.Moved[0].To) != "14" {
-		t.Errorf("g14's node value moved %+v", a.Moved)
+	a = set(t, c, Call{Key: "font-size", Value: 14.0, Node: "node-b"})
+	expect(t, m, "node-b", "14", SourceNode)
+	expect(t, m, "node-c", "12", SourceMesh)
+	if len(a.Moved) != 1 || a.Moved[0].Node != "node-b" || string(a.Moved[0].From) != "12" || string(a.Moved[0].To) != "14" {
+		t.Errorf("node-b's node value moved %+v", a.Moved)
 	}
 
-	a = set(t, c, Call{Key: "font-size", Value: 16.0, Node: "g14", Module: "dunst"})
-	expect(t, m, "g14", "16", SourceModule)
-	expect(t, m, "novox", "12", SourceMesh)
+	a = set(t, c, Call{Key: "font-size", Value: 16.0, Node: "node-b", Module: "dunst"})
+	expect(t, m, "node-b", "16", SourceModule)
+	expect(t, m, "node-c", "12", SourceMesh)
 	if len(a.Moved) != 1 || a.Moved[0].Source != SourceModule {
 		t.Errorf("dunst's own value moved %+v", a.Moved)
 	}
 
 	// A value set below the module's own moves nothing it overrides.
-	if a = set(t, c, Call{Key: "font-size", Value: 18.0, Node: "g14"}); len(a.Moved) != 0 {
+	if a = set(t, c, Call{Key: "font-size", Value: 18.0, Node: "node-b"}); len(a.Moved) != 0 {
 		t.Errorf("a node value under a module's own moved %+v", a.Moved)
 	}
 
-	set(t, c, Call{Action: "clear", Key: "font-size", Node: "g14", Module: "dunst"})
-	expect(t, m, "g14", "18", SourceNode)
-	set(t, c, Call{Action: "clear", Key: "font-size", Node: "g14"})
-	expect(t, m, "g14", "12", SourceMesh)
+	set(t, c, Call{Action: "clear", Key: "font-size", Node: "node-b", Module: "dunst"})
+	expect(t, m, "node-b", "18", SourceNode)
+	set(t, c, Call{Action: "clear", Key: "font-size", Node: "node-b"})
+	expect(t, m, "node-b", "12", SourceMesh)
 	set(t, c, Call{Action: "clear", Key: "font-size"})
-	expect(t, m, "g14", "10", SourceDefault)
-	expect(t, m, "novox", "10", SourceDefault)
+	expect(t, m, "node-b", "10", SourceDefault)
+	expect(t, m, "node-c", "10", SourceDefault)
 }
 
 // **A value naming no predefined key ignores mesh and node config** (ADR 0348 §2): it resolves from its default and
@@ -247,20 +247,20 @@ func TestEachOfTheFourSourcesResolvesInTurnAndEachClearedFallsBack(t *testing.T)
 func TestAValueNamingNoPredefinedKeyResolvesFromItsDefaultAndItsOwnValueOnly(t *testing.T) {
 	c, m := aMesh(t)
 	set(t, c, Call{Key: "font-size", Value: 12.0})
-	set(t, c, Call{Key: "font-size", Value: 14.0, Node: "g14"})
-	if r := m.resolved(t, "g14", "dunst", "width"); string(r.Value) != "300" || r.Source != SourceDefault {
+	set(t, c, Call{Key: "font-size", Value: 14.0, Node: "node-b"})
+	if r := m.resolved(t, "node-b", "dunst", "width"); string(r.Value) != "300" || r.Source != SourceDefault {
 		t.Errorf("width is %s from %s, want its default", r.Value, r.Source)
 	}
-	set(t, c, Call{Key: "width", Value: 400.0, Node: "g14", Module: "dunst"})
-	if r := m.resolved(t, "g14", "dunst", "width"); string(r.Value) != "400" || r.Source != SourceModule {
+	set(t, c, Call{Key: "width", Value: 400.0, Node: "node-b", Module: "dunst"})
+	if r := m.resolved(t, "node-b", "dunst", "width"); string(r.Value) != "400" || r.Source != SourceModule {
 		t.Errorf("width is %s from %s, want dunst's own value", r.Value, r.Source)
 	}
 	// A module not yet moved, in the settings form: its default and its own value.
-	if r := m.resolved(t, "g14", "old", "workers"); string(r.Value) != "4" || r.Source != SourceDefault {
+	if r := m.resolved(t, "node-b", "old", "workers"); string(r.Value) != "4" || r.Source != SourceDefault {
 		t.Errorf("old's workers is %s from %s", r.Value, r.Source)
 	}
-	set(t, c, Call{Key: "workers", Value: 8.0, Node: "g14", Module: "old"})
-	if r := m.resolved(t, "g14", "old", "workers"); string(r.Value) != "8" || r.Source != SourceModule {
+	set(t, c, Call{Key: "workers", Value: 8.0, Node: "node-b", Module: "old"})
+	if r := m.resolved(t, "node-b", "old", "workers"); string(r.Value) != "8" || r.Source != SourceModule {
 		t.Errorf("old's workers is %s from %s", r.Value, r.Source)
 	}
 }
@@ -268,15 +268,15 @@ func TestAValueNamingNoPredefinedKeyResolvesFromItsDefaultAndItsOwnValueOnly(t *
 // **A required value nothing sets is answered unset** (ADR 0348 §4), and once set, it is the value.
 func TestARequiredValueNothingSetsIsAnsweredUnset(t *testing.T) {
 	c, m := aMesh(t)
-	r := m.resolved(t, "g14", "dunst", "origin")
+	r := m.resolved(t, "node-b", "dunst", "origin")
 	if r.Source != SourceUnset || !r.Required || len(r.Value) != 0 {
 		t.Errorf("an unset required value resolves as %+v", r)
 	}
-	set(t, c, Call{Key: "origin", Value: "home", Node: "g14", Module: "dunst"})
-	if r = m.resolved(t, "g14", "dunst", "origin"); r.Source != SourceModule || string(r.Value) != `"home"` {
+	set(t, c, Call{Key: "origin", Value: "home", Node: "node-b", Module: "dunst"})
+	if r = m.resolved(t, "node-b", "dunst", "origin"); r.Source != SourceModule || string(r.Value) != `"home"` {
 		t.Errorf("a set required value resolves as %+v", r)
 	}
-	if r = m.resolved(t, "novox", "dunst", "origin"); r.Source != SourceUnset {
+	if r = m.resolved(t, "node-c", "dunst", "origin"); r.Source != SourceUnset {
 		t.Errorf("another node's required value resolves as %+v", r)
 	}
 }
@@ -291,30 +291,30 @@ func TestTheVerbRefusesWhatADeclarationDoesNotAllow(t *testing.T) {
 		call Call
 		want string
 	}{
-		{"a key the module does not declare", Call{Key: "colour", Value: "red", Node: "g14", Module: "dunst"},
+		{"a key the module does not declare", Call{Key: "colour", Value: "red", Node: "node-b", Module: "dunst"},
 			"it declares: font-size, origin, position, width"},
 		{"a key not on the predefined list, at the mesh", Call{Key: "width", Value: 400.0},
 			"the predefined keys are: agent-managed-settings, font-size"},
-		{"a key not on the predefined list, at a node", Call{Key: "width", Value: 400.0, Node: "g14"}, "is not one"},
+		{"a key not on the predefined list, at a node", Call{Key: "width", Value: 400.0, Node: "node-b"}, "is not one"},
 		{"a module value without a node", Call{Key: "width", Value: 400.0, Module: "dunst"},
 			"no module value for the whole mesh"},
-		{"a module on a node it is not assigned to", Call{Key: "width", Value: 400.0, Node: "ace", Module: "dunst"},
-			"it is assigned to: g14, novox"},
-		{"a module not registered", Call{Key: "width", Value: 400.0, Node: "g14", Module: "nobody"}, "not a registered module"},
+		{"a module on a node it is not assigned to", Call{Key: "width", Value: 400.0, Node: "node-a", Module: "dunst"},
+			"it is assigned to: node-b, node-c"},
+		{"a module not registered", Call{Key: "width", Value: 400.0, Node: "node-b", Module: "nobody"}, "not a registered module"},
 		{"a value of another type", Call{Key: "font-size", Value: "12"}, `"12" is not a number`},
-		{"a value below its minimum", Call{Key: "font-size", Value: 2.0, Node: "g14"}, "below the minimum 6"},
-		{"a value above its maximum", Call{Key: "font-size", Value: 99.0, Node: "g14", Module: "dunst"}, "above the maximum 72"},
-		{"a value not in its enum", Call{Key: "position", Value: "middle", Node: "g14", Module: "dunst"}, "is not one of"},
-		{"a value not matching its pattern", Call{Key: "origin", Value: "Home 1", Node: "g14", Module: "dunst"},
+		{"a value below its minimum", Call{Key: "font-size", Value: 2.0, Node: "node-b"}, "below the minimum 6"},
+		{"a value above its maximum", Call{Key: "font-size", Value: 99.0, Node: "node-b", Module: "dunst"}, "above the maximum 72"},
+		{"a value not in its enum", Call{Key: "position", Value: "middle", Node: "node-b", Module: "dunst"}, "is not one of"},
+		{"a value not matching its pattern", Call{Key: "origin", Value: "Home 1", Node: "node-b", Module: "dunst"},
 			"does not match the pattern"},
 		{"a trusted value at the mesh, not from the terminal", Call{Key: "agent-managed-settings",
 			Value: map[string]any{"a": 1.0}}, "set only at the controller's terminal"},
 		{"a trusted module value, not from the terminal", Call{Key: "managed", Value: map[string]any{},
-			Node: "g14", Module: "claude-code"}, "set only at the controller's terminal"},
+			Node: "node-b", Module: "claude-code"}, "set only at the controller's terminal"},
 		{"a change without why", Call{Key: "font-size", Value: 12.0, Why: " "}, "say why"},
 		{"an unproven caller", Call{Key: "font-size", Value: 12.0, Caller: Unproven}, "no proven caller"},
 		{"by from anyone but the controller", Call{Key: "font-size", Value: 12.0, By: "jochen"}, "only the controller says"},
-		{"a clear of nothing set", Call{Action: "clear", Key: "font-size", Node: "g14"}, "nothing is set"},
+		{"a clear of nothing set", Call{Action: "clear", Key: "font-size", Node: "node-b"}, "nothing is set"},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			call := tc.call
@@ -322,7 +322,7 @@ func TestTheVerbRefusesWhatADeclarationDoesNotAllow(t *testing.T) {
 				call.Action = "set"
 			}
 			if call.Caller == "" {
-				call.Caller = "g14.node-tools"
+				call.Caller = "node-b.node-tools"
 			}
 			if call.Why == "" {
 				call.Why = "a test"
@@ -349,7 +349,7 @@ func TestATrustedValueFromTheTerminalIsSetWithWhoGaveIt(t *testing.T) {
 	if string(a.Value) != `{"a":1,"b":2}` {
 		t.Errorf("the value is written as %s", a.Value)
 	}
-	r := m.resolved(t, "g14", "claude-code", "managed")
+	r := m.resolved(t, "node-b", "claude-code", "managed")
 	if r.Source != SourceMesh || !r.Trusted || string(r.Value) != `{"a":1,"b":2}` {
 		t.Errorf("claude-code's managed settings resolve as %+v", r)
 	}
@@ -366,8 +366,8 @@ func TestATrustedValueFromTheTerminalIsSetWithWhoGaveIt(t *testing.T) {
 func TestEveryChangeIsKeptWithWhoAndWhyAndRaisesConfigChanged(t *testing.T) {
 	c, m := aMesh(t)
 	m.events = nil
-	set(t, c, Call{Key: "font-size", Value: 12.0, Caller: "novox.node-tools", Why: "bigger on every desk"})
-	set(t, c, Call{Action: "clear", Key: "font-size", Caller: "g14.node-tools", Why: "back to the default"})
+	set(t, c, Call{Key: "font-size", Value: 12.0, Caller: "node-c.node-tools", Why: "bigger on every desk"})
+	set(t, c, Call{Action: "clear", Key: "font-size", Caller: "node-b.node-tools", Why: "back to the default"})
 
 	history, err := c.History(Call{})
 	if err != nil {
@@ -379,22 +379,22 @@ func TestEveryChangeIsKeptWithWhoAndWhyAndRaisesConfigChanged(t *testing.T) {
 			changes = append(changes, h)
 		}
 	}
-	if len(changes) != 2 || changes[0].By != "novox.node-tools" || changes[0].Why != "bigger on every desk" ||
-		changes[1].Action != "clear" || changes[1].By != "g14.node-tools" || string(changes[1].Was) != "12" {
+	if len(changes) != 2 || changes[0].By != "node-c.node-tools" || changes[0].Why != "bigger on every desk" ||
+		changes[1].Action != "clear" || changes[1].By != "node-b.node-tools" || string(changes[1].Was) != "12" {
 		t.Fatalf("the history holds %+v", changes)
 	}
-	if len(m.handActs) != 2 || !strings.Contains(m.handActs[0], "config set font-size at mesh config to 12, by novox.node-tools | bigger on every desk") {
+	if len(m.handActs) != 2 || !strings.Contains(m.handActs[0], "config set font-size at mesh config to 12, by node-c.node-tools | bigger on every desk") {
 		t.Errorf("the hand-act log holds %q", m.handActs)
 	}
 	if len(m.events) != 2 || len(m.events[0].Moved) != 2 || m.events[0].Key != "font-size" || m.events[1].Action != "clear" {
 		t.Errorf("config-changed was raised as %+v", m.events)
 	}
-	// Narrowed: g14's dunst sees both, through what they moved; a node that holds no dunst sees neither.
-	if h, _ := c.History(Call{Module: "dunst", Node: "g14"}); len(h) < 2 {
-		t.Errorf("dunst on g14's history holds %d changes", len(h))
+	// Narrowed: node-b's dunst sees both, through what they moved; a node that holds no dunst sees neither.
+	if h, _ := c.History(Call{Module: "dunst", Node: "node-b"}); len(h) < 2 {
+		t.Errorf("dunst on node-b's history holds %d changes", len(h))
 	}
-	if h, _ := c.History(Call{Node: "ace"}); len(h) != 0 {
-		t.Errorf("ace's history holds %+v", h)
+	if h, _ := c.History(Call{Node: "node-a"}); len(h) != 0 {
+		t.Errorf("node-a's history holds %+v", h)
 	}
 }
 
@@ -406,7 +406,7 @@ func TestAChangeTheHandActLogRefusesIsSaid(t *testing.T) {
 	if len(a.Unsaid) != 1 || !strings.Contains(a.Unsaid[0], "hand-act log does not hold it") {
 		t.Errorf("the answer says %q", a.Unsaid)
 	}
-	expect(t, m, "g14", "12", SourceMesh)
+	expect(t, m, "node-b", "12", SourceMesh)
 }
 
 // **The newest list of predefined keys is published, and an older one heard later is not** (ADR 0348 §7).
@@ -447,7 +447,7 @@ func TestTheNewestListOfPredefinedKeysIsPublished(t *testing.T) {
 // listing says why until the value is cleared.
 func TestAListDroppingAKeyThatHoldsAValueIsWithheldUntilItIsCleared(t *testing.T) {
 	c, m := aMesh(t)
-	set(t, c, Call{Key: "font-size", Value: 12.0, Node: "novox"})
+	set(t, c, Call{Key: "font-size", Value: 12.0, Node: "node-c"})
 	m.mirror(t, PredefinedRead, PredefinedMirrorKey, `{"keys":{"agent-managed-settings":{"type":"object",
 		"description":"managed settings","trusted":true}},"commit":"cccccccccc","generation":9}`)
 	if _, err := c.Reconcile(); err != nil {
@@ -458,11 +458,11 @@ func TestAListDroppingAKeyThatHoldsAValueIsWithheldUntilItIsCleared(t *testing.T
 		t.Fatal(err)
 	}
 	if _, kept := listed.Predefined["font-size"]; !kept ||
-		!strings.Contains(listed.Withheld, "drops font-size (still set as node config on novox)") {
+		!strings.Contains(listed.Withheld, "drops font-size (still set as node config on node-c)") {
 		t.Fatalf("the list was published over a value it drops: withheld %q, published %v", listed.Withheld,
 			joinKeys(listed.Predefined))
 	}
-	set(t, c, Call{Action: "clear", Key: "font-size", Node: "novox"})
+	set(t, c, Call{Action: "clear", Key: "font-size", Node: "node-c"})
 	if _, err := c.Reconcile(); err != nil {
 		t.Fatal(err)
 	}
@@ -481,19 +481,19 @@ func TestAnAssignmentMovesTheResolvedValuesAndAQuietPassWritesNothing(t *testing
 		t.Fatalf("a pass over unchanged sources moved %+v (%v)", r.Moved, err)
 	}
 	m.events = nil
-	m.assign(t, "ace", "dunst")
+	m.assign(t, "node-a", "dunst")
 	if r, _ = c.Reconcile(); len(r.Moved) != 4 {
 		t.Errorf("an assignment moved %+v", r.Moved)
 	}
-	expect(t, m, "ace", "10", SourceDefault)
+	expect(t, m, "node-a", "10", SourceDefault)
 	if len(m.events) != 1 || m.events[0].Action != "resolve" {
 		t.Errorf("an assignment raised %+v", m.events)
 	}
-	_ = m.Delete(AssignmentsRead, "ace.dunst")
+	_ = m.Delete(AssignmentsRead, "node-a.dunst")
 	if r, _ = c.Reconcile(); len(r.Moved) != 4 || !r.Moved[0].Gone {
 		t.Errorf("an unassignment moved %+v", r.Moved)
 	}
-	if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "dunst", "font-size")); e != nil {
+	if e, _ := m.Get(ResolvedState, ResolvedKey("node-a", "dunst", "font-size")); e != nil {
 		t.Error("an unassigned module keeps its resolved values")
 	}
 }
@@ -523,17 +523,17 @@ func TestTheDeclaredConfigMirrorsTwoShapesReadTheSame(t *testing.T) {
 func TestAListingNarrowsByModuleAndNode(t *testing.T) {
 	c, _ := aMesh(t)
 	set(t, c, Call{Key: "font-size", Value: 12.0})
-	set(t, c, Call{Key: "font-size", Value: 14.0, Node: "novox"})
-	l, err := c.List(Call{Module: "dunst", Node: "g14"})
+	set(t, c, Call{Key: "font-size", Value: 14.0, Node: "node-c"})
+	l, err := c.List(Call{Module: "dunst", Node: "node-b"})
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(l.Resolved) != 4 || len(l.Set) != 1 || l.Set[0].Level.Kind != LevelMesh || l.Predefined != nil {
-		t.Errorf("dunst on g14 lists %d resolved and %+v", len(l.Resolved), l.Set)
+		t.Errorf("dunst on node-b lists %d resolved and %+v", len(l.Resolved), l.Set)
 	}
-	l, _ = c.List(Call{Node: "novox"})
+	l, _ = c.List(Call{Node: "node-c"})
 	if len(l.Resolved) != 4 || len(l.Set) != 2 {
-		t.Errorf("novox lists %d resolved and %+v", len(l.Resolved), l.Set)
+		t.Errorf("node-c lists %d resolved and %+v", len(l.Resolved), l.Set)
 	}
 }
 
@@ -556,20 +556,20 @@ func TestTheVerbsArgumentsAreReadStrictly(t *testing.T) {
 // resolves nothing and takes the module's resolved values away, as a removed key does.
 func TestAnEndedAssignmentIsNotAnAssignment(t *testing.T) {
 	c, m := aMesh(t)
-	m.assign(t, "ace", "dunst")
+	m.assign(t, "node-a", "dunst")
 	if r, err := c.Reconcile(); err != nil || len(r.Moved) != 4 {
 		t.Fatalf("the assignment moved %+v (%v)", r.Moved, err)
 	}
 	for _, ended := range []string{`"ended":"2026-10-18T01:00:00Z"`, `"state":"pending"`} {
-		m.mirror(t, AssignmentsRead, "ace.dunst", `{"node":"ace","module":"dunst","assigned":"2026-10-14T00:00:00Z",`+ended+`}`)
+		m.mirror(t, AssignmentsRead, "node-a.dunst", `{"node":"node-a","module":"dunst","assigned":"2026-10-14T00:00:00Z",`+ended+`}`)
 		r, err := c.Reconcile()
 		if err != nil || len(r.Moved) != 4 || !r.Moved[0].Gone {
 			t.Errorf("%s moved %+v (%v)", ended, r.Moved, err)
 		}
-		if e, _ := m.Get(ResolvedState, ResolvedKey("ace", "dunst", "font-size")); e != nil {
+		if e, _ := m.Get(ResolvedState, ResolvedKey("node-a", "dunst", "font-size")); e != nil {
 			t.Errorf("%s: the module keeps its resolved values", ended)
 		}
-		m.assign(t, "ace", "dunst")
+		m.assign(t, "node-a", "dunst")
 		if r, _ = c.Reconcile(); len(r.Moved) != 4 {
 			t.Fatalf("the assignment standing again moved %+v", r.Moved)
 		}
@@ -579,14 +579,14 @@ func TestAnEndedAssignmentIsNotAnAssignment(t *testing.T) {
 // Issue 1098: the fields the controller adds to an assignment change nothing, under the same key.
 func TestAnAssignmentCarriesBuildCommitAndRolloutWithoutChangingItsKey(t *testing.T) {
 	c, m := aMesh(t)
-	m.mirror(t, AssignmentsRead, "ace.dunst", `{"node":"ace","module":"dunst","assigned":"2026-10-14T00:00:00Z",`+
+	m.mirror(t, AssignmentsRead, "node-a.dunst", `{"node":"node-a","module":"dunst","assigned":"2026-10-14T00:00:00Z",`+
 		`"build":"b-1","artifact":{"name":"dunst","version":"1.2"},"commit":"abc123","rollout":"r-9",`+
 		`"since":"2026-10-18T00:00:00Z","ended":"","state":"","future":{"x":1}}`)
 	r, err := c.Reconcile()
 	if err != nil || len(r.Moved) != 4 {
 		t.Fatalf("an assignment with the new fields moved %+v (%v)", r.Moved, err)
 	}
-	expect(t, m, "ace", "10", SourceDefault)
+	expect(t, m, "node-a", "10", SourceDefault)
 	if r, _ = c.Reconcile(); len(r.Moved) != 0 {
 		t.Errorf("a quiet pass moved %+v", r.Moved)
 	}