Read memberships from the grants part's state, what the mesh holds from the indexer and placement, and give bundles newest, since and watch on logs, so the tool runner asks the controller for nothing it keeps (issue 1955, ADR 0571 clauses 1, 4, 5, 7)

Pins mesh-sdk bb993dd. The assignments stream stays the membership's
fallback until the lease write; a log another module keeps is read as
<module>.<log>.

node-tools/internal/runtime/runtime.go

@@ -969,9 +969,24 @@ type logAsked struct {
 	From   uint64          `json:"from"`
 	Keys   string          `json:"keys"`
 	Limit  int             `json:"limit"`
+	// Since is a read's or a watch's start as an RFC 3339 time, in place of From (novox/hq ADR 0571).
+	Since string `json:"since"`
 }
 
-// Log answers a bundle's `append`, `read`, `last` and `info` on its module's log (ADR 0297). The runtime
+// since is the asked start time, zero when none.
+func (a logAsked) since() (time.Time, error) {
+	if a.Since == "" {
+		return time.Time{}, nil
+	}
+	at, err := time.Parse(time.RFC3339Nano, a.Since)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("since is an RFC 3339 time (2026-10-29T09:30:00Z), not %q", a.Since)
+	}
+	return at, nil
+}
+
+// Log answers a bundle's `append`, `read`, `newest`, `last` and `info` on its module's log and on a log its module reads
+// as `<module>.<log>` (ADR 0297, ADR 0571). The runtime
 // refuses, with the reason, a log the module was not issued; an append whose `expect` is stale is
 // refused with the code of a lost state update.
 func (b *moduleBus) Log(verb string, params json.RawMessage) (json.RawMessage, error) {
@@ -989,11 +1004,22 @@ func (b *moduleBus) Log(verb string, params json.RawMessage) (json.RawMessage, e
 		}
 		answer = map[string]any{"sequence": seq}
 	case "read":
-		page, err := conn.LogRead(b.module, asked.Log, asked.From, asked.Keys, asked.Limit)
+		since, err := asked.since()
+		if err != nil {
+			return nil, err
+		}
+		page, err := conn.LogRead(b.module, asked.Log, asked.From, since, asked.Keys, asked.Limit)
 		if err != nil {
 			return nil, err
 		}
 		answer = page
+	case "newest":
+		// The newest entry of each key the pattern names (mesh-sdk process.LogReader.Newest).
+		entries, err := conn.LogNewest(b.module, asked.Log, asked.Keys)
+		if err != nil {
+			return nil, err
+		}
+		answer = entries
 	case "last":
 		entry, err := conn.LogLast(b.module, asked.Log, asked.Key)
 		if err != nil {
@@ -1015,6 +1041,26 @@ func (b *moduleBus) Log(verb string, params json.RawMessage) (json.RawMessage, e
 	return json.Marshal(answer)
 }
 
+// LogWatch hands a bundle each entry of a log, `{log, keys, from, since}`: from a sequence, from a time, or with neither
+// each new one, one at a time (novox/hq ADR 0571; mesh-sdk process.LogReader.Watch).
+func (b *moduleBus) LogWatch(params json.RawMessage, deliver func(json.RawMessage) error) (func(), error) {
+	var asked logAsked
+	if err := json.Unmarshal(params, &asked); err != nil || asked.Log == "" {
+		return nil, fmt.Errorf("mesh/log.watch names no log: {log, keys, from, since}")
+	}
+	since, err := asked.since()
+	if err != nil {
+		return nil, err
+	}
+	return b.all.conn.LogWatch(b.module, asked.Log, asked.Keys, asked.From, since, func(e bus.LogEntry) error {
+		raw, err := json.Marshal(e)
+		if err != nil {
+			return err
+		}
+		return deliver(raw)
+	})
+}
+
 // Watch hands a bundle its module's state as it is and as it changes (ADR 0201): `{state, key}`, the
 // key a pattern with `*` and `**`, empty for every key.
 func (b *moduleBus) Watch(params json.RawMessage, deliver func(json.RawMessage) error) (func(), error) {