Name no controller verb in hints and drop its handover and paging reads, since the controller ended (issue 1126 B19)

Claude-Session: https://claude.ai/code/session_01NcbgfJ9Gum47zkFKWRaovL

node-tools/internal/bus/bus.go

@@ -32,9 +32,7 @@ import (
 	"github.com/novox/mesh-tools/node-tools/internal/wire"
 )
 
-// RequestTimeout is how long a call waits for its answer — what modules already expect. The
-// controller answers its verbs well inside it (its AnswerWithin, ten seconds), with a call id while a
-// verb still runs, so a caller is never left guessing past this (novox/hq issue 265).
+// RequestTimeout is how long a call waits for its answer — what modules already expect.
 const RequestTimeout = 30 * time.Second
 
 // Credential is a broker credential as the mesh delivers it (novox/hq ADR 0120).
@@ -344,7 +342,7 @@ func (c *Conn) Credential() Credential { return c.cred }
 // Follow reads a module's membership on this machine once and follows it live, so its tools are
 // served where the mesh issued them (ADR 0175). It is read from the grants part's state memberships, its key
 // `<node>.<module>` (novox/hq ADR 0571 clause 7 and 10, mesh-sdk buscompose.GrantsMembershipsBucket), and nowhere else:
-// the controller's assignments stream is not read and its subject is not heard.
+// the old assignments stream is not read and its subject is not heard.
 func (c *Conn) Follow(module string) {
 	c.mu.Lock()
 	if c.node == "" {
@@ -790,83 +788,47 @@ func (c *Conn) Ask(key string, body any, on string) (Answered, error) {
 	// account publish with its own name alone; asked again on the subject that names no caller only when the
 	// first reached nobody — nothing serves it yet, or the bus does not grant it yet — so no call is done twice.
 	if called := CalledSubject(subject, c.cred.User); called != "" {
-		answered, handingOver, fallBack, err := c.askCalled(called, data)
+		answered, fallBack, err := c.askCalled(called, data)
 		if !fallBack {
-			if !handingOver {
-				return answered, err
-			}
-			time.Sleep(HandoverPause)
-			answered, again, _, err := c.askCalled(called, data)
-			if err != nil && again {
-				return Answered{}, fmt.Errorf("asked twice, %s apart, and both times refused as a handover: %w", HandoverPause, err)
-			}
 			return answered, err
 		}
 	}
-	answered, handingOver, err := c.askOnce(subject, data)
-	if !handingOver {
-		return answered, err
-	}
-	// **Refused because the controller is handing over: asked once more** (novox/hq issue 289). The
-	// controller being replaced did nothing and said so; the one after it answers the same call. Once:
-	// a second refusal is a controller that is not coming back, and the caller is told.
-	time.Sleep(HandoverPause)
-	answered, again, err := c.askOnce(subject, data)
-	if err != nil && again {
-		return Answered{}, fmt.Errorf("asked twice, %s apart, and both times refused as a handover: %w", HandoverPause, err)
-	}
-	return answered, err
+	return c.askOnce(subject, data)
 }
 
-// HandoverPause is how long a call refused as a handover waits before it is asked once more: the
-// supervisor's restart of the controller, which stops the one being replaced and starts the next. A
-// variable so a test need not wait.
-var HandoverPause = 3 * time.Second
-
-// RetryHandingOver is the mark the controller puts on a call it refused because it is being replaced
-// (mesh-controller internal/link, `"retry": "handing-over"`).
-const RetryHandingOver = "handing-over"
-
 // ErrNoResponders is the bus's own refusal: nothing subscribes to the subject asked. It is told apart
 // from a tool's own error by errors.Is, never by its text (a tool may say "503" itself, issue 1529).
 var ErrNoResponders = errors.New("503 no responders")
 
-// askOnce asks once, and says whether the answer was a refusal marked to be asked again.
-func (c *Conn) askOnce(subject string, data []byte) (Answered, bool, error) {
+// askOnce asks once.
+func (c *Conn) askOnce(subject string, data []byte) (Answered, error) {
 	msg, err := c.nc.Request(subject, data, RequestTimeout)
 	if err != nil {
 		if errors.Is(err, nats.ErrNoResponders) {
-			return Answered{}, false, ErrNoResponders
+			return Answered{}, ErrNoResponders
 		}
 		if errors.Is(err, nats.ErrTimeout) {
-			return Answered{}, false, errors.New("timeout")
+			return Answered{}, errors.New("timeout")
 		}
-		return Answered{}, false, err
+		return Answered{}, err
 	}
-	return c.answerOf(subject, msg.Data)
+	return answerOf(msg.Data)
 }
 
-// answerOf reads one answer, asking the rest of a paged one on the subject it was asked on, and says whether it
-// was a refusal marked to be asked again.
-func (c *Conn) answerOf(subject string, data []byte) (Answered, bool, error) {
-	// An answer larger than one message comes in parts (pages.go, novox/hq issue 314).
-	body, err := c.whole(subject, data)
-	if err != nil {
-		return Answered{}, false, err
-	}
+// answerOf reads one answer.
+func answerOf(data []byte) (Answered, error) {
 	var r struct {
 		Result json.RawMessage `json:"result"`
 		Error  string          `json:"error"`
 		Node   string          `json:"node"`
-		Retry  string          `json:"retry"`
 	}
-	if err := json.Unmarshal(body, &r); err != nil {
-		return Answered{}, false, err
+	if err := json.Unmarshal(data, &r); err != nil {
+		return Answered{}, err
 	}
 	if r.Error != "" {
-		return Answered{}, r.Retry == RetryHandingOver, errors.New(r.Error)
+		return Answered{}, errors.New(r.Error)
 	}
-	return Answered{Result: r.Result, Node: r.Node}, false, nil
+	return Answered{Result: r.Result, Node: r.Node}, nil
 }
 
 // PublishAs emits an event as a module: published into JetStream and awaited, de-duplicated by its
@@ -1070,7 +1032,7 @@ func (c *Conn) AskAs(module, key string, body any) (Answered, error) {
 }
 
 // EventsStream is where every module's events land, and ConsumerOf the durable consumer the
-// controller makes for a module on a machine: the same names the module's own runtime bound
+// mesh makes for a module on a machine: the same names the module's own runtime bound
 // (node-tools/src/broker-nats.ts), so moving the module into the node's runtime neither loses an
 // event nor sees one twice.
 const EventsStream = "EVENTS"
@@ -1085,7 +1047,7 @@ func ConsumerOf(node, module string) string {
 
 // NakDelay is how long an event a handler failed waits before it is offered again: a transient cause
 // gets another attempt, a permanent one exhausts the consumer's max-deliver rather than spinning. The
-// consumer then gives the event up, and the controller keeps it in DEAD_LETTERS until a person delivers
+// consumer then gives the event up, and the mesh keeps it in DEAD_LETTERS until a person delivers
 // it again — under `mesh.again.<consumer>.…`, from which keyOf reads the same key — or drops it
 // (novox/hq issue 330).
 var NakDelay = 5 * time.Second
@@ -1099,7 +1061,7 @@ var EventHeartbeat = 10 * time.Second
 // ConsumeAs reads a module's durable consumer on EVENTS, and each one on a module's stream its
 // membership names (novox/hq ADR 0363 §8), and hands each event to deliver one at a time (novox/hq
 // ADR 0198): acknowledged when deliver returns nil, negatively acknowledged after NakDelay when it
-// returns an error, terminated when it is not an event at all. The consumers are the controller's to
+// returns an error, terminated when it is not an event at all. The consumers are the mesh's to
 // create; this binds to them and never makes one. Runs until stopped.
 func (c *Conn) ConsumeAs(module string, deliver func(Envelope) error) (func(), error) {
 	durable := ConsumerOf(c.node, module)
@@ -1109,7 +1071,7 @@ func (c *Conn) ConsumeAs(module string, deliver func(Envelope) error) (func(), e
 	}
 	h := newHearing(c, js, module, deliver)
 	// Bound by name, never created and never matched against a subject: the consumer and its
-	// filters are the controller's (design 29 §3), exactly as the module's own runtime bound it.
+	// filters are the mesh's (design 29 §3), exactly as the module's own runtime bound it.
 	events, _, doing, err := h.bind(EventsStream, durable, nil)
 	if err != nil {
 		return nil, fmt.Errorf("%s %s's consumer %s: %w", doing, module, durable, err)