@real-life/trust-protocol 0.1.1 → 0.3.0

package/dist/probe/continuity.js

@@ -19,11 +19,15 @@
 // alte deaktiviert; Evidenz akkumuliert AUF DER BEZIEHUNG (✓ bleibt ✓),
 // für Dritte unsichtbar. Wer die Probe nicht beantworten kann, IST
 // protokollisch eine neue Beziehung (Identity 9.3).
-import { jcs } from '../core.js';
+import { jcs, makeValidator } from '../core.js';
+import { SCHEMAS } from '../schemas.js';
 import * as C from './deps.js';
-import { hmac } from './trust.js';
+import { hmac, hmacU, reissueTrust, chainAdmission, withContactLock, withIssueLock } from './trust.js';
+import { buildAck, ACK_TYPE } from './acks.js';
 const say = (p, m) => p.log.push(m);
 const CHUNK = 256;
+const V = makeValidator(SCHEMAS);
+const schemaOk = (file, data) => V.validate(data, SCHEMAS[file], SCHEMAS[file]).length === 0;
 // ── Schlüssel (Spec-Infostrings, richtungsgebunden) ─────────────────────
 // k_p = HKDF(ECDH(newPairX_sender, newPairX_recipient),
 //            'rltp/visibility/blind/probe/' + senderNewPair + '/' + recipientNewPair)
@@ -37,72 +41,221 @@ export const snapshotPriors = (p) => ({
     counterpart: [...p.contacts.entries()].filter(([, c]) => !c.deactivated).map(([k]) => k),
 });
 // ── continuity-probe@1: bauen ───────────────────────────────────────────
-export async function buildProbe(p, newKey, ent = {}) {
+// Sequenzvergabe SYNCHRON (BigInt-String — 18 Stellen exakt), Bau je
+// Kontakt serialisiert: zwei parallele buildProbe-Aufrufe teilen nie
+// eine Sequenz, und der Wire-Wert ist der reservierte (Review 2, B-1)
+const withContLock = withContactLock; // EIN Lock je Kontakt, geteilt mit trust (Review 4, B-1)
+export async function buildProbe(p, newKey, when, ent = {}) {
     const t = p.contacts.get(newKey);
-    if (!t?.channel?.own)
-        return null;
-    t.probeSeqOut = (t.probeSeqOut ?? 0) + 1;
-    const kp = await kProbe(t.channel.own.x.priv, t.channel.counterpartKa, t.channel.own.anchor, newKey);
-    const entries = [];
-    for (const a of t.priorCands?.own ?? [])
-        entries.push(await hmac(kp, a));
-    // Polstern auf das nächste Vielfache von 256 (leerer Bestand → 1 Voll-Polster-Chunk)
-    const total = Math.max(CHUNK, Math.ceil(entries.length / CHUNK) * CHUNK);
-    while (entries.length < total)
-        entries.push(C.b64uOf(ent.pad ?? C.rand(32)));
-    entries.sort();
-    const outbound = [];
-    for (let i = 0; i * CHUNK < entries.length; i++) {
-        const body = { type: 'continuity-probe@1', probe: String(t.probeSeqOut), seq: String(i + 1), last: (i + 1) * CHUNK >= entries.length, blinded: entries.slice(i * CHUNK, (i + 1) * CHUNK) };
-        outbound.push({ to: t, kind: 'continuity-probe@1 (geblendet, gepolstert, versiegelt)', env: await C.seal({ ...body, mac: await hmac(kp, jcs(body)) }, t.channel.counterpartKa, ent) });
-    }
-    say(p, `Kontinuitäts-Probe an ${t.name}: ${t.priorCands?.own.length ?? 0} eigene Beziehungs-Anker, geblendet + gepolstert (${entries.length})`);
-    return outbound;
+    if (!t?.channel?.own || t.deactivated)
+        return null; // deaktivierte Tupel stellen nichts aus (Review 8, B-2)
+    return withContLock(t, async () => {
+        if (t.deactivated)
+            return null; // Re-Check nach dem Lock-Erwerb
+        // Sequenz nur GEPEEKT (Review 25): „assigning … and committing are
+        // one step" — ein Bau-Fehler verbraucht nichts, auch am letzten
+        // Wert entsteht nie falsche Erschöpfung; committet wird synchron
+        // mit der Outbox (persisted atomically before send)
+        const nextProbe = BigInt(t.probeSeqOut ?? '0') + 1n;
+        if (nextProbe > 10n ** 18n - 1n)
+            throw new Error('scope exhausted — issues nothing further (2.1)');
+        const probeSeq = String(nextProbe);
+        const kp = await kProbe(t.channel.own.x.priv, t.channel.counterpartKa, t.channel.own.anchor, newKey);
+        const entries = [];
+        // §6a: prior ist „nie das frische Tupel" — Hygiene am NUTZUNGSORT:
+        // ein Host, der das Set nach der Tupel-Anlage (neu) schnappschießt,
+        // darf keine Selbst-Kette provozieren können (Selbst-Match →
+        // chainTuple(key, key) deaktivierte den eigenen Kopf)
+        for (const a of t.priorCands?.own ?? [])
+            if (a !== t.channel.own.anchor)
+                entries.push(await hmacU(kp, a));
+        // Polstern auf das nächste Vielfache von 256 (leerer Bestand → 1 Voll-Polster-Chunk);
+        // KOLLISION → Neusampling (Review 6, MAJOR: „the padding value is
+        // resampled") — ein injizierter ent.pad wird höchstens EINMAL
+        // verwendet, Duplikate fallen auf frische Zufallswerte zurück
+        const total = Math.max(CHUNK, Math.ceil(entries.length / CHUNK) * CHUNK);
+        const used = new Set(entries);
+        while (entries.length < total) {
+            let v = 'u' + C.b64uOf(ent.pad ?? C.rand(32));
+            while (used.has(v))
+                v = 'u' + C.b64uOf(C.rand(32));
+            used.add(v);
+            entries.push(v);
+        }
+        entries.sort();
+        // Bau + Seal + Digest sind FEHLBAR und warten — vorbereiten, dann
+        // Re-Check, dann Outbox-Schreibungen synchron (Review 9, B-3: ein
+        // während der Awaits deaktiviertes Tupel stellt nichts aus)
+        const preps = [];
+        const threadId = ent.threadId ?? globalThis.crypto.randomUUID();
+        for (let i = 0; i * CHUNK < entries.length; i++) {
+            const body = { type: 'continuity-probe@1', probe: probeSeq, seq: String(i + 1), last: (i + 1) * CHUNK >= entries.length, blinded: entries.slice(i * CHUNK, (i + 1) * CHUNK) };
+            const artifact = { body, proof: { mac: await hmacU(kp, jcs(body)) } };
+            const doc = { id: globalThis.crypto.randomUUID(), type: 'https://real-life.org/trust-tasks/continuity-probe/0.1', issuer: t.channel.own.anchor, recipient: newKey, threadId, issuedAt: C.iso(when), payload: artifact };
+            const env = await C.seal(doc, t.channel.counterpartKa, ent);
+            const digest = await C.digestDoc(doc);
+            preps.push({ digest, env });
+        }
+        if (t.deactivated)
+            return null; // Re-Check (B-3), danach kein await
+        // COMMIT — Sequenz + Outbox in EINEM synchronen Zug (Review 25):
+        // byte-identische Redelivery-Zuordnung fürs Ack-Matching (4.2;
+        // erneut SENDEN tut ein Retry nie, §6a)
+        t.probeSeqOut = probeSeq;
+        const outbound = [];
+        for (const { digest, env } of preps) {
+            ;
+            (t.outbox ??= new Map()).set(digest, { env, threadId, kind: 'continuity-probe' });
+            outbound.push({ to: t, kind: 'continuity-probe/0.1 (geblendet, gepolstert, versiegelt)', env });
+        }
+        say(p, `Kontinuitäts-Probe an ${t.name}: ${t.priorCands?.own.length ?? 0} eigene Beziehungs-Anker, geblendet + gepolstert (${entries.length})`);
+        return outbound;
+    });
 }
 // ── continuity-mapping@1: bauen ─────────────────────────────────────────
 // prior = EIGENER alter pair-Anker · next = eigener neuer · to = neuer der
 // Gegenseite; mac1 unter dem ALTEN Beziehungs-Schlüssel, mac2 unter dem
 // NEUEN — nur derselbe Schlüssel-Inhaber kann beide (für die Adressatin
 // fälschbar: Klasse V, abstreitbar).
-async function buildMapping(p, newKey, oldKey, when, ent = {}) {
+// PREPARE (fehlbar: MACs, Seal, Digest — mutiert nichts) und COMMIT
+// (synchron: Zähler + Outbox) getrennt (Review 12, B-2): die Record-
+// Wahl kettet ATOMAR mit der Ausgabe ihres Mappings — beide Schritte
+// liegen dann in EINEM synchronen Zug. Alle Aufrufer laufen unter dem
+// Kontakt-Lock des Tupels (Handler + Flush), der die Revisionsvergabe
+// serialisiert; buildMapping hält zusätzlich den Issue-Lock.
+async function prepareContMapping(p, newKey, oldKey, when, ent = {}, duty) {
     const t = p.contacts.get(newKey), old = p.contacts.get(oldKey);
-    const body = { type: 'continuity-mapping@1', prior: old.channel.own.anchor, next: t.channel.own.anchor, to: newKey, revision: '1', issuedAt: C.iso(when) };
+    if (t.deactivated)
+        throw new Error('tuple deactivated — issues nothing (§6.4)');
+    // 6.4/6a.4: Revision je (next, to) monoton — nur gepeekt, ein
+    // Fehlschlag verbraucht nichts (§6.4: one step per scope)
+    const nextRev = BigInt(t.contRevOut ?? '0') + 1n;
+    if (nextRev > 10n ** 18n - 1n)
+        throw new Error('scope exhausted — issues nothing further (2.1)');
+    const rev = String(nextRev);
+    const body = { type: 'continuity-mapping@1', prior: old.channel.own.anchor, next: t.channel.own.anchor, to: newKey, revision: rev, issuedAt: C.iso(when) };
     const msg = jcs(body);
-    const doc = { ...body,
-        mac1: await hmac(await kMac(old.channel.own.x.priv, old.channel.counterpartKa, 'rltp/visibility/mac/cont1'), msg),
-        mac2: await hmac(await kMac(t.channel.own.x.priv, t.channel.counterpartKa, 'rltp/visibility/mac/cont2'), msg) };
-    return { to: t, kind: 'continuity-mapping@1 (mac1 alt · mac2 neu, versiegelt)', env: await C.seal(doc, t.channel.counterpartKa, ent) };
+    const artifact = { body, proof: {
+            mac1: await hmacU(await kMac(old.channel.own.x.priv, old.channel.counterpartKa, 'rltp/visibility/mac/cont1'), msg),
+            mac2: await hmacU(await kMac(t.channel.own.x.priv, t.channel.counterpartKa, 'rltp/visibility/mac/cont2'), msg)
+        } };
+    const doc = { id: globalThis.crypto.randomUUID(), type: 'https://real-life.org/trust-tasks/continuity-mapping/0.1', issuer: t.channel.own.anchor, recipient: newKey, threadId: ent.threadId ?? globalThis.crypto.randomUUID(), issuedAt: C.iso(when), payload: artifact };
+    const env = await C.seal(doc, t.channel.counterpartKa, ent);
+    const digest = await C.digestDoc(doc);
+    return { t, rev, env, digest, threadId: doc.threadId, duty, prior: old.channel.own.anchor };
+}
+const commitContMapping = (prep) => {
+    prep.t.contRevOut = prep.rev;
+    (prep.t.outbox ??= new Map()).set(prep.digest, { env: prep.env, threadId: prep.threadId, kind: 'continuity-mapping', duty: prep.duty, prior: prep.prior });
+    return { to: prep.t, kind: 'continuity-mapping/0.1 (mac1 alt · mac2 neu, versiegelt)', env: prep.env };
+};
+async function buildMapping(p, newKey, oldKey, when, ent = {}, duty) {
+    const t = p.contacts.get(newKey);
+    return withIssueLock(t, async () => {
+        const prep = await prepareContMapping(p, newKey, oldKey, when, ent, duty);
+        if (t.deactivated)
+            throw new Error('tuple deactivated — issues nothing (§6.4)'); // Re-Check (B-2), danach kein await
+        return commitContMapping(prep);
+    });
 }
 // ── die Kette: neues Tupel wird Kopf, das alte deaktiviert ──────────────
-// Tupel-Ebene bleibt (Stern-Salts, Probe-Sequenzen); KETTEN-Ebene wandert:
-// Kontakt-Gedächtnis, Evidenz (✓ akkumuliert), Offenlegungen, Gruppen.
-function chainTuple(p, newKey, oldKey) {
+// Visibility 0.29 §6.4: PER-TUPEL-ZUSTAND WANDERT NICHT — Grade,
+// Stern-Salts, Baseline und empfangene Sterne sterben mit dem alten
+// Kopf (der neue beginnt fail-closed; das Fenster schließen 5.5s
+// Neuausstellung und das New-Head-Korollar von 5.4, nie eine
+// Migration). KETTEN-Ebene wandert: Kontakt-Gedächtnis, Evidenz
+// (✓ akkumuliert), das WISSEN um den offengelegten Anker (die
+// Admissionsschicht hängt an der Beziehung), die eigene
+// Vertrauens-ENTSCHEIDUNG (trustGiven) und die Pause.
+function chainTuple(p, newKey, oldKey, when) {
     const head = p.contacts.get(newKey), old = p.contacts.get(oldKey);
-    if (!head || !old || old.deactivated)
-        return false; // idempotent
+    if (!head || !old || head === old || old.deactivated)
+        return false; // idempotent; NIE Selbst-Kette (§6a)
     old.deactivated = true;
     old.chainedInto = newKey;
     head.chain = [...(old.chain ?? []), oldKey];
+    // Zustands-Vorrang entlang der Kette (Encounter 4.2, „evidence accumulates
+    // on the relationship through its chain"): ✓ > Zeremonie-Richtung (→/←)
+    // > Vorstellung (⇄). Eine einseitige Zeremonie ist stärker als eine
+    // Vorstellung — der Kopf verliert seine Richtung nicht an ein ⇄
     if (old.state === '✓' || head.state === '✓') {
         head.state = '✓';
         head.provenance = 'ceremony';
     }
+    else if (head.state === '→' || head.state === '←') { /* die Richtung des Kopfes bleibt */ }
+    else if (old.state === '→' || old.state === '←') {
+        head.state = old.state;
+        head.provenance = 'ceremony';
+    }
     else if (old.state === '⇄' || head.state === '⇄')
         head.state = '⇄';
     head.since = [old.since, head.since].filter(Boolean).sort()[0];
     head.name = old.name; // lokales Kontakt-Gedächtnis
-    head.selfAnchor ??= old.selfAnchor;
-    head.mapping ??= old.mapping;
-    head.trustGiven ??= old.trustGiven;
-    head.trustReceived ??= old.trustReceived;
-    head.trustPaused ??= old.trustPaused;
-    head.sentMapping ??= old.sentMapping;
-    head.starReceived ??= old.starReceived;
-    head.starInfo ??= old.starInfo;
+    head.selfAnchor ??= old.selfAnchor; // Ketten-WISSEN: wer das ist (das Mapping selbst stirbt mit dem Tupel, §6.4)
+    const oldRel = old.relId ?? oldKey;
+    // Admission (B-4): der neue Kopf löst über die überlebende Beziehung
+    // auf; ein schon existierender Eintrag der frischen Beziehung
+    // verschmilzt atomar (früheste Position, Aliase, k−1). Die
+    // IDENTITÄT ist die des TATSÄCHLICH überlebenden Eintrags (Review
+    // 36: „the merged relationship's identity is the surviving
+    // entry's") — existiert nur der frische, bleibt DESSEN Identität;
+    // existiert keiner, die des jüngsten Kopfs (Review 4, B-4)
+    const survivor = chainAdmission(p, oldRel, newKey, newKey, when);
+    // Ketten-Identität = die des Survivors NUR, wenn sie zu DIESER Kette
+    // gehört (Review 36 + 37, B-1): die kanonische Identität eines
+    // Weg-2-Merges gehört einer ANDEREN, weiterhin aktiven Beziehung —
+    // Admission-Identität und Beziehungsstrang bleiben unterscheidbar,
+    // der Abgang dieser Kette darf die andere nie mitreißen
+    const sid = survivor?.id;
+    const sidInChain = sid !== undefined && (sid === oldRel || sid === newKey || (p.contacts.get(sid)?.relId ?? null) === oldRel);
+    head.relId = sidInChain ? sid : (survivor ? oldRel : newKey);
+    // die GANZE Kette identifiziert sich als DIESE Beziehung — auch der
+    // alte Kopf (Review 36: der Abgang räumt sämtliche Ketten-Aliase)
+    old.relId = head.relId;
+    head.trustGiven ??= old.trustGiven; // die Entscheidung gehört der Beziehung (V2)
+    // 5.5: „MUST re-issue its most recently ISSUED grade" — der
+    // Ordnungsstempel entscheidet, nie der zufällig frischere Kopf
+    // (Review 27: setGrade auf dem alten Kopf NACH dem Trust-Akt des
+    // frischen muss die Kettung überleben)
+    if (old.gradeOutLast !== undefined && (head.gradeOutLast === undefined || (old.gradeOutOrder ?? 0n) > (head.gradeOutOrder ?? 0n))) {
+        head.gradeOutLast = old.gradeOutLast;
+        head.gradeOutOrder = old.gradeOutOrder;
+    }
+    // Pause ist chain-level und ÜBERLEBT die Kettung (Review 37, B-2):
+    // der Zustand der Beziehung, auf die gekettet wird, gewinnt gegen
+    // Vor-Kettungs-Akte des frischen Tupels
+    head.trustPaused = old.trustPaused ?? head.trustPaused;
     head.sharedGroups = [...new Set([...(old.sharedGroups ?? []), ...(head.sharedGroups ?? [])])];
+    // NICHT migriert (per Tupel, stirbt mit dem alten Kopf):
+    // trustReceived, starReceived, starInfo, starSaltIn, sentMapping,
+    // sub (Baseline/inFlight), starSeqNext. Die 5.5-Neuausstellung ist
+    // die stehende Pflicht des neuen Kopfs; ihr Producer ist
+    // trust.reissueTrust via starRefreshAll.
+    // die Pflicht entsteht, wenn eine DECLARATION ausgestellt war (5.5:
+    // „a subject holding an issued declaration … MUST re-issue") — auch
+    // ohne Trust-Akt (eigenständiges setGrade); Review 33, B-1
+    if (head.trustGiven || head.gradeOutLast !== undefined)
+        head.trustReissueDue = true;
     say(p, `Kontinuität: ${head.name} wiedererkannt — neues Tupel an die Beziehung gekettet (${head.state}, ${head.chain.length + 1} Enactments)`);
     return true;
 }
+// V2-Hook (5.5): direkt nach der Kettung wird die Neuausstellung
+// versucht; ein Bau-Fehler lässt die Pflicht (trustReissueDue) stehen —
+// ihr Producer ist starRefreshAll, nie eine Wiederzustellung.
+async function v2Reissue(p, newKey, when, ent, outbound) {
+    const t = p.contacts.get(newKey);
+    if (!t?.trustReissueDue)
+        return undefined;
+    try {
+        const r = await reissueTrust(p, newKey, when, ent);
+        if (r)
+            outbound.push(...r.outbound);
+        return undefined;
+    }
+    catch (e) {
+        return String(e?.message ?? e);
+    }
+}
 // ── Empfangs-Dispatch ───────────────────────────────────────────────────
 const iAmRecord = (t, newKey) => t.channel.own.anchor < newKey; // lexikographisch kleinerer NEUER Anker
 const tupleOf = (p, rkid) => {
@@ -112,93 +265,252 @@ const tupleOf = (p, rkid) => {
     const e = [...p.contacts.entries()].find(([, c]) => c.channel?.own?.anchor === ctx.anchor);
     return e ? { key: e[0], t: e[1], ctx } : null;
 };
+const TT_PROBE = 'https://real-life.org/trust-tasks/continuity-probe/0.1';
+const TT_MAP = 'https://real-life.org/trust-tasks/continuity-mapping/0.1';
 export async function receiveContinuity(p, env, when, ent = {}) {
     const opened = await C.openEnvelope(p, env); // Stufen 1–4, Cache-Lesung
-    if (opened.duplicate)
-        return { handled: true, duplicate: true };
     if (opened.error)
         return { handled: false };
-    const r = await receiveContinuityInner(p, env, opened.doc, when, ent);
-    if (r?.handled && !r.error)
-        C.effectDone(p, opened.digest);
-    return r;
-}
-async function receiveContinuityInner(p, env, doc, when, ent = {}) {
     const hit = tupleOf(p, env.rkid);
     if (!hit)
         return { handled: false };
-    if (doc?.type === 'continuity-probe@1')
-        return handleProbe(p, hit, doc, when, ent);
-    if (doc?.type === 'continuity-mapping@1')
-        return handleMapping(p, hit, doc, when, ent);
-    return { handled: false, doc };
+    if (opened.duplicate) {
+        // 4.2: byte-identischer Re-Ack innerhalb der Retention
+        const stored = hit.t.ackStore?.get(opened.digest);
+        return { handled: true, duplicate: true, ack: stored ? { to: hit.t, kind: 'delivery-ack/0.1 (Re-Ack, byte-identisch)', env: stored } : undefined };
+    }
+    const doc = opened.doc;
+    if (doc?.type !== TT_PROBE && doc?.type !== TT_MAP)
+        return { handled: false, doc };
+    // Dokumentprofil (Delivery §3) + Artefakt-Schema (Stufen 5/7)
+    if (!schemaOk('rltp-delivery-document.schema.json', doc) || doc.proof !== undefined)
+        return { handled: true, error: 'malformed document' };
+    // Stufe 5: recipient; die issuer-Bindung (Stufe 8) läuft NACH den
+    // Payload-Schemata (Review 32)
+    if (doc.recipient !== hit.t.channel.own.anchor)
+        return { handled: true, error: 'outer binding (recipient)' };
+    // Kalender-Validität des DOKUMENTS (Review 12, B-3); die PAYLOAD-
+    // Kalenderprüfung sitzt NACH dem Artefakt-Schema (Review 31)
+    if (!C.calOK(doc.issuedAt))
+        return { handled: true, error: 'calendar-invalid issuedAt' };
+    if (doc.type === TT_PROBE && !schemaOk('visibility-continuity-probe.schema.json', doc.payload))
+        return { handled: true, error: 'malformed probe' };
+    if (doc.type === TT_MAP && !schemaOk('visibility-continuity-mapping.schema.json', doc.payload))
+        return { handled: true, error: 'malformed mapping' };
+    if (doc.type === TT_MAP && !C.calOK(doc.payload?.body?.issuedAt))
+        return { handled: true, error: 'calendar-invalid issuedAt' }; // Stufe 8, nach dem Schema (Review 31)
+    if (doc.issuer !== hit.key)
+        return { handled: true, error: 'outer binding (issuer, Stufe 8)' };
+    // Profil-Regel (Review 29/30): Stufe 8 NACH dem Payload-Schema —
+    // ein präsentes ceremony.enactment kann bei diesen Payloads nie
+    // nachrechnen (kein umschlossenes Bindungsmaterial) →
+    // failed(validation-failed); andere Framework-Member passieren (§4.11.1)
+    if (doc.ceremony?.enactment !== undefined)
+        return { handled: true, error: 'ceremony.enactment kann nicht nachrechnen (validation-failed)' };
+    // GESAMTER Empfang unter dem Kontakt-Lock (B-1: kein Rollback durch
+    // parallele Handler); der Ack entsteht IN den Handlern nach der
+    // vollen Validierung (M-2), Commit hier atomar mit Cache+Store
+    return withContLock(hit.t, async () => {
+        // §6.4: ein deaktiviertes Tupel nimmt nichts mehr an (Review 5, B-1)
+        if (hit.t.deactivated)
+            return { handled: true, error: 'tuple deactivated' };
+        // Stage-4-Reentry nach Lock-Wartezeit: ein inzwischen verarbeitetes
+        // Duplikat erhält den gespeicherten Ack byte-identisch
+        if ((p.deliveryCache ?? new Set()).has(opened.digest)) {
+            const stored = hit.t.ackStore?.get(opened.digest);
+            return { handled: true, duplicate: true, ack: stored ? { to: hit.t, kind: 'delivery-ack/0.1 (Re-Ack, byte-identisch)', env: stored } : undefined };
+        }
+        const mkAck = () => buildAck(p, hit.t, opened.digest, doc.threadId, when).then((a) => a.env);
+        // Effekt + completed-effect cache + gespeicherter Ack committen in
+        // EINEM synchronen Zug IM Handler (Review 6, B-5: „inside the
+        // effect's transaction") — die Outbound-PRODUKTION (buildMapping,
+        // V2) läuft danach; ihr Scheitern hinterlässt eine Pflicht, nie
+        // einen halben Empfangs-Commit
+        const commitAck = (ackEnv) => {
+            C.effectDone(p, opened.digest);
+            (hit.t.ackStore ??= new Map()).set(opened.digest, ackEnv);
+            return { to: hit.t, kind: 'delivery-ack/0.1', env: ackEnv };
+        };
+        return doc.type === TT_PROBE
+            ? handleProbe(p, hit, doc.payload, doc.threadId, when, ent, mkAck, commitAck)
+            : handleMapping(p, hit, doc.payload, when, ent, mkAck, commitAck);
+    });
 }
-async function handleProbe(p, { key, t }, doc, when, ent) {
-    // form BEFORE fields (M-3): mac, sequence and chunk list as used below
-    if (!C.shaped(doc, { mac: 'string', probe: 'string', seq: 'string', blinded: 'array' }) || typeof doc.last !== 'boolean'
-        || !C.intStr(doc.probe) || !C.intStr(doc.seq) // NaN in probeSeqIn wäre Replay-Zustandskorruption (Review 9, P-B1)
-        || doc.blinded.length !== 256 // die Chunkform ist FEST: genau 256 Einträge (Review 10, P-B1-Rest)
-        || !doc.blinded.every((b) => typeof b === 'string'))
+async function handleProbe(p, { key, t }, artifact, threadId, when, ent, mkAck, commitAck) {
+    // Schema lief im Dispatch; hier die wertgebundenen Reste (M-3)
+    const doc = artifact.body;
+    if (!C.intStr(doc.probe) || !C.intStr(doc.seq) // NaN in probeSeqIn wäre Replay-Zustandskorruption (Review 9, P-B1)
+        || doc.blinded.length !== 256) // die Chunkform ist FEST: genau 256 Einträge (Review 10, P-B1-Rest)
         return { handled: true, error: 'malformed probe' };
     // Senderseitiger k_p, aus Empfängersicht nachgerechnet (Richtung!)
     const kp = await kProbe(t.channel.own.x.priv, t.channel.counterpartKa, key, t.channel.own.anchor);
-    const { mac, ...body } = doc;
-    if ((await hmac(kp, jcs(body))) !== mac)
+    if ((await hmacU(kp, jcs(doc))) !== artifact.proof.mac)
         return { handled: true, error: 'probe mac' };
     if (BigInt(doc.probe) <= BigInt(t.probeSeqIn ?? '0'))
         return { handled: true, error: 'probe replay (nicht streng größer)' };
-    // Chunk-Sammlung pro (Tupel, probe); höhere probe verwirft die offene
-    if (t.probeAsm?.probe !== doc.probe)
-        t.probeAsm = { probe: doc.probe, blinded: [], next: 1 };
-    if (Number(doc.seq) !== t.probeAsm.next)
-        return { handled: true, error: 'malformed probe (chunk order)' };
-    t.probeAsm.next += 1;
-    t.probeAsm.blinded.push(...doc.blinded);
-    if (!doc.last)
-        return { handled: true, partial: true };
-    // finaler Chunk: union lesen, dann vollzieht sich der EFFEKT (consume
-    // + Wahl + Kette) VOR dem fehlbaren Mapping-Bau — bewusst, denn die
-    // Frische-Regel verbietet Chunk-Replays als Retry-Weg; ein Bau-Fehler
-    // wird als getypte Pflicht persistiert und über flushContinuity()
-    // eingelöst (Reviews 5–8)
-    const union = t.probeAsm.blinded;
-    const consume = () => { t.probeAsm = null; t.probeSeqIn = doc.probe; }; // als STRING — BigInt-Vergleich, 18 Stellen exakt
+    // VERGIFTETE Probe (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 (§6a.2 übernimmt die
+    // 5.2a-Konfliktregeln in kind)
+    if (t.probePoison?.has(doc.probe))
+        return { handled: true, error: 'probe vergiftet (assembly conflict)' };
+    // Re-Check nach den MAC-Awaits (Review 6, B-1): die Assembly ist
+    // Tupel-Zustand und nimmt nach einer Deaktivierung nichts mehr auf
+    if (t.deactivated)
+        return { handled: true, error: 'tuple deactivated' };
+    // Chunk-Sammlung pro (Tupel, probe): LÜCKEN PUFFERN (Ankunftsreihen-
+    // folge irrelevant, 5.2a in kind), nur eine STRIKT HÖHERE probe
+    // verdrängt die offene, eine niedrigere wird verworfen; threadId-
+    // Dissens verwirft; seq-Konflikt (andere Bytes) verwirft (byte-
+    // identische Wiederholung fängt duplicate-known auf Envelope-Ebene).
+    // Entscheidungen auf LOCALS (Review 6, B-1) — GESCHRIEBEN wird erst
+    // nach Ack-Bau und letztem Re-Check, synchron mit dem Commit
+    const cur = t.probeAsm;
+    const displaced = cur && BigInt(doc.probe) > BigInt(cur.probe);
+    if (cur && !displaced && BigInt(doc.probe) < BigInt(cur.probe))
+        return { handled: true, error: 'below open probe assembly' };
+    const a = (!cur || displaced) ? { probe: doc.probe, threadId, chunks: new Map(), lastSeq: undefined } : cur;
+    if (threadId !== a.threadId) {
+        t.probeAsm = null;
+        (t.probePoison ??= new Set()).add(doc.probe);
+        return { handled: true, error: 'probe assembly conflict (threadId)' };
+    }
+    const seq = BigInt(doc.seq);
+    if (a.chunks.has(doc.seq)) {
+        t.probeAsm = null;
+        (t.probePoison ??= new Set()).add(doc.probe);
+        return { handled: true, error: 'probe assembly conflict (seq)' };
+    }
+    if (doc.last && a.lastSeq !== undefined) {
+        t.probeAsm = null;
+        (t.probePoison ??= new Set()).add(doc.probe);
+        return { handled: true, error: 'probe assembly conflict (two last)' };
+    }
+    const candLast = doc.last ? doc.seq : a.lastSeq;
+    if (candLast !== undefined && seq > BigInt(candLast)) {
+        t.probeAsm = null;
+        (t.probePoison ??= new Set()).add(doc.probe);
+        return { handled: true, error: 'seq beyond last' };
+    }
+    // auch BEREITS GEPUFFERTE Chunks oberhalb von last verwerfen die
+    // Assembly (Review 16, B-1 — 5.2a in kind, Ankunftsreihenfolge egal)
+    if (candLast !== undefined)
+        for (const s of a.chunks.keys())
+            if (BigInt(s) > BigInt(candLast)) {
+                t.probeAsm = null;
+                (t.probePoison ??= new Set()).add(doc.probe);
+                return { handled: true, error: 'seq beyond last (gepuffert)' };
+            }
+    // Komplettierung VOR dem Puffern vorhersagen (Review 5, B-4 — die
+    // Star-Struktur gespiegelt): jeder NICHT-komplettierende Chunk (auch
+    // ein früh eintreffender last:true) wird nach den Per-Chunk-Gates
+    // quittiert und gepuffert; NUR der KOMPLETTIERENDE wartet auf die
+    // Union-Validierung (M-2) — Ankunftsreihenfolge ist irrelevant (5.2a)
+    const complete = candLast !== undefined && (() => {
+        for (let i = 1n; i <= BigInt(candLast); i++)
+            if (String(i) !== doc.seq && !a.chunks.has(String(i)))
+                return false;
+        return true;
+    })();
+    if (!complete) {
+        const __ackEnv = await mkAck();
+        if (t.deactivated)
+            return { handled: true, error: 'tuple deactivated' }; // Re-Check (B-1), danach kein await
+        t.probeAsm = a; // Übernahme JETZT — synchron mit Puffern + Commit (B-5)
+        if (doc.last)
+            a.lastSeq = doc.seq;
+        a.chunks.set(doc.seq, doc.blinded);
+        return { handled: true, partial: true, ack: commitAck(__ackEnv) };
+    }
+    // Union aus Puffer + aktuellem Chunk OHNE Mutation; globale
+    // Sortierung + Duplikatfreiheit (§6a.2)
+    const union = [];
+    for (let i = 1n; i <= BigInt(candLast); i++)
+        union.push(...(String(i) === doc.seq ? doc.blinded : a.chunks.get(String(i))));
+    if (!union.every((x, i, arr) => i === 0 || arr[i - 1] < x)) {
+        t.probeAsm = null;
+        (t.probePoison ??= new Set()).add(doc.probe);
+        return { handled: true, error: 'probe assembly invalid (order/duplicates)' };
+    }
     // Schnitt gegen die GEGENSEITEN-Anker des eigenen Prior-Candidate-Sets
+    // — reine Rechnung, VOR dem Ack-Bau, damit zwischen Re-Check und
+    // Übernahme kein await mehr liegt (Review 5, B-1)
     const matches = [];
     for (const cp of t.priorCands?.counterpart ?? []) {
-        if (union.includes(await hmac(kp, cp)))
+        if (cp === key)
+            continue; // §6a: das frische Tupel selbst ist NIE ein prior (Selbst-Ketten-Schutz)
+        if (union.includes(await hmacU(kp, cp)))
             matches.push(cp);
     }
+    const __ackEnv = await mkAck(); // JETZT ist alles validiert (M-2)
+    if (t.deactivated)
+        return { handled: true, error: 'tuple deactivated' }; // Re-Check (B-1), danach kein await bis zum Commit
+    // Übernahme + Cache + Ack in EINEM synchronen Zug (B-5); die
+    // Kettenwahl mutiert ebenfalls synchron — erst DANACH die fehlbare
+    // Outbound-Produktion (ihr Scheitern hinterlässt eine Pflicht)
+    t.probeAsm = null;
+    if (BigInt(doc.probe) > BigInt(t.probeSeqIn ?? '0'))
+        t.probeSeqIn = doc.probe; // monoton (B-1)
+    if (t.probePoison)
+        for (const ps of t.probePoison)
+            if (BigInt(ps) <= BigInt(t.probeSeqIn))
+                t.probePoison.delete(ps); // Gift unterhalb des High-Water ist gegenstandslos
+    const ack = commitAck(__ackEnv);
     if (!matches.length) {
-        consume();
         say(p, `Probe von ${t.name}: kein Match — ehrlich eine neue Beziehung`);
-        return { handled: true, matches: 0 };
+        return { handled: true, matches: 0, ack };
     }
     const outbound = [];
     let chained = false;
     let outboundError;
     if (iAmRecord(t, key)) {
-        // Record-Seite: einmal wählen, endgültig; Kette atomar mit der Wahl
+        // Record-Seite: einmal wählen, endgültig — „the record side chains
+        // atomically with issuing its choice" (Review 12, B-2): erst das
+        // Wahl-Mapping FEHLBAR vorbereiten, dann Wahl + Kette + Ausgabe in
+        // EINEM synchronen Zug; scheitert die Vorbereitung, wird NICHT
+        // gekettet und die volle Wahl-Pflicht bleibt stehen (Flush holt sie
+        // atomar nach)
         if (!t.contChosen) {
-            const choice = matches[0]; // Wahl frei — hier: erster Match (reichste Historie wäre App-Sache)
-            consume();
-            t.contChosen = choice;
-            chained = chainTuple(p, key, choice);
-            try {
-                outbound.push(await buildMapping(p, key, choice, when, ent));
-            }
-            catch (err) {
-                t.contMappingDue = { prior: choice, kind: 'choice' };
-                outboundError = String(err?.message ?? err);
+            // Wahl frei — hier: der erste LEBENDE, KETTBARE Match (Review 19,
+            // B-4: ein von einem konkurrierenden Tupel verbrauchter erster
+            // Match blockiert die weiteren gültigen nicht; reichste Historie
+            // wäre App-Sache). Kette ZUERST (Review 13, B-1): „chains
+            // atomically with issuing its choice" heißt beides oder keins.
+            for (const choice of matches) {
+                if (p.contacts.get(choice)?.deactivated)
+                    continue; // toter prior → nächster Match
+                let prep;
+                try {
+                    prep = await prepareContMapping(p, key, choice, when, ent);
+                }
+                catch (err) {
+                    // die Pflicht trägt ALLE Matches (Review 20, B-3): wird der
+                    // erste vor dem Flush unkettbar, versucht der Flush die
+                    // übrigen lebenden Kandidaten
+                    t.contMappingDue = { prior: choice, kind: 'choice', alts: matches.filter((x) => x !== choice) };
+                    outboundError = String(err?.message ?? err);
+                    break;
+                }
+                if (t.deactivated || t.contChosen)
+                    break;
+                chained = chainTuple(p, key, choice, when);
+                if (!chained)
+                    continue; // Rennen verloren → nächster lebender Match
+                t.contChosen = choice;
+                if (t.contMappingDue?.kind === 'choice')
+                    delete t.contMappingDue; // die alte Bau-Pflicht ist ERFÜLLT (Review 14, B-2)
+                outbound.push(commitContMapping(prep));
+                const v2Err = await v2Reissue(p, key, when, ent, outbound);
+                if (v2Err)
+                    outboundError = outboundError ? outboundError + ' · ' + v2Err : v2Err;
+                break;
             }
         }
-        else
-            consume();
     }
     else {
         // Nicht-Record: Match-Report (löst NIE eine Kette aus)
         if (!t.contReported) {
-            consume();
             t.contReported = matches[0];
             try {
                 outbound.push(await buildMapping(p, key, matches[0], when, ent));
@@ -208,65 +520,167 @@ async function handleProbe(p, { key, t }, doc, when, ent) {
                 outboundError = String(err?.message ?? err);
             }
         }
-        else
-            consume();
     }
-    return { handled: true, matches: matches.length, chained, name: chained ? t.name : undefined, outbound, outboundError };
+    return { handled: true, matches: matches.length, chained, name: chained ? t.name : undefined, outbound, outboundError, ack };
 }
-async function handleMapping(p, { key, t }, doc, when, ent) {
-    if (!C.shaped(doc, { mac1: 'string', mac2: 'string', prior: 'string', next: 'string', to: 'string' }))
+async function handleMapping(p, { key, t }, artifact, when, ent, mkAck, commitAck) {
+    if (!C.shaped(artifact ?? {}, { body: 'object', proof: 'object' })
+        || !C.shaped(artifact.body, { prior: 'string', next: 'string', to: 'string' })
+        || typeof artifact.proof.mac1 !== 'string' || typeof artifact.proof.mac2 !== 'string')
         return { handled: true, error: 'malformed mapping' };
-    const { mac1, mac2, ...body } = doc;
+    const body = artifact.body;
+    const { mac1, mac2 } = artifact.proof;
     const fail = (why) => { say(p, `Kontinuitäts-Mapping verworfen: ${why}`); return { handled: true, error: why }; };
     if (body.to !== t.channel.own.anchor)
         return fail('to ≠ eigener neuer Anker');
     if (body.next !== key)
         return fail('next ≠ neuer Anker der Gegenseite');
     // prior MUSS im Schnappschuss liegen (nie das frische Tupel, nie tiefere Kettenglieder)
+    if (body.prior === key)
+        return fail('prior = frisches Tupel (§6a)'); // Selbst-Ketten-Schutz, auch bei vergiftetem Schnappschuss
     if (!(t.priorCands?.counterpart ?? []).includes(body.prior))
         return fail('prior nicht im Prior-Candidate-Set');
     const old = p.contacts.get(body.prior);
     if (!old?.channel?.own)
         return fail('alte Beziehung ohne eigenen Kontext');
     const msg = jcs(body);
-    if ((await hmac(await kMac(old.channel.own.x.priv, old.channel.counterpartKa, 'rltp/visibility/mac/cont1'), msg)) !== mac1)
+    if ((await hmacU(await kMac(old.channel.own.x.priv, old.channel.counterpartKa, 'rltp/visibility/mac/cont1'), msg)) !== mac1)
         return fail('mac1 (alter Beziehungs-Schlüssel)');
-    if ((await hmac(await kMac(t.channel.own.x.priv, t.channel.counterpartKa, 'rltp/visibility/mac/cont2'), msg)) !== mac2)
+    if ((await hmacU(await kMac(t.channel.own.x.priv, t.channel.counterpartKa, 'rltp/visibility/mac/cont2'), msg)) !== mac2)
         return fail('mac2 (neuer Beziehungs-Schlüssel)');
+    // 6.4, die GENERISCHE Revisionsregel im (next, to)-Scope (Review 11,
+    // B-2): höher ersetzt · gleich + JCS-identischer Body = idempotenter
+    // Repeat (No-op, geackt) · gleich + anderer Body = Äquivokation ·
+    // niedriger = reject. Der Revisionsstand rückt erst NACH allen
+    // Ablehnungsgründen vor (Record-Freeze gilt whatever its revision)
+    if (BigInt(body.revision) === BigInt(t.contRevIn ?? '0')) {
+        if (t.contBodyIn && msg === t.contBodyIn) {
+            const __ackEnv = await mkAck();
+            if (t.deactivated)
+                return fail('tuple deactivated');
+            return { handled: true, idempotent: true, ack: commitAck(__ackEnv) };
+        }
+        return fail('Äquivokation — gleiche Revision, anderer Body');
+    }
+    if (BigInt(body.revision) < BigInt(t.contRevIn ?? '0'))
+        return fail('mapping revision (niedriger)');
     const senderIsRecord = key < t.channel.own.anchor;
+    // Record-Freeze VOR Ack und Revisionsstand (B-3): ein verworfenes
+    // Dokument konsumiert weder Revision noch Krypto
+    if (senderIsRecord && t.contRecordPrior && t.contRecordPrior !== body.prior)
+        return fail('Äquivokation — Record-Wahl ist eingefroren');
+    // §6a.4/6.4: „On verification of a record-side mapping, chain" —
+    // wurde der genannte alte Kopf von einem KONKURRIERENDEN Tupel
+    // gekettet, ist die Kette hier nicht möglich: ablehnen statt
+    // Freeze + Ack + Alignment ohne Kette (Review 14, B-3). ABER: „a
+    // head deactivated by THIS VERY chaining remains a valid prior for
+    // this tuple" (Review 15) — eine höhere Revision derselben
+    // eingefrorenen Wahl wird per 6.4 normal verarbeitet
+    const priorTaken = () => old.deactivated && old.chainedInto !== key;
+    if (senderIsRecord && priorTaken())
+        return fail('prior von konkurrierendem Tupel gekettet (§6.4) — nicht kettbar');
+    const __ackEnv = await mkAck(); // alle Gates bestanden — VOR der Mutation
+    if (t.deactivated)
+        return fail('tuple deactivated'); // Re-Check (B-1), danach kein await bis zum Commit
+    if (senderIsRecord && priorTaken())
+        return fail('prior von konkurrierendem Tupel gekettet (§6.4) — nicht kettbar'); // Re-Check (B-3)
+    // Effekt (Revision, Freeze, Kette) + Cache + Ack in EINEM synchronen
+    // Zug (Review 6, B-5/B-1); die fehlbare Outbound-Produktion läuft
+    // DANACH — ihr Scheitern hinterlässt die Pflicht (contMappingDue),
+    // nie einen halben Commit
+    t.contRevIn = body.revision;
+    t.contBodyIn = msg; // für den Idempotenz-Vergleich (Review 11, B-2)
     const outbound = [];
+    let chainedNow = false; // das ECHTE Kettenergebnis (Review 14, B-3), nie eine Ableitung
+    const done = (extra = {}) => ({ handled: true, chained: chainedNow, name: t.name, outbound, ack, ...extra });
+    let ack;
     if (senderIsRecord) {
-        // Record-Freeze: abweichendes prior derselben (next,to) = Äquivokation
-        if (t.contRecordPrior && t.contRecordPrior !== body.prior)
-            return fail('Äquivokation — Record-Wahl ist eingefroren');
-        // fehlbare Arbeit VOR der Mutation (B-2): erst das Alignment-Mapping
-        // bauen, dann Freeze + Kette in einem synchronen Zug
         t.contRecordPrior = body.prior;
-        chainTuple(p, key, body.prior);
+        // nach den Re-Checks garantiert kettbar ODER schon in GENAU dieses
+        // Tupel gekettet (Re-Verifikation derselben Wahl, Review 15)
+        chainedNow = chainTuple(p, key, body.prior, when) || old.chainedInto === key;
+        // „the non-record side's match-report duty … dies on verifying the
+        // record side's mapping on that tuple" (Review 11, B-3): der alte
+        // Match-Report wird retired — nie mehr gesendet (stale
+        // counter-claim MUST NOT be sent), sein Ack-Ref bleibt erhalten
+        for (const o of (t.outbox ?? new Map()).values())
+            if (o.kind === 'continuity-mapping' && o.duty !== 'align')
+                o.retired = true;
+        if (t.contMappingDue?.kind === 'report')
+            delete t.contMappingDue;
+        ack = commitAck(__ackEnv);
         if (!t.contAligned) {
-            try {
-                const mapping = await buildMapping(p, key, body.prior, when, ent);
-                t.contAligned = true;
-                if (t.contMappingDue?.prior === body.prior)
-                    delete t.contMappingDue;
-                outbound.push(mapping);
-            }
-            catch (err) {
-                t.contMappingDue = { prior: body.prior, kind: 'align' };
-                return { handled: true, chained: p.contacts.get(body.prior)?.deactivated === true, name: t.name, outbound, outboundError: String(err?.message ?? err) };
+            // ein noch UNQUITTIERTES Alignment wird byte-identisch erneut
+            // gesendet (Review 16, B-2: „is resent — same revision,
+            // idempotent by 6.4") — eine höhere Record-Revision derselben
+            // Wahl prägt NIE eine zweite Alignment-Revision für dieselbe
+            // offene Pflicht
+            const pending = [...(t.outbox ?? new Map()).values()].find((o) => o.kind === 'continuity-mapping' && o.duty === 'align' && !o.retired);
+            if (pending)
+                outbound.push({ to: t, kind: 'continuity-mapping/0.1 (Retry, byte-identisch)', env: pending.env });
+            else {
+                // Produktion registriert in der Outbox; die Pflicht stirbt erst
+                // mit dem QUITTIERTEN Dokument (Ack-Pfad setzt contAligned)
+                try {
+                    outbound.push(await buildMapping(p, key, body.prior, when, ent, 'align'));
+                    if (t.contMappingDue?.prior === body.prior)
+                        delete t.contMappingDue;
+                }
+                catch (err) {
+                    t.contMappingDue = { prior: body.prior, kind: 'align' };
+                    return done({ outboundError: String(err?.message ?? err) });
+                }
             }
         }
+        const v2Err = await v2Reissue(p, key, when, ent, outbound);
+        if (v2Err)
+            return done({ outboundError: v2Err });
     }
     else {
-        // Match-Report der Nicht-Record-Seite: darf die Wahl INFORMIEREN, kettet nie
+        // Match-Report der Nicht-Record-Seite: darf die Wahl INFORMIEREN,
+        // kettet nie selbst. Die Record-Wahl darauf kettet ATOMAR mit der
+        // Ausgabe ihres Mappings (Review 12, B-2): erst vorbereiten, dann
+        // Wahl + Kette + Ausgabe synchron; Fehlschlag → volle Wahl-Pflicht
         if (iAmRecord(t, key) && !t.contChosen) {
-            const mapping = await buildMapping(p, key, body.prior, when, ent);
-            t.contChosen = body.prior;
-            chainTuple(p, key, body.prior);
-            outbound.push(mapping);
+            ack = commitAck(__ackEnv); // der EMPFANGS-Effekt (Revision) committet unabhängig von der Wahl
+            let prep;
+            try {
+                prep = await prepareContMapping(p, key, body.prior, when, ent);
+            }
+            catch (err) {
+                t.contMappingDue = { prior: body.prior, kind: 'choice' };
+                return done({ outboundError: String(err?.message ?? err) });
+            }
+            if (t.deactivated || t.contChosen)
+                return done();
+            // Kette ZUERST (Review 13, B-1): scheitert sie, keine Wahl, keine Ausgabe
+            chainedNow = chainTuple(p, key, body.prior, when);
+            if (chainedNow) {
+                t.contChosen = body.prior;
+                if (t.contMappingDue?.kind === 'choice')
+                    delete t.contMappingDue; // die alte Bau-Pflicht ist ERFÜLLT (Review 14, B-2)
+                outbound.push(commitContMapping(prep));
+                const v2Err = await v2Reissue(p, key, when, ent, outbound);
+                if (v2Err)
+                    return done({ outboundError: v2Err });
+            }
+        }
+        else {
+            // NUR das Gegen-Mapping AUF DER GEWÄHLTEN Beziehung ist die
+            // ALIGNMENT-Antwort (Review 14, B-1): body.prior = der eigene
+            // alte Anker des Senders = unser Kontaktschlüssel der gewählten
+            // alten Beziehung (t.contChosen). Ein Match-Report für eine
+            // ANDERE gemeinsame Altbeziehung beantwortet die Wahl NICHT —
+            // erst die echte Antwort beendet die Resend-Pflicht (retiren,
+            // Ack-Ref bleibt; Review 13, B-2)
+            if (t.contChosen && body.prior === t.contChosen)
+                for (const o of (t.outbox ?? new Map()).values())
+                    if (o.kind === 'continuity-mapping')
+                        o.retired = true;
+            ack = commitAck(__ackEnv);
         }
     }
-    return { handled: true, chained: p.contacts.get(body.prior)?.deactivated === true, name: t.name, outbound };
+    return done();
 }
 /**
  * The host's producing call for a mapping the receiver still owes
@@ -276,28 +690,103 @@ async function handleMapping(p, { key, t }, doc, when, ent) {
  */
 export async function flushContinuity(p, newKey, when, ent = {}) {
     const t = p.contacts.get(newKey);
-    if (!t?.contMappingDue)
-        return { outbound: [] };
-    // Single-Flight (Review 7, B-3): zwei parallele Flushes liefern nie
-    // zwei Mappings für EINE Pflicht
-    if (t.contFlushPending)
-        return { outbound: [], pending: true };
-    t.contFlushPending = true;
-    try {
-        const due = t.contMappingDue;
-        const mapping = await buildMapping(p, newKey, due.prior, when, ent);
-        // der Flush stellt GENAU den Zustand her, den der gelungene
-        // Direktpfad hinterlassen hätte — kind-bewusst. Und er löscht NUR
-        // die Pflicht, die er selbst gebaut hat: ist während des await eine
-        // NEUERE an ihre Stelle getreten, bleibt sie stehen (Review 8, B-3)
-        if (due.kind === 'align')
-            t.contAligned = true;
-        if (t.contMappingDue === due)
-            delete t.contMappingDue;
-        return { outbound: [mapping] };
-    }
-    finally {
-        t.contFlushPending = false;
+    if (!t || t.deactivated)
+        return { outbound: [] }; // Per-Tupel-Pflichten sterben mit dem Tupel (Review 8, B-2)
+    // Retry-ENTSCHEIDUNG und Pflicht-Bau laufen unter dem Kontakt-Lock
+    // (Review 12, B-1): der Empfang (der Reports retired) hält denselben
+    // Lock — kein Fenster, in dem ein gestarteter Flush eine gerade
+    // gestorbene Report-Pflicht doch noch ausstellt („a match report
+    // flushed after the choice … MUST NOT be sent"). Nur der frische
+    // Probe-Neubau läuft danach (buildProbe nimmt denselben Lock selbst).
+    const r = await withContactLock(t, async () => {
+        if (t.deactivated)
+            return { outbound: [] };
+        // unquittierte MAPPINGS: byte-identischer Retry (4.2), retired nie
+        // (gestorbene Match-Report-Pflicht, Review 11, B-3). PROBEN nie
+        // byte-identisch — §6a: „a resend is always a fresh probe sequence
+        // with freshly sampled padding" (Review 5, B-3): stale Einträge
+        // werden RETIRED (Ack-Ref bleibt, Review 6, B-3), EINE frische
+        // Probe ersetzt sie (Bau nach der Lock-Sektion)
+        const retries = [...(t.outbox ?? new Map()).values()]
+            .filter((o) => o.kind === 'continuity-mapping' && !o.retired)
+            .map((o) => ({ to: t, kind: o.kind + '/0.1 (Retry, byte-identisch)', env: o.env }));
+        const staleProbes = [...(t.outbox ?? new Map()).values()].filter((o) => o.kind === 'continuity-probe' && !o.retired);
+        let probeDue = false;
+        if (staleProbes.length) {
+            for (const o of staleProbes)
+                o.retired = true;
+            probeDue = true;
+        }
+        if (!t.contMappingDue)
+            return { outbound: retries, probeDue };
+        // Single-Flight (Review 7, B-3): zwei parallele Flushes liefern nie
+        // zwei Mappings für EINE Pflicht
+        if (t.contFlushPending)
+            return { outbound: retries, pending: true, probeDue };
+        t.contFlushPending = true;
+        try {
+            const due = t.contMappingDue;
+            // eine Choice-Pflicht nach bereits GEFALLENER Wahl ist tot
+            // (Review 14, B-2): der Direktpfad hat sie erfüllt oder ersetzt —
+            // sie darf NIE in den generischen Bau fallen (der eine frische
+            // Revision prägte statt der Same-Revision-Wiederholung)
+            if (due.kind === 'choice' && t.contChosen) {
+                if (t.contMappingDue === due)
+                    delete t.contMappingDue;
+                return { outbound: retries, probeDue };
+            }
+            if (due.kind === 'choice' && !t.contChosen) {
+                // die nachgeholte RECORD-WAHL kettet atomar mit der Ausgabe
+                // (Review 12, B-2) und ITERIERT alle bekannten Matches
+                // (Review 20, B-3): erster lebender, kettbarer Kandidat
+                // gewinnt; sind alle tot, stirbt die Pflicht ehrlich
+                // ungekettet (spätere Probes wählen neu). Ein Bau-Fehler
+                // wirft → der äußere catch hält die Pflicht am Leben.
+                const cands = [...new Set([due.prior, ...(due.alts ?? [])])];
+                for (const cand of cands) {
+                    if (p.contacts.get(cand)?.deactivated)
+                        continue;
+                    const prep = await prepareContMapping(p, newKey, cand, when, ent);
+                    if (t.deactivated)
+                        return { outbound: retries, probeDue };
+                    if (t.contChosen)
+                        break;
+                    if (!chainTuple(p, newKey, cand, when))
+                        continue; // Rennen verloren → nächster Kandidat
+                    t.contChosen = cand;
+                    retries.push(commitContMapping(prep));
+                    break;
+                }
+                if (t.contMappingDue === due)
+                    delete t.contMappingDue;
+                return { outbound: retries, probeDue };
+            }
+            const mapping = await buildMapping(p, newKey, due.prior, when, ent, due.kind);
+            // der Flush stellt GENAU den Zustand her, den der gelungene
+            // Direktpfad hinterlassen hätte — kind-bewusst. Und er löscht NUR
+            // die Pflicht, die er selbst gebaut hat: ist während des await
+            // eine NEUERE an ihre Stelle getreten, bleibt sie stehen (Review
+            // 8, B-3); aligned setzt erst der ACK — hier stirbt die BAU-Pflicht
+            if (t.contMappingDue === due)
+                delete t.contMappingDue;
+            return { outbound: [...retries, mapping], probeDue };
+        }
+        catch (err) {
+            return { outbound: retries, probeDue, outboundError: String(err?.message ?? err) };
+        }
+        finally {
+            t.contFlushPending = false;
+        }
+    });
+    if (r.probeDue) {
+        try {
+            r.outbound.push(...(await buildProbe(p, newKey, when, { ...ent, pad: undefined, threadId: undefined }) ?? []));
+        }
+        catch (err) {
+            r.outboundError = r.outboundError ? r.outboundError + ' · ' + String(err?.message ?? err) : String(err?.message ?? err);
+        }
     }
+    delete r.probeDue;
+    return r;
 }
 //# sourceMappingURL=continuity.js.map