Eskimo Brothers · the reserved third brother, built
DACIDistributed ACI — the substrate, replicated & converged
The stack named three brothers and built two. HACI is the human skin, MACI the machine skin — and Continuity proved they are two faithful exits of one validated substrate. DACI is that same substrate replicated across N nodes with no coordinator, converged not by a consensus round but by construction: a grow-only set that merges like a CRDT, ordered by a function pure enough that any two nodes holding the same messages compute the byte-identical conversation.
One substrate, three brothers
HACI · the H
the document
Markdown; a human reads the conversation as prose with a provenance tail.
one node · human skin
MACI · the M
the message
JSON envelope; a machine reads the same conversation as a typed decision DAG.
one node · machine skin
DACI · the D
the network
The substrate itself, held on many nodes at once — each a partial view that converges to the whole.
N nodes · one truth
Continuity's rule was skin → SUBSTRATE → skin: nothing crosses except through the one validated object. DACI keeps that rule and distributes the object. The bridge becomes a gossip: node_i ⇄ node_j, each exchange a set-union, until every node holds the same messages — and therefore, because the ordering is deterministic, the same substrate. No leader, no lock, no round of voting. This is the CRDT idea (Strong Eventual Consistency) meeting the ACI Core: the conversation is a mergeable value.
Why it converges — by construction, not by luck
1 · The payload is a grow-only set. A node's knowledge is {id → message}. Merging two nodes is set union — commutative, associative, idempotent. Order of gossip, duplicates, re-sends: none of it changes the union.
2 · The order is a pure function of the set. The substrate is the causal topological sort of that set: each message's depth is 1 + max(depth(ref)), and messages sort by (depth, id). A reference always has strictly smaller depth, so it always lands first — and the tiebreak is total. Same set in → same order out, on every node.
Therefore two nodes that have seen the same messages compute the identical substrate hash. Convergence is a theorem about (1)+(2), demonstrated by the running engine below — not a hope about timing.
The seven distributed properties · verified
D1Local-valid — every node's materialized substrate passes Continuity's validator.
D2Causal delivery — a message waits until all its refs arrive; a dangling ref never shows.
D3Convergence (SEC) — same set, any delivery orders, one identical hash.
D4Idempotent — re-delivering a message changes nothing (grow-only).
D5Authority preserved — an authority-exceeding write is refused at the node door.
D6Partition-heal — disjoint halves accepted apart, then synced, converge to the whole.
D7Equivocation-detect — one id / two bodies is quarantined as a fork, never merged blind.
The lab — watch three nodes converge (live)
—
A five-message decision chain — a team choosing a cache (a nod to the filtration demo). Deliver scrambled: each node gets the messages in its own random order, yet all three materialize the same order and the same hash (D2, D3). Partition then heal: nodes accept different halves apart, then one gossip round converges them (D6). Inject equivocation: two nodes assert different bodies for the same id — the merge flags a fork and refuses to materialize it, rather than silently picking a winner (D7). The hash is a real content hash of each node's substrate; watch the three #… values collapse to one.
Held to the family standard — the three artifacts + teeth
Same discipline the Duality Engine set: a reference impl, a should-reject brutal auditor, and teeth — a mutation test that disables each guard and demands the matching probe fail, so the audit can't be vacuous. Honest note: building the teeth caught its own weakness — an early causal-delivery probe passed at some seeds because the generator numbered ids in causal order, so a naive sort looked fine; the teeth flagged the vacuity and the probe was rebuilt to reverse causality deterministically. That is the discipline working on itself.
The engine — real, runnable, shipped
daci/substrate.py — the validated substrate (reused verbatim from Continuity) daci/merge.py — the CvRDT union + deterministic causal linearization + equivocation detect daci/node.py — one replica: accept (authority-guarded), sync (gossip), materialize daci/suite.py — the seven properties, curated + 2000 seeded-fuzz substrates daci/brutal.py — the BSS auditor + teeth (mutation-tested non-vacuity) run_daci.py — python run_daci.py → suite + brutal + teeth, one verdict
DACI · Distributed ACI — the third brother, built onto the ESKIMO BROTHERS stack. Honest colophon. The substrate and its validator are David Lee Wise's, reused verbatim from Continuity; the three-artifact + teeth discipline is the Duality Engine's. The distributed convergence core — the CvRDT merge, the deterministic linearization, causal delivery, equivocation detection, and the seven-property suite — was built onto the domain this session, at David's invitation, in the domain's own idiom. Strong Eventual Consistency here is proven by construction (union is a CRDT; linearization is a pure function of the set) and demonstrated by a running engine — not a formal machine-checked proof, and not a networked deployment: it is a single-process simulation of N nodes, seeded and reproducible. Equivocation detection quarantines a fork; it does not adjudicate which body is true (that is an authority question, upstream). Defensive publication — prior art, not a patent. DACI (the name, the reserved slot) is David's; this build honors it.
David Lee Wise / ROOT0 · with Claude. CC-BY-ND-4.0.