@securecoms/agent-bridge 0.32.0 → 0.33.1

package/dist/index.js

@@ -14687,6 +14687,18 @@ async function sendWithSelfHeal(session, channelId, build, publish) {
 // ../connect-sdk-ts/dist/groupkey/stub.js
 import { sha256 as sha2563 } from "@noble/hashes/sha2";
 
+// ../connect-sdk-ts/dist/receive/inbox.js
+function parseOpenedAt(v) {
+  if (typeof v !== "object" || v === null)
+    return void 0;
+  const o = v;
+  if (typeof o.groupId !== "string" || o.groupId.length === 0)
+    return void 0;
+  if (typeof o.epoch !== "number" || !Number.isSafeInteger(o.epoch) || o.epoch < 0)
+    return void 0;
+  return { groupId: o.groupId, epoch: o.epoch };
+}
+
 // ../connect-sdk-ts/dist/spans/names.js
 var SPAN = {
   MESSAGE_SENT: "agentvault.connect.message.sent",
@@ -17415,7 +17427,9 @@ function decodeCustodyEntry(bytes) {
   if (typeof plaintextHex !== "string" || typeof rest.queueId !== "string" || typeof rest.channelId !== "string" || typeof rest.custodiedAt !== "number") {
     throw new Error("malformed custody entry");
   }
-  return { ...rest, plaintext: hexToBytes22(plaintextHex) };
+  const { openedAt, ...others } = rest;
+  const position = parseOpenedAt(openedAt);
+  return { ...others, ...position ? { openedAt: position } : {}, plaintext: hexToBytes22(plaintextHex) };
 }
 function custodyAad(identityId, queueId) {
   return new TextEncoder().encode(`securecoms-custody-v1\0${identityId}\0${queueId}`);
@@ -17463,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}`));
@@ -18510,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);
@@ -18624,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;
@@ -20113,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
@@ -20222,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 });
       }
@@ -20235,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
@@ -20708,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))
@@ -20728,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) {
@@ -20742,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]);
@@ -20961,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) {
@@ -20979,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;
@@ -21300,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
@@ -22068,7 +22352,7 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
    * read #750 made in here is gone (ruling §8.2).
    */
   async trySupersede(channelId, row, callerHeldGroupId, owner, mode, pullRows) {
-    const refuse = (msg) => {
+    const refuse2 = (msg) => {
       this.recordDecryptError(row, new Error(msg));
       const now = Date.now();
       for (const [k, v] of this.supersedeRefusals) {
@@ -22101,34 +22385,34 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       att = await this.o.backend.fetchResetAttestation(row.group_id);
     }
     if (!att) {
-      return refuse(`supersede refused: no attestation for group ${row.group_id}`);
+      return refuse2(`supersede refused: no attestation for group ${row.group_id}`);
     }
     if (att.signerIdentityId !== owner.identityId) {
-      return refuse("supersede refused: signer is not the pinned owner");
+      return refuse2("supersede refused: signer is not the pinned owner");
     }
     let content;
     try {
       content = JSON.parse(att.signedContent);
     } catch {
-      return refuse("supersede refused: unparseable signed_content");
+      return refuse2("supersede refused: unparseable signed_content");
     }
     if (content.channel_id !== row.connect_channel_id || content.new_group_id !== row.group_id) {
-      return refuse("supersede refused: attestation channel/group mismatch");
+      return refuse2("supersede refused: attestation channel/group mismatch");
     }
     if (content.purpose !== RESET_SUPERSEDE_PURPOSE) {
-      return refuse("supersede refused: attestation purpose is not connect-reset-supersede");
+      return refuse2("supersede refused: attestation purpose is not connect-reset-supersede");
     }
     const targetCreatedMs = signedCreatedAtMs(content);
     if (targetCreatedMs === null) {
-      return refuse("supersede refused: unparseable attestation created_at");
+      return refuse2("supersede refused: unparseable attestation created_at");
     }
     const targetPrev = signedPrevLink(content, row.group_id);
     if (targetPrev === null) {
-      return refuse("supersede refused: unparseable attestation prev_group_id");
+      return refuse2("supersede refused: unparseable attestation prev_group_id");
     }
     const ok = await verifyApprovalArtifact({ content, signature: att.signatureHex, signerPublicKey: owner.publicKeyHex, createdAt: "", version: 1 }, owner.publicKeyHex);
     if (!ok) {
-      return refuse("supersede refused: signature does not verify against pinned owner key");
+      return refuse2("supersede refused: signature does not verify against pinned owner key");
     }
     const targetLink = targetPrev.chained ? { createdAtMs: targetCreatedMs, chained: true, prevGroupId: targetPrev.prev } : { createdAtMs: targetCreatedMs, chained: false, prevGroupId: null };
     if (callerHeldGroupId !== null && callerHeldGroupId !== row.group_id) {
@@ -22138,7 +22422,7 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
       if (v.kind === "refuse") {
         if (v.notNewer)
           this.supersedeNotNewer.add(`${channelId}:${row.group_id}`);
-        return refuse(v.reason);
+        return refuse2(v.reason);
       }
     }
     const bundle = await this.o.store.loadPendingBundle(this.o.deviceId);
@@ -22146,7 +22430,7 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
     if (!bundle && !supersedeSlot) {
       if (mode === "adopt")
         return { kind: "no_bundle" };
-      return refuse("supersede refused: no pending KeyPackage bundle to open the new Welcome");
+      return refuse2("supersede refused: no pending KeyPackage bundle to open the new Welcome");
     }
     return await this.locks.run(channelId, async () => {
       let inLockHeld;
@@ -22193,7 +22477,7 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
         return { kind: "unopenable", requested };
       }
       if (new TextDecoder().decode(mgr.groupId) !== row.group_id) {
-        return refuse("supersede refused: post-join group id != attested new_group_id");
+        return refuse2("supersede refused: post-join group id != attested new_group_id");
       }
       let dead = null;
       try {
@@ -23120,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;
   }
   /**
@@ -23318,15 +23605,20 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
         done();
       };
     };
+    const fromManager = async (mgr) => {
+      const openedAt = { groupId: new TextDecoder().decode(mgr.groupId), epoch: Number(mgr.epoch) };
+      const key = await mgr.exportSecret(LABEL, buildExporterContext(envelope.enclave_id, envelope.channel_id, envelope.mls_group_epoch), 32);
+      return { key, openedAt };
+    };
     const derive = keyFrom ? () => {
       takeInFlight();
-      return keyFrom.exportSecret(LABEL, buildExporterContext(envelope.enclave_id, envelope.channel_id, envelope.mls_group_epoch), 32);
-    } : () => {
+      return fromManager(keyFrom);
+    } : async () => {
       takeInFlight();
-      return this.exporterKeyUnfenced(envelope.enclave_id, envelope.channel_id, envelope.mls_group_epoch);
+      return fromManager(await this.manager(envelope.channel_id));
     };
     try {
-      const key = opts.lockHeld ? await derive() : await this.locks.run(envelope.channel_id, derive);
+      const { key, openedAt } = opts.lockHeld ? await derive() : await this.locks.run(envelope.channel_id, derive);
       const aad = await buildAssociatedData({
         message_id: envelope.message_id,
         channel_id: envelope.channel_id,
@@ -23350,7 +23642,8 @@ var MlsGroupKeyProvider = class _MlsGroupKeyProvider {
         voiceMode: row.voice_mode ?? void 0,
         voiceDefaultResponder: row.voice_default_responder ?? void 0,
         ...typeof row.identity_signature === "string" && row.identity_signature ? { identitySignature: row.identity_signature } : {},
-        payloadHex: row.payload
+        payloadHex: row.payload,
+        openedAt
       };
       const custodiedAt = this.nowMs();
       this.custody.set(row.queue_id, entry);
@@ -24905,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 {
@@ -25149,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) => {
@@ -25158,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 {
@@ -25208,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();
@@ -25292,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);
@@ -25341,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")}`;
@@ -25350,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,
@@ -25487,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({
@@ -25509,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);
@@ -25532,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++,
@@ -25592,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";
   }
@@ -26084,6 +26565,7 @@ function openSchema(db) {
   ensureToolGrantTables(db);
   ensureToolGrantAppliedTable(db);
   ensureRoomSearchCapTable(db);
+  ensureVoiceChannelParentTable(db);
   db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
 }
 function ensureMlsCustody(db) {
@@ -26269,6 +26751,16 @@ function ensureToolGrantAppliedTable(db) {
     );
   `);
 }
+function ensureVoiceChannelParentTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS voice_channel_parent (
+      identity_id       TEXT NOT NULL,
+      voice_channel_id  TEXT NOT NULL,
+      parent_channel_id TEXT NOT NULL,
+      PRIMARY KEY (identity_id, voice_channel_id)
+    );
+  `);
+}
 function ensureRoomSearchCapTable(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS room_search_cap (
@@ -26960,6 +27452,21 @@ var SqliteMlsStateStore = class _SqliteMlsStateStore {
        VALUES (?,?,?,?)
        ON CONFLICT(identity_id, channel_id) DO UPDATE SET is_dm=excluded.is_dm, updated_at=excluded.updated_at`).run(this.id, channelId, isDm ? 1 : 0, Date.now());
   }
+  /** ADR-0024 Task 20 (final review I-1): records V -> P once; a later, different parent is ignored (immutable link). */
+  recordVoiceChannelParent(voiceChannelId, parentChannelId) {
+    this.db.prepare(`INSERT INTO voice_channel_parent (identity_id, voice_channel_id, parent_channel_id) VALUES (?,?,?)
+       ON CONFLICT(identity_id, voice_channel_id) DO NOTHING`).run(this.id, voiceChannelId, parentChannelId);
+  }
+  /** The recorded parent of a voice channel, if any. */
+  voiceChannelParent(voiceChannelId) {
+    const row = this.db.prepare("SELECT parent_channel_id FROM voice_channel_parent WHERE identity_id=? AND voice_channel_id=?").get(this.id, voiceChannelId);
+    return row?.parent_channel_id;
+  }
+  /** Every recorded voice channel of a parent conversation. */
+  voiceChannelsOf(parentChannelId) {
+    const rows = this.db.prepare("SELECT voice_channel_id FROM voice_channel_parent WHERE identity_id=? AND parent_channel_id=?").all(this.id, parentChannelId);
+    return rows.map((r) => r.voice_channel_id);
+  }
   getChannelMeta(channelId) {
     const row = this.db.prepare("SELECT enclave_id, is_dm FROM channel_meta WHERE identity_id=? AND channel_id=?").get(this.id, channelId);
     if (!row)
@@ -31783,7 +32290,7 @@ var EmbedderClient = class {
           resolve(ok);
         }
       }
-      const refuse = (reason) => {
+      const refuse2 = (reason) => {
         s.destroy();
         if (!settled) {
           this.fail(reason);
@@ -31802,22 +32309,22 @@ var EmbedderClient = class {
               return;
             }
             const f2 = this.chan.open(line);
-            if (!f2) return refuse("embedder_unavailable");
+            if (!f2) return refuse2("embedder_unavailable");
             this.onFrame(f2);
             return;
           }
           const f = JSON.parse(line);
-          if (!f || typeof f !== "object") return refuse("embedder_unavailable");
+          if (!f || typeof f !== "object") return refuse2("embedder_unavailable");
           if (!ns) {
-            if (f.t !== "challenge" || f.protocol !== EMBEDDER_PROTOCOL || typeof f.ns !== "string" || !/^[0-9a-f]{32}$/.test(f.ns)) return refuse(f.t === "challenge" ? "embedder_mismatch" : "embedder_unavailable");
+            if (f.t !== "challenge" || f.protocol !== EMBEDDER_PROTOCOL || typeof f.ns !== "string" || !/^[0-9a-f]{32}$/.test(f.ns)) return refuse2(f.t === "challenge" ? "embedder_mismatch" : "embedder_unavailable");
             ns = f.ns;
             s.write(JSON.stringify({ t: "hello", nc, mac_c: macClient(token, ns, nc) }) + "\n");
             return;
           }
-          if (f.t !== "hello" || typeof f.mac_s !== "string" || !macEqual(f.mac_s, macServer(token, ns, nc))) return refuse("embedder_unavailable");
+          if (f.t !== "hello" || typeof f.mac_s !== "string" || !macEqual(f.mac_s, macServer(token, ns, nc))) return refuse2("embedder_unavailable");
           const model = this.m.files.find((x) => x.name === "model.onnx");
           const ok = f.protocol === EMBEDDER_PROTOCOL && f.model_id === this.m.modelId && f.model_sha256 === model.sha256 && f.wasm_sha256 === this.m.wasmSha256 && f.dims === this.m.dims;
-          if (!ok) return refuse("embedder_mismatch");
+          if (!ok) return refuse2("embedder_mismatch");
           if (this.closed) {
             s.destroy();
             return done(true);
@@ -31835,9 +32342,9 @@ var EmbedderClient = class {
           this.settleReady(true);
           done(true);
         } catch {
-          refuse("embedder_unavailable");
+          refuse2("embedder_unavailable");
         }
-      }, () => refuse("embedder_unavailable")));
+      }, () => refuse2("embedder_unavailable")));
     });
   }
   onFrame(f) {
@@ -35175,6 +35682,213 @@ function roomIsCrossOrg(rows) {
   return unknown ? null : false;
 }
 
+// src/voice-channel-binding.ts
+var BOUND = Object.freeze({ bound: true });
+var refuse = (reason) => ({ bound: false, reason });
+function evaluateVoiceBinding(v, p, isVRelay) {
+  if (v.ownLeafIndex === null || v.leaves.length === 0) return refuse("v_not_held");
+  if (p.ownLeafIndex === null || p.leaves.length === 0) return refuse("p_not_held");
+  if (v.leaves.some((l) => !l.basic || l.identity === null)) return refuse("non_basic_leaf");
+  const pIds = /* @__PURE__ */ new Set();
+  for (const l of p.leaves) if (l.basic && l.identity !== null) pIds.add(l.identity);
+  const nonParent = /* @__PURE__ */ new Set();
+  for (const l of v.leaves) if (!pIds.has(l.identity)) nonParent.add(l.identity);
+  if (nonParent.size > 1) return refuse("two_non_parent");
+  if (isVRelay === void 0) return nonParent.size === 0 ? BOUND : refuse("relay_unknown");
+  const relays = vRelayIdentities(v, isVRelay);
+  if (relays.size > 1) return refuse("two_relays");
+  const [relay] = relays;
+  for (const id of nonParent) if (id !== relay) return refuse("foreign_leaf");
+  return BOUND;
+}
+function vRelayIdentities(v, isVRelay) {
+  const relays = /* @__PURE__ */ new Set();
+  for (const l of v.leaves) if (l.basic && l.identity !== null && isVRelay(l.identity)) relays.add(l.identity);
+  return relays;
+}
+function voiceRelayIdentity(v, isVRelay) {
+  if (isVRelay === void 0) return void 0;
+  const relays = vRelayIdentities(v, isVRelay);
+  return relays.size === 1 ? [...relays][0] : void 0;
+}
+function parseVoiceResolution(channelId, status, body) {
+  if (status === 404) return { kind: "absent" };
+  if (status !== 200) return { kind: "error" };
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return { kind: "error" };
+  const b = body;
+  if (b.channel_id !== channelId || typeof b.channel_kind !== "string") return { kind: "error" };
+  if (b.channel_kind !== "voice") return { kind: "not_voice" };
+  const parent3 = b.parent_channel_id;
+  if (typeof parent3 !== "string" || parent3.length === 0 || parent3 === channelId) return { kind: "error" };
+  return { kind: "voice", parentChannelId: parent3 };
+}
+var VOICE_RESOLVE_RETRY_BASE_MS = 3e4;
+var VOICE_RESOLVE_RETRY_MAX_MS = 10 * 6e4;
+var VOICE_RESOLVE_ABSENT_HELD_MAX_MS = 6e4;
+var VOICE_RECEIPT_CAP = 1e4;
+var VOICE_RECEIPT_MAX_AGE_MS = 15 * 6e4;
+function voiceParentStamp(p) {
+  return JSON.stringify([p.groupId, p.epoch]);
+}
+var VoiceChannelRegistry = class {
+  parents = /* @__PURE__ */ new Map();
+  notVoice = /* @__PURE__ */ new Set();
+  failures = /* @__PURE__ */ new Map();
+  bindings = /* @__PURE__ */ new Map();
+  generations = /* @__PURE__ */ new Map();
+  /** Fix I-1 / Task 20 R1: message id -> P's held position before the batch that first received it; null = not knowable. */
+  receipts = /* @__PURE__ */ new Map();
+  /** Final review M-d: arrivals not recorded because the map was full of young records. */
+  capReached = 0;
+  /** True when a lookup should run now: never once resolved; after a failure, only past its back-off. */
+  resolveDue(channelId, now, opts = {}) {
+    if (this.parents.has(channelId) || this.notVoice.has(channelId)) return false;
+    const f = this.failures.get(channelId);
+    if (f === void 0) return true;
+    let wait = Math.min(VOICE_RESOLVE_RETRY_MAX_MS, VOICE_RESOLVE_RETRY_BASE_MS * 2 ** Math.min(f.attempts - 1, 20));
+    if (f.kind === "absent" && opts.heldGroup === true) wait = Math.min(wait, VOICE_RESOLVE_ABSENT_HELD_MAX_MS);
+    return now - f.at >= wait;
+  }
+  record(channelId, r, now) {
+    if (r.kind === "voice") {
+      this.parents.set(channelId, r.parentChannelId);
+      this.failures.delete(channelId);
+    } else if (r.kind === "not_voice") {
+      this.notVoice.add(channelId);
+      this.failures.delete(channelId);
+    } else {
+      const prev = this.failures.get(channelId);
+      this.failures.set(channelId, { at: now, attempts: (prev?.attempts ?? 0) + 1, kind: r.kind });
+    }
+  }
+  /** True once get_channel has answered for this channel (voice or not). */
+  isResolved(channelId) {
+    return this.parents.has(channelId) || this.notVoice.has(channelId);
+  }
+  /** Final review M-a: true once get_channel answered this channel's own row with a kind other than voice. */
+  isNotVoice(channelId) {
+    return this.notVoice.has(channelId);
+  }
+  /** Final review (R∈P): bound Vs whose admitted R is also a P leaf (the pre-stamp shape; a sunset signal). */
+  relayInParentCount() {
+    let n = 0;
+    for (const [v, e] of this.bindings) {
+      if (this.parents.has(v) && e.verdict.bound && e.relay !== void 0 && e.parentMembers?.has(e.relay) === true) n++;
+    }
+    return n;
+  }
+  /** True for a resolved V, bound or not. */
+  isVoice(channelId) {
+    return this.parents.has(channelId);
+  }
+  /** P of a resolved V, bound or not; undefined otherwise. Never use this to route: see {@link boundParentOf}. */
+  parentOf(channelId) {
+    return this.parents.get(channelId);
+  }
+  /** Every resolved V with its P. */
+  voiceChannels() {
+    return [...this.parents.entries()];
+  }
+  /** The gate for a channel the bridge's listing has never classified (`unlisted`), or for a resolved V. */
+  gate(channelId, unlisted) {
+    if (this.parents.has(channelId)) return "drop";
+    if (!unlisted || this.notVoice.has(channelId)) return "normal";
+    return this.failures.get(channelId)?.kind === "absent" ? "drop" : "hold";
+  }
+  bindingKey(channelId) {
+    return this.bindings.get(channelId)?.key;
+  }
+  setBinding(channelId, key, verdict, positions = null, admitted = {}) {
+    this.bindings.set(channelId, { key, positions, verdict, ...admitted });
+  }
+  /** Fix M-1: each evaluation of a V takes a generation; only the newest started may store its verdict. */
+  beginEvaluation(channelId) {
+    const g = (this.generations.get(channelId) ?? 0) + 1;
+    this.generations.set(channelId, g);
+    return g;
+  }
+  isLatestEvaluation(channelId, generation) {
+    return this.generations.get(channelId) === generation;
+  }
+  /**
+   * Fix I-1: records a frame's receipt stamp the FIRST time it is seen; a re-served frame keeps its first record.
+   * Task 20 R2: at the cap nothing is evicted and the new arrival is not recorded (refused: no record, no parent).
+   */
+  noteReceipt(messageId, pStamp, now = Date.now()) {
+    if (this.receipts.has(messageId)) return;
+    if (this.receipts.size >= VOICE_RECEIPT_CAP) {
+      for (const [id, r] of this.receipts) if (now - r.at > VOICE_RECEIPT_MAX_AGE_MS) this.receipts.delete(id);
+      if (this.receipts.size >= VOICE_RECEIPT_CAP) {
+        this.capReached++;
+        return;
+      }
+    }
+    this.receipts.set(messageId, { stamp: pStamp, at: now });
+  }
+  /** Final review M-d: arrivals refused because the receipt map was full (a number only). */
+  receiptCapReached() {
+    return this.capReached;
+  }
+  /** Test visibility: receipt records held. */
+  receiptCount() {
+    return this.receipts.size;
+  }
+  forgetReceipt(messageId) {
+    this.receipts.delete(messageId);
+  }
+  /**
+   * Fix I-1: P for one frame on V only when V is bound now AND both groups' held positions are exactly those at the
+   * frame's receipt. A frame received at other positions (or with none recorded) gets undefined: dropped, never held.
+   */
+  boundParentForFrame(channelId, messageId, openedAt) {
+    return this.frameContext(channelId, messageId, openedAt)?.parent;
+  }
+  /**
+   * Task 20: the per-frame verdict with what the accept filter needs. Bound now AND the frame's pre-batch P stamp equals
+   * the verdict's P position AND (R1) the frame's own opening position equals the verdict's V position. A frame with
+   * no record, a null record, or no `openedAt` is refused.
+   */
+  frameContext(channelId, messageId, openedAt) {
+    const parent3 = this.boundParentOf(channelId);
+    if (parent3 === void 0) return void 0;
+    const entry = this.bindings.get(channelId);
+    const at = this.receipts.get(messageId)?.stamp;
+    if (entry?.positions == null || typeof at !== "string" || at !== entry.positions.p) return void 0;
+    const v = entry.positions.v;
+    if (v === null || openedAt == null || openedAt.groupId !== v.groupId || openedAt.epoch !== v.epoch) return void 0;
+    return { parent: parent3, relay: entry.relay, parentMembers: entry.parentMembers ?? /* @__PURE__ */ new Set() };
+  }
+  /** The current verdict, or undefined when never evaluated. */
+  binding(channelId) {
+    return this.bindings.get(channelId)?.verdict;
+  }
+  /** P only while V is a resolved V whose last verdict is bound; undefined otherwise. */
+  boundParentOf(channelId) {
+    const parent3 = this.parents.get(channelId);
+    return parent3 !== void 0 && this.bindings.get(channelId)?.verdict.bound === true ? parent3 : void 0;
+  }
+};
+
+// src/voice-channel-frame.ts
+function classifyVoiceFrame(f) {
+  if (f.senderId === f.ownIdentityId) return "drop";
+  const fromRelay = f.relay !== void 0 && f.senderId === f.relay;
+  const fromMember = f.parentMembers.has(f.senderId);
+  if (!fromRelay && !fromMember) return "drop";
+  let body;
+  try {
+    body = JSON.parse(new TextDecoder().decode(f.plaintext));
+  } catch {
+    return "drop";
+  }
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return "drop";
+  const b = body;
+  if (b.type === "call_transcript") return "call_transcript";
+  if (b.type !== void 0 && b.type !== "text" || typeof b.text !== "string") return "drop";
+  if (fromRelay) return "relay_turn";
+  return b.text.trim() === VOICE_CALL_START_MARKER ? "greeting" : "drop";
+}
+
 // src/grants/owner-turn.ts
 import { ed25519 as ed255196 } from "@noble/curves/ed25519";
 var HEX = /^(?:[0-9a-fA-F]{2})+$/;
@@ -35270,6 +35984,7 @@ var OWNER_DM_DEFAULT_READ_GRANTS = Object.freeze([
 var ROOM_DEFAULT_READ_GRANTS = Object.freeze([
   Object.freeze({ tool: "current_time", mode: "read" })
 ]);
+var BRIDGE_CAPABILITIES = Object.freeze(["voice_channel_v1"]);
 var RELAYED_VOICE_GRANTS = Object.freeze([
   Object.freeze({ tool: "current_time", mode: "read" }),
   Object.freeze({ tool: "web_search", mode: "read" })
@@ -35544,12 +36259,19 @@ var RoomClassChangedSendError = class extends SendForbiddenError {
     this.message = `reply dropped for channel ${channelId}: the room changed after its tools were granted; no retry`;
   }
 };
+function voiceVerdictPositions(v, p) {
+  return {
+    v: v.groupId !== null && v.epoch !== null ? { groupId: v.groupId, epoch: v.epoch } : null,
+    p: voiceParentStamp(p)
+  };
+}
 function rosterFreshAt(entry, heldEpoch, heldGroupId) {
   return entry !== void 0 && typeof heldEpoch === "number" && entry.epoch === heldEpoch && typeof heldGroupId === "string" && entry.groupId === heldGroupId;
 }
 var RoomGrantEpochMovedError = class extends Error {
 };
 var ROOM_GRANT_TRACK_MAX = 4096;
+var VOICE_FRAME_PARENT_MAX = 4096;
 var SessionSupersededError = class extends Error {
   constructor() {
     super("session_superseded: another copy of this agent took its session during start()");
@@ -35981,6 +36703,13 @@ var BridgeAgent = class _BridgeAgent {
   supersedeRefundable = /* @__PURE__ */ new Set();
   /** M-1: channels this process has used as a FileSafe vault channel. */
   vaultChannelIds = /* @__PURE__ */ new Set();
+  /**
+   * ADR-0024 step 2a Task 19 (spec §9): hidden voice channels V resolved to their conversation P, lookup back-off, and
+   * each V's binding verdict. In memory only: a restart re-resolves (one get_channel per V) and re-evaluates.
+   */
+  voiceChannels = new VoiceChannelRegistry();
+  /** Fix M-3: channels a listing row marked channel_kind "voice"; never recorded as listed. */
+  listedAsVoice = /* @__PURE__ */ new Set();
   /** Phase 3 F3: consecutive agent turns per channel. */
   agentHops = new AgentHopTracker();
   maxAgentHops;
@@ -36011,6 +36740,12 @@ var BridgeAgent = class _BridgeAgent {
    * counter is incremented. Surfaced on health()/metrics().
    */
   failedAttachments = 0;
+  /** Task 20 R4: V frames dropped by the per-frame verdict (not bound, or not at the verdict's positions). A number only. */
+  voiceFramesRefused = 0;
+  /** Task 20: frames on a bound V the accept filter dropped (not R's voice frame, a greeting marker or a transcript). */
+  voiceFramesFiltered = 0;
+  /** Task 20: message id of an admitted V frame -> its P (B.8 keys). Bounded; an entry lives one ingest cycle in practice. */
+  voiceFrameParent = /* @__PURE__ */ new Map();
   /** Files link: vault_ref bodies refused by R1 (strict parse) or R2 (enclave binding). */
   refusedVaultRefs = 0;
   /**
@@ -36424,7 +37159,9 @@ var BridgeAgent = class _BridgeAgent {
     // Fix round MEDIUM 2: a channel this process used as a FileSafe vault
     // channel is never swept (the sweeper also refuses any channel no listing
     // has shown, which covers a vault channel after a restart).
-    conversations: () => this.store.memoryConversationIds().filter((c) => !this.vaultChannelIds.has(c)),
+    // Task 20 final review I-1: a voice channel V is never listed, so it is swept as its parent P: V is present exactly
+    // when P is, and purgeConversation(P) purges every V of P. P is swept even when only its V holds memory.
+    conversations: () => [...new Set(this.store.memoryConversationIds().filter((c) => !this.vaultChannelIds.has(c)).map((c) => this.store.voiceChannelParent(c) ?? c))],
     enclaveOf: (c) => this.store.getChannelMeta(c)?.enclaveId,
     // Audit r1 M6: the persisted flag, never the channelOwner cache. Set only
     // from a listing, so undefined means no listing has ever shown the channel.
@@ -36844,6 +37581,8 @@ var BridgeAgent = class _BridgeAgent {
       // the actual protected-memory adapter. It is an enum, never a path or
       // provider credential.
       memory_provider: this.cfg.memoryProvider ?? "securecoms",
+      // Spec §2 (Task 18): the per-device capability declaration; a fixed enum list, one body for every report path.
+      capabilities: [...BRIDGE_CAPABILITIES],
       // Spec §11.1-11.2 (OQ-E): flat keys; the string `memory` above is
       // unchanged. memory_notes is true only when notes are actually on (the
       // provider is securecoms and the parsed payload.memory keeps them on);
@@ -38091,6 +38830,7 @@ var BridgeAgent = class _BridgeAgent {
    * across a supersede), and the group must not move around the reads.
    */
   async reclassifyForReply(channelId, grant) {
+    if (this.voiceChannels.isVoice(channelId)) return false;
     const startedAt = Date.now();
     await this.refreshChannelRoster(channelId);
     const held = await this.heldPosition(channelId);
@@ -38107,8 +38847,9 @@ var BridgeAgent = class _BridgeAgent {
       this.enforceRateFloor("a2a", channelId);
       return;
     }
-    const meta = this.freshMeta(channelId);
-    if (meta && !meta.is_dm) this.enforceRateFloor("room", channelId);
+    const capChannel = this.capChannelFor(channelId);
+    const meta = this.freshMeta(capChannel);
+    if (meta && !meta.is_dm) this.enforceRateFloor("room", capChannel);
   }
   /** Bookkeeping after a CONFIRMED publish of `body` under `id`. */
   afterPublish(channelId, body, id, opts, purgeEpoch, replyCapture) {
@@ -38590,8 +39331,289 @@ var BridgeAgent = class _BridgeAgent {
       return probeResultFor("threw");
     }
   }
+  // ── ADR-0024 step 2a Task 19: the hidden voice channel V (spec §9, B.8) ──────
+  //
+  // The rule and the cache live in voice-channel-binding.ts; this is the wiring: the get_channel lookup, the bridge's
+  // own held ratchet trees and positions, V's member list (is_relay only), and the receive-cycle gate.
+  /**
+   * Task 20's accessor: P's channel id ONLY while V is bound under the spec §9 rule at both groups' held positions as
+   * of the last evaluation (every receive cycle, before any frame is processed; or {@link voiceParentNow}); undefined
+   * for an unbound or refused V, and for any channel that is not a resolved V.
+   */
+  voiceParentOf(channelId) {
+    return this.voiceChannels.boundParentOf(channelId);
+  }
+  /** True for a channel resolved as a V, bound or not. Such a channel is never processed as a normal channel. */
+  isKnownVoiceChannel(channelId) {
+    return this.voiceChannels.isVoice(channelId);
+  }
+  /** Re-evaluates one V at the held positions now, then answers as {@link voiceParentOf}. */
+  async voiceParentNow(channelId) {
+    const parent3 = this.voiceChannels.parentOf(channelId);
+    if (parent3 === void 0) return void 0;
+    await this.reevaluateVoiceBinding(channelId, parent3);
+    return this.voiceChannels.boundParentOf(channelId);
+  }
+  /** A channel no listing has ever classified (in memory or persisted). V is hidden from the listing, so it is one. */
+  isUnlistedChannel(channelId) {
+    return this.channelMeta.get(channelId) === void 0 && this.store.getChannelMeta(channelId)?.isDm === void 0;
+  }
+  voiceChannelGate(channelId) {
+    if (this.vaultChannelIds.has(channelId)) return "normal";
+    return this.voiceChannels.gate(channelId, this.isUnlistedChannel(channelId));
+  }
+  /**
+   * Looks up one channel with get_channel (the voice arm, OQ-5 (a)). Only the classification is kept. Never throws; a
+   * failure is recorded and retried (30 s doubling to 10 min). Called only from {@link resolveUnlistedChannels}, which
+   * selects unlisted channels whose back-off allows.
+   */
+  async resolveVoiceChannel(channelId) {
+    let status = "threw";
+    let body;
+    try {
+      const url = `${this.cfg.apiBase}/api/v1/channels/${encodeURIComponent(channelId)}?caller_identity_id=${encodeURIComponent(this.cfg.identityId)}`;
+      const res = await this.fetchBounded("get_channel", "read", url, { headers: { authorization: `Bearer ${this.cfg.apiKey}` } });
+      if (res.ok) {
+        body = await res.json();
+      } else {
+        try {
+          await res.body?.cancel();
+        } catch {
+        }
+      }
+      status = res.status;
+    } catch {
+      status = "threw";
+    }
+    const r = parseVoiceResolution(channelId, status, body);
+    this.voiceChannels.record(channelId, r, Date.now());
+    if (r.kind === "voice") {
+      try {
+        this.store.recordVoiceChannelParent(channelId, r.parentChannelId);
+      } catch {
+      }
+    }
+    if (r.kind === "voice") writeServiceLog2("info", "voice.channel_lookup", { result: ServiceLogEnum.of("voice", ["voice", "absent", "error"]) });
+    else if (r.kind !== "not_voice") writeServiceLog2("warn", "voice.channel_lookup", { result: ServiceLogEnum.of(r.kind, ["voice", "absent", "error"]) });
+  }
+  /**
+   * Looks up every unlisted channel among `channelIds` whose back-off allows. A channel is "unlisted" only after this
+   * cycle's listing: if any candidate remains and the cycle has not listed yet, one listing runs first, so a channel
+   * that is merely new (listed, not yet cached) is never looked up. Returns true when it ran that listing.
+   */
+  async resolveUnlistedChannels(channelIds, listed) {
+    const ids = [...new Set(channelIds)].filter((c) => !this.vaultChannelIds.has(c));
+    const held = /* @__PURE__ */ new Set();
+    for (const c of ids) {
+      if (!this.isUnlistedChannel(c) || this.voiceChannels.isResolved(c)) continue;
+      try {
+        if ((await this.heldPosition(c)).groupId !== null) held.add(c);
+      } catch {
+      }
+    }
+    const due = () => ids.filter((c) => this.isUnlistedChannel(c) && this.voiceChannels.resolveDue(c, Date.now(), { heldGroup: held.has(c) }));
+    let candidates = due();
+    if (candidates.length === 0) return false;
+    let ran = false;
+    if (!listed) {
+      await this.refreshChannelMeta();
+      ran = true;
+      candidates = due();
+    }
+    for (const c of candidates) await this.resolveVoiceChannel(c);
+    return ran;
+  }
+  /** Final review M-c: V -> consecutive failed member-list reads for the binding, and when the last one ran. */
+  voiceRosterRetry = /* @__PURE__ */ new Map();
+  /** The first retry after a failure is immediate (next cycle); then 30 s, doubling, capped at 10 min. */
+  voiceRosterRetryDue(v) {
+    const f = this.voiceRosterRetry.get(v);
+    if (f === void 0 || f.attempts <= 1) return true;
+    const wait = Math.min(VOICE_RESOLVE_RETRY_MAX_MS, VOICE_RESOLVE_RETRY_BASE_MS * 2 ** Math.min(f.attempts - 2, 20));
+    return Date.now() - f.at >= wait;
+  }
+  noteVoiceRosterRead(v, ok) {
+    if (ok) {
+      this.voiceRosterRetry.delete(v);
+      return;
+    }
+    this.voiceRosterRetry.set(v, { at: Date.now(), attempts: (this.voiceRosterRetry.get(v)?.attempts ?? 0) + 1 });
+  }
+  /** Every resolved V, re-evaluated where a position or a roster moved. */
+  async reevaluateVoiceBindings() {
+    for (const [v, p] of this.voiceChannels.voiceChannels()) await this.reevaluateVoiceBinding(v, p);
+  }
+  /**
+   * The spec §9 binding rule over the bridge's OWN ratchet trees (never a server list of leaves), keyed by both
+   * groups' held (group, epoch) and both rosters' fetch times: a change in any of them re-evaluates. V's member list
+   * is read only for `is_relay`, and only when it is fresh at V's held position. Fail closed: a tree that moved while
+   * it was read, or any exception, leaves V unbound and is re-evaluated next time.
+   */
+  async reevaluateVoiceBinding(v, p) {
+    const generation = this.voiceChannels.beginEvaluation(v);
+    try {
+      const vPos = await this.heldPosition(v);
+      const pPos = await this.heldPosition(p);
+      const positions = voiceVerdictPositions(vPos, pPos);
+      const parentNotConversation = this.voiceChannels.isVoice(p) || this.isUnlistedChannel(p);
+      const keyOf = () => JSON.stringify([positions, this.freshRosterEntry(v)?.at ?? null, this.freshRosterEntry(p)?.at ?? null, parentNotConversation]);
+      if (this.voiceChannels.bindingKey(v) === keyOf()) return;
+      if (parentNotConversation) {
+        if (this.voiceChannels.isLatestEvaluation(v, generation)) this.noteVoiceBinding(v, keyOf(), { bound: false, reason: "parent_not_conversation" }, positions);
+        return;
+      }
+      const vTree = await this.provider.leafTreeSummary(v);
+      const pTree = await this.provider.leafTreeSummary(p);
+      const relayCheck = () => {
+        const entry = this.freshRosterEntry(v);
+        return entry !== void 0 && rosterFreshAt(entry, vPos.epoch, vPos.groupId) ? (id) => entry.members.get(id)?.is_relay === true : void 0;
+      };
+      if (relayCheck() === void 0 && this.voiceRosterRetryDue(v)) {
+        await this.refreshChannelRoster(v);
+        this.noteVoiceRosterRead(v, relayCheck() !== void 0);
+      }
+      const isVRelay = relayCheck();
+      let verdict = evaluateVoiceBinding(vTree, pTree, isVRelay);
+      const vAfter = await this.heldPosition(v);
+      const pAfter = await this.heldPosition(p);
+      const moved = vAfter.groupId !== vPos.groupId || vAfter.epoch !== vPos.epoch || pAfter.groupId !== pPos.groupId || pAfter.epoch !== pPos.epoch;
+      if (moved) verdict = { bound: false, reason: "moved" };
+      const retry = !verdict.bound && (verdict.reason === "relay_unknown" || verdict.reason === "moved") || verdict.bound && isVRelay === void 0;
+      if (!this.voiceChannels.isLatestEvaluation(v, generation)) return;
+      const parentMembers = /* @__PURE__ */ new Set();
+      for (const l of pTree.leaves) if (l.basic && l.identity !== null) parentMembers.add(l.identity);
+      this.noteVoiceBinding(v, retry ? "" : keyOf(), verdict, positions, void 0, {
+        relay: verdict.bound ? voiceRelayIdentity(vTree, isVRelay) : void 0,
+        parentMembers
+      });
+    } catch (e) {
+      if (this.voiceChannels.isLatestEvaluation(v, generation)) this.noteVoiceBinding(v, "", { bound: false, reason: "moved" }, null, e);
+    }
+  }
+  /**
+   * Fix I-1 / Task 20 R1: P's held position for every resolved V, read before a receive so frames can be stamped. V's
+   * half is not stamped here: each frame carries the epoch that opened it (`openedAt`).
+   */
+  async voicePositionSnapshot() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [v, p] of this.voiceChannels.voiceChannels()) {
+      try {
+        out.set(v, voiceParentStamp(await this.heldPosition(p)));
+      } catch {
+      }
+    }
+    return out;
+  }
+  /**
+   * Fix I-1, for Task 20: P for ONE frame on V, only when V is bound now AND neither P's nor V's held (group, epoch)
+   * moved between that frame's first receipt and the verdict. Otherwise undefined: the frame is dropped (acked, never
+   * held, never processed). A frame first received before V was resolved has no receipt positions and is refused.
+   */
+  voiceParentForFrame(channelId, messageId, openedAt) {
+    return this.voiceChannels.boundParentForFrame(channelId, messageId, openedAt);
+  }
+  /** Stores a verdict; a change of verdict logs one content-free line. */
+  noteVoiceBinding(v, key, verdict, positions, error, admitted = {}) {
+    const prev = this.voiceChannels.binding(v);
+    this.voiceChannels.setBinding(v, key, verdict, positions, admitted);
+    const state = verdict.bound ? "bound" : verdict.reason;
+    const prevState = prev === void 0 ? void 0 : prev.bound ? "bound" : prev.reason;
+    if (state === prevState && error === void 0) return;
+    writeServiceLog2(verdict.bound ? "info" : "warn", "voice.channel_binding", {
+      state: ServiceLogEnum.of(state, ["bound", "v_not_held", "p_not_held", "non_basic_leaf", "foreign_leaf", "two_non_parent", "two_relays", "relay_unknown", "moved", "parent_not_conversation"])
+    }, error);
+  }
+  /**
+   * The receive-cycle gate, before any per-frame work. A resolved V is never a normal channel: a frame passes only when
+   * the per-frame verdict names P (bound now, its P stamp and its own opening epoch at the verdict's positions) AND the
+   * accept filter takes it (Task 20: R's voice frame or a P member's greeting marker; a call_transcript is acked, not a
+   * turn). Every other V frame is acked unprocessed and never recorded. A channel get_channel answered 404 is acked
+   * unprocessed (fail closed). An unlisted channel whose lookup errored or has not run is held: neither processed nor
+   * acked, so it is re-served once the lookup answers. Everything else passes unchanged.
+   */
+  async gateVoiceEntries(entries) {
+    const keep = [];
+    const drop = [];
+    for (const m of entries) {
+      const gate = this.voiceChannelGate(m.channelId);
+      if (gate === "hold") continue;
+      if (gate === "normal") {
+        this.voiceChannels.forgetReceipt(m.messageId);
+        keep.push(m);
+        continue;
+      }
+      if (this.voiceChannels.isVoice(m.channelId)) {
+        const admitted = this.admitVoiceFrame(m);
+        this.voiceChannels.forgetReceipt(m.messageId);
+        if (admitted) {
+          keep.push(m);
+          continue;
+        }
+      } else {
+        this.voiceChannels.forgetReceipt(m.messageId);
+      }
+      drop.push(m.queueId);
+    }
+    if (drop.length) {
+      try {
+        await this.provider.ackDelivery(this.cfg.deviceId, drop);
+      } catch {
+      }
+    }
+    return keep;
+  }
+  /**
+   * Task 20: the per-frame verdict and the accept filter for one frame on a resolved V. True only for a model turn
+   * (R's voice frame, a P member's greeting marker), which is then keyed per B.8 through {@link voiceFrameParent}. A
+   * call_transcript is accepted but is not a turn (acked, nothing more, as step 1 on P). Counters are numbers only.
+   */
+  admitVoiceFrame(m) {
+    const parent3 = this.voiceParentForFrame(m.channelId, m.messageId, m.openedAt ?? null);
+    const ctx = parent3 === void 0 ? void 0 : this.voiceChannels.frameContext(m.channelId, m.messageId, m.openedAt ?? null);
+    if (ctx === void 0) {
+      this.voiceFramesRefused++;
+      return false;
+    }
+    const kind2 = classifyVoiceFrame({
+      senderId: m.envelope.sender_id,
+      ownIdentityId: this.cfg.identityId,
+      relay: ctx.relay,
+      parentMembers: ctx.parentMembers,
+      plaintext: m.plaintext
+    });
+    if (kind2 === "call_transcript") return false;
+    if (kind2 === "drop") {
+      this.voiceFramesFiltered++;
+      return false;
+    }
+    this.voiceFrameParent.set(m.messageId, ctx.parent);
+    if (this.voiceFrameParent.size > VOICE_FRAME_PARENT_MAX) this.voiceFrameParent.delete(this.voiceFrameParent.keys().next().value);
+    return true;
+  }
+  /**
+   * Task 20 (B.8): the key channel for metadata, audience, owner, manifest and caps. For an admitted V frame, its P;
+   * for any other frame, its own channel.
+   */
+  keyChannelForFrame(m) {
+    return this.voiceFrameParent.get(m.messageId) ?? m.channelId;
+  }
+  /**
+   * Task 20 (B.8 "per-room daily caps → P", the room rate floor): the channel a cap or floor counts against. A known V
+   * counts against its bound P; an unbound V against itself (no grant can be issued there, so nothing is widened).
+   */
+  capChannelFor(channelId) {
+    return this.voiceChannels.parentOf(channelId) ?? channelId;
+  }
+  /** Phase 3 F1 pause, for a voice channel V also read on its P (a paused agent runs no inference on the call either). */
+  pausedFor(channelId) {
+    return this.pausedChannels.has(channelId) || this.pausedChannels.has(this.capChannelFor(channelId));
+  }
   /** §5.4: one conversation's turns, facts, notes and recall, inside the memory mutex, with every in-memory copy. */
   async purgeConversation(channelId) {
+    await this.purgeOneConversation(channelId);
+    for (const v of this.store.voiceChannelsOf(channelId)) await this.purgeOneConversation(v);
+  }
+  async purgeOneConversation(channelId) {
     const scopes = this.unifiedOn ? this.store.ownerDmScopeIds().filter((s) => parseOwnerDmScopeId(s)?.channelId === channelId) : [];
     await this.notes.purgeChannel(channelId);
     for (const s of scopes) this.store.clearConversationAbsence(s);
@@ -39448,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);
@@ -39456,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,
@@ -39469,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 {
@@ -39831,17 +40873,17 @@ var BridgeAgent = class _BridgeAgent {
   async applyMemoryNote(raw, ctx) {
     if (this.unifiedOn) return this.applyUnifiedNote(raw, ctx);
     const ids = echoIds(raw);
-    const refuse = (reason, echo = ids) => {
+    const refuse2 = (reason, echo = ids) => {
       writeServiceLog2("info", "memory.note_refused", {
         reason_class: ServiceLogEnum.of(reason, ["mode", "invalid", "message", "audience", "provenance", "secret", "cap", "cleared", "store", "budget", "purged", "not_owner_words"])
       });
       return { type: "memory_note_result", ...echo, ok: false, reason };
     };
-    if (!this.notesProviderOn()) return refuse("mode");
+    if (!this.notesProviderOn()) return refuse2("mode");
     const f = parseMemoryNoteFrame(raw);
-    if (!f) return refuse("invalid");
-    if (ctx.pendingRequests.has(f.request_id)) return refuse("invalid", { message_id: f.message_id });
-    if (ctx.pendingRequests.size >= MAX_PENDING_NOTE_REQUESTS) return refuse("invalid", {});
+    if (!f) return refuse2("invalid");
+    if (ctx.pendingRequests.has(f.request_id)) return refuse2("invalid", { message_id: f.message_id });
+    if (ctx.pendingRequests.size >= MAX_PENDING_NOTE_REQUESTS) return refuse2("invalid", {});
     ctx.pendingRequests.add(f.request_id);
     try {
       const w2 = () => {
@@ -39853,13 +40895,13 @@ var BridgeAgent = class _BridgeAgent {
         return cur.record;
       };
       const rec = w2();
-      if (rec === void 0) return refuse("message");
+      if (rec === void 0) return refuse2("message");
       const channelId = rec.channel_id;
-      if (rec.authorization?.memory_write !== true) return refuse("audience");
-      if (!this.noteTurnClean(rec.message_id)) return refuse("audience");
+      if (rec.authorization?.memory_write !== true) return refuse2("audience");
+      if (!this.noteTurnClean(rec.message_id)) return refuse2("audience");
       const held = await this.heldPosition(channelId);
       const now = this.authorizationFor(channelId, rec.sender_id, void 0, held.epoch, held.groupId, { log: false });
-      if (now.memory_write !== true) return refuse("audience");
+      if (now.memory_write !== true) return refuse2("audience");
       const spend = async () => {
         const rw = await this.store.prepareRuntimeInboxRewrite(rec.message_id, bumpW9);
         if (rw === "declined") return "budget";
@@ -39875,44 +40917,44 @@ var BridgeAgent = class _BridgeAgent {
       };
       if (f.op === "forget" && typeof f.id === "object") {
         const shown = ctx.shownRecall(f.message_id, ctx.token);
-        if (!shown || !shown.has(f.id.recall)) return refuse("invalid");
+        if (!shown || !shown.has(f.id.recall)) return refuse2("invalid");
         const rw = await spend();
-        if (typeof rw === "string") return refuse(rw);
-        if (w2() !== rec) return refuse("message");
-        if (!this.notesProviderOn()) return refuse("mode");
+        if (typeof rw === "string") return refuse2(rw);
+        if (w2() !== rec) return refuse2("message");
+        if (!this.notesProviderOn()) return refuse2("mode");
         const r2 = await this.recall.forget(channelId, f.id.recall, rw, precommit(rw));
-        if (r2 === "unknown_id") return refuse("invalid");
-        if (r2 !== "ok") return refuse(r2);
+        if (r2 === "unknown_id") return refuse2("invalid");
+        if (r2 !== "ok") return refuse2(r2);
         writeServiceLog2("info", "memory.recall_forgotten");
         return { type: "memory_note_result", request_id: f.request_id, message_id: f.message_id, ok: true };
       }
       let mutation;
       let rewrite;
       if (f.op === "forget") {
-        if (typeof f.id !== "number") return refuse("invalid");
+        if (typeof f.id !== "number") return refuse2("invalid");
         const rw = await spend();
-        if (typeof rw === "string") return refuse(rw);
+        if (typeof rw === "string") return refuse2(rw);
         rewrite = rw;
         mutation = { op: "forget", id: f.id, rewrite: rw };
       } else {
         const p = prepareStoredNote(f.text, { text: rec.text, ...rec.transcribed === true ? { transcribed: true } : {} });
-        if (!p.ok) return refuse(p.reason);
+        if (!p.ok) return refuse2(p.reason);
         if (f.op === "replace") {
-          if (typeof f.id !== "number") return refuse("invalid");
+          if (typeof f.id !== "number") return refuse2("invalid");
           const rw = await spend();
-          if (typeof rw === "string") return refuse(rw);
+          if (typeof rw === "string") return refuse2(rw);
           rewrite = rw;
           mutation = { op: "replace", id: f.id, text: p.text, rewrite: rw };
         } else {
           mutation = { op: "add", text: p.text };
         }
       }
-      if (w2() !== rec) return refuse("message");
-      if (!this.notesProviderOn()) return refuse("mode");
+      if (w2() !== rec) return refuse2("message");
+      if (!this.notesProviderOn()) return refuse2("mode");
       const stamp = this.ingestGeneration.get(rec.message_id);
-      if (stamp === void 0) return refuse("cleared");
+      if (stamp === void 0) return refuse2("cleared");
       const r = await this.notes.write(channelId, mutation, stamp, precommit(rewrite));
-      if (!r.ok) return refuse(r.reason);
+      if (!r.ok) return refuse2(r.reason);
       writeServiceLog2("info", "memory.note_written", {
         op: ServiceLogEnum.of(f.op, ["add", "replace", "forget"]),
         notes_count: r.notesCount,
@@ -39921,7 +40963,7 @@ var BridgeAgent = class _BridgeAgent {
       return { type: "memory_note_result", request_id: f.request_id, message_id: f.message_id, ok: true, id: r.id };
     } catch (e) {
       writeServiceLog2("warn", "memory.note_write_failed", {}, e);
-      return refuse("store");
+      return refuse2("store");
     } finally {
       ctx.pendingRequests.delete(f.request_id);
     }
@@ -39935,17 +40977,17 @@ var BridgeAgent = class _BridgeAgent {
    */
   async applyUnifiedNote(raw, ctx) {
     const ids = echoIds(raw);
-    const refuse = (reason, echo = ids) => {
+    const refuse2 = (reason, echo = ids) => {
       writeServiceLog2("info", "memory.note_refused", {
         reason_class: ServiceLogEnum.of(reason, ["mode", "invalid", "message", "audience", "provenance", "secret", "cap", "cleared", "store", "budget", "purged", "not_owner_words"])
       });
       return { type: "memory_note_result", ...echo, ok: false, reason };
     };
-    if (!this.unifiedProviderOn()) return refuse("mode");
+    if (!this.unifiedProviderOn()) return refuse2("mode");
     const f = parseMemoryNoteFrame(raw);
-    if (!f) return refuse("invalid");
-    if (ctx.pendingRequests.has(f.request_id)) return refuse("invalid", { message_id: f.message_id });
-    if (ctx.pendingRequests.size >= MAX_PENDING_NOTE_REQUESTS) return refuse("invalid", {});
+    if (!f) return refuse2("invalid");
+    if (ctx.pendingRequests.has(f.request_id)) return refuse2("invalid", { message_id: f.message_id });
+    if (ctx.pendingRequests.size >= MAX_PENDING_NOTE_REQUESTS) return refuse2("invalid", {});
     ctx.pendingRequests.add(f.request_id);
     try {
       const w2 = () => {
@@ -39957,25 +40999,25 @@ var BridgeAgent = class _BridgeAgent {
         return cur.record;
       };
       const rec = w2();
-      if (rec === void 0) return refuse("message");
+      if (rec === void 0) return refuse2("message");
       const channelId = rec.channel_id;
-      if (rec.authorization?.memory_write !== true) return refuse("audience");
-      if (!this.noteTurnClean(rec.message_id)) return refuse("audience");
+      if (rec.authorization?.memory_write !== true) return refuse2("audience");
+      if (!this.noteTurnClean(rec.message_id)) return refuse2("audience");
       const held = await this.heldPosition(channelId);
-      if (this.authorizationFor(channelId, rec.sender_id, void 0, held.epoch, held.groupId, { log: false }).memory_write !== true) return refuse("audience");
+      if (this.authorizationFor(channelId, rec.sender_id, void 0, held.epoch, held.groupId, { log: false }).memory_write !== true) return refuse2("audience");
       const scopeId = this.ownerScopeNow(channelId);
-      if (scopeId === null) return refuse("audience");
+      if (scopeId === null) return refuse2("audience");
       const precommit = () => !this.unifiedProviderOn() ? "mode" : w2() !== rec ? "message" : null;
-      if (f.op === "replace") return refuse("invalid");
-      if (f.op === "forget") return await this.forgetUnified(f, rec, channelId, ctx, refuse, precommit);
+      if (f.op === "replace") return refuse2("invalid");
+      if (f.op === "forget") return await this.forgetUnified(f, rec, channelId, ctx, refuse2, precommit);
       const stripped = allowlistPin(f.text);
-      if (stripped.trim().length === 0) return refuse("invalid");
+      if (stripped.trim().length === 0) return refuse2("invalid");
       const shown = ctx.shownUnified(f.message_id, ctx.token) ?? /* @__PURE__ */ new Set();
-      if (!pinCoverage(stripped, rec.text, this.unifiedReads.coverageTexts(f.message_id, shown)).ok) return refuse("not_owner_words");
-      if (scanNote(stripped) !== null) return refuse("secret");
-      if (stripped.length > PIN_MAX_CHARS) return refuse("cap");
+      if (!pinCoverage(stripped, rec.text, this.unifiedReads.coverageTexts(f.message_id, shown)).ok) return refuse2("not_owner_words");
+      if (scanNote(stripped) !== null) return refuse2("secret");
+      if (stripped.length > PIN_MAX_CHARS) return refuse2("cap");
       const stamp = this.ingestGeneration.get(rec.message_id);
-      if (stamp === void 0) return refuse("cleared");
+      if (stamp === void 0) return refuse2("cleared");
       const capture = this.store.itemCapture(channelId);
       const r = await this.items.commit({
         scopeKind: "owner_dm",
@@ -39993,7 +41035,7 @@ var BridgeAgent = class _BridgeAgent {
       });
       if (!r.ok) {
         const map = { pin_cap: "cap", secret: "secret", cleared: "cleared", room_cleared: "cleared", disabled: "mode", mode: "mode", purged: "purged", message: "message", duplicate: "invalid", invalid: "invalid", empty: "invalid" };
-        return refuse(map[r.reason] ?? "store");
+        return refuse2(map[r.reason] ?? "store");
       }
       await this.notes.exclusive(async () => this.unifiedReads.bumpGeneration());
       void this.send(channelId, pinnedLine(stripped), void 0, { agentTurn: false }).catch((e) => writeServiceLog2("warn", "memory.pinned_line_failed", {}, e));
@@ -40001,7 +41043,7 @@ var BridgeAgent = class _BridgeAgent {
       return { type: "memory_note_result", request_id: f.request_id, message_id: f.message_id, ok: true, id: r.itemIds[0] };
     } catch (e) {
       writeServiceLog2("warn", "memory.note_write_failed", {}, e);
-      return refuse("store");
+      return refuse2("store");
     } finally {
       ctx.pendingRequests.delete(f.request_id);
     }
@@ -40015,16 +41057,16 @@ var BridgeAgent = class _BridgeAgent {
    * is invalidated in the same mutex hold, the item leaves the ranking hot set, then the bridge publishes `Forgot:`
    * (OQ-P2: afterPublish keeps the line out of history and the items). Every reason is a key of UNIFIED_REFUSAL.
    */
-  async forgetUnified(f, rec, channelId, ctx, refuse, precommit) {
-    if (typeof f.id !== "object") return refuse("invalid");
+  async forgetUnified(f, rec, channelId, ctx, refuse2, precommit) {
+    if (typeof f.id !== "object") return refuse2("invalid");
     const itemId = f.id.recall;
     const shown = ctx.shownUnified(f.message_id, ctx.token);
-    if (!shown || !shown.has(itemId)) return refuse("invalid");
+    if (!shown || !shown.has(itemId)) return refuse2("invalid");
     const text = this.unifiedReads.shownText(f.message_id, itemId);
-    if (text === void 0) return refuse("invalid");
+    if (text === void 0) return refuse2("invalid");
     const rw = await this.store.prepareRuntimeInboxRewrite(rec.message_id, bumpW9);
-    if (rw === "declined") return refuse("budget");
-    if (rw === "no_row") return refuse("message");
+    if (rw === "declined") return refuse2("budget");
+    if (rw === "no_row") return refuse2("message");
     const r = await this.notes.exclusive(async () => {
       const veto = precommit();
       if (veto !== null) return { ok: false, reason: veto };
@@ -40037,7 +41079,7 @@ var BridgeAgent = class _BridgeAgent {
       }
       return out;
     });
-    if (!r.ok) return refuse(r.reason === "unknown_id" ? "invalid" : r.reason);
+    if (!r.ok) return refuse2(r.reason === "unknown_id" ? "invalid" : r.reason);
     this.rankingNote(() => this.ranking.removed(r.itemIds));
     void this.send(channelId, forgotLine(text), void 0, { agentTurn: false }).catch((e) => writeServiceLog2("warn", "memory.forgot_line_failed", {}, e));
     writeServiceLog2("info", "memory.item_forgotten");
@@ -40111,8 +41153,9 @@ var BridgeAgent = class _BridgeAgent {
     this.fastReplyChains.set(channelId, next);
   }
   /** Count a fast reply against FAST_REPLY_MAX_JOBS and reserve its room send-floor token; returns the release. */
-  reserveFastReply(channelId) {
+  reserveFastReply(replyChannel) {
     this.fastReplyJobs++;
+    const channelId = this.capChannelFor(replyChannel);
     this.fastReplyReserved.set(channelId, (this.fastReplyReserved.get(channelId) ?? 0) + 1);
     return () => {
       this.fastReplyJobs--;
@@ -40336,6 +41379,7 @@ var BridgeAgent = class _BridgeAgent {
     });
     if (!res.ok) throw new Error(`list_channels failed: ${res.status}`);
     const rows = await res.json();
+    for (const r of rows) if (r.channel_kind === "voice") this.listedAsVoice.add(r.channel_id);
     for (const r of rows) this.store.recordChannelEnclave(r.channel_id, r.enclave_id);
     return rows.map((r) => ({
       channel_id: r.channel_id,
@@ -40419,6 +41463,7 @@ var BridgeAgent = class _BridgeAgent {
    */
   recordListedChannelMeta(channels, at) {
     for (const c of channels) {
+      if (this.listedAsVoice.has(c.channel_id)) continue;
       this.channelMeta.set(c.channel_id, { is_dm: c.is_dm, name: c.name, at });
       this.store.recordChannelIsDm(c.channel_id, c.is_dm);
     }
@@ -40602,7 +41647,8 @@ var BridgeAgent = class _BridgeAgent {
       }
       const self = members.get(this.cfg.identityId);
       if (self?.name) this.lastOwnDisplayName = self.name;
-      await this.resolveAndPinOwner(channelId, liveRows);
+      const unclassified = this.isUnlistedChannel(channelId) && !this.voiceChannels.isNotVoice(channelId);
+      if (!this.voiceChannels.isVoice(channelId) && !unclassified) await this.resolveAndPinOwner(channelId, liveRows);
     } catch {
     }
   }
@@ -40638,7 +41684,7 @@ var BridgeAgent = class _BridgeAgent {
    * held group (never the backend's row label, M-2). NEVER throws (M-4): any
    * exception is `failed verify_error`, and the row is acked like any other turn.
    */
-  async verifyOwnerTurn(m) {
+  async verifyOwnerTurn(m, keyChannel = m.channelId) {
     const pin = this.cfg.ownerGrantPin?.pin ?? null;
     if (!pin || m.envelope.sender_id !== pin.ownerIdentityId) return OWNER_TURN_UNCHECKED;
     try {
@@ -40650,9 +41696,9 @@ var BridgeAgent = class _BridgeAgent {
       }
       if (v.sender_id !== pin.ownerIdentityId) return this.ownerTurnFailed(m, "malformed");
       let leafClass = "ok";
-      if (this.freshMeta(m.channelId)?.is_dm === true) {
+      if (this.freshMeta(keyChannel)?.is_dm === true) {
         const signedDm = this.toolGrantManifest?.owner_dm_channel_id;
-        if (signedDm !== void 0 && signedDm !== m.channelId) return this.ownerTurnFailed(m, "wrong_dm_channel");
+        if (signedDm !== void 0 && signedDm !== keyChannel) return this.ownerTurnFailed(m, "wrong_dm_channel");
         leafClass = classifyOwnerDmLeaves((await this.provider.leafTreeSummary(m.channelId)).leaves, {
           ownerIdentityId: pin.ownerIdentityId,
           agentIdentityId: this.cfg.identityId,
@@ -40816,9 +41862,14 @@ var BridgeAgent = class _BridgeAgent {
     });
   }
   /** Classify one inbound turn at the agent's CURRENT epoch for its channel. */
-  async authorizeTurn(channelId, messageId, senderId, ownerVerdict, relaySpeakerId, voiceScoped) {
+  async authorizeTurn(channelId, messageId, senderId, ownerVerdict, relaySpeakerId, voiceScoped, voiceParent) {
     const held = await this.heldPosition(channelId);
-    const auth = this.authorizationFor(channelId, senderId, relaySpeakerId, held.epoch, held.groupId, { ownerVerdict, voiceScoped });
+    const keyHeld = voiceParent === void 0 ? held : await this.heldPosition(voiceParent);
+    const auth = this.authorizationFor(voiceParent ?? channelId, senderId, relaySpeakerId, keyHeld.epoch, keyHeld.groupId, {
+      ownerVerdict,
+      voiceScoped,
+      ...voiceParent === void 0 ? {} : { voice: { channelId, heldEpoch: held.epoch, heldGroupId: held.groupId } }
+    });
     if (!(auth.audience === "team_room" && auth.tool_grants.length > 0)) return auth;
     if (this.roomGrantEpochs.size >= ROOM_GRANT_TRACK_MAX || held.epoch === null || held.groupId === null) {
       writeServiceLog2("warn", "room_grant.untracked");
@@ -40871,7 +41922,10 @@ var BridgeAgent = class _BridgeAgent {
     const meta = this.freshMeta(channelId);
     const entry = this.freshRosterEntry(channelId);
     const roster = entry?.members;
-    const sender = roster?.get(senderId);
+    const vEntry = opts.voice === void 0 ? void 0 : this.freshRosterEntry(opts.voice.channelId);
+    const vSender = vEntry?.members.get(senderId);
+    const sender = opts.voice === void 0 ? roster?.get(senderId) : vSender === void 0 ? void 0 : roster?.get(senderId) ?? vSender;
+    const senderIsRelay = opts.voice === void 0 ? sender?.is_relay === true : vSender?.is_relay === true;
     let audience = "unknown";
     if (meta && sender) {
       if (sender.is_agent) audience = "agent_to_agent";
@@ -40883,15 +41937,15 @@ var BridgeAgent = class _BridgeAgent {
     let tool_grants = NO_TOOL_GRANTS;
     let relaySpeaker;
     let memoryWrite = false;
-    const epochFresh = rosterFreshAt(entry, heldEpoch, heldGroupId);
-    const ownerDmFresh = epochFresh || this.ownerDmCycleFresh.has(channelId);
+    const epochFresh = rosterFreshAt(entry, heldEpoch, heldGroupId) && (opts.voice === void 0 || rosterFreshAt(vEntry, opts.voice.heldEpoch, opts.voice.heldGroupId));
+    const ownerDmFresh = epochFresh || opts.voice === void 0 && this.ownerDmCycleFresh.has(channelId);
     if (ownerDmFresh && this.ownerDmDefaultGrants && meta?.is_dm === true && sender) {
       const pinned = this.channelOwner.get(channelId);
       const ownerId = pinned && pinned !== "anomalous" ? pinned.identityId : void 0;
       if (ownerId !== void 0) {
         const ownerDirect = audience === "owner_dm" && senderId === ownerId;
         const owner = roster?.get(ownerId);
-        const ownerRelayed = relaySpeakerId !== void 0 && sender.is_relay && relaySpeakerId === ownerId && owner !== void 0 && !owner.is_agent && owner.is_agent_owner;
+        const ownerRelayed = relaySpeakerId !== void 0 && senderIsRelay && relaySpeakerId === ownerId && owner !== void 0 && !owner.is_agent && owner.is_agent_owner;
         if (ownerDirect) tool_grants = opts.voiceScoped === true ? RELAYED_VOICE_GRANTS : OWNER_DM_DEFAULT_READ_GRANTS;
         if (ownerRelayed) tool_grants = RELAYED_VOICE_GRANTS;
         if (ownerRelayed) relaySpeaker = "owner";
@@ -41570,6 +42624,9 @@ var BridgeAgent = class _BridgeAgent {
   async ingestCycleBody(receiptIds) {
     if (this.closingDown) return;
     const cycleStart = performance.now();
+    let voiceListed = false;
+    const cycleStartedAt = Date.now();
+    const joinedInPhase0 = /* @__PURE__ */ new Set();
     try {
       const rows = await this.latency.time("recv.pull", () => this.backend.pullDelivery(this.cfg.deviceId));
       this.recordRecvLag(rows);
@@ -41579,9 +42636,11 @@ var BridgeAgent = class _BridgeAgent {
       }
       for (const cid of channelIds) {
         if (this.joinState.get(cid) !== "JOINED") {
+          joinedInPhase0.add(cid);
           await this.reconcileJoin(cid);
         }
       }
+      if (await this.resolveUnlistedChannels(channelIds, false)) voiceListed = true;
       for (const cid of channelIds) {
         if (this.freshRoster(cid) === void 0) {
           await this.refreshChannelRoster(cid);
@@ -41606,6 +42665,13 @@ var BridgeAgent = class _BridgeAgent {
       }
     } catch {
     }
+    const voiceStamp = await this.voicePositionSnapshot();
+    const receiveStartedAt = Date.now();
+    const stampsFor = (m) => {
+      if (m.receivedAt >= receiveStartedAt) return true;
+      const p = this.voiceChannels.parentOf(m.channelId);
+      return m.receivedAt >= cycleStartedAt && p !== void 0 && !joinedInPhase0.has(p);
+    };
     let entries;
     try {
       entries = await this.latency.time("recv.decrypt", () => this.provider.receiveOnce(this.cfg.deviceId));
@@ -41615,29 +42681,56 @@ var BridgeAgent = class _BridgeAgent {
     for (const cid of entries.supersededChannelIds ?? []) {
       this.joinState.set(cid, "JOINED");
     }
-    if (!entries.length) return;
+    if (!entries.length) {
+      await this.reevaluateVoiceBindings();
+      return;
+    }
     await this.maybePruneOwnerReplay();
     const receivedAt = Date.now();
     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);
+      if (stamp !== void 0) this.voiceChannels.noteReceipt(m.messageId, stampsFor(m) ? stamp : null);
+      else if (this.voiceChannels.isVoice(m.channelId) || this.isUnlistedChannel(m.channelId) && !this.voiceChannels.isResolved(m.channelId)) {
+        this.voiceChannels.noteReceipt(m.messageId, null);
+      }
     }
-    let metaRefreshed = false;
-    if (entries.some((m) => this.freshMeta(m.channelId) === void 0)) {
+    if (await this.resolveUnlistedChannels(entries.map((m) => m.channelId), voiceListed)) voiceListed = true;
+    await this.reevaluateVoiceBindings();
+    entries = await this.gateVoiceEntries(entries);
+    let metaRefreshed = voiceListed;
+    if (!voiceListed && entries.some((m) => this.freshMeta(this.keyChannelForFrame(m)) === void 0)) {
       await this.refreshChannelMeta();
       metaRefreshed = true;
     }
-    await this.refreshRostersForCycle(entries.map((m) => m.channelId));
+    await this.refreshRostersForCycle(entries.flatMap((m) => {
+      const key = this.keyChannelForFrame(m);
+      return key === m.channelId ? [m.channelId] : [m.channelId, key];
+    }));
     const relayMissRefreshed = /* @__PURE__ */ new Set();
     const acked = [];
     for (const m of entries) {
+      if (this.voiceChannels.isVoice(m.channelId) && !this.voiceFrameParent.has(m.messageId)) {
+        acked.push(m.queueId);
+        continue;
+      }
       try {
         if (m.voiceMode === false) this.callBuffer.reset(m.channelId);
         const encId = m.envelope.enclave_id;
@@ -41798,7 +42891,9 @@ var BridgeAgent = class _BridgeAgent {
         }
         if (typeof parsed.text === "string") {
           if (parsed.text.trim() === VOICE_CALL_START_MARKER) this.callBuffer.reset(m.channelId);
-          const meta = this.freshMeta(m.channelId);
+          const keyChannel = this.keyChannelForFrame(m);
+          const voiceParent = keyChannel !== m.channelId ? keyChannel : void 0;
+          const meta = this.freshMeta(keyChannel);
           const senderType = m.envelope.sender_type;
           const senderIsAgent = senderType === "agent" ? true : senderType === "human" ? false : void 0;
           const claimsRelaySpeaker = parsed.relay === true && typeof parsed.speaker_identity_id === "string" && typeof parsed.speaker_display_name === "string";
@@ -41845,14 +42940,15 @@ var BridgeAgent = class _BridgeAgent {
               senderIsRelay: this.freshRoster(m.channelId)?.get(m.envelope.sender_id)?.is_relay === true,
               text: parsed.text
             });
-            const ownerVerdict = await this.verifyOwnerTurn(m);
+            const ownerVerdict = await this.verifyOwnerTurn(m, keyChannel);
             const turnAuthorization = await this.authorizeTurn(
               m.channelId,
               m.messageId,
               m.envelope.sender_id,
               ownerVerdict,
               speaker?.identityId,
-              voiceScoped
+              voiceScoped,
+              voiceParent
             );
             await this.prepareNotesForTurn(m.channelId, turnAuthorization);
             const voiceGuidance = m.voiceMode ? selectVoiceGuidance(meta?.is_dm, m.voiceDefaultResponder) : void 0;
@@ -41879,11 +42975,12 @@ var BridgeAgent = class _BridgeAgent {
             }
             let fastPathRoomBlocked = false;
             if (!coalescible && fastPathEligible && meta && meta.is_dm === false) {
-              const reserved = this.fastReplyReserved.get(m.channelId) ?? 0;
-              if (this.rateFloor.available(`room:${m.channelId}`) - reserved < 2) fastPathRoomBlocked = true;
+              const floorKey = this.capChannelFor(m.channelId);
+              const reserved = this.fastReplyReserved.get(floorKey) ?? 0;
+              if (this.rateFloor.available(`room:${floorKey}`) - reserved < 2) fastPathRoomBlocked = true;
             }
             if (fastPathRoomBlocked) this.fastPathSkipped++;
-            const fastPathFiring = fastPathEligible && !fastPathRoomBlocked && !this.pausedChannels.has(m.channelId);
+            const fastPathFiring = fastPathEligible && !fastPathRoomBlocked && !this.pausedFor(m.channelId);
             const fastGreeting = isCallStart && fastPathFiring;
             const runtimeVoice = (ackSent) => m.voiceMode ? {
               voice: true,
@@ -41952,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);
@@ -41982,18 +43080,19 @@ 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));
                 }
                 void recordInboundMemory(this.memory, channelId, senderId, text, firstId, "voice", win.purgeEpoch);
                 let roomBlocked = false;
                 if (fastPathEligible && isRoom) {
-                  const reserved = this.fastReplyReserved.get(channelId) ?? 0;
-                  if (this.rateFloor.available(`room:${channelId}`) - reserved < 2) roomBlocked = true;
+                  const floorKey = this.capChannelFor(channelId);
+                  const reserved = this.fastReplyReserved.get(floorKey) ?? 0;
+                  if (this.rateFloor.available(`room:${floorKey}`) - reserved < 2) roomBlocked = true;
                 }
                 if (roomBlocked) this.fastPathSkipped++;
-                const plan = fastPathEligible && !roomBlocked && !this.pausedChannels.has(channelId) ? this.planFastPath(firstId, text, false) : void 0;
+                const plan = fastPathEligible && !roomBlocked && !this.pausedFor(channelId) ? this.planFastPath(firstId, text, false) : void 0;
                 if (!plan || plan.kind === "dup" || plan.kind === "skip") {
                   if (plan?.kind === "skip" && plan.full) this.fastPathSkipped++;
                   await this.settleHeldRuntimeMessage(merged, true);
@@ -42071,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));
                 }
@@ -42097,6 +43200,7 @@ var BridgeAgent = class _BridgeAgent {
       }
     }
     for (const m of entries) this.recallReceipt.delete(m.messageId);
+    for (const m of entries) this.voiceFrameParent.delete(m.messageId);
     if (acked.length) {
       try {
         await this.latency.time("recv.ack", () => this.provider.ackDelivery(this.cfg.deviceId, acked));
@@ -42377,8 +43481,9 @@ var BridgeAgent = class _BridgeAgent {
     }
   }
   /** Spec §7.5 (T-14c, M-4): the runtime reports an executed-call cap for a room. Never throws. */
-  noteRoomCapReached(channelId) {
-    if (typeof channelId !== "string" || this.closingDown) return;
+  noteRoomCapReached(reported) {
+    if (typeof reported !== "string" || this.closingDown) return;
+    const channelId = this.capChannelFor(reported);
     if (this.roomSearchDailyCap === 0) return;
     if (this.freshMeta(channelId)?.is_dm !== false || this.channelRoster.get(channelId)?.crossOrg !== false) return;
     const day = utcDayOf(Date.now());
@@ -42435,8 +43540,9 @@ ${channelId}`;
     const a = entry.authorization;
     if (!a || a.audience !== "team_room" || !a.tool_grants.some((g) => g.tool === "web_search")) return entry;
     const day = utcDayOf(Date.now());
+    const room = this.capChannelFor(entry.channel_id);
     if (this.roomSearchDailyCap === 0) {
-      this.logRoomCap(day, entry.channel_id, "operator");
+      this.logRoomCap(day, room, "operator");
       return this.withoutWebSearch(entry);
     }
     if (this.agentRoomSearchDailyCap === 0) {
@@ -42444,9 +43550,9 @@ ${channelId}`;
       return this.withoutWebSearch(entry);
     }
     try {
-      const n = this.store.countRoomSearchGrant(entry.channel_id, day);
-      if (n === this.roomSearchDailyCap && this.store.markRoomSearchCapReached(entry.channel_id, day, "bridge")) {
-        this.logRoomCap(day, entry.channel_id, "bridge");
+      const n = this.store.countRoomSearchGrant(room, day);
+      if (n === this.roomSearchDailyCap && this.store.markRoomSearchCapReached(room, day, "bridge")) {
+        this.logRoomCap(day, room, "bridge");
       }
       if (n > this.roomSearchDailyCap) return this.withoutWebSearch(entry);
       const total = this.store.countRoomSearchGrant(AGENT_TOTAL_KEY, day);
@@ -42543,9 +43649,15 @@ ${channelId}`;
    * PAUSE_RECHECK_MS window, so release does not depend on new traffic.
    */
   heldForPause(channelId) {
-    const at = this.pausedChannels.get(channelId);
+    let key = channelId;
+    let at = this.pausedChannels.get(channelId);
+    const parent3 = at === void 0 ? this.voiceChannels.parentOf(channelId) : void 0;
+    if (parent3 !== void 0) {
+      key = parent3;
+      at = this.pausedChannels.get(parent3);
+    }
     if (at === void 0) return false;
-    this.schedulePauseRecheck(channelId, at);
+    this.schedulePauseRecheck(key, at);
     return true;
   }
   schedulePauseRecheck(channelId, confirmedAt) {
@@ -42574,7 +43686,7 @@ ${channelId}`;
     if (await this.probeOwnPause(channelId) === true) {
       const now = Date.now();
       this.pausedChannels.set(channelId, now);
-      if (this.buffer.some((m) => m.channel_id === channelId)) this.schedulePauseRecheck(channelId, now);
+      if (this.buffer.some((m) => m.channel_id === channelId || this.voiceChannels.parentOf(m.channel_id) === channelId)) this.schedulePauseRecheck(channelId, now);
       return;
     }
     this.clearPause(channelId);
@@ -43053,6 +44165,10 @@ ${channelId}`;
       custody_store_unavailable: this.provider.custodyHealth().storeUnavailable,
       failed_attachments: this.failedAttachments,
       refused_vault_refs: this.refusedVaultRefs,
+      voice_frames_refused: this.voiceFramesRefused,
+      voice_frames_filtered: this.voiceFramesFiltered,
+      voice_receipt_cap_reached: this.voiceChannels.receiptCapReached(),
+      voice_relay_in_parent: this.voiceChannels.relayInParentCount(),
       fast_path_sent: this.fastPathSent,
       fast_path_failed: this.fastPathFailed,
       fast_path_skipped: this.fastPathSkipped,