member-wallet-delay.md is marked built, with a table of where the build chose differently -- most of all that a request carrying no policy still reads, so wallets guarded before policies keep verifying. The member wallets note's "full control" stops saying 12, and its D3 adds that only an open group takes a request; the guardian-delay note's member-wallet row and the README follow. The three-emulator run is still to do by hand. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
31 KiB
The group decides whether it guards members' wallets, and at what delay
A member's guarded wallet carries one leaf for the group that guards it and one
for every group above it. Since guardian-delay.md, each
ancestor's leaf keeps the delay that ancestor chose when it made the group below
it. The group's own leaf, though, is always GuardianDerivation.DEFAULT_DELAY,
12 blocks. The member's device builds the grant without a delay
(MemberWalletManager.kt:193), and every signer recomputes it the same way and
refuses anything else (refuseCertificate, line 518). Nobody chooses the number.
This plan lets the group choose it. The group's quorum signs one standing
statement in its own room: wallets members ask this group to guard carry this
group's leaf at d blocks. A member's device builds its request under the
newest such statement and carries that statement in the request. Every signer
checks that the request's own leaf has exactly that delay, and that the
statement it was built under is the group's newest. Each wallet's delay is
then fixed in its certificate, as every guardian tag already is. A later
statement changes the wallets members ask for after it, and never one already
guarded.
The statement is also the group's opt-in. A group that has never signed one
does not guard members' wallets: the member's group picker says so, and every
signer refuses a request to it. A later statement can close it again with a
closed tag, and from then on the group takes no new member wallets until a
newer statement opens it. Closing never releases a wallet already guarded, since
the group's leaf is in every one of its addresses.
Read member-guarded-wallets.md and guardian-delay.md first. This plan reuses the request, the certificate, the key notice and the signer check from the first, and the delay range, the formatter and the delay chooser from the second.
Built, phases 1-7, one commit each, written against the code as it stood at
05bd6ed6, schema v31, with no schema change. D1 (a group-signed event, not the
birth certificate) was decided before the build; the opt-in (D8) and the
closed tag (D9) were added on review. MemberWalletPolicyEvent,
MemberWalletManager.policyFor and judgePolicy, and MemberWalletPolicyScreen
are the entry points. The phases below are kept as written; where the build
chose differently the table says so.
| what the plan said | what it turned out to be |
|---|---|
Phase 1: verify only |
also read, the shape without the signature, for ProposedEvent: a signer reads a policy before the group has signed it. ORDER is public, for the signers' staleness check |
Phase 4: a POLICY_UNKNOWN refusal |
not built. KEY_UNKNOWN already covers a member who has had no key answer, with its button to ask, and the answer carries the policy. A member whose answer came from a device that held no policy reads NOT_OFFERED until an answer that does arrives |
Phase 4: verified() refuses a request carrying no policy |
it accepts one. Certificates signed before policies embed a request with none, and refusing it would stop every wallet already guarded from verifying. That a new request must carry an open policy is the signers' rule, in judgePolicy |
| Phase 4: set by #Council beside the group's line | not added: the reach sentence already names the group whose delay it is |
| Phase 5: the group page's request row says why | the member's wallet screen does, through MemberWalletRow.refusedBecause and MemberWalletManager.Why. Ask again on a refused request makes a new one under the newest policy with a new key and discards the old -- askAgain takes the member's key and returns the wallet now asked for, and the wallet screen follows it. For a closed group only Discard is offered |
Phase 6: MemberWalletPolicyViewModel holds the input as typed |
in GuardianDelayInput, shared with the subgroup picker, as GuardianDelayChooser is |
| Phase 6: the row shows for every member | for every member of a Marmot group that is not disbanded (showsMemberWalletPolicy); a device that cannot sign sees the state and no button |
| nothing about test fixtures | GroupFixtures.openToMembers: every member-wallet test now opens its group first, since D8 closes a group with no policy |
Still to do by hand: the three-emulator run in Phase 7.
Where the delay should live
The question this plan has to settle first. There are four places a group-level number could be signed, and only one of them is the group's own decision about the group's own leaf.
| place | who signs it | why not |
|---|---|---|
| the group's birth certificate (30329) | the parent's quorum, once, at the group's birth | it is the parent's statement about the child, and the member-wallet delay is the group's decision about its own leaf. The group did not sign it and cannot change it, because a certificate is replaceable only by the parent, and the group's key state carries the one it was born with. A root group has no certificate at all, so the most common group could never set a delay |
| the group's key state (30326) | the group's own quorum | it answers one question, what does this room sign with, and GroupKeyStateManager.stateFrom drops a state that says anything it cannot check. Changing a wallet policy would mean re-signing the room's key state, which every device then re-adopts. The key notice already carries the key, so the delivery advantage is small |
| the group's wallet statement (30331) | the group's own quorum | it opens one account on one network, and only once. A group with no wallet of its own, or a group that guards members on signet and mainnet, has nowhere to put it. It is also immutable for its account by the guardians note's rule 2 |
| a new group-signed event, 30337 | the group's own quorum | recommended. Signed by the group about the group, changeable by the group, and verifiable by anyone holding the room's id, through the same GroupKeyStateEvent.isSignedByRoom check the chronicle and the certificates use |
So the answer to "birth certificate or group signed event" is a group-signed event of its own kind. The birth certificate stays the parent's, and keeps deciding only what the parent decides: whether the group is guarded, and the parent's own leaf's delay in the group's wallet.
The policy event
Two shapes, one kind:
open: kind 30337, pubkey G, content ""
["d", "member-wallets"] addressable: the newest wins
["guardian_delay", "<blocks>"] 6..65,535, GuardianDerivation.DELAY_RANGE
closed: kind 30337, pubkey G, content ""
["d", "member-wallets"]
["closed"]
Exactly one of guardian_delay and closed. An event with both, or neither,
does not read: a group that has said two things about its members' wallets has
said nothing a device can act on, and guessing which it meant would be the device
deciding for the group.
- Signed by
G's quorum through the existing FROST proposal path, like the wallet statement. No new signing machinery. - Newest wins, by the group's own
created_atwith the id breaking a tie, for the reasonGroupWallet.newestAmonggives: two devices that read the same events in different orders have to agree. - No policy means not offered (D8). A group guards members' wallets only once its quorum has said so, and at the delay it said.
- The newest decides, open or closed (D9). Closing and opening again are each one more statement; nothing is ever deleted, and every device agrees on which is newest.
- The
dtag names member wallets, not delay, so a later rule about members' wallets is another tag on the same event rather than another kind.
Why the request carries it
A member's device needs the delay before it builds anything, because the leaf, the tree and both descriptors depend on it. Two kinds of device may not hold the newest policy:
- A member who joined after it was signed. MLS cannot decrypt messages from before a member's welcome, which is the reason the key notice (30336) exists.
- A signer who missed it.
docs/mls-skipped-keys.mddescribes how a group event that arrives a moment late is dropped for good on one device.
So the request carries, whole, the policy event it was built under. Any reader
can check it with G alone. A signer that missed the newest policy then still
judges the request against what the group actually signed. A signer whose newest
is newer than the one carried refuses the request as stale, and the member asks
again. Because the certificate embeds the request, the ancestors can also see
why the leaf has the delay it has.
Phase 0 — decisions, before any code
D1. A group-signed event, not the birth certificate
Decided. Kind 30337, the next free number after the key notice at 30336.
D2. Can the group change it?
Recommended: yes, for wallets asked for afterwards; never for one already guarded. A wallet's delay is in its certificate's guardian tags, and the guardians note's rule 2 fixes an account's guardians, delays included. So a new policy reaches only requests built under it. The screen that changes it says so: Wallets already guarded keep the delay they were guarded at.
D3. What the delay covers
Recommended: the group's own leaf only. Each group above keeps the delay it
chose for the group (guardian-delay D1), so a member's wallet under M, under
the root, reads:
leaf 1 M's own delay from M's newest 30337, or 12
leaf 2 the root's the delay the root chose for M, unchanged
A group cannot shorten the root's wait in its members' wallets any more than in its subgroups'.
D4. One delay per group, not per member
Recommended: one. A group that wants to treat one member differently is asking for a different rule, and a per-member table would be a roster the group signs over and keeps current. The member still chooses whether to ask. If they do not like the group's delay, they do not have to ask that group.
D5. Who may set it
Recommended: any member holding a share proposes, and the group's quorum
decides, like every other event the group signs. The entrance is shown only to
a device that can sign (FrostSigningManager.canSign), as the wallet's Open
button is.
D6. Which request a signer accepts
A signer holds held, the newest verified 30337 it has, or none. The request
carries carried, or none. Recommended:
| carried | held | judged at | otherwise |
|---|---|---|---|
an open 30337 G signed |
none, or one -- open or closed -- not newer than it | carried's delay |
— |
an open 30337 G signed |
a newer open one | — | refused: was asked under a delay the group has since changed |
an open 30337 G signed |
a newer closed one | — | refused: the group has stopped guarding members' wallets |
a closed 30337, or one not signed by G, or unreadable |
any | — | refused: carries a policy this group did not sign open |
| none | any | — | refused: does not say the group guards members' wallets |
The first row covers the signer that missed the group's opening statement, and
the one whose newest is a closing the group has since reversed: the request
carries an open policy G signed, and nothing newer says otherwise, so the
signer is told what it missed rather than refusing it.
The last row is how a request from a build before this plan fails: it carries no policy, so it never asked for the delay the group chose, or for a group that chose to guard members at all. That is the right failure.
D7. Mixed versions
A signer on a build before this plan compares to grantFor at the default,
so it refuses any request whose own leaf is not at 12. That is the safe way to
fail. It is also blind to D8 and D9: it would still sign a request at 12 to a
group that never opened, or has closed, if a member on an older build asked. A
group should open at a delay other than 12, or close, only once every member who
can sign is on a build from Phase 5 onward. The screen says this, because a
device cannot see other devices' versions.
D8. No policy, no member wallets: the statement is the group's opt-in
Recommended. Today any member can ask any group, and the group only agrees when its quorum signs that member's certificate. With D8 the group agrees up front, once, for everybody, and every new member wallet's delay is one its group chose. There is no default any more.
What this changes for groups that exist:
- A group that wants to keep guarding members' wallets signs an open policy once, even to stay at 12. Phase 6's screen offers Guard members' wallets with 12 selected, so that is one tap and a quorum.
- Wallets already guarded are not touched. Their certificates stand; the member still spends, and every guardian still watches. D8 is about new requests.
- A request already asked and not yet signed is refused by D6's last row once the signers update. The member's row says why and offers Ask again, which works once the group opens.
D9. Closing, and opening again
Recommended: ["closed"] on a newer policy.
- Closed means no new member wallets. The member's picker says this group has stopped guarding members' wallets; every signer refuses a request built under an older open policy (D6's fourth row) and puts nothing to the quorum.
- Closed does not release a wallet already guarded. The group's leaf is in every address of every wallet it guards, and no statement can take it out. The group can still take any coin there after its delay, and the screen that closes says so: Wallets already guarded stay guarded. A member who wants out moves their coins to a wallet of their own, which needs nobody's agreement.
- Opening again is a newer open policy, at any delay. It reaches only requests built after it, as every policy does.
- Closing is not a refusal of a person. It is the group's statement about every member at once, and D4 rules out a per-member list for the same reason.
Phase 1 — the policy event, pure
New nostr/wallet/MemberWalletPolicyEvent.kt:
object MemberWalletPolicyEvent {
val KIND: Kind = 30337
const val IDENTIFIER = "member-wallets"
fun open(delay: Long, createdAt: Long = now): EventTemplate // requires DELAY_RANGE
fun closed(createdAt: Long = now): EventTemplate
/** What [event] says, as [chatRoomId] signed it. */
sealed interface Policy {
val event: Event
val createdAt: Long get() = event.createdAt
data class Open(val delay: Long, override val event: Event) : Policy
data class Closed(override val event: Event) : Policy
}
/** [event] as [chatRoomId]'s policy: the kind, the `d`, exactly one of a readable delay or `closed`, signed by the room. */
fun verify(event: Event, chatRoomId: String): Policy?
/** The newest among [events] that verifies, by created_at then id -- open or closed. */
fun newestAmong(events: List<Event>, chatRoomId: String): Policy?
}
verify checks the kind, the d tag, exactly one of a guardian_delay tag that
reads and is in GuardianDerivation.DELAY_RANGE or a bare closed tag, and
GroupKeyStateEvent.isSignedByRoom(event, chatRoomId), all inside runCatching.
Tests, MemberWalletPolicyEventTest, pure:
- an open policy and a closed one each round-trip;
- each of these fails on its own: another kind, a missing
d, two delays,"5","65536","twelve", both a delay andclosed, neither, signed by another room; - of an open, a closed and a second open policy, the newest wins whatever order
they arrive in, and a tie on
created_atgoes to the larger id on every device.
Phase 2 — the group files it, and the transcript says it
The FROST completion path already files every signed event in
GroupSignedEvent (FrostSigningManager.recordSignedEvents), whatever its kind.
This phase reads them:
MemberWalletManager.policyFor(database, G): MemberWalletPolicyEvent.Policy?is the newest verified amongG's stored 30337s and any carried in key-notice answers (Phase 3). It is the one reader, used by the member's device in Phase 4 and by every signer in Phase 5. Null means the group has not opened (D8).ChatMessage.applyInnerEventandapplySignedEventget a 30337 arm that writes one transcript line: The group guards members' wallets, after 144 blocks, about 1 day, or The group has stopped guarding new members' wallets. Without the arm an older build shows a raw-JSON bubble, which is reason to ship this phase before Phase 6's entrance.ProposedEvent.summarizegets a 30337 arm: Members' guarded wallets · this group after 144 blocks, about 1 day · for wallets asked for from now on, or Members' guarded wallets · no new ones · wallets already guarded stay guarded.
Tests: policyFor prefers the newest of an open and a closed policy, either
way round; ignores one signed by another room; returns null for a group that
never signed one. The summary says the delay in both blocks and time, and says
what closing leaves alone.
Phase 3 — the key notice carries it
A member who joined after the policy was signed cannot decrypt it. The key notice already answers that member's other question, what does this group sign with, so it answers this one too:
GroupKeyNoticeEvent.answeringTagsgains["member_wallet_policy", <the newest 30337, whole>]when the answering device holds one, open or closed.readreturns it inGroupKey.policy, verified byMemberWalletPolicyEvent.verify(it, G). A policy present and unreadable makes the whole answer unreadable, as an unreadable certificate already does. It is never read as "no policy".MemberWalletManager.groupKeyForgains the policy, andpolicyForconsiders it beside the stored ones.
Until an answer brings one, a late member's device holds no policy for a group that may well be open. Phase 4's picker therefore tells not known yet apart from not offered: a device that holds no key state and no answer says the first, and offers the existing Ask the group for its key.
Tests: an answer carrying an open policy gives it, and so does one carrying a closed one; one carrying a policy signed by another room does not read; an answer without one reads, with no policy.
Phase 4 — the member builds under it
MemberWalletManager.refusal(database, G, chain) gains three reasons, checked
after the ones it has:
MemberWalletManager.Refusal |
when | what the picker says |
|---|---|---|
POLICY_UNKNOWN |
no key state and no key answer yet, so no policy could be known | Ask the group for its key (the existing button) |
NOT_OFFERED |
the key is known and no policy is | This group doesn't guard members' wallets |
CLOSED |
the newest policy is closed | This group has stopped guarding members' wallets |
So the picker still lists every group, each with why it cannot be chosen, as it does today. A group without an open policy is never offered silently.
In MemberWalletManager.request, which already refuses on any refusal:
val policy = policyFor(database, chatRoomId) as? MemberWalletPolicyEvent.Policy.Open
?: throw IllegalStateException("$chatRoomId does not guard members' wallets")
val grant = GuardianDerivation.grant(
groupKey.thresholdPublicKey, chatRoomId.lowercase(), groupKey.guardians, walletId,
delay = policy.delay,
)
MemberWalletRequestEventgains["member_wallet_policy", <the open 30337, whole>], always. The member's nostr signature covers it, as it covers everything in the request.Reading.verified()gains a sixth check: the carried policy is open, verifies against the request'sh, and the first guardian's delay equals its delay. This is everything a reader can check without knowing the group's newest. The newest is Phase 5's job.MemberWalletManager.delaysOfreads the open policy for the first delay, and is null for a group that is not open. The new-wallet screen already lists each guardian's delay from it (since3b2d9bd8), and gains set by #Council beside the group's own line.
Tests: a request under an open policy at 4,320 has its first guardian at
4,320 and carries the policy; request refuses a group with no policy and one
whose newest is closed; a request whose first delay disagrees with its carried
policy fails verified(), and so does one carrying a closed policy or none.
Phase 5 — every signer checks it
MemberWalletManager.refuseCertificate stops computing the expected grant at
the default. Instead it:
- reads the request out of the certificate, as it already does;
- applies D6's table, with
held = policyFor(database, G)andcarriedfrom the request, to get the delay or a reason to refuse; - compares the certificate's guardians to
SubgroupManager.grantFor(database, G, K_G, W, delay), which since guardian-delay Phase 6 takes the own leaf's delay. The keys, their order and every inherited delay are checked exactly as before.
MemberWalletManager.putToGroup runs the same check before it proposes, as it
already runs refuseCertificate. A sponsor is then never asked to put to the
quorum a request their own device knows is stale, or asks a closed group.
The member's request row on the group page (Asked by @alice, not yet signed) reads the same reasons:
- asked under an older delay: offers the member Ask again, which builds a new request under the newest open policy, with a new key;
- the group has stopped guarding members' wallets: offers Discard, and says Ask again will be possible if the group opens again;
- does not say the group guards members' wallets, a request from before this plan: offers Ask again once the group has opened.
Either way the old request's key is discarded, because no address was ever offered.
Tests, MemberWalletSigningJvmTest: every row of D6's table, through
refuseCertificate; a signer that missed the opening policy accepts a request
carrying it; a signer holding a newer closed policy refuses a request carrying an
older open one; two signers with different held policies agree once the request
carries the newer one.
Phase 6 — the group opens it, sets it, and closes it
Phases 5 and 6 ship together (see the order table): once signers refuse a request with no policy, a group needs this screen to open.
The entrance. On ChatRoomDetailScreen, in Members' guarded wallets, a
first row for every member, in one of three states:
Guards members' wallets after 144 blocks, about 1 day [Change]
Doesn't guard members' wallets [Guard members' wallets]
Stopped guarding new members' wallets [Guard members' wallets]
The buttons are shown only where the device can sign (D5); everybody sees the
state. Every button opens MemberWalletPolicyScreen, a pushed screen with a
NavigateBackButton, which holds:
GuardianDelayChooser, moved out ofSelectSubgroupAdminsScreenintoui/composable/widgets/GuardianDelayChooser.kt, with its presets, its custom field and its livedelayText, starting at the group's current delay, or 12 for a group opening for the first time. Its words are passed in, because the subgroup and the member differ;- D2's line: Wallets already guarded keep the delay they were guarded at;
- D7's line: Members whose app is older than this one can only be guarded at 12 blocks, and don't know this group can close;
- Ask the group, which proposes an open 30337 at the chosen delay through
FrostSigningRepository.proposeSigningand goes toFrostSigningRoute, as opening a wallet does; - on an open group only, Stop guarding new wallets, an
OutlinedButtonunder it, which first asks in a dialog -- Stop guarding new members' wallets? Wallets already guarded stay guarded, and this group can still take their coins after the delay. -- and then proposes a closed 30337 the same way.
A view model, MemberWalletPolicyViewModel, holds the input as typed, refuses a
delay below 6 or above 65,535 blocks with the reasons the subgroup picker
already uses, does not propose the delay an open group already has, and does not
propose closing a group that is not open.
The member's own leaf is the group's, and the trade the subgroup picker states applies here too, said for a person: A coin the member moves starts waiting again, so a long delay lets them keep their coins out of reach by moving them.
CLAUDE.md applies in full: strings in the catalogue in sentence case, spacing
from MaterialTheme.spacing, the screen's four states, and the outcome reported
through rememberNotifier.
Tests, MemberWalletPolicyViewModelJvmTest: a group opening for the first
time starts at 12; an open group starts at its delay; a preset and a typed delay
are what it proposes; out-of-range delays are refused with their reasons;
proposing the current delay is refused; closing is offered only to an open
group, and proposes a closed policy.
Phase 7 — docs, and checking it on the emulators
- member-guarded-wallets.md: What "full control" means stops saying 12 and links here; D3 (which members may ask) gains and only of a group that has opened. The request's tag list gains the policy.
- guardian-delay.md: its build table's member-wallet row ("a group still cannot choose…") points here.
- README.md: this note's row.
- This note: Built, and a table of where the build chose differently.
By hand, regtest, three emulators: Alice (a signer), Bob (a signer), and Carol, who joined the group after step 2.
- Carol's picker, before anything, says This group doesn't guard members' wallets.
- Alice and Bob open the group at 144 blocks. The transcript says so on the devices that were in the room.
- Carol joins. Her picker says the group's key is not known yet; she asks; the answer carries the policy; her screen says after 144 blocks, about 1 day.
- Bob puts Carol's request to the group. Both signers accept it, and the certificate's first guardian tag says 144.
- Alice and Bob change the delay to 1,008. Carol's wallet still says 144. A new request from Carol is built at 1,008.
- Alice and Bob close the group. Carol's picker says stopped guarding; a request she built before the close is refused by both signers; her wallet at 144 is still guarded, and Alice can still take a coin from it after 144 blocks.
- Alice and Bob open it again at 6. Carol can ask again, at 6.
- A request built on an older build (12, no policy) is refused by both signers, with does not say the group guards members' wallets.
./gradlew :composeApp:compileDebugKotlinAndroid :composeApp:jvmTest
./gradlew :composeApp:m3Audit
Order and size
| phase | touches | ships |
|---|---|---|
| 1 | MemberWalletPolicyEvent and its test |
dark: a kind nothing produces |
| 2 | policyFor, the transcript and summary arms |
dark, and should ship early: an older build shows a raw-JSON bubble for a 30337 it has no arm for |
| 3 | the key notice | dark |
| 4 | the request, the picker's refusals | with 5 and 6: from here a member can ask only an open group |
| 5 | the signers' check | with 4 and 6: from here signers refuse a request to a group that has not opened |
| 6 | the entrance and the screen | with 4 and 5: the only way a group opens |
| 7 | docs and the emulator run | last |
Phases 4, 5 and 6 are one release. Under D8, Phases 4 and 5 stop every group taking new member wallets until it opens, and Phase 6 is how it opens. Shipped apart, the member's picker would say doesn't guard members' wallets about every group, with no way for any group to say otherwise. Shipped together, an existing group loses nothing but one quorum: the first time anybody wants a new member wallet from it, a signer opens it at 12. The release note should say so, since for a few days every group will read doesn't guard members' wallets until somebody opens it.
No schema change. Policies are GroupSignedEvent rows like every other event
the group signs, and the request already keeps its event whole.
What this does not do
It does not change a wallet already guarded (D2). A different delay is a new request, with a new key.
Closing does not release a wallet (D9). The group's leaf is in every address of every wallet it already guards, and the group can still take a coin from one after its delay. Closing stops new wallets, and nothing else. Releasing a member's wallet would need the member to move their coins somewhere the group holds no leaf, which they can do alone at any time.
It does not open groups that existed before it (D8). Each group's quorum opens it, once. Nothing opens a group on its behalf, because the point of D8 is that a group guards members' wallets only once it has said so.
It does not let the member choose. The member chooses whether to ask, and sees the delay before they do. A member who wants a longer delay than the group offers asks a different group, or asks this one to change it.
It does not set the subgroup picker's default. A group making a guarded subgroup still chooses that subgroup's delay on the picker, starting from 12. Using the member-wallet policy as the picker's starting point is a one-line follow-up, and it is left out so that the policy means one thing.
It does not reach a group's ancestors. The root's delay in a member's wallet
under M is the delay the root chose for M (D3). A root that wants a
different wait in its descendants' members' wallets sets it when it makes the
group below it.
Appendix — what was considered and rejected
| idea | why not |
|---|---|
| a tag on the group's birth certificate | the parent's statement, not the group's; fixed at birth; absent for a root group (see Where the delay should live) |
| a tag on the group's key state | re-signing what the room signs with to change a wallet rule, and every device re-adopting it |
| a tag on the group's wallet statement | one per network and account, immutable, and absent for a group with no wallet of its own |
| the member chooses, within a range the group sets | asked for as the group sets the delay; a range is a second number to sign and explain, and can be added later as a second tag on the same event |
| signers judge only by the policy they hold | a signer that missed the newest policy would refuse a correct request, and two signers holding different ones would never agree on the same request |
| a per-member delay | a roster the group signs and keeps current (D4) |
| no policy means guard at the default, 12 | the first draft of this plan. It made every group a guardian of any member who asked until its quorum refused, and made the closed tag an opt-out from something no group had opted into (D8) |
| a separate kind to close | two kinds to order against each other; one addressable kind whose newest says open or closed has one answer on every device (D9) |
| deleting the policy to close | a signed event is never deleted on other devices, and an absence cannot be told apart from a member who never received it |