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>
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.
- 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.DkgRitualScreenstarts nothing. DkgRitualRoute.dkgSessionIdbecomes 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.- 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.
- 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.
- The member chronicle stays, empty and quiet. It was built to hand a late
member the group's signed document history, and
CHRONICLABLE_KINDSdeliberately 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_grouparriving 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 withsession == nullafter 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);
approvecallsonApprovedonly 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).CreateSharedKeyViewModeltakes over fromDkgRitualViewModelthe parts that are about starting:threshold,quorumRange(),setThreshold(), the minimum-participants check, andstartRitual()ascreate().CreateSharedKeyScreenshows whatDkgRitualScreenshows today whensession == null: the two paragraphs about holding one key between the group and needing everyone online, theQuorumStepper, and one button, Start key ceremony. Its app bar hasNavigateBackButton.- The four states: loading while the room loads; an
ErrorStatewith a retry if the room cannot be read; anEmptyStatesaying 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)withpopUpTo<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 withDkgRitualRoute(…, dkgSessionId = it.id). Otherwise it opensCreateSharedKeyRoute. The detail view model reads this withgetLatestSessionFor(chatRoomId, parentChatRoomId = null), which is the right question here because a NIP-17 room hosts no subgroups.- The error card
SelectChatRoomTypeScreenshows when a robust group was created but its ceremony was not (keyCeremonyNotStarted,was_created_but_its_shared_key_ceremony) gets a button toCreateSharedKeyRoutefor 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.dkgSessionIdbecomes 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 nodkgSessionIdshows no link rather than opening the room's newest.DkgRitualViewModellosesstartRitual(),canStartRitual(),threshold,quorumRange(),setThreshold()and the fallback toobserveLatestSessionForChatRoom.DkgRitualUIState.LoadedlosesroomHasCeremonyand its comment, andsessionbecomes non-null once loaded. A session id that matches no row is the error state, not an invitation to start one.DkgRitualScreenloses thesession == nullbranch 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
#Checkersreads 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).SelectSubgroupAdminsViewModelfills in the name, the admins and the quorum from the failed session (subject,participantPublicKeysminus this device,threshold). The member can change any of them before confirming, and the usual refusals run again.
- a group's own ceremony →
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 callsfail(...)with this device as the culprit and broadcastsDkgRitualEvents.FAILURE, exactly as a local fault does today.DkgRepository.abandonwraps it.record()'s FAILURE arm ignores a sender who is not inparticipantsOf(session, room), with a warning likeisFromCoordinator's.DkgRitualScreengets 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 existingTYPE_DKG_FAILEDline already tells the room.DkgApprovalScaffold.kt:191-195then 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 inDkgRitualEvents.ALLorFrostSigningEvents.ALLis stored as aMarmotInnerEventas now, never treated as a submission envelope, and produces no chat line. Their managers are dispatched separately fromNostrDao.fileGroupEventResultand write their own transcript lines. A realSubmissionEventloses its envelope handling until Phase 7 removes it; nothing can send one, because the screens that did are unreachable. - In
ChatMessage.applyInnerEvent, movein FrostSigningEvents.ALL -> nullandin DkgRitualEvents.ALL -> nullto the top of thewhen. Protocol kinds are never content, whatever else shares their number, and the first match wins. - Rewrite the comments in
FrostSigningEvents.kt,ChronicleEvent.ktandDkgRitualEvents.ktto 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'sNo app logic to handlefrom 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 inDkgRitualEvents.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 forFrostSigningEvents.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/mobi/giza/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
GizaNavHost.kt: the feature's imports,databaseMantraRepository, themantraRepository =argument in the chat room detail block, and thecomposable<>blocks for the nine routes.ChatRoomDetailScreen.kt,ChatRoomDetailViewModel.kt: themantraRepositoryparameter and field, which is stored and never read, and the preview'sNO_OP_MANTRA_REPOSITORY.ChatMessage.kt:- the nip30303 imports;
- the submission envelope in
fromGroupEventResult(submission,payload,payloadEventId = payload?.id, and theunsupportedbranch, whoseelsebecomes a plainapplyInnerEvent(event = event)); - the eleven nip30303 arms of
applyInnerEventand 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 ofsummaryOf. The rest (key state, subgroup certificate, metadata, text note, relay lists, wallet) stays.MarmotInnerEventDao.deleteByPayloadEventId: deleted; it has no callers. ThepayloadEventIdcolumn goes in Phase 8.strings.xml: the 61 keys only the deleted files use (59, plusadd_chapter_toandchapter_words_charactersonceStringCatalogueJvmTeststops 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. Keepdirect_message_detailanddirect_message_functionality_will_be_here, which chat screens share.- Leave alone: the
mantra/prefix inSharedKeyDerivation.kt:74andChillDkgRitualManager.kt:101, which is hashed into derived keys and must never change; the relay host inRelays.kt; preview and sample text that only says "translation" (ProposalListScreenpreviews, "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}.
- commonTest:
- Re-fixture the ones that used a nip30303 event as an arbitrary payload:
GroupKeyStateTestandGroupSignedEventDaoJvmTestneed any kind;TextNoteEventor 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, andGroupWalletStatementEventor 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(theNO_OP_MANTRA_REPOSITORYargument) andStringCatalogueJvmTest(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_ORDERbecomes empty, and with itCHRONICLABLE_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.requestIfEmptyreturns false while that set is empty, before it queues anything, stampschronicleRequestedAtor 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, andChatMessageListViewModel.askForGroupHistoryneeds no change.sendToneeds no change. It already sends nothing and writes no line whenassemblecomes 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) andcurrentTranslationsOnly(657-718), which exists only for translation chunks.signedEventsOfstays; it readsGroupSignedEventby kind and will find nothing. - Kept as they are:
ChronicleRequestEvent, the three chronicle tags,TYPE_CHRONICLE_*andCHRONICLE_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,ChronicleApplyJvmTestandChronicleAssemblyJvmTestexercise paging, verification and ordering with document events as the payload. With an empty production set they have nothing to page. SoChronicleEventandChronicleManagertake the chroniclable kinds as a parameter, defaulting to the production set, and those tests pass a test set (TextNoteEventand 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:195expects 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:requestIfEmptysends nothing and writes no line;sendToon 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.kindis the column the secondDELETEreads. DROP COLUMNis safe becausegetRoomDatabasepinsBundledSQLiteDriveron every platform, the argumentChronicleRenameMigrationalready makes forRENAME COLUMN. Check first thatpayloadEventIdis 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.
GroupSignedEventkeeps 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.GizaDatabase:version = 27, the twelve entities and thirteen DAO accessors removed, and the migration-history comment gets a line for 26 → 27. Commit27.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 editingChronicleEvent.APPLY_ORDERon purpose.docs/README.md:39already 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) andmls-skipped-keys.md(MantraDao.addArtifact): a line each saying the example was removed, rather than rewriting history.marmot-v2.mdandgroup-chain-wallet.mdmention 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:
- Bob makes a subgroup over all three admins of a parent room.
- 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.
- All three approve round 1 and round 2; the ceremony completes; the
certificate and key state follow as
subgroups.mddescribes. - 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. - Abandon a ceremony from one device and watch it end on the other two.
- No
unsupportedbubble 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. - 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
abandonsends 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
GroupSignedEventstay; 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.