@securecoms/agent-bridge 0.31.0 → 0.33.0

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}`);
@@ -22068,7 +22082,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 +22115,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 +22152,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 +22160,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 +22207,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 {
@@ -23318,15 +23332,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 +23369,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);
@@ -26084,6 +26104,7 @@ function openSchema(db) {
   ensureToolGrantTables(db);
   ensureToolGrantAppliedTable(db);
   ensureRoomSearchCapTable(db);
+  ensureVoiceChannelParentTable(db);
   db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
 }
 function ensureMlsCustody(db) {
@@ -26269,6 +26290,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 +26991,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 +31829,7 @@ var EmbedderClient = class {
           resolve(ok);
         }
       }
-      const refuse = (reason) => {
+      const refuse2 = (reason) => {
         s.destroy();
         if (!settled) {
           this.fail(reason);
@@ -31802,22 +31848,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 +31881,9 @@ var EmbedderClient = class {
           this.settleReady(true);
           done(true);
         } catch {
-          refuse("embedder_unavailable");
+          refuse2("embedder_unavailable");
         }
-      }, () => refuse("embedder_unavailable")));
+      }, () => refuse2("embedder_unavailable")));
     });
   }
   onFrame(f) {
@@ -33659,6 +33705,8 @@ var schema = z2.object({
     model: z2.string().min(1),
     api_key: z2.string().min(1).optional(),
     api_key_env: z2.string().min(1).optional(),
+    // E.2: only the exact string "direct" opts in; any other value is ignored (today's proxy behavior), never an error.
+    route: z2.unknown().optional(),
     timeout_ms: z2.number().int().min(500).max(1e4).default(2500),
     max_tokens: z2.number().int().min(16).max(400).default(80)
   })
@@ -33683,7 +33731,8 @@ function parseVoiceConfig(raw, env) {
       model: v.fast_path.model,
       apiKey,
       timeoutMs: v.fast_path.timeout_ms,
-      maxTokens: v.fast_path.max_tokens
+      maxTokens: v.fast_path.max_tokens,
+      ...v.fast_path.route === "direct" ? { route: "direct" } : {}
     }
   };
 }
@@ -34297,6 +34346,7 @@ function lineHash(line) {
   return createHash5("sha256").update(line.trim(), "utf8").digest("hex");
 }
 var LOCAL_REPORT_FILE = "local-config.json";
+var LOCAL_PERSONA_FILE_NAMES = ["IDENTITY.md", "SOUL.md", "AGENTS.md"];
 var SECRET_PATH_COUNT_MAX = 1e4;
 var isCount = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0 && v <= SECRET_PATH_COUNT_MAX;
 function parseSecretPathsReport(raw) {
@@ -34378,18 +34428,23 @@ function readLocalReport(home, identityId) {
   const hasSearchKey = doc.has_search_key === true;
   const hasLlmKey = doc.has_llm_key === true;
   const raw = doc.persona;
-  const persona = raw && typeof raw === "object" && !Array.isArray(raw) ? Object.fromEntries(
-    Object.entries(raw).filter(([, v]) => typeof v === "string")
-  ) : {};
+  const persona = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const personaFiles = [];
+  for (const name of LOCAL_PERSONA_FILE_NAMES) {
+    const text = persona[name];
+    if (typeof text === "string" && text.trim() !== "") {
+      personaFiles.push({ name, bytes: Buffer.byteLength(text, "utf8") });
+    }
+  }
   const capRaw = doc.owner_dm_search_cap_effective;
   const ownerDmCap = typeof capRaw === "number" && Number.isInteger(capRaw) && capRaw >= 0 && capRaw <= OWNER_DM_SEARCH_DAILY_CAP_MAX ? capRaw : void 0;
   return {
-    persona,
+    local_persona_files: personaFiles,
     has_search_key: hasSearchKey,
     has_llm_key: hasLlmKey,
     has_extract_provider: doc.has_extract_provider === true,
     ...ownerDmCap !== void 0 ? { owner_dm_search_cap_effective: ownerDmCap } : {},
-    legacy_memory: localLegacySources(doc).map(({ path: _path, ...source }) => source),
+    legacy_memory: localLegacySources(doc).map(({ path: _path, content: _content, ...source }) => source),
     secret_paths: parseSecretPathsReport(doc.secret_paths)
   };
 }
@@ -34474,16 +34529,6 @@ async function applyLegacyMemoryFactDecisions(home, identityId, rawDecisions, re
   }
   return { sourcesDeleted, factsAssigned };
 }
-function readManagedMemory(home, identityId) {
-  const p = join15(runtimeConfigDir(home, identityId), MEMORY_FILE);
-  if (!existsSync4(p)) return null;
-  try {
-    const body = readFileSync8(p, "utf8").trim();
-    return body || null;
-  } catch {
-    return null;
-  }
-}
 function pruneManagedMemory(home, identityId, hashes, deps = REAL_FS) {
   const dir = runtimeConfigDir(home, identityId);
   const path = join15(dir, MEMORY_FILE);
@@ -35176,6 +35221,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})+$/;
@@ -35271,6 +35523,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" })
@@ -35545,12 +35798,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()");
@@ -35773,6 +36033,9 @@ var BridgeAgent = class _BridgeAgent {
     this.injectedFastLlm = !!deps.fastLlm;
     this.fileVoiceConfig = cfg.voice;
     this.fastLlm = deps.fastLlm ?? (cfg.voice?.fastPath.enabled ? new FastLlmClient(cfg.voice.fastPath, this.fetchImpl) : void 0);
+    if (this.fileVoiceConfig?.fastPath.route === "direct" && !this.fileVoiceConfig.fastPath.apiKey) {
+      writeServiceLog2("warn", "voice.fast_path_direct_no_key");
+    }
     this.voiceSettingsSource = cfg.voice ? "file" : "none";
     this.latency = deps.latency ?? new LatencyRecorder();
     this.voiceCoalesceWindowMs = Math.max(0, deps.voiceCoalesceWindowMs ?? voiceCoalesceWindowFromEnv());
@@ -35979,6 +36242,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;
@@ -36009,6 +36279,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;
   /**
@@ -36422,7 +36698,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.
@@ -36572,6 +36850,7 @@ var BridgeAgent = class _BridgeAgent {
       const s = parseVoiceSettings(await res.json());
       if (s.identityDisplayName) this.lastOwnDisplayName = s.identityDisplayName;
       const proxy = settingsToVoiceConfig(s, { baseUrl: this.cfg.apiBase, apiKey: this.cfg.apiKey });
+      const direct = this.fileVoiceConfig?.fastPath.route === "direct" ? this.fileVoiceConfig.fastPath : void 0;
       if (s.version === 0 && this.fileVoiceConfig) {
         const merged = {
           ...s,
@@ -36580,16 +36859,16 @@ var BridgeAgent = class _BridgeAgent {
           quirks: this.fileVoiceConfig.persona.quirks
         };
         this.voiceSettings = merged;
-        this.cfg.voice = { persona: this.fileVoiceConfig.persona, fastPath: proxy.fastPath, settings: merged };
+        this.cfg.voice = { persona: this.fileVoiceConfig.persona, fastPath: direct ?? proxy.fastPath, settings: merged };
         this.voiceSettingsVersion = 0;
         this.voiceSettingsSource = "file";
       } else {
         this.voiceSettings = s;
-        this.cfg.voice = proxy;
+        this.cfg.voice = direct ? { ...proxy, fastPath: direct } : proxy;
         this.voiceSettingsVersion = s.version;
         this.voiceSettingsSource = "backend";
       }
-      if (!this.injectedFastLlm) {
+      if (!this.injectedFastLlm && !direct) {
         this.fastLlm = new FastLlmClient(this.cfg.voice.fastPath, this.fetchImpl);
       }
       writeServiceLog2("info", "voice.settings_loaded", {
@@ -36818,12 +37097,10 @@ var BridgeAgent = class _BridgeAgent {
     const report = {
       applied_version: version,
       paths: checkConfiguredPaths(skillsJson),
-      // Read AFTER the prunes above, so the owner's next view of memory is
-      // the file as it now stands, not the one they just pruned from.
-      memory: readManagedMemory(this.home, this.cfg.identityId),
-      // E13: pass through what the runtime reported. The daemon does not
-      // interpret any of it.
-      local_persona: local?.persona ?? null,
+      // F-0 (G-5): the report carries no content. No MEMORY.md text, no persona text, no legacy
+      // text. E13 needs only to know which of the runtime's own persona files hold something, so
+      // this is [{name, bytes}] for each non-blank file and nothing else.
+      local_persona_files: local?.local_persona_files ?? [],
       // Only the runtime knows whether a search key file is configured — it
       // is an environment value on that process, invisible to the daemon and
       // to the backend. The backend needs it to generate a truthful tool
@@ -36843,6 +37120,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);
@@ -36856,9 +37135,9 @@ var BridgeAgent = class _BridgeAgent {
       ...this.reportedClearGeneration(),
       // 7b spec §9.2 (Task 19): capability versus state. Read-only: the report never starts the embedder.
       ...this.reportedRecall(),
-      // Inert legacy files only. `readLocalReport` revalidates the current
-      // regular-file bytes and strips every local path before this leaves the
-      // machine.
+      // Inert legacy files only, metadata only. `readLocalReport` revalidates the current
+      // regular-file bytes and strips every local path and every `content` before this
+      // leaves the machine.
       legacy_memory: local?.legacy_memory ?? [],
       // §B.4: counts of server-named secret paths inside / allowlisted /
       // outside the secrets directory, and the runtime's mode. Numbers and
@@ -38090,6 +38369,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);
@@ -38106,8 +38386,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) {
@@ -38589,8 +38870,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);
@@ -39830,17 +40392,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 = () => {
@@ -39852,13 +40414,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";
@@ -39874,44 +40436,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,
@@ -39920,7 +40482,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);
     }
@@ -39934,17 +40496,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 = () => {
@@ -39956,25 +40518,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",
@@ -39992,7 +40554,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));
@@ -40000,7 +40562,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);
     }
@@ -40014,16 +40576,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 };
@@ -40036,7 +40598,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");
@@ -40110,8 +40672,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--;
@@ -40335,6 +40898,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,
@@ -40418,6 +40982,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);
     }
@@ -40601,7 +41166,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 {
     }
   }
@@ -40637,7 +41203,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 {
@@ -40649,9 +41215,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,
@@ -40815,9 +41381,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");
@@ -40870,7 +41441,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";
@@ -40882,15 +41456,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";
@@ -41569,6 +42143,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);
@@ -41578,9 +42155,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);
@@ -41605,6 +42184,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));
@@ -41614,7 +42200,10 @@ 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();
@@ -41627,16 +42216,31 @@ var BridgeAgent = class _BridgeAgent {
       if (this.unifiedOn && !itemCaptureAtReceipt.has(m.channelId)) itemCaptureAtReceipt.set(m.channelId, this.store.itemCapture(m.channelId));
       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;
@@ -41797,7 +42401,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";
@@ -41844,14 +42450,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;
@@ -41878,11 +42485,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,
@@ -41988,11 +42596,12 @@ var BridgeAgent = class _BridgeAgent {
                 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);
@@ -42096,6 +42705,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));
@@ -42376,8 +42986,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());
@@ -42434,8 +43045,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) {
@@ -42443,9 +43055,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);
@@ -42542,9 +43154,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) {
@@ -42573,7 +43191,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);
@@ -43052,6 +43670,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,