@xmoxmo/bncr 0.3.3 → 0.3.5

package/src/core/accounts.ts

@@ -53,4 +53,4 @@ export function listAccountIds(cfg: any): string[] {
   return ids.length ? ids : [BNCR_DEFAULT_ACCOUNT_ID];
 }
 
-export { CHANNEL_ID, BNCR_DEFAULT_ACCOUNT_ID };
+export { BNCR_DEFAULT_ACCOUNT_ID, CHANNEL_ID };

package/src/core/connection-capability.ts

@@ -56,8 +56,8 @@ export function findCapabilityConnection(args: {
 
 export function buildCapabilitySnapshot(connection: CapabilityConnection) {
   return {
-    outboundReadyUntil: connection.outboundReadyUntil || null,
-    preferredForOutboundUntil: connection.preferredForOutboundUntil || null,
+    outboundReadyUntil: connection.outboundReadyUntil ?? null,
+    preferredForOutboundUntil: connection.preferredForOutboundUntil ?? null,
     inboundOnly: connection.inboundOnly === true,
   };
 }

package/src/core/connection-reachability.ts

@@ -94,6 +94,112 @@ export function hasAlternativeLiveConnection(args: {
   return false;
 }
 
+type OutboundPushCandidateConnection = BncrConnection & {
+  inboundOnly?: boolean;
+  preferredForOutboundUntil?: number;
+  outboundReadyUntil?: number;
+  lastAckOkAt?: number;
+  lastPushTimeoutAt?: number;
+  pushFailureScore?: number;
+};
+
+export function isEligibleOutboundPushConnection(args: {
+  connection?: BncrConnection | null;
+  now: number;
+  connectTtlMs: number;
+}): args is { connection: OutboundPushCandidateConnection; now: number; connectTtlMs: number } {
+  const conn = args.connection as OutboundPushCandidateConnection | null | undefined;
+  if (!conn?.connId) return false;
+  const nowMs = finiteNumberOr(args.now, 0);
+  const connectTtlMs = finiteNumberOr(args.connectTtlMs, 0);
+  const lastSeenAt = finiteNumberOr(conn.lastSeenAt, 0);
+  if (!nowMs || !connectTtlMs || !lastSeenAt) return false;
+  if (nowMs - lastSeenAt > connectTtlMs) return false;
+  if (conn.inboundOnly === true) return false;
+  return true;
+}
+
+function scoreOutboundPushConnection(args: {
+  connection: BncrConnection;
+  now: number;
+  recentInboundConnIds: Set<string>;
+}) {
+  const conn = args.connection as OutboundPushCandidateConnection;
+  const preferredForOutboundUntil = finiteNumberOr(conn.preferredForOutboundUntil, 0);
+  const outboundReadyUntil = finiteNumberOr(conn.outboundReadyUntil, 0);
+  const lastPushTimeoutAt = finiteNumberOr(conn.lastPushTimeoutAt, 0);
+  const lastAckOkAt = finiteNumberOr(conn.lastAckOkAt, 0);
+  const pushFailureScore = finiteNumberOr(conn.pushFailureScore, 0);
+  const recentTimeoutPenalty =
+    lastPushTimeoutAt > 0 && args.now - lastPushTimeoutAt <= 30_000 ? 1 : 0;
+  return {
+    preferred: preferredForOutboundUntil > args.now ? 1 : 0,
+    ready: outboundReadyUntil > args.now ? 1 : 0,
+    recentInbound: args.recentInboundConnIds.has(conn.connId) ? 1 : 0,
+    recentTimeoutPenalty,
+    pushFailureScore,
+    lastAckOkAt,
+    lastPushTimeoutAt,
+    lastSeenAt: finiteNumberOr(conn.lastSeenAt, 0),
+    connectedAt: finiteNumberOr(conn.connectedAt, 0),
+  };
+}
+
+export function compareOutboundPushConnections(args: {
+  a: BncrConnection;
+  b: BncrConnection;
+  now: number;
+  recentInboundConnIds: Set<string>;
+}) {
+  const sa = scoreOutboundPushConnection({
+    connection: args.a,
+    now: args.now,
+    recentInboundConnIds: args.recentInboundConnIds,
+  });
+  const sb = scoreOutboundPushConnection({
+    connection: args.b,
+    now: args.now,
+    recentInboundConnIds: args.recentInboundConnIds,
+  });
+  if (sb.preferred !== sa.preferred) return sb.preferred - sa.preferred;
+  if (sb.ready !== sa.ready) return sb.ready - sa.ready;
+  if (sa.recentTimeoutPenalty !== sb.recentTimeoutPenalty)
+    return sa.recentTimeoutPenalty - sb.recentTimeoutPenalty;
+  if (sa.pushFailureScore !== sb.pushFailureScore) return sa.pushFailureScore - sb.pushFailureScore;
+  if (sb.lastAckOkAt !== sa.lastAckOkAt) return sb.lastAckOkAt - sa.lastAckOkAt;
+  if (sa.lastPushTimeoutAt !== sb.lastPushTimeoutAt)
+    return sa.lastPushTimeoutAt - sb.lastPushTimeoutAt;
+  if (sb.recentInbound !== sa.recentInbound) return sb.recentInbound - sa.recentInbound;
+  if (sb.lastSeenAt !== sa.lastSeenAt) return sb.lastSeenAt - sa.lastSeenAt;
+  return sb.connectedAt - sa.connectedAt;
+}
+
+export function selectOrderedOutboundPushConnections(args: {
+  accountId: string;
+  now: number;
+  connectTtlMs: number;
+  recentInboundConnIds: Set<string>;
+  connections: Iterable<BncrConnection>;
+}) {
+  return Array.from(args.connections)
+    .filter((c): c is BncrConnection => c.accountId === args.accountId)
+    .filter((connection) =>
+      isEligibleOutboundPushConnection({
+        connection,
+        now: args.now,
+        connectTtlMs: args.connectTtlMs,
+      }),
+    )
+    .sort((a, b) =>
+      compareOutboundPushConnections({
+        a,
+        b,
+        now: args.now,
+        recentInboundConnIds: args.recentInboundConnIds,
+      }),
+    );
+}
+
 type ReachableConnection = BncrConnection & {
   inboundOnly?: boolean;
   preferredForOutboundUntil?: number;
@@ -142,7 +248,12 @@ export function getRevalidatedAttemptReason(args: {
       lastPushTimeoutAt <= lastAttemptAt &&
       lastSeenAt > lastPushTimeoutAt;
 
-    if (!revalidatedByPreferred && !revalidatedByReady && !revalidatedByAck && !revalidatedByFreshReachability) {
+    if (
+      !revalidatedByPreferred &&
+      !revalidatedByReady &&
+      !revalidatedByAck &&
+      !revalidatedByFreshReachability
+    ) {
       return null;
     }
 

package/src/core/dead-letter-diagnostics.ts

@@ -0,0 +1,91 @@
+import { summarizeBncrTextPreview } from './logging.ts';
+import { formatDisplayScope } from './targets.ts';
+import type { OutboxEntry } from './types.ts';
+
+export type DeadLetterTopReason = { reason: string; count: number };
+
+export type BuildDeadLetterDiagnosticsOptions = {
+  entries: OutboxEntry[];
+  allAccountsTotal: number;
+  sinceStart: number;
+  cappedAt: number;
+};
+
+function asString(value: unknown, fallback = ''): string {
+  if (typeof value === 'string') return value;
+  if (value == null) return fallback;
+  return String(value);
+}
+
+export function buildDeadLetterDiagnostics(options: BuildDeadLetterDiagnosticsOptions) {
+  const reasonCounts = new Map<string, number>();
+  let oldestAt: number | null = null;
+  let newestAt: number | null = null;
+
+  for (const entry of options.entries) {
+    const reason = asString(entry.lastError || 'unknown').trim() || 'unknown';
+    reasonCounts.set(reason, (reasonCounts.get(reason) || 0) + 1);
+    const createdAt = Number(entry.createdAt);
+    if (Number.isFinite(createdAt)) {
+      oldestAt = oldestAt === null ? createdAt : Math.min(oldestAt, createdAt);
+      newestAt = newestAt === null ? createdAt : Math.max(newestAt, createdAt);
+    }
+  }
+
+  return {
+    total: options.entries.length,
+    allAccountsTotal: options.allAccountsTotal,
+    sinceStart: options.sinceStart,
+    cappedAt: options.cappedAt,
+    oldestAt,
+    newestAt,
+    topReasons: Array.from(reasonCounts.entries())
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .slice(0, 5)
+      .map(([reason, count]) => ({ reason, count })),
+  };
+}
+
+export function formatDeadLetterTopReasons(topReasons: DeadLetterTopReason[]): string {
+  if (!topReasons.length) return '-';
+  return topReasons.map((item) => `${item.reason}:${item.count}`).join(',');
+}
+
+export function parseDeadLetterLimit(raw: unknown, defaultValue: number): number {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return defaultValue;
+  return Math.max(0, Math.min(100, Math.floor(n)));
+}
+
+export function parseDeadLetterOffset(raw: unknown, defaultValue: number): number {
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return defaultValue;
+  return Math.max(0, Math.floor(n));
+}
+
+export function parseDeadLetterOlderThan(raw: unknown): number | null {
+  if (raw === undefined || raw === null) return null;
+  const normalized = typeof raw === 'string' ? raw.trim() : raw;
+  if (normalized === '') return null;
+  const numeric = Number(normalized);
+  if (Number.isFinite(numeric)) return numeric;
+  const parsed = Date.parse(String(normalized));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+export function summarizeDeadLetterEntry(entry: OutboxEntry) {
+  const meta = entry.payload?._meta || {};
+  const msg = (entry.payload as any)?.message || {};
+  const text = asString(meta.text || msg.msg || '');
+  return {
+    messageId: entry.messageId,
+    accountId: entry.accountId,
+    sessionKey: entry.sessionKey,
+    route: formatDisplayScope(entry.route),
+    kind: asString(meta.kind || (entry.payload as any)?.type || 'message'),
+    createdAt: Number.isFinite(Number(entry.createdAt)) ? Number(entry.createdAt) : null,
+    retryCount: Number.isFinite(Number(entry.retryCount)) ? Number(entry.retryCount) : 0,
+    lastError: entry.lastError || null,
+    textPreview: summarizeBncrTextPreview(text, 24),
+  };
+}

package/src/core/diagnostic-counters.ts

@@ -0,0 +1,61 @@
+import { normalizeAccountId } from './accounts.ts';
+import { parseStrictBncrSessionKey } from './targets.ts';
+import type { OutboxEntry } from './types.ts';
+
+export type AccountResidueSessionRoute = { accountId?: string | null };
+
+function hasMismatchedAccountId(raw: unknown, expectedAccountId: string): boolean {
+  const text = String(raw || '').trim();
+  return Boolean(text) && normalizeAccountId(text) !== expectedAccountId;
+}
+
+export function countInvalidOutboxSessionKeys(args: {
+  accountId: string;
+  outboxEntries: Iterable<OutboxEntry>;
+}): number {
+  const accountId = normalizeAccountId(args.accountId);
+  let count = 0;
+  for (const entry of args.outboxEntries) {
+    if (normalizeAccountId(entry.accountId) !== accountId) continue;
+    if (!parseStrictBncrSessionKey(entry.sessionKey)) count += 1;
+  }
+  return count;
+}
+
+export function countLegacyAccountResidue(args: {
+  accountId: string;
+  outboxEntries: Iterable<Pick<OutboxEntry, 'accountId'>>;
+  deadLetterEntries: Iterable<Pick<OutboxEntry, 'accountId'>>;
+  sessionRoutes: Iterable<AccountResidueSessionRoute>;
+  lastSessionAccountIds: Iterable<string>;
+  lastActivityAccountIds: Iterable<string>;
+  lastInboundAccountIds: Iterable<string>;
+  lastOutboundAccountIds: Iterable<string>;
+}): number {
+  const accountId = normalizeAccountId(args.accountId);
+  let count = 0;
+
+  for (const entry of args.outboxEntries) {
+    if (hasMismatchedAccountId(entry.accountId, accountId)) count += 1;
+  }
+  for (const entry of args.deadLetterEntries) {
+    if (hasMismatchedAccountId(entry.accountId, accountId)) count += 1;
+  }
+  for (const info of args.sessionRoutes) {
+    if (hasMismatchedAccountId(info.accountId, accountId)) count += 1;
+  }
+  for (const key of args.lastSessionAccountIds) {
+    if (hasMismatchedAccountId(key, accountId)) count += 1;
+  }
+  for (const key of args.lastActivityAccountIds) {
+    if (hasMismatchedAccountId(key, accountId)) count += 1;
+  }
+  for (const key of args.lastInboundAccountIds) {
+    if (hasMismatchedAccountId(key, accountId)) count += 1;
+  }
+  for (const key of args.lastOutboundAccountIds) {
+    if (hasMismatchedAccountId(key, accountId)) count += 1;
+  }
+
+  return count;
+}

package/src/core/diagnostics.ts

@@ -6,6 +6,10 @@ function finiteNumberOr(value: unknown, fallback: number): number {
   return Number.isFinite(n) ? n : fallback;
 }
 
+function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
+  return Math.max(0, finiteNumberOr(value, fallback));
+}
+
 type DiagnosticsPayloadArgs = {
   cfg: any;
   channelId: string;
@@ -26,11 +30,11 @@ export function buildDiagnosticsPayload(args: DiagnosticsPayloadArgs) {
   const probe = probeBncrAccount({
     accountId: args.accountId,
     connected: Boolean(args.runtime?.connected),
-    pending: finiteNumberOr(args.runtime?.meta?.pending, 0),
-    deadLetter: finiteNumberOr(args.runtime?.meta?.deadLetter, 0),
-    activeConnections: args.activeConnections,
-    invalidOutboxSessionKeys: args.invalidOutboxSessionKeys,
-    legacyAccountResidue: args.legacyAccountResidue,
+    pending: nonNegativeFiniteNumberOr(args.runtime?.meta?.pending, 0),
+    deadLetter: nonNegativeFiniteNumberOr(args.runtime?.meta?.deadLetter, 0),
+    activeConnections: nonNegativeFiniteNumberOr(args.activeConnections, 0),
+    invalidOutboxSessionKeys: nonNegativeFiniteNumberOr(args.invalidOutboxSessionKeys, 0),
+    legacyAccountResidue: nonNegativeFiniteNumberOr(args.legacyAccountResidue, 0),
     lastActivityAt: args.runtime?.meta?.lastActivityAt ?? null,
     structure: {
       coreComplete: true,

package/src/core/downlink-health.ts

@@ -5,6 +5,10 @@ function finiteNumberOr(value: unknown, fallback: number): number {
   return Number.isFinite(n) ? n : fallback;
 }
 
+function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
+  return Math.max(0, finiteNumberOr(value, fallback));
+}
+
 type DownlinkHealthInput = {
   accountId: string;
   now: number;
@@ -24,22 +28,23 @@ export function buildDownlinkHealth(input: DownlinkHealthInput) {
   const oldestPendingCreatedAt = pending.length
     ? Math.min(...pending.map((entry) => finiteNumberOr(entry.createdAt, input.now)))
     : null;
-  const oldestPendingAgeMs = oldestPendingCreatedAt
-    ? Math.max(0, input.now - oldestPendingCreatedAt)
-    : 0;
+  const oldestPendingAgeMs =
+    oldestPendingCreatedAt !== null ? Math.max(0, input.now - oldestPendingCreatedAt) : 0;
   const lastSignalAt =
-    Math.max(finiteNumberOr(input.lastInboundAt, 0), finiteNumberOr(input.lastActivityAt, 0)) || null;
+    Math.max(finiteNumberOr(input.lastInboundAt, 0), finiteNumberOr(input.lastActivityAt, 0)) ||
+    null;
   const inboundHealthy = !!lastSignalAt && input.now - lastSignalAt <= 5 * 60 * 1000;
-  const ackRecentlyHealthy =
-    !!input.lastAckOkAt && input.now - input.lastAckOkAt <= 5 * 60 * 1000;
+  const ackRecentlyHealthy = !!input.lastAckOkAt && input.now - input.lastAckOkAt <= 5 * 60 * 1000;
   const ackTimeoutRecent =
     !!input.lastAckTimeoutAt && input.now - input.lastAckTimeoutAt <= 5 * 60 * 1000;
+  const recentAckTimeoutCount = nonNegativeFiniteNumberOr(input.recentAckTimeoutCount, 0);
+  const activeConnectionCount = nonNegativeFiniteNumberOr(input.activeConnectionCount, 0);
   const ackStalled =
     pendingCount > 0 &&
-    input.activeConnectionCount === 1 &&
+    activeConnectionCount === 1 &&
     inboundHealthy &&
     ackTimeoutRecent &&
-    input.recentAckTimeoutCount > 0 &&
+    recentAckTimeoutCount > 0 &&
     !ackRecentlyHealthy;
 
   return {
@@ -48,8 +53,8 @@ export function buildDownlinkHealth(input: DownlinkHealthInput) {
     oldestPendingAgeMs,
     lastAckOkAt: input.lastAckOkAt,
     lastAckTimeoutAt: input.lastAckTimeoutAt,
-    recentAckTimeoutCount: input.recentAckTimeoutCount,
-    activeConnectionCount: input.activeConnectionCount,
+    recentAckTimeoutCount,
+    activeConnectionCount,
     recentInboundReachable: inboundHealthy,
     onlineByConn: input.onlineByConn,
     ackStalled,

package/src/core/extended-diagnostics.ts

@@ -22,6 +22,8 @@ type ExtendedDiagnosticsInput = {
     traceSummary: Record<string, any>;
     lastDriftSnapshot: any;
   };
+  outbound?: Record<string, any>;
+  deadLetterSummary?: Record<string, any>;
   connection: {
     active: number;
     primaryLeaseId: string | null;
@@ -66,6 +68,8 @@ export function buildExtendedDiagnostics(input: ExtendedDiagnosticsInput) {
       ...input.connection,
       recent: input.connection.recent.map((entry) => ({ ...entry })),
     },
+    outbound: input.outbound ? { ...input.outbound } : undefined,
+    deadLetterSummary: input.deadLetterSummary ? { ...input.deadLetterSummary } : undefined,
     protocol: {
       ...input.protocol,
       features: { ...input.protocol.features },

package/src/core/file-transfer-payloads.ts

@@ -61,10 +61,7 @@ export function buildFileTransferAbortPayload(args: {
   };
 }
 
-export function buildFileTransferCompletePayload(args: {
-  transferId: string;
-  ts: number;
-}) {
+export function buildFileTransferCompletePayload(args: { transferId: string; ts: number }) {
   return {
     transferId: args.transferId,
     ts: args.ts,

package/src/core/logging.ts

@@ -1,7 +1,26 @@
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+
 export type BncrLogLevel = 'info' | 'warn' | 'error';
 export type BncrLogOptions = { debugOnly?: boolean };
 
 const BNCR_PREFIX = '[bncr]';
+const DEBUG_TEXT_PREVIEW_LIMIT = 24;
+const DEBUG_HASH_LENGTH = 12;
+
+const TEXT_PAYLOAD_KEYS = new Set([
+  'caption',
+  'fallbackText',
+  'messageText',
+  'msg',
+  'rawText',
+  'text',
+]);
+const MEDIA_PAYLOAD_KEYS = new Set(['mediaUrl', 'path']);
+const MEDIA_LIST_PAYLOAD_KEYS = new Set(['mediaUrls', 'mediaList']);
+const SENSITIVE_DEBUG_KEY_PATTERN =
+  /(?:authorization|cookie|password|secret|token|api[-_]?key|access[-_]?key|refresh[-_]?key)/i;
+const REDACTED_DEBUG_VALUE = '[redacted]';
 
 type DebugGate = () => boolean;
 
@@ -43,6 +62,85 @@ export function formatBncrLogLine(scope: string | undefined, message: string | u
   return normalizedMessage ? `${prefix} ${normalizedMessage}` : prefix;
 }
 
+function shortHash(raw: string) {
+  return createHash('sha256').update(raw).digest('hex').slice(0, DEBUG_HASH_LENGTH);
+}
+
+function summarizeDebugTextValue(raw: string) {
+  const compact = String(raw || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return {
+    preview: summarizeBncrTextPreview(compact, DEBUG_TEXT_PREVIEW_LIMIT),
+    length: compact.length,
+    sha256: shortHash(compact),
+  };
+}
+
+function mediaUrlBasename(raw: string) {
+  const value = String(raw || '').trim();
+  if (!value) return '';
+  try {
+    const parsed = new URL(value);
+    const decodedPath = decodeURIComponent(parsed.pathname || '');
+    return path.basename(decodedPath) || parsed.hostname || '';
+  } catch {
+    return path.basename(value.split(/[?#]/, 1)[0] || value);
+  }
+}
+
+function summarizeDebugMediaValue(raw: string) {
+  const value = String(raw || '').trim();
+  if (!value) return '';
+  return {
+    basename: mediaUrlBasename(value),
+    scheme: /^[a-z][a-z0-9+.-]*:/i.exec(value)?.[0].slice(0, -1) || 'path',
+    sha256: shortHash(value),
+  };
+}
+
+function sanitizeDebugValue(key: string, value: unknown): unknown {
+  if (SENSITIVE_DEBUG_KEY_PATTERN.test(key)) return REDACTED_DEBUG_VALUE;
+  if (typeof value === 'string') {
+    if (TEXT_PAYLOAD_KEYS.has(key)) return summarizeDebugTextValue(value);
+    if (MEDIA_PAYLOAD_KEYS.has(key)) return summarizeDebugMediaValue(value);
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (MEDIA_LIST_PAYLOAD_KEYS.has(key))
+      return value.map((item) => summarizeDebugMediaValue(String(item || '')));
+    return value.map((item) => sanitizeDebugValue('', item));
+  }
+  if (value && typeof value === 'object')
+    return sanitizeDebugPayload(value as Record<string, unknown>);
+  return value;
+}
+
+export function sanitizeBncrDebugPayload(payload: Record<string, unknown>) {
+  return sanitizeDebugPayload(payload);
+}
+
+function sanitizeDebugPayload(payload: Record<string, unknown>) {
+  const sanitized: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(payload)) {
+    sanitized[key] = sanitizeDebugValue(key, value);
+  }
+  return sanitized;
+}
+
+export function buildBncrDebugJsonMessage(event: string, payload: Record<string, unknown>) {
+  return `${event} ${JSON.stringify(sanitizeBncrDebugPayload(payload))}`;
+}
+
+export function summarizeBncrTextPreview(raw: string, limit = 8) {
+  const compact = String(raw || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!compact) return '-';
+  const chars = Array.from(compact);
+  return chars.length > limit ? `${chars.slice(0, Math.max(1, limit)).join('')}…` : compact;
+}
+
 export function emitBncrLog(
   level: BncrLogLevel,
   scope: string | undefined,

package/src/core/outbox-entry-builders.ts

@@ -1,3 +1,4 @@
+import type { OutboundReplyTargetPolicy } from '../messaging/outbound/reply-target-policy.ts';
 import { normalizeOutboundReplyToId } from '../messaging/outbound/reply-target-policy.ts';
 import type { BncrRoute, OutboxEntry } from './types.ts';
 
@@ -16,6 +17,7 @@ export function buildFileTransferOutboxEntry(args: {
   audioAsVoice?: boolean;
   kind?: 'tool' | 'block' | 'final';
   replyToId?: string;
+  replyTargetPolicy?: OutboundReplyTargetPolicy;
 }): OutboxEntry {
   const messageId = args.createMessageId();
   const createdAt = args.now();
@@ -35,7 +37,12 @@ export function buildFileTransferOutboxEntry(args: {
         asVoice: args.asVoice === true,
         audioAsVoice: args.audioAsVoice === true,
         finalEvent: args.pushEvent,
-        replyToId: normalizeOutboundReplyToId({ kind: args.kind, replyToId: args.replyToId }) || undefined,
+        replyToId:
+          normalizeOutboundReplyToId({
+            kind: args.kind,
+            replyToId: args.replyToId,
+            replyTargetPolicy: args.replyTargetPolicy,
+          }) || undefined,
         messageKind: args.kind,
       },
     },
@@ -56,6 +63,7 @@ export function buildTextOutboxEntry(args: {
   text: string;
   kind?: 'tool' | 'block' | 'final';
   replyToId?: string;
+  replyTargetPolicy?: OutboundReplyTargetPolicy;
 }): OutboxEntry {
   const messageId = args.createMessageId();
   const createdAt = args.now();
@@ -64,7 +72,12 @@ export function buildTextOutboxEntry(args: {
     messageId,
     idempotencyKey: messageId,
     sessionKey: args.sessionKey,
-    replyToId: normalizeOutboundReplyToId({ kind: args.kind, replyToId: args.replyToId }) || undefined,
+    replyToId:
+      normalizeOutboundReplyToId({
+        kind: args.kind,
+        replyToId: args.replyToId,
+        replyTargetPolicy: args.replyTargetPolicy,
+      }) || undefined,
     message: {
       platform: args.route.platform,
       groupId: args.route.groupId,

package/src/core/outbox-file-transfer-bookkeeping.ts

@@ -1,5 +1,5 @@
-import type { BncrConnection, OutboxEntry } from './types.ts';
 import { buildPushOkArgs } from './outbox-push-args.ts';
+import type { BncrConnection, OutboxEntry } from './types.ts';
 
 export function buildFileTransferPushSuccessArgs(args: {
   entry: OutboxEntry;

package/src/core/outbox-file-transfer-failure.ts

@@ -1,5 +1,5 @@
-import type { OutboxEntry } from './types.ts';
 import { buildPushFailureArgs } from './outbox-push-args.ts';
+import type { OutboxEntry } from './types.ts';
 
 export function resolveFileTransferFailureState(args: {
   entry: OutboxEntry;
@@ -13,10 +13,7 @@ export function resolveFileTransferFailureState(args: {
   };
 }
 
-export function buildFileTransferPushFailureArgs(args: {
-  entry: OutboxEntry;
-  retryable: boolean;
-}) {
+export function buildFileTransferPushFailureArgs(args: { entry: OutboxEntry; retryable: boolean }) {
   return buildPushFailureArgs({
     entry: args.entry,
     retryable: args.retryable,

package/src/core/outbox-file-transfer-success.ts

@@ -1,8 +1,5 @@
+import { buildPushBroadcastPayload, buildPushRouteSelectArgs } from './outbox-push-args.ts';
 import type { BncrConnection, OutboxEntry } from './types.ts';
-import {
-  buildPushBroadcastPayload,
-  buildPushRouteSelectArgs,
-} from './outbox-push-args.ts';
 
 export function buildFileTransferBroadcastPayload(args: {
   frame: Record<string, unknown>;

package/src/core/outbox-text-push-failure.ts

@@ -1,9 +1,7 @@
-import type { OutboxEntry } from './types.ts';
 import { buildPushFailureArgs } from './outbox-push-args.ts';
+import type { OutboxEntry } from './types.ts';
 
-export function buildTextPushFailureArgs(args: {
-  entry: OutboxEntry;
-}) {
+export function buildTextPushFailureArgs(args: { entry: OutboxEntry }) {
   return buildPushFailureArgs({
     entry: args.entry,
   });

package/src/core/outbox-text-push-success.ts

@@ -1,9 +1,9 @@
-import type { BncrConnection, OutboxEntry } from './types.ts';
 import {
   buildPushBroadcastPayload,
   buildPushOkArgs,
   buildPushRouteSelectArgs,
 } from './outbox-push-args.ts';
+import type { BncrConnection, OutboxEntry } from './types.ts';
 
 export function buildTextPushBroadcastPayload(args: {
   payload: Record<string, unknown>;