Files
giza-kmp/docs/ceremony-creation.md
T
Kgothatso NgakoandClaude Opus 5.5 0449293963 fix(marmot): a direct message's envelope is opened, not taken for a signing decline
FrostSigningEvents.DECLINE and MarmotDirectMessage.ENVELOPE_KIND are both
30330. Recognising protocol kinds first (ceremony-creation Phase 6) returned
before the direct-message branch, so every direct message in a
current-profile room was dropped unopened. A 30330 that holds a gift wrap is
an envelope; only one that does not is a decline.

ProtocolKindDispatchJvmTest now opens an envelope through
fromGroupEventResult, which no test did before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 18:13:02 +02:00

40 KiB

One place to start a key ceremony

A plan to fix the bug where joining a subgroup's key ceremony could start a second, unrelated one. It also removes the nip30303 document and translation code, whose event kinds overlap the ceremony's own. The member chronicle, which carried nothing but nip30303 events, is kept as an empty shell that no longer asks for or sends anything.

Read shared-key-ceremony.md and subgroups.md first, Phase 10 of the second in particular: the bug exists because a subgroup's ceremony moved into the parent's Marmot room, and the screens that start and show ceremonies were written for a room that only ever held its own.

Built, one commit per phase on claude/ceremony-creation (Phase 7 in two), against the code as it stood at e3839da5. CreateSharedKeyScreen is the one screen that starts a group's own ceremony, and DkgRitualScreen only ever shows one. The phases are kept as written because they are the reasoning; where the build chose differently it did so these times:

what the plan said what it turned out to be
Phase 7 deletes the 103 files, Phase 8 the tables the line moved. The Mantra* entities convert to and from the nip30303 event classes, so the classes, entities and DAOs went in Phase 8 with the tables. Phase 7 removed the screens (part 1) and the inbound handling, ProposedEvent's arms and the chronicle's document parts (part 2)
the group details' Shared key opens an existing ceremony itself, else the creation screen it always opens CreateSharedKeyRoute, which hands over to an existing ceremony. One place decides, and back from the ceremony still returns to the details
only DkgRitualRoute.dkgSessionId becomes required the three approval routes' too, and DkgRitualUIState.Loaded.session is non-null. Every approval was already named by the ceremony screen that opened it
the subgroup picker's quorum stepper and the shared-key one are one component two. The picker's asks a different question ("how many admins have to approve a change"), so the shared-key one is SharedKeyQuorumStepper, private to the creation screen
requestIfEmpty keeps its "holds work" check it had to change: the check read the dialect and artifact tables. A room now holds work if it holds a GroupSignedEvent of a chroniclable kind, and with none chroniclable it never asks
the chronicle's tests re-fixture three of four did, with TEST_KINDS (a relay list, a profile, a post -- group-signed kinds whose arrival writes no row of its own, so the GroupSignedEvent rows are the observable). ChronicleRoundTripTest was entirely the rebuild through document rows and is deleted. The positive invite push could not take a test set -- deliveryWelcome calls sendTo with the app's kinds -- and became the "sends nothing" case
SignedGroupKeyStateTest and GroupSignedEventDaoJvmTest re-fixture in Phase 8 Phase 7: they failed at runtime the moment document arms stopped writing rows. They sign posts now, and "the row a signed event becomes points back at it" is deleted -- no kept kind writes a row
a migration test with tables copied from 26.json built from the exported 26.json at run time and compared with 27.json, so it cannot drift from what Room expects
CLAUDE.md's literal count goes to 20 19, after Phase 5 took another
61 strings plus four already unused 65 in all: the string catalogue test's two chapter strings went once it checked its escapes on recovered_of_still_unreadable instead

Checked on the three emulators that found the bug, upgraded in place from v26 with their data. The migration ran on each: v27, no document tables, and the raw-hex bubbles gone from Bob's and Charlie's #Checkers. Bob abandoned the stray whole-room ceremony 8199d186 from its screen and it ended on all three; its Try again led to the creation screen's Marmot-room refusal. Then Tapscript (89d4c4d0) ran to completion: Bob and Charlie each approved round one and came back to its screen with no start button on it -- the step where Charlie had opened the second ceremony -- and all three confirmed round two and hold the same key. No new ceremony, no unsupported line, and no chronicle request, page or line on any device. The NIP-17 Checkers group's Shared key handed over to its finished ceremony, and back returned to its details. Not exercised on a device: the certificate and key state after Tapscript, and starting a ceremony from CreateSharedKeyScreen in a group without a key.

A regression Phase 6 shipped, and its fix. FrostSigningEvents.DECLINE and MarmotDirectMessage.ENVELOPE_KIND are both 30330. Phase 6 returned early for every protocol kind before the direct-message branch, so every direct message in a current-profile room was dropped unopened. Found while mapping this fix onto Curare. An event of kind 30330 that holds a gift wrap is now an envelope, never a decline -- the test MarmotDirectMessage.wrapInside already made -- and ProtocolKindDispatchJvmTest opens one. Any port of Phase 6 has to carry this.

The headline: a ceremony is started only from a screen that knows what it is for, and the screen that shows a ceremony can never start one. Today DkgRitualScreen does three jobs (showing progress, asking for approvals, and starting a ceremony) and puts the button for the first and the last in the same place. Separating them makes the bug impossible, not just this path to it. A guard in proposeRitual makes it impossible a second time, in case a future screen gets it wrong.


What happened

Three emulators, all admins of #Checkers (639f795d…, a Marmot room): Bob (44d9ed79), Charlie (73015ef7) and Medium (e51b5720). Bob made a subgroup called Tapscript over all three of them, 2-of-3. From each device's logcat and aux.db:

time device what
13:17:00 Bob proposes 89d4c4d0, 2-of-3, parent_group = #Checkers, subject Tapscript
13:17:00 Charlie, Medium record it, awaiting approval
13:17:23 Medium approves joining; 2 of 3 host keys
13:17:35 Charlie approves joining; now 3 of 3 host keys
13:17:39 Charlie proposes 8199d186: 2-of-3 over the whole room, no parent_group, subject #Checkers
13:17:40 Bob, Medium record 8199d186 as a new ceremony awaiting approval
13:17:53 Medium approves round 1 of Tapscript
13:18:03 Medium approves joining 8199d186

Tapscript never failed. All three devices hold all three host keys, Medium has sent its round-1 contribution, and Bob and Charlie are each waiting for their own round-1 approval. No approval threw on any device. The "errors" seen while joining and confirming were screens showing the wrong state, and one chat line: on Bob and Charlie, Medium's round-1 contribution also appears as an unsupported bubble of raw hex (ChatMessage rows 66 and 62), because kind 30312 is read as a nip30303 SubmissionEvent first. That is the Leading zeroes not allowed warning in both logs at 13:17:53.

8199d186 could only have come from DkgRitualViewModel.startRitual(). It is the one caller of proposeRitual that passes no participants, no parent and no subject, which is what produces a whole-room ceremony named after the room. Charlie pressed Start key ceremony four seconds after approving, in the place where Review and join had just been.


The findings

# finding where fixed in
F1 proposeRitual will open a group's own ceremony in a Marmot room. The key it makes can never be that room's, since a Marmot room's id is derived from the key it already has. ChatRoomDetailScreen hides the button there; nothing refuses the call ChillDkgRitualManager.kt:178 Phase 1
F2 DkgRitualScreen shows progress, asks for approvals and starts ceremonies, and the approval button and the start button share one slot in the bottom bar DkgRitualScreen.kt:194-262 Phases 3, 4
F3 initiate() runs again every time the screen comes back into view, because its LaunchedEffect checks the parameter initialDkgRitualUIState, which is always Loading. Each run resets the state to Loaded(session = null) and starts another set of collectors without stopping the last DkgRitualScreen.kt:344, DkgRitualViewModel.kt:136 Phase 2
F4 Five coroutines on Dispatchers.IO each read dkgRitualUIState, copy one field and write it back. The session collector suspends on a database query between its read and its write. A write based on an old copy wipes out session and pendingApproval, and nothing re-sends them DkgRitualViewModel.kt:174-235, 251-347 Phase 2
F5 roomHasCeremony counts only the room's own ceremonies (observeLatestSessionForChatRoom defaults parentChatRoomId to null), so in a parent room hosting a subgroup's ceremony it says there is none DkgRitualViewModel.kt:175 Phase 4 (deleted)
F6 The approval button calls approve(step) and then onDone() straight away. Popping the screen clears its view model and cancels the approval's coroutine, so a slow publish can be cut off. On the last approval of a round nothing arrives afterwards to resume it DkgApprovalScaffold.kt:205 Phase 2
F7 A failed ceremony's Try again calls startRitual(), which opens a group's own ceremony whatever the failed one was for. A failed subgroup ceremony is retried as a whole-room ceremony in the parent's room, which is F1 again DkgRitualScreen.kt:239-251 Phase 4
F8 There is no way to abandon a ceremony. DkgApprovalScaffold.kt:191-195 says "Abandoning is on the ritual screen"; nothing implements it. A ceremony opened by mistake, like 8199d186, can only be left running DkgApprovalScaffold.kt:191 Phase 5
F9 record() accepts a FAILURE message from any sender. In a parent room, a member who is not in the subgroup can read its proposal and end it ChillDkgRitualManager.kt:636 Phase 5
F10 In a Marmot room, ChatMessage.applyInnerEvent matches TranslationContributorListEvent.KIND (30310) and TranslationEvent.KIND (30311) before in DkgRitualEvents.ALL. A subgroup's proposal and host keys reach the translation arms first. It does nothing today only because one arm is an empty TODO and the other's parser returns null without translation tags ChatMessage.kt:1439-1493 Phase 6
F11 Kind 30312 is both the ceremony's round 1 and nip30303's SubmissionEvent. ChatMessage.fromGroupEventResult checks for a submission before applyInnerEvent runs, tries to parse the round-1 hex as an event, fails, and writes an unsupported chat line with the raw hex. Reordering applyInnerEvent does not reach it. Seen on Bob and Charlie ChatMessage.kt:880, 986-1012 Phase 6
F12 The comments that call the kind overlap safe are out of date: they say ceremony kinds only travel in NIP-17 gift wraps, which stopped being true with subgroups' Phase 10 FrostSigningEvents.kt:52-70, ChronicleEvent.kt:89-101, DkgRitualEvents.kt:15 Phase 6
F13 The nip30303 document and translation feature is unreachable: nothing constructs ArtifactDetailRoute, AddArtifactRoute or AddDialectRoute, and the other six routes are only built from inside those screens. It is still wired into inbound dispatch, ProposedEvent, the chat transcript and 12 database tables nostr/nip30303/ and below Phases 7, 9
F14 The member chronicle can carry only nip30303 kinds (ChronicleEvent.APPLY_ORDER), yet it is live: every room asks for one when it opens (ChatMessageListViewModel.kt:206) and every invite sends one (MarmotOutboundDao.kt:1086). Without nip30303 it has nothing it is allowed to carry managers/ChronicleManager.kt, nostr/chronicle/ Phase 7

Phase 0 — before any code

An hour, to settle five things the phases assume.

  1. Ceremonies start in exactly three places. Group creation (SelectChatRoomTypeViewModel) and the subgroup picker (SelectSubgroupAdminsViewModel) already know what their ceremony is for and stay as they are. The third is new: CreateSharedKeyScreen, for a NIP-17 group that has no key yet. DkgRitualScreen starts nothing.
  2. DkgRitualRoute.dkgSessionId becomes required. Every caller that has a ceremony to show knows which one it is. A caller that does not is asking to start one, and goes to the creation screen instead.
  3. Abandoning is open to any participant, and only to participants. ChillDKG has no way to say no short of ending the ceremony, and any participant can already end it by never approving. Making it explicit just lets the others stop waiting.
  4. The whole nip30303 family goes, not only translation. Artifacts, versions, chapters, chunks, dialects and translations share one entry point, and it is unreachable. Removing only the translation kinds would leave the rest of the screens and the database tables behind them, and would leave 30312 colliding with round 1.
  5. The member chronicle stays, empty and quiet. It was built to hand a late member the group's signed document history, and CHRONICLABLE_KINDS deliberately excludes everything else (posts, profiles, relay lists, key states, subgroup certificates, wallet statements). With nip30303 gone it carries nothing. Its machinery (paging, verification against the room's key, the request and the push) is kept for the next kind that should join it, and the set it may carry becomes empty. "Quiet" means that with an empty set it puts nothing on the wire and nothing in the transcript: no request when a room opens, no pages on an invite, no reply to a request from an older build. Adding a kind back is a decision that set's comment asks for, not a side effect.

Phase 1 — proposeRitual refuses a group's own ceremony in a Marmot room

An hour. Closes F1 whatever any screen does.

In ChillDkgRitualManager.proposeRitual, beside the existing requires:

// A Marmot room's id is derived from the key it already has, so a ceremony of
// its own would make a key the room could never answer to. It hosts its
// subgroups' ceremonies and nothing else.
require(parentChatRoomId != null || localChatRoom.chatRoom.mlsGroupState == null) {
    "${localChatRoom.chatRoom.id} is a Marmot room; it can only host a subgroup's ceremony"
}

It goes after the "already running" lookup, like the other requires, so a caller who asks again for a running ceremony still gets it back.

acceptProposal gets the matching refusal: a proposal with no parent_group arriving in a Marmot room is dropped with a warning and no session is recorded. Without it, a build that predates this phase can still put one on the wire and every member's device would show it.

Tests, in SubgroupCeremonyInParentRoomTest (it already builds a parent Marmot room with parentRoom()):

  • proposing with no parent in a Marmot room throws, and writes no session and no inner event;
  • a proposal with no parent_group arriving in a Marmot room records nothing;
  • proposing a subgroup in the same room still works (the existing tests cover this; check they still pass).

Phase 2 — the ceremony screen stops losing its ceremony

Half a day. Closes F3, F4 and F6.

initiate() runs once

DkgRitualViewModel gets an initiated flag that initiate() checks and sets first. DkgRitualScreen's LaunchedEffect stays as it is; it is the view model that decides whether starting again means anything. Returning from an approval screen then reuses the collectors already running, and the state is never reset to "no session".

One writer

Replace the five read-copy-write collectors with one state built by combine:

combine(
    sessionFlow,                     // observeSessionById(dkgSessionId)
    dkgRepository.observeMessages(dkgSessionId),
    keyStateFlow,
    certificateFlow,
) { session, messages, keyState, certificate -> … }
    .mapLatest { parts -> parts.toLoaded(pendingApproval = dkgRepository.pendingApproval(parts.session)) }
    .collect { dkgRitualUIState = it }

pendingApproval is computed inside the pipeline, before the single write, so there is no suspension between reading the state and writing it. adminGroupBlockedOn is the one field set by an action rather than a flow; it becomes a MutableStateFlow that is a fifth input to combine.

This is easier once Phase 4 makes dkgSessionId required, because the "which session" question disappears. The two phases can be done in one commit if that reads better; the order here keeps Phase 2 small enough to land first.

Approving finishes before the screen closes

DkgRitualViewModel.approve(step, onApproved: () -> Unit) calls onApproved on Dispatchers.Main after dkgRepository.approve returns. DkgApprovalScaffold passes onDone there instead of calling it straight after. The button already shows a spinner while isActionPending is true, so the member sees the approval being sent rather than a screen that closed and might not have.

Tests, a new DkgRitualViewModelJvmTest beside the other view model tests in jvmTest/.../ui/view/model/:

  • calling initiate() twice leaves one set of collectors and never emits a state with session == null after the first non-null one;
  • a burst of message inserts while the session row changes ends with the state holding both the session and the messages (the lost-update case);
  • approve calls onApproved only after the repository call returns.

Phase 3 — CreateSharedKeyScreen

A day. The first half of F2.

A screen that does one thing: start a group's own key ceremony in a NIP-17 room that has no key and no ceremony running.

  • CreateSharedKeyRoute(activeUserPublicKey, chatRoomId).
  • CreateSharedKeyViewModel takes over from DkgRitualViewModel the parts that are about starting: threshold, quorumRange(), setThreshold(), the minimum-participants check, and startRitual() as create().
  • CreateSharedKeyScreen shows what DkgRitualScreen shows today when session == null: the two paragraphs about holding one key between the group and needing everyone online, the QuorumStepper, and one button, Start key ceremony. Its app bar has NavigateBackButton.
  • The four states: loading while the room loads; an ErrorState with a retry if the room cannot be read; an EmptyState saying why not when the group is too small or is a Marmot room; loaded otherwise.
  • The view model refuses, rather than hides, the cases Phase 1 refuses, so the screen can say why. A room that already has a ceremony running sends the member to that ceremony instead of offering a second.
  • On success it navigates to DkgRitualRoute(chatRoomId, dkgSessionId) with popUpTo<CreateSharedKeyRoute> { inclusive = true }. Back from the new ceremony goes to wherever the member came from, never to the creation screen.

Entry points:

  • ChatRoomDetailScreen's Shared key button (NIP-17 rooms only, as now). If the room has its own ceremony that has not failed, it opens that one with DkgRitualRoute(…, dkgSessionId = it.id). Otherwise it opens CreateSharedKeyRoute. The detail view model reads this with getLatestSessionFor(chatRoomId, parentChatRoomId = null), which is the right question here because a NIP-17 room hosts no subgroups.
  • The error card SelectChatRoomTypeScreen shows when a robust group was created but its ceremony was not (keyCeremonyNotStarted, was_created_but_its_shared_key_ceremony) gets a button to CreateSharedKeyRoute for the room it just made. Today the only way back is through the group's details, which the card does not mention.

Strings go in strings.xml in sentence case. Spacing comes from MaterialTheme.spacing, the content root gets readableContent(), and ./gradlew :composeApp:m3Audit passes with no budget raised.

Tests: CreateSharedKeyViewModelJvmTest — a NIP-17 room with no ceremony can create one; a room with one running is sent to it; a Marmot room and a one-member room are refused with a reason.


Phase 4 — DkgRitualScreen only shows a ceremony

Half a day. The second half of F2, and F5 and F7.

  • DkgRitualRoute.dkgSessionId becomes non-null. The two callers left (ChatRoomMessagingScreen's transcript links and the detail screen's Shared key from Phase 3) already pass one. A transcript line that somehow has no dkgSessionId shows no link rather than opening the room's newest.
  • DkgRitualViewModel loses startRitual(), canStartRitual(), threshold, quorumRange(), setThreshold() and the fallback to observeLatestSessionForChatRoom. DkgRitualUIState.Loaded loses roomHasCeremony and its comment, and session becomes non-null once loaded. A session id that matches no row is the error state, not an invitation to start one.
  • DkgRitualScreen loses the session == null branch and the start button. Its bottom bar has one job: the pending approval, when there is one.
  • The app bar title comes from the ceremony, not the room: a subgroup's ceremony in #Checkers reads as Tapscript, not Shared key for #Checkers.
  • Try again on a failed ceremony goes back to the screen that knows what it was for:
    • a group's own ceremony → CreateSharedKeyRoute(chatRoomId);
    • a subgroup's → SelectSubgroupAdminsRoute(parentChatRoomId, retrying = dkgSessionId). SelectSubgroupAdminsViewModel fills in the name, the admins and the quorum from the failed session (subject, participantPublicKeys minus this device, threshold). The member can change any of them before confirming, and the usual refusals run again.
  • SelectSubgroupAdminsViewModel.kt:263-276, the comment about the coordinator landing on a Start key ceremony button, is shortened to say why the transcript is still the right place to land: that is where every admin answers from.

After this phase proposeRitual has exactly three callers, which is the promise in the title. A test that greps commonMain for proposeRitual( and counts three, with a comment naming them, is cheap and fails the day a fourth appears without anyone deciding it should.

Tests: extend DkgRitualViewModelJvmTest — the view model has no way to start a ceremony; a failed subgroup ceremony's retry route carries the parent and the session; a failed group ceremony's goes to the creation screen. Extend the subgroup picker's tests with prefilling from a failed session.


Phase 5 — abandoning a ceremony

Half a day. Closes F8 and F9.

  • ChillDkgRitualManager.abandon(database, localChatRoom, sessionId, nostrPrivateKey): refuses unless this device is a participant and the ceremony is neither complete nor failed; then calls fail(...) with this device as the culprit and broadcasts DkgRitualEvents.FAILURE, exactly as a local fault does today. DkgRepository.abandon wraps it.
  • record()'s FAILURE arm ignores a sender who is not in participantsOf(session, room), with a warning like isFromCoordinator's.
  • DkgRitualScreen gets Abandon ceremony as a secondary action, shown while the ceremony is running and this member is a participant. It opens a confirmation dialog saying what happens: the ceremony ends for everyone, no key is created, and it can be started again. That matches what the existing TYPE_DKG_FAILED line already tells the room.
  • DkgApprovalScaffold.kt:191-195 then describes something that exists. The approval screens keep Not now and do not get an abandon button: the consequence belongs on the screen that shows the whole ceremony.

Tests, in SubgroupCeremonyInParentRoomTest: a participant's abandon fails the session on every device; a FAILURE from a parent member outside the subgroup is ignored; abandoning a completed ceremony does nothing.

On the test devices, once this lands: abandon 8199d186 from any of the three. Tapscript (89d4c4d0) is untouched and finishes once Bob and Charlie approve round 1. Until this lands, do not approve 8199d186 on Bob. Medium has already joined it, so Bob's approval would complete a key for #Checkers that the room can never use.


Phase 6 — the kind overlap, closed first

Two hours. Closes F10, F11 and F12 before the removal, so the removal is only deletion, and so the fix can ship on its own if the removal waits.

  • In ChatMessage.fromGroupEventResult, decide on protocol kinds first: an inner event whose kind is in DkgRitualEvents.ALL or FrostSigningEvents.ALL is stored as a MarmotInnerEvent as now, never treated as a submission envelope, and produces no chat line. Their managers are dispatched separately from NostrDao.fileGroupEventResult and write their own transcript lines. A real SubmissionEvent loses its envelope handling until Phase 7 removes it; nothing can send one, because the screens that did are unreachable.
  • In ChatMessage.applyInnerEvent, move in FrostSigningEvents.ALL -> null and in DkgRitualEvents.ALL -> null to the top of the when. Protocol kinds are never content, whatever else shares their number, and the first match wins.
  • Rewrite the comments in FrostSigningEvents.kt, ChronicleEvent.kt and DkgRitualEvents.kt to say what is true now: ceremony kinds travel as Marmot inner events in a parent room, and they stopped colliding when the dispatch order above was fixed. After Phase 7 they shrink again, to say 30300-30309 are free and 30310-30316 are the ceremony's alone.
  • Lower NostrDao.fileGroupEventResult's No app logic to handle from info to debug, or skip it for ceremony and signing kinds. It reads like a failure on every application message and sent this investigation the wrong way.
  • Tests, in a new ProtocolKindDispatchJvmTest: every kind in DkgRitualEvents.ALL, arriving as a Marmot application message with a real ceremony payload (round 1's hex content in particular), writes no chat line and no row outside the DKG tables; the same for FrostSigningEvents.ALL.

The unsupported rows already on devices are cleaned up by Phase 8's migration, which can find them by kind.


Phase 7 — removing the nip30303 code

A day and a half: a day of deletion, and half a day giving the chronicle's tests a kind set of their own. Closes F13 and F14 in code; the tables go in Phase 8.

Paths below are under composeApp/src/commonMain/kotlin/com/machankura/bennu/compose/ unless they say otherwise. Line numbers were right at e3839da5; confirm them with a grep.

Deleted outright (103 files)

what where files
the 14 event classes and their 22 tags nostr/nip30303/, nostr/nip30303/tags/ 36
the 12 Mantra* entities, plus MantraTranslationChunkProposal, which is annotated @Entity but never registered database/model/Mantra*.kt 13
the 12 table DAOs and MantraDao database/dao/Mantra*Dao.kt 13
MantraRepository, DatabaseMantraRepository repository/, database/repository/ 2
TranslationScaffold managers/ 1
nine screens, nine view models, nine UI states, nine routes: AddArtifact, AddChapter, AddDialect, AddTranslationArtifactVersion (route AddTranslation), ArtifactDetail, ChapterDetail, TranslateChunk, TranslationArtifactVersionDetail, TranslationChapter ui/composable/, ui/view/model/, ui/view/state/, ui/composable/navigation/routes/ 36
helpers nothing else uses: Markdown.kt, DetailRow.kt text/, ui/composable/widgets/ 2

Edited

  • BennuNavHost.kt: the feature's imports, databaseMantraRepository, the mantraRepository = argument in the chat room detail block, and the composable<> blocks for the nine routes.
  • ChatRoomDetailScreen.kt, ChatRoomDetailViewModel.kt: the mantraRepository parameter and field, which is stored and never read, and the preview's NO_OP_MANTRA_REPOSITORY.
  • ChatMessage.kt:
    • the nip30303 imports;
    • the submission envelope in fromGroupEventResult (submission, payload, payloadEventId = payload?.id, and the unsupported branch, whose else becomes a plain applyInnerEvent(event = event));
    • the eleven nip30303 arms of applyInnerEvent and the KDoc above it.
    • The messageTypes those arms wrote (artifact, chapter, dialect, translationArtifactVersion, translation) have no renderer; Phase 8 deletes any rows of them.
  • text/ProposedEvent.kt: the seven nip30303 arms of summaryOf. The rest (key state, subgroup certificate, metadata, text note, relay lists, wallet) stays.
  • MarmotInnerEventDao.deleteByPayloadEventId: deleted; it has no callers. The payloadEventId column goes in Phase 8.
  • strings.xml: the 61 keys only the deleted files use (59, plus add_chapter_to and chapter_words_characters once StringCatalogueJvmTest stops asserting them), and four feature strings that are already unused: add_artifact_to_library, dialects, no_artifacts_exists_in_this_groups_library, no_dialects_have_been_defined_in_this_group_2. Keep direct_message_detail and direct_message_functionality_will_be_here, which chat screens share.
  • Leave alone: the mantra/ prefix in SharedKeyDerivation.kt:74 and ChillDkgRitualManager.kt:101, which is hashed into derived keys and must never change; the relay host in Relays.kt; preview and sample text that only says "translation" (ProposalListScreen previews, "Translation room" subjects), which uses no removed type.

Tests

  • Delete the twelve that test only the feature:
    • commonTest: nostr/nip30303/{ArtifactEventTest, ChapterChunkSplitTest, InitialArtifactVersionTest, SubmissionEventTest}, managers/{TranslationScaffoldTest, SignedArtifactTest, SignedChapterTest}, database/model/RumorIdAgreementTest;
    • jvmTest: database/dao/MantraDaoJvmTest, database/model/TranslationChunkApplyJvmTest, managers/{ChapterBatchProposalJvmTest, TranslationBatchProposalJvmTest}.
  • Re-fixture the ones that used a nip30303 event as an arbitrary payload:
    • GroupKeyStateTest and GroupSignedEventDaoJvmTest need any kind; TextNoteEvent or a relay list works.
    • SignedGroupKeyStateTest (tests at 1046 and 1221) checks that a batch the group signs lands on every device. It needs a kind that writes a row on arrival, and GroupWalletStatementEvent or the relay lists do.
    • MarmotPayloadBoundsTest's chronicle cases (at 75 and 88) size a page of nip30303 events; they re-fixture with the test kind set described under "The chronicle, emptied and quiet" below.
  • Edit ChatRoomMemberRowJvmTest, GroupSignedWorkRowsJvmTest (the NO_OP_MANTRA_REPOSITORY argument) and StringCatalogueJvmTest (the two chapter strings).

Audit: neither floor moves; the deleted screens hold none of the 12 adaptive uses or the 2 navigation components. The unbudgeted string-literal count drops from 29 to 20; update the number in CLAUDE.md's "39 remain" line while there, which is already stale.

The chronicle, emptied and quiet

Kept, per Phase 0 decision 5. What changes is what it may carry, and that it says nothing when the answer is nothing.

  • ChronicleEvent.APPLY_ORDER becomes empty, and with it CHRONICLABLE_KINDS. Its comment says why: the document kinds it was built for were removed by this plan, everything else is excluded for the reasons already listed there, and a kind joins only by a decision that edits this list. applyPage's and the outbound filter's existing checks then refuse everything without any change of their own, including a page from an older build that still carries document kinds.
  • ChronicleManager.requestIfEmpty returns false while that set is empty, before it queues anything, stamps chronicleRequestedAt or writes a transcript line. Its "holds work" check (ChronicleManager.kt:169-170) reads the Mantra DAOs and goes; the empty-set check replaces it. Opening a room then sends nothing, and ChatMessageListViewModel.askForGroupHistory needs no change.
  • sendTo needs no change. It already sends nothing and writes no line when assemble comes back empty ("silence is the honest reply"), which is what an empty set makes it do. That covers the push on every invite (MarmotOutboundDao.kt:1086) and the reply to a request from an older build (ChatMessage.kt:972). Phase 7's tests assert both stay silent.
  • Removed from ChronicleManager: the rebuild fallback that reads the Mantra tables (rebuiltEventsOf, 748-811) and currentTranslationsOnly (657-718), which exists only for translation chunks. signedEventsOf stays; it reads GroupSignedEvent by kind and will find nothing.
  • Kept as they are: ChronicleRequestEvent, the three chronicle tags, TYPE_CHRONICLE_* and CHRONICLE_TYPES, ChatRoom.chronicleRequestedAt, and the comments that say why a kind is not chronicled. All of them still describe the machinery accurately. Rows already written stay too.
  • Tests. ChronicleEventTest, ChronicleRoundTripTest, ChronicleApplyJvmTest and ChronicleAssemblyJvmTest exercise paging, verification and ordering with document events as the payload. With an empty production set they have nothing to page. So ChronicleEvent and ChronicleManager take the chroniclable kinds as a parameter, defaulting to the production set, and those tests pass a test set (TextNoteEvent and a relay list, say) built in a shared fixture. That keeps the machinery covered without making any kind chroniclable in the app. Assertions of the count (ChronicleEventTest:195 expects 8; ChronicleRoundTripTest:418, ChronicleApplyJvmTest:801, ChronicleAssemblyJvmTest:336, 511) assert against the test set, and one new test asserts the production set is empty. The other new tests: requestIfEmpty sends nothing and writes no line; sendTo on an invite sends nothing and writes no line; a page from an older build carrying document kinds applies nothing.

Phase 8 — schema 26 → 27

Half a day, most of it the migration test.

One manual MIGRATION_26_27 in database/migrations/RemoveDocumentsMigration.kt, registered in getRoomDatabase beside the other four. Manual rather than an AutoMigration, because it deletes chat rows as well as changing shape, which is the line that file's comment already draws.

-- the chat lines the removed arms wrote, and the ceremony round-1 lines
-- misread as submissions (F11)
DELETE FROM ChatMessage WHERE messageType IN
  ('artifact', 'chapter', 'dialect', 'translationArtifactVersion', 'translation');
DELETE FROM ChatMessage WHERE messageType = 'unsupported' AND marmotInnerEventId IN
  (SELECT id FROM MarmotInnerEvent WHERE kind BETWEEN 30310 AND 30316);

DROP TABLE MantraArtifact;  -- … and the other eleven, children before parents
ALTER TABLE MarmotInnerEvent DROP COLUMN payloadEventId;

The chronicle's column (ChatRoom.chronicleRequestedAt) and its chat lines stay, since the chronicle does.

  • The table names come from composeApp/schemas/…/26.json; check them there, not here. MarmotInnerEvent.kind is the column the second DELETE reads.
  • DROP COLUMN is safe because getRoomDatabase pins BundledSQLiteDriver on every platform, the argument ChronicleRenameMigration already makes for RENAME COLUMN. Check first that payloadEventId is not indexed or part of a foreign key, since SQLite refuses to drop a column that is.
  • No kept table has a foreign key into a Mantra table, so dropping them cascades into nothing that stays. Drop children before parents anyway, so the order holds if foreign keys are ever enforced during migration.
  • GroupSignedEvent keeps any rows of kinds 30300-30309. The table is generic and keyed by kind, nothing reads those kinds any more, and deleting a group's signed record is not this plan's call.
  • BennuDatabase: version = 27, the twelve entities and thirteen DAO accessors removed, and the migration-history comment gets a line for 26 → 27. Commit 27.json.

Test, RemoveDocumentsMigrationJvmTest, in the same style as the three migration tests already there: the version-26 tables created by hand from 26.json, seeded with a Mantra row, a translation chat line, an unsupported line pointing at a kind-30312 inner event, and an unsupported line pointing at some other kind. After the migration, the Mantra tables and payloadEventId are gone, chronicleRequestedAt is still there, the first two lines are deleted, and the last one is still there.


Phase 9 — docs, and checking it on the emulators

Half a day.

  • shared-key-ceremony.md: a section on where a ceremony can be started (the three places), on abandoning, and the kind table noting that 30310-30316 now travel in both transports.
  • subgroups.md: a line under Phase 10 pointing here for the retry path and the guard. Its chronicle mentions stay true: a subgroup certificate is still not chroniclable.
  • member-chronicle.md: a status line at the top saying the chronicle is built but carries no kinds since this plan removed the document kinds, that it is silent while that is so, and that adding a kind means editing ChronicleEvent.APPLY_ORDER on purpose. docs/README.md:39 already contradicts the note's status (it says the chronicle was never built); fix both together.
  • frost-batch-signing.md (its first caller was a chapter and its chunks, 519-546) and mls-skipped-keys.md (MantraDao.addArtifact): a line each saying the example was removed, rather than rewriting history. marmot-v2.md and group-chain-wallet.md mention the chronicle, not the documents, and need nothing.
  • material-design-conformance.md: the screen count (43) and the "artifacts → chapters" list-detail family.
  • docs/README.md: a row for this note, and its place in the reading order (after the subgroups note).
  • This note: mark it built, and add a table of where the build chose differently, as the other plans do.

Then the scenario that found the bug, on the same three emulators:

  1. Bob makes a subgroup over all three admins of a parent room.
  2. Charlie and Medium each open it from the transcript, approve joining, and land back on the ceremony screen. It shows the subgroup's ceremony and offers Review and contribute once all host keys are in, and there is no start button anywhere on it.
  3. All three approve round 1 and round 2; the ceremony completes; the certificate and key state follow as subgroups.md describes.
  4. In a NIP-17 group without a key, Shared key from the group's details opens CreateSharedKeyScreen, and starting a ceremony there lands on its progress screen, with back returning to the details.
  5. Abandon a ceremony from one device and watch it end on the other two.
  6. No unsupported bubble appears in the parent room at any point, and the two left over from the original run (Bob and Charlie) are gone after the upgrade.
  7. Inviting a member to a group and opening a room both work, and neither puts a chronicle request, a chronicle page, or a chronicle line in the transcript on any device (Phase 7's quiet shell).

./gradlew check passes, which runs the m3 audit.


What this does not do

  • It does not change the protocol. No new kinds, no new tags; the FAILURE message abandon sends is the one a fault already sends.
  • It does not migrate ceremonies already on devices. A whole-room ceremony already recorded in a Marmot room, like 8199d186, stays until it is abandoned. Phase 1 stops new ones being opened or recorded.
  • It does not touch the group's signed record. Rows of kinds 30300-30309 in GroupSignedEvent stay; see Phase 8.
  • It does not remove the member chronicle. Its machinery stays, carrying nothing and saying nothing, until a kind is chosen to join it.
  • It does not free the mantra/ derivation prefix. It is an input to the host-key and shared-key hashes, not a reference to the removed feature.

Order and size

phase what size depends on
0 decisions an hour —
1 proposeRitual guard an hour —
2 ceremony screen keeps its ceremony half a day —
3 CreateSharedKeyScreen a day 1
4 ceremony screen only shows half a day 2, 3
5 abandoning half a day 4
6 protocol kinds dispatched first two hours —
7 remove nip30303 code, quiet the chronicle a day and a half 6
8 schema 26 → 27 half a day 7
9 docs and emulator check half a day all

Phases 1, 2 and 6 are independent and the most urgent; each can ship alone. Phases 3-5 are one line of work on the ceremony screens, and 7-8 another on the removal, and the two lines touch different files apart from ChatMessage.kt (Phase 6 against Phase 7), so they can run side by side once Phase 6 is in.