docs/scripts/giza-rename.sh, run over the moves of Phase 3a:
- com.machankura.bennu.{compose,android,desktop} -> mobi.giza.{...}, in
package lines, imports, fully qualified references, the manifest, mainClass,
the Android namespace (one value with applicationId again), the m3Audit
source path, the six docs/scripts tools, and the source links in docs/;
- Res moves from bennu.composeapp.generated.resources to
mobi.giza.compose.resources, now pinned with packageOfResClass so a later
rename of the root project leaves the imports alone;
- BennuDatabase, BennuTheme and the other eleven Bennu identifiers are Giza*.
The script's search is now the same pattern as its sed expressions, so on a
renamed tree it finds nothing and changes nothing.
Checked against the Phase 0 baseline: jvmTest 1643 run (1642 + AppDirJvmTest),
0 failed, 2 skipped; compileDebugKotlinAndroid passes; m3-audit prints the
baseline report line for line. iOS is not compiled on this Linux host.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
32 KiB
Resending a signing session
A proposer can ask the group to sign something and never hear back from a member
who would have agreed, because the message asking them never arrived. Today there
is nothing to do about it. The session sits in COLLECTING_NONCES until somebody
abandons it and proposes afresh, and the member it was waiting on never knew they
were being waited on.
This is the plan for a resend: the proposer re-publishing what they authored for a session, and — the half that is not obvious — the silent member republishing what they authored, because the proposer cannot do it for them and must not be able to.
Read docs/mls-skipped-keys.md first. It documents the
failure that makes this necessary and ends with the sentence this plan is a reply
to: "nothing asks the sender to resend."
The problem
"Missed it" is five different things, and only some of them are a resend's business.
| why a member has nothing | does a resend help? |
|---|---|
| offline, and the relay still holds the kind:445 | no — ordinary sync catches up |
| MLS skipped keys: the group event decrypted to nothing | yes, and nothing else does |
| NIP-40 expiration: a disappearing-message group dropped it off the relay | yes, and nothing else does |
| the member's read relays never had it | yes |
| the member was not in the room when it was sent | yes |
| the session already failed | no — fail already says "it is safe to ask again" |
The second row is the one that forces the feature. From the skipped-keys doc:
the key is derived from a ratchet that has moved past it and cannot be recovered
Terminal at the receiver, invisible to the sender, and the doc's own worked
example is this exact flow — a FROST proposal lost to it, leaving the proposer's
nonce filed against a session that will never exist. MlsGroupCache narrows the
window; it does not close it, and a restart or another writer reopens it.
A resend fixes it because a resent message is a new application message at a new generation. The old generation's key is gone; the new one is derivable. The same is true of the expiration case: a fresh event carries a fresh expiry.
What is safe to resend, and what is not
Every kind in a session has a direction, and the direction decides whether a resend is even meaningful.
| kind | author | who must actually receive it | proposer can resend? |
|---|---|---|---|
30320 PROPOSAL |
proposer | every share holder | yes |
30321 NONCE |
a signer | only the coordinator | no, and not needed |
30322 SIGNER_SET |
coordinator | the chosen signers | yes |
30323 PARTIAL_SIGNATURE |
a signer | only the coordinator | no, and not needed |
30324 SIGNATURE |
coordinator | every share holder | yes |
30325 FAILURE |
anyone | everyone | n/a — the session is over |
30330 DECLINE |
a share holder | every share holder, for the count | no — see below |
The third column is read off the code, not guessed. orderedNonces and
orderedPartialSignatures are both called under session.isCoordinator();
nothing else in advance reads another member's nonce or partial. A non-coordinator
device uses other members' nonces for exactly one thing — the "Ready to sign" row
in FrostSigningUIState.offeredNonce — which is cosmetic.
So the parenthetical in the request is the right answer. A nonce is a signal only the proposer needs, and the proposer already has it, which is how they know the member is not silent. There is nothing to resend.
Receiver-side idempotence already holds
A resend is only cheap because every arm of record is already write-once. This is
an audit of the gates, not a wish list; each one is a line that exists today.
PROPOSAL→acceptProposalfinds the session, compares the proposed ids against the storedFrostSigningItem.eventIds, finds them equal, returns the existing session. No write, no log line.SIGNER_SET→isFromCoordinator, thenif (current(database, session).signerIds != null) return true.SIGNATURE→if (isSigned(database, session)) return true.NONCE/PARTIAL_SIGNATURE→ upsert keyed on(sessionId, signerPublicKey, kind);knownis true, so no second transcript line.DECLINE→recordDeclinerecomputes atoSet()count;failhas its own already-settled guard.
publishOwn already states the policy this plan generalises:
A crash between the two therefore costs a duplicate broadcast — which every receiver folds away
No protocol change is required for the proposer to resend its own messages. That is the whole of Phase 2.
Why the proposer cannot resend another member's message
Three reasons, in increasing order of seriousness.
It would be filed under the wrong author. record writes
FrostSignerMessage(signerPublicKey = innerEvent.pubKey, …). A forwarded copy is
authored by the forwarder, so a nonce the proposer relayed on Bob's behalf is filed
as the proposer's nonce, overwriting their own. On Marmot there is no way around
this: MIP-03 rejects an inner event whose pubKey is not the MLS sender's identity,
and docs/marmot-direct-messages.md describes the single carve-out that exists and
why it is narrow.
For a decline it is a forgery primitive. recordDecline counts distinct
signerPublicKeys against declinesThatAbandon(). A proposer who could relay a
decline under their own key would be able to manufacture refusals; in an n-of-n
group one is enough to abandon a session nobody refused. Forwarding would have to
carry a signature over the original, verified before counting — a new envelope kind,
new verification code, and a new way to get it wrong, to deliver a message that
nobody but the coordinator needed in the first place.
For the proposal it is already load-bearing. acceptProposal sets
coordinatorPublicKey = innerEvent.pubKey for a session it has never seen. A
non-coordinator who resends the proposal to a member with no session row makes that
member believe the resender coordinates — and that member will then drop the real
coordinator's signer set through isFromCoordinator. Resend is coordinator-only,
and the restriction is correctness rather than etiquette. (A member could already
mint a proposal under someone else's session id today; resend does not widen that,
but it must not make it a routine code path either.)
The half the request is actually about
The request asks whether the proposer needs to resend a member's availability signal. It does not, but there is a real gap hiding behind the question, and it is the mirror image:
A nonce lost on the way to the proposer is a permanent stall, and no device will ever republish it.
advance republishes a message it has no local copy of — if (ownNonces == null).
Bob's device, having published and recorded its nonce, will never send it again,
however long the proposer waits. The member who can fix it is Bob, and Bob has no
way to know.
So the resend has two halves:
- the proposer republishes what the proposer authored (Phase 2), and
- the resent proposal names the members the proposer has not heard from, and a named device republishes what it authored (Phase 3).
Half 2 is what the request is reaching for, reached from the only side that can author the message. It needs no forwarding, no new envelope and no signature checking, because every message still travels under the key that made it.
Phase 1 — a tag for the silent set
FrostSilentMembersTag, in nostr/frost/tags/, following FrostSignerIdsTag
exactly: a TAG_NAME const, parse/assemble, and all-or-nothing parsing because
a partially-read list is a list naming the wrong people.
const val TAG_NAME = "frost_silent"
Hex pubkeys, comma separated, in tag[1]. An entry that is not 64 hex characters
invalidates the whole tag.
FrostSigningEvents.assembleTags grows a fourth optional parameter:
fun assembleTags(
sessionId: String,
dkgSessionId: String? = null,
signerIds: List<Int>? = null,
silentMembers: List<HexKey>? = null
): Array<Array<String>>
and a parseSilentMembers beside the other three parsers. broadcast gains a
matching optional parameter and passes it through.
Why a tag on the proposal rather than a kind of its own. A bare nudge reaches a
device with no session to apply it to and is dropped —
getSessionById returns null and processSigningPayload logs "leaving it stored".
That is exactly the device we are trying to reach. The member who is silent is
overwhelmingly silent because they never got the proposal, so the nudge and the
thing they are missing have to travel in one message or the common case is not
fixed. See the appendix for the kind-30331 version and why it loses.
It is invisible to the id check. acceptProposal rebuilds the signed events from
innerEvent.content; the carrier's tags are not part of any id. Adding a tag cannot
change what a signer is putting their share behind.
It leaks nothing. On Marmot every nonce is a group event the room already saw; on NIP-17 every member is p-tagged on every message. Who has signalled is not a secret the tag gives away.
The silent set comes off the ceremony, not the room. signerIds(database, key).keys
minus everyone with any FrostSignerMessage for the session — the same source
recordDecline counts against and observeShareHolders draws. The room's roster is
wrong twice over, for the reasons FrostSigningUIState.Loaded.members already gives:
it can hold members added after the key was made, and a subgroup's ceremony room is
the parent.
Phase 2 — the proposer resends what it authored
suspend fun resend(
database: GizaDatabase,
localChatRoom: LocalChatRoom,
sessionId: String
): Boolean
Returns whether anything went out, so the caller can say so.
Refused unless it is this device's session to resend. session.isCoordinator(),
for the acceptProposal reason above. Refused for FAILED — nothing can be
resent into a dead session and fail already tells the group to ask again — and
refused for a session whose items are empty.
It sends the minimum the stage requires, which is at most two events:
| stage | what goes out |
|---|---|
COLLECTING_NONCES |
the proposal |
COLLECTING_PARTIAL_SIGNATURES |
the proposal, then the signer set |
COMPLETE |
the proposal, then the signature |
FAILED |
refused |
The proposal goes in every case because a device with no session row cannot apply
anything else: a signer set naming ids it has no items for, or a signature over
events it has never seen, are both dropped. COMPLETE is worth resending rather
than skipping — a member who never received the signature never ran complete, so
the signed events were never applied to their local store.
The proposal's content is FrostSigningEvents.encodeProposal over the stored
items' unsignedEventJson. Re-serialising is safe: the receiver compares rebuilt
ids, and an id is over the canonical form, so any JSON with the same fields hashes
the same. A batch of one must still go out as a bare object — encodeProposal
guarantees it, and decodeProposal dispatching on a leading [ is why it matters.
Two hazards worth naming before writing the code
The id collision. broadcast derives the queue row's primary key from
EventHasher.hashId(pubKey, createdAt, tags, content, kind) with createdAt in
whole seconds. A resend whose content, tags and second all match the original
produces the same id, and @Upsert then replaces the sent row with an
unsent one: marmotGroupEventId goes back to null, the already-delivered event is
queued a second time, and its mapping to the group event it became is lost. The
cooldown in Phase 4 makes this improbable; it must not be the only defence.
broadcast should refuse to overwrite a row whose marmotGroupEventId is already
set, and the resend path should carry createdAt forward a second at a time until
the id is unused. Worth a test of its own.
The burst. Resending two events back-to-back recreates precisely the condition
the skipped-keys bug needs. MlsGroupCache covers a burst decrypted in one sync,
which is what makes proposeSigningBatch's own two-message burst work today, so
the mitigation is the existing one — send in protocol order, in one pass, and do not
add a third event. It is the strongest argument for the stage table above being a
minimum rather than "send everything".
Transport
broadcast already knows the difference and needs no new branch for Marmot: one
group event reaches everybody, and every receiver folds the duplicate away, which
is cheaper than one message per silent member and tells the room nothing it does not
already know.
NIP-17 names everybody too, and the reason is worth getting right because the
first version of this got it wrong. On that transport the p-tag set is the
room's identity, not a recipient list. A receiver works out which room a payload
belongs to by hashing the sender together with the p-tags —
GiftWrapPayload.aggregatedParticipantsPublicKey, via ChatRoom.deriveChatRoomId
— so leaving a member out changes the id, and the resend is filed under a room
that does not exist. getOrCreateChatRoom then mints that room rather than
rejecting it, which turns a repaired session into a phantom conversation in the
reader's list.
There is no saving to trade against that, either: sealGiftWrapPayload wraps for
every participant of the room it looks up, not for the p-tags it was handed, so a
narrowed payload costs exactly as many wraps as a full one. Who a resend is for
travels in frost_silent, which is not part of the hash. This is the first
signature a group makes, on gift wraps, per GroupKeyStateManager.propose.
Phase 3 — a named member republishes what it authored
In processSigningPayload, after the session is in hand and before advance:
if (FrostSigningEvents.parseSilentMembers(innerEvent.tags)
?.contains(session.userPublicKey) == true &&
isFromCoordinator(session, innerEvent)
) {
republishOwn(database, localChatRoom, session)
}
republishOwn re-broadcasts this device's own stored FrostSignerMessage rows for
NONCE, PARTIAL_SIGNATURE and DECLINE — the stored bytes, never regenerated.
They are byte-identical by construction, so they cannot produce a second aggregate,
and reading the row avoids k native SecretNonce.generate calls to arrive at the
same answer.
Three constraints, each of which is a rule that already exists somewhere else:
Only from the coordinator. A member who could name another member as silent could make them republish on demand. It changes nothing on the wire — the bytes are the same ones already sent — but it is a publish anybody could trigger, and that is not a thing to leave lying around.
Nothing new is published. republishOwn sends only what is already on file. A
device with no FrostSignerMessage of its own sends nothing and falls through to
advance, which does what it has always done: ask whether the owner has decided,
and if they have not, write the approval request and stop. A message from the
proposer must never be able to talk a device into publishing a nonce its owner has
not approved — that is acceptProposal's "Publishes nothing" rule, and the gate
that enforces it is advance's if (session.signApprovedAt == null), untouched.
Once per delivery. A redelivered resend has the same inner-event id and is deduplicated upstream; a second resend from the proposer is a new id and will republish again, which costs a duplicate everybody folds away. The Phase 4 cooldown bounds how often that can happen.
What this fixes, concretely
- Bob approved, published a nonce, and the proposer never got it. Bob is named,
republishes the same bytes, and the proposer's
orderedNoncesfinds a quorum. - Bob approved and his device died before
publishOwnqueued anything. Today the resent proposal alone already fixes this, becauseacceptProposal→record→advancere-enters theownNonces == nullbranch. Worth knowing: part of the fix is free. - Bob declined and the refusal was lost. He republishes it, and every device's count converges on the same arithmetic instead of waiting on a member who has answered.
- Bob never saw the proposal at all. He sees it now, and
announceApprovalNeededputs the request in his transcript.
Phase 4 — schema 24 → 25: resentAt
Landed with Phase 2 rather than after it: resend needs the column for its
cooldown, and writing it twice to keep the phases apart would have been
ceremony.
A nullable Instant? on FrostSigningSession, written by resend:
/**
* When the coordinator last re-published this session, or null if never.
*
* Two jobs. It is the cooldown -- a resend is a publish, and a button that
* publishes on every tap is a button that fills a room with duplicates. And it
* keeps a second resend from landing in the same second as the first, where the
* queue row's id is a hash over `createdAt` and a collision un-sends the
* message it collides with.
*/
val resentAt: Instant? = null
AutoMigration(from = 24, to = 25) with the comment the others carry, and the
generated composeApp/schemas/25.json committed. Nothing is backfilled: a session
that has never been resent reads null, which is what every session before the column
was.
A cooldown of five minutes, as a const on the manager beside MAX_BATCH_SIZE,
with the reasoning on it. resend returns false inside the window rather than
throwing; the screen disables the button and says when it may be used again.
The alternative — deriving the last resend from the TYPE_FROST_RESENT transcript
row — needs no migration but makes the manager read the chat table to decide a
protocol question, and makes a user-deletable row load-bearing. The column is
cheaper than that.
Phase 5 — the transcript
ChatMessage.TYPE_FROST_RESENT = "frostResent", added to the frost block and to
FROST_TYPES (whatever the rendering set is called where TYPE_FROST_DECLINED
appears), with the house comment explaining why it is its own type: it is not a
protocol step, it is the proposer knocking, and the ladder should show that the
knock happened so a second one is visibly a second one.
The line is the announce shape the other frost lines use, with the actor as the
coordinator:
asked the 2 members who have not answered to take another look.
Named rather than counted when there are few, for the reason FrostSigningScreen
already gives — "1 of 2" does not tell anyone whose door to knock on. Written
once per resend, which resentAt makes true.
A resent message must not write a second step line. That is already how it
works: announceStep is called from publishOwn and record only when known is
false, and resend calls broadcast directly rather than publishOwn — which is
also why resend must not be routed through publishOwn, whose whole job is to
record a local copy that already exists.
Phase 6 — repository and view model
FrostSigningRepository grows one method, documented with the directionality that
makes it one method rather than two:
/**
* Re-publishes the messages this device authored for a session, for the members
* it has not heard from.
*
* Coordinator only, and a resend of *this device's* messages only. A member's
* nonce is read by nobody but the coordinator, who already has it; and a message
* relayed by somebody else would be filed under the relayer, which for a refusal
* is a way to manufacture one. What the resend does for a silent member is name
* them, so their own device republishes what it already said.
*
* Returns false when there was nothing to do: not the coordinator, already
* failed, nobody silent, or inside the cooldown.
*/
suspend fun resend(localChatRoom: LocalChatRoom, sessionId: String): Boolean
NO_OP_FROST_SIGNING_REPOSITORY returns false. DatabaseFrostSigningRepository
delegates to the manager, as its other methods do.
FrostSigningUIState.Loaded gains two derived values rather than two fields:
/** Share holders this session has heard nothing from. Whose door to knock on. */
val silent: Set<HexKey> get() = shareHolders - offeredNonce - signed - declined
/** Whether this device may knock: it proposed, the session is open, somebody is quiet. */
val canResend: Boolean get() = …
silent is already computable from what the view model collects — offeredNonce,
signed, declined and shareHolders are all there — so the screen needs no new
flow. FrostSigningViewModel gains a resend(onDone:) on the approve/decline
pattern, guarded by the same isActionPending.
Phase 7 — UI
The affordance belongs on FrostSigningScreen, below the member list and above the
approval block, in a section the coordinator alone sees. The member list is already
the screen's answer to "whose door to knock on"; this is the knock, and it goes
where the doors are.
if (state.canResend) {
HorizontalDivider()
Text(
text = stringResource(Res.string.these_members_have_not_answered),
style = MaterialTheme.typography.bodySmall
)
Button(
enabled = !frostSigningViewModel.isActionPending.value,
onClick = { frostSigningViewModel.resend { notify(resent) } }
) {
Icon(Icons.Default.Send, contentDescription = Decorative)
Spacer(modifier = Modifier.width(MaterialTheme.spacing.space125))
Text(stringResource(Res.string.ask_again))
}
}
Per CLAUDE.md, and each of these is enforced by ./gradlew :composeApp:m3Audit:
- strings in
composeApp/src/commonMain/composeResources/values/strings.xml, in sentence case:asked_again,one_member_has_not_answered,members_have_not_answered,asked_again_recently,everyone_has_answered_this_session. The count interpolates as%1$s, which is what the catalogue's other counted strings use.ask_againwas already there for re-querying a list's relays and means exactly this, so it is reused rather than duplicated — two keys with one label is how a translator comes to pick two different words for one idea. - spacing from
MaterialTheme.spacing; no.dpliteral in a spacing position. - the icon is beside its label, so
contentDescription = Decorative— decided, notnull. - the outcome goes through
rememberNotifier(rememberCoroutineScope()), with thestringResourceread above the handler, sinceonClickis not composable. - no new state branch: the screen keeps its four, and this sits inside
Loaded.
ProposalListScreen gets nothing. A resend is a decision about one session made
while looking at who has answered, and the list shows neither.
Within the cooldown the button is disabled with a supporting line saying so, rather than hidden — a control that vanishes after a tap reads as a control that failed.
Phase 8 — the tests
FrostSigningResendJvmTest, on FrostSigningDeclineJvmTest's harness: a 2-of-3
Frost.trustedDealerKeygen, a room at SharedKeyDerivation.marmotGroupId, and its
openDevice / propose / proposalArrivedAt / receive / queued(kind) helpers.
That test is already a two-device simulation over one real database, which is what
this needs.
The properties, each one a thing that would otherwise be found in a group:
- A resend reaches a device that missed the proposal. Propose on Alice, never deliver, resend, deliver the resent proposal to Bob: Bob has a session and an approval request. This is the skipped-keys case.
- A resend is idempotent on a device that has the session. Deliver the proposal,
approve, then deliver the resend: the item ids are unchanged, no second
transcript line, no second nonce row, and
signerIdsunchanged once set. - A named member republishes their nonce. Bob approves, his nonce is dropped, the proposer resends naming Bob, and Bob's device queues the same payload a second time. Assert byte equality against the first — a different nonce for the same message against two aggregates is the share extraction the whole design forbids.
- A named member who has not decided publishes nothing. The strongest test here.
Bob is named without having approved: nothing is queued, and
isAwaitingApprovalis still true. - A named member republishes their refusal, and counts converge.
- A non-coordinator cannot resend, and a resend tag from a non-coordinator is ignored.
- A resend of a
FAILEDsession is refused, and nothing is queued. - Two resends in the same second do not collide. Two ids, both rows unsent, the first not reverted. The hazard from Phase 2.
- The cooldown holds: the second call inside the window returns false and queues nothing.
A pure commonTest for FrostSilentMembersTag round-tripping, beside
FrostProposalCodecTest: an empty list, a malformed entry invalidating the whole
tag, and an unknown tag surviving assembleTags/parse untouched.
Then the project's two gates:
./gradlew :composeApp:m3Audit
./gradlew :composeApp:compileDebugKotlinAndroid :composeApp:jvmTest
One unrelated 5-second-timeout failure per full jvmTest run is a known flake;
re-run the suite alone before investigating.
Rollout and compatibility
Nothing here is a wire break, and that is by design.
A build predating this plan receiving a resent proposal reads an unknown
frost_silent tag, ignores it, and runs acceptProposal — which either creates the
session it was missing or returns the one it has. The half that matters works on
old builds without a change. Only the republish-when-named half needs both ends.
A build predating this plan receiving a resent signer set or signature applies them if it was missing them and hits its own write-once gate if it was not. Both behaviours are today's.
An old coordinator never resends, which is today's behaviour exactly.
The one ordering constraint: Phase 1's tag must ship no later than Phase 2, because a resent proposal with no silent tag is a resend whose second half silently does nothing. Phases 4 through 7 can land after, and Phase 8's tests should land with the phase they test rather than at the end.
What landing it turned up
Two things worth recording, both of them in broadcast and neither of them about
resend as such.
The id collision was real, and the guard needed a second half. broadcast
now steps past a taken id rather than upserting over it, and returns whether it
queued anything. That return is load-bearing: publishOwn writes the local copy
that stops [advance] from publishing a message again, so a broadcast that
queued nothing must record nothing, or the group waits forever on a message that
never went out. The comment on publishOwn had the trade written down in one
direction only.
Narrowing the recipients is not something this transport allows, and the test
meant to prove it instead encoded the bug. A resend was narrowed to the quiet
members, with a passing test asserting the p-tags were narrowed. Both the code and
the test were wrong about what a p-tag is for: on NIP-17 the set is hashed into
the room id a receiver files the payload under, so a narrowed resend would have
landed in a room nobody is in — and getOrCreateChatRoom would have created it.
Found by asking whether the change was backwards compatible. It was; this was
never a compatibility bug, it broke old and new receivers identically.
The lesson is narrower than "assert behaviour, not bytes". The p-tags are the right thing to assert — they just mean something other than what they look like, and the assertion needed to be that they do not change.
What this does not do
- It does not retry automatically. See the appendix.
- It does not resend another member's message, and cannot be extended to without a signed forwarding envelope. The appendix says why that is not worth building.
- It does not recover a failed session. A retry is a new batch, always:
proposeSigningBatch's own notes say why, anditemsOvermints fresh nonce seeds so a retry is a new session by construction. - It does not change the quorum arithmetic. A resend publishes nothing new and
counts nothing twice;
declinesThatAbandonis untouched. - It does not help a member who holds no share. They were never in the session.
signerIds(database, key)is the list, for the reasonFrostSigningUIState.Loaded.membersgives. - It does not fix the skipped-keys bug. It is a recovery for it, driven by a
person who noticed. The fix is in quartz, and
docs/mls-skipped-keys.mdhas it.
Appendix — what was considered and rejected
A resend kind of its own (30331). Cleaner to read, and it could nudge without
re-sending a proposal carrying up to MAX_BATCH_SIZE events. It loses on the common
case: a bare nudge arriving at a device with no session for it is dropped —
getSessionById returns null, processSigningPayload logs "leaving it stored" —
and that device is the one we are trying to reach. It would also be unrouted by any
build predating it, since ALL is what the inbound path dispatches on, which is the
same degradation the decline kind at 30330 documents. If the proposal's size ever
becomes the binding cost, the nudge can be added alongside the resent proposal
rather than instead of it.
Forwarding another member's message in a signed envelope. Technically possible:
wrap the original event, verify the inner signature before record files it under
the inner author. Rejected on cost against benefit. It is new verification code on
the path that decides whether a refusal counts — see the forgery note above — and it
exists to deliver nonces and partial signatures that nobody but the coordinator ever
needed. The coordinator already has them. Naming the silent member and letting their
own device speak costs one tag.
Automatic resend on a timer. A background publisher that fires on a stalled session. Rejected: it publishes without anybody deciding to, it would write a transcript line per tick in a room whose protocol lines are deliberately one per step, and every amplification bug in the app's history has been something that published on a schedule. A person noticing a stalled session and knocking is the same shape as everything else on this screen. The cooldown column would make a timer straightforward to add later if a group asks for it.
A Marmot direct message per silent member. MarmotInnerEvent has
directMessageRecipientPublicKey and it would work. Rejected twice over: it is m
events where one does, and per docs/marmot-direct-messages.md every member of the
group sees that a private message was sent and to whom — so a nudge would read as a
side channel in a room where the nudge is public information anyway.
Narrowing the resend to the silent set. Tried, landed, and reverted. On Marmot there is nothing to narrow — a group event is encrypted to the group and names nobody. On NIP-17 it is actively wrong: the p-tag set is what a receiver hashes into the room id, so a narrowed resend lands in a room that does not exist, and it buys nothing anyway because the sealer wraps per room participant rather than per p-tag. See the transport note in Phase 2.
Resetting the queue row instead of writing a new one. @Upsert of a
MarmotInnerEvent with marmotGroupEventId = null puts an already-sent row back on
the outbound queue, which looks like a free resend. Rejected: it destroys the row's
mapping to the group event it became, which the transcript and
MarmotPublishObligation both read, and it re-sends the old ciphertext's plaintext
at an id that no longer describes a new event. A resend is a new message with a new
created_at, which is also what makes it decryptable at a generation the receiver
has not passed.