A runtime serves what the mesh issued it, and a seat's verbs are implemented under the seat's name (hq ADR 0160)

The one address a runtime derives for itself is mesh.assignment.<node>.<module>. It reads the
membership there with a direct get on the ASSIGNMENTS stream, serves each tool exactly where the
membership says — the plain subject in the module's queue when the mesh issued one, this machine's
beside it — and follows the subject, re-serving when a new membership arrives. A mesh that has issued
nothing yet gets the shape it always derived, and the log says so.

A seat's verbs are the role's, not the software's (ADR 0159): a module implements them with
registerModuleTools("<seat>", …), the runtime serves that on the seat's subjects when the credential
claims the seat, and never lists it among the module's own tools. A module named like its seat
registers once and is both.

The tools answer carries each tool's subjects, and the console and CLI call the subject the listing
gave them instead of composing one.

src/client.ts

@@ -40,6 +40,9 @@ export interface Tool {
   input?: unknown;
   /** True for a role's tool: addressed to the seat, answered by whoever holds it (ADR 0132). */
   seat?: boolean;
+  /** Where the tool is answered, as the mesh issued it (ADR 0160): the plain subject first when the
+   *  module answers for itself anywhere, then one per machine. Absent for a runtime older than this. */
+  subjects?: string[];
 }
 
 /**
@@ -188,7 +191,7 @@ export async function toolsOn(bus: Broker): Promise<Listing> {
     const module = names[i]!;
     if (outcome.status === "fulfilled" && Array.isArray(outcome.value?.tools)) {
       for (const t of outcome.value.tools) {
-        tools.push({ module, name: t.name, description: t.description, input: t.input });
+        tools.push({ module, name: t.name, description: t.description, input: t.input, subjects: t.subjects });
       }
     } else {
       notAnswering.push(module);
@@ -204,7 +207,13 @@ export async function toolsOn(bus: Broker): Promise<Listing> {
 /** Call a tool and learn which machine answered (novox/hq ADR 0159). `<module>.<tool>@<node>` asks
  *  the instance on one machine; without it, whichever instance answers first does, and the answer
  *  says which. */
-export async function callTool(bus: Broker, key: string, args: unknown, seats?: Seats): Promise<Answered<unknown>> {
+export async function callTool(
+  bus: Broker,
+  key: string,
+  args: unknown,
+  seats?: Seats,
+  listing?: Listing,
+): Promise<Answered<unknown>> {
   const at = key.indexOf("@");
   const name = at < 0 ? key : key.slice(0, at);
   const node = at < 0 ? "" : key.slice(at + 1);
@@ -215,11 +224,28 @@ export async function callTool(bus: Broker, key: string, args: unknown, seats?:
     );
   }
   const resolved = toolKey(name, seats) + (node ? `@${node}` : "");
-  const asking = bus as Broker & { ask?: <Req, Res>(k: string, b: Req) => Promise<Answered<Res>> };
-  if (typeof asking.ask === "function") return asking.ask<unknown, unknown>(resolved, args ?? {});
+  // Where the tool is answered is the module's to say and the mesh's to issue (ADR 0160): when the
+  // listing carried subjects for it, the call goes to one of those and composes nothing.
+  const on = subjectListed(name, node, listing);
+  const asking = bus as Broker & { ask?: <Req, Res>(k: string, b: Req, on?: string) => Promise<Answered<Res>> };
+  if (typeof asking.ask === "function") return asking.ask<unknown, unknown>(resolved, args ?? {}, on);
   return { result: await bus.request<unknown, unknown>(resolved, args ?? {}) };
 }
 
+/** The subject the listing says answers `<module>.<tool>` — the machine's when one is named, else
+ *  the plain one — or undefined when the listing said none, and the key is composed as before. */
+export function subjectListed(name: string, node: string, listing?: Listing): string | undefined {
+  if (!listing) return undefined;
+  const dot = name.indexOf(".");
+  const module = name.slice(0, dot);
+  const tool = name.slice(dot + 1);
+  const found = listing.tools.find((t) => t.module === module && t.name === tool && !t.seat);
+  const subjects = found?.subjects ?? [];
+  if (subjects.length === 0) return undefined;
+  if (node) return subjects.find((s) => s.endsWith(`.${node}`));
+  return subjects[0];
+}
+
 /**
  * Why a call failed, said so that the remedy is in the words.
  *