Storyteller 2: passing the pen

One story, five authors, no server. Who may write the next passage? This
lesson exists because the answer picks your architecture — and because
"whoever holds the pen" is secretly the same question every multi-writer P2P
app must answer. (Trust without a boss is the
general theory.)

Option A: don't coordinate — branch

Everyone appends passage ops to their own log; the fold builds a tree.
Two continuations of the same parent = two branches. Readers follow the
branch they like; a story is really a garden of tellings.

• No coordination, no waiting, works fully offline.
• Perfect when parallel realities are acceptable — often they are better

than acceptable (this is question 3 from
Storyteller 1 paying off).

Option B: soft convention — the pen token

Keep branching possible but make turn-taking the norm: a
pass_pen { storyId, to } op, honored by UIs (grey out the composer unless
the fold says you hold the pen). Nothing enforces it — a rude client can
still append — but every op is signed forever, and the fold can mark
out-of-turn passages so readers see them for what they are. Social
contract + total visibility replaces enforcement; most human-scale
coordination needs nothing stronger.

Option C: real shared state — Autobase

When the product demands one agreed sequence (one canonical story, a shared
membership roster), you need causal ordering and deterministic apply across
writers — exactly what Autobase provides: everyone
writes their own input core, one apply function folds them into one view on
every peer.

Choosing

Storyteller ships A + B: branching as the data truth, the pen as the social
layer. p2pbuilders is pure A — votes commute, comments hang off ids, nothing
needs a canonical order. Start at A; each step down the table buys
consistency and costs simplicity. Take the trade only when the product
forces you.