Nothing navigated to the artifact, chapter, dialect or translation screens:
ArtifactDetailRoute, AddArtifactRoute and AddDialectRoute were never built,
and the other six were only reached from inside those screens. Removed with
their view models, UI states, routes, nav host entries, the repository behind
them, TranslationScaffold, DetailRow, and the 65 strings only they used. The
group details screen loses the document repository it stored and never read.
The string catalogue test now checks its escapes on a string that stays.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A subgroup's ceremony runs in its parent's Marmot room, where its kinds
30310-30312 are also nip30303 document kinds. Round 1 (30312) was read as a
document submission first, failed to parse, and reached every other admin's
chat as an unsupported bubble of raw hex; the proposal and host keys reached
the translation arms before the ceremony's own. fromGroupEventResult now
stores a protocol message and returns before any document handling, and
applyInnerEvent checks the protocol arms first.
The comments that called the overlap safe are corrected, and the
"No app logic to handle" line every application message logged at info is
now a debug line that does not read like a failure.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
There was no way to end a ceremony: ChillDKG has no "no" short of it, and
the approval screens pointed at an abandon action on the ritual screen that
did not exist. ChillDkgRitualManager.abandon now ends a running ceremony this
device is in, filing and broadcasting the same FAILURE a fault sends, and the
ceremony screen offers it behind a confirmation.
record() now ignores a FAILURE from anyone outside the ceremony. In a
parent's room every member can read a subgroup's proposal, so any of them
could otherwise end it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
DkgRitualRoute and the three approval routes now require the ceremony's id,
and the screen loses its start button, its quorum stepper and its fallback to
the room's newest ceremony. A transcript line naming no ceremony opens
nothing. The title is the ceremony's name rather than the room's, so a
subgroup's ceremony is not called after its parent.
Try again on a failed ceremony goes back to the screen that starts that kind:
the creation screen for a group's own key, or the subgroup picker filled in
from the ceremony that failed. Retrying a failed subgroup used to open a
whole-room ceremony in the parent's room.
A test counts the screens that open a ceremony, so a fourth is a decision.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
CreateSharedKeyScreen takes the quorum and a single button, and nothing
else. It refuses a Marmot room and a group of one with a reason, hands over
to a ceremony the group already has rather than offering a second, and
replaces itself with the ceremony once it is opened so back never returns to
an offer. The group details' Shared key button and the card shown when a
robust group was created without its ceremony both lead here.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Three ways the shared-key screen could lose the ceremony it was showing, and
so offer to start one:
- initiate() ran again whenever the screen came back into view, resetting
the state to no ceremony and stacking another set of watchers. It now runs
once per view model.
- five coroutines each read the state, changed one field and wrote it back,
one of them across a suspending query, so an old copy could overwrite a
newer one. The state is now built by one flow and written in one place.
- an approval closed its screen as the button was pressed, cancelling the
view model's scope and with it a publish still in flight. The screen now
closes once the approval has gone out.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
proposeRitual now refuses a ceremony with no parent in a Marmot room, and
acceptProposal drops one arriving there. A Marmot room's id is derived from
the key it already has, so a key of its own is one it could never use -- and
the shared-key screen offering to start one in a parent's room is how a
second, whole-room ceremony opened beside a subgroup's.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The form read which coins and change addresses open spends hold once,
when it opened. A spend another member proposed while it was open still
looked free, so sending everything would ask the group to sign a second
spend of coins only one spend can have. The form now combines the chain
state with observeGroupTransactions, as the wallet screen does, and
re-reads both reservations on every change, as one state.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The group wallet's address list: every paid receive address, the
current one and the two after it, any unused one handed out as a QR
code, and the used change addresses -- docs/group-wallet-addresses.md.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every place a spend is described -- the proposal list and the wallet's
spend rows through ProposedSpend.summarize, the approval screen through
isChange, and the signed and confirmed transcript lines through
amountSent -- already reported the payment rather than payment plus
change. Nothing needed fixing; ProposedSpendTest and the end-to-end
spend test now hold each of them to it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The amount field shows its unit, how many sats are confirmed and free to
spend, and on mainnet the cap; a problem with the amount -- not whole,
too large, more than the group has, too small, over the cap -- is said on
the field in its error state instead of under the form. The send-everything
row is one 48dp toggleable target, and turning it off again finds the
amount typed. The wording of every reason is one function shared by the
field and the preview.
GroupSendScreenJvmTest types into the form on regtest and mainnet.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
SEND_AN_AMOUNT kept every network on send-all until a release had shipped
with no mislabelled change, which no release could do while the gate was
closed. It is removed: the send screen always offers the switch and the
amount, and on mainnet the existing 100,000 sat cap bounds what a change
bug could put at risk. Phase 3's end-to-end test is what stands in for
the release the gate was waiting for.
The view model test no longer branches on the constant, and a mainnet
test holds an amount to the cap.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupWalletState.changeAddresses lists the change addresses that have
been used, newest first -- never a current or a next one, since change
is chosen by a spend. The address list shows them in a section of their
own once there are any, with copy and nothing else.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Tapping the current or a next address on the list opens it in a sheet
-- the receive card's QR code, selectable text and copy, titled with the
index so a member can say which one they gave. A used address has copy
and nothing else: copying is for checking, a QR code is for being paid.
The sheet closes itself, with "Address N was just paid", when Electrum
reports a payment to the address it is showing.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Two open spends with change both paid to the first unused change
address, since a spend waiting for signatures has not used it yet.
Change indices are now reserved like coins: reservedChangeIndices reads
the claims of every open spend, and the builder takes the lowest watched,
unused, unheld index. It chooses among generated addresses only, so
change never lands outside the window; CHANGE_LOOKAHEAD rises to 10 and
past it a spend with change returns TooManyOpen.
The change branch not having answered is FindingChange rather than
NothingToSpend, and change too small to send back is reported as
Built.absorbed and said in the preview.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupWalletAddressesScreen, pushed from an "All addresses" button in the
wallet screen's receive card: index, address, and what each has been
used for, newest first, with the current address on the secondary
container and a copy button on every row. Its view model reads the
wallet GroupOnchainWallets already holds, so the list costs no
subscriptions and agrees with the wallet screen about which address is
current.
FakeElectrum moves out of GroupOnchainWalletJvmTest so the view model's
test can drive a chain too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupWalletState.receiveAddresses: every paid receive address, the
current one, and ADDRESSES_AHEAD (2) after it, newest first -- reaching
the highest paid address even when a watch-only wallet was paid past
that. Null until Electrum has answered, as receiveAddress is.
The test fake now reports a status over a script's history rather than
its unspents, as Electrum does, so an address spent from stays used.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The gated amount field read its text by dropping every non-digit, so
21000.5 became 210,005 sats and 0.0005 became 5. parseSats accepts
thousands grouping and refuses decimals, grouping that groups nothing,
non-ASCII digits and more sats than exist; the preview reports which.
The field shows plain digits grouped and keeps what was typed.
Also plans the rest in docs/group-send-an-amount.md: send-an-amount
opens on every network at once, held on mainnet by the existing cap.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The wallet screen's title, the room's detail row, the button that opens
one and the proposal summary a member agrees to all said "group wallet".
They now say "group onchain wallet", which is what it holds, and agrees
with GroupOnchainWallet in the code. Sentence case, as every string is.
Resource keys are unchanged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
DERIVATION_PAYLOAD closed its JSON object with a bare `}`. The JVM reads
that as a literal; ICU, which backs Regex on Android, rejects the
pattern. It was a private val of FrostSigningManager, so the throw came
from the class initialiser, which Android does not retry: every signing
session on the device failed with NoClassDefFoundError until restart.
The first symptom was a ceremony that "couldn't ask the group to agree
its signing key".
The JVM suite cannot ask ICU, so RegexPortabilityJvmTest reads every
Regex literal out of the main source sets and holds it to the stricter
rule: a `}` is escaped, inside a class, or the end of a quantifier. With
the old pattern restored it fails on FrostSigningManager.kt.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every conflict was the curated-lists removal on bennu meeting a wallet
line added beside it: the removal is taken and the wallet lines kept.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
And its registry, GroupChainWallets, is GroupOnchainWallets, with the
files, the test and the plan's references following.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupWalletRollout holds the three gates, each with what lifts it. The
flag is on, its condition met. Send-an-amount is off, so the form sends
everything confirmed to one address and says so. A spend proposed from
this device on mainnet may send at most 100,000 sats; test networks
have no cap. The gates are on the composer and nothing else: a device
behind them still accepts, shows and signs what another member
proposes, through every check GroupSpend makes.
The plan is marked built, with its table of where the build chose
differently. Full JVM suite: 1474 tests, none failing; the Android
target compiles; every M3 budget is met.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every spend the room proposed, newest first, for every member whether
or not they have a node: what it sends and where it has got to --
waiting for signatures, abandoned, signed, sent (reported back by
Electrum, not merely broadcast), confirmed, or replaced by a later
spend. A signed spend Electrum has not reported can be sent again; a
signed, unconfirmed one can be bumped to twice its feerate, a new
session over the same coins that whichever confirms settles. Each row
opens its signing session.
Full JVM suite: 1473 tests, none failing.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupTransactionWatcher, one per identity beside its wallets: every
signed spend still on its way is sent from this device too, sent again
every ten minutes while Electrum has not reported it -- its broadcast
reports success whatever the server said -- and followed to a
confirmation. FrostSigningManager.recordConfirmed then settles every
other spend of the same coins: one still collecting is abandoned as
spent by another transaction, one already signed is marked replaced
rather than failed, and the room gets one line saying it confirmed.
GroupSpendBuilder.bump re-spends the same coins at a higher feerate,
the extra taken from the change or, for a send-all, the one payment.
The test caught a stale write: a pass followed each spend from the list
it started with, so settling one spend was undone by writing the next
back from its old copy. follow() reads its row again first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupSendRoute and GroupSendScreen, behind a Send button on the wallet
screen for a member who holds a share and has a node to see the coins
with. Address, amount or send everything, and a feerate prefilled from
Electrum's six-block estimate. The preview is GroupSpendBuilder over the
same inputs the proposal is built from -- what leaves, the fee, what
comes back as change, or why it cannot be built -- and proposing moves
onto the signing session, replacing the form.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupSpendBuilder: send-all, as Phoenix's final wallet does, and an
amount paid largest coin first with change to the next change address,
or to fees when it would be dust. Confirmed coins only, never one an
open spend already holds; the fee is exact before signing because every
witness is 64 bytes. Every built spend passes GroupSpend.check.
The signing screen draws a spend where it draws events: every output
with its address and amount, change labelled, the fee and feerate, and
the coins spent -- read from FrostSigningManager.checkedSpend, the
stored PSBT checked again, and unsignable when this device cannot check
it. The proposal list and the chat notice say "Spend from the group's
wallet". FrostSigningRepository gains proposeSpend, checkedSpend and
reservedOutPoints.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Kind 30332 opens a session over a PSBT, one item per input, each its own
FROST instance over that input's BIP341 sighash with its own nonce seed
and its own tweak cache. proposeSpend and acceptSpendProposal run the
same GroupSpend checks: every input derives under the account the
room's verified statement gives -- looked up under the ceremony's own
key -- default sighash only, no script-path fields, replaceable, change
only where its claim derives, and a fee under a ceiling. A second
proposal under one id is ignored. completeSpend checks each signature
against its coin's output key and the whole transaction with
correctlySpends before writing it.
An old build does not route 30332, so it never signs a transaction it
cannot show. Resend repeats the PSBT byte for byte. Two-device test:
a quorum spends two coins and both devices hold a transaction that
correctlySpends; each check refuses a hand-built proposal outright.
Full JVM suite: 1458 tests, none failing.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
FrostSigningSession.subject, NOT NULL with a default of EVENTS, says
what a session's items are messages of; FrostSigningItem.inputIndex
names the input a transaction item signs, with message and payload as
getters over the existing columns. GroupTransaction holds a spend from
proposal on: the PSBT, written once with IGNORE, the txid fixed before
signing, and the signed transaction, broadcast, seen and confirmed.
AutoMigration(25, 26) is three ADD COLUMNs and a CREATE TABLE -- no
rebuild of either signing table, so no cascade fires.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupWalletRoute and GroupWalletScreen, reached from a Group wallet row
on the group's screen. A group that has not opened a wallet gets an
empty state with, for a member who can sign, what opening one asks of
everybody -- including that shares are unencrypted at rest -- and the
button that proposes the statement. An open wallet shows the balance,
confirmed and on the way said apart, the next receive address as a
BIP21 QR code, selectable text and a copy button, the coins, and an
export of the two watch-only descriptors with what they give away.
The wallets are watched on the identity's own Electrum client and made
per PhoenixBusiness in BennuNavHost; a profile with no node sees the
wallet and is told it cannot watch the chain.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupChainWallet is Phoenix's FinalWallet for a group: two
ElectrumMiniWallets, one per BIP44 branch since a mini-wallet holds one
generator, gap-limited at 10 for receive and 3 for change, on the shared
client. GroupWalletState gives the coins with the derivation that spends
each, the confirmed and pending balances, the next receive address and
change index, and derivationOf -- bounded by the addresses the wallet
has generated, which is how far a check of a claim will look.
Tested against a fake IElectrumClient: a payment moves the receive
address on, change is counted and never offered, and two groups on one
client see only their own coins.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Kind 30331, inner only: the account xpub, the network, the account
number and both descriptors. A reader believes one only when the room
signed it and the room's threshold key rederives every value it
carries -- GroupWallet.of, used by the repository and by the transcript
arm alike. The broadcast screen refuses the kind twice, at the loader
and in sendToRelays, because the xpub on a relay is the whole balance.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Real ChillDKG, real FROST, no manager: two wallet inputs signed as two
independent instances, each over its own BIP341 sighash with its own
cache, judged by correctlySpends. The negatives are the ones a positive
cannot catch -- another input's cache, a cache missing the tail or the
key-path tweak, and a sighash over a lied-about amount all produce
signatures the script interpreter rejects.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
GroupWalletDerivation: a public account step -- a tagged HMAC over the
threshold key, the network and an account number -- gives a depth-0 xpub,
and below it BIP86's own unhardened tail, /<change>/<index>, with the
key-path tweak on top. Each address is computed twice, as points and as
tweaks on a FROST cache, and refused if the two disagree.
Tests: BIP86's published vectors through the cache prove the tail; a
pinned vector freezes the account step; a sweep covers both parities.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Bennu no longer speaks curare.to's list protocol. The schemas, templates,
entries and the suggestion queue go, with their six screens, routes, view
models, strings and tests, and the hooks into the group screen, the paste
proposal, proposal summaries, broadcast relay seeding, the chat repository
and the transcript.
The two transcript message types stay as private legacy names so rows
already stored still render as system lines rather than chat bubbles.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Move the packages to com.machankura.bennu.{compose,android,desktop}, the
Android applicationId to com.machankura.bennu.android and the iOS bundle
id to com.machankura.bennu.ios. The root project, launcher label, iOS
product, desktop window, user-facing strings, client tags and the
Curare* classes all say Bennu now.
Left alone on purpose: the mantra/ derivation tags, the `curated` desktop
data directory, the mantra.press relay and the curare.to references.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The bulk control I argued against, built -- and the objection turned out to be
solvable rather than fatal, so it is worth recording what happened to it.
Half of it was already handled. Two resends in the same second do not collide
on the outbound row id: `broadcast` hashes that id over the session's own tags
and steps a second forward when it finds a collision rather than overwriting.
Different sessions were never at risk.
The other half was real. A resend publishes two messages, and `resend` keeps to
two deliberately because "publishing in bursts is what the skipped-keys bug
feeds on"; three proposals at once is six, in the same second that "two events
published in the same second race, and exactly one survives" was written about.
So the sessions are spaced rather than the budget quietly raised --
`resendAll` waits `RESEND_SPACING` between them, one second, which is the
resolution the protocol works in because `created_at` is stored to the second.
The pacing lives in the manager and not in the loop that wanted it, because
everything that justifies it does: MLS generations, relay ordering, outbound
ids. A caller that launched `resend` per session would put every burst into one
second, and the call site is the wrong place to know why that matters. There is
a test against the real manager that three sessions take longer than two
spacings and claim three different seconds.
What it acts on is `visible`, not the room: a bulk control reaching rows the
reader cannot see is its one unforgivable move. A cooling-down row is left out
of the count rather than included and skipped, because the count is what the
button says out loud and offering three while able to send two is a lie told
before the tap. Offered from two up: one is what the row's own button is for.
Every covered row goes quiet for the whole run rather than for its own turn --
a paced run means a row whose turn has not come is still about to publish, and
a row button offering to send it meanwhile would send it twice. A session
already in flight on its own is left out of the run for the same reason.
It is offered on any filter showing two it can act on, not only "being signed".
That filter is where it earns its place -- three rows stalled for one reason --
but the rule is about what is on screen, not about which chip put it there.
1419 jvm tests pass, the Android target compiles, all audit budgets met.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The offer the signing screen already makes, reached from the list. A
coordinator whose room has stalled should not have to open each proposal in
turn to find the button, and filtering to "being signed" now puts every stalled
one in front of them at once.
It is on the row and not on the chip, which is where it was asked for, for
three reasons. A chip is a selection control, and giving it a second action
would make the control that publishes the one you cannot undo. A chip stands
for several proposals while `resend` takes one session, so a chip-level button
means resending all of them -- and the manager caps itself at two messages per
resend precisely because "publishing in bursts is what the skipped-keys bug
feeds on", which three proposals at six messages would re-create. And the offer
is the coordinator's alone and only exists while somebody owes, so on a chip
standing for a mixed set it would be enabled for proposals it cannot act on.
It is called "ask again" rather than "re-broadcast" for the same reason the
list calls a review a review: somebody who found the button on the signing
screen and then found this one should not have to work out that two labels are
one button.
Whether to offer it is asked of `membersOwing`, not derived from the signature
count. Past the nonces a signer who refused has answered and is owed nothing
while the count is still short by one, so a row reading `have < need` would
offer to knock on a door that has already been shut. That is one query per row
and the only one on this screen, so it is asked for as few rows as possible:
not ours to send, nothing to send, and already ended all answer without
touching the database. An ended session is left out although the manager would
take it -- re-sending a completed one delivers the signature to a member who
never applied it, which is worth a button on the one proposal's screen rather
than a query per row on a list that only grows. The signing screen still offers
it.
Guarded per session rather than by one flag for the screen, because these rooms
have several proposals open at once and a coordinator working down the list
should not be locked out of the second by the first still publishing. The
cooldown disables rather than hides, as it does on the signing screen: a
control that vanishes after a tap reads as one that failed.
1396 jvm tests pass, the Android target compiles, all audit budgets met.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
A row said "waiting for 2 of 3 members to take part" on the day a proposal was
made and on the day before it completed. That is the rule, not the progress.
Now it says "1 of 3 members have offered to sign", and on the next stage "2 of
3 signatures are in" -- the fractions that actually move.
Nothing is counted once it has ended, which is both endings and not only the
happy one. A signed session has nothing left to gather; an abandoned one has
counts frozen where they stopped, and "2 of 3" beside a failure invites the
reader to wait for a third that is never coming. The failure reason is what
that row has to say.
The denominators are the ones the protocol gates on. `orderedNonces` returns
nothing until `threshold` nonces have arrived and then takes the first
`threshold` of them, so the threshold is both what is needed and what is used --
the room's size is a bigger number nothing waits for. Once the signer set
exists it is the set being waited on, which is the same count from the other
side.
The numerator is the part that had to be got right. A nonce or a partial
signature is recorded with no check on who sent it, unlike a refusal, and
`orderedNonces` drops the ones from members holding no share when it
aggregates. So the tally joins `DkgParticipantMessage` on HOST_KEY and counts
members rather than rows: a count including strangers would have a row read
ahead of the coordinator, saying the group has what it needs while the session
sits still. That is the one direction a progress figure must never be wrong in,
and there is a DAO test for it. A count that still runs ahead -- a nonce
landing before this device runs `advance` -- is clamped, because a fraction
over one reads as a bug rather than as a session about to move.
The counts travel as their own `GROUP BY` flow, combined with the sessions in
the view model. They change far more often than the rows do, and carrying the
messages themselves would carry every nonce payload the room has ever exchanged
to a screen that only wants to count them.
The progress is its own line rather than a clause, so a reader scanning for the
one that is nearly there does not have to read a sentence to find out. That
left `statusOf` saying only who the reader is in the proposal, and since this
adds user-facing text its remaining literals moved to the catalogue with it --
nine strings that had been raw in the screen since before the catalogue rule.
1367 jvm tests pass, the Android target compiles, all audit budgets met.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Every step a session takes is driven by a message arriving, and a device
killed part way through its own pass is waiting on one that has already
been delivered. The signer set is recorded, so it will never be processed
again; the partial signature it would have produced was never made. The
coordinator asking again cannot reach past it either -- what a resend
asks a member for is the message this device believes it already sent --
so the session is a dead end on both sides, and in a room with several
open proposals it is the one that was mid-pass that stops.
So one sweep that no message drives: on opening a room, every session in
it that is not settled and whose owner has answered is handed to
`advance`, which does what it always does. It publishes nothing new --
each step asks whether its output exists rather than whether a stage says
it ran -- and only answered sessions are passed in, so the approval gate
is not approached, let alone reached past. A refusal counts as an answer
for the same reason: a device killed between deciding and publishing says
it on the next open rather than never.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
A resend had one idea of who it was for at every stage -- the share
holders it had heard nothing at all from -- and that is a question only
the first stage can answer. A session reaches
COLLECTING_PARTIAL_SIGNATURES because enough members offered a nonce, so
every member who could be holding it up has been heard from: the set came
back holding the members who were never chosen and owe nothing, while the
chosen signer whose partial signature went missing was named nowhere.
Once the unchosen had answered or refused the set was empty, and the
control gave up before it reached the branch written for the stall it was
meant to repair.
So the set asks what the stage can answer. Of the signers the coordinator
chose, who has yet to send a partial signature -- which is the half of a
resend only they can carry out, since a partial signature is read by
nobody but the coordinator and no other device can repeat it. COMPLETE
keeps the old reading, and correctly: the signature is the coordinator's
own and nobody answers it.
The screen now asks the manager who is owed rather than deriving it from
the rows beside the button, the way it already asks about approvals: the
same reading decides whether a resend publishes anything, and two copies
of a rule that changes with the stage is a screen offering a knock the
manager would refuse. The transcript line and the notice say what the
members named are short of, since past the nonces they have answered once
already.
The test that looked like it covered this passed because it wrote the
stage into the row with no nonce on file anywhere -- a state the protocol
cannot produce, and exactly the state that hid the bug. It now reaches
the stage by offering a real nonce.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
"In progress" was one chip over two situations that ask different things of
the reader, and collapsing them was the wrong call.
Short of members, a proposal can still die of indifference: refusals are
counted against `declinesThatAbandon`, so one more may end it, and a member who
is offline is indistinguishable from one who has not looked. It is also the
only stage the coordinator's resend is for. These are the proposals somebody
may have to do something about.
Once the signer set is written, none of that is true. `signerIds` is written
once and never revised, so no further refusal is counted against it, and what
is left is arithmetic the chosen devices have already committed to. Where one
asks whether this will happen, the other says it is happening.
So: WAITING_ON_MEMBERS and BEING_SIGNED, named for what the reader is waiting
on rather than for the protocol step -- "collecting nonces" is true and says
nothing. The icons carry it as well as the labels, people against machinery,
which is the only signal a monochrome display has.
What is *not* split, and the comments say why: whether this device was picked
to sign, and whether the reader agreed or declined. Those are facts about the
reader rather than states of the proposal, so they stay a sentence on the row.
Splitting on them would be splitting every state by who is looking.
The classification is now the stage plus one, which is the shape it was always
going to take -- the one being NEEDS_YOU, which no stage can express.
Six chips means the last two now sit past the fold at phone widths, so the
screen test measures order only over what the viewport lays out and the full
lifecycle order is pinned on the enum, where no viewport is involved.
1342 jvm tests pass, the Android target compiles, all audit budgets met.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The transcript's notice counts the proposals waiting on this member and says
so. A tap on it that then showed the room's whole signing history would have
the reader go and find the three it had just named for them, so the route
carries a filter and the notice asks for the queue.
`ProposalListRoute.filter` defaults to ALL, which is both the honest default
and what every caller predating it reads back as -- the group's own Proposals
row still means "show me the room".
The transcript's other way in turns out to be two ways, not one, and they
wanted different lists. A line too old to name its session could be about
anything the group has ever signed, so it opens the room. A tap held back
*because several decisions are waiting* was held back for those decisions, not
for the history -- so it opens on them. That decision now lives in
`proposalDestination` instead of in a condition nine levels down a LazyColumn,
which is the only way anything could be held to it.
Nine tests over the three branches, including that the queue is offered only
for the proposal actually tapped -- a line about something already signed is
history, and handing its reader the queue would invert what
`hidesOtherDecisions` is for. The filter's ride on a type-safe route is pinned
too: navigation reads an argument's NavType off the serial descriptor and takes
an ENUM as a string, so the test fails if the filter ever becomes a shape
navigation cannot place.
The notice's own one-line wiring is not itself covered -- it builds a route
inside the transcript's lambda -- so it rests on the route tests and on review.
1338 jvm tests pass, the Android target compiles, all audit budgets met.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Five chips under the app bar, each carrying its count, scrolling sideways. The
row is outside the list rather than its first item, because a control that
scrolls away is a control the reader has to scroll back for -- and the list it
filters is as long as the group's whole signing history. It scrolls rather than
wraps for the same reason from the other side: five counted chips do not fit
the sixty characters `readableContent` holds the column to at the largest text
size a reader can ask for, and a row reflowing to a second line moves the list
under the thumb about to tap it.
Unfiltered, the two sections stay. Filtered, they go: "waiting for you" against
"everything else" is a distinction the reader has already made by tapping, and
heading a single-state list with it would answer a question nobody asked.
A room with nothing in it gets no chips at all. Five chips reading 0 over an
empty screen would be five ways of saying what the empty state says once.
The screen also picks up the state widgets it never had -- `LoadingDataIndicator`,
`ErrorState` with an explicit `onRetry = null` because a room missing from this
device will not appear by looking again, and `EmptyState` with a message per
filter. That last one is the point: one shared default is how five different
absences here came to say one thing. A group never asked to sign and a queue
the reader has worked through are not the same fact, and the second is not an
absence at all -- it keeps the queue's own icon and reads as finished.
`initialFilter` reaches the screen and is applied in the view model's `init`,
so a `Loaded` handed in for a preview cannot open with its chips saying one
thing and its rows showing another. Nothing passes it yet.
Fourteen screen tests, and the audit's budgets all still met: 0 hardcoded
colours, 0 dp literals in spacing positions, 0 title-case strings, both floors
held. 1329 jvm tests pass; the Android target compiles.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>