CPP13 — ref counting ambiguous?

For servant reference counting, the words "at least once" appear
in a number of places when it comes to servant activation. set_servant(),
activate_object(), activate_object_with_id(), servant_to_id(),
servant_to_reference(), and _this() all use this language (pages 1-137 and
1-138):

... will invoke _add_ref at least once on the Servant argument...

Problem: suppose my ORB calls _add_ref() twice in each of these operations
for some reason. I now have a problem. That's because, for servant
activators, responsibility for calling _remove_ref() passes to
etherialize(). However, if the ORB is permitted to call _add_ref() as
many times as it likes, I have no idea how many times I have to call
_remove_ref() from within etherealize(). I think that the spec should say
that _add_ref() is called exactly once for these operations if the
corresponding servant is not in the AOM already.

I vaguely remember the discussion about optimization of the calls
to _add_ref() and _remove_ref(). I think the idea was to permit the ORB
to avoid redundant calls. However, it seems that the language in the spec
isn't precise enough. Under one interpretation, the refcount counts
the number of entries in the AOM. Under another interpretation, it counts
the number of calls in progress as well (because an ORB could call _add_ref()
when a call is dispatched and call _remove_ref() when it finishes).
Under yet a third interpretation, the refcount counts the number of
object references in my address space. That interpretation is happens
if every call to _this() calls _add_ref()...

The language is not precise enough, I think...