A node-scoped seat's verb is callable through the console, naming its machine (hq ADR 0169)

The listing left node-scoped seats out, so <seat>.<verb> never resolved as a
seat's and the call went to a module subject nothing served. Listed now with
their scope: the schema requires the machine, the call carries it in the
subject, and a call without one is refused in words.

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;
+  /** A role's scope: `node` for a seat held once per machine, whose verb is asked of one machine
+   *  (design 33 §4) and takes `node` for it; `mesh` or absent otherwise. */
+  scope?: string;
   /** 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[];
@@ -177,11 +180,11 @@ export async function toolsOn(bus: Broker): Promise<Listing> {
   const notAnswering: string[] = [];
   if (roles) {
     for (const s of roles.seats ?? []) {
-      // A node-scoped seat's tool is asked of one machine, and the listing does not know which;
-      // those wait for a caller naming the node (`seat:<seat>.<verb>@<node>`).
-      if (s.scope === "node") continue;
+      // A node-scoped seat's tool is asked of one machine (design 33 §4): listed with its scope, so
+      // a caller names the machine and the call carries it — `seat:<seat>.<verb>@<node>`. Left out
+      // of the listing, the verb never resolved as a seat's and nothing served it (ADR 0169).
       for (const t of s.tools ?? []) {
-        tools.push({ module: s.seat, name: t.name, description: t.description, input: t.input, seat: true });
+        tools.push({ module: s.seat, name: t.name, description: t.description, input: t.input, seat: true, scope: s.scope });
       }
     }
   } else {

src/mcp.ts

@@ -122,7 +122,9 @@ export function mcpSurface(bus: Broker, who: string): Surface {
               // the module runs on several (novox/hq ADR 0159); a seat's verb takes none, the
               // seat's scope decides. An empty object is a tool that takes nothing, which is a
               // real answer and not a missing one.
-              inputSchema: t.seat ? asSchema(t.input) : withNode(asSchema(t.input)),
+              inputSchema: t.seat && t.scope !== "node" ? asSchema(t.input)
+                : t.seat ? withNode(asSchema(t.input), "the machine whose seat answers; required, the seat is held once per machine", true)
+                : withNode(asSchema(t.input)),
             })),
             // Silence, named (design 34 §3): the modules the catalogue holds and nothing answered
             // for. Not a tool, so not in `tools`; not dropped either.
@@ -139,9 +141,18 @@ export function mcpSurface(bus: Broker, who: string): Surface {
           // is the verb's own, as `push` and `assign` take one, and is handed through untouched.
           const have = await listing().catch(() => undefined);
           const roles = have && seatsIn(have);
-          const isSeatVerb = roles ? toolKey(given.split("@", 1)[0], roles).startsWith("seat:") : false;
-          const node = !isSeatVerb && typeof args.node === "string" && args.node !== "" ? args.node : "";
-          if (!isSeatVerb) delete args.node;
+          const bare = given.split("@", 1)[0];
+          const isSeatVerb = roles ? toolKey(bare, roles).startsWith("seat:") : false;
+          // A node-scoped seat's verb is asked of one machine (design 33 §4, ADR 0169): `node`
+          // names it and travels in the subject, as for a module's tool.
+          const nodeScoped = isSeatVerb && (have?.tools.some((t) => t.seat && t.scope === "node" &&
+            `${t.module}.${t.name}` === bare) ?? false);
+          const takesNode = !isSeatVerb || nodeScoped;
+          const node = takesNode && typeof args.node === "string" && args.node !== "" ? args.node : "";
+          if (takesNode) delete args.node;
+          if (nodeScoped && !node && !given.includes("@")) {
+            return refuse(request.id, -32602, `${given} is a machine's seat's verb: name the machine with \`node\``);
+          }
           const name = node && !given.includes("@") ? `${given}@${node}` : given;
           try {
             const { result, node: answeredBy } = await callTool(bus, name, args, roles, have);
@@ -229,13 +240,19 @@ async function* lines(): AsyncGenerator<string> {
 
 /** Every module tool takes an optional `node`: the machine to ask when the module runs on several
  *  (novox/hq ADR 0159). Added to the listing, stripped before the call, never seen by the module. */
-function withNode(schema: Record<string, unknown>): Record<string, unknown> {
+function withNode(schema: Record<string, unknown>, description?: string, required = false): Record<string, unknown> {
   const properties = { ...((schema.properties as Record<string, unknown> | undefined) ?? {}) };
   if (!("node" in properties)) {
     properties.node = {
       type: "string",
-      description: "the machine to ask, when this module runs on several; else whichever answers, and the answer says which",
+      description: description ??
+        "the machine to ask, when this module runs on several; else whichever answers, and the answer says which",
     };
   }
-  return { ...schema, type: "object", properties };
+  const out: Record<string, unknown> = { ...schema, type: "object", properties };
+  if (required) {
+    const have = Array.isArray(schema.required) ? (schema.required as string[]) : [];
+    out.required = have.includes("node") ? have : [...have, "node"];
+  }
+  return out;
 }