@securecoms/agent-bridge 0.33.0 → 0.33.1

package/dist/index.js

@@ -17477,7 +17477,17 @@ var CODES = [
   // missed and before any write, so nothing landed. Definite: the committer's
   // work cannot name an agent in a humans-only enclave (admission refuses
   // one), so dropping the commit starts no resend loop.
-  { status: 403, code: "humans_only_enclave" }
+  { status: 403, code: "humans_only_enclave" },
+  // ADR-0024 step 2a PR-E (carry-A ruling §3 A): a V Add or Welcome whose
+  // leaf-key claim map is missing, does not cover exactly the Welcome
+  // targets, or names a key that is not the target's current vendable
+  // KeyPackage's. Refused before any write; definite, so the committer drops
+  // the commit, refetches the KeyPackages and rebuilds instead of resending
+  // the same stale bytes forever.
+  { status: 409, code: "voice_stale_key_package" },
+  // PR-E: a Welcome target already holds a bound leaf in this V group (the
+  // DS-level duplicate-leaf guard). Nothing written; a resend cannot land.
+  { status: 409, code: "voice_leaf_already_bound" }
 ];
 var DISTRIBUTE_DEFINITE_CODES = Object.freeze(CODES.map((c) => Object.freeze({ ...c })));
 var DEFINITE_KEYS = new Set(DISTRIBUTE_DEFINITE_CODES.map((c) => `${c.status} ${c.code}`));
@@ -18524,6 +18534,31 @@ function ownLeafIndexOf(mgr) {
 function tagOf(mgr) {
   return { groupId: new TextDecoder().decode(mgr.groupId), epoch: Number(mgr.epoch) };
 }
+function leafKeyClaims(targets, pkgs) {
+  if (targets.length !== pkgs.length)
+    throw new Error("leafKeyClaims: targets and KeyPackages differ in length");
+  const out = {};
+  targets.forEach((d, i) => {
+    out[d] = bytesToHex22(pkgs[i].leafNode.signaturePublicKey);
+  });
+  return out;
+}
+function leafIndicesForSignatureKey(mgr, keyHex) {
+  const tree = mgr.state?.ratchetTree;
+  if (!tree)
+    return [];
+  const want = keyHex.toLowerCase();
+  const out = [];
+  const numLeaves = Math.floor((tree.length + 1) / 2);
+  for (let i = 0; i < numLeaves; i++) {
+    const node = tree[i * 2];
+    if (!node || node.nodeType !== "leaf")
+      continue;
+    if (bytesToHex22(getSignaturePublicKeyFromLeafIndex2(tree, toLeafIndex2(i))) === want)
+      out.push(i);
+  }
+  return out;
+}
 function tagOfState(state) {
   const m = new MLSGroupManager(state.ciphersuite);
   m.importState(state);
@@ -18638,6 +18673,12 @@ var SelfAddRefusedError = class extends Error {
     this.name = "SelfAddRefusedError";
   }
 };
+var VoiceMirrorAddRefusedError = class extends Error {
+  constructor() {
+    super("addMemberToLiveGroup: refusing a voice-channel Add of a device already in the roster mirror (it would mint a duplicate leaf)");
+    this.name = "VoiceMirrorAddRefusedError";
+  }
+};
 var VaultCredentialMismatchError = class extends Error {
   expected;
   got;
@@ -20127,10 +20168,28 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
    * The row is deliberately NOT acked here — the subsequent ensureSession(join) /
    * joinAndReconcile consumes the same Welcome and acks it after joining.
    */
-  async peekWelcomeChannel(deviceId) {
+  async peekWelcomeChannel(deviceId, opts = {}) {
     const rows = await this.o.backend.pullDelivery(deviceId);
-    const w = rows.find((r) => r.message_type === "welcome" && r.connect_channel_id != null);
-    return w?.connect_channel_id ?? null;
+    const asked = /* @__PURE__ */ new Set();
+    for (const r of rows) {
+      if (r.message_type !== "welcome" || r.connect_channel_id == null)
+        continue;
+      const ch = r.connect_channel_id;
+      if (!opts.accept)
+        return ch;
+      if (asked.has(ch))
+        continue;
+      asked.add(ch);
+      let ok = false;
+      try {
+        ok = await opts.accept(ch) === true;
+      } catch {
+        ok = false;
+      }
+      if (ok)
+        return ch;
+    }
+    return null;
   }
   /**
    * Publish this device's KeyPackage if it holds none; otherwise a no-op that
@@ -20236,10 +20295,17 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
     }
     const attempted = [];
     const failed = [];
+    const discarded = [];
     for (const channelId of channelIds) {
       attempted.push(channelId);
       try {
-        await this.ensureSession(channelId, { enclaveId: "welcome-drain", bootstrap: false });
+        await this.ensureSession(channelId, {
+          enclaveId: "welcome-drain",
+          bootstrap: false,
+          onUnopenableWelcome: (groupId) => {
+            discarded.push({ channelId, groupId });
+          }
+        });
       } catch (error) {
         failed.push({ channelId, error });
       }
@@ -20249,7 +20315,7 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       receipt = new DrainReceipt(DRAIN_RECEIPT_TOKEN);
       this.drainReceipts.set(receipt, this.nowMs());
     }
-    return { attempted, failed, skipped, unknown, pageFull, receipt };
+    return { attempted, failed, skipped, unknown, pageFull, receipt, discarded };
   }
   /**
    * Resolve the channel's pending commit record, under the channel lock, and
@@ -20722,7 +20788,8 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
           throw new Error(`ensureSession: no published KeyPackage for device ${d}`);
         return MLSGroupManager.deserializeKeyPackage(hexToBytes22(hex));
       });
-      const init = await this.o.backend.initConnectChannelGroup(channelId, [this.o.deviceId]);
+      const creatorLeafSignatureKey = bundle ? bytesToHex22(bundle.publicPackage.leafNode.signaturePublicKey) : void 0;
+      const init = await this.o.backend.initConnectChannelGroup(channelId, [this.o.deviceId], creatorLeafSignatureKey !== void 0 ? { creatorLeafSignatureKey } : void 0);
       if (init.created === false) {
         if (!this.isAdoptableOrphan(init, others)) {
           if (this.isOrphanShape(init, others))
@@ -20742,7 +20809,9 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
         commit_epoch: Number(mgr.epoch),
         expected_epoch: init.current_epoch,
         member_device_ids: [this.o.deviceId, ...others],
-        welcomes: welcome ? others.map((d) => ({ target_device_id: d, payload: bytesToHex22(welcome) })) : []
+        welcomes: welcome ? others.map((d) => ({ target_device_id: d, payload: bytesToHex22(welcome) })) : [],
+        // Task 24b (ruling §3 A): exact cover of the Welcome targets ({} when none).
+        added_leaf_signature_keys: leafKeyClaims(welcome ? others : [], welcome ? pkgs : [])
       }, mgr, null);
       const res = await this.commitWithPendingRecord(channelId, rec, mgr);
       if (!res.landed) {
@@ -20756,15 +20825,32 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       const w = rows.find((r) => r.message_type === "welcome" && r.connect_channel_id === channelId);
       if (!w)
         throw new Error("ensureSession(join): no Welcome available yet for this channel");
+      const aborted = () => opts.shouldAbort?.() === true;
+      if (aborted())
+        throw new Error("ensureSession(join): aborted by the caller");
       let mgr;
       try {
         mgr = await this.openWelcome(hexToBytes22(w.payload), [bundle, joinSlot]);
       } catch (err) {
+        if (aborted())
+          throw new Error("ensureSession(join): aborted by the caller");
         this.recordDecryptError(w, err);
         writeServiceLog("warn", "session.unopenable_welcome_discarded", {}, err);
         await this.o.backend.ackDelivery(this.o.deviceId, [w.queue_id]);
+        try {
+          opts.onUnopenableWelcome?.(w.group_id);
+        } catch (e) {
+          writeServiceLog("warn", "session.unopenable_welcome_report_failed", {}, e);
+        }
+        try {
+          this.o.onUnopenableWelcomeDiscarded?.({ channelId, groupId: w.group_id });
+        } catch (e) {
+          writeServiceLog("warn", "session.unopenable_welcome_report_failed", {}, e);
+        }
         return;
       }
+      if (aborted())
+        throw new Error("ensureSession(join): aborted by the caller");
       this.managers.set(channelId, mgr);
       await this.saveMain(channelId, mgr);
       await this.o.backend.ackDelivery(this.o.deviceId, [w.queue_id]);
@@ -20975,6 +21061,13 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       await this.refuseUnlessHeldGroupIsActive(channelId, mgr, "addMemberToLiveGroup");
       const init = await this.o.backend.initConnectChannelGroup(channelId, [this.o.deviceId]);
       groupId = init.group_id;
+      if (this.o.isVoiceChannel?.(channelId) === true) {
+        const mirror = init.member_device_ids;
+        if (!Array.isArray(mirror) || mirror.includes(newDeviceId)) {
+          writeServiceLog("warn", "admission.voice_device_already_in_mirror");
+          throw new VoiceMirrorAddRefusedError();
+        }
+      }
       members = [.../* @__PURE__ */ new Set([...init.member_device_ids ?? [this.o.deviceId], newDeviceId])];
     }
     if (new TextDecoder().decode(mgr.groupId) !== groupId) {
@@ -20993,7 +21086,9 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       expected_epoch: priorEpoch,
       member_device_ids: members,
       op: "add",
-      welcomes: welcome ? [{ target_device_id: newDeviceId, payload: bytesToHex22(welcome) }] : []
+      welcomes: welcome ? [{ target_device_id: newDeviceId, payload: bytesToHex22(welcome) }] : [],
+      // Task 24b (ruling §3 A): the exact Welcome cover's leaf keys.
+      added_leaf_signature_keys: leafKeyClaims(welcome ? [newDeviceId] : [], welcome ? [pkg] : [])
     }, mgr, prior), mgr);
     if (!res.landed) {
       const e = res.error;
@@ -21314,6 +21409,181 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       return this.removeDeviceFromLiveGroupUnlocked(channelId, deviceId, opts, _attempt + 1);
     }
   }
+  /**
+   * ADR-0024 step 2a, round 2 F4 (Task 24): the committer sweep's DEVICE-level
+   * Remove of one leaf the server's committer-work lists in `remove_devices`
+   * (on the hidden voice channel V: a stale device of an agent or relay
+   * identity that is still on V's roster).
+   *
+   * ⛔ WHY NOT {@link removeDeviceFromLiveGroup}. That path resolves a FOREIGN
+   * identity's leaf by add-order position, which RFC 9420's leftmost-blank
+   * refill permutes. Here the identity keeps a CURRENT device, so a wrong guess
+   * evicts the current device's leaf while the distribute's `removed_device_id`
+   * makes the server drop the STALE device from its mirror. The current device
+   * is then in the roster with no leaf, outside the adds delta forever: an
+   * unrecoverable wedge. So this resolves the leaf by EXACT evidence only:
+   *
+   *   - the target device's PUBLISHED KeyPackage, whose LeafNode signature key
+   *     is matched against THIS committer's live tree (the device-level leaf
+   *     predicate, {@link leafIndicesForKeyPackage}). `generateKeyPackage`
+   *     mints a fresh signature keypair per call, so a match names exactly the
+   *     leaf that KeyPackage was Added as;
+   *   - exactly ONE matching leaf, or nothing is committed;
+   *   - that leaf's credential identity is read from the tree, never from the
+   *     server, and is what the distribute names as `removed_identity_id`.
+   *
+   * Outcomes. `"removed"`: one leaf evicted and the distribute landed.
+   * `"unresolved"`: no KeyPackage is published for the device, or it matches no
+   * leaf (the device rotated it after its Add, or the leaf is already gone).
+   * Nothing is committed: the leaf, if any, stays, and is reported, never
+   * guessed. The server's next delta lists it again (the caller's throttle
+   * bounds the retries).
+   *
+   * Refusals (thrown before any commit is built, so nothing is distributed):
+   * the committer's own device (`own_device`), any leaf of the committer's own
+   * identity, the committer's own leaf, or an unknown own leaf
+   * (`own_leaf` / `own_leaf_unknown`, {@link OwnLeafRemoveRefusedError}); two
+   * or more matching leaves; a held group that is not the channel's active
+   * group (#757 binding, checked BEFORE init).
+   */
+  async removeStaleDeviceLeafFromLiveGroup(channelId, deviceId, bound) {
+    return this.locks.run(channelId, () => this.evictOnThrow(channelId, async () => {
+      await this.requirePendingResolvedUnlocked(channelId);
+      return this.removeStaleDeviceLeafUnlocked(channelId, deviceId, 0, bound);
+    }));
+  }
+  async removeStaleDeviceLeafUnlocked(channelId, deviceId, _attempt, bound) {
+    if (await this.custodyHeld(channelId))
+      throw new CustodyPersistError(channelId);
+    if (deviceId === this.o.deviceId)
+      throw new OwnLeafRemoveRefusedError("removeDevice", "own_device");
+    const mgr = await this.manager(channelId);
+    const resolved = bound ? this.resolveBoundDeviceLeaf(mgr, bound) : await this.resolveServedKeyPackageLeaf(mgr, deviceId);
+    if (resolved === "unresolved")
+      return "unresolved";
+    const { leafIndex, leafIdentity } = resolved;
+    await this.refuseUnlessHeldGroupIsActive(channelId, mgr, "removeStaleDeviceLeafFromLiveGroup");
+    const init = await this.o.backend.initConnectChannelGroup(channelId, [this.o.deviceId]);
+    if (new TextDecoder().decode(mgr.groupId) !== init.group_id) {
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: group binding mismatch");
+    }
+    const priorEpoch = Number(mgr.epoch);
+    const prior = tagOf(mgr);
+    const { commit } = await mgr.removeMembers([leafIndex]);
+    if (Number(mgr.epoch) !== priorEpoch + 1) {
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: unexpected epoch drift before distribute");
+    }
+    const members = init.member_device_ids ?? [this.o.deviceId];
+    const res = await this.commitWithPendingRecord(channelId, this.pendingRecord("remove", init.group_id, {
+      device_id: this.o.deviceId,
+      commit: bytesToHex22(commit),
+      commit_epoch: Number(mgr.epoch),
+      expected_epoch: priorEpoch,
+      member_device_ids: members,
+      op: "remove",
+      removed_identity_id: leafIdentity,
+      removed_device_id: deviceId,
+      welcomes: []
+    }, mgr, prior), mgr);
+    if (!res.landed) {
+      const e = res.error;
+      if (isSupersededRefusal(e))
+        throw new GroupSupersededError(channelId, init.group_id);
+      if (_attempt >= 2 || !isEpochConflict(e))
+        throw e;
+      try {
+        await this.drainChannelCommitsUnlocked(this.o.deviceId, channelId);
+      } catch (e2) {
+        if (e2 instanceof CustodyPersistError)
+          throw e2;
+      }
+      return this.removeStaleDeviceLeafUnlocked(channelId, deviceId, _attempt + 1, bound);
+    }
+    return "removed";
+  }
+  /** F4 (Task 24): the target's PUBLISHED KeyPackage, matched by key against
+   *  the committer's tree. Unchanged from Task 24 and its fix round 1. */
+  async resolveServedKeyPackageLeaf(mgr, deviceId) {
+    const kps = await this.o.backend.fetchKeyPackages([deviceId]);
+    const hex = kps[deviceId];
+    if (!hex) {
+      writeServiceLog("info", "committer.remove_device_unresolved", { no_key_package: true });
+      return "unresolved";
+    }
+    const pkg = MLSGroupManager.deserializeKeyPackage(hexToBytes22(hex));
+    const leaves = leafIndicesForKeyPackage(mgr, pkg);
+    if (leaves.length === 0) {
+      writeServiceLog("info", "committer.remove_device_unresolved", { no_matching_leaf: true });
+      return "unresolved";
+    }
+    if (leaves.length > 1) {
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: ambiguous key match (more than one leaf)");
+    }
+    const leafIndex = leaves[0];
+    const tree = mgr.state?.ratchetTree;
+    if (!tree)
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: no local group state");
+    const cred = getCredentialFromLeafIndex(tree, toLeafIndex2(leafIndex));
+    if (cred.credentialType !== "basic") {
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: leaf carries no basic credential");
+    }
+    const leafIdentity = new TextDecoder().decode(cred.identity);
+    const ownIdentity = new TextDecoder().decode(this.o.identity);
+    this.refuseOwnLeafRemove(mgr, [leafIndex], "removeDevice");
+    if (!leafIdentity || leafIdentity === ownIdentity) {
+      throw new OwnLeafRemoveRefusedError("removeDevice", "own_leaf");
+    }
+    if (mgr.leafIndicesForIdentity(leafIdentity).length <= 1) {
+      writeServiceLog("warn", "committer.remove_device_refused_last_leaf", {});
+      return "unresolved";
+    }
+    return { leafIndex, leafIdentity };
+  }
+  /**
+   * ADR-0024 step 2a Task 24b (architect ruling "carry A", §3 B and §4 R5):
+   * resolve the leaf by the SERVER-BOUND leaf signature key (committer work's
+   * `remove_device_leaves`). The server recorded the key when the leaf was
+   * born, from the KeyPackage it vended, so it survives the target's
+   * KeyPackage rotation, revocation and deletion, which the served-KeyPackage
+   * path cannot.
+   *
+   *  - Leaves are matched by the bound key ONLY: exactly one match, else
+   *    `unresolved` (zero) or a throw (two or more). ⛔ NEVER a fall back to
+   *    the served KeyPackage: two evidence sources that disagree fail closed.
+   *  - The matched leaf's basic-credential identity must equal the server's
+   *    `identityId` for the device (R4), else a throw.
+   *  - The committer's own leaf index (or an unknown one) is refused
+   *    ({@link refuseOwnLeafRemove}); the own device was refused by the caller.
+   *  - R5: a leaf of the committer's OWN identity is admitted (a sibling
+   *    device: a revoked laptop). The brick class the own-identity refusal
+   *    guards came from positional or identity-level resolution, which this
+   *    exact-key path cannot reach, and the own leaf index is still refused.
+   *  - No last-leaf refusal: the binding is exact evidence, and an identity's
+   *    last leaf is exactly the revoked single-device case (and carry A's
+   *    Remove before its re-Add).
+   * Synchronous and before any commit is built: a refusal distributes nothing.
+   */
+  resolveBoundDeviceLeaf(mgr, bound) {
+    const leaves = leafIndicesForSignatureKey(mgr, bound.leafSignatureKeyHex);
+    if (leaves.length === 0) {
+      writeServiceLog("info", "committer.remove_device_unresolved", { no_bound_leaf: true });
+      return "unresolved";
+    }
+    if (leaves.length > 1) {
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: ambiguous bound-key match (more than one leaf)");
+    }
+    const leafIndex = leaves[0];
+    const tree = mgr.state?.ratchetTree;
+    if (!tree)
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: no local group state");
+    const cred = getCredentialFromLeafIndex(tree, toLeafIndex2(leafIndex));
+    const leafIdentity = cred.credentialType === "basic" ? new TextDecoder().decode(cred.identity) : "";
+    if (!leafIdentity || leafIdentity !== bound.identityId) {
+      throw new Error("removeStaleDeviceLeafFromLiveGroup: the bound leaf's credential identity is not the device's identity");
+    }
+    this.refuseOwnLeafRemove(mgr, [leafIndex], "removeDevice");
+    return { leafIndex, leafIdentity };
+  }
   /**
    * Committer-side (owner): evict a SINGLE device leaf from a LIVE VAULT group,
    * targeted by its owner-observed leaf `signaturePublicKey` against the live
@@ -23134,6 +23404,9 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
     if (supersededChannelIds.length) {
       Object.defineProperty(appEntries, "supersededChannelIds", { value: supersededChannelIds, enumerable: false });
     }
+    if (w2Kept.size) {
+      Object.defineProperty(appEntries, "pendingWelcomeChannelIds", { value: [...w2Kept], enumerable: false });
+    }
     return appEntries;
   }
   /**
@@ -24925,9 +25198,9 @@ var RestMlsBackend = class {
       current_epoch: j.current_epoch != null ? Number(j.current_epoch) : null
     };
   }
-  async initConnectChannelGroup(channelId, memberDeviceIds) {
+  async initConnectChannelGroup(channelId, memberDeviceIds, opts) {
     const path = `/api/v1/mls/connect-channels/${channelId}/init`;
-    const body = { member_device_ids: memberDeviceIds };
+    const body = opts?.creatorLeafSignatureKey !== void 0 ? { member_device_ids: memberDeviceIds, creator_leaf_signature_key: opts.creatorLeafSignatureKey } : { member_device_ids: memberDeviceIds };
     let j;
     for (let attempt = 0; ; attempt++) {
       try {
@@ -25169,6 +25442,22 @@ var RestMlsBackend = class {
       throw new Error(`unrequested-removals: reports is ${describeType(rows)}`);
     return rows;
   }
+  async signalVoiceLeafUnusable(groupId, deviceId) {
+    const res = await this.fetchBounded("mls_voice_leaf_unusable", "control", this.opts.baseUrl + `/api/v1/mls/groups/${groupId}/voice-leaf-unusable`, { method: "POST", headers: this.headers(), body: JSON.stringify({ device_id: deviceId }) });
+    const text = await res.text().catch(() => "");
+    if (res.ok)
+      return { status: res.status };
+    let parsed = null;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = null;
+      }
+    }
+    const code = parseErrorCode(parsed);
+    return code === void 0 ? { status: res.status } : { status: res.status, code };
+  }
   async getCommitterWork(channelId) {
     const j = await this.get("mls_committer_work", `/api/v1/mls/connect-channels/${channelId}/committer-work`);
     const requireList = (field) => {
@@ -25178,7 +25467,29 @@ var RestMlsBackend = class {
       }
       return v.map(String);
     };
-    return { adds: requireList("adds"), removes: requireList("removes") };
+    const work = {
+      adds: requireList("adds"),
+      removes: requireList("removes")
+    };
+    if (j?.remove_devices !== void 0) {
+      work.removeDevices = requireList("remove_devices");
+    }
+    const rawLeaves = j?.remove_device_leaves;
+    if (rawLeaves !== void 0) {
+      if (!Array.isArray(rawLeaves))
+        throw new MalformedCommitterWorkError(channelId, "remove_device_leaves", describeType(rawLeaves));
+      const seen = /* @__PURE__ */ new Set();
+      work.removeDeviceLeaves = rawLeaves.map((e) => {
+        const o = e !== null && typeof e === "object" && !Array.isArray(e) ? e : null;
+        const key = typeof o?.leaf_signature_key === "string" ? o.leaf_signature_key.toLowerCase() : null;
+        if (!o || typeof o.device_id !== "string" || !o.device_id || typeof o.identity_id !== "string" || !o.identity_id || key === null || key.length === 0 || key.length % 2 !== 0 || !/^[0-9a-f]+$/.test(key) || seen.has(o.device_id)) {
+          throw new MalformedCommitterWorkError(channelId, "remove_device_leaves[]", describeType(e));
+        }
+        seen.add(o.device_id);
+        return { deviceId: o.device_id, identityId: o.identity_id, leafSignatureKeyHex: key };
+      });
+    }
+    return work;
   }
   async acquireCommitLease(channelId) {
     try {
@@ -25228,6 +25539,48 @@ var RestMlsBackend = class {
 
 // ../connect-sdk-ts/dist/mls/fake-backend.js
 var DELIVERY_PULL_LIMIT = 100;
+function keyPackageSignatureKeyHex(kpHex) {
+  const b = hexToBytes22(kpHex);
+  let at = 0;
+  const u16 = () => {
+    if (at + 2 > b.length)
+      throw new Error("t");
+    const v = b[at] << 8 | b[at + 1];
+    at += 2;
+    return v;
+  };
+  const opaque = () => {
+    if (at >= b.length)
+      throw new Error("t");
+    const prefix = b[at] >> 6;
+    if (prefix === 3)
+      throw new Error("t");
+    const size = 1 << prefix;
+    if (at + size > b.length)
+      throw new Error("t");
+    let n = b[at] & 63;
+    for (let i = 1; i < size; i++)
+      n = n << 8 | b[at + i];
+    at += size;
+    if (at + n > b.length)
+      throw new Error("t");
+    const out = b.slice(at, at + n);
+    at += n;
+    return out;
+  };
+  try {
+    if (u16() !== 1 || u16() !== 5)
+      return null;
+    u16();
+    u16();
+    opaque();
+    opaque();
+    const sig = opaque();
+    return sig.length > 0 ? bytesToHex22(sig) : null;
+  } catch {
+    return null;
+  }
+}
 var FakeConnectBackend = class _FakeConnectBackend {
   // Key-package store: deviceId → hex-encoded KeyPackage
   kps = /* @__PURE__ */ new Map();
@@ -25312,6 +25665,7 @@ var FakeConnectBackend = class _FakeConnectBackend {
    * server's purge_device_queue. */
   linkIdentityDevice(identityId, deviceId) {
     this.deviceByIdentity.set(identityId, deviceId);
+    this.identityByDevice.set(deviceId, identityId);
   }
   async publishKeyPackage(deviceId, keyPackageHex) {
     this.kps.set(deviceId, keyPackageHex);
@@ -25361,8 +25715,38 @@ var FakeConnectBackend = class _FakeConnectBackend {
       current_epoch: this.epochByChannel.get(channelId) ?? 0
     };
   }
-  async initConnectChannelGroup(channelId, memberDeviceIds) {
+  /** ADR-0024 step 2a (P-7): channel ids the test registers as a hidden
+   *  voice channel V. Init on an EXISTING V returns it unchanged and merges
+   *  nothing, as the real backend does. */
+  voiceChannelIds = /* @__PURE__ */ new Set();
+  /** Task 24b (architect ruling "carry A", §3 A-C), modelled for a channel in
+   *  {@link voiceChannelIds} only, as the PR-E server does for V:
+   *  `channel -> device -> { key (hex), unusableSignaledAt }`, written ONLY
+   *  when a V leaf is born (the creator's init, an Add's Welcome) from the
+   *  verified claim, and deleted when a Remove of that device (or its
+   *  identity) lands. */
+  voiceLeafBindings = /* @__PURE__ */ new Map();
+  /** The device -> identity the server knows (the devices table). Written by
+   *  {@link linkIdentityDevice}; read for `remove_device_leaves`. */
+  identityByDevice = /* @__PURE__ */ new Map();
+  static voiceRefusal(path, code) {
+    return new MlsBackendHttpError(path, 409, code);
+  }
+  /** The current vendable KeyPackage key of `deviceId`, or null. */
+  currentLeafKey(deviceId) {
+    const hex = this.kps.get(deviceId);
+    return hex ? keyPackageSignatureKeyHex(hex) : null;
+  }
+  async initConnectChannelGroup(channelId, memberDeviceIds, opts) {
     const alreadyExists = this.groupIdByChannel.has(channelId);
+    if (!alreadyExists && this.voiceChannelIds.has(channelId)) {
+      const creator = memberDeviceIds[0];
+      const current = creator ? this.currentLeafKey(creator) : null;
+      if (!opts?.creatorLeafSignatureKey || current === null || opts.creatorLeafSignatureKey.toLowerCase() !== current) {
+        throw new Error(`/api/v1/mls/connect-channels/${channelId}/init failed: 409 {"detail":"voice_stale_key_package"}`);
+      }
+      this.voiceLeafBindings.set(channelId, /* @__PURE__ */ new Map([[creator, { key: current, unusableSignaledAt: null }]]));
+    }
     let groupId = this.groupIdByChannel.get(channelId);
     if (!groupId) {
       groupId = `00000000-0000-0000-0000-${String(this.groupIdByChannel.size + 1).padStart(12, "0")}`;
@@ -25370,7 +25754,7 @@ var FakeConnectBackend = class _FakeConnectBackend {
       this.channelByGroup.set(groupId, channelId);
       this.epochByChannel.set(channelId, 0);
     }
-    const members = [.../* @__PURE__ */ new Set([...this.membersByChannel.get(channelId) ?? [], ...memberDeviceIds])];
+    const members = alreadyExists && this.voiceChannelIds.has(channelId) ? [...this.membersByChannel.get(channelId) ?? []] : [.../* @__PURE__ */ new Set([...this.membersByChannel.get(channelId) ?? [], ...memberDeviceIds])];
     this.membersByChannel.set(channelId, members);
     return {
       group_id: groupId,
@@ -25507,6 +25891,27 @@ var FakeConnectBackend = class _FakeConnectBackend {
         throw new MlsBackendHttpError(_FakeConnectBackend.distributePath(groupId), 409, "EPOCH_CONFLICT", "stale_epoch");
       }
     }
+    const vBindings = this.voiceChannelIds.has(channelId) ? this.voiceLeafBindings.get(channelId) ?? /* @__PURE__ */ new Map() : null;
+    let bindNow = [];
+    if (vBindings && req.commit && req.op !== "remove") {
+      const targets = (req.welcomes ?? []).map((w) => w.target_device_id);
+      const claims = req.added_leaf_signature_keys;
+      const path = _FakeConnectBackend.distributePath(groupId);
+      if (!claims)
+        throw _FakeConnectBackend.voiceRefusal(path, "voice_stale_key_package");
+      const claimed = Object.keys(claims);
+      if (claimed.length !== targets.length || targets.some((t) => !(t in claims))) {
+        throw _FakeConnectBackend.voiceRefusal(path, "voice_stale_key_package");
+      }
+      for (const t of targets) {
+        const current = this.currentLeafKey(t);
+        if (current === null || claims[t].toLowerCase() !== current)
+          throw _FakeConnectBackend.voiceRefusal(path, "voice_stale_key_package");
+        if (vBindings.has(t))
+          throw _FakeConnectBackend.voiceRefusal(path, "voice_leaf_already_bound");
+      }
+      bindNow = targets.map((t) => [t, claims[t].toLowerCase()]);
+    }
     if (req.commit) {
       const log = this.commitLog.get(groupId) ?? [];
       log.push({
@@ -25529,6 +25934,12 @@ var FakeConnectBackend = class _FakeConnectBackend {
       this.membersByChannel.set(channelId, remaining);
       if (evictedDevice)
         this.queues.delete(evictedDevice);
+      if (vBindings) {
+        for (const d of [...vBindings.keys()]) {
+          if (d === evictedDevice || !req.removed_device_id && this.identityByDevice.get(d) === req.removed_identity_id)
+            vBindings.delete(d);
+        }
+      }
     } else {
       const members = [.../* @__PURE__ */ new Set([...this.membersByChannel.get(channelId) ?? [], ...req.member_device_ids ?? []])];
       this.membersByChannel.set(channelId, members);
@@ -25552,6 +25963,11 @@ var FakeConnectBackend = class _FakeConnectBackend {
         });
       }
     }
+    if (vBindings && bindNow.length > 0) {
+      for (const [d, k] of bindNow)
+        vBindings.set(d, { key: k, unusableSignaledAt: null });
+      this.voiceLeafBindings.set(channelId, vBindings);
+    }
     for (const w of req.welcomes ?? []) {
       this.q(w.target_device_id).push({
         queue_id: "q-" + this._seq++,
@@ -25612,6 +26028,51 @@ var FakeConnectBackend = class _FakeConnectBackend {
   async getCommitterWork(_channelId) {
     return { adds: [], removes: [] };
   }
+  /** Task 24b (ruling §3 C): the carry-A signal, every call recorded. Gates
+   *  modelled: the group is a V (else 404), a binding exists (else 409), the
+   *  device's current vendable key differs from the bound one (409
+   *  `voice_leaf_key_current` when equal, `voice_no_current_key_package`
+   *  when it has none). An already-signalled row is an idempotent 202. The
+   *  bind and roster gates are the server's (backend tests). */
+  signalVoiceLeafUnusableCalls = [];
+  async signalVoiceLeafUnusable(groupId, deviceId) {
+    this.signalVoiceLeafUnusableCalls.push({ groupId, deviceId });
+    const channelId = this.channelByGroup.get(groupId);
+    if (!channelId || !this.voiceChannelIds.has(channelId))
+      return { status: 404, code: "Not Found" };
+    const row = this.voiceLeafBindings.get(channelId)?.get(deviceId);
+    if (!row)
+      return { status: 409, code: "voice_leaf_binding_missing" };
+    const current = this.currentLeafKey(deviceId);
+    if (current === null)
+      return { status: 409, code: "voice_no_current_key_package" };
+    if (current === row.key)
+      return { status: 409, code: "voice_leaf_key_current" };
+    if (row.unusableSignaledAt === null)
+      row.unusableSignaledAt = this.now();
+    return { status: 202 };
+  }
+  /** Task 24b test seam: V's committer work as the PR-E server derives it,
+   *  for a test's `roster` (the server's roster devices): `adds` = roster
+   *  devices not in the mirror; `remove_devices` / `remove_device_leaves` =
+   *  roster devices whose binding is signalled unusable (NOT in `adds`: they
+   *  are still in the mirror). The re-Add follows only from a later call,
+   *  after the Remove landed and the mirror dropped the device. */
+  voiceCommitterWork(channelId, roster) {
+    const mirror = this.membersByChannel.get(channelId) ?? [];
+    const bindings = this.voiceLeafBindings.get(channelId) ?? /* @__PURE__ */ new Map();
+    const signalled = roster.filter((d) => mirror.includes(d) && bindings.get(d)?.unusableSignaledAt != null);
+    return {
+      adds: roster.filter((d) => !mirror.includes(d)),
+      removes: [],
+      removeDevices: signalled,
+      removeDeviceLeaves: signalled.map((d) => ({
+        deviceId: d,
+        identityId: this.identityByDevice.get(d) ?? "",
+        leafSignatureKeyHex: bindings.get(d).key
+      }))
+    };
+  }
   async acquireCommitLease(_channelId) {
     return "fake-lease-token";
   }
@@ -40009,6 +40470,12 @@ var BridgeAgent = class _BridgeAgent {
    * frozen at receipt) AND a window-eligible turn (voiceWindowEligible), whatever the window size. Two call sites: the voice
    * window flush, and the ingest tap block when the window did not take the turn (off, 0 by default). Like the typed tap, the write-time owner scope's pinned identity must be the speaking identity;
    * otherwise nothing is written (H-4). Logs are content-free (U17). Never throws.
+   *
+   * Bridge 0.33.1 (architect Q2, C5 not accepted): a turn on a voice channel V carries `parent`, its P from the
+   * per-frame verdict. The scope is ownerScopeForWrite(P) (P's pin and roster, as for a turn on P), the item keeps
+   * channelId = V (so V's own capture still guards it in the store), and P's receipt capture is checked at commit,
+   * inside the memory mutex: a purge or room clear of P since receipt writes nothing. No P capture at receipt, or no
+   * persisted V -> P link (the purge of P reaches V's items only through it): nothing is written.
    */
   async tapUnifiedVoice(m, c) {
     const skip = (reason) => this.logUnifiedTapSkip(reason);
@@ -40017,9 +40484,22 @@ var BridgeAgent = class _BridgeAgent {
       if (m.authorization?.relay_speaker !== "owner" || m.speaker === void 0) return skip("audience");
       if (c.stamp === void 0) return skip("stamp_missing");
       if (c.capture.purgeEpoch < 0) return skip("purged");
-      const scopeId = await this.ownerScopeForWrite(m.channel_id);
+      const parent3 = c.parent;
+      const parentCapture = parent3?.capture;
+      if (parent3 === void 0 && this.voiceChannels.isVoice(m.channel_id)) return skip("scope");
+      if (parent3 !== void 0) {
+        if (parentCapture === void 0 || parentCapture.purgeEpoch < 0) return skip("scope");
+        if (this.store.voiceChannelParent(m.channel_id) !== parent3.channelId) return skip("scope");
+      }
+      const scopeId = await this.ownerScopeForWrite(parent3?.channelId ?? m.channel_id);
       if (scopeId === null) return skip("scope");
       if (parseOwnerDmScopeId(scopeId)?.ownerIdentityId !== m.speaker.identityId) return skip("scope");
+      const precommit = parent3 === void 0 || parentCapture === void 0 ? void 0 : () => {
+        const now = this.store.itemCapture(parent3.channelId);
+        if (now.purgeEpoch !== parentCapture.purgeEpoch) return "purged";
+        if (now.roomClearGeneration !== parentCapture.roomClearGeneration) return "room_cleared";
+        return null;
+      };
       const r = await this.items.commit({
         scopeKind: "owner_dm",
         scopeId,
@@ -40030,7 +40510,8 @@ var BridgeAgent = class _BridgeAgent {
         source: "owner_voice",
         trust: OWNER_VOICE_TRUST,
         text: typeof m.text === "string" ? m.text : "",
-        expect: { ...c.capture, clearGeneration: c.stamp }
+        expect: { ...c.capture, clearGeneration: c.stamp },
+        ...precommit ? { precommit } : {}
       });
       return r.ok ? { ok: true } : { ok: false, reason: r.reason };
     } catch {
@@ -42209,11 +42690,20 @@ var BridgeAgent = class _BridgeAgent {
     const purgeEpochAtReceipt = /* @__PURE__ */ new Map();
     const itemCaptureAtReceipt = /* @__PURE__ */ new Map();
     const recallModeEpochAtReceipt = this.store.recallState().modeEpoch;
+    const unifiedVoiceParentAt = (p) => {
+      const cap = itemCaptureAtReceipt.get(p);
+      return { channelId: p, capture: cap === void 0 ? void 0 : { ...cap, purgeEpoch: purgeEpochAtReceipt.get(p) ?? -1 } };
+    };
     for (const m of entries) {
       this.lastInboundAt.set(m.channelId, receivedAt);
       if (m.voiceMode === true) this.heartbeat.noteVoiceActivity();
       if (!purgeEpochAtReceipt.has(m.channelId)) purgeEpochAtReceipt.set(m.channelId, this.store.conversationPurgeEpoch(m.channelId));
       if (this.unifiedOn && !itemCaptureAtReceipt.has(m.channelId)) itemCaptureAtReceipt.set(m.channelId, this.store.itemCapture(m.channelId));
+      const receiptParent = this.voiceChannels.parentOf(m.channelId);
+      if (receiptParent !== void 0) {
+        if (!purgeEpochAtReceipt.has(receiptParent)) purgeEpochAtReceipt.set(receiptParent, this.store.conversationPurgeEpoch(receiptParent));
+        if (this.unifiedOn && !itemCaptureAtReceipt.has(receiptParent)) itemCaptureAtReceipt.set(receiptParent, this.store.itemCapture(receiptParent));
+      }
       this.recallReceipt.set(m.messageId, { purgeEpoch: purgeEpochAtReceipt.get(m.channelId), modeEpoch: recallModeEpochAtReceipt });
       receiptIds.push(m.messageId);
       const stamp = voiceStamp.get(m.channelId);
@@ -42559,6 +43049,7 @@ var BridgeAgent = class _BridgeAgent {
                 pending: Promise.resolve(),
                 purgeEpoch: purgeEpochAtReceipt.get(m.channelId),
                 itemCapture: itemCaptureAtReceipt.get(m.channelId),
+                ...voiceParent !== void 0 ? { voiceParent: unifiedVoiceParentAt(voiceParent) } : {},
                 bufferGeneration
               };
               this.voiceCoalescing.set(windowKey, win);
@@ -42589,7 +43080,7 @@ var BridgeAgent = class _BridgeAgent {
                 const merged = { ...held, text, memory: windowMemory };
                 if (this.unifiedOn) {
                   const snap = win.itemCapture ?? { ...this.store.itemCapture(channelId), purgeEpoch: -1 };
-                  const work = this.tapUnifiedVoice(merged, { stamp: this.ingestGeneration.get(firstId), capture: { ...snap, purgeEpoch: win.purgeEpoch ?? -1 } });
+                  const work = this.tapUnifiedVoice(merged, { stamp: this.ingestGeneration.get(firstId), capture: { ...snap, purgeEpoch: win.purgeEpoch ?? -1 }, ...win.voiceParent ? { parent: win.voiceParent } : {} });
                   this.unifiedWork.add(work);
                   void work.finally(() => this.unifiedWork.delete(work));
                 }
@@ -42679,7 +43170,11 @@ var BridgeAgent = class _BridgeAgent {
                 );
                 if (windowEligible && turnAuthorization.relay_speaker === "owner") {
                   const snap = itemCaptureAtReceipt.get(m.channelId) ?? { ...this.store.itemCapture(m.channelId), purgeEpoch: -1 };
-                  const work = this.tapUnifiedVoice(runtimeEntry(false, { recent: [], facts: [] }), { stamp: this.ingestGeneration.get(m.messageId), capture: { ...snap, purgeEpoch: purgeEpochAtReceipt.get(m.channelId) ?? -1 } });
+                  const work = this.tapUnifiedVoice(runtimeEntry(false, { recent: [], facts: [] }), {
+                    stamp: this.ingestGeneration.get(m.messageId),
+                    capture: { ...snap, purgeEpoch: purgeEpochAtReceipt.get(m.channelId) ?? -1 },
+                    ...voiceParent !== void 0 ? { parent: unifiedVoiceParentAt(voiceParent) } : {}
+                  });
                   this.unifiedWork.add(work);
                   void work.finally(() => this.unifiedWork.delete(work));
                 }