How to use SPHINCS+? Based on the NIST submission it looks like the SPHINCS+-256s algorithm comes in at public key sizes of 64 bytes, private key sizes of 128 bytes, and signature sizes of 29,792 bytes.

What I can't seem to locate (or understand from the submission documentation) are implementation details suggesting how to use it.  For that I have the following questions (all specifically for the SPHINCS+-256s algorithms)


How many signatures can you safely get out of it?
Are the signatures one-time use, or can you sign something and have it verified repeatedly without giving up the private key?  (I'm assuming this is the "stateless" aspect, but want to be certain I'm not misunderstanding it.)
Are there any specific caveats involved?


The protocol I'm thinking of implementing with it would be along the lines of:


Publish the public key, signed with a different signature algorithm.
Retain the secret key.
Sign N messages, post signatures and messages publicly for verification.


What I'm trying to avoid would be the one-time signature aspects of most hash-based signature protocols where you sign something, distribute the thing, then post the solution proving you signed it at some later point while simultaneously making it unverifiable to future parties (since you give up the private information in the process of proving the signature belonged to you.)
Most of this was already explained in the comments but let me summarize this.

a) SPHINCS+ as SPHINCS are stateless signature schemes like RSA or (EC)DSA. You can use the secret key to sign a virtually unlimited number of messages. In practice, you can sign up to $2^{64}$ messages with SPHINCS+ ($2^{50}$ for SPHINCS) without allowing any kind of forgery.  

b) Your idea of a one-time signature is wrong. A one-time signature scheme is a signature scheme which allows the user to sign a single (arbitrary) message securely. The resulting signature is a standard signature as you know it from RSA that can be verified by everyone and as often as you want. The limitation of one-time signature schemes is just that you can only use your key pair to sign one message. As soon as you sign two different messages, security drops almost instantly to zero (depends a bit on the setting, but lets ignore this). So, a one-time signature is no interactive protocol. Just think of it as an RSA signature where you are only allowed to use your secret key once.

c) SPHINCS (with and without +) is no one-time signature scheme as a) already states. It internally uses a one-time and a few-time signature scheme. So, you can use it like RSA / (EC)DSA. 

[Details]
If you would use a key pair more than $2^{64}$ times (which is almost impossible if you don't rent a massive server farm that does nothing else than signing messages with the same key pair for the next 20 years or so) security will slowly degrade as the probability of using a few-time signature key pair too often increases.
[/Details]

d) There are no specific caveats involved. As stated above, you can use it like any other signature scheme. (Actually, it follows the NIST call so you can see the requirements there...)

e) As there also seems to be some confusion about stateless vs stateful: The difference between stateless and stateful signature schemes is that stateful schemes require the secret key to change after every signature. So, we should rather talk about a secret key state than a static secret key. The crucial point is, a secret key state must not be used twice. This means, you have to make sure that you do not accidentally reuse it (e.g., back-ups are a problem in this case if you cannot recover the last used state somehow). Stateless schemes are actually the "standard setting", i.e., RSA, (EC)DSA are stateless. For hash-based signatures stateless schemes are not trivial to build. They avoid all this trouble with state handling at the cost of worse performance.