@real-life/trust-protocol 0.1.1 → 0.3.0

package/dist/probe/trust.js

@@ -1,40 +1,48 @@
-// trust.mjs — Stufe 2 des Redesigns: der EXPLIZITE VERTRAUENSAKT
-// (aufgeschobene Anker-Offenlegung), der geblendete Stern und die
-// Pause-Semantik. PROBE, DOM-frei, auf rltp-core + rltp-crypto.
+// trust — der GRADUIERTE Vertrauensakt: seit dem Nachzug auf Visibility
+// 0.29 + Delivery 0.79 baut dieses Modul die ECHTEN Wire-Artefakte
+// (anchor-mapping@2 · grade-declaration@1 · star@1 mit 5.2a-Chunks),
+// getragen von den registrierten Task-Dokumenten (Delivery §4.4:
+// anchor-mapping/0.1 · grade-declaration/0.1 · star/0.1 — Payload = das
+// Artefakt, Dokument proof-frei, ein Träger), quittiert mit dem
+// deniablen delivery-ack (4.2-Klassenregel). Formen und Schlüssel sind
+// byte-kompatibel zu vectors/visibility.json (vectors3.test.mjs rechnet
+// sie unabhängig nach).
 //
-// DAS MODELL (portiert aus graph-web.mjs auf den WebCrypto-Stack):
-//   Vertrauensakt = EINSEITIGE Offenlegungsentscheidung. A liefert an B:
-//     1. das kreuz-MAC-te anchor-mapping pair→self (Designated Verifier:
-//        BEIDE MACs könnte auch B selbst berechnen — ein geleaktes
-//        Mapping beweist Dritten NICHTS; forgeMapping demonstriert das),
-//     2. die eigene Self-Card (stabiler Anker + keyAgreement),
-//     3. den geblendeten Stern-Schnappschuss.
-//   B VERIFIZIERT das Mapping mit den eigenen Geheimnissen, bevor die
-//   Verknüpfung akzeptiert wird. Pausieren stoppt nur KÜNFTIGE
-//   Lieferungen — Geliefertes bleibt (Einweg-Tür, irreversibles Wissen).
-//
-//   Stern (Publikums-Prinzip, Klasse D): der Sender leitet NIE rohe
-//   Dritt-Anker weiter. Jeder gehaltene Self-Anker reist als
-//   HMAC(k, anchor) unter dem Beziehungs-Schlüssel k; der Empfänger kann
-//   nur Anker testen, die er selbst legitim hält („gemeinsame Kontakte"),
-//   und sonst nichts. Epochales Blenden: salt = monotone Sequenznummer
-//   pro Beziehung; Listen SORTIERT (Lieferreihenfolge leakt nichts).
-//   Ehrlicher Rest: 1-Bit-Orakel über gehaltene Anker + die Zählung.
-import { jcs } from '../core.js';
+// Die Zustandsmaschinen sind die konvergierten:
+//   · Admissionsschicht (Sektion 2): Promotion-Commit beim ERSTEN
+//     verifizierten anchor-mapping@2 einer BEZIEHUNG (relId = die
+//     Kette, der Idempotenzschlüssel); genau ein Eintrag je Beziehung,
+//     self-Korrektur per höherer Revision in place; gleiche self auf
+//     zweiter Beziehung = Weg-2-Merge (früheste Position überlebt,
+//     Aliase); EINE totale Verifikations-Commit-Ordnung (a.seq).
+//   · Rekonziliation (5.4): Sicht = {(member, grade)} der admittierten,
+//     unmaskierten Mitglieder (Maske: 24h grade-wait ab Admission, fällt
+//     mit verifizierter Declaration oder Ablauf → fail-closed count);
+//     Baseline-Automat monoton über Ack-Completions, highWater überlebt
+//     ⊥, kein Failure-Ereignis, nie Rollback.
+//   · Byte-identische Redelivery (4.2): jede unquittierte Zustellung
+//     wird als DASSELBE Dokument erneut gesendet (outbox hält die Envs);
+//     der Empfänger re-ackt duplicate-known byte-identisch (ackStore).
+import { jcs, makeValidator, sameDigest } from '../core.js';
+import { SCHEMAS } from '../schemas.js';
 import * as C from './deps.js';
+import { buildAck, verifyAck, ACK_TYPE } from './acks.js';
 const te = new TextEncoder();
 const S = globalThis.crypto.subtle;
 const TT = 'https://real-life.org/trust-tasks/';
 const say = (p, m) => p.log.push(m);
 const uuid = (ent) => ent ?? globalThis.crypto.randomUUID();
+const V = makeValidator(SCHEMAS);
+const schemaOk = (file, data) => V.validate(data, SCHEMAS[file], SCHEMAS[file]).length === 0;
+export const GRADE_WAIT = 86_400_000; // 5.4: PT24H, in when-Millisekunden
+export const ADMISSION_BOUND = 10n ** 18n - 1n; // Sektion 2 — unerreichbar, geführt für die Totalität
+const CHUNK_MAX = 1024; // 5.2a: blinded[] je Chunk
 // ── Primitiven ──────────────────────────────────────────────────────────
 export async function hmac(keyBytes, msg) {
     const k = await S.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
     return C.b64uOf(new Uint8Array(await S.sign('HMAC', k, te.encode(msg))));
 }
-// der stabile soziale Anker = COMMUNITY-ANKER (Identity 0.13, S-DID-Schnitt):
-// gewöhnlicher Gruppen-Kontext über die Genesis der persönlichen Community —
-// nie mehr die zero-input-Recovery-Strings
+export const hmacU = async (keyBytes, msg) => 'u' + await hmac(keyBytes, msg);
 export async function communityContext(p) {
     if (!p.selfCtx)
         p.selfCtx = await C.communityContext(p.rootIkm, p.communityGenesis);
@@ -44,122 +52,394 @@ export const selfCard = async (p, whenIso) => {
     const s = await communityContext(p);
     return C.signCard(s, C.cardBody(s, { name: p.name }), whenIso);
 };
-// Beziehungs-Schlüssel: X25519 zwischen den pair-Kontexten des Kanals
+// self-card@1 (§6.2): { body: {type, anchor, keyAgreement}, proof:
+// {proofValue} } — ROHE Ed25519-Signatur über JCS(body), 'z'+base58
+// (§2.1: bewusst KEINE DI-Suite; zwei Artefakt-Familien)
+export async function selfCard1(p) {
+    const s = await communityContext(p);
+    const body = { type: 'self-card@1', anchor: s.anchor, keyAgreement: s.keyAgreement };
+    const sig = new Uint8Array(await S.sign({ name: 'Ed25519' }, s.ed.priv, te.encode(jcs(body))));
+    return { body, proof: { proofValue: 'z' + C.base58(sig) } };
+}
+const verifyRawSig = async (did, body, proofValue) => {
+    try {
+        if (typeof proofValue !== 'string' || proofValue[0] !== 'z')
+            return false;
+        const raw = C.edRawOfAnchor(did);
+        const sig = C.fromBase58(proofValue.slice(1));
+        if (!raw || !sig || sig.length !== 64)
+            return false;
+        const key = await S.importKey('raw', raw, { name: 'Ed25519' }, false, ['verify']);
+        return await S.verify({ name: 'Ed25519' }, key, sig, te.encode(jcs(body)));
+    }
+    catch {
+        return false;
+    }
+};
 const chShared = (contact) => C.ecdh(contact.channel.own.x.priv, C.xRawOfMk(contact.channel.counterpartKa));
 const relKey = async (contact, info) => C.hkdf(await chShared(contact), info);
-// ── anchor-mapping@2 (Designated Verifier, Doppel-MAC) ──────────────────
-// mac1: Kanal-DH (pairA × pairB) · mac2: selfA × pairB — der Empfänger
-// rechnet mac2 mit SEINEM pair-Privkey gegen die Self-Card nach. Beide
-// Schlüssel kann auch der Empfänger allein ableiten: Abstreitbarkeit.
-const mappingBody = (pairAnchor, selfAnchor, toPairAnchor, whenIso) => ({ type: 'anchor-mapping@2', pair: pairAnchor, self: selfAnchor, to: toPairAnchor, issuedAt: whenIso });
-export async function makeMapping(p, counterpartAnchor, when) {
-    const contact = p.contacts.get(counterpartAnchor);
+// ── anchor-mapping@2 — die normative Wire-Form (§6.1–6.3) ──────────────
+// body = { type, pair, self, to, card, revision, issuedAt } ·
+// proof = { mac1 (Kanal-DH, info map1) · mac2 (selfX × pairX-Adressat,
+// info map2) }, beide 'u'-MACs über JCS(body). Die Card reist IM Body.
+// der reine BAU (fehlbar, mutiert nichts) — modul-lokal: nur Aufrufer,
+// die den Issue-Lock halten und selbst committen (setTrust/
+// reissueTrust), erreichen ihn mit vorreservierter Revision. Der
+// explizite Revisionspfad ist NICHT mehr exportiert (Review 9, B-2:
+// er umging Lock, Deaktivierungs-Check und Persistenz).
+async function buildMappingArtifact(p, contact, counterpartAnchor, when, revision) {
     const s = await communityContext(p);
     const whenIso = C.iso(when);
-    const card = await selfCard(p, whenIso);
-    const body = mappingBody(contact.channel.own.anchor, s.anchor, counterpartAnchor, whenIso);
+    const card = await selfCard1(p);
+    const body = { type: 'anchor-mapping@2', pair: contact.channel.own.anchor, self: s.anchor, to: counterpartAnchor, card, revision, issuedAt: whenIso };
     const msg = jcs(body);
     const theirKa = C.xRawOfMk(contact.channel.counterpartKa);
-    return { body, card,
-        mac1: await hmac(await relKey(contact, 'rltp/trust/mac/map1'), msg),
-        mac2: await hmac(await C.hkdf(await C.ecdh(s.x.priv, theirKa), 'rltp/trust/mac/map2'), msg) };
+    return { body, proof: {
+            mac1: await hmacU(await relKey(contact, 'rltp/visibility/mac/map1'), msg),
+            mac2: await hmacU(await C.hkdf(await C.ecdh(s.x.priv, theirKa), 'rltp/visibility/mac/map2'), msg)
+        } };
+}
+export async function makeMapping(p, counterpartAnchor, when) {
+    const contact = p.contacts.get(counterpartAnchor);
+    // Ausstellungs-Disziplin (Review 8/9): Peek → fehlbar bauen →
+    // Zähler UND Body synchron committen (sentMapping = der persistierte
+    // ausgestellte Body, §6.4: one step per scope), seriell je Kontakt;
+    // ein deaktiviertes Tupel stellt nichts aus
+    return withIssueLock(contact, async () => {
+        if (contact.deactivated)
+            throw new Error('tuple deactivated — issues nothing (§6.4)');
+        const revision = peekRev(contact, 'mapRevOut');
+        const m = await buildMappingArtifact(p, contact, counterpartAnchor, when, revision);
+        if (contact.deactivated)
+            throw new Error('tuple deactivated — issues nothing (§6.4)');
+        contact.mapRevOut = revision;
+        contact.sentMapping = m;
+        return m;
+    });
 }
-// Verifikation ist EMPFÄNGER-PRIVAT: sie BRAUCHT die eigenen Geheimnisse
-// (das ist der Punkt — ein Dritter kann nicht einmal die Gültigkeit prüfen)
-export async function verifyMapping(p, m) {
+// Verifikation ist EMPFÄNGER-PRIVAT (§6.3, geschlossene Liste) — und
+// die Liste wird IN IHRER REIHENFOLGE ausgewertet (Review 19, B-1:
+// „all of the following hold, evaluated in this order"): 1 Schema ·
+// 2 to · 3 pair · 4 Card verifiziert unter IHREM Anker · 5
+// card.anchor == self · 6 k2 aus card.keyAgreement · 7 MACs.
+// arrivalKey = das Ankunftstupel (Empfangspfad); standalone wählt
+// body.pair (Schritt 3 dann trivial).
+export async function verifyMapping(p, m, arrivalKey) {
     try {
-        const b = m?.body;
-        if (!b || b.type !== 'anchor-mapping@2')
-            return false;
-        const entry = p.contacts.get(b.pair);
-        if (!entry?.channel?.own)
+        if (!schemaOk('visibility-anchor-mapping.schema.json', m))
+            return false; // 1
+        const b = m.body;
+        if (!C.calOK(b.issuedAt))
+            return false; // Kalender-Validität gehört zur Parse-Ebene (Review 12, B-3)
+        const key = arrivalKey ?? b.pair;
+        const entry = p.contacts.get(key);
+        if (!entry?.channel?.own || entry.deactivated)
             return false;
         if (b.to !== entry.channel.own.anchor)
-            return false;
-        const card = m.card;
-        if (card?.anchor !== b.self || !(await C.diVerify(card, b.self)))
-            return false;
+            return false; // 2
+        if (b.pair !== key)
+            return false; // 3 (Cross-Tupel-Bindung, Review 9)
+        if (!(await verifyRawSig(b.card?.body?.anchor, b.card?.body, b.card?.proof?.proofValue)))
+            return false; // 4: unter IHREM Anker
+        if (b.card.body.anchor !== b.self)
+            return false; // 5
         const msg = jcs(b);
-        if ((await hmac(await relKey(entry, 'rltp/trust/mac/map1'), msg)) !== m.mac1)
-            return false;
-        const k2 = await C.hkdf(await C.ecdh(entry.channel.own.x.priv, C.xRawOfMk(card.keyAgreement)), 'rltp/trust/mac/map2');
-        if ((await hmac(k2, msg)) !== m.mac2)
-            return false;
+        const k2 = await C.hkdf(await C.ecdh(entry.channel.own.x.priv, C.xRawOfMk(b.card.body.keyAgreement)), 'rltp/visibility/mac/map2'); // 6: k2 aus card.keyAgreement — VOR den MACs (Review 20, B-1)
+        if ((await hmacU(await relKey(entry, 'rltp/visibility/mac/map1'), msg)) !== m.proof.mac1)
+            return false; // 7 (mac1)
+        if ((await hmacU(k2, msg)) !== m.proof.mac2)
+            return false; // 7 (mac2)
         return true;
     }
     catch {
         return false;
     }
 }
-// die Abstreitbarkeits-Demo: der EMPFÄNGER fabriziert ein Mapping, das
-// einen beliebigen pair-Anker an ein beliebiges Self bindet, dessen Card
-// er hält — es verifiziert identisch. Genau darum überzeugt ein
-// geleaktes Mapping niemanden.
+// Abstreitbarkeits-Demo: der Empfänger fabriziert ein identisch
+// verifizierendes Mapping — ein Leak beweist Dritten nichts (Klasse V)
 export async function forgeMapping(forger, victimCard, pairAnchor, when) {
     const entry = forger.contacts.get(pairAnchor);
     const whenIso = C.iso(when);
-    const body = mappingBody(pairAnchor, victimCard.anchor, entry.channel.own.anchor, whenIso);
+    const body = { type: 'anchor-mapping@2', pair: pairAnchor, self: victimCard.body.anchor, to: entry.channel.own.anchor, card: victimCard, revision: '1', issuedAt: whenIso };
     const msg = jcs(body);
-    const k2 = await C.hkdf(await C.ecdh(entry.channel.own.x.priv, C.xRawOfMk(victimCard.keyAgreement)), 'rltp/trust/mac/map2');
-    return { body, card: victimCard,
-        mac1: await hmac(await relKey(entry, 'rltp/trust/mac/map1'), msg),
-        mac2: await hmac(k2, msg) };
+    const k2 = await C.hkdf(await C.ecdh(entry.channel.own.x.priv, C.xRawOfMk(victimCard.body.keyAgreement)), 'rltp/visibility/mac/map2');
+    return { body, proof: {
+            mac1: await hmacU(await relKey(entry, 'rltp/visibility/mac/map1'), msg),
+            mac2: await hmacU(k2, msg)
+        } };
 }
-// ── der geblendete Stern ────────────────────────────────────────────────
-// Sequenz-Reservierung: SYNCHRON vor jedem await, damit zwei
-// nebenläufige Aufrufe nie denselben Salt ziehen (Review 6, B-1).
-// Ein bei Fehlschlag verbrannter Salt ist erlaubt — die Sequenz ist
-// strikt monoton, nicht lückenlos.
-const reserveStarSeq = (contact) => {
-    contact.starSeqNext = Math.max(contact.starSeqNext ?? 0, contact.starSeq ?? 0) + 1;
-    return contact.starSeqNext;
+// ── die Admissionsschicht (Sektion 2) ───────────────────────────────────
+const relIdOf = (p, contactKey) => {
+    const c = p.contacts.get(contactKey);
+    return c ? (c.relId ??= contactKey) : contactKey;
+};
+// Bound testbar: p.admissionBound (BigInt) überschreibt den
+// unerreichbaren Spec-Bound — die MECHANIK (pending, k−1, Departure)
+// ist dieselbe (Sektion 2, „the rule exists for totality")
+const admission = (p) => (p.admission ??= { seq: 0n, byRel: new Map(), admitted: 0n });
+const boundOf = (p) => p.admissionBound ?? ADMISSION_BOUND;
+// grade-wait läuft nur ab, wenn ein Admissionszeitpunkt EXISTIERT
+// (Review 5, MAJOR): jede Zustandsoperation verlangt eine endliche Uhr
+const finite = (when) => {
+    if (!Number.isFinite(when))
+        throw new Error('admission requires a finite clock (5.4 grade-wait)');
+    return when;
 };
-const commitStar = (contact, seq, snap) => {
-    // das Journal hält NUR den High-Water-Stern: ein verspätet fertig
-    // gewordener kleinerer Salt rollt sentStar nicht zurück (Review 7, B-2)
-    if (seq > (contact.starSeq ?? 0)) {
-        contact.starSeq = seq;
-        contact.sentStar = snap;
+// Scope-Preflight (Review 5, B-5): prüft OHNE zu verbrauchen — ein Akt,
+// der in einem erschöpften Scope ausstellen müsste, suspendiert atomar
+const scopeOk = (cur) => BigInt(cur ?? '0') < ADMISSION_BOUND;
+// EIN atomarer Merge zweier Einträge: früheste Position überlebt,
+// Aliase lösen auf, Grade nach commitOrder; k admitted → k−1 Slots
+// frei → die nächsten Pending admittieren (Set-Änderung via reconcile)
+function mergeEntries(p, a, survivorIn, goneIn, when) {
+    const survivor = goneIn.pos < survivorIn.pos ? goneIn : survivorIn;
+    const gone = survivor === goneIn ? survivorIn : goneIn;
+    for (const rid of gone.relIds) {
+        survivor.relIds.add(rid);
+        a.byRel.set(rid, survivor);
+    }
+    for (const ck of gone.rels)
+        survivor.rels.add(ck);
+    // Declarations bleiben je Herkunftstupel (B-2): höchste order je Tupel
+    for (const [ck, g] of gone.grades ?? []) {
+        const cur = survivor.grades?.get(ck);
+        if (!cur || g.order > cur.order)
+            (survivor.grades ??= new Map()).set(ck, g);
+    }
+    // NUMERISCHES Minimum (Review 22): admittedAt ist eine Zahl — der
+    // Default-Sort verglich Strings (9 > 10) und konnte den grade-wait
+    // des verschmolzenen Members fälschlich verlängern
+    survivor.admittedAt = [survivor.admittedAt, gone.admittedAt].filter((x) => x !== undefined).sort((x, y) => x - y)[0];
+    if (survivor.status === 'admitted' && gone.status === 'admitted') {
+        a.admitted -= 1n;
+        admitPending(p, a, when);
+    }
+    else if (gone.status === 'admitted') {
+        survivor.status = 'admitted';
+    }
+    return survivor;
+}
+const admitPending = (p, a, when) => {
+    // k−1-Nachrücken in Promotion-Commit-Ordnung (Sektion 2)
+    while (a.admitted < boundOf(p)) {
+        const next = [...new Set(a.byRel.values())].filter((x) => x.status === 'pending').sort((x, y) => x.pos < y.pos ? -1 : 1)[0];
+        if (!next)
+            break;
+        next.status = 'admitted';
+        next.admittedAt = when;
+        a.admitted += 1n;
     }
 };
-// Produktion pro Kontakt SERIALISIERT: die Reservierung macht Salts
-// eindeutig, erst die Kette macht ihre AUSLIEFERUNG streng steigend —
-// der Empfänger verwirft normativ jeden nicht strikt größeren Salt
-const withStarLock = (contact, fn) => {
-    const run = (contact.starLock ?? Promise.resolve()).then(fn, fn);
-    contact.starLock = run.catch(() => { });
-    return run;
+/** Departure (Sektion 2): der Abgang EINER Beziehung entfernt nur
+ *  ihren Alias — „the relationships themselves remain fully active"
+ *  (Review 16, B-3): der verschmolzene Eintrag (und sein Slot) stirbt
+ *  erst mit der LETZTEN Beziehung */
+export function departMember(p, relId, when) {
+    finite(when);
+    const a = admission(p);
+    const e = a.byRel.get(relId);
+    if (!e)
+        return;
+    // die KETTE ist EINE Beziehung (Review 35): ihr Abgang entfernt auch
+    // die Ketten-Aliase (byRel-Schlüssel, deren Kontakt sich als DIESE
+    // Beziehung identifiziert — z. B. der frische Tupelschlüssel nach
+    // einer Kettung mit vorbestehendem Eintrag); Aliase ANDERER
+    // Beziehungen (Weg-2-Merge) bleiben
+    for (const rid of [...e.relIds]) {
+        if (rid === relId || (p.contacts.get(rid)?.relId ?? rid) === relId) {
+            e.relIds.delete(rid);
+            a.byRel.delete(rid);
+        }
+    }
+    e.relIds.delete(relId);
+    a.byRel.delete(relId);
+    // der Grade-Strang der GEGANGENEN Beziehung stirbt mit ihr (Review
+    // 17, B-1): „across the member's LIVE relationships' active heads" —
+    // Kontaktschlüssel dieser Beziehung verlassen die effektive
+    // Grade-Auswertung atomar mit dem Departure
+    for (const ck of [...e.rels]) {
+        const c = p.contacts.get(ck);
+        if ((c?.relId ?? ck) === relId) {
+            e.rels.delete(ck);
+            e.grades?.delete(ck);
+        }
+    }
+    if (e.relIds.size > 0)
+        return; // Aliase bleiben, der Member bleibt admittiert
+    if (e.status === 'admitted') {
+        a.admitted -= 1n;
+        admitPending(p, a, when);
+    }
+}
+export function promotionCommit(p, relId, self, contactKey, when) {
+    finite(when);
+    const a = admission(p);
+    let e = a.byRel.get(relId);
+    if (e) {
+        // spätere Verifikation derselben Beziehung: in place — auch eine
+        // self-KORREKTUR per höherer Revision ändert nur den Inhalt, nie
+        // Position oder Status (Sektion 2). Trifft die Korrektur die self
+        // einer ANDEREN Beziehung, ist das der Weg-2-Merge
+        if (e.self !== self) {
+            const twin = [...a.byRel.values()].find((x) => x !== e && x.self === self);
+            if (twin) {
+                e.self = self;
+                e = mergeEntries(p, a, e, twin, when);
+            }
+            else
+                e.self = self;
+        }
+        e.rels.add(contactKey);
+    }
+    else {
+        // gleiche self auf einer ANDEREN Beziehung = der Weg-2-Merge
+        const twin = [...a.byRel.values()].find((x) => x.self === self);
+        if (twin) {
+            twin.relIds.add(relId);
+            twin.rels.add(contactKey);
+            a.byRel.set(relId, twin);
+            e = twin;
+        }
+        else {
+            // Admission ist TOTAL: unter dem Bound admitted (der Normalfall —
+            // die Promotion selbst ist die Admission), am Bound
+            // deliverable-pending (triggert nichts, rückt bei Abgang nach)
+            const status = a.admitted < boundOf(p) ? 'admitted' : 'pending';
+            if (status === 'admitted')
+                a.admitted += 1n;
+            e = { id: relId, pos: (a.seq += 1n), relIds: new Set([relId]), self, rels: new Set([contactKey]), status, admittedAt: status === 'admitted' ? when : undefined, grades: new Map() }; // id = kanonische Identität (Review 36)
+            a.byRel.set(relId, e);
+        }
+    }
+    return e;
+}
+/** Kettung (B-4): der neue Kopf löst über die überlebende Beziehung auf;
+ *  hält die frische Beziehung schon einen EIGENEN Eintrag, verschmilzt
+ *  er atomar mit dem der alten (früheste Position, Aliase, k−1) */
+export function chainAdmission(p, survivingRelId, freshRelId, newContactKey, when) {
+    finite(when);
+    const a = admission(p);
+    const oldE = a.byRel.get(survivingRelId);
+    const freshE = a.byRel.get(freshRelId);
+    let e = oldE;
+    if (oldE && freshE && oldE !== freshE)
+        e = mergeEntries(p, a, oldE, freshE, when);
+    else if (!oldE && freshE) {
+        e = freshE;
+        freshE.relIds.add(survivingRelId);
+        a.byRel.set(survivingRelId, freshE);
+    }
+    if (e) {
+        e.relIds.add(freshRelId);
+        a.byRel.set(freshRelId, e);
+        e.rels.add(newContactKey);
+    }
+    return e;
+}
+// Declarations je HERKUNFTSTUPEL (Review 5, B-2): §6.4 — „a deactivated
+// head's declarations are dead with their tuple". order = dieselbe
+// totale Verifikations-Commit-Ordnung wie die Promotions.
+// order stammt aus dem Moment der VERIFIKATION (Review 6, B-2): eine
+// vor dem Mapping verifizierte Declaration trägt ihren Stempel schon
+// und erhält beim späteren Commit KEINEN neuen — sonst schlüge sie
+// nach einem Merge eine echt später verifizierte Declaration
+const declCommit = (p, relId, grade, contactKey, order) => {
+    const e = admission(p).byRel.get(relId);
+    if (e)
+        (e.grades ??= new Map()).set(contactKey, { grade, order: order ?? (admission(p).seq += 1n) });
+    return e;
 };
-// reine Berechnung — mutiert NICHTS; Sequenz kommt aus reserveStarSeq
-async function buildStarPure(p, contact, seq) {
-    const salt = String(seq);
-    const k = await relKey(contact, 'rltp/trust/blind/star/' + salt);
-    const blinded = [];
-    let count = 0;
-    for (const e of p.contacts.values()) {
-        if (!e.selfAnchor)
+// die effektive Grade beim LESEN über die aktiven Köpfe berechnet —
+// Deaktivierung tötet die Declaration ohne Migrations- oder Aufräumlogik
+const effectiveGrade = (p, e) => {
+    let best = null;
+    for (const [ck, g] of e.grades ?? []) {
+        const c = p.contacts.get(ck);
+        if (!c || c.deactivated)
+            continue;
+        if (!best || g.order > best.order)
+            best = g;
+    }
+    return best;
+};
+/**
+ * Die Rekonziliations-Sicht (5.4): {(member, grade)} der admittierten,
+ * unmaskierten Mitglieder. Maske: keine verifizierte Declaration UND
+ * grade-wait (24h ab Admission) offen → nicht in der Sicht; nach
+ * Ablauf fail-closed 'count'.
+ */
+export function viewOf(p, when) {
+    const seen = new Set();
+    const out = [];
+    for (const e of admission(p).byRel.values()) {
+        if (seen.has(e))
             continue;
-        count++;
-        blinded.push(await hmac(k, e.selfAnchor));
+        seen.add(e);
+        if (e.status !== 'admitted')
+            continue; // deliverable-pending triggert nichts (Sektion 2)
+        const g = effectiveGrade(p, e); // nur AKTIVE Köpfe zählen (B-2)
+        if (g)
+            out.push({ member: e.self, grade: g.grade });
+        // Grenzzeitpunkt: „the window elapses only strictly afterwards" —
+        // bei exakter Gleichheit bleibt maskiert (Review 11, B-4)
+        else if (e.admittedAt === undefined || when <= e.admittedAt + GRADE_WAIT)
+            continue; // provisorisch maskiert (B-3)
+        else
+            out.push({ member: e.self, grade: 'count' });
     }
+    return out.sort((x, y) => x.member < y.member ? -1 : x.member > y.member ? 1 : 0);
+}
+// ── star@1 — die normative Wire-Form (5.2/5.2a) ────────────────────────
+const kStar = (contact, counterpartAnchor, salt) => relKey(contact, `rltp/visibility/blind/star/${contact.channel.own.anchor}/${counterpartAnchor}/${salt}`);
+const kStarIn = (contact, counterpartAnchor, salt) => relKey(contact, `rltp/visibility/blind/star/${counterpartAnchor}/${contact.channel.own.anchor}/${salt}`);
+// reine Berechnung: die 5.2a-Chunk-Serie einer Zustellung — count zählt
+// ALLE Mitglieder der Sicht, blinded[] nur die blinded-graded Teilmenge
+async function buildStarChunks(contact, counterpartAnchor, salt, view) {
+    const k = await kStar(contact, counterpartAnchor, salt);
+    const blinded = [];
+    for (const v of view)
+        if (v.grade === 'blinded')
+            blinded.push(await hmacU(k, v.member));
     blinded.sort();
-    return { salt, count, blinded };
+    const count = String(view.length);
+    const n = Math.max(1, Math.ceil(blinded.length / CHUNK_MAX));
+    const chunks = [];
+    for (let i = 0; i < n; i++) {
+        const body = { type: 'star@1', salt, seq: String(i + 1), last: i === n - 1, count, blinded: blinded.slice(i * CHUNK_MAX, (i + 1) * CHUNK_MAX) };
+        chunks.push({ body, proof: { mac: await hmacU(k, jcs(body)) } });
+    }
+    return chunks;
 }
-export function buildStar(p, contact) {
+export async function buildStar(p, contact, when) {
+    if (contact.deactivated)
+        return null; // deaktivierte Tupel stellen nichts aus (Review 9, B-3)
     return withStarLock(contact, async () => {
-        const seq = reserveStarSeq(contact);
-        const snap = await buildStarPure(p, contact, seq);
-        commitStar(contact, seq, snap); // Sender-Journal: was ich hier zuletzt geliefert habe
-        return snap;
+        if (contact.deactivated)
+            return null; // Re-Check nach dem Lock-Erwerb
+        const salt = peekStarSeq(contact); // nur gepeekt (Review 25)
+        const key = [...p.contacts.entries()].find(([, c]) => c === contact)?.[0];
+        // dieselbe Commit-Revalidierung wie reconcile (Review 26): wanderte
+        // die Sicht während der MAC-Awaits, wird mit der aktuellen neu
+        // gebaut — „every delivery carries the set current at its
+        // production commit"
+        for (;;) {
+            const view = viewOf(p, when);
+            const chunks = await buildStarChunks(contact, key, salt, view);
+            if (contact.deactivated)
+                return null; // Re-Check nach den MAC-Awaits (Review 10) — danach kein await
+            if (!sameView(view, viewOf(p, when)))
+                continue;
+            contact.starSeqNext = salt; // COMMIT synchron mit der Ausgabe
+            return chunks[0].body;
+        }
     });
 }
 // Empfängerseite: denselben Lieferschlüssel nachrechnen, EINEN Anker testen
 export async function starMatch(p, entry, snap, anchor) {
-    const k = await relKey(entry, 'rltp/trust/blind/star/' + snap.salt);
-    return snap.blinded.includes(await hmac(k, anchor));
+    const key = [...p.contacts.entries()].find(([, c]) => c === entry)?.[0];
+    const k = await kStarIn(entry, key, snap.salt);
+    return snap.blinded.includes(await hmacU(k, anchor));
 }
-// Cache für die synchrone UI: pro Kontakt { count, knownNames } aus dem
-// empfangenen Schnappschuss gegen die EIGENEN gehaltenen Self-Anker.
 export async function refreshStarInfo(p) {
     for (const [key, entry] of p.contacts) {
         if (!entry.starReceived || !entry.channel?.own)
@@ -173,60 +453,264 @@ export async function refreshStarInfo(p) {
             if (await starMatch(p, entry, entry.starReceived, e.selfAnchor))
                 known.push(e.name);
         }
-        entry.starInfo = { count: entry.starReceived.count, knownNames: known.sort() };
+        entry.starInfo = { count: entry.starReceived.count, knownNames: known.sort() }; // count bleibt String — 18 Stellen exakt
     }
 }
-// ── der Vertrauensakt ───────────────────────────────────────────────────
-// Erlaubt für ✓ (Zeremonie) UND ⇄ (vorgestellt, beidseitig) — Vertrauen
-// ist eine OFFENLEGUNGS-Entscheidung, keine Verifikations-Behauptung
-// (Antons Entscheid 24.08.); die UI benennt bei ⇄ ehrlich die
-// Vermittler-Abhängigkeit. Gesperrt bleibt ◇: einseitig hast du nichts
-// freigegeben — es existiert kein eigener Kanal-Kontext für das Mapping.
-// Einweg-Tür: trustGiven bleibt; Pausieren stoppt nur das Abo.
+// ── grade-declaration@1 (5.5) ──────────────────────────────────────────
+const kGrade = (subjectCtx, holderKa, subjectAnchor, holderAnchor) => C.ecdh(subjectCtx.x.priv, C.xRawOfMk(holderKa)).then((sh) => C.hkdf(sh, `rltp/visibility/mac/grade/${subjectAnchor}/${holderAnchor}`));
+// revision IMMER vorreserviert (gepeekt) vom Aufrufer, der den
+// Issue-Lock hält und den Zähler synchron committet (Review 8, B-1:
+// kein Defaultpfad, der vor fehlbarer Arbeit verbraucht)
+async function buildGradeDecl(p, counterpartAnchor, grade, when, revision) {
+    const contact = p.contacts.get(counterpartAnchor);
+    const body = { type: 'grade-declaration@1', subject: contact.channel.own.anchor, holder: counterpartAnchor, grade, revision, issuedAt: C.iso(when) };
+    const k = await kGrade(contact.channel.own, contact.channel.counterpartKa, body.subject, body.holder);
+    return { body, proof: { mac: await hmacU(k, jcs(body)) } };
+}
+// ── Dokumente, Outbox, byte-identische Redelivery (Delivery §3/4.2/4.4) ─
+// Payload = das Artefakt selbst; das Dokument trägt KEINEN Proof (die
+// Artefakt-MACs sind der eine Träger). threadId frisch je Zustellung;
+// Chunks eines Salts teilen sie. Die outbox hält jede unquittierte
+// Zustellung als DENSELBEN Env — Redelivery ist byte-identisch (4.2).
+const outboxOf = (contact) => (contact.outbox ??= new Map());
+async function sendDoc(p, counterpartAnchor, slug, payload, when, threadId, meta = {}, ent = {}) {
+    const contact = p.contacts.get(counterpartAnchor);
+    const doc = {
+        id: uuid(ent.id), type: TT + slug + '/0.1',
+        issuer: contact.channel.own.anchor, recipient: counterpartAnchor,
+        threadId, issuedAt: C.iso(when), payload,
+    };
+    const env = await C.seal(doc, contact.channel.counterpartKa, ent);
+    const digest = await C.digestDoc(doc);
+    outboxOf(contact).set(digest, { env, threadId, kind: slug, ...meta });
+    return { to: contact, kind: slug + '/0.1', env };
+}
+// ── die Ausstellungs-Disziplin (Review 7, B-1/B-2) ─────────────────────
+// „Assigning a revision and persisting the issued body are one step per
+// scope" (§6.4): je Kontakt serialisiert EIN Issue-Lock alle
+// Revisions-Producer; die Revision wird nur GEPEEKT, alles Fehlbare
+// (Bau, Seal, Digest) läuft davor, und Zähler + Outbox + Zustand
+// committen in EINEM synchronen Zug am Ende — ein Fehlschlag
+// verbraucht NICHTS, und gradeOutLast folgt der Ausstellungsordnung.
+export const withIssueLock = (contact, fn) => {
+    const run = (contact.issueLock ?? Promise.resolve()).then(fn, fn);
+    contact.issueLock = run.catch(() => { });
+    return run;
+};
+export const peekRev = (contact, field) => {
+    const next = BigInt(contact[field] ?? '0') + 1n;
+    if (next > ADMISSION_BOUND)
+        throw new Error('scope exhausted — issues nothing further (2.1)');
+    return String(next);
+};
+// prepare (fehlbar: Seal + Digest) / commit (synchron: Outbox-Eintrag)
+async function prepareDoc(p, counterpartAnchor, slug, payload, when, threadId, meta = {}, ent = {}) {
+    const contact = p.contacts.get(counterpartAnchor);
+    const doc = {
+        id: uuid(ent.id), type: TT + slug + '/0.1',
+        issuer: contact.channel.own.anchor, recipient: counterpartAnchor,
+        threadId, issuedAt: C.iso(when), payload,
+    };
+    const env = await C.seal(doc, contact.channel.counterpartKa, ent);
+    const digest = await C.digestDoc(doc);
+    return { contact, digest, entry: { env, threadId, kind: slug, ...meta }, out: { to: contact, kind: slug + '/0.1', env } };
+}
+const commitDoc = (prep) => { outboxOf(prep.contact).set(prep.digest, prep.entry); return prep.out; };
+// Salt nur GEPEEKT (Review 25): strikt monoton, nie dicht (5.2) —
+// aber „taking the set snapshot, assigning the salt, and committing
+// are one step": ein Bau-Fehler verbraucht nichts, auch am letzten
+// Wert entsteht nie falsche Erschöpfung. Der Aufrufer committet
+// synchron mit der Persistenz (unter dem Star-Lock serialisiert).
+const peekStarSeq = (contact) => {
+    const next = BigInt(contact.starSeqNext ?? '0') + 1n;
+    if (next > ADMISSION_BOUND)
+        throw new Error('scope exhausted — issues nothing further (2.1)');
+    return String(next);
+};
+// EIN Lock je Kontakt für Produktion UND Empfang, geteilt mit dem
+// Continuity-Pfad (Review 4, B-1/B-2: Trust- und Continuity-Effekte
+// desselben Kontakts serialisieren gemeinsam; Reentry-Checks im Lock)
+export const withContactLock = (contact, fn) => {
+    const run = (contact.contLock ?? Promise.resolve()).then(fn, fn);
+    contact.contLock = run.catch(() => { });
+    return run;
+};
+const withStarLock = withContactLock;
+// der Baseline-Automat (5.4, totale Tabelle): completion(salt), sobald
+// JEDER Chunk-Digest des Salts quittiert ist
+const subOf = (contact) => (contact.sub ??= { highWater: 0n, baseline: null, inFlight: new Map() });
+const sameView = (a, b) => a.length === b.length && a.every((x, i) => x.member === b[i].member && x.grade === b[i].grade);
+/**
+ * reconcile (5.4 — die eine Regel): divergiert die Sicht von der
+ * Baseline (⊥ = divergent, das New-Head-Korollar), und ist nicht
+ * pausiert, wird der AKTUELLE Stand geliefert — an JEDEM weiteren
+ * Delivery-Kontakt unter frischem, höherem Salt (5.4 wörtlich,
+ * Review 23; Salts sind ausdrücklich nicht dicht). Es gibt keinen
+ * Same-View-Retry; die 4.4-Byte-Identität ist eine Formvorschrift
+ * für Chunk-Retries, keine Anordnung.
+ */
+export async function reconcile(p, counterpartAnchor, when, ent = {}) {
+    const contact = p.contacts.get(counterpartAnchor);
+    if (!contact || contact.deactivated || !contact.trustGiven || contact.trustPaused)
+        return null;
+    return withStarLock(contact, async () => {
+        // Re-Check nach dem Lock-Erwerb (Review 9 B-3 / Review 11 B-1):
+        // auch die Pause — „while paused, the delivery duty is suppressed"
+        if (contact.deactivated || contact.trustPaused)
+            return null;
+        let view = viewOf(p, when);
+        const s = subOf(contact);
+        if (s.baseline && sameView(s.baseline, view))
+            return null;
+        // überholte In-Flight-Salts (≤ highWater) sind tot: der Empfänger
+        // MUSS sie ablehnen — purgen, nie wiederverwenden (Review 2, B-7)
+        for (const [salt, f] of [...s.inFlight]) {
+            if (BigInt(salt) <= s.highWater) {
+                for (const d of f.pending.keys())
+                    outboxOf(contact).delete(d);
+                s.inFlight.delete(salt);
+            }
+        }
+        // KEIN Same-View-Retry (Review 23, B-1): 5.4 wörtlich — „a
+        // delivery whose chunks are never all acknowledged … simply never
+        // completes … and the next available delivery contact ships the
+        // current view under a fresh, higher salt." Die 4.4-Byte-
+        // Identitäts-Regel ist eine FORMVORSCHRIFT für den Fall eines
+        // Chunk-Retries, keine Anordnung eines solchen — jeder weitere
+        // Delivery-Kontakt prägt frisch und höher (Salts sind ausdrücklich
+        // nicht dicht). So löst der Sender auch ein beim Empfänger
+        // vergiftetes in-flight-Salt ab, ohne je vom Gift zu wissen; alte
+        // Ack-Referenzen bleiben bis zur Completion-Purge sicher stehen.
+        const salt = peekStarSeq(contact); // nur gepeekt (Review 25) — committet synchron mit Outbox + inFlight
+        const threadId = ent.threadId ?? globalThis.crypto.randomUUID();
+        // „taking the set snapshot, assigning the salt, and committing are
+        // one step" (Review 9, B-4): der Bau ist fehlbar und wartet — am
+        // Commit wird die Sicht SYNCHRON neu verglichen; wanderte sie
+        // während des Baus (Promotion/Declaration eines ANDEREN Kontakts),
+        // wird mit der aktuellen Sicht neu gebaut, unter demselben Salt
+        // (nichts wurde persistiert). Jede Zustellung trägt so den Stand
+        // ihres Production-Commits.
+        for (;;) {
+            const chunks = await buildStarChunks(contact, counterpartAnchor, salt, view);
+            const preps = [];
+            for (const chunk of chunks)
+                preps.push(await prepareDoc(p, counterpartAnchor, 'star', chunk, when, threadId, { salt }, ent));
+            // Re-Check (Review 9 B-3 / Review 11 B-1), danach kein await:
+            // eine während des Baus gesetzte Pause supprimiert die Zustellung
+            if (contact.deactivated || contact.trustPaused)
+                return null;
+            const now = viewOf(p, when);
+            if (!sameView(view, now)) {
+                view = now;
+                if (s.baseline && sameView(s.baseline, view))
+                    return null; // konvergiert während des Baus → Schweigen
+                continue;
+            }
+            // COMMIT — ein synchroner Zug: Salt + Outbox + inFlight + Sicht
+            contact.starSeqNext = salt;
+            const pending = new Map();
+            const envs = [];
+            for (const prep of preps) {
+                const out = commitDoc(prep);
+                pending.set(prep.digest, { env: out.env });
+                envs.push(out.env);
+            }
+            s.inFlight.set(salt, { view, pending, threadId });
+            return { to: contact, kind: 'star/0.1', envs, salt };
+        }
+    });
+}
+// die eigene Grade-ENTSCHEIDUNG trägt einen Ausstellungs-Ordnungsstempel
+// (Review 27): beim Chaining gewinnt die ZULETZT AUSGESTELLTE („MUST
+// re-issue its most recently issued grade"), nie die des zufällig
+// frischeren Kopfs
+export const stampGradeOut = (p, contact, grade) => {
+    contact.gradeOutLast = grade;
+    contact.gradeOutOrder = (p.gradeIssueSeq = (p.gradeIssueSeq ?? 0n) + 1n);
+};
+// ── der Vertrauensakt (register no. 3: EIN menschlicher Akt) ────────────
+// setTrust stellt aus: anchor-mapping@2 (Offenlegung) + grade-
+// declaration@1 'blinded' (die Wahl) — zwei registrierte Dokumente.
+// Der Stern folgt über reconcile (5.4: die Promotion der Gegenseite
+// erzeugt dort die Divergenz; hier entsteht nur die eigene Sicht).
 export async function setTrust(p, counterpartAnchor, when, ent = {}) {
     const contact = p.contacts.get(counterpartAnchor);
     if (!contact)
         return { error: 'kein Kontakt' };
     if (!contact.channel?.own)
         return { error: 'kein eigener Kanal — einseitig (◇) hast du nichts freigegeben' };
-    if (contact.trustGiven)
-        return { error: 'bereits geschenkt (Einweg-Tür)' };
-    // In-flight-Latch (Review 6, B-1): der Latch fällt SYNCHRON — zwei
-    // nebenläufige Aufrufe können die offene Tür nicht beide bestehen
-    if (contact.trustPending)
-        return { error: 'bereits unterwegs (Einweg-Tür)' };
-    contact.trustPending = true;
-    try {
-        // ALLES Fehlbare — auch die Zeitform (when=NaN wirft) — liegt im
-        // try, dessen finally den Latch räumt (Review 7, B-1)
-        const whenIso = C.iso(when);
-        // die Tür schließt erst, wenn die Disclosure WIRKLICH existiert
-        // (Review 5, B-5): alles Fehlbare läuft vor den Journal-Mutationen
-        const mapping = await makeMapping(p, counterpartAnchor, when);
-        // Stern-Abschnitt unter dem Kontakt-Lock: Reservierung, Bau, Siegel
-        // und Commit in EINEM geordneten Zug (Review 7, B-2)
-        const { env, star, seq } = await withStarLock(contact, async () => {
-            const seq = reserveStarSeq(contact);
-            const star = await buildStarPure(p, contact, seq);
-            const body = {
-                id: uuid(ent.id), type: TT + 'trust-disclosure@probe',
-                issuer: contact.channel.own.anchor, recipient: counterpartAnchor,
-                issuedAt: whenIso, payload: { mapping, star },
-            };
-            const doc = await C.diSign(contact.channel.own, body, whenIso);
-            const env = await C.seal(doc, contact.channel.counterpartKa, ent);
-            commitStar(contact, seq, star);
-            return { env, star, seq };
-        });
-        contact.trustGiven = whenIso;
-        contact.sentMapping = mapping; // Sender-Journal: die geöffnete Einweg-Tür
-        say(p, `Vertrauen geschenkt an ${contact.name}: stabiler Anker offengelegt (DV-Mapping) + Kontakt-Updates aktiv`);
-        return { to: contact, env };
-    }
-    finally {
-        contact.trustPending = false;
-    }
+    // GANZER Akt unter dem Issue-Lock (Review 7, B-1/B-2): Revisionen
+    // werden nur gepeekt, alles Fehlbare läuft davor, Zähler + Outbox +
+    // Zustand committen synchron am Ende — ein Seal-Fehler verbraucht
+    // NICHTS, und kein Producer schiebt sich zwischen Peek und Commit
+    return withIssueLock(contact, async () => {
+        // ein deaktiviertes Tupel stellt nichts aus (Review 8, B-2 —
+        // §6.4/„a chain append is atomic with the deactivation"): geprüft
+        // nach dem Lock-Erwerb UND synchron vor dem Commit
+        if (contact.deactivated)
+            return { error: 'tuple deactivated — Kopf der Beziehung ist gewandert' };
+        if (contact.trustGiven)
+            return { error: 'bereits geschenkt (Einweg-Tür)' };
+        if (contact.trustPending)
+            return { error: 'bereits unterwegs (Einweg-Tür)' }; // Latch (Review 6, B-1)
+        if (!scopeOk(contact.mapRevOut) || !scopeOk(contact.gradeRevOut))
+            return { error: 'scope exhausted — act suspended (2.1)' };
+        contact.trustPending = true;
+        try {
+            const mapRev = peekRev(contact, 'mapRevOut');
+            const gradeRev = peekRev(contact, 'gradeRevOut');
+            const whenIso = C.iso(when);
+            const mapping = await buildMappingArtifact(p, contact, counterpartAnchor, when, mapRev);
+            const grade = await buildGradeDecl(p, counterpartAnchor, 'blinded', when, gradeRev);
+            const prepM = await prepareDoc(p, counterpartAnchor, 'anchor-mapping', mapping, when, uuid(ent.threadId), {}, ent);
+            const prepG = await prepareDoc(p, counterpartAnchor, 'grade-declaration', grade, when, uuid(), {}, ent);
+            if (contact.deactivated)
+                return { error: 'tuple deactivated — Kopf der Beziehung ist gewandert' }; // Re-Check (B-2), danach kein await
+            // COMMIT — ein synchroner Zug (§6.4: assigning + persisting = one step)
+            contact.mapRevOut = mapRev;
+            contact.gradeRevOut = gradeRev;
+            const outbound = [commitDoc(prepM), commitDoc(prepG)];
+            contact.trustGiven = whenIso;
+            stampGradeOut(p, contact, 'blinded'); // die zuletzt ausgestellte Entscheidung (für V2), mit Ordnungsstempel
+            contact.sentMapping = mapping;
+            say(p, `Vertrauen geschenkt an ${contact.name}: Anker offengelegt (anchor-mapping@2) + Grade 'blinded' erklärt`);
+            return { to: contact, outbound, env: outbound[0].env };
+        }
+        finally {
+            contact.trustPending = false;
+        }
+    });
+}
+/**
+ * setGrade (5.5): die spätere Grade-Entscheidung des Subjekts — auch
+ * 'count' (die Wahl gehört dem Kontakt; register no. 3 kollabiert sie
+ * nur im Default-UX). Producer der Declaration, Revision monoton.
+ */
+export async function setGrade(p, counterpartAnchor, grade, when, ent = {}) {
+    const contact = p.contacts.get(counterpartAnchor);
+    if (!contact?.channel?.own || contact.deactivated)
+        return { error: 'kein aktiver Kanal' };
+    return withIssueLock(contact, async () => {
+        // Re-Check nach dem Lock-Erwerb (Review 8, B-2): eine Kettung
+        // während der Wartezeit deaktiviert dieses Tupel — es stellt nichts
+        // mehr aus, gradeOutLast des neuen Kopfs bleibt die Wahrheit
+        if (contact.deactivated)
+            return { error: 'tuple deactivated — Kopf der Beziehung ist gewandert' };
+        const gradeRev = peekRev(contact, 'gradeRevOut'); // wirft bei Erschöpfung, verbraucht nichts (B-1)
+        const g = await buildGradeDecl(p, counterpartAnchor, grade, when, gradeRev);
+        const prep = await prepareDoc(p, counterpartAnchor, 'grade-declaration', g, when, uuid(), {}, ent);
+        if (contact.deactivated)
+            return { error: 'tuple deactivated — Kopf der Beziehung ist gewandert' }; // Re-Check (B-2), danach kein await
+        // COMMIT — ein synchroner Zug (Review 7, B-1)
+        contact.gradeRevOut = gradeRev;
+        const out = commitDoc(prep);
+        stampGradeOut(p, contact, grade);
+        say(p, `Grade '${grade}' erklärt an ${contact.name}`);
+        return { to: contact, outbound: [out] };
+    });
 }
+// Pause (5.4): initial unpaused, EINZIGE Transition ist dieser Akt;
+// Unpause re-evaluiert die Divergenz (Producer: starRefreshAll)
 export function setTrustPaused(p, counterpartAnchor, paused) {
     const contact = p.contacts.get(counterpartAnchor);
     if (!contact?.trustGiven)
@@ -234,39 +718,99 @@ export function setTrustPaused(p, counterpartAnchor, paused) {
     contact.trustPaused = !!paused;
     say(p, paused ? `Kontakt-Updates an ${contact.name} pausiert (Geliefertes bleibt)` : `Kontakt-Updates an ${contact.name} wieder aktiv`);
 }
-// Bestand geändert (neuer Self-Anker gehalten) → Stern überall auffrischen,
-// wo ich vertraue und nicht pausiert habe. Ohne das frieren Sterne in der
-// Toggle-Reihenfolge ein (Antons Erstlauf-Befund im Graph-Simulator).
 /**
- * Refresh every deliverable star. Per-recipient resilience (review 5,
- * M-1): a failure for ONE recipient never discards the stars already
- * built for others — the result carries the sealed outbound plus a
- * named failure list. THE CONTRACT: the caller (host application) owns
- * redelivery of failed refreshes, e.g. by calling this again; a failed
- * refresh is a SEND problem, never grounds to redeliver the inbound
- * document (its effect is complete and cached).
+ * V2 (5.5): auf dem neuen Kopf stellt das Subjekt seinen zuletzt
+ * ausgestellten Grade neu aus — Revision startet im neuen Tupel-Scope,
+ * keine Nutzerfrage; das Mapping reist als MAY (6a.4) mit. Die Pause
+ * supprimiert dies NICHT (5.5 kennt keine Pause-Ausnahme — sie
+ * supprimiert nur die Stern-Delivery); die Pflicht (trustReissueDue)
+ * stirbt erst mit der QUITTIERTEN Zustellung der Declaration.
+ */
+export async function reissueTrust(p, counterpartAnchor, when, ent = {}) {
+    const contact = p.contacts.get(counterpartAnchor);
+    // Gate: eine AUSGESTELLTE Declaration ODER der Trust-Akt trägt die
+    // Pflicht (Review 33, B-1) — nie nur trustGiven
+    if (!contact?.channel?.own || contact.deactivated || (!contact.trustGiven && contact.gradeOutLast === undefined))
+        return null;
+    // KEINE Pause-Suppression (Review 12, B-4): 5.4 supprimiert die
+    // DELIVERY-Pflicht (Stern); die Register-5-Neuausstellung läuft
+    // „on the next available delivery contact" ohne Pause-Ausnahme (5.5)
+    if (contact.reissuePending)
+        return null; // Single-Flight
+    contact.reissuePending = true;
+    try {
+        return await withIssueLock(contact, async () => {
+            if (contact.deactivated)
+                return null; // Re-Check nach dem Lock-Erwerb (Review 8, B-2)
+            // unquittierte Neuausstellung → byte-identischer Retry
+            for (const [digest, o] of outboxOf(contact))
+                if (o.kind === 'grade-declaration' && o.v2) {
+                    return { to: contact, outbound: [{ to: contact, kind: 'grade-declaration/0.1 (Retry, byte-identisch)', env: o.env }] };
+                }
+            // die MUST-Grade hängt NIE am MAY-Mapping (Review 5, B-5): Grade-
+            // Scope erschöpft → Pflicht suspendiert (2.1, trustReissueDue
+            // bleibt); Revisionen nur gepeekt, Commit synchron (Review 7, B-1)
+            if (!scopeOk(contact.gradeRevOut))
+                return null;
+            const gradeRev = peekRev(contact, 'gradeRevOut');
+            const grade = await buildGradeDecl(p, counterpartAnchor, contact.gradeOutLast ?? 'blinded', when, gradeRev);
+            const prepG = await prepareDoc(p, counterpartAnchor, 'grade-declaration', grade, when, uuid(), { v2: true }, ent);
+            let prepM, mapping, mapRev;
+            if (contact.trustGiven && scopeOk(contact.mapRevOut)) { // das MAY-Mapping gehört zum TRUST-Akt (6a.4)
+                try {
+                    mapRev = peekRev(contact, 'mapRevOut');
+                    mapping = await buildMappingArtifact(p, contact, counterpartAnchor, when, mapRev);
+                    prepM = await prepareDoc(p, counterpartAnchor, 'anchor-mapping', mapping, when, uuid(), {}, ent);
+                }
+                catch {
+                    prepM = undefined; /* MAY (6a.4) — ein Mapping-Fehler suspendiert nur das Mapping, verbraucht nichts */
+                }
+            }
+            if (contact.deactivated)
+                return null; // Re-Check (B-2), danach kein await
+            // COMMIT — ein synchroner Zug (§6.4)
+            contact.gradeRevOut = gradeRev;
+            stampGradeOut(p, contact, grade.body.grade); // die Neuausstellung IST eine Ausstellung (Review 27)
+            const outbound = [commitDoc(prepG)];
+            if (prepM) {
+                contact.mapRevOut = mapRev;
+                outbound.push(commitDoc(prepM));
+                contact.sentMapping = mapping;
+            }
+            say(p, `Vertrauen auf dem neuen Kopf neu ausgestellt an ${contact.name} (5.5 — ohne neue Nutzerfrage)`);
+            return { to: contact, outbound };
+        });
+    }
+    finally {
+        contact.reissuePending = false;
+    }
+}
+/**
+ * Der Producer-Sweep (Host-Vertrag): erst die V2-Pflichten, dann die
+ * 5.4-Rekonziliation je Empfänger. Idempotent, per-recipient resilient,
+ * Retries byte-identisch.
  */
 export async function starRefreshAll(p, when, ent = {}) {
     const outbound = [];
     const failures = [];
     for (const [anchor, contact] of p.contacts) {
-        if (!contact.trustGiven || contact.trustPaused)
+        if (contact.deactivated)
             continue;
         try {
-            const env = await withStarLock(contact, async () => {
-                const seq = reserveStarSeq(contact);
-                const star = await buildStarPure(p, contact, seq);
-                const whenIso = C.iso(when);
-                const body = {
-                    id: uuid(), type: TT + 'trust-star@probe',
-                    issuer: contact.channel.own.anchor, recipient: anchor,
-                    issuedAt: whenIso, payload: { star },
-                };
-                const sealed = await C.seal(await C.diSign(contact.channel.own, body, whenIso), contact.channel.counterpartKa, ent);
-                commitStar(contact, seq, star);
-                return sealed;
-            });
-            outbound.push({ to: contact, env });
+            // die V2-Pflicht läuft AUCH pausiert (Review 12, B-4) und AUCH
+            // ohne Trust-Akt (Review 33, B-1: eine ausgestellte Declaration
+            // genügt); nur die Stern-Delivery braucht trustGiven
+            if (contact.trustReissueDue) {
+                const r = await reissueTrust(p, anchor, when, ent);
+                if (r)
+                    outbound.push(...r.outbound);
+            }
+            if (!contact.trustGiven || contact.trustPaused)
+                continue;
+            const r = await reconcile(p, anchor, when, ent);
+            if (r)
+                for (const env of r.envs)
+                    outbound.push({ to: contact, kind: r.kind, env });
         }
         catch (e) {
             failures.push({ to: contact.name ?? anchor, error: String(e?.message ?? e) });
@@ -274,72 +818,416 @@ export async function starRefreshAll(p, when, ent = {}) {
     }
     return Object.assign(outbound, { failures });
 }
-// ── Empfangs-Dispatch (Form wie groups.receiveDoc) ──────────────────────
+// ── Empfang: registrierte Dokumente, Schema-validiert, atomar geackt ────
+const asmOf = (contact) => contact.asm;
 export async function receiveTrustDoc(p, env, when, ent = {}) {
-    const opened = await C.openEnvelope(p, env); // Stufen 1–4, Cache-Lesung
-    if (opened.duplicate)
-        return { handled: true, duplicate: true };
+    const opened = await C.openEnvelope(p, env);
     if (opened.error)
         return { handled: false };
-    const r = await receiveTrustDocInner(p, env, opened.doc, when, ent);
-    if (r?.handled && !r.error)
-        C.effectDone(p, opened.digest);
-    return r;
-}
-async function receiveTrustDocInner(p, env, doc, when, ent = {}) {
     const ctx = p.contexts.get(env.rkid);
-    if (!ctx)
-        return { handled: false };
-    if (typeof doc?.type !== 'string' || !doc.type.startsWith(TT + 'trust-'))
-        return { handled: false, doc };
-    // form BEFORE fields (M-3): issuer, proof and payload as used below
-    // form BEFORE fields (M-3, verschärft in Runde 3): jeder Typ verlangt
-    // SEIN Payload — star@probe ohne star ist formwidrig, nicht ein Throw
-    const kind = doc.type.slice((TT + 'trust-').length);
-    const starOk = C.shaped(doc.payload ?? {}, { star: 'object' }) && C.shaped(doc.payload.star, { salt: 'string', count: 'number', blinded: 'array' })
-        && C.intStr(doc.payload.star.salt) && Number.isInteger(doc.payload.star.count) && doc.payload.star.count >= 0
-        && doc.payload.star.count === doc.payload.star.blinded.length
-        && doc.payload.star.blinded.every((b) => typeof b === 'string');
-    const mappingOk = C.shaped(doc.payload ?? {}, { mapping: 'object' }) && C.shaped(doc.payload.mapping, { mac1: 'string', mac2: 'string', card: 'object' });
-    if (!C.shaped(doc, { issuer: 'string', proof: 'object', payload: 'object' })
-        || (kind === 'disclosure@probe' && !(mappingOk && starOk))
-        || (kind === 'star@probe' && !starOk))
-        return { handled: true, error: 'malformed' };
-    const fromEntry = [...p.contacts.entries()].find(([, c]) => c.channel?.own?.anchor === ctx.anchor);
+    const fromEntry = ctx && [...p.contacts.entries()].find(([, c]) => c.channel?.own?.anchor === ctx.anchor);
     if (!fromEntry)
-        return { handled: true, error: 'kein Kanal' };
+        return { handled: false };
     const [fromKey, from] = fromEntry;
-    if (doc.issuer !== fromKey || !(await C.diVerify(doc, doc.issuer)))
-        return { handled: true, error: 'trust doc proof' };
-    switch (doc.type.slice((TT + 'trust-').length)) {
-        case 'disclosure@probe': {
-            const m = doc.payload?.mapping;
-            if (!(await verifyMapping(p, m))) {
-                say(p, `Mapping von ${from.name} verifiziert NICHT — verworfen`);
-                return { handled: true, error: 'mapping' };
+    const doc = opened.doc;
+    if (opened.duplicate) {
+        // 4.2: innerhalb der Retention wird EXAKT der gespeicherte Ack
+        // byte-identisch erneut gesendet — nie ein neu erzeugter
+        const stored = from.ackStore?.get(opened.digest);
+        // der Store behält sein Exemplar — der Host bekommt eine Kopie (Encounter-Review 8, B-1)
+        return { handled: true, duplicate: true, ack: stored ? { to: from, kind: 'delivery-ack/0.1 (Re-Ack, byte-identisch)', env: structuredClone(stored) } : undefined };
+    }
+    // Acks laufen durch dieselbe kritische Sektion (Delivery §6.2:
+    // „stage 9 is a critical section whose lock set is the document
+    // digest … it re-enters at stage 4"): der Verlierer zweier
+    // gleichzeitiger identischer Acks sieht nach der Lock-Wartezeit den
+    // completed-effect cache und meldet duplicate-known — nie
+    // 'ack unknown ref' (Review 13, B-3)
+    if (doc?.type === ACK_TYPE) {
+        // deaktivierte Tupel nehmen keine NEUEN Acks für VISIBILITY-Dokumente
+        // an (Review 37, B-3: „not the active head … MUST be rejected") —
+        // ein Ack auf ein ENCOUNTER-Dokument bleibt gültig (Delivery 6.1:
+        // „a late valid acknowledgement … transitions the status to
+        // delivered"); die Unterscheidung fällt am referenzierten
+        // Outbox-Eintrag in receiveAckInner (Encounter-Review 2, B-5)
+        // Stufe 5 VOR dem Payload-Gate auch für Acks (Review 33, B-2), in
+        // ihrer Ordnung: erst das DOKUMENTPROFIL (malformed), dann recipient =
+        // eigener Anker (Empfänger-Prinzip) — Encounter-Review 8, B-2
+        if (!schemaOk('rltp-delivery-document.schema.json', doc))
+            return { handled: true, error: 'malformed document' };
+        if (doc.recipient !== from.channel.own.anchor)
+            return { handled: true, error: 'wrong-recipient' }; // 6.2 stage 5 disposition
+        return withContactLock(from, async () => {
+            if ((p.deliveryCache ?? new Set()).has(opened.digest))
+                return { handled: true, duplicate: true };
+            return receiveAckInner(p, fromKey, from, opened);
+        });
+    }
+    if (typeof doc?.type !== 'string' || !doc.type.startsWith(TT))
+        return { handled: false, doc };
+    const slug = doc.type.slice(TT.length);
+    if (!['anchor-mapping/0.1', 'grade-declaration/0.1', 'star/0.1'].includes(slug))
+        return { handled: false, doc };
+    // Dokumentprofil (Delivery §3): Schema-validiert, proof-frei, Bindungen
+    if (!schemaOk('rltp-delivery-document.schema.json', doc))
+        return { handled: true, error: 'malformed document' };
+    if (doc.proof !== undefined)
+        return { handled: true, error: 'document proof forbidden (one carrier)' };
+    // Stufe 5: recipient = eigener Anker (Empfänger-Prinzip). Die
+    // issuer-Bindung ist eine TYP-Konsistenzregel (Stufe 8) und läuft je
+    // Zweig NACH dem Payload-Schema (Review 32)
+    if (doc.recipient !== from.channel.own.anchor)
+        return { handled: true, error: 'wrong-recipient' }; // 6.2 stage 5 disposition
+    // Kalender-Validität des DOKUMENTS (Review 12, B-3): „a verifier
+    // MUST reject a date its RFC 3339 parser refuses" — das Dokument-
+    // Schema lief bereits; die PAYLOAD-Kalenderprüfung sitzt je Typ NACH
+    // dem Payload-Schema (Review 31: Stufe 7 vor Stufe 8)
+    if (!C.calOK(doc.issuedAt))
+        return { handled: true, error: 'calendar-invalid issuedAt' };
+    // Ack erst NACH der Payload-Validierung bauen (M-3: keine Krypto
+    // für formwidrige Fracht), aber VOR jeder Zustandsmutation
+    // (poisoning rule: ein Ack-Bau-Fehler konsumiert nichts); Effekt +
+    // Cache + ackStore committen in EINEM synchronen Zug (4.2/§6.2)
+    const mkAck = () => buildAck(p, from, opened.digest, doc.threadId, when).then((a) => a.env);
+    const commit = (result, ackEnv) => {
+        C.effectDone(p, opened.digest);
+        (from.ackStore ??= new Map()).set(opened.digest, ackEnv);
+        return { ...result, ack: { to: from, kind: 'delivery-ack/0.1', env: ackEnv } };
+    };
+    const r0 = await (async () => {
+        switch (slug) {
+            case 'anchor-mapping/0.1': {
+                return withContactLock(from, async () => {
+                    // Reentry (B-1/B-2): Kopf noch aktiv? Duplikat inzwischen? Revision noch frisch?
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' };
+                    if ((p.deliveryCache ?? new Set()).has(opened.digest)) {
+                        const stored = from.ackStore?.get(opened.digest);
+                        return { handled: true, duplicate: true, ack: stored ? { to: from, kind: 'delivery-ack/0.1 (Re-Ack, byte-identisch)', env: stored } : undefined };
+                    }
+                    const m = doc.payload;
+                    // Stufe 7 zuerst: Payload-Schema → failed(malformed) (Review 30)
+                    if (!schemaOk('visibility-anchor-mapping.schema.json', m))
+                        return { handled: true, error: 'malformed mapping' };
+                    if (doc.issuer !== fromKey)
+                        return { handled: true, error: 'outer binding (issuer, Stufe 8)' };
+                    if (!C.calOK(m.body.issuedAt))
+                        return { handled: true, error: 'calendar-invalid issuedAt' }; // Stufe 8, nach dem Schema (Review 31)
+                    if (doc.ceremony?.enactment !== undefined)
+                        return { handled: true, error: 'ceremony.enactment kann nicht nachrechnen (validation-failed)' }; // Stufe 8 — NACH dem Payload-Schema (Review 30)
+                    // §6.3 in Spec-REIHENFOLGE (Review 19, B-1), Tupel = Ankunftskanal
+                    // (Review 9, B-1: Cross-Tupel-Bindung = Schritt 3 der Liste)
+                    if (!(await verifyMapping(p, m, fromKey))) {
+                        say(p, `Mapping von ${from.name} verifiziert NICHT — verworfen`);
+                        return { handled: true, error: 'mapping' };
+                    }
+                    // 6.4, die GENERISCHE Revisionsregel (Review 11, B-2): höher
+                    // ersetzt · gleich + JCS-identischer Body = idempotenter Repeat
+                    // (No-op-Effekt, geackt — resends bleiben harmlos) · gleich +
+                    // anderer Body = Äquivokation (reject, Zustand bleibt) ·
+                    // niedriger = reject
+                    if (BigInt(m.body.revision) === BigInt(from.mapRevIn ?? '0')) {
+                        if (from.mapping && jcs(m.body) === jcs(from.mapping.body)) {
+                            const ackEnv = await mkAck();
+                            if (from.deactivated)
+                                return { handled: true, error: 'tuple deactivated' };
+                            return commit({ handled: true, idempotent: true }, ackEnv);
+                        }
+                        return { handled: true, error: 'equivocation (gleiche Revision, anderer Body)' };
+                    }
+                    if (BigInt(m.body.revision) < BigInt(from.mapRevIn ?? '0'))
+                        return { handled: true, error: 'mapping revision (niedriger)' };
+                    const ackEnv = await mkAck(); // fehlbar VOR jeder Mutation
+                    // synchroner Re-Check nach dem LETZTEN await (Review 5, B-1): eine
+                    // Kettung unter dem Lock eines ANDEREN Kontakts kann dieses Tupel
+                    // während verify/mkAck deaktiviert haben — danach kein await mehr
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' };
+                    if (BigInt(m.body.revision) <= BigInt(from.mapRevIn ?? '0'))
+                        return { handled: true, error: 'mapping revision (nicht strikt größer)' };
+                    from.mapRevIn = m.body.revision;
+                    from.selfAnchor = m.body.self;
+                    from.mapping = m;
+                    from.trustReceived = doc.issuedAt;
+                    const e = promotionCommit(p, relIdOf(p, fromKey), m.body.self, fromKey, when);
+                    e.admittedAt ??= when; // grade-wait ankert an der Admission (5.4)
+                    // eine VOR dem Mapping verifizierte Declaration steht und wirkt
+                    // bei der Admission sofort (Sektion 2 / 5.4)
+                    if (from.gradeIn && !e.grades?.has(fromKey))
+                        declCommit(p, relIdOf(p, fromKey), from.gradeIn, fromKey, from.gradeInOrder);
+                    say(p, `${from.name} vertraut dir: stabiler Anker geprüft übernommen (nur für dich beweisend)`);
+                    // der Producer-Sweep läuft NACH der Lock-Sektion (Reentranz!)
+                    return commit({ handled: true, disclosed: m.body.self, fromName: from.name, __sweep: true }, ackEnv);
+                });
+            }
+            case 'grade-declaration/0.1': {
+                return withContactLock(from, async () => {
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' };
+                    if ((p.deliveryCache ?? new Set()).has(opened.digest)) {
+                        const stored = from.ackStore?.get(opened.digest);
+                        return { handled: true, duplicate: true, ack: stored ? { to: from, kind: 'delivery-ack/0.1 (Re-Ack, byte-identisch)', env: stored } : undefined };
+                    }
+                    const g = doc.payload;
+                    if (!schemaOk('visibility-grade-declaration.schema.json', g))
+                        return { handled: true, error: 'malformed grade' };
+                    if (doc.issuer !== fromKey)
+                        return { handled: true, error: 'outer binding (issuer, Stufe 8)' };
+                    if (!C.calOK(g.body.issuedAt))
+                        return { handled: true, error: 'calendar-invalid issuedAt' }; // Stufe 8, nach dem Schema (Review 31)
+                    if (doc.ceremony?.enactment !== undefined)
+                        return { handled: true, error: 'ceremony.enactment kann nicht nachrechnen (validation-failed)' }; // Stufe 8 — NACH dem Payload-Schema (Review 30)
+                    if (g.body.subject !== fromKey || g.body.holder !== from.channel.own.anchor)
+                        return { handled: true, error: 'grade binding' };
+                    const k = await kGrade(from.channel.own, from.channel.counterpartKa, g.body.subject, g.body.holder);
+                    if ((await hmacU(k, jcs(g.body))) !== g.proof.mac)
+                        return { handled: true, error: 'grade mac' };
+                    // 6.4, die GENERISCHE Revisionsregel (Review 11, B-2):
+                    // dreiteilig — siehe Mapping-Pfad
+                    if (BigInt(g.body.revision) === BigInt(from.gradeRevIn ?? '0')) {
+                        if (from.gradeBodyIn && jcs(g.body) === from.gradeBodyIn) {
+                            const ackEnv = await mkAck();
+                            if (from.deactivated)
+                                return { handled: true, error: 'tuple deactivated' };
+                            return commit({ handled: true, idempotent: true }, ackEnv);
+                        }
+                        return { handled: true, error: 'equivocation (gleiche Revision, anderer Body)' };
+                    }
+                    if (BigInt(g.body.revision) < BigInt(from.gradeRevIn ?? '0'))
+                        return { handled: true, error: 'grade revision (niedriger)' };
+                    const ackEnv = await mkAck(); // fehlbar VOR jeder Mutation
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' }; // Re-Check (B-1), danach kein await
+                    if (BigInt(g.body.revision) <= BigInt(from.gradeRevIn ?? '0'))
+                        return { handled: true, error: 'grade revision (nicht strikt größer)' };
+                    from.gradeRevIn = g.body.revision;
+                    from.gradeBodyIn = jcs(g.body); // für den Idempotenz-Vergleich (Review 11, B-2)
+                    from.gradeIn = g.body.grade;
+                    from.gradeInOrder = (admission(p).seq += 1n); // Verifikations-Commit-Ordnung JETZT (B-2)
+                    if (from.selfAnchor)
+                        declCommit(p, relIdOf(p, fromKey), g.body.grade, fromKey, from.gradeInOrder);
+                    say(p, `${from.name} erklärt Grade '${g.body.grade}'`);
+                    return commit({ handled: true, grade: g.body.grade, __sweep: true }, ackEnv);
+                });
             }
-            from.selfAnchor = m.body.self;
-            from.mapping = m;
-            from.trustReceived = doc.issuedAt;
-            from.starReceived = doc.payload.star;
-            await refreshStarInfo(p);
-            say(p, `${from.name} vertraut dir: stabiler Anker geprüft übernommen (nur für dich beweisend)`);
-            // mein Bestand wuchs → mein lieferbarer Stern auch: auffrischen.
-            // Der INBOUND-Effekt ist hier komplett und bleibt cached;
-            // starRefreshAll ist pro Empfänger resilient — Teilergebnisse
-            // gehen nie verloren, Fehlschläge stehen benannt in failures und
-            // gehören dem HOST (Nachliefer-Vertrag, Review 5 M-1)
-            const outbound = await starRefreshAll(p, when, ent);
-            const outboundError = outbound.failures.length ? outbound.failures.map((f) => `${f.to}: ${f.error}`).join(' · ') : undefined;
-            return { handled: true, disclosed: m.body.self, fromName: from.name, outbound: [...outbound], outboundError };
+            case 'star/0.1': {
+                // Stage-9-Lockmenge in kind: konkurrierende Chunks derselben
+                // Assembly serialisieren über den Kontakt-Lock (§4.4)
+                return withStarLock(from, async () => {
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' }; // §6.4 — auch der Star-Pfad (Review 5, B-1)
+                    // Stage-4-Reentry nach Lock-Wartezeit (§6.2): ein inzwischen
+                    // verarbeitetes Duplikat erhält den gespeicherten Ack byte-identisch
+                    if ((p.deliveryCache ?? new Set()).has(opened.digest)) {
+                        const stored = from.ackStore?.get(opened.digest);
+                        return { handled: true, duplicate: true, ack: stored ? { to: from, kind: 'delivery-ack/0.1 (Re-Ack, byte-identisch)', env: stored } : undefined };
+                    }
+                    const chunk = doc.payload;
+                    if (!schemaOk('visibility-star.schema.json', chunk))
+                        return { handled: true, error: 'malformed star' };
+                    if (doc.issuer !== fromKey)
+                        return { handled: true, error: 'outer binding (issuer, Stufe 8)' };
+                    if (doc.ceremony?.enactment !== undefined)
+                        return { handled: true, error: 'ceremony.enactment kann nicht nachrechnen (validation-failed)' }; // Stufe 8 — NACH dem Payload-Schema (Review 30)
+                    const b = chunk.body;
+                    // Empfänger-Monotonie (5.2): nicht strikt größer als der
+                    // completed High-Water → verworfen
+                    if (BigInt(b.salt) <= BigInt(from.starSaltIn ?? '0'))
+                        return { handled: true, error: 'star replay (nicht strikt größer)' };
+                    // VERGIFTETER Salt (Review 21): nach einem Assembly-Konflikt
+                    // wird KEIN weiterer Chunk dieser Lieferung quittiert — sonst
+                    // kombinieren früh geackte, verlorene Pufferwirkungen mit
+                    // späteren Acks zu einer falschen Completion („the delivery
+                    // simply cannot complete until every seq is held")
+                    if (from.starPoison?.has(b.salt))
+                        return { handled: true, error: 'star salt vergiftet (assembly conflict)' };
+                    const k = await kStarIn(from, fromKey, b.salt);
+                    if ((await hmacU(k, jcs(b))) !== chunk.proof.mac)
+                        return { handled: true, error: 'star mac' };
+                    // Re-Check nach den MAC-Awaits (Review 6, B-1): ab hier wird bis
+                    // zum jeweils nächsten await NUR NOCH LOKAL entschieden — die
+                    // Assembly ist Tupel-Zustand und darf nach einer Deaktivierung
+                    // keinen Chunk mehr aufnehmen („dies, atomically, with its
+                    // tuple's deactivation")
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' };
+                    // 5.2a-Entscheidungen auf LOCALS (Review 6, B-1): höherer Salt
+                    // verdrängt, niedrigerer wird verworfen, threadId-Dissens
+                    // verwirft, Lücken puffern — GESCHRIEBEN wird erst nach Ack-Bau
+                    // und letztem Re-Check, in einem synchronen Zug
+                    const cur = asmOf(from);
+                    const displaced = cur && BigInt(b.salt) > BigInt(cur.salt);
+                    if (cur && !displaced && BigInt(b.salt) < BigInt(cur.salt))
+                        return { handled: true, error: 'below open assembly' };
+                    const a = (!cur || displaced) ? { salt: b.salt, threadId: doc.threadId, count: b.count, chunks: new Map(), lastSeq: undefined } : cur;
+                    if (doc.threadId !== a.threadId || b.count !== a.count) {
+                        from.asm = undefined;
+                        (from.starPoison ??= new Set()).add(b.salt);
+                        return { handled: true, error: 'assembly conflict (threadId/count)' };
+                    }
+                    const seq = b.seq;
+                    if (a.chunks.has(seq)) {
+                        from.asm = undefined;
+                        (from.starPoison ??= new Set()).add(b.salt);
+                        return { handled: true, error: 'assembly conflict (seq)' };
+                    }
+                    if (b.last && a.lastSeq !== undefined) {
+                        from.asm = undefined;
+                        (from.starPoison ??= new Set()).add(b.salt);
+                        return { handled: true, error: 'assembly conflict (two last)' };
+                    }
+                    const candLast = b.last ? seq : a.lastSeq;
+                    if (candLast !== undefined && BigInt(seq) > BigInt(candLast)) {
+                        from.asm = undefined;
+                        (from.starPoison ??= new Set()).add(b.salt);
+                        return { handled: true, error: 'seq beyond last' };
+                    }
+                    // auch BEREITS GEPUFFERTE Chunks oberhalb von last verwerfen die
+                    // Assembly (Review 16, B-1): „a seq greater than the held last
+                    // chunk's … reject" gilt unabhängig von der Ankunftsreihenfolge
+                    if (candLast !== undefined)
+                        for (const s of a.chunks.keys())
+                            if (BigInt(s) > BigInt(candLast)) {
+                                from.asm = undefined;
+                                (from.starPoison ??= new Set()).add(b.salt);
+                                return { handled: true, error: 'seq beyond last (gepuffert)' };
+                            }
+                    let ackEnv;
+                    const complete0 = candLast !== undefined && (() => { for (let i = 1n; i <= BigInt(candLast); i++)
+                        if (String(i) !== seq && !a.chunks.has(String(i)))
+                            return false; return true; })();
+                    if (!complete0) {
+                        ackEnv = await mkAck();
+                        if (from.deactivated)
+                            return { handled: true, error: 'tuple deactivated' }; // Re-Check (B-1), danach kein await
+                        from.asm = a; // Übernahme JETZT — synchron mit dem Puffern
+                        if (b.last)
+                            a.lastSeq = seq;
+                        a.chunks.set(seq, b);
+                        return commit({ handled: true, partial: true }, ackEnv);
+                    }
+                    // der KOMPLETTIERENDE Chunk: Union aus Puffer + aktuellem Chunk
+                    // OHNE Mutation berechnen und validieren, dann Ack + Re-Check,
+                    // dann Übernahme + completed-salt + Cache + Ack in EINEM
+                    // SYNCHRONEN Zug (§4.4); die UI-Auffrischung läuft NACH dem Commit
+                    const union = [];
+                    for (let i = 1n; i <= BigInt(candLast); i++)
+                        union.push(...(String(i) === seq ? b : a.chunks.get(String(i))).blinded);
+                    const sorted = [...union].every((x, i, arr) => i === 0 || arr[i - 1] < x);
+                    if (!sorted || BigInt(union.length) > BigInt(a.count)) {
+                        from.asm = undefined;
+                        (from.starPoison ??= new Set()).add(a.salt);
+                        return { handled: true, error: 'assembly invalid (order/|union|>count)' };
+                    }
+                    ackEnv = await mkAck(); // JETZT ist alles validiert (M-2), vor der Übernahme
+                    if (from.deactivated)
+                        return { handled: true, error: 'tuple deactivated' }; // Re-Check (B-1), danach kein await
+                    from.asm = undefined;
+                    from.starSaltIn = a.salt;
+                    from.starReceived = { salt: a.salt, count: a.count, blinded: union };
+                    if (from.starPoison)
+                        for (const ps of from.starPoison)
+                            if (BigInt(ps) <= BigInt(a.salt))
+                                from.starPoison.delete(ps); // Gift unterhalb des High-Water ist gegenstandslos
+                    const out = commit({ handled: true, star: true }, ackEnv);
+                    await refreshStarInfo(p);
+                    say(p, `Kontakt-Update von ${from.name}: ${a.count} Kontakte (geblendet: ${union.length})`);
+                    return out;
+                });
+            }
+        }
+        return { handled: false, doc };
+    })();
+    // Effekt fertig, Lock frei — jetzt der Producer-Sweep (5.4), dessen
+    // reconcile die Empfänger-Locks selbst nimmt
+    if (r0?.__sweep) {
+        delete r0.__sweep;
+        const outbound = await starRefreshAll(p, when, ent);
+        r0.outbound = [...outbound];
+        if (outbound.failures.length)
+            r0.outboundError = outbound.failures.map((f) => `${f.to}: ${f.error}`).join(' · ');
+    }
+    return r0;
+}
+// completion (5.4-Automat): jeder Chunk-Ack streicht seinen Digest;
+// der letzte lässt den Automaten laufen
+async function receiveAckInner(p, fromKey, from, opened) {
+    // der referenzierte Outbox-Eintrag zuerst — seine KLASSE wählt die
+    // Proof-Form des Acks (4.2/4.4: Encounter-Payloads tragen übertragbare
+    // Signaturen → signierter Ack; Visibility-Payloads sind DV → MAC).
+    // Digest-Gleichheit über die dekodierten Multihash-Bytes (Encounter
+    // 2.3) — ein `z`-gerenderter ref trifft den `u`-Outbox-Schlüssel
+    // Stufe 7 zuerst: das Payload-Schema (malformed) — VOR jeder Klassen-
+    // oder Konsistenzregel der Stufe 8 (Encounter-Review 16, B-1)
+    if (!schemaOk('payload-delivery-ack.schema.json', opened.doc?.payload))
+        return { handled: true, error: 'malformed' };
+    const ref0 = opened.doc.payload.ref;
+    let refKey, o;
+    for (const [k, e] of outboxOf(from))
+        if (sameDigest(k, ref0)) {
+            refKey = k;
+            o = e;
+            break;
         }
-        case 'star@probe': {
-            from.starReceived = doc.payload.star;
-            await refreshStarInfo(p);
-            say(p, `Kontakt-Update von ${from.name}: ${doc.payload.star.count} Kontakte (geblendet)`);
-            return { handled: true, star: true };
+    if (!o)
+        return { handled: true, error: 'ack unknown ref' }; // Stufe 8: ref trifft kein gesendetes Dokument — keine Klasse wählbar
+    const ENCOUNTER_KIND = o.kind === 'encounter-bundle' || o.kind === 'encounter-credential-delivery';
+    const v = await verifyAck(p, from, opened.doc, ENCOUNTER_KIND ? 'signature' : 'dv');
+    if (!v)
+        return { handled: true, error: 'ack invalid' };
+    if (o.threadId !== v.threadId)
+        return { handled: true, error: 'ack unknown ref' };
+    if (from.deactivated && !ENCOUNTER_KIND)
+        return { handled: true, error: 'tuple deactivated' }; // nach den Awaits (Review 37, B-3), danach kein await
+    // ZWEI Pflicht-Ebenen (Review 19, B-3): der Delivery-Ack erledigt den
+    // TRANSPORT — die Visibility-Pflicht eines choice/report-Mappings
+    // („resent … until answered by the counterpart's aligned mapping")
+    // lebt weiter: der Eintrag bleibt für byte-identische Resends, bis
+    // die Alignment-Antwort ihn retired. Die ALIGNMENT-Pflicht selbst
+    // stirbt mit dem Ack (completed delivery, §6a.3).
+    if (o.kind === 'continuity-mapping' && o.duty !== 'align' && !o.retired)
+        o.acked = true;
+    else
+        outboxOf(from).delete(refKey);
+    C.effectDone(p, opened.digest);
+    if (o.kind === 'star') {
+        const s = subOf(from);
+        const f = s.inFlight.get(o.salt);
+        if (f) {
+            f.pending.delete(refKey);
+            if (f.pending.size === 0) {
+                s.inFlight.delete(o.salt);
+                if (BigInt(o.salt) > s.highWater) {
+                    s.highWater = BigInt(o.salt);
+                    s.baseline = f.view;
+                }
+                // Completion räumt alle niedrigeren In-Flights (tot beim Empfänger)
+                for (const [salt2, f2] of [...s.inFlight])
+                    if (BigInt(salt2) < s.highWater) {
+                        for (const d of f2.pending.keys())
+                            outboxOf(from).delete(d);
+                        s.inFlight.delete(salt2);
+                    }
+                return { handled: true, completed: o.salt, advanced: true };
+            }
+            return { handled: true, partialAck: true };
         }
     }
-    return { handled: false, doc };
+    if (o.v2)
+        delete from.trustReissueDue; // die V2-Pflicht stirbt mit der QUITTIERTEN Zustellung
+    if (o.duty === 'align')
+        from.contAligned = true; // 6a.3: Alignment-Pflicht stirbt mit der Completion
+    // Encounter (Delivery 6.1): „delivered" ist der Sender-Status NUR auf
+    // den gültigen Ack — der Host liest diese Marken, nie die Ankunft
+    if (o.kind === 'encounter-bundle')
+        from.bundleAcked = true;
+    if (o.kind === 'encounter-credential-delivery')
+        from.counterAcked = true;
+    // the host correlates the ack with ITS active encounter (Encounter-Review 11, B-3):
+    // the acked document's digest, thread and the counterpart anchor travel along
+    return { handled: true, acked: o.kind, ref: refKey, threadId: o.threadId, peerAnchor: fromKey };
+}
+export async function receiveAck(p, env) {
+    return receiveTrustDoc(p, env, 0);
 }
 //# sourceMappingURL=trust.js.map