@securecoms/agent-bridge 0.26.1 → 0.26.3

package/dist/index.js

@@ -27308,6 +27308,15 @@ var TokenBucketFloor = class {
 };
 
 // src/service-log.ts
+var ENUM_VALUE = /^[a-z][a-z_]{0,31}$/;
+var ServiceLogEnum = class _ServiceLogEnum {
+  constructor(value) {
+    this.value = value;
+  }
+  static of(value, allowed) {
+    return new _ServiceLogEnum(allowed.includes(value) && ENUM_VALUE.test(value) ? value : "invalid");
+  }
+};
 var TOKEN2 = /^[a-z][a-z0-9_.-]{0,63}$/;
 var CLASS2 = /^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/;
 function errorClass2(error) {
@@ -27337,6 +27346,7 @@ function formatServiceLog2(level3, event, fields = {}, error) {
     if (!TOKEN2.test(key)) continue;
     if (typeof value === "boolean") parts.push(`${key}=${value}`);
     else if (typeof value === "number" && Number.isFinite(value)) parts.push(`${key}=${value}`);
+    else if (value instanceof ServiceLogEnum && ENUM_VALUE.test(value.value)) parts.push(`${key}=${value.value}`);
   }
   if (error !== void 0) parts.push(`error_class=${errorClass2(error)}`);
   return parts.join(" ");
@@ -27971,9 +27981,9 @@ async function recordInboundMemory(sink, channelId, senderId, text, messageId, m
   } catch {
   }
 }
-async function recordOutboundMemory(sink, channelId, text, messageId) {
+async function recordOutboundMemory(sink, channelId, text, messageId, modality = "text") {
   try {
-    await sink.record({ conversationId: channelId, role: "agent", text, modality: "text", messageId });
+    await sink.record({ conversationId: channelId, role: "agent", text, modality, messageId });
   } catch {
   }
 }
@@ -28958,6 +28968,15 @@ function logPendingCommitResolved(outcome) {
       writeServiceLog2("info", "mls.pending_commit.resolved.unknown");
   }
 }
+var OWNER_DM_DEFAULT_READ_GRANTS = Object.freeze([
+  Object.freeze({ tool: "current_time", mode: "read" }),
+  Object.freeze({ tool: "web_search", mode: "read" })
+]);
+var NO_TOOL_GRANTS = Object.freeze([]);
+function ownerDmDefaultGrantsEnabled(env = process.env) {
+  const v = env.SECURECOMS_OWNER_DM_DEFAULT_GRANTS;
+  return v === void 0 || v === "on";
+}
 var VAULT_REF_BARE_TEXT = "[Files link]";
 var VOICE_MODE_GUIDANCE = "Reply immediately and conversationally, one short sentence per message; never bundle multiple points into one message.";
 var FAST_PATH_SPOKEN_GUIDANCE = "A one-sentence spoken acknowledgement has already been sent for this turn. Reply only with information it did not contain, in one or two short sentences; if there is nothing to add, send nothing.";
@@ -28969,6 +28988,20 @@ function selectVoiceGuidance(isDm, voiceDefaultResponder) {
   }
   return VOICE_MODE_GUIDANCE;
 }
+var VOICE_COALESCE_WINDOW_MS = 0;
+var VOICE_COALESCE_WINDOW_MAX_MS = 5e3;
+function voiceCoalesceWindowFromEnv(env = process.env) {
+  const raw = env.SECURECOMS_VOICE_COALESCE_MS;
+  if (raw === void 0 || !/^\d{1,6}$/.test(raw.trim())) return VOICE_COALESCE_WINDOW_MS;
+  return Math.min(Number(raw.trim()), VOICE_COALESCE_WINDOW_MAX_MS);
+}
+function waitMs(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    t.unref?.();
+  });
+}
 var DEFAULT_MAX_BUFFER = 1e3;
 var DEFAULT_MAX_DELIVERY_ATTEMPTS = 5;
 var REDELIVERY_BACKOFF_BASE_MS = 5e3;
@@ -29253,6 +29286,7 @@ var BridgeAgent = class _BridgeAgent {
     this.fastLlm = deps.fastLlm ?? (cfg.voice?.fastPath.enabled ? new FastLlmClient(cfg.voice.fastPath, this.fetchImpl) : void 0);
     this.voiceSettingsSource = cfg.voice ? "file" : "none";
     this.latency = deps.latency ?? new LatencyRecorder();
+    this.voiceCoalesceWindowMs = Math.max(0, deps.voiceCoalesceWindowMs ?? voiceCoalesceWindowFromEnv());
     this.maxBuffer = deps.maxBuffer ?? DEFAULT_MAX_BUFFER;
     this.maxDeliveryAttempts = deps.maxDeliveryAttempts ?? DEFAULT_MAX_DELIVERY_ATTEMPTS;
     this.maxAgentHops = deps.maxAgentHops ?? DEFAULT_MAX_AGENT_HOPS;
@@ -29501,6 +29535,19 @@ var BridgeAgent = class _BridgeAgent {
   /** Room send-floor tokens reserved by queued fast replies, per channel (F3). */
   fastReplyReserved = /* @__PURE__ */ new Map();
   static FAST_REPLY_MAX_JOBS = 32;
+  /** Voice repeats (a): see {@link VOICE_COALESCE_WINDOW_MS}. */
+  voiceCoalesceWindowMs;
+  /** H1: fast-path reply ids being published right now (recorded as voice memory). */
+  spokenReplyIds = /* @__PURE__ */ new Set();
+  /** Open coalescing windows, keyed by channel + speaker. */
+  voiceCoalescing = /* @__PURE__ */ new Map();
+  /** Ids of every coalesced fragment (capped FIFO): a redelivered row is acked, never a second turn. */
+  voiceCoalescedIds = /* @__PURE__ */ new Set();
+  /** Merged turn id -> the absorbed fragments' held frames, retired with it. */
+  voiceCoalescedTails = /* @__PURE__ */ new Map();
+  /** (4) recv.lag: application queue ids already measured (capped FIFO), so a re-pulled row is not re-counted. */
+  recvLagSeen = /* @__PURE__ */ new Set();
+  static RECV_LAG_SEEN_CAP = 2e3;
   /** Fast-path turns handed to the runtime behind a spoken ack (LLM [[DEFER]], pre-check, or ack_only). */
   fastPathDeferred = 0;
   /** Of those, `full`-mode turns the deterministic pre-check deferred without calling the fast model. */
@@ -29594,6 +29641,8 @@ var BridgeAgent = class _BridgeAgent {
    * back to the delivery-row-driven Task 11 behaviour only.
    */
   selfHealSweepEnabled = process.env.SECURECOMS_SELF_HEAL_SWEEP !== "false";
+  /** Read once at startup; see ownerDmDefaultGrantsEnabled. */
+  ownerDmDefaultGrants = ownerDmDefaultGrantsEnabled();
   /** Task 12: proactive sweep cadence (in addition to the once-at-boot fire). */
   static SELF_HEAL_SWEEP_INTERVAL_MS = SELF_HEAL_SWEEP_INTERVAL_MS;
   /**
@@ -30958,7 +31007,8 @@ var BridgeAgent = class _BridgeAgent {
   /** Bookkeeping after a CONFIRMED publish of `body` under `id`. */
   afterPublish(channelId, body, id, opts) {
     if (opts.agentTurn !== false) this.agentHops.noteOwnSend(channelId);
-    if (body.kind === "text") void recordOutboundMemory(this.memory, channelId, body.text, id);
+    const modality = this.spokenReplyIds.has(id) ? "voice" : "text";
+    if (body.kind === "text") void recordOutboundMemory(this.memory, channelId, body.text, id, modality);
   }
   isIdempotentSend(messageId, opts) {
     if (opts.inReplyTo === void 0 && opts.idempotencyKey === void 0) return false;
@@ -31136,26 +31186,26 @@ var BridgeAgent = class _BridgeAgent {
       } catch (e) {
         if (e instanceof ReplyInFlightError) {
           if (inFlight >= REPLY_IN_FLIGHT_RETRIES) throw e;
-          const waitMs2 = Math.min(
+          const waitMs3 = Math.min(
             REPLY_RATE_LIMIT_MAX_WAIT_MS,
             Math.max(REPLY_IN_FLIGHT_BASE_WAIT_MS * 2 ** inFlight, e.retryAfterSec * 1e3)
           );
           inFlight++;
-          writeServiceLog2("info", "reply.in_flight_retry", { attempt: inFlight, wait_ms: waitMs2 });
-          await this.replySleep(waitMs2);
+          writeServiceLog2("info", "reply.in_flight_retry", { attempt: inFlight, wait_ms: waitMs3 });
+          await this.replySleep(waitMs3);
           continue;
         }
         const backendSec = backendRetryAfterSec(e);
         const wait = e instanceof RateLimitedError ? e.retryAfterMs : backendSec !== void 0 ? backendSec * 1e3 : null;
         if (wait === null) throw e;
-        const waitMs = Math.min(REPLY_RATE_LIMIT_MAX_WAIT_MS, Math.max(REPLY_RATE_LIMIT_MIN_WAIT_MS, wait));
+        const waitMs2 = Math.min(REPLY_RATE_LIMIT_MAX_WAIT_MS, Math.max(REPLY_RATE_LIMIT_MIN_WAIT_MS, wait));
         if (rateLimited >= REPLY_RATE_LIMIT_RETRIES) {
-          throw e instanceof RateLimitedError ? e : new RateLimitedError(channelId, waitMs);
+          throw e instanceof RateLimitedError ? e : new RateLimitedError(channelId, waitMs2);
         }
         rateLimited++;
         this.replyRateLimitRetries++;
-        writeServiceLog2("info", "reply.rate_limited_retry", { attempt: rateLimited, wait_ms: waitMs });
-        await this.replySleep(waitMs);
+        writeServiceLog2("info", "reply.rate_limited_retry", { attempt: rateLimited, wait_ms: waitMs2 });
+        await this.replySleep(waitMs2);
       }
     }
   }
@@ -31644,6 +31694,13 @@ var BridgeAgent = class _BridgeAgent {
     if (needsRuntime(text)) return { kind: "ack", line: deferAck(messageId), intent: true };
     return { kind: "fast" };
   }
+  noteVoiceCoalesced(messageId) {
+    this.voiceCoalescedIds.add(messageId);
+    if (this.voiceCoalescedIds.size > _BridgeAgent.FAST_PATH_SEEN_CAP) {
+      const oldest = this.voiceCoalescedIds.values().next().value;
+      if (oldest !== void 0) this.voiceCoalescedIds.delete(oldest);
+    }
+  }
   markFastPathSeen(messageId) {
     this.fastPathSeen.add(messageId);
     if (this.fastPathSeen.size > _BridgeAgent.FAST_PATH_SEEN_CAP) {
@@ -31660,22 +31717,36 @@ var BridgeAgent = class _BridgeAgent {
    * reserve a room send-floor token until they finish. A job never throws.
    */
   enqueueFastReply(channelId, job, spends = true) {
-    if (spends) {
-      this.fastReplyJobs++;
-      this.fastReplyReserved.set(channelId, (this.fastReplyReserved.get(channelId) ?? 0) + 1);
-    }
+    const release = spends ? this.reserveFastReply(channelId) : void 0;
     const prev = this.fastReplyChains.get(channelId) ?? Promise.resolve();
     const next = prev.then(() => this.outsideIngestCycle(job)).catch((e) => writeServiceLog2("warn", "voice.fast_reply_job_failed", {}, e)).finally(() => {
-      if (spends) {
-        this.fastReplyJobs--;
-        const left3 = (this.fastReplyReserved.get(channelId) ?? 1) - 1;
-        if (left3 > 0) this.fastReplyReserved.set(channelId, left3);
-        else this.fastReplyReserved.delete(channelId);
-      }
+      release?.();
       if (this.fastReplyChains.get(channelId) === next) this.fastReplyChains.delete(channelId);
     });
     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) {
+    this.fastReplyJobs++;
+    this.fastReplyReserved.set(channelId, (this.fastReplyReserved.get(channelId) ?? 0) + 1);
+    return () => {
+      this.fastReplyJobs--;
+      const left3 = (this.fastReplyReserved.get(channelId) ?? 1) - 1;
+      if (left3 > 0) this.fastReplyReserved.set(channelId, left3);
+      else this.fastReplyReserved.delete(channelId);
+    };
+  }
+  /**
+   * Speak a planned fast turn ("ack" or "fast") and settle its held frame:
+   * retired when the fast model answered alone, otherwise released to the
+   * runtime (with the "ack already spoken" guidance only when an ack or a
+   * deferring fast reply was actually published — F3).
+   */
+  async speakAndSettle(turn, plan, held, heldAfterAck, fastText, guidance, fastSpeaker, greeting) {
+    const outcome = plan.kind === "ack" ? await this.sendFastLine(turn.channelId, turn.messageId, plan.line) ? "deferred" : "failed" : await this.runFastReply(turn, fastText, guidance, fastSpeaker, greeting);
+    if (outcome === "answered") await this.settleHeldRuntimeMessage(held, false);
+    else await this.settleHeldRuntimeMessage(outcome === "deferred" ? heldAfterAck : held, true);
+  }
   /**
    * Stage a runtime frame without overtaking a turn of the same channel that
    * is still queued behind the fast path (F2): while the channel has a queue,
@@ -31691,10 +31762,19 @@ var BridgeAgent = class _BridgeAgent {
   async settleFastReplies() {
     while (this.fastReplyChains.size) await Promise.all([...this.fastReplyChains.values()]);
   }
+  /** Send a line the voice fast path speaks: its memory record is "voice" (H1). */
+  async sendSpoken(channelId, text, messageId) {
+    this.spokenReplyIds.add(messageId);
+    try {
+      await this.send(channelId, text, messageId);
+    } finally {
+      this.spokenReplyIds.delete(messageId);
+    }
+  }
   /** Speak a fixed acknowledgement line; failures are counted, never thrown. */
   async sendFastLine(channelId, messageId, line) {
     try {
-      await this.send(channelId, line, fastReplyId(this.replyIdKey, this.cfg.identityId, channelId, messageId));
+      await this.sendSpoken(channelId, line, fastReplyId(this.replyIdKey, this.cfg.identityId, channelId, messageId));
       this.fastPathSent++;
       return true;
     } catch (e) {
@@ -31751,7 +31831,7 @@ var BridgeAgent = class _BridgeAgent {
       const raw = await this.latency.time("voice.fast_llm", () => fastLlm.complete(messages));
       const { reply, defer } = splitFastReply(raw, 200, maxSentences);
       if (!reply) return "failed";
-      await this.send(m.channelId, reply, fastReplyId(this.replyIdKey, this.cfg.identityId, m.channelId, m.messageId));
+      await this.sendSpoken(m.channelId, reply, fastReplyId(this.replyIdKey, this.cfg.identityId, m.channelId, m.messageId));
       this.fastPathSent++;
       if (defer) this.fastPathDeferred++;
       return defer ? "deferred" : "answered";
@@ -31784,15 +31864,48 @@ var BridgeAgent = class _BridgeAgent {
     }
   }
   /** Settle a held frame: the fast path answered alone (retire it) or the runtime answers next (release it, in channel order). */
-  settleHeldRuntimeMessage(message, release) {
+  async settleHeldRuntimeMessage(message, release) {
     if (!this.runtimePendingIds.has(message.message_id)) return;
     if (!release) {
       this.ackRuntimeMessages([message.message_id]);
       return;
     }
-    this.buffer.push(message);
+    const memory = await this.memoryAtRelease(message);
+    if (this.closingDown || !this.runtimePendingIds.has(message.message_id)) return;
+    this.buffer.push(memory === message.memory ? message : { ...message, memory });
     this.wakeListeners();
   }
+  /**
+   * Voice repeats (b): a held frame's memory was read when its turn ARRIVED,
+   * before the replies queued ahead of it (an earlier turn's fast reply, this
+   * turn's own ack) were spoken. The runtime replaces its history with the
+   * frame's memory, so with the arrival snapshot it answered an
+   * already-answered turn again. At release the context is re-read and the
+   * AGENT turns it holds beyond the snapshot (afterPublish ->
+   * recordOutboundMemory) are appended to the snapshot. Peer turns recorded
+   * since (this turn itself, later turns) are not, so the frame stays
+   * prior-turn-only for what the runtime is about to answer. New turns are
+   * found by recorded time, never by `seq` (the OpenClaw provider renumbers
+   * seq per read). A failed re-read keeps the arrival snapshot.
+   */
+  async memoryAtRelease(message) {
+    const prior = message.memory;
+    if (!prior || !this.mayReadOpenClawMemoryForTurn(message.authorization)) return prior;
+    let fresh;
+    try {
+      fresh = await this.memory.context(message.channel_id, _BridgeAgent.TURN_MEMORY_LIMIT);
+    } catch {
+      return prior;
+    }
+    const after = prior.recent.reduce((max, turn) => Math.max(max, turn.ts ?? 0), message.ts);
+    const spoken = fresh.recent.filter((turn) => turn.role === "agent" && turn.ts !== void 0 && turn.ts > after);
+    if (spoken.length === 0) return prior;
+    return {
+      recent: [...prior.recent, ...spoken].slice(-_BridgeAgent.TURN_MEMORY_LIMIT),
+      facts: prior.facts
+    };
+  }
+  static TURN_MEMORY_LIMIT = 50;
   /**
    * List channels in one enclave (default: the daemon's own home enclave).
    * Task 3: called per-*known* enclave by refreshChannelMeta so a
@@ -32054,10 +32167,22 @@ var BridgeAgent = class _BridgeAgent {
    * Missing or stale metadata is UNKNOWN with zero grants, never a permissive
    * guess. The returned object and grant array are frozen before they cross the
    * daemon boundary so one consumer cannot widen a later execution check.
+   *
+   * Grants (architect ruling 2026-10-02): OWNER_DM_DEFAULT_READ_GRANTS only when
+   * the kill switch is on, the channel is a DM, and EITHER
+   *   (a) audience is owner_dm AND the sender is the pinned structural owner
+   *       (`channelOwner`, never "anomalous") — a lying `is_agent_owner` flag
+   *       alone gets nothing; OR
+   *   (b) the sender is this channel's server-marked relay (`is_relay`) and the
+   *       relayed `speaker_identity_id` (passed by the caller only for relay
+   *       turns) is that same pinned owner, whose roster row is the agent's
+   *       owner. A speaker claim from any non-relay sender gets nothing.
+   * Everything else gets the frozen empty list.
    */
-  authorizationFor(channelId, senderId) {
+  authorizationFor(channelId, senderId, relaySpeakerId) {
     const meta = this.freshMeta(channelId);
-    const sender = this.freshRoster(channelId)?.get(senderId);
+    const roster = this.freshRoster(channelId);
+    const sender = roster?.get(senderId);
     let audience = "unknown";
     if (meta && sender) {
       if (sender.is_agent) audience = "agent_to_agent";
@@ -32066,11 +32191,71 @@ var BridgeAgent = class _BridgeAgent {
       else if (sender.is_partner) audience = "partner_room";
       else audience = "team_room";
     }
+    let tool_grants = NO_TOOL_GRANTS;
+    if (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;
+        if (ownerDirect || ownerRelayed) tool_grants = OWNER_DM_DEFAULT_READ_GRANTS;
+      }
+    }
+    this.logAuthzDecision(channelId, senderId, relaySpeakerId, audience, tool_grants.length);
     return Object.freeze({
       version: 1,
       audience,
       sender_membership: sender ? "active" : "unknown",
-      tool_grants: Object.freeze([])
+      tool_grants
+    });
+  }
+  /**
+   * One content-free INFO line per authorization decision (every call site of
+   * authorizationFor stages exactly one runtime turn). It says WHY a turn got
+   * the grants it got, without any identifier, name or text: every field is a
+   * boolean, a count, or a closed-set label.
+   *
+   *   owner_pin                pinned | anomalous | missing (channelOwner cache)
+   *   owner_row_is_agent_owner the pinned owner's roster row; `absent` when
+   *                            there is no pin or the row is not in the roster
+   *   sender_is_owner          sender identity == pinned owner identity
+   *   relay                    sender's roster row has is_relay
+   *   relay_speaker_is_owner   `na` unless a relay speaker was passed
+   *   kill_switch              SECURECOMS_OWNER_DM_DEFAULT_GRANTS as read at
+   *                            startup: `on` = default grants enabled
+   *   meta_fresh / roster_fresh whether the channel meta / roster caches were
+   *                            fresh (either stale forces audience=unknown)
+   */
+  logAuthzDecision(channelId, senderId, relaySpeakerId, audience, grants) {
+    const meta = this.freshMeta(channelId);
+    const roster = this.freshRoster(channelId);
+    const sender = roster?.get(senderId);
+    const pinned = this.channelOwner.get(channelId);
+    const ownerId = pinned && pinned !== "anomalous" ? pinned.identityId : void 0;
+    const ownerRow = ownerId !== void 0 ? roster?.get(ownerId) : void 0;
+    const ownerPin = pinned === void 0 ? "missing" : pinned === "anomalous" ? "anomalous" : "pinned";
+    const ownerRowIsAgentOwner = ownerRow === void 0 ? "absent" : ownerRow.is_agent_owner ? "true" : "false";
+    const speakerIsOwner = relaySpeakerId === void 0 ? "na" : ownerId !== void 0 && relaySpeakerId === ownerId ? "true" : "false";
+    writeServiceLog2("info", "authz.decision", {
+      audience: ServiceLogEnum.of(audience, [
+        "owner_dm",
+        "other_human_dm",
+        "team_room",
+        "partner_room",
+        "agent_to_agent",
+        "unknown"
+      ]),
+      grants,
+      owner_pin: ServiceLogEnum.of(ownerPin, ["pinned", "anomalous", "missing"]),
+      owner_row_is_agent_owner: ServiceLogEnum.of(ownerRowIsAgentOwner, ["true", "false", "absent"]),
+      sender_is_owner: ownerId !== void 0 && senderId === ownerId,
+      relay: sender?.is_relay === true,
+      relay_speaker_is_owner: ServiceLogEnum.of(speakerIsOwner, ["true", "false", "na"]),
+      is_dm: meta?.is_dm === true,
+      kill_switch: ServiceLogEnum.of(this.ownerDmDefaultGrants ? "on" : "off", ["on", "off"]),
+      meta_fresh: meta !== void 0,
+      roster_fresh: roster !== void 0
     });
   }
   /**
@@ -32578,11 +32763,36 @@ var BridgeAgent = class _BridgeAgent {
     this.ingestInFlight = entry;
     return promise;
   }
+  /**
+   * (4) recv.lag = server message created_at -> this pull's completion, per
+   * application row, counted once per queue id. It makes the daemon-side
+   * receive delay measurable (recv.pull alone times only the HTTP call).
+   * Cross-clock: daemon-vs-server skew lands in the sample; a negative lag
+   * is clamped to 0. The server serialises a naive UTC datetime (no offset),
+   * which Date.parse would read as LOCAL time, so a bare timestamp is UTC.
+   */
+  recordRecvLag(rows) {
+    const now = Date.now();
+    for (const row of rows) {
+      if (row.message_type !== "application" || typeof row.queue_id !== "string") continue;
+      if (typeof row.created_at !== "string" || this.recvLagSeen.has(row.queue_id)) continue;
+      const iso = /(Z|[+-]\d{2}:?\d{2})$/i.test(row.created_at) ? row.created_at : `${row.created_at}Z`;
+      const createdAt = Date.parse(iso);
+      if (!Number.isFinite(createdAt)) continue;
+      this.recvLagSeen.add(row.queue_id);
+      if (this.recvLagSeen.size > _BridgeAgent.RECV_LAG_SEEN_CAP) {
+        const oldest = this.recvLagSeen.values().next().value;
+        if (oldest !== void 0) this.recvLagSeen.delete(oldest);
+      }
+      this.latency.record("recv.lag", Math.max(0, now - createdAt));
+    }
+  }
   async ingestCycle() {
     if (this.closingDown) return;
     const cycleStart = performance.now();
     try {
       const rows = await this.latency.time("recv.pull", () => this.backend.pullDelivery(this.cfg.deviceId));
+      this.recordRecvLag(rows);
       const channelIds = /* @__PURE__ */ new Set();
       for (const row of rows) {
         if (row.connect_channel_id) channelIds.add(row.connect_channel_id);
@@ -32839,21 +33049,23 @@ var BridgeAgent = class _BridgeAgent {
             )?.name;
             const turnAuthorization = this.authorizationFor(
               m.channelId,
-              m.envelope.sender_id
+              m.envelope.sender_id,
+              speaker?.identityId
             );
             const runtimeMemory = this.memoryForTurn(m.channelId, turnAuthorization);
             const voiceGuidance = m.voiceMode ? selectVoiceGuidance(meta?.is_dm, m.voiceDefaultResponder) : void 0;
             const humanTurn = senderIsAgent !== true || speaker !== void 0;
             const fastPathEligible = Boolean(m.voiceMode && humanTurn && this.fastLlm && voiceGuidance);
+            const turnText = parsed.text;
+            const isCallStart = turnText.trim() === VOICE_CALL_START_MARKER;
+            const coalescible = this.voiceCoalesceWindowMs > 0 && m.voiceMode === true && speaker !== void 0 && parsed.transcribed === true && voiceGuidance !== void 0 && !isCallStart;
             let fastPathRoomBlocked = false;
-            if (fastPathEligible && meta && meta.is_dm === 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;
             }
             if (fastPathRoomBlocked) this.fastPathSkipped++;
             const fastPathFiring = fastPathEligible && !fastPathRoomBlocked && !this.pausedChannels.has(m.channelId);
-            const turnText = parsed.text;
-            const isCallStart = turnText.trim() === VOICE_CALL_START_MARKER;
             const fastGreeting = isCallStart && fastPathFiring;
             const runtimeVoice = (ackSent) => m.voiceMode ? {
               voice: true,
@@ -32874,6 +33086,95 @@ var BridgeAgent = class _BridgeAgent {
               ...speaker ? { speaker } : {},
               ...runtimeVoice(ackSent)
             });
+            if (coalescible) {
+              if (this.voiceCoalescedIds.has(m.messageId) || this.runtimePendingIds.has(m.messageId)) {
+                acked.push(m.queueId);
+                continue;
+              }
+              const windowKey = `${m.channelId}\0${speaker.identityId}`;
+              const open = this.voiceCoalescing.get(windowKey);
+              if (open && !open.closed) {
+                open.ids.push(m.messageId);
+                open.parts.push(turnText);
+                const staging = (async () => {
+                  const ok = await this.stageHeldRuntimeMessage(runtimeEntry(false, await runtimeMemory));
+                  if (!ok) {
+                    const i = open.ids.indexOf(m.messageId);
+                    if (i > 0) {
+                      open.ids.splice(i, 1);
+                      open.parts.splice(i, 1);
+                    }
+                  }
+                  return ok;
+                })();
+                open.pending = Promise.all([open.pending, staging]);
+                if (!await staging) continue;
+                this.noteVoiceCoalesced(m.messageId);
+                acked.push(m.queueId);
+                continue;
+              }
+              const held = runtimeEntry(false, await runtimeMemory);
+              if (!await this.stageHeldRuntimeMessage(held)) continue;
+              this.noteVoiceCoalesced(m.messageId);
+              const win = {
+                speakerId: speaker.identityId,
+                ids: [m.messageId],
+                parts: [turnText],
+                closed: false,
+                pending: Promise.resolve()
+              };
+              this.voiceCoalescing.set(windowKey, win);
+              const openedAt = Date.now();
+              const channelId = m.channelId;
+              const senderId = m.envelope.sender_id;
+              const isRoom = meta?.is_dm === false;
+              this.enqueueFastReply(channelId, async () => {
+                await waitMs(openedAt + this.voiceCoalesceWindowMs - Date.now());
+                win.closed = true;
+                if (this.voiceCoalescing.get(windowKey) === win) this.voiceCoalescing.delete(windowKey);
+                await win.pending;
+                if (this.closingDown) return;
+                const [firstId, ...tailIds] = win.ids;
+                if (tailIds.length) this.voiceCoalescedTails.set(firstId, tailIds);
+                const text = win.parts.join(" ");
+                const merged = { ...held, text };
+                void recordInboundMemory(this.memory, channelId, senderId, text, firstId, "voice");
+                let roomBlocked = false;
+                if (fastPathEligible && isRoom) {
+                  const reserved = this.fastReplyReserved.get(channelId) ?? 0;
+                  if (this.rateFloor.available(`room:${channelId}`) - reserved < 2) roomBlocked = true;
+                }
+                if (roomBlocked) this.fastPathSkipped++;
+                const plan = fastPathEligible && !roomBlocked && !this.pausedChannels.has(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);
+                  return;
+                }
+                this.markFastPathSeen(firstId);
+                if (plan.kind === "ack") {
+                  this.fastPathDeferred++;
+                  if (plan.intent) this.fastPathIntentDeferred++;
+                }
+                const release = this.reserveFastReply(channelId);
+                try {
+                  await this.speakAndSettle(
+                    { channelId, messageId: firstId, senderId, authorization: turnAuthorization },
+                    plan,
+                    merged,
+                    { ...merged, ...runtimeVoice(true) },
+                    text,
+                    voiceGuidance,
+                    speaker,
+                    false
+                  );
+                } finally {
+                  release();
+                }
+              }, false);
+              acked.push(m.queueId);
+              continue;
+            }
             if (fastPathFiring) {
               const fastSpeaker = speaker ?? (senderName ? { identityId: m.envelope.sender_id, displayName: senderName } : void 0);
               const fastText = fastGreeting ? greetingTurnFor(this.voiceSettings ?? DEFAULT_VOICE_SETTINGS, fastSpeaker?.displayName) : parsed.text;
@@ -32899,11 +33200,11 @@ var BridgeAgent = class _BridgeAgent {
                   this.fastPathDeferred++;
                   if (ack.intent) this.fastPathIntentDeferred++;
                 }
-                this.enqueueFastReply(m.channelId, async () => {
-                  const outcome = ack ? await this.sendFastLine(turn.channelId, turn.messageId, ack.line) ? "deferred" : "failed" : await this.runFastReply(turn, fastText, guidanceForFast, fastSpeaker, greeting);
-                  if (outcome === "answered") this.settleHeldRuntimeMessage(held, false);
-                  else this.settleHeldRuntimeMessage(outcome === "deferred" ? { ...held, ...runtimeVoice(true) } : held, true);
-                });
+                const heldAfterAck = { ...held, ...runtimeVoice(true) };
+                this.enqueueFastReply(
+                  m.channelId,
+                  () => this.speakAndSettle(turn, ack ?? plan, held, heldAfterAck, fastText, guidanceForFast, fastSpeaker, greeting)
+                );
               }
             } else {
               if (!await this.stageRuntimeMessageInOrder(runtimeEntry(false, await runtimeMemory))) continue;
@@ -33324,6 +33625,11 @@ var BridgeAgent = class _BridgeAgent {
       this.deliveryAttempts.delete(messageId);
       this.redeliverNotBefore.delete(messageId);
       this.supersedeRefundable.delete(messageId);
+      const tails = this.voiceCoalescedTails.get(messageId);
+      if (tails) {
+        this.voiceCoalescedTails.delete(messageId);
+        this.ackRuntimeMessages(tails);
+      }
     }
   }
   async restoreRuntimeInbox() {

package/dist/memory-taps.d.ts

@@ -12,6 +12,7 @@ interface MemorySink {
  *  for a turn whose InboxEntry had the server-set `voiceMode` flag, so memory
  *  continuity reflects how the turn actually arrived. */
 export declare function recordInboundMemory(sink: MemorySink, channelId: string, senderId: string, text: string, messageId: string, modality?: "text" | "voice"): Promise<void>;
-/** Record the agent's own outbound text reply. Best-effort. */
-export declare function recordOutboundMemory(sink: MemorySink, channelId: string, text: string, messageId: string): Promise<void>;
+/** Record the agent's own outbound reply. Best-effort. `modality` is "voice"
+ *  for a line the voice fast path spoke (H1), else "text". */
+export declare function recordOutboundMemory(sink: MemorySink, channelId: string, text: string, messageId: string, modality?: "text" | "voice"): Promise<void>;
 export {};

package/dist/service-log.d.ts

@@ -1,5 +1,18 @@
 export type ServiceLogLevel = "debug" | "info" | "warn" | "error";
-export type ServiceLogFields = Readonly<Record<string, number | boolean>>;
+/**
+ * A closed-set label for a service-log field. The only way to build one is
+ * `ServiceLogEnum.of(value, allowed)`: a value outside `allowed`, or one that
+ * is not a short lowercase word, renders as `invalid`. Raw strings are still
+ * dropped by `formatServiceLog`, so an identifier, name or message text can
+ * never reach the log through a field. The privacy test requires `allowed` to
+ * be an inline array of string literals at every call site.
+ */
+export declare class ServiceLogEnum {
+    readonly value: string;
+    private constructor();
+    static of<T extends string>(value: T, allowed: readonly T[]): ServiceLogEnum;
+}
+export type ServiceLogFields = Readonly<Record<string, number | boolean | ServiceLogEnum>>;
 export type ServiceLog = (level: ServiceLogLevel, event: string, fields?: ServiceLogFields, error?: unknown) => void;
 /** Reduce a thrown value without reading its message, stack, or string form. */
 export declare function errorClass(error: unknown): string;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const BRIDGE_VERSION = "0.26.1";
+export declare const BRIDGE_VERSION = "0.26.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@securecoms/agent-bridge",
-  "version": "0.26.1",
+  "version": "0.26.3",
   "type": "module",
   "engines": {
     "node": ">=22.5.0"