Skip to content

Latest commit

 

History

History
292 lines (239 loc) · 95 KB

CLAUDE.md

File metadata and controls

292 lines (239 loc) · 95 KB

CLAUDE.md

Muster — a local-first client for coordinating multi-party transactions inside conversations, on the Logos stack. The conversation is the security boundary. The first mission is education: walk people through the entire transaction lifecycle, showing at each step how Logos maintains privacy and security and where other stacks leak (docs/00-vision.md). The end state is a usable client for doing things together, securely and privately.

Built as logos-core modules: a Nim backend (muster-module.lgx) and a QML frontend (muster-ui.lgx), hosted by logos-basecamp (GUI) and logoscore (headless). Full requirements: docs/01-furps.md. Phase plan: docs/02-implementation-plan.md. UI reference: ui/prototype/coordination-prototype-v2.html (tokens, components, copy voice) — a self-contained, no-crypto HTML/JS simulation of the six-step legend. It is not the app; it drives the QML build in P4 and should keep pace with the FURPS/plan as they evolve, but where prototype and FURPS conflict, FURPS wins. Layout reference for the desktop redesign (epic exo-720, docs/design/ui-modernization.md): ui/prototype/desktop-v3.html, on Logos.Theme's own token values; where v2 and v3 differ on layout, v3 wins.

Invariants — violating any of these is a bug, whatever the tests say

  1. Effects are reviewed; materializations are signed; the client re-derives the materialization and refuses on mismatch. This check lives in the module core and cannot be disabled (F-4, FS-6).

  2. Every signing payload commits to environment, account, slot, and expiry. A signature must be worthless anywhere else (F-5, FS-3).

  3. Plugins never sign, never hold keys, never touch the network. They emit typed blocks only; there is no plugin canvas (F-12, F-13, FS-5).

  4. State = reduce(log). Nothing exists that can't be rebuilt from log + keys. Reducers are idempotent; convergence under reorder/duplication is a property test (R-2, R-3).

  5. Deterministic bytes on signing paths. The same value always encodes to the same bytes: CDE bytewise-lex map ordering (never length-first), shortest integers, no indefinite lengths, no floats. Every hash is a domain-separated hash-input record; no ad-hoc concatenation. This is ours to enforce — the platform's own transport encoding is non-canonical, so determinism cannot be inherited.

    5b is not an invariant: which profile derives schema identity is versioned and swappable. Every signing payload carries profile + schema-id; v0 uses hand-assigned ids (muster.event.*.v1), cdCDDLe schema roots slot into the same field when those specs ratify (ADR-009). Do not let 5b's flexibility leak into 5 — changing the derivation must never weaken F-5.

  6. The core never interprets contribution bytes — drivers do. Rounds, serialization domain, threshold, and finality are driver-described, never hardcoded (F-6, F-7).

  7. Membership epochs are real: adding a member re-keys forward; they cannot read earlier epochs (F-16). The UI seam depends on this.

  8. No server, no telemetry. Store nodes and RPC are untrusted, user-configurable infrastructure (FS-1, FS-8).

  9. What the client says about a member is only what that member disclosed. Readiness, offers, and the holdings catalogue grade your own keys and holdings; nothing reveals which other member holds what. Every driver is named — members know who approved, declined, or shared, inside the room and never outside it (FS-7). Anonymous membership was retired (ADR-015, spec derived-exo-f60 → contracts/specs/retired/); reintroducing it is a deliberate relaxation behind a new ADR.

  10. Nothing is signed whose inputs can't be accounted for. Every signing payload commits to a provenance record naming, for each input that reached the signed bytes, its class (plugin block, driver-interpreted contribution, external read, peer message) and its log position — and signing is refused when any input's origin is unaccountable. Invariant 1 proves a materialization is consistent with its effect; it says nothing about where the effect's inputs came from, so correctly-derived data of unknown origin passes it. The record names the account that contributed each input — every participant could disclose the same fact anyway. The boundary that matters is the conversation, not the participant — the record is a reduction over the log rather than a side-car store (4), and is scoped to the membership epoch of the entries it describes, so a later joiner cannot read earlier lineage (7) — the boundary is the room, not the participant, who can always disclose what they legitimately hold (F-20, FS-10). Spec derived-exo-3a1.

Pattern sources

The contract is muster.lidl — LIDL (logos-co/logos-lidl) is the platform's language-neutral module contract, and Muster is contract-first: methods, events, and record types are declared there and the callable surface is generated from it. Its type vocabulary is CDDL's (tstr, bstr, int, uint, ?, ;) plus result; its spec is explicit that CDDL describes data and LIDL describes interfaces — so CDDL-family types describe our log, LIDL describes our API, and wire encoding is out of LIDL's scope entirely. Never hand-write what the contract should generate.

The Nim gap is filled — muster consumes a Nim SDK. What was once "write a codegen backend over lidl_c.h" became logos_sdk, built and then extracted to its own repo, corpetty/logos-nim-sdk (mirrors logos-rust-sdk: an lp_* runtime + a LIDL→Nim generator). muster depends on it via a codegen.nim.packages entry in module/metadata.json (owner corpetty, repo logos-nim-sdk, subdir src): delivery.nim + muster_module.nim import logos_sdk/{ffi,bytes,api}, and nim-lib/muster_gen.nim is generated by the SDK's lidl-gen (run via tools/regen.sh, which fetches the SDK at the pinned rev). The generator still binds the canonical LIDL frontend over lidl_c.h's JSON bridge (lidl_parse_to_json etc.) — free every returned string with lidl_free_string, and read optionality from the derived isOptional/valueType keys — but that lives in the SDK now, not here. Bump the metadata.json rev+hash when the SDK runtime changes.

The Nim-behind-FFI half is logos-storage/logos-storage-nim → logos-co/logos-storage-module: a Nim engine behind a C API (library/libstorage.h) with generated module glue. Copy its FFI shape and its async-callback seam, including the abandoned flag that prevents use-after-free on caller timeout. Built with mkExternalLib + logos-module-builder from one metadata.json (ADR-008).

Read, don't copy:

  • logos-co/logos-core-poc2 — a Nim reading of the draft specs. Take its nimble.lock pin set and project mechanics; do not lift shell.nim — its symbol set targets a runtime logoscore does not load. Its schemas.nim is a line-based CDDL extractor and cbor_stuff.nim defers canonicalization; both are ours to build properly. Its tests track behavior, not intent — never copy them as spec.
  • logos-co/logos-lips branch draft/logos-core-module-specs — the LOGOS-MODULE-* specs and cdCDDLe. Unmerged draft, tracked not targeted. Adopt the cheap invariant-critical parts (deterministic encoding, domain-separated hash inputs); defer schema roots and verified views until ratification. Where any of it diverges from what logoscore actually loads, the shipping host wins.

Re-validate the stack decisions table in docs/02-implementation-plan.md against upstream HEADs at the start of every phase. The platform moves faster than these docs.

Working agreements

  • chronos only; never std asyncdispatch.
  • Conformance suite (module/src/drivers/conformance.nim, run by tests/conformance_test.nim) before driver features; never merge with it red. A driver is a complete unit behind the Driver seam — describe (coordination policy), canonicalize (effect→signable bytes, a driver method since 2026-08-23), verifyContribution — and checkConformance grades stub, Safe, and any new driver identically.
  • Integration tests use the stub driver and local transport — never mock Driver or Transport.
  • Invariant tests are append-only. Extend, don't weaken.
  • Each phase's accept criteria become an integration test (Nim headless, or a logos-qt-mcp script for UI phases) before implementation.
  • The module imports nothing from ui/. The UI reaches the module only through the logos API under capability policy. Inter-module calls go through logos-core.
  • The educational layer explains what the code already guarantees — it never adds a code path the invariants don't cover. If a lifecycle step can't be shown truthfully, that's a product bug, not a copy problem.
  • A runner build (make build) takes more than 7 GB just to evaluate the flake, and on 2026-10-05 it froze the operator's workstation. Ask before starting one. make build, build-lgx and appimage cap themselves when BUILD_MEM is set (uncapped by default, so a fresh clone builds anywhere); on a machine short of memory, set it in the shell profile (export BUILD_MEM=10G) and wrap any other evaluation of the flake in the same cap. Reuse an existing runner when the change touches nothing compiled into it. See .claude/doctrine/codebase.md § Runner builds.

Layout

What exists today (the real module/+ui/ build landed P0→P2 and the P4 UI spike across 2026-08-19/20):

module/          Nim core behind the muster.lidl contract → muster-module.lgx
  src/api/       muster.lidl (the only outward seam) + generated surface
  src/dcbor/     deterministic CDE encoder (inv 5)
  src/hashing/   sha256 · keccak256 · domain-separated hash-input records (inv 5)
  src/log/       content-addressed, hash-linked log, epoch-sealed, reduce(log) (inv 4) — kind-agnostic; author signatures live in coordination/authorship · `after` (the heads a publisher had seen; outside the id, read by no fold) and `causalOrder` for views — exo-655, docs/design/causal-parents.md
  src/intents/   lifecycle (F-3) · materialization · signing_payload · provenance · disclosure (observer classes + the FS-9 baseline rows, exo-002)
  src/drivers/   driver interface (inv 6) · profile (the multisig family each driver implements, per instance: locus/scheme/binding/…, CAIP-2 chain, CAIP-10 account, k of n — held to contracts/families/registry.json, exo-a50.1.1) · manifest (the per-action manifest: agreement/requirements/disclosure/touches, `Driver.manifest(effect)`, conformance-checked — exo-002.1) · safe · safe_rpc (P2 wedge) · threshold · frost · invoke · eip191 · btc_multisig (P2WSH sortedmulti + tapscript multi_a, exo-a50.2) · lez_multisig (the vote locus: pointer effect, vote receipts, S5 reads, exo-a50.3; and the config effect — add, remove, threshold — re-read before a vote and settled by ExecuteConfig, exo-267.6) · frost_group (a FROST group: the two rounds' contributions, verification, aggregation — shared by every aggregate-locus family) · btc_frost (btc.frost-bip445: a ChillDKG taproot account, key-path spend, Phase D) · lez_frost (lez.frost-public-account: the group's untweaked LEZ public account, lez-call at a chain-read nonce, exo-55e) · inapp (in-app signing as a driver hook) · interop (signers outside muster, seam S8) · lez_msig (lez.msig: a LEZ program that verifies M-of-N BIP-340 approvals itself at execution; the effect is the proposal's exact bytes; per-multisig approval keys named msig:<key> — exo-0d3, docs/design/lez-msig.md) · split (a bill split: the `each` locus — no shared account, the debtors named in the effect, each pays their own share; evm.split + lez.split, the private split, exo-a90 + btc.split, exo-d17 + monero.split, the XMR payment request, exo-dcc.5) · charter (a room's charter: who decides it and how many named in each charter's effect, so a later join never unmakes it — exo-267.1) · xmr_msig (monero.multisig-coordinated: the members' own Monero multisig wallets, a spend each wallet's `describe_transfer` must match before it signs, two rounds; stagenet, pre-FCMP++, ADR-020 — its setup and spend carried by the room, in the UI from S4, not yet run on stagenet, exo-dcc.34; runbook docs/runbooks/xmr-multisig.md) · kinds · registry · conformance
  src/crypto/    secp256k1 (authorization identity) · curve25519 (Ed25519/X25519 encryption identity, F-14) · binding (secp↔enc link statement, F-14/F-9) · conversation (ConversationCrypto seam) · epoch_crypto (ECIES-via-sealed-box stopgap, F-16) · sodium (libsodium AEAD + Argon2id) · keystore (two-identity seam, FS-4: file stopgap + in-memory) · account_labels (the keystore labels a member's own LEZ accounts live under: lez-member/0, lez-account/<n>; found by deriving, never disclosed, exo-1f9) · blob_seal (FileShare's sealed blobs: a fresh secretstream key per file, the plaintext digest checked on open, a neutral upload name, exo-4d0.3) · platform_identity + platform_identity_lp (the room identity in the person's keystore_module, through signer_manager_module's record / open / secret legs, inside the unlock granted muster; setting identity-backend, set before any room is joined; exo-833)
  src/transport/ transport (F-15 interface + LocalTransport) · delivery (DeliveryTransport, over the SDK's `logos_sdk/ffi` lp_* binding) · inbound_queue (foreign-thread seam) · infra (inv 8) · node_config (the node's createNode config: fleet, the `mix` setting) · store_catchup (the store poll, page by page) · mix_status (the mix path as one status row, exo-dcc.4)
  src/storage/   the storage seam (F-17; FileShare, epic exo-4d0, docs/design/room-swarm.md): blob_store (BlobStore + LocalBlobStore, the stand-in modelled on what S0 observed) · storage_events (replies, events, jobs; pure) · storage_readiness (storage_module graded registry-first: not installed names the package) · storage_lp (storage_module over lp_*: attaches; where it must start a node, keeps it to this instance and restores the shared config)
  src/coordination/ session (multi-instance flow) · room_charter (the charter in force as a fold: a founding every member it names agreed — among rival foundings the one naming everyone the others name, never the lowest id; foundings by groups neither of which includes the other are contested — then amendments under the charter in force's own rule, competing ones resolved the same on every member; charterProposal (a founding or an amendment, from a body or the circle template) and charterJson (each charter proposal's standing before anyone signs) behind coordinate_charter / coordinate_propose_charter and the room's Charter tab — exo-267.1) · quest (quests in the room: terms hashed into the record, the Open/Close/Cancel calls a LEZ multisig proposes and the Accept/Confirm a person sends, questsOf, and verifyQuestAttestation — what an outsider checks from chain reads alone; exo-267.8) · member_changes (a LEZ multisig's members and threshold from the room: ProposeConfig / ExecuteConfig voted like any proposal, the card naming the member whose shared account it adds or removes; a removal the chain executed carried into the room — the proposer's client re-keys the member out once, CoordinationSession.expel, F-16 removal — and who-can-read follows; coordinate_propose_lez_config — exo-267.6) · circle (a savings circle's rounds from the pot: the charter in force names a LEZ v0.3 multisig and a schedule; each member's pay-in counts only when the chain holds it — included, exactly the share into the vault, signed by an account its member shared with the room, one transaction per round — and a payout is matched to its round or flagged off schedule before anyone votes; behind coordinate_circle / _circle_pay_in / _propose_circle_payout and the Charter tab's rounds — exo-267.3) · swarm + swarm_live (FileShare: the room as tracker — file/<fid>, seed and retract events, author-signed, folded by reduceSwarm; share, fetch and seed from a pump; spec derived-exo-4d0.4) · authorship (exo-f76: the five kinds that name an author — message, decline, material share, account disclosure, FROST join — carry that author's Ed25519 signature bound to the room; roomEvents(s) is the room's authentic view every hosted read goes through, buildProof alone reads the raw log) · intents (intent lifecycle = reduce(log); gates approvals on their attestation) · intent_events (event constructors) · live (the hosted propose/contribute path, driveable in-process) · home (what waits on THIS member, per room: needs-you / waiting-on-others / settled, F-18, exo-ed5) · joined_rooms (the rooms this member joined, kept beside the keystore and re-entered on relaunch, exo-ecbe) · room_journal (each room's own copy on the member's machine: its data and grant frames, still sealed, replayed grants-first on re-entry, so a room outlives the store's copy, exo-dcc.14) · covers (an effect settling parts of OTHER intents, checked against them — exo-3c6) · settle_up (netting the room's open split shares — exo-3c6) · attest (invariants 2+10 live: the intent context, log-derived inputs citing content ids, the same-key attestation over P, approval grades — exo-ef1) · audit (the signature-audit file: export / verify-from-the-file-alone / report — exo-403) · room_graph (the room map: the room as nodes and edges folded from the log — members, intents, entries, what left to whom, what came in; an actor named only where the log proves it; each entry's epoch from the key that opened it, `CoordinationSession.sealedIn` — exo-dde, docs/design/room-map.md) · vote (a vote-locus approval = the member's own on-chain vote: S5 re-read, cast, confirm, receipt — exo-a50.3) · parts + parts_evm + parts_lez + parts_btc (settlement in parts: a party pays its own part — derived from the agreed effect — the counterparty confirms from its own read; PartSeam, a fake ledger, the EVM seam, the LEZ private-rail seam whose creditor confirms by scan, the Bitcoin seam — the payer's own wpkh key and node, the creditor's node confirming an exact output at depth — exo-a90.4, .9, exo-d17) · parts_xmr + xmr_request (the XMR payment request, and sending XMR — a request on the payee's behalf with the sender its only payer, at the address they shared, never one already backing a payment, exo-dcc.32: each debtor's monero: link derived from the agreed effect, "I paid" a claim only, the creditor's own Monero wallet history confirming each part — exo-dcc.5, docs/labbook/xmr-payment-request.md) · module_registry (a module need in three states — not installed, installed but not running, running — from Basecamp's `modules_state`; never calls a module that is not ready; names the package to install, exo-dcc.10) · keystore_approval (an approval a person signs in `keystore_module`'s signer, exo-149) · xmr_msig_setup (a Monero multisig set up over the room: each member's own wallet runs the exchange, the room carries its rounds in order, the account acted from once every member disclosed it, ADR-020 S2) · xmr_msig_spend (a spend from it: the first M agreements are the signers; each signer's wallet syncs, the first builds, each next signs only after its describe_transfer matches, the last submits; final at 10 confirmations; one spend per wallet in flight, ADR-020 S3) · attest_typed (ADR-017's EIP-712 form of the attestation and binding, K6b) · msig_room (a lez-msig made together: open, each member's approval key proved by itself and author-signed, the opener creates and discloses; proposing at the chain's epoch and next free nonce — exo-0d3) · member_accounts (a member shares an account of their own with the room — member/<who>/account/<address>, proved by its own key for that member in that room, author-signed, retractable — usable as their approval key when the room sets up a lez-msig, exo-1f9)
  src/wallet/    chain-agnostic wallet (F-Design): types (Account/AssetId/Amount over stint UInt256) · adapter (ChainAdapter seam + Wallet aggregate) · evm_adapter (ETH + ERC-20 · verifiedBalance via eth_getProof · client-side signing) · evm_rpc (typed eth_* over nim-web3, sync via waitFor) · evm_sign (nim-eth EIP-155 tx signing via the keystore seam) · mock_chain (non-EVM: shielded accounts, delayed finality) · lez_core (LezCore seam + FakeLezCore) + lez_adapter (the real LEZ ChainAdapter: public/shield/deshield/private rails + per-rail disclosure, receive-by-scan, delayed finality) + lez_lp (LpLezCore — the real lez_core over lp_*, async proving, a scan that walks to the tip in bounded steps, saved after every change, its accounts named by wallet labels; gated MUSTER_LEZ_REAL) + lez_encoding (amountLe16Hex + the wallet config's zone) · verify (nim-eth verifyMptProof — Nimbus verified-proxy core, in-process, F-10) · rpc_budget (every chain call under a chronos deadline — reads 5 s, sends 30 s, bitcoind's UTXO-set scan 5 min — so a hung endpoint never holds the module thread; a null read raises, exo-14f, exo-496) · btc_adapter (BitcoindAdapter over the user's own node: scantxoutset / sendrawtransaction / confirmations, exo-a50.2.5) · xmr_msig_wallet (a member's own monero-wallet-rpc for the multisig, setting `xmr-msig-rpc`: setup, sync, build, describe, sign, submit, ADR-020) · monero_backend + monero_backend_lp (the creditor's wallet seam over monero_wallet_backend: a closed read-and-mint call set, never a spend, exo-dcc.5) · chain_endpoint + eth_rpc_lp (an EVM endpoint is a URL or `logos:eth_rpc_module/<chainId>`, exo-d4d) · tx_sender + tx_sender_lp (every EVM send through the platform's `tx_sender_module`, refused unless what it prepared is what the room agreed, exo-d4d) · support (Like Muster?: the project's tip addresses, pinned in `support.json` and published at the site's /support/ from the same file, each held to its own network; a tip goes only to a pinned address, from a wallet the person connected, exo-168) · lez_msig_chain (lez-msig's chain seam, the public posture) · lez_msig_private (its private posture: state from the room's newest note, every transaction through the prover, exo-efa) · msig_prover + msig_prover_lp (the prover seam: the `lez_msig_module` over lp_*, or its `msig_exec` CLI for tests) · lez_msig_chain (lez-msig's chain seam: read its state, send its instructions from the member's own funded account, exo-0d3)
  src/bitcoin/   Bitcoin primitives (exo-a50.2): tx + segwit serialization · BIP-143 / BIP-341-342 sighash · sortedmulti + multi_a scripts · bech32/bech32m · taproot (NUMS internal key, control block) · DER / BIP-340 keys · PSBT v0 + BIP-371 (canonical form = dCBOR, never PSBT bytes) · networks (CAIP-2)
  src/settlement/ the settlement seam (exo-a50.1.5): chosen by the driver's profile, assembled from the log, through the ChainAdapter — SafeSettlement · BitcoinSettlement · LezMultisigSettlement (counts the votes on chain)
  src/frost/     threshold Schnorr (exo-a50.4): secp (points with infinity, scalars mod n) · signing (BIP-445 FROST, all draft vectors) · chilldkg (the ChillDKG ceremony, all draft vectors) · schnorr (BIP-340 with a tag prefix, ECDH) — demo-grade, not constant time
  src/lez/       LEZ programs (exo-a50.3): multisig (lez-multisig's borsh state/proposals, SPEL seeds, versioned PDAs) · multisig_chain (the chain seam + FakeLezMultisig, the program's handlers in process) · tx (LEZ public transactions as bytes: v0.2.4's risc0-serde instruction + borsh message, and v0.3.0's program shards, borsh instruction and fee declaration; BIP-340 witnesses; both held to vectors from LEZ's own crates; and a v0.3 transaction read back from getTransaction, held to a real sequencer's answer, exo-267.3) · account_view (getAccount on either line: v0.3's program shards and native balance) · msig (lez-msig's bytes: its types, borsh, tagged hashes, public PDA and the card's decode, held to the program's own vectors — exo-0d3)
  src/monero/    Monero for the XMR request (exo-dcc.5), pure, no keys: address (Monero's block-wise base58, the network tags, standard/subaddress/integrated, CAIP-2 by genesis-hash prefix, `acceptablePayTo`, the `monero:` URI) · point (the subgroup check wallet2's `check_address` makes) — held to monero-project's own vectors
  src/plugins/   plugin sandbox (inv 3)
  nim-lib/       muster_gen.nim (generated) + muster_module.nim (hosted surface)
  tools/         regen.sh (fetches the SDK's lidl-gen at the pinned rev + regenerates muster_gen.nim) · muster_audit_verify.nim (standalone audit-file verifier, exo-403)
  tests/         lifecycle/safe/crypto/transport/coordination tests + tests/probes/ (75 invariant probes — each an oracle of a typed spec in contracts/specs/) · run-suite.sh (the whole suite, one command)
programs/lez-msig/ the lez-msig LEZ program (RFP-005, epic exo-0d3, docs/design/lez-msig.md): core (msig_core, the rules as pure functions, no LEZ dependency) · v03 (the v0.3 wire types + account derivation) · methods/guest (the run_program(plan, apply) adapter; accelerated k256) · host (msig_host: both postures on LEE's state, the real-proving benchmark, the vectors muster's port is held to) — BENCHMARKS.md
ui/              QML view + C++ backend → muster-ui.lgx (Logos.Theme, ADR-011)
  src/qml/       Main.qml · src/muster_ui_backend.{cpp,h} · muster_ui.rep
infra/anvil/     devnet.sh: anvil + the REAL Safe v1.4.1 (singleton, factory, fallback handler, a 2-of-3 proxy) + foundry
demo/            the speed build — runnable, and deliberately not the specified client
  muster-ui/     fork of logos-co/logos-chat-ui: QML + QtRO C++ backend, wallet journey
  poc/           LEZ private-transfer POCs + upstream bug write-ups
docs/            00-vision · 01-furps · 02-implementation-plan
  diagrams/      the figure programme, its manifest, and the rot checker
  labbook/       traps found the expensive way
  posts/         campaign write-ups
contracts/specs/ typed specs with acceptance oracles, one per invariant (derived-exo-*)
contracts/families/ the multisig family registry · actions/ the action corpus (exo-661): generated.json (built drivers' describe/profile/manifest, from module/tools/action_corpus.nim, held by action_corpus_test) + family/<id>.json, room.json, wallet.json (authored, checked by scripts/check-action-corpus.py) — rendered by docs/design/multisig-atlas.html, served at https://corpetty.github.io/muster/atlas/
ui/prototype/    coordination-prototype-v2.html — the standalone HTML reference build · desktop-v3.html — the desktop layout reference (exo-720)
catalog/         Muster's own Basecamp catalogue (exo-dcc.3): logos-repo.json, and index.json + icons/ once a release is up; publishes muster_module and muster_ui, and lez_msig_module (the private lez-msig's prover, optional, linux-amd64 only, since 0.3.3), every other dependency from Logos Official; `.lgx` files are `muster-v<version>` release assets (catalog/README.md)
site/            index.html — the Pages landing page (https://corpetty.github.io/muster/); scripts/build-site.sh assembles it with docs/diagrams/ at /diagrams/ and the atlas at /atlas/, and checks every relative link
ui-nim/          the UI in Nim on nim-seaqt + nimside (epic exo-607, docs/design/seaqt-ui.md): flake.nix pins seaqt qt-6.11 on nixos-unstable's Qt 6.11.2 and rebuilds liblogos_core + liblogos_protocol on it (T1b, ADR-019; nix/nixpkgs-app — the module processes keep Logos's Qt 6.9.2) · nix/seaqt-app.nix · hello/ (T1) · contract/ (T2: repContract, the .rep → nimside qobject: macro, checked index for index against repc) · app/ + headless/ (T4a–T7: muster-app, the standalone Nim UI — the real QML, every SLOT and the autopilot in backend.nim, muster_module through the client generated from muster.lidl, async; parity 11/11) · nix/seaqt-ro.nix + nix/seaqt-gen-patches/ + ro/ (T3: QtRemoteObjects bindings generated at build time, never committed)
programs/        LEZ programs muster authors: lez-quest/ (the quest record program on LEZ v0.3.0, exo-267.7 — Rust, plan/apply, a risc0 guest, an e2e on a local zone; read by module/src/lez/quest.nim)
scripts/         git hooks

Not yet present — do not cite as though these resolve: module/src/schemas/ (no CDDL parser / cdCDDLe in v0, ADR-009); cross-host (two-instance) coordination over the network (the room's verified propose/contribute path landed 2026-08-24 — cards render from the coordinate_intents fold, propose → coordinate_propose, approve → an owner signature the driver verifies via coordinate_contribute; delivery_module now rides the standalone runner's module set and loads+initializes, so coordinate_join resolves; two instances now converge over the live Logos fleet — the membership handshake works end to end (join → ask → admit → both at two members), 2026-09-01, see below — but the cross-host Safe-txn half (propose → sign → settle over the live wire) still needs a two-machine end-to-end run — the peer seeding it needs now exists (MUSTER_DEV_SECP_KEY / scripts/demo-peer.sh), so what remains is the run + the R-4/R-6 kill-mid-collection resilience check (cross-host receive is ~1s after exo-38e)); the wallet's own Mode A send UI driven live against testnet.lez.logos.co (the real core's shield and private rails and its receive-by-scan HAVE run there, inside the private split's testnet run, 2026-09-28); the plugin runtime beyond the sandbox type (P5); for Monero (epic exo-dcc), a live XMR payment between two machines (exo-dcc.19: it waits on stagenet XMR for the payer), paying from Basecamp's own Monero wallet (exo-dcc.6: it waits on an upstream review intent), and Monero mainnet (exo-dcc.8); RLN on logos.test past R1 — R2 (one membership active end to end), R3 (the room gifter the demo runs on), R4 (the default fleet moves to logos.test); a local copy of each room's log (a room lives only as long as the fleet's store keeps it, exo-dcc.14). (Room-side submit and multi-room have landed — see the current-phase section; do not cite them as absent.) The module/ flake pins logos-module-builder to a GitHub ref on the fork (corpetty/logos-module-builder@codegen-on-basecamp, c10a94c): basecamp's coherent builder plus the three codegen commits muster needs. #202 merged the codegen.nim path; the nim.packages + RUNPATH half is still upstream-pending in #226. No machine-local path: a fresh clone builds (verified 2026-09-25, docs/04-session-handoff-2026-09-25.md).

ADRs are not in docs/adr/; they are a section of docs/02-implementation-plan.md.

Commands

These run today. The root Makefile drives the real client (module/ + ui/); demo/ keeps its own Makefile for the speed build.

make build                                      # build the standalone runner into .run/runner (the slow first build; uncapped unless BUILD_MEM is set, `make help` says which)
make run                                        # launch the real UI standalone (logos-standalone-app), seeded as anvil Safe owner 0
make run-fleet PEER=alice                       # a peer on the live Logos fleet; PEER=bob in a second terminal (auto-seeded owners 0/1)
make clean-peer PEER=alice                      # wipe one peer's identity + wallet (seeding applies only on a fresh identity)
scripts/try-infra.sh up                         # every local chain the hands-on tour uses, own ports: anvil :8555 (the real Safe + the MTD token), bitcoind regtest :18453 (payers + 2-of-3 multisigs funded, a block every 10 s); addresses in .run/try/env; also status | env | down | btc … | eth …
infra/lez/localnet.sh                           # a local LEZ v0.3.0 zone on :3040 with a genesis-funded funder (LEZ v0.3 has no faucet); fund <account> <amount> | deploy <prog.bin> (a v0.3 program through program_loader) | status | stop; MUSTER_LEZ_VERSION=v0.2.4 for the multisig/FROST e2e tests (exo-eb6.4)
infra/lez/funder.sh [--zone local|testnet|<url>] account | balance | fund <id> <amt> | deploy <prog.bin>   # the zone's funder: on the testnet the one account to fund (no faucet on v0.3); every live run draws from it (exo-eb6.4.5)
scripts/lez-local-self-test.sh                  # a runner's real LEZ wallet on that zone, funded by the funder, reads its balance through lez_core
scripts/try-peer.sh alice --fresh               # a peer seeded for that infra on the live fleet (bob/carol in more terminals; --lez for the real LEZ wallet) — the tour: docs/runbooks/client-tour.md
make help                                       # every target
module/tests/run-suite.sh                       # every unit test + invariant probe, in parallel; the Nim closure at metadata.json's pins
module/tests/run-suite.sh e2e <name>            # one chain-bound test (TEST_ARGS= for its args); bring its chain up first — module/tests/README.md
scripts/card-self-test.sh                       # offscreen UI round trips; also install-self-test.sh (a module the host lacks reads unknown, names the package to install, never blocks the module thread, exo-dcc.10), infra-, audit-download-self-test.sh, two-instance-proof.sh, relaunch-self-test.sh (a relaunch re-enters its rooms, exo-ecbe), invite-proof.sh and split-self-test.sh (live fleet; the split also runs a throwaway anvil; split-btc-self-test.sh a fresh Bitcoin Core regtest, under `nix shell nixpkgs#bitcoind`); split-lez-testnet.sh is the private split on the LEZ testnet (real lez_core wallets, two proofs — ~25 min; wallets kept in .run/lez-split; v0.3 has no faucet, so B waits for someone to fund it), or with LEZ_SPLIT_ZONE=local on a local v0.3 zone whose genesis funder funds B (dev-mode receipts, ~1 min). Each kills only its own instances (per session, `scripts/lib/ui-build.sh`), never another session's runners; `MUSTER_UI=nim` points them at the Nim (seaqt) build
scripts/lez-msig-self-test.sh                   # lez-msig (exo-0d3): two runners in one room and the program on infra/lez/localnet.sh; A opens a 2-of-2, both join with their own approval keys, A creates + discloses, A proposes a payment, B approves on the card, A settles — the program pays (MSIG_PROGRAM to skip the deploy)
module/tests/run-suite.sh e2e lez_msig_private  # the PRIVATE lez-msig from a room (exo-efa): a sealed group secret, Create / deposit / a 2-of-3 payment through the prover (`msig_exec`: cargo build --release -p msig_host --bin msig_exec in programs/lez-msig), on a dev-mode local zone; MUSTER_LEZ_MSIG_PROGRAM=<deployed>
scripts/fileshare-self-test.sh                  # FileShare (exo-4d0): two runners in one room, each with its own storage_module node on a private storage network, own HOME each; A shares a 3 MB file, B fetches it byte-identical and seeds it. Storage asks for the Storage team: docs/design/storage-asks.md
scripts/split-xmr-self-test.sh                  # the XMR request through the real runner, offscreen and with no Monero wallet (the runner bundles none): the bare kind lands on stagenet, Propose and Share are refused naming Open Monero Wallet and Install, nothing reaches the room; the paid path is held by the probes (exo-dcc.5). Also founding-relaunch-self-test.sh (a founder relaunched before admitting anyone reads its room again, exo-6dc.1)
ui/tests/qrcode-test.sh                         # QrCode.qml decodes back to what it encodes (zbarimg), no display, no runner (exo-dcc.5)
scripts/catalog-release.sh                      # muster_module + muster_ui for every platform from CI's lgx-variants build of HEAD (dispatched and awaited if none; --here builds for this host only), lez_msig_module built here, and catalog/ written (exo-04f); publishes nothing, prints the release commands (catalog/README.md); --local DIR --base-url https://… for a local https test (docs/runbooks/install-from-catalogue.md)
scripts/release-appimage.sh --lgx-dir .run/catalog-release/muster-v<version>   # the release AppImage: Basecamp's released AppImage + those two .lgx + the pinned Logos Official deps (infra/basecamp/bundle-<tag>.tsv), repacked; `make appimage` builds it from the tree (RELEASING.md)
scripts/ui-parity.sh                            # the UI parity suite: every offscreen self-test above, one at a time, green/red table (MUSTER_UI=cpp|nim, exo-607 T0); MUSTER_FLEET=local runs it on a network the instances make on this host, no fleet (exo-eb6.7)
cd ui-nim && nix build .#checks.x86_64-linux.hello   # the seaqt toolchain gate: nimside qobject: ↔ QML, against the runner's own Qt 6.9.2 (exo-607 T1)
scripts/nim-app-core-probe.sh                   # exo-607 T4a (option B): the real QML in a Nim host that starts logos-core itself and calls muster_module over lp_* (needs make build)
scripts/nim-headless-probe.sh                   # exo-607 T7: the Nim headless host (ui-nim/headless, stdin → lp_* calls) drives muster_module (needs make build)
python3 scripts/check-no-cpp.py                 # no C/C++ outside ui/ (the frozen Basecamp build) and demo/ (exo-607, ADR-019; pre-commit)
make build-nim                                  # exo-607 T6: the Nim UI's runner, .run/runner-nim (the C++ runner's modules; needs make build); then MUSTER_UI=nim make run, or MUSTER_UI=nim scripts/ui-parity.sh (11/11, as C++)
scripts/grade-specs.sh [exo-xxx]                 # grade the typed specs with exophial's own oracle (links the probes' closure into module/.probe-env, exo-a7b)
python3 docs/diagrams/tools/check-manifest.py   # figure-provenance gate (--update, --stamp)
python3 scripts/check-readme-rot.py             # entry-point README staleness gate vs the Current-phase section (--stamp)
python3 scripts/check-claims-registry.py        # ADR-012 claims registry: every protects→requirement+test, every gap→fix+status
python3 scripts/check-family-registry.py        # multisig family registry + the landscape table (exo-68f)
python3 scripts/check-action-corpus.py [--write] # the action corpus resolves; --write re-embeds it into the atlas (exo-661)
TEST_ARGS=--write module/tests/run-suite.sh action_corpus   # regenerate contracts/actions/generated.json after a driver change
python3 ui/tools/gen-claims-qml.py [--check]    # regen ui/src/qml/ClaimsRegistry.qml from the registry (CI checks drift)
python3 scripts/check-run-targets.py            # run instructions resolve (make run / nix runner / README agree)
cd demo && make app && make alice               # the speed build (demo/README.md); `make bob` for the second peer

The real module/+ui/ build (every flake input is a GitHub ref, so a fresh clone builds; build via cache.nix.logos.co as a substituter — the user is not a trusted nix user, so pass --extra-substituters explicitly):

cd module && nix build .#lgx            # muster-module.lgx (dev, keyed linux-amd64-dev)
cd module && nix build .#lgx-portable   # portable variant (keyed by the host: linux-amd64, linux-arm64, or darwin-arm64 on an Apple Silicon Mac — docs/runbooks/macos.md; logoscore's default resolver wants this one)
cd ui     && nix build .#lgx            # muster-ui.lgx (follows module's builder pins)
module/tests/run-suite.sh probes                    # the invariant probes (no host); a single test: run-suite.sh <substring>
# Load headless: lgpm install --file ./result*/*.lgx --modules-dir <dir>; logoscore -m <dir> -l muster_module -c 'muster_module.health()' --quit-on-finish

Not yet wired as one-shot targets (listed as the intent, not something to run):

nix build '.#tests'              # the suite as a nix check + a CI job (run-suite.sh is the one command meanwhile; no CI runs it, exo-1ec.2)
nix run  '.#integration'         # two isolated logoscore instances, stub + safe drivers
nix run  '.#anvil'               # local chain with Safe fixture (infra/anvil/devnet.sh runs it; no flake app yet)
# UI e2e (P4 acceptance): logos-basecamp --user-dir per instance + logos-qt-mcp scripts — BLOCKED on the SDK-rev skew, see Current phase

Current phase

P3 — real transport + encryption; two instances converge over the live Logos fleet (membership handshake end to end, 2026-09-01); latency polish + room-side submit + multi-room landed; the multisig families (epic exo-a50, Phases A–D: Safe fidelity, Bitcoin via PSBT, the LEZ multisig program, FROST) landed 2026-09-24/25. What remains: the multi-party runs across two machines — the cross-host Safe-txn settle over the live wire + R-4/R-6 resilience, the LEZ multisig propose → vote → settle, a FROST ceremony. Since 2026-10-07 the work aims at the Monero community campaign (epic exo-dcc, below): the XMR payment request landed 2026-10-09; its live stagenet run waits on funds. P0–P2 and all 11 invariant pebbles landed by hand (the suite is now 92 invariant probes + 163 unit tests, 255/255 green in module/tests/run-suite.sh on 2026-10-14; first verified on a second machine 2026-09-25); P4 shipped; P3's core is done and the two-instance live wire works for membership (join → ask → admit → both at two members, over the public fleet). The whole transaction lifecycle runs in the UI, multi-party coordination of real intents works end to end, and the room settles Safe intents on-chain (coordinate_submit, proven on anvil) at the Safe's live nonce.

Shipped since P4: releases — the current one is muster-v0.3.3 (2026-10-23; lez-msig, FileShare, the Monero fixes, delivery >=0.3.2): the portable .lgx files the catalogue serves (and lez_msig_module, the private multisig's prover), and an AppImage, Basecamp 0.3.2's own release with Muster and its Logos Official dependencies installed inside (scripts/release-appimage.sh, RELEASING.md). The older demo AppImages v0.1.0-demo and v0.2.0-demo (2026-09-21) stay up for the record but cannot share a room with today's builds, whose wire format changed. Also shipped: the two-party Safe+FROST runbook docs/two-party-demo-runbook.md, and scripts/demo-peer.sh (seeds a peer as an anvil owner). The Nim SDK was built, consumed, and extracted to corpetty/logos-nim-sdk (see "The Nim gap is filled" above). FROST is a real in-room driver (roomPolicyFrost); Safe proposals commit to the live on-chain nonce (safeNonce). Design note for turning any Logos module into a driver: docs/design/driver-derivation.md (epic exo-fa4).

Monero in Muster rooms (epic exo-dcc, from 2026-10-07). Plan docs/design/monero-in-rooms.md; ADR-018 accepted 2026-10-08. Settlement stays on Monero, and Muster covers the rest of the deal; Muster holds no Monero key and never spends. Handoff: docs/06-session-handoff-2026-10-09.md.

  • The XMR payment request — landed (exo-dcc.5, .20). Family monero.split: the split's each locus, one debtor, the requester not in it. The creditor's own wallet, reached through monero_wallet_backend (an optional dependency of muster_module), mints a subaddress per request; the debtor pays from any wallet through a monero: link or its QR code; a part is confirmed only by the creditor's own history(): that subaddress, exactly the share, at least 10 confirmations. "I paid" is a claim, never a confirmation, and settle-up never nets a Monero split. Spec derived-exo-dcc.5, 7/7. The UI has Home's "Request a payment", the Split composer on Monero, the card's link, QR and "I paid", "seen, n of 10", Open Monero Wallet naming the wallet, and "Share my Monero address" (so a request can be made on someone's behalf). Seen on display in Basecamp 0.3.2 with a real stagenet wallet, up to the payment. No payment has been made yet: the two-machine stagenet run (exo-dcc.19) waits on stagenet XMR for the payer. Labbook docs/labbook/xmr-payment-request.md.
  • Send Monero — landed (exo-dcc.32). A member sends XMR to another: a Monero request on the payee's behalf with the sender its only payer (no new driver; the split driver's agreesByProposing now counts a split's only payer, so proposing is their agreement). It pays at the newest address the payee shared (Share my Monero address, minted by their own wallet), and an address already backing a Monero payment in the room is refused (shared-address-used), since the payee's wallet confirms by amount at a subaddress. The payee's Accept vouches the address is theirs; the sender pays from any wallet; the payee's wallet confirms. Since exo-dcc.33 a send works in every asset a split takes: ETH or a token, BTC and LEZ as well as XMR. coordination/send.nim (behalfPayTo) picks the payee's shared address by rail: Ethereum and Bitcoin addresses are reused freely (each payment is confirmed from its own transaction), a LEZ key node never under another unpaid payment of the same amount (amount-in-flight), and Monero never reused. A member can share a LEZ key node, and an ask can name only the rail, which the payee's module resolves to its own network. UI: Send money in the room's + picker and on Home, XMR by default, the rail from Settles on. xmr_send_test, send_any_asset_test.
  • Install what's missing — landed (exo-dcc.10, .11). Readiness grades a module in three states from Basecamp's modules_state registry and never calls one that is not ready. The card and the proposal form raise Basecamp's packages.install for the package a driver names (monero_wallet_ui for the Monero backend); the person confirms in Basecamp's own dialog, and Muster installs nothing. In Basecamp a module the registry reports ready reads met, since lp_get_methods there always returns [].
  • The mixnet for a room's sends — opt-in (exo-dcc.4). Setting mix (off | preferred | required, off by default) sets delivery 0.3's anonymityLevel. On logos.dev every send went over mix. It hides which member sent a message, not who reads a room: reading is a store query from the reader's own address. Claim [4] is partial. Untested on logos.test. Labbook docs/labbook/mixnet-on-delivery-03.md.
  • Basecamp 0.3.2. Delivery 0.3.2 pinned (exo-dcc.12). A founder who relaunches before admitting anyone reads its room again: epoch 0's key is derived from the keystore and the room (exo-6dc.1). Only the first transport boots delivery's node, one per module instance; a second start crashed delivery on relaunch.
  • An installable Muster — published (exo-dcc.3). Every dependency carries a version range; Muster is 0.3.0 (since 2026-10-14, after the UI redesign, epic exo-720). The catalogue lives in this repo (catalog/), publishes only muster_module and muster_ui, and takes every dependency from Logos Official. scripts/catalog-release.sh builds both and writes it. A fresh Basecamp 0.3.2 installed Muster from a locally served copy (docs/design/catalogue-install.md §7). Release muster-v0.2.0 was published on 2026-10-09 (target 0b99493), and muster-v0.3.0 on 2026-10-14 (target 2aa5e08, with the AppImage); catalog/index.json is on main, so the catalogue lists Muster 0.3.0. Steps for a stranger: docs/runbooks/install-from-catalogue.md.

Decided 2026-10-08: the demo's target network is logos.test with a room gifter we run (docs/design/rln-membership.md §7: R2, then R3, then R4, none built yet), and the catalogue lives in this repo. For now (2026-10-09) the demo and all live testing run on logos.dev, the default, until RLN is settled and the gifter is funded. In Basecamp, another module that boots delivery on logos.test first takes Muster with it (exo-dcc.24). Waiting on funds: stagenet XMR for the payer (exo-dcc.19) and native LEZ on LEZ classic for the gifter (exo-dcc.2). Ahead: the deal-desk demo (exo-dcc.7: terms → request → pay → confirm → a receipt the member chooses to share; the receipt landed 2026-10-12 — a split's signature-audit file carries every counted part report as an external read, checked against the author its driver names, split_receipt_test), paying from Basecamp's own Monero wallet (exo-dcc.6, after an upstream review intent), and the mainnet gate (exo-dcc.8).

Real use in Basecamp (epic exo-d4d, 2026-10-06/07). Under Basecamp a member's EVM key is a keystore_module account approved in the platform's Signer; chain reads go through eth_rpc_module; and every EVM transaction Muster originates goes through tx_sender_module, refused unless what it prepared is what the room agreed. A fresh install shows nothing seeded. The exit test, R6, passed on display on Sepolia: two fresh Basecamp 0.3.1 profiles, a split, and a Safe the members already owned (docs/labbook/muster-in-basecamp-031.md). ADR-017 (an EIP-712 form of the attestation and the identity binding, for keys the platform holds) is accepted; its builders and verifiers landed (K6b). Until K6c–K6d land, Safe approvals go to the platform's Signer only on test chains. Design: docs/design/real-use-basecamp.md.

Done:

  • P0–P2 — loading spike + signing-path core (dCBOR, hash-input records, hash-linked log); intent lifecycle engine + driver interface + all 11 invariants; Safe driver (EIP-712 safeTxHash, secp256k1 owner verification, collect-2-of-3, on-chain execTransaction vs the anvil Safe (the real v1.4.1 singleton since exo-a50.1.4), no indexer). B4: tools/lidl_gen.nim generates the surface from muster.lidl. Route B codegen.nim path added to logos-module-builder (PR #202, merged 2026-08-31; the nim.packages + RUNPATH half is #226, open).
  • P4 — complete (ADR-013). The exo-c6a SDK-rev render blocker was routed around without the upstream fix: build muster-ui on basecamp's coherent builder instead of muster_module's Nim-cdylib builder (ADR-013). The full lifecycle runs through the real UI in logos-basecamp — describe() → the real 2-of-3 Safe, propose() → real re-derived safeTxHash (F-4), approve() → collect owner signatures → executable, submit() → a real on-chain execTransaction → final. Acceptance harness ui/tests/muster-ui-test.mjs is 6/6 (render, health, propose, lifecycle, reject+reset, submit). exo-c6a remains open only for the eventual upstream codegen bump.
  • P4 product surfaces — the demo experience reproduced in the spec-first client (2026-08-24). Beyond the lifecycle spike: the room/home/composer/card surfaces, driven by demo/muster-ui as reference and the prototype as spec. (1) A conversation layer in muster_module — four new lidl methods (coordinate_post_message/coordinate_messages/coordinate_members/coordinate_conversations) folding a new message/<id> event kind over the existing sealed coordination log; the demo borrowed chat from chat_module, but the spec-first client talks only to muster_module, so it builds its own (coordination_messages_test green, regression green). (2) The UI — a home → compose → room shell: Home.qml (F-18 action list — since exo-ed5 a query over intents for THIS member, across every joined room: coordinate_conversations classes each room's intents as needs-you / waiting-on-others / settled with coordination/home.nim, asking the driver seam mayContribute whether your contribution would count), Composer.qml (verb → people → account), Room.qml (the thread rendering MusterCard for card-bodied messages — the closed vocabulary: address-share, intent-propose with a status rail + approval slots + the honesty caveat, receipt), ScopePanel.qml (roster + scope line, U-1/U-9/F-16). Built contract-first, the UI surfaces fanned out in parallel, each launch-verified in the standalone runner — which now works (make run; the runner was always in mkLogosQmlModule's apps.default, now exposed as ui/flake.nix#runner), retiring the "standalone renders no ui_qml" claim (that predated ADR-014's coherent builder). The ADR-012 claims registry + Walkthrough.qml also shipped. Update (2026-08-24): the room's intent cards are now wired to the verified path — coordinate_intents returns a render-ready projection (reduceIntentViews: effect + driver threshold + distinct-owner approvals), Room.qml draws its proposal cards from that fold (not posted JSON), Propose calls coordinate_propose (content-addressed), and Approve reveals an honest signature field feeding coordinate_contribute (the driver refuses a non-owner). Verified headless (coordination_surface_test step 6) + the module .lgx compiles; the on-display render is parse-clean (qmllint) but the qt-mcp launch gate stays the same UI-e2e blocker. Still ahead: the cross-host Safe-txn settle over the live wire (the two-instance membership wire landed 2026-09-01 — see below; the seeding it needs now exists via scripts/demo-peer.sh, so a two-machine end-to-end run + R-4/R-6 resilience remain), wallet-in-room, a committed CI acceptance harness, and the shielded LEZ journey (deferred, infra-bound adapter). (Room-side submit landed — coordinate_submit + the roomApproveSubmit button, proven on anvil, coordinate_submit_anvil. Multi-room landed — gSessions per topic. Latency polish landed 2026-09-01 — store-catchup tightened 8s→1s + time-windowed, exo-38e.)
  • P3 — transport + encryption + multi-party coordination. ADR-010 resolved then amended to the persistent, room-scoped identity model (FS-7 reframed; the platform mixnet closes FS-9): build a thin ECIES stopgap behind a ConversationCrypto interface, native logos-chat-module the target once it ships persistence + removal. Consume logos-delivery-module behind a Transport interface. Built + tested (against LocalTransport): the lp_* C-ABI Nim binding + DeliveryTransport; ECIES-secp256k1 EpochCrypto with F-16 verified (a mid-conversation joiner cannot open earlier epochs); the multi-instance coordination flow; the foreign-thread GC seam + async send; and — the payoff — the intent lifecycle as reduce(log), so two owners coordinate a real Safe intent over encrypted transport and converge on it reaching executable. The full P3 stack links in the shipping plugin (secp256k1 + libsodium).

Remaining in P3:

  • Persistent identity (FS-4) — the prerequisite, now landed. A Keystore operation seam (address/sign/encIdentity/sealOpen/bindingFor — never a key getter, so a Keycard backend slots behind it) with a file stopgap (FileKeystore: an Argon2id-encrypted keyfile) and an in-memory backend. The secret never enters the coordination layer (unwrap goes through sealOpen). The identity() lidl method is wired and the module opens its keystore under the host-provided instance path. keystore_test 6/6.
  • Two bound identities (F-14, ADR-010 revisit 2026-08-23) — landed. A revisit relaxed F-14 from one curve to two bound keypairs: a secp256k1 authorization identity (Safe/Keycard) and an Ed25519/X25519 encryption identity (curve25519.nim), joined by a signed link statement the core verifies on ingest (binding.nim, F-9). Member is now the encryption identity; epoch keys wrap with libsodium sealed boxes (ECIES over X25519). Fixes the ECDSA+ECDH key-reuse the one-curve model hid, and builds the exact binding native chat's Ed25519/X25519 layer needs. curve25519_test/binding_test/keystore_test + all epoch/coordination/handshake tests green through the refactor.
  • Hosted coordination surface — landed. coordinate_join/coordinate_propose/coordinate_contribute/coordinate_intents lidl methods drive a conversation from a host over CoordinationSession + reduceIntents (the multi-party state = reduce(log) path), keyed by a content-addressed intent id so hosts agree without a round-trip. This compiles coordination/intents.nim into the plugin — the musterP3LinkCheck stub is gone. Verified in-process (tests/coordination_surface_test.nim: two owners converge on a real Safe intent → executable, non-owner refused, duplicate folds once) + the portable .lgx builds clean with it. Not yet driven cross-host — that needs a running delivery node and a membership/grant handshake (below).
  • Membership/grant handshake — landed. A join-request/admit protocol over the coordination session: a joiner sends a join request: its encryption identity, signed by that identity for the room, and no secp key, so asking discloses no address (coordinate_request_join, no authority, exo-a87), an existing member decides to coordinate_admit it, and the epoch key travels as an opaque ECIES control frame on the same topic (a 1-byte kind tag separates the frame kinds). Since exo-661.7 nothing on the topic names a member: the request is sealed to a join key the room announces (derived from its epoch key), each grant is sealed whole to one member, and envelopes carry no epoch number (store_node_view_test). Admission re-keys forward, so F-16 holds over the wire — the newly admitted member reads from its epoch on, nothing before its seam. The mechanism lives behind the ConversationCrypto seam (identity/admit/ingestControl), so native chat swaps in as a binding change. Verified in tests/membership_handshake_test.nim. Still needs a running delivery node for the cross-host wire (below).
  • Delivery node stood up in the app (2026-08-24). delivery_module (v0.2.0, the repo the demo consumes) is now a declared dependency of muster_module (the lp_* caller) and muster_ui, and it rides the standalone runner's module set (make build bundles it via the builder's collectAllModuleDeps). Verified by launching the runner offscreen: the host logs Module loaded: delivery_module → DeliveryModuleImpl: Initialized successfully, so coordinate_join's lp_client_create("delivery_module") now resolves instead of raising. publish() records to the local log before broadcasting (session.nim), so a single instance's propose/contribute/fold completes without a peer. Resolved 2026-09-01: coordinate_join does boot the node (createNode/start) once the embedded-lp token is saved (fix 2 below), and connects to the fleet (six :30303 peers, live cluster-2 relay traffic); two instances converge over it. The offscreen self-test (scripts/two-instance-proof.sh, QT_QPA_PLATFORM=offscreen) drives the runner headless-enough to prove convergence without GL. The basecamp bake used by ui/tests would still separately need delivery bundled to run the room loop there.
  • Live two-instance wire over the Logos fleet — LANDED for membership (2026-09-01, 499b512). Two muster-ui runners on the public logos.test fleet do the full handshake end to end: join the same room → one asks → the other admits → the re-key grant crosses → both show members = 2. Discovery is the fleet (infra/fleets/), no bootstrap node to run. It took a chain of six fixes, each hiding the next — all recorded, with the self-test rig and every build/iteration gotcha, in the ✅ SOLVED box of docs/labbook/two-instance-live-wire-blockers.md; the operator flow is docs/two-instance-fleet-runbook.md; no-GUI check is scripts/two-instance-proof.sh. The six, briefly: (1) fleet entryNodes for discovery; (2) logos_module_accept_token must lp_token_save or the embedded-lp node never boots (now in the SDK's lidl-gen template as accept_token → saveToken, so a regen can't drop it — was the cross-host regression that motivated extracting the generator); (3) delivery v0.2.0's relay never surfaces a received message on our sparse shard, so cross-host receive rides store catchup (request/response, mesh-independent; a ~8s poll at first — the "slow chatroom" latency — since tightened to ~1s + time-windowed, exo-38e); (4) requestJoin re-announces every ~5s (one-shot missed on the sparse shard); (5) toContentTopic normalizes any room name to a valid 4-segment Waku content topic (raw dotted/bare topics silently don't shard); (6) coordinate_admit follows "a member decides" (any valid binding, not Safe-owner-gated). Still ahead: the cross-host Safe-txn half (propose → sign → settle) needs the two peers seeded with anvil Safe owner keys — contribute refuses a non-owner signature (F-9 working), and the runner gives each a random key; then the R-4/R-6 kill-mid-collection resilience run. Latency polish landed 2026-09-01 (exo-38e): the store query is now time-windowed (timeStart = now − MUSTER_CATCHUP_LOOKBACK_MS, default 60s; a topic is first read whole so late joiners catch up — since exo-aaf by following the store's pagination cursor, page by page on the peer that issued it, where it had fetched only the oldest 50 messages and so lost a busy room's middle on relaunch, transport/store_catchup.nim) and the period dropped 8s→1s (MUSTER_CATCHUP_MS, floor 200ms), with the UI live-refresh + offscreen self-test matched to 1s — measured offscreen at ~1s cross-host receive, ~3s to both members=2. Follow-ups since (exo-d01, 2026-09-02): store-peer rotation landed — fireCatchup round-robins across all entryNodes, so a down store node costs one tick not the catchup. Real-time push receive investigated and found blocked upstream — a light node's Waku filter client does receive pushes on our sparse shard (both peers), but the closed liblogosdelivery v0.38.1 kernel only surfaces some as message_received (founder yes, joiner no), identically under relay (Core) and filter (Edge), so muster has no lever; store-poll (~1s) stays the reliable path until an upstream kernel fix. Full evidence in the labbook.

Testnet v0.3 migration (epic exo-eb6, started 2026-10-01). Logos Testnet v0.3 launched 2026-09-30; its rolling upgrade took the fleet away for a day (docs/labbook/testnet-v03-fleet-rollout.md). muster now pins delivery v0.3.3 (v0.3.0 until 2026-10-08, when exo-dcc.12 moved it to 0.3.2, which splits its own startup catch-up into the store's 24 h windows; 0.3.3 since 2026-10-23, the code its authors first tagged 0.4.0 and withdrew: logos.test moves to a new RLN registry on the LEZ v0.3.1 testnet, metadata.json accepts >=0.3.2, so the catalogue's 0.4.0 also satisfies it; exo-eb6.1, five traps fixed, each tested — transport/received.nim, transport/node_config.nim, store-peer backoff and a 15 s store window in store_catchup.nim, since live receive works on v0.3; scripts/ui-parity.sh 8/8 green) and defaults to the logos.dev fleet (cluster 3, no RLN; MUSTER_FLEET / TRY_FLEET / FLEET= pick logos.test, exo-eb6.2), because a v0.3 node on logos.test sends nothing until it has an active, funded RLN membership (it runs, and holds every send) — the decisions that needs are in docs/design/rln-membership.md (exo-eb6.3; proof validation on logos.test from about 2026-10-14). R1 (exo-4a7a) bundles the RLN modules and shows the node's membership: on logos.test a connectivity row, and Settings with the payer to fund (scripts/rln-self-test.sh, live). MUSTER_FLEET=local runs the self-tests with no fleet, on a two-node network of their own (exo-eb6.7): ui-parity.sh 8/8 there during the fleet outage of 2026-10-01. The LEZ testnet was reset to LEZ v0.3.0 (faucet program removed, new tx codec and fees, 256-bit private identifiers; exo-eb6.4). muster now pins lez_core 0.5.0 (LEZ 0.3.0, L1): no faucet and no account registration anywhere in muster, wallet_lez_setup() names the account to fund, and the real wallet follows the instance's zone (MUSTER_LEZ_RPC). A local v0.3.0 zone with a genesis funder (infra/lez/localnet.sh, L2) is where the LEZ paths are re-checked; its self-test reads a funded balance through lez_core. L3: lez/tx.nim builds v0.3.0 public transactions (shards, borsh instruction, fee), held to vectors from LEZ v0.3.0's crates, and a FROST group acts on a v0.3 zone from the room, paying its own fee (lez-call v2; lez_frost_room_v030_e2e). On v0.3 a refused call is still included and pays, and the chain reports no outcome, so the group signs only a native transfer out of its own account and settlement sends one only when the account covers it and its fee cap at the signed nonce — then inclusion means it took effect (exo-eb6.4.6). The private split runs on a local v0.3 zone end to end (LEZ_SPLIT_ZONE=local scripts/split-lez-testnet.sh, the funder funding B; ~1 min with dev-mode receipts); on v0.3 private transactions are fee-exempt and public ones pay up to the declared cap, and muster's fee estimate says so. L4: the LEZ multisig program is ported to v0.3's run_program(plan, apply) ABI without SPEL (a clone of logos-co/lez-multisig, branch feat/lee-v0.3.0; design docs/design/lez-multisig-v03.md), deployed on the local zone with localnet.sh deploy, and driven from the room there (lez_multisig_live_v030_e2e): layout v0.3, a v2 pointer effect committing the whole call, every vote its member's own fee, Execute naming the approvals the chain holds from current members; refusals are included and pay, so every step is judged by the state read back. Traps and facts: docs/labbook/lez-v03-migration.md. Still ahead: the port upstream (L4e), and every LEZ path live on the testnet (L5): infra/lez/funder.sh reduces that to one account to fund (--zone testnet account), and the private split, the multisig (deploy included) and FROST all fund through it, verified on the local zone; they run on the testnet once someone holding native LEZ funds it.

Chain-agnostic wallet (F-Design) — landed 2026-08-23. A ChainAdapter seam + Wallet aggregate (module/src/wallet/) with two impls proving genericity: an EVM adapter (ETH + ERC-20 over the user's RPC, inv 8 / F-10) and a mock shielded chain modelled on the LEZ (dual public/shielded accounts, delayed finality, sentinel-failure defense). Amounts are arbitrary-precision (wei > uint64). Failure is always a raise — a failed read never reads as a zero balance. Hosted methods: wallet_accounts/wallet_balances/wallet_estimate_fee/wallet_send/wallet_finality/wallet_verified_balance. Diagram: docs/diagrams/mech-wallet-seam.svg.

Nimbus/Status Nim reuse (ADR-014) — landed 2026-08-23. The wallet's Ethereum layer runs on the org's Nim stack, unblocked by a nim.packages hook added to logos-module-builder: stint (amounts), nim-secp256k1 (one secp source — the hand FFI + system lib dropped), nim-eth (EIP-155 tx signing + verifyMptProof for verified reads — the Nimbus verified-proxy core reused in-process, wallet_verified_balance, F-10; diagram docs/diagrams/mech-verified-reads.svg), nim-web3 (typed RPC over chronos), nimcrypto. Kept ours: dcbor (inv 5), curve25519/libsodium (F-14). All 42 probes green on nim-secp256k1; safe_anvil_e2e green on live anvil.

Wallet UI — wired, render unverified. ui/ gained a WALLET card (balances across chains, each with a green verified / amber attested F-10 badge). The .lgx builds (client regenerated from muster.lidl, .rep+backend compile), but nix build does not evaluate QML — the card rendering is the remaining ADR-013 logos-qt-mcp harness assertion.

Experience-smoothing round. Client caching in evm_rpc (no reconnect per call); module/tools/regen.sh (one-command surface regen); infra/anvil/devnet.sh (one-command anvil + the real Safe v1.4.1 fixture, exo-a50.1.4, documents the delivery-node + verified-proxy sidecars).

Deferred, infra-bound: client-side EVM signing on a non-anvil node; the beacon light-client sidecar that makes verified-locally trustless end to end. (The real LEZ adapter is no longer deferred — see "Send assets via Logos" below.)

Send assets via Logos — the LEZ landed (2026-09-14). The real LEZ ChainAdapter (module/src/wallet/lez_*.nim, epic exo-Lxx / PR #64): the zone's four rails behind the wallet seam — public / shield (pub→priv) / deshield (priv→pub) / private — each with a Disclosure{amount,payer,payee} (the education square: the amount is public unless both ends are shielded), receive-by-scan (a private note lands at an account the recipient didn't create; sync discovers it), delayed finality, and every lez_core quirk (empty-string / success:false envelope) → a WalletError raise. FakeLezCore is the deterministic no-infra default; LpLezCore is the real lez_core (v0.3.0, logos-blockchain/logos-execution-zone-module @ 549cf115, bundled in the runner) over lp_*, gated behind MUSTER_LEZ_REAL and falling back to the fake — a proving transfer runs async (900s lp_invoke_async) so the ~7-min proof never freezes the module. Design + reuse map: docs/design/lez-adapter.md (grounded in the working demo's Zone.h/rails). UI: the "Send λ" panel — Mode A request → share → send (the receiver picks their own disclosure by which address form they share: a public id names them, a shielded key node does not), with balances + a zone-error state. The real core's rails have now run on testnet.lez.logos.co — a faucet claim, a shield to one's own key node, a private transfer, a receive found by scan — inside the private split's testnet run (2026-09-28; findings in docs/labbook/lez-wallet-scan-and-proving.md). Not yet: this panel's own send driven live, and a room-coordinated LEZ transfer (Mode B).

Multisig families — Phase A landed (epic exo-a50, 2026-09-24). Design: docs/design/multisig-landscape.md; registry contracts/families/registry.json (checked by scripts/check-family-registry.py); atlas docs/design/multisig-atlas.html. Every driver declares its family PROFILE (drivers/profile.nim, CAIP-2/10); ONE kind list (drivers/kinds.nim) — an unknown kind is unsupported, never a silent Safe; accounts live in the room, disclosed by members (coordination/accounts.nim, account/<CAIP-10>/disclose/<member>, checked against the chain) and an account-bound policy is safe@<CAIP-10> — the module-global Safe is gone from room paths (the anvil Safe is only describe()'s disclosable suggestion); the Safe maps every SafeTx field, refuses an unallowlisted delegatecall (signRefusal, MUSTER_SAFE_DELEGATECALL_ALLOW), reads modules/guard, and infra/anvil/devnet.sh deploys the real Safe v1.4.1 (0xEb45…E841); settlement is a seam (settlement/, chosen by profile, relayer setting self | unlocked:<0x…>); the card's ten fixed rows come from the profile (coordination/card_rows.nim). Exit test: phase_a_exit_test.

Phase B landed (exo-a50.2, 2026-09-24): Bitcoin through PSBT.

  • Families. btc.p2wsh-sortedmulti and btc.tapscript-multi-a are built. module/src/bitcoin/ holds the primitives, pinned to the BIP vectors, and a PSBT v0 + BIP-371 codec whose canonical form is dCBOR, never PSBT bytes. drivers/btc_multisig.nim does the rest: it derives an account from k of n keys, so a disclosure is checked with no chain read; it builds a spend from UTXOs (buildBtcSpend); it re-derives every input's sighash, refuses foreign coins, a wrong fee or dust, and finalizes the witnesses.
  • Signing in-app. A member signs through the keystore with the signInApp driver hook: DER or BIP-340, attested by the same key (drivers/inapp.nim).
  • Signers outside muster. These form seam S8, drivers/interop.nim. A Bitcoin intent exports as a PSBT, and an outside signer's PSBT imports as counted, unattested approvals. This is coordinate_export_outside / coordinate_import_outside, "Sign outside muster (PSBT)" on the card.
  • Settlement. BitcoinSettlement runs over the user's own node, the wallet/btc_adapter.nim BitcoindAdapter (setting btc-rpc). It uses scantxoutset for coins, sendrawtransaction to broadcast, and confirmations for finality. coordinate_propose_btc_spend is the room's Bitcoin payment composer.
  • Exit test. btc_regtest_e2e, against Bitcoin Core on regtest (infra/bitcoind/regtest.sh), where Core's wallet is the outside signer.
  • Not yet. A Keycard Shell over QR, the same PSBT path, has not been run on the device.

Phase C: the core landed (exo-a50.3, 2026-09-24). This is the vote locus on Logos's own chain (logos-co/lez-multisig, Squads-v4-style).

  • The program model. module/src/lez/ holds the program's borsh state and proposals, SPEL seeds, and the public-PDA formula, with the scheme versioned. The chain seam LezMultisigChain has an in-process model, FakeLezMultisig, that reproduces the handlers.

  • The driver. drivers/lez_multisig.nim holds family lez.multisig-program:

    • an account is disclosed with its config, and its address must be the PDA that config derives;
    • the effect is a pointer to on-chain proposal #i plus the content the room reviews;
    • a contribution is a vote receipt.
  • S5 as a driver seam. reads / checkRead re-read the pointer and refuse on any mismatch before a vote.

  • Voting in the room. In coordination/vote.nim, approving is the member's own on-chain transaction. Their LEZ wallet signs it, never muster, and a funded payer account of theirs pays for it. Muster confirms the vote by reading it back, then publishes the receipt with a room-key attestation.

  • Settlement. LezMultisigSettlement counts the votes on chain and Executes.

  • Exit test. phase_c_exit_test passes against the model.

  • Live (exo-3c9, 2026-09-25). wallet/lez_multisig_live.nim is the chain seam over the user's own LEZ sequencer. The member's key is derived per membership in the keystore (lezMemberKey) and signs the member's own transaction, built by lez/tx.nim. lez_core cannot carry a generic program call at muster's pin (see the labbook). The hosted surface covers:

    • lez-rpc / lez-chain / lez-multisig-program settings;
    • lez_member_account, lez_multisig_create, and disclosure by config;
    • coordinate_propose_lez[_transfer|_vault_init], coordinate_vote, and settle.

    Each step sends at once and completes when the chain includes it (a pump on the intents tick), because a UI call must not wait on a block. The room UI has a LEZ multisig section, a transfer composer, and a card that reads the proposal in words. lez_multisig_live_e2e drives the room against the program on the public testnet and a local v0.2.4 sequencer (infra/lez/localnet.sh).

  • The rebuild. The published program targets nssa v0.2.0-rc3. The live testnet runs the LEZ v0.2.2–v0.2.4 line (probed), so the program was rebuilt for SPEL v0.7.0 / LEZ v0.2.4 with the lez-multisig#40 fix (#41), in the local clone feat/lee-v0.2.4. Muster models both builds as named proposal layouts:

    • count-only: the card names #40;
    • account-ids: the target accounts are committed on chain and checked on the S5 re-read.

    lez-multisig's own e2e suites pass against a local v0.2.4 sequencer, including an on-chain refusal of a substituted recipient. Muster decodes the resulting accounts and derives their PDAs byte for byte (lez_multisig_rebuilt_test §5).

  • Deployed to the public testnet (2026-09-24). The testnet is v0.2.4: its built-in image ids equal a v0.2.4 build's. The rebuilt program is live at ImageID 2ced3d30…d4c7 (block 23405). lez-multisig's e2e_multisig passes against the testnet itself, including the refused substitution. The port is upstream as logos-co/lez-multisig#45. Muster reads the testnet multisig byte for byte and accepts it as a lez:testnet room account (§5). See docs/labbook/lez-multisig-versions.md.

Phase D: FROST in the room — the exit test passes (exo-a50.4, 2026-09-25). module/src/frost/ holds threshold Schnorr on secp256k1:

  • Group arithmetic (secp.nim): points with infinity over libsecp's ABI, scalars mod n over stint.
  • FROST signing (signing.nim, the BIP-445 draft): held to all 266 of its vectors.
  • ChillDKG (chilldkg.nim, the draft key ceremony): held to all 249 of its vectors.
  • BIP-340 with a tag prefix, and ECDH (schnorr.nim).
  • The two compose (frost_dkg_sign_test): a key made by a ceremony signs as one plain BIP-340 signature that libsecp accepts, the witness of a single-sig taproot spend.
  • Caveat. None of this is constant time. It is demo-grade, behind the same production gate as MPC.
  • Round secrets as keystore operations (S7, frost/keystore_ops.nim behind Keystore.frost*):
    • A host key is derived per ceremony label.
    • Ceremony states are held between steps.
    • A secret share is never stored: it is recovered from the ceremony's PUBLIC recovery data plus the host key, so it is "log + keys".
    • A nonce is consumed before it is used, and a restart aborts its session (frost_keystore_test).
  • The aggregate-locus driver (drivers/btc_frost.nim, family btc.frost-bip445, kind btc-frost):
    • The account is derived from the ceremony's recovery data alone, and its address is OP_1 x(Q).
    • A spend's materialization is the key-path SigMsgs.
    • Round 1 carries nonces; round 2 carries partials plus the signer set they sign under.
    • Settlement aggregates into one BIP-340 signature per input (btc_frost_driver_test).
  • The room as ChillDKG's coordinator (coordination/aggregate.nim):
    • Open, joins and step messages ride the log, and every member computes the coordinator's steps from it.
    • The account is disclosed with its recovery data.
    • The two signing rounds run over the log, which fixes round 2's signer set (frost_ceremony_room_test).
  • Exit (phase_d_exit_test, on a real Bitcoin Core regtest):
    • A 2-of-3 is made in the room, funded, and spent in two rounds.
    • Core derives the address as rawtr(x(Q)).
    • On chain the spend is ONE 64-byte signature, the same witness a single-sig taproot spend has.
  • LEZ (lez_frost_account_e2e, a real v0.2.4 chain): an aggregate key owns a LEZ public account with no tweak, and a FROST witness co-signs and signs alone. The registry's open question is settled.
  • Hosted + UI (exo-355):
    • frost_ceremony_open / frost_ceremony_join / frost_ceremonies.
    • A pump on the intents tick advances every ceremony this member joined, and runs round 2 after this member's Approve, so a member approves once.
    • The Bitcoin spend composer builds a FROST key-path spend for a btc-frost@ policy, and coordinate_submit settles through the user's node.
    • The room accounts panel has a key-ceremony section; the card already shows "round R of N".
  • LEZ from the room (exo-55e, lez_frost_room_e2e on a real v0.2.4 chain):
    • The same ceremony, run on a lez: zone, discloses the group's untweaked LEZ public account (drivers/lez_frost.nim).
    • A lez-call at the account's chain-read nonce (a recorded read) runs both rounds.
    • Settlement re-reads the nonce (a stale one can never land, so it is refused), aggregates one signature, and sends it.
    • drivers/frost_group.nim is the group and rounds both FROST families share.
  • Hosted and in the room UI (exo-55e):
    • A ceremony opened on a lez: zone discloses the group's LEZ account.
    • Under a lez-frost@ policy the LEZ transfer composer sends from the group's account (a lez-call at its chain-read nonce).
    • Approve runs both rounds; the partial follows automatically once round 1 closes.
    • coordinate_submit sends the aggregate through the user's sequencer, and the pump watches for inclusion.

Next: the LEZ multisig's and FROST's on-display runs in a runner and across two instances.

Split the bill — S0–S4 landed (epic exo-a90, 2026-09-28). Design: docs/design/split-the-bill.md. The first action with no shared account: one member fronted a bill, the effect (muster.effect.split.v1) names every debtor's share and the address to pay, each debtor agrees with their room key — and so does the creditor, their word that the address is theirs (exo-770) — then each pays their own share from their own wallet and the creditor's client confirms each payment from its own RPC read. Two driver-generic seams made it possible without a split special case in the core (invariant 6): describeFor(effect) (a proposal's own policy — the threshold is every party named: each debtor and the creditor) and settlement in parts (settlementParts / partAuthor / partTransfer; author-signed intent/<id>/part/<part>/<step> reports; any settled → submitted, all confirmed → final; a bare submit/final never finalizes a parts intent). A new registry locus each; families evm.split and lez.split (the private split), both built. Hosted: coordinate_propose_split / coordinate_settle_part / coordinate_confirm_part + a pump on the intents tick. split_anvil_e2e green on a live anvil (client-side EIP-155 through each member's keystore). The UI (exo-a90.6): a "Split a bill" verb, the in-room Split composer (total in ETH, who's in, "I'm in it too", exact wei by string arithmetic), and the split card (who owes what and where each share stands; Agree to my share / Pay my share / Mark received). scripts/split-self-test.sh drives it through the real runner over the live fleet and a throwaway anvil: propose → agree → pay → the creditor's RPC read confirms → final on both, exact balance. The composer and card were looked at on a display for the first time — two runners on Xvfb, driven with xdotool (recipe: docs/labbook/qml-errors-are-invisible-to-nix-build.md) — through a whole EVM split and a whole private split, and fixed (exo-9a4): the room no longer outgrows a normal window (the accounts block scrolls in its own share of the column, so the message row and "+" stay on screen), kind buttons are no longer truncated, the card says "Proposed a split", and the copy is singular for one debtor. lez.split — the private split (exo-a90.9) — built, hosted and in the UI: a shielded payTo, every share a distinct amount (the i-th debtor owes i base units less), debtors pay shielded → shielded only, and the creditor's own scan confirms a part when a note of exactly that share arrives at payTo (PartSeam.matchReceived; the room records a note hash). Held in-process on a shared fake LEZ chain (split_lez_test) and on a fake that behaves as the zone does (split_lez_zone_test). It ran on the LEZ testnet (2026-09-28, exo-14d): scripts/split-lez-testnet.sh puts two runners on the live fleet, each with its own real lez_core wallet; the debtor claims the faucet, shields it to its own key node, pays its share privately, and the creditor's own scan finds a note of exactly that share — final on both in ~25 min (proofs ~6 and ~8 min; a fresh wallet's scan from block 0 ~2 min of work); a re-run over the same, now labelled, wallets (LEZ_SPLIT_FUND=0, one proof) went final in 7.6 min, the creditor confirming 2 s after the report, with no account minted and its payTo unchanged. The real scan does expose a received note's key node and amount. The run found six places the fake was kinder than the zone, each fixed with a red-first test: the scan walks to the tip in bounded steps and "still scanning" is its own state (exo-66e); a debtor pays from the one note that covers the share, since received money — a shield to yourself included — lands at a discovered account (exo-9b7); the pay deadline outlasts the proving budget and a report names the zone's transaction (exo-15c); LpLezCore saves the wallet after every change (exo-2ce); a relaunch reuses the wallet's accounts, named by lez_core labels (exo-884); and each member's scan follows the private splits that wait on them, from the proposal on, never while their wallet proves (exo-270a). Details: docs/labbook/lez-wallet-scan-and-proving.md. A privacy-preserving transaction names no zone id, but each private input cites a commitment-set root the zone checks against its own history, so a debtor's payment lands only where it was proven; a fork or replica sharing that history is the exposure (exo-a90.22, labbook §10, read at LEZ v0.2.2 and v0.2.4). ERC-20 splits (exo-5ab, the first of the backlog exo-a90.11): an Ethereum split may be paid in a token named erc20:<0x token> — paid by transfer(payTo, share) on the token, confirmed from the receipt's Transfer log (that token, exactly the share, to payTo); coordinate_token_info reads a token's own symbol/decimals for display only (never signed); split_erc20_anvil_e2e on anvil; the composer's "pay in a token" field and the card seen on a display. Proposer ≠ creditor (exo-770): a split's content is anyone's to write, so it is payable only once its creditor agrees too — made at propose when they propose it (driver seam agreesByProposing); every proposal of every kind publishes an author-signed intent/<id>/proposer/<who> claim (IntentView.proposers, attribution only); coordinate_propose_split {creditor} proposes on a member's behalf, paid at the address they last shared into the room (sharedAddressOf), and the creditor's client refuses to agree to a payTo it does not hold (payto-not-mine); split_creditor_test, scripts/split-self-test.sh SPLIT_ON_BEHALF=1. btc.split (exo-d17): a split paid in BTC (satoshis, no share below 546-sat dust) — each debtor pays from wpkh(<their muster key>), coins from their own node, every input signed DER over BIP-143 through the keystore; the creditor's own node confirms an output paying payTo exactly the share at the network's depth (coordination/parts_btc.nim); split_btc_test, split_btc_regtest_e2e (real Bitcoin Core regtest), scripts/split-btc-self-test.sh (the real runner over the live fleet). Fiat bills (exo-3a4): a split may carry a quote — the bill in a currency's minor units at the proposer's rate (asset per one unit), with its source and time — converted exactly (fiatQuote, string arithmetic; the total must BE the conversion), signed as the materialization's tenth element, and recorded as an external read before any agreement (liveProposeIntent(…, reads); without it every agreement is unaccountable-input, invariant 10); the composer's "The bill is in another currency" and the card's named quote; split_fiat_test. Settle up (exo-3c6): a second effect of the split families (muster.effect.settle-up.v1, its own domain) nets the room's agreed, unpaid shares on one chain and asset into fewer payments — every member's balance conserved, each recipient paid only at an address a split owing them agreed, every covered party agreeing; a driver seam Driver.covers declares what an effect settles and coordination/covers checks each cover against its split before anyone agrees (generic — the core never knows what a split is); each net transfer is a part (a payer owing two people pays two; paying finds "my part" through partAuthor); a covered share is paid only through the settle-up; once final each creditor marks the shares it covered received (settleCovered), so a split's finality is unchanged; the private split is never netted; coordinate_propose_settle_up, the Split composer's "Settle up", the settle-up card; settle_up_test, settle_up_live_test. The split backlog (exo-a90.11) is done. Since (2026-09-29): a settle-up that expires unpaid releases its covered shares a day later (CoverReleaseGraceS), and one that began paying is finished past its expiry — generic over Driver.covers, a plain split unchanged (exo-a90.16, settle_up_expiry_test); a part in flight is never paid twice, and a Bitcoin payment is built only from coins no mempool transaction spends (exo-a90.18, part_in_flight_test, settle_up_btc_regtest_e2e, settle_up_erc20_anvil_e2e); fiat quotes are held in BTC, a token and the private split (split_fiat_test §5–7). A split past its expiry is renewed as a settle-up of its unpaid shares, everyone they name agreeing again under a fresh expiry (exo-a90.15, split_renew_test); the Bitcoin split was looked at on a display and fixed (exo-a90.19). A payment in flight is never forgotten while it might still land — unresolved past its deadline, released only when the chain says it can never land (PartSeam.partGone), and saved so a restart forgets none (exo-a90.23, pending_parts_test, checked live across a payer's crash). Open split follow-ups are exo-a90.17 and .21. The typed spec derived-exo-a90 (exo-a90.10, via discuss-issue; catastrophic) holds all six guarantees — the payment derived, the fold order-free, only the named people move a part, finality is the parts', one reference settles one part, the private split — as five model checks and a conservation relation, graded 6/6 by scripts/grade-specs.sh. derived-exo-a90.20 (exo-a90.20, via discuss-issue; catastrophic) holds the eight that landed after it — the creditor agrees, fiat converted exactly, settle-up conservation, covered shares paid only through the settle-up, settle-up expiry, renewal, a share in flight never paid twice (on the fake ledger and a fake Bitcoin node, tests/probes/fake_bitcoind.nim, the seam's own JSON-RPC code unmodified), Bitcoin shares — as seven model checks and a conservation relation, graded 8/8. derived-exo-a90.17 (exo-a90.17.6, via discuss-issue; catastrophic) holds the six guarantees of a settle-up across assets and chains — each conversion exact (an overflow refused, never wrapped, exo-df6), balances conserved in the payment asset, the rates the proposer's signed and recorded quote, where a recipient is paid (owed only elsewhere: at an address they vouch for), finishing across chains by each creditor's word, and what does not change (golden vectors frozen from main before exo-a90.17; the private split never netted) — as five model checks and a conservation relation, graded 6/6.

The action atlas — landed (epic exo-661, closed 2026-09-28). Every action a person can take in Muster, served at https://corpetty.github.io/muster/atlas/: built family actions draw their machine facts from contracts/actions/generated.json (never hand-typed); declared ones cite primary sources. Design: docs/design/action-atlas.md. Writing it found three defects: imprecise built manifests (exo-661.6, fixed: CAIP-2 chains, CAIP-10 accounts, manifest_precision_test), registry values the research contradicted (exo-661.8, fixed after re-verifying each against a pinned source or a live chain read), and the store node reading who is in a room off its topic (exo-661.7, moved out of the epic and then fixed: join requests sealed to a join key the room announces, grants sealed whole to each member, no epoch number on envelopes, composer topics of random bits only; store_node_view_test).

The action manifest (epic exo-002, started 2026-09-15). One per-action object answering the card's five questions — what will it do / what is needed / what will it touch / what will happen / how do we agree — designed against the PriFi imperative-vs-motivational credibility axis (muster classifies commitments per link × observer, never scores them). Design + the eight-slice plan: docs/design/action-manifest.md; live status pb dep tree exo-002. M1 landed: Driver.manifest(effect) (default UNDECLARED, shown never guessed), consistencyFailures (external finality ⇒ environment + chain-observer disclosure + write touch; every manifest names the contributor authority), the core-added baseline disclosure that always names the store node (FS-9), all six drivers declaring, LEZ disclosureOf → rows, and three new conformance checks (an undeclared driver goes red). M2 landed (2026-09-16): coordinate_readiness(intent_id) — coordination/readiness.nim grades each manifest requirement for THIS instance (module → the host invoker's methodsOf; environment → the configured RPC probed for the expected chain; authority → whether YOUR key is a recognized signer, never who else is; infra → configuration; capability → unknown until the host broker exists) with unknown first-class and a remedy per non-met item; the payload also carries the manifest + effect, i.e. the card's five questions. readiness_test 6/6. M3 landed (2026-09-16): the self-explaining card — MusterCard.qml's "What this needs" box (needs ✓/✗/? + remedies, touches, who-will-see-what by observer with the store node always listed, the agreement line; undeclared/unknown shown as such) fed by loadReadiness → readinessJson, plus Deny → coordinate_decline (a decline/<who> log event folded into the intent view + activity; names who declined; since exo-720 a decline is final: the decliner's approval counts for nothing, an intent too many signers declined is declined, and nothing changes once the room has submitted). decline_test green. M8 landed (2026-09-16): every protects/gap claim in contracts/claims/registry.json carries credibility (imperative | motivational | exposed | not-applicable) and, where someone's conduct or view remains, its party; check-claims-registry.py enforces protects ⇒ imperative and party-on-motivational/exposed; the walkthrough renders the line. M4 landed (2026-09-16): provenance for EVERY action — logProvenance (coordinate_provenance) classes every log entry (message / propose / policy / sig / decline / submit / final / admit) by the F-20 vocabulary with the guarantee the code enforces + its epoch; admits are now log events (membershipEvent, sealed under the new epoch — exo-275 closed; the activity feed shows the re-key); log/proof.nim gives an exportable self-verifying proof (coordinate_proof / coordinate_verify_proof: content ids recomputed, parent-closed, canonical order, state digest — any tamper refuses; log_proof_test). M5 landed (2026-09-16): the information-flow view — reduceFlow (coordinate_flow) folds log × each action's manifest disclosure × the membership at that point into per-(field, observer) rows + an observer matrix; inside rows name the epoch-key holders then, the store node's metadata rows are on every entry (FS-9), a driver's outside rows appear at submit/final (when the information actually leaves), an undeclared driver yields an undeclared row; FlowView.qml renders it under the room history (flow_test; offscreen scripts/card-self-test.sh asserts the flow payload). M7 muster-half landed (2026-09-16): coordinate_authorization(intent_id) issues a replay-bound (inv 2), secp-signed grant ONLY for an executable intent — capability name + the exact materialization root + environment/account/slot/expiry — and coordinate_check_authorization verifies one purely (refuse-on-mismatch); the host-side proposal (gated EFFECTS beside allowed callers, the hook's four steps, the questions for Basecamp) is docs/design/host-effect-policy.md + infra/access-policy.effects.example.json. M6 landed (2026-09-16, logos-nim-sdk PR #3): lidl_gen driver … [declarations.json] — each action entry carries manifest {declared, requirements, discloses, touches}, validated against muster's closed vocabulary (anything outside it raises), declared:false when absent, and a Tier-1 skeleton renders its manifest override; muster's SDK pin bumped to 9aa82f3 (also picks up SDK #2's capability name). Remaining in exo-002: only M7's upstream half (the broker consulting the grant before dispatch). M7 (the host refusing a gated call without a matching executable intent) is upstream and the long pole.

Basecamp capability alignment (2026-09-14). docs/design/basecamp-capability-alignment.md + docs/basecamp-access-policy.md: muster's musters (coordinatable actions) compose above Basecamp's app-to-app intents — muster_ui now provides: ["coordinate.request"] (handler TBD, needs the Basecamp broker), execution stays core-to-core (muster_module → lez_core/safe, the sanctioned pattern), and infra/access-policy.json names the muster_ui → muster_module edge so --access-policy enforce doesn't deny muster's own UI. The driver manifest (logos-nim-sdk lidl-gen driver) now carries a capability name separate from the schema-id, so a muster is addressable both as a Basecamp capability and — when cdCDDLe ratifies (inv 5b) — as a CDDL-typed effect.

Two supporting fixes live outside this repo: the logos-module-builder RUNPATH fix (carries secp256k1 + libsodium into the plugin RUNPATH) is committed on the fork the module flake pins and upstream-pending in logos-co/logos-module-builder#226; the logos-basecamp bake-in for the P4 UI render harness is a local edit to a basecamp checkout, documented step by step in ui/tests/README.md §1. See docs/02-implementation-plan.md for per-phase accept criteria and ADR status.