diff --git a/modules/netcheck/cmd/netcheck/ask_test.go b/modules/netcheck/cmd/netcheck/ask_test.go
index 1ad2c293..6bdf4349 100644
--- a/modules/netcheck/cmd/netcheck/ask_test.go
+++ b/modules/netcheck/cmd/netcheck/ask_test.go
@@ -10,7 +10,7 @@ import (
 	"time"
 )
 
-// respond answers one query: novox.internal A 10.10.0.1 via a compressed name, anything else rcode.
+// respond answers one query: node-c.internal A 10.10.0.1 via a compressed name, anything else rcode.
 func respond(q []byte, rcode byte) []byte {
 	end := 12
 	for q[end] != 0 {
@@ -20,7 +20,7 @@ func respond(q []byte, rcode byte) []byte {
 	name := strings.ToLower(string(q[13:end]))
 	r := append([]byte{}, q[:2]...)
 	r = append(r, 0x81, 0x80|rcode, 0, 1)
-	answer := rcode == 0 && strings.Contains(name, "novox") && binary.BigEndian.Uint16(q[end+1:]) == 1
+	answer := rcode == 0 && strings.Contains(name, "node-c") && binary.BigEndian.Uint16(q[end+1:]) == 1
 	if answer {
 		r = append(r, 0, 1, 0, 0, 0, 0)
 	} else {
@@ -80,11 +80,11 @@ func tcpResolver(t *testing.T) string {
 
 // Issue 348: the question that could not be asked during the outage — does the resolver at one address answer?
 func TestDNSAsksANamedResolverOverUDPAndTCPAndSaysItsResponseCode(t *testing.T) {
-	got, err := AskDNS("novox.internal", "A", udpResolver(t, 0), false, time.Second)
+	got, err := AskDNS("node-c.internal", "A", udpResolver(t, 0), false, time.Second)
 	if err != nil || got.Rcode != "NOERROR" || got.Protocol != "udp" || len(got.Answers) != 1 || got.Answers[0] != "10.10.0.1" || got.Error != "" {
 		t.Fatalf("udp: %+v, %v", got, err)
 	}
-	got, err = AskDNS("novox.internal", "A", tcpResolver(t), true, time.Second)
+	got, err = AskDNS("node-c.internal", "A", tcpResolver(t), true, time.Second)
 	if err != nil || got.Rcode != "NOERROR" || got.Protocol != "tcp" || len(got.Answers) != 1 || got.Answers[0] != "10.10.0.1" {
 		t.Fatalf("tcp: %+v, %v", got, err)
 	}
@@ -92,7 +92,7 @@ func TestDNSAsksANamedResolverOverUDPAndTCPAndSaysItsResponseCode(t *testing.T)
 	if got.Rcode != "NXDOMAIN" || got.Error == "" || len(got.Answers) != 0 {
 		t.Fatalf("no such name is a result with its code: %+v", got)
 	}
-	got, _ = AskDNS("novox.internal", "A", udpResolver(t, 5), false, time.Second)
+	got, _ = AskDNS("node-c.internal", "A", udpResolver(t, 5), false, time.Second)
 	if got.Rcode != "REFUSED" || got.Error == "" {
 		t.Fatalf("a refusal: %+v", got)
 	}
@@ -102,14 +102,14 @@ func TestDNSSaysARefusedPortAndRefusesANameAsServer(t *testing.T) {
 	l, _ := net.Listen("tcp", "127.0.0.1:0")
 	addr := l.Addr().String()
 	l.Close()
-	got, err := AskDNS("novox.internal", "A", addr, true, time.Second)
+	got, err := AskDNS("node-c.internal", "A", addr, true, time.Second)
 	if err != nil || !strings.Contains(got.Error, "connection refused") {
 		t.Fatalf("nothing listening is a result naming it: %+v, %v", got, err)
 	}
-	if _, err := AskDNS("novox.internal", "A", "resolver.example", false, time.Second); err == nil {
+	if _, err := AskDNS("node-c.internal", "A", "resolver.example", false, time.Second); err == nil {
 		t.Fatal("a server given by name was accepted")
 	}
-	if _, err := AskDNS("novox.internal", "A", "", true, time.Second); err == nil {
+	if _, err := AskDNS("node-c.internal", "A", "", true, time.Second); err == nil {
 		t.Fatal("tcp without a server was accepted")
 	}
 	if a, _ := serverAddress("10.10.0.1"); a != "10.10.0.1:53" {
diff --git a/modules/netcheck/cmd/netcheck/tunnel_test.go b/modules/netcheck/cmd/netcheck/tunnel_test.go
index 29f85b78..c5737cd4 100644
--- a/modules/netcheck/cmd/netcheck/tunnel_test.go
+++ b/modules/netcheck/cmd/netcheck/tunnel_test.go
@@ -13,8 +13,8 @@ func dump(now time.Time) string {
 	fresh := now.Add(-40 * time.Second).Unix()
 	old := now.Add(-10 * time.Minute).Unix()
 	return privateKey + "\tPUBkeyOfTheHubAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\t51820\toff\n" +
-		"PUBkeyAceAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\t(none)\t84.193.151.6:40122\t10.10.0.2/32\t" + itoa(old) + "\t1000\t2000\t25\n" +
-		"PUBkeyShanksAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\t(none)\t84.193.151.6:51820\t10.10.0.3/32\t" + itoa(fresh) + "\t3000\t4000\toff\n" +
+		"PUBkeyNodeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\t(none)\t84.193.151.6:40122\t10.10.0.2/32\t" + itoa(old) + "\t1000\t2000\t25\n" +
+		"PUBkeyNodeDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\t(none)\t84.193.151.6:51820\t10.10.0.3/32\t" + itoa(fresh) + "\t3000\t4000\toff\n" +
 		"PUBkeyNewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=\t(none)\t(none)\t10.10.0.9/32\t0\t0\t0\toff\n"
 }
 
@@ -33,12 +33,12 @@ func TestTheDumpIsReadAndNoKeyIsSaid(t *testing.T) {
 	if tun.ListenPort != 51820 || len(tun.Peers) != 3 {
 		t.Fatalf("got %+v", tun)
 	}
-	ace, shanks, fresh := tun.Peers[0], tun.Peers[1], tun.Peers[2]
-	if ace.Endpoint != "84.193.151.6:40122" || ace.HandshakeAge != 600 || !ace.Stale || ace.Keepalive != "25s" || ace.Sent != 2000 {
-		t.Errorf("ace %+v", ace)
+	nodeA, nodeD, fresh := tun.Peers[0], tun.Peers[1], tun.Peers[2]
+	if nodeA.Endpoint != "84.193.151.6:40122" || nodeA.HandshakeAge != 600 || !nodeA.Stale || nodeA.Keepalive != "25s" || nodeA.Sent != 2000 {
+		t.Errorf("nodeA %+v", nodeA)
 	}
-	if shanks.Stale || shanks.HandshakeAge != 40 || shanks.Keepalive != "" {
-		t.Errorf("shanks %+v", shanks)
+	if nodeD.Stale || nodeD.HandshakeAge != 40 || nodeD.Keepalive != "" {
+		t.Errorf("nodeD %+v", nodeD)
 	}
 	if fresh.Endpoint != "" || fresh.HandshakeAge != -1 || !fresh.Stale || fresh.Handshake != "" {
 		t.Errorf("a peer never heard from %+v", fresh)
diff --git a/modules/nfs-server/cmd/nfs-server/backup_test.go b/modules/nfs-server/cmd/nfs-server/backup_test.go
index 7ae3298b..0af8bd31 100644
--- a/modules/nfs-server/cmd/nfs-server/backup_test.go
+++ b/modules/nfs-server/cmd/nfs-server/backup_test.go
@@ -81,16 +81,16 @@ func TestWithoutTheBackupListTheExportsStayAndItIsSaid(t *testing.T) {
 }
 
 func TestBackupFromTheSeatsAndTheData(t *testing.T) {
-	seats := json.RawMessage(`{"answer":{"seats":[{"seat":"node-backup","scope":"node","holders":[{"module":"restic","node":"ace"},{"module":"borg","node":"shanks"}]}]},"ok":true}`)
-	data := json.RawMessage(`{"answer":{"data":[{"machine":"ace","module":"restic","item":"repository","path":"/storage/restic"},{"machine":"ace","module":"restic","item":"state","path":"/var/lib/restic"},{"machine":"ace","module":"plex","item":"data","path":"/mnt/plex/data"}]},"ok":true}`)
-	holder, paths, err := BackupFrom("ace", seats, data)
+	seats := json.RawMessage(`{"answer":{"seats":[{"seat":"node-backup","scope":"node","holders":[{"module":"restic","node":"node-a"},{"module":"borg","node":"node-d"}]}]},"ok":true}`)
+	data := json.RawMessage(`{"answer":{"data":[{"machine":"node-a","module":"restic","item":"repository","path":"/storage/restic"},{"machine":"node-a","module":"restic","item":"state","path":"/var/lib/restic"},{"machine":"node-a","module":"plex","item":"data","path":"/mnt/plex/data"}]},"ok":true}`)
+	holder, paths, err := BackupFrom("node-a", seats, data)
 	if err != nil || holder != "restic" || strings.Join(paths, " ") != "/storage/restic /var/lib/restic" {
 		t.Errorf("got %q %v %v", holder, paths, err)
 	}
-	if _, _, err := BackupFrom("g14", seats, data); err == nil {
+	if _, _, err := BackupFrom("node-b", seats, data); err == nil {
 		t.Errorf("a machine whose backup seat nobody holds is not said")
 	}
-	if _, _, err := BackupFrom("ace", seats, json.RawMessage(`{"ok":true}`)); err == nil {
+	if _, _, err := BackupFrom("node-a", seats, json.RawMessage(`{"ok":true}`)); err == nil {
 		t.Errorf("an answer with no data list reads as an empty list")
 	}
 }
@@ -99,11 +99,11 @@ func TestBackupFromTheSeatsAndTheData(t *testing.T) {
 func TestAFailedAskKeepsTheLastBackupPaths(t *testing.T) {
 	f := newFake(t)
 	m := f.machine()
-	m.TakeBackupWith("ace", func(string, any) (json.RawMessage, error) {
+	m.TakeBackupWith("node-a", func(string, any) (json.RawMessage, error) {
 		return nil, errors.New("no responders")
 	})
 	f.backup("restic", "/storage/restic")
-	m.TakeBackupWith("ace", func(string, any) (json.RawMessage, error) {
+	m.TakeBackupWith("node-a", func(string, any) (json.RawMessage, error) {
 		return nil, errors.New("timeout")
 	})
 	var b BackupFromBus
diff --git a/modules/nfs-server/cmd/nfs-server/guards_test.go b/modules/nfs-server/cmd/nfs-server/guards_test.go
index add729ff..1c43676c 100644
--- a/modules/nfs-server/cmd/nfs-server/guards_test.go
+++ b/modules/nfs-server/cmd/nfs-server/guards_test.go
@@ -64,9 +64,9 @@ func TestAFailedReloadIsTriedAgainWhenNothingElseAsks(t *testing.T) {
 }
 
 func TestBackupFromRefusesAnAnswerWithoutADataList(t *testing.T) {
-	seats := json.RawMessage(`{"answer":{"seats":[{"seat":"node-backup","holders":[{"module":"restic","node":"ace"}]}]}}`)
+	seats := json.RawMessage(`{"answer":{"seats":[{"seat":"node-backup","holders":[{"module":"restic","node":"node-a"}]}]}}`)
 	for _, data := range []string{`{"answer":{}}`, `{"answer":{"data":null}}`} {
-		if _, paths, err := BackupFrom("ace", seats, json.RawMessage(data)); err == nil {
+		if _, paths, err := BackupFrom("node-a", seats, json.RawMessage(data)); err == nil {
 			t.Errorf("%s was read as the empty list %v: never \"nothing to fear\"", data, paths)
 		}
 	}
diff --git a/modules/nodered/mqtt/connection.ts b/modules/nodered/mqtt/connection.ts
index c7204413..a9deaa09 100644
--- a/modules/nodered/mqtt/connection.ts
+++ b/modules/nodered/mqtt/connection.ts
@@ -8,7 +8,7 @@
 //
 // **Which broker nodes are the mesh's.** Never guessed: a flow may talk to a broker that has nothing
 // to do with this mesh. The step owns the node it creates itself (id `mesh-mqtt-topic`, "mesh:
-// mqtt-topic") and the ones an assignment names in settings (`mqtt.brokers`: node ids — how ace's
+// mqtt-topic") and the ones an assignment names in settings (`mqtt.brokers`: node ids — how node-a's
 // existing broker node, which every one of its MQTT flows uses, is handed over). With none named and
 // none made yet, it makes one, so a fresh Node-RED has a broker the flows can pick.
 //
diff --git a/modules/nodered/test/mqtt.test.ts b/modules/nodered/test/mqtt.test.ts
index 59a1f6a0..25e33b54 100644
--- a/modules/nodered/test/mqtt.test.ts
+++ b/modules/nodered/test/mqtt.test.ts
@@ -4,7 +4,7 @@
 // differs; a node that is not named is never touched; a loopback broker address is refused.
 //
 // Node-RED and the broker are fakes answering as the real ones do (admin API v2 of nodered/node-red
-// 5.0.7, the build ace runs).
+// 5.0.7, the build node-a runs).
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
@@ -13,10 +13,10 @@ import { MESH_BROKER_ID, namedBrokers, reconcileBrokers, type Binding, type Flow
 import type { Probe } from "../mqtt/probe.ts";
 
 const MINTED = "mesh-minted-password";
-const binding = (at = "ace.internal"): Binding => ({ provision: "mqtt-topic", from: "ace", at, as: "mesh_ace_nodered", serves: { scheme: "mqtt", port: 1883 } });
+const binding = (at = "node-a.internal"): Binding => ({ provision: "mqtt-topic", from: "node-a", at, as: "mesh_node_a_nodered", serves: { scheme: "mqtt", port: 1883 } });
 
-/** ace's flows, reduced: its one broker node (dead, zurag.be:1884) and a node that uses it. */
-function aceFlows(): FlowNode[] {
+/** node-a's flows, reduced: its one broker node (dead, zurag.be:1884) and a node that uses it. */
+function nodeAFlows(): FlowNode[] {
   return [
     { id: "2b0aece9c5f3b307", type: "mqtt-broker", name: "MQTT Broker", broker: "zurag.be", port: "1884", clientid: "", usetls: false, protocolVersion: "4", keepalive: "60" },
     { id: "fe0cae96f1e3ae4d", type: "mqtt in", topic: "stat/sonoff_office_light_switch/RESULT", broker: "2b0aece9c5f3b307", z: "t" },
@@ -52,17 +52,17 @@ const marks = (): Marks & { store: Map<string, string> } => {
   const store = new Map<string, string>();
   return { store, get: async (k) => store.get(k), set: async (k, v) => void store.set(k, v) };
 };
-const takes: Probe = async (_h, _p, user, pass) => ({ connack: user === "mesh_ace_nodered" && pass === MINTED ? 0 : 5, suback: 0 });
+const takes: Probe = async (_h, _p, user, pass) => ({ connack: user === "mesh_node_a_nodered" && pass === MINTED ? 0 : 5, suback: 0 });
 
-test("ace: the named broker node is moved to the bound broker and login; the other broker is not touched", async () => {
-  const f = fakeNodeRed(aceFlows(), { "2b0aece9c5f3b307": { user: "luffy", password: "old" }, "other-broker": { user: "x", password: "y" } });
+test("node-a: the named broker node is moved to the bound broker and login; the other broker is not touched", async () => {
+  const f = fakeNodeRed(nodeAFlows(), { "2b0aece9c5f3b307": { user: "luffy", password: "old" }, "other-broker": { user: "x", password: "y" } });
   const m = marks();
   const out = await reconcileBrokers({ nodered: f.nodered, probe: takes, marks: m }, binding(), `${MINTED}\n`, ["2b0aece9c5f3b307"]);
   assert.deepEqual(out, [{ what: "broker 2b0aece9c5f3b307", result: "written", fields: ["broker", "port", "user", "password"] }]);
   const node = f.flows.find((n) => n.id === "2b0aece9c5f3b307");
-  assert.deepEqual(node, { ...aceFlows()[0], broker: "ace.internal", port: "1883", usetls: false });
-  assert.deepEqual(f.creds["2b0aece9c5f3b307"], { user: "mesh_ace_nodered", password: MINTED });
-  assert.deepEqual(f.flows.find((n) => n.id === "other-broker"), aceFlows()[2]);
+  assert.deepEqual(node, { ...nodeAFlows()[0], broker: "node-a.internal", port: "1883", usetls: false });
+  assert.deepEqual(f.creds["2b0aece9c5f3b307"], { user: "mesh_node_a_nodered", password: MINTED });
+  assert.deepEqual(f.flows.find((n) => n.id === "other-broker"), nodeAFlows()[2]);
   assert.deepEqual(f.creds["other-broker"], { user: "x", password: "y" });
   // Only the changed node carried credentials in the deploy.
   assert.deepEqual(f.deploys[0].filter((n) => n.credentials).map((n) => n.id), ["2b0aece9c5f3b307"]);
@@ -78,19 +78,19 @@ test("fresh: with nothing named, the step makes its own broker node", async () =
   const out = await reconcileBrokers({ nodered: f.nodered, probe: takes, marks: marks() }, binding(), MINTED, []);
   assert.deepEqual(out, [{ what: `broker ${MESH_BROKER_ID}`, result: "written", fields: ["node"] }]);
   assert.equal(f.flows[0].type, "mqtt-broker");
-  assert.equal(f.flows[0].broker, "ace.internal");
-  assert.deepEqual(f.creds[MESH_BROKER_ID], { user: "mesh_ace_nodered", password: MINTED });
+  assert.equal(f.flows[0].broker, "node-a.internal");
+  assert.deepEqual(f.creds[MESH_BROKER_ID], { user: "mesh_node_a_nodered", password: MINTED });
 });
 
 test("a login the broker does not take is never written", async () => {
-  const f = fakeNodeRed(aceFlows());
+  const f = fakeNodeRed(nodeAFlows());
   const out = await reconcileBrokers({ nodered: f.nodered, probe: async () => ({ connack: 5 }), marks: marks() }, binding(), MINTED, ["2b0aece9c5f3b307"]);
   assert.equal(out[0].result, "refused");
   assert.equal(f.deploys.length, 0);
 });
 
 test("a named node that is not there, or a loopback broker, is refused", async () => {
-  const f = fakeNodeRed(aceFlows());
+  const f = fakeNodeRed(nodeAFlows());
   const out = await reconcileBrokers({ nodered: f.nodered, probe: takes, marks: marks() }, binding(), MINTED, ["gone"]);
   assert.match((out[0] as { problem: string }).problem, /no such node/);
   const lo = await reconcileBrokers({ nodered: f.nodered, probe: takes, marks: marks() }, binding("127.0.0.1"), MINTED, []);
@@ -99,7 +99,7 @@ test("a named node that is not there, or a loopback broker, is refused", async (
 });
 
 test("a deploy that raced another is read again once", async () => {
-  const f = fakeNodeRed(aceFlows());
+  const f = fakeNodeRed(nodeAFlows());
   let first = true;
   const racing: NodeRed = {
     ...f.nodered,
diff --git a/modules/telegram/cmd/telegram/channel_test.go b/modules/telegram/cmd/telegram/channel_test.go
index 06c96121..0c1be4f0 100644
--- a/modules/telegram/cmd/telegram/channel_test.go
+++ b/modules/telegram/cmd/telegram/channel_test.go
@@ -217,7 +217,7 @@ func TestAQuestionIsShownWithItsTicketsAndRingsAndAWarningIsSilent(t *testing.T)
 	if f.of("sendMessage")[1].Body["disable_notification"] != true {
 		t.Error("a clearing rang (D4)")
 	}
-	subject, body = work(asks.Send, asks.Message{Handle: "m3", Title: "Urgent: ace silent", Urgent: true, To: "42"})
+	subject, body = work(asks.Send, asks.Message{Handle: "m3", Title: "Urgent: node-a silent", Urgent: true, To: "42"})
 	_ = c.Take(subject, body)
 	if f.of("sendMessage")[2].Body["disable_notification"] != false {
 		t.Error("an urgent message was silent (D4)")
@@ -243,7 +243,7 @@ func TestALongMessageIsCutAndTheCutSaid(t *testing.T) {
 // nor injects. The tap on it is still compared by the plain words, which is what Telegram gives back.
 func TestAMessageIsRenderedInHTMLWithItsMarkupEscaped(t *testing.T) {
 	c, f, s, _ := newChannel(t, goodToken)
-	subject, body := work(asks.Show, asks.Message{Handle: "q1", Title: "Set mounts on <shanks> & co?",
+	subject, body := work(asks.Show, asks.Message{Handle: "q1", Title: "Set mounts on <node-d> & co?",
 		Body: "Changes two settings.\n+ shares: media=/storage/media\n~ sources: a=b (was: c)",
 		Note: "Asked by mesh-controller at 15:11.\nFingerprint 1234 5678 9abc.",
 		To:   "42", Buttons: []asks.Button{{Label: "Approve", Ticket: "tkt"}}})
@@ -251,7 +251,7 @@ func TestAMessageIsRenderedInHTMLWithItsMarkupEscaped(t *testing.T) {
 		t.Fatal(err)
 	}
 	sent := f.of("sendMessage")
-	want := "<b>Set mounts on &lt;shanks&gt; &amp; co?</b>\nChanges two settings.\n<code>+ shares: media=/storage/media</code>\n" +
+	want := "<b>Set mounts on &lt;node-d&gt; &amp; co?</b>\nChanges two settings.\n<code>+ shares: media=/storage/media</code>\n" +
 		"<code>~ sources: a=b (was: c)</code>\n\n<blockquote expandable>Asked by mesh-controller at 15:11.\nFingerprint 1234 5678 9abc.</blockquote>"
 	if len(sent) != 1 || sent[0].Body["text"] != want || sent[0].Body["parse_mode"] != "HTML" {
 		t.Fatalf("sent %v", sent)
@@ -262,7 +262,7 @@ func TestAMessageIsRenderedInHTMLWithItsMarkupEscaped(t *testing.T) {
 	// Telegram gives the words back plain, the space around the blockquote as it pleases: the tap on them is taken.
 	c.Handle(Update{UpdateID: 1, Callback: &Callback{ID: "cb1", Data: "tkt", From: User{ID: 42, FirstName: "Jo"},
 		Message: &Msg{MessageID: shown, Chat: Chat{ID: 42, Type: "private"},
-			Text: "Set mounts on <shanks> & co?\nChanges two settings.\n+ shares: media=/storage/media\n~ sources: a=b (was: c)\n" +
+			Text: "Set mounts on <node-d> & co?\nChanges two settings.\n+ shares: media=/storage/media\n~ sources: a=b (was: c)\n" +
 				"Asked by mesh-controller at 15:11.\nFingerprint 1234 5678 9abc."}}})
 	if got := s.of(asks.IntakeSubject(asks.Chosen, Kind)); len(got) != 1 {
 		t.Fatalf("the tap on the rendered message was not taken: %s", got)
@@ -270,20 +270,20 @@ func TestAMessageIsRenderedInHTMLWithItsMarkupEscaped(t *testing.T) {
 	// Words changed by another holder of the token are still told apart.
 	c.Handle(Update{UpdateID: 2, Callback: &Callback{ID: "cb2", Data: "tkt", From: User{ID: 42, FirstName: "Jo"},
 		Message: &Msg{MessageID: shown, Chat: Chat{ID: 42, Type: "private"},
-			Text: "Set mounts on <shanks> & co?\nChanges three settings.\n+ shares: media=/storage/media\n~ sources: a=b (was: c)\n" +
+			Text: "Set mounts on <node-d> & co?\nChanges three settings.\n+ shares: media=/storage/media\n~ sources: a=b (was: c)\n" +
 				"Asked by mesh-controller at 15:11.\nFingerprint 1234 5678 9abc."}}})
 	if got := s.of(asks.IntakeSubject(asks.Chosen, Kind)); len(got) != 1 {
 		t.Fatalf("a tap on changed words was taken: %s", got)
 	}
 	// The edit says what was chosen, one line with the headline, and is in the same mode.
-	subject, body = work(asks.Edit, asks.Message{Handle: "q1", Title: "You chose Approve at 15:06 on Telegram · Set mounts on <shanks> & co?",
+	subject, body = work(asks.Edit, asks.Message{Handle: "q1", Title: "You chose Approve at 15:06 on Telegram · Set mounts on <node-d> & co?",
 		Note: "Told to mesh-controller, which acts on it itself.", To: "42"})
 	if err := c.Take(subject, body); err != nil {
 		t.Fatal(err)
 	}
 	ed := f.of("editMessageText")
 	if len(ed) != 1 || ed[0].Body["parse_mode"] != "HTML" ||
-		ed[0].Body["text"] != "<b>You chose Approve at 15:06 on Telegram · Set mounts on &lt;shanks&gt; &amp; co?</b>\n\n<blockquote expandable>Told to mesh-controller, which acts on it itself.</blockquote>" {
+		ed[0].Body["text"] != "<b>You chose Approve at 15:06 on Telegram · Set mounts on &lt;node-d&gt; &amp; co?</b>\n\n<blockquote expandable>Told to mesh-controller, which acts on it itself.</blockquote>" {
 		t.Errorf("edited %v", ed)
 	}
 	// A plain answer in the chat is escaped too.
@@ -657,7 +657,7 @@ func TestAToastIsCutAtTelegramsBound(t *testing.T) {
 // loses its buttons. A new handle is a new message, and nothing is deleted.
 func TestAMessageSaidAgainUnderItsHandleReplacesTheEarlierOne(t *testing.T) {
 	c, f, _, st := newChannel(t, goodToken)
-	subject, body := work(asks.Show, asks.Message{Handle: "m1", Title: "Urgent: ace silent", Urgent: true, To: "42",
+	subject, body := work(asks.Show, asks.Message{Handle: "m1", Title: "Urgent: node-a silent", Urgent: true, To: "42",
 		Buttons: []asks.Button{{Label: "Silence for a week", Ticket: "0123456789abcdef0123456789abcdef"}}})
 	if err := c.Take(subject, body); err != nil {
 		t.Fatal(err)
@@ -668,7 +668,7 @@ func TestAMessageSaidAgainUnderItsHandleReplacesTheEarlierOne(t *testing.T) {
 	if len(f.of("deleteMessage")) != 0 {
 		t.Fatal("a new handle deleted a message")
 	}
-	subject, body = work(asks.Show, asks.Message{Handle: "m1", Title: "Still open: ace silent", Urgent: true, To: "42",
+	subject, body = work(asks.Show, asks.Message{Handle: "m1", Title: "Still open: node-a silent", Urgent: true, To: "42",
 		Buttons: []asks.Button{{Label: "Silence for a week", Ticket: "fedcba9876543210fedcba9876543210"}}})
 	if err := c.Take(subject, body); err != nil {
 		t.Fatal(err)
@@ -686,7 +686,7 @@ func TestAMessageSaidAgainUnderItsHandleReplacesTheEarlierOne(t *testing.T) {
 		return 400, `{"ok":false,"error_code":400,"description":"Bad Request: message can't be deleted"}`
 	}
 	second := st.placed["m1"].ID
-	subject, body = work(asks.Send, asks.Message{Handle: "m1", Title: "Now urgent: ace silent", Urgent: true, To: "42"})
+	subject, body = work(asks.Send, asks.Message{Handle: "m1", Title: "Now urgent: node-a silent", Urgent: true, To: "42"})
 	_ = c.Take(subject, body)
 	ed := f.of("editMessageText")
 	if len(ed) != 1 || ed[0].Body["message_id"] != float64(second) || !strings.Contains(ed[0].Body["text"].(string), "Replaced") {
@@ -705,7 +705,7 @@ func TestAReplacementThatCannotBeSentLeavesTheEarlierMessage(t *testing.T) {
 	f.answer["sendMessage"] = func(map[string]any) (int, string) {
 		return 400, `{"ok":false,"error_code":400,"description":"Bad Request: chat not found"}`
 	}
-	subject, body := work(asks.Send, asks.Message{Handle: "m1", Title: "Still open: ace silent", Urgent: true, To: "42"})
+	subject, body := work(asks.Send, asks.Message{Handle: "m1", Title: "Still open: node-a silent", Urgent: true, To: "42"})
 	_ = c.Take(subject, body)
 	if len(f.of("deleteMessage")) != 0 || st.placed["m1"].ID != 7 {
 		t.Fatalf("the earlier message was taken away though its replacement was not sent: %+v", f.of("deleteMessage"))
diff --git a/modules/telegram/cmd/telegram/render_test.go b/modules/telegram/cmd/telegram/render_test.go
index 963136d8..a678fb12 100644
--- a/modules/telegram/cmd/telegram/render_test.go
+++ b/modules/telegram/cmd/telegram/render_test.go
@@ -20,7 +20,7 @@ var adr0343 = asks.Message{Handle: "h-343", To: "42",
 		"• A deleted file is marked, and a newer change elsewhere outlives the deletion",
 	Note: "Asked by mesh-knowledge at 16:05. Unanswered by tomorrow 15:55: the record stays proposed; nothing of it is in force.\n" +
 		"Approve: the record is accepted and its clauses are in force. Decline: the record stays proposed; nothing of it is in force.\n" +
-		"ADR 0343, proposed by fix-367@g14; the knowledge base's own review approved it. Fingerprint a59f 361b f60e cb5e d237 a837.\n" +
+		"ADR 0343, proposed by fix-367@node-b; the knowledge base's own review approved it. Fingerprint a59f 361b f60e cb5e d237 a837.\n" +
 		"Read its 13 clauses with the knowledge base's get, number 343.",
 	Buttons: []asks.Button{{Label: "Approve", Ticket: "t-approve"}, {Label: "Decline", Ticket: "t-decline"}}}