@evomap/evolver 1.89.20 → 2.0.0-beta.0

package/src/proxy/sync/engine.js

@@ -1,179 +0,0 @@
-'use strict';
-
-const { OutboundSync } = require('./outbound');
-const { InboundSync, DEFAULT_POLL_INTERVAL_ACTIVE, DEFAULT_POLL_INTERVAL_IDLE } = require('./inbound');
-const { AuthError } = require('../lifecycle/manager');
-
-const DEFAULT_OUTBOUND_INTERVAL = 5_000;
-const IDLE_THRESHOLD = 5 * 60_000;
-
-class SyncEngine {
-  constructor({ store, hubUrl, getHeaders, logger, onInboundReceived, onAuthError, onOutboundFlushed }) {
-    this.store = store;
-    this.hubUrl = hubUrl;
-    this.logger = logger || console;
-    this.getHeaders = getHeaders;
-    this.onInboundReceived = onInboundReceived || null;
-    this.onAuthError = onAuthError || null;
-    this.onOutboundFlushed = onOutboundFlushed || null;
-
-    this.outbound = new OutboundSync({ store, hubUrl, getHeaders, logger });
-    this.inbound = new InboundSync({ store, hubUrl, getHeaders, logger });
-
-    this._outTimer = null;
-    this._inTimer = null;
-    this._running = false;
-    this._lastActivity = Date.now();
-  }
-
-  start() {
-    if (this._running) return;
-    this._running = true;
-    this._lastActivity = Date.now();
-    this._scheduleOutbound(500);
-    this._scheduleInbound(1_000);
-    this.logger.log('[sync] engine started');
-  }
-
-  stop() {
-    this._running = false;
-    if (this._outTimer) { clearTimeout(this._outTimer); this._outTimer = null; }
-    if (this._inTimer) { clearTimeout(this._inTimer); this._inTimer = null; }
-    this.logger.log('[sync] engine stopped');
-  }
-
-  notifyNewOutbound() {
-    this._lastActivity = Date.now();
-    if (this._running && !this._outPending) {
-      if (this._outTimer) clearTimeout(this._outTimer);
-      this._scheduleOutbound(100);
-    }
-  }
-
-  _isIdle() {
-    return (Date.now() - this._lastActivity) > IDLE_THRESHOLD;
-  }
-
-  async _handleAuthError(source) {
-    this.logger.error(`[sync] auth error from ${source}, triggering re-authentication`);
-    if (typeof this.onAuthError === 'function') {
-      try { await this.onAuthError(); } catch (e) {
-        this.logger.error(`[sync] onAuthError callback failed: ${e.message}`);
-      }
-    }
-  }
-
-  _scheduleOutbound(delayMs) {
-    if (!this._running) return;
-    this._outTimer = setTimeout(async () => {
-      // Defence-in-depth: a throw from this.outbound.flush(),
-      // this.store.countPending(), or any post-flush bookkeeping used
-      // to escape the setTimeout callback. Node logs the unhandled
-      // rejection and the next setTimeout was never armed — the
-      // outbound sync loop silently died until the process restarted,
-      // while `_running` stayed true (no signal to the caller).
-      //
-      // Mirrors the heartbeat-loop fix in PR #147 (issue #544): wrap
-      // the whole tick, schedule the next iteration in `finally` so a
-      // surprise throw cannot park the loop.
-      let nextDelay = DEFAULT_OUTBOUND_INTERVAL;
-      let hubRetryAfterMs = 0;
-      try {
-        if (!this._running) return;
-        this._outPending = true;
-        try {
-          const result = await this.outbound.flush();
-          if (result.sent > 0) this._lastActivity = Date.now();
-          if (result.retryAfterMs > 0) hubRetryAfterMs = result.retryAfterMs;
-          if ((result.sent > 0 || result.dropped > 0) && typeof this.onOutboundFlushed === 'function') {
-            try { this.onOutboundFlushed(result); } catch (e) {
-              this.logger.warn?.('[sync] onOutboundFlushed callback failed:', e.message);
-            }
-          }
-        } catch (err) {
-          if (err instanceof AuthError) {
-            await this._handleAuthError('outbound');
-          } else {
-            this.logger.error(`[sync] outbound error: ${err.message}`);
-          }
-        }
-        this._outPending = false;
-        if (hubRetryAfterMs > 0) {
-          nextDelay = Math.max(1_000, hubRetryAfterMs);
-        } else {
-          try {
-            const pending = this.store.countPending({ direction: 'outbound' });
-            if (pending > 0) nextDelay = 1_000;
-          } catch (err) {
-            // countPending threw (corrupt store, FS hiccup): keep the
-            // default cadence rather than parking the loop.
-            this.logger.error(`[sync] countPending threw (non-fatal): ${err && err.message}`);
-          }
-        }
-      } catch (err) {
-        // Anything that escaped the inner blocks above. Log and let
-        // finally re-arm the timer.
-        this.logger.error(`[sync] outbound tick threw (non-fatal): ${err && err.message}`);
-        this._outPending = false;
-      } finally {
-        if (this._running) this._scheduleOutbound(nextDelay);
-      }
-    }, delayMs);
-    if (this._outTimer.unref) this._outTimer.unref();
-  }
-
-  _scheduleInbound(delayMs) {
-    if (!this._running) return;
-    this._inTimer = setTimeout(async () => {
-      // Same defence-in-depth pattern as _scheduleOutbound: a throw
-      // from inbound.pull / ackDelivered / _isIdle used to escape the
-      // setTimeout callback and silently park the inbound loop.
-      let nextDelay = DEFAULT_POLL_INTERVAL_ACTIVE;
-      let hubRetryAfterMs = 0;
-      try {
-        if (!this._running) return;
-        try {
-          const result = await this.inbound.pull();
-          if (result.retryAfterMs > 0) {
-            hubRetryAfterMs = result.retryAfterMs;
-          } else if (result.received > 0) {
-            this._lastActivity = Date.now();
-            if (typeof this.onInboundReceived === 'function') {
-              try { this.onInboundReceived(result.received); } catch (e) {
-                this.logger.warn?.('[sync] onInboundReceived callback failed:', e.message);
-              }
-            }
-          }
-          if (!hubRetryAfterMs) {
-            const ack = await this.inbound.ackDelivered();
-            if (ack.retryAfterMs > 0) hubRetryAfterMs = ack.retryAfterMs;
-          }
-        } catch (err) {
-          if (err instanceof AuthError) {
-            await this._handleAuthError('inbound');
-          } else {
-            this.logger.error(`[sync] inbound error: ${err.message}`);
-          }
-        }
-        if (hubRetryAfterMs > 0) {
-          nextDelay = Math.max(1_000, hubRetryAfterMs);
-        } else {
-          try {
-            nextDelay = this._isIdle()
-              ? DEFAULT_POLL_INTERVAL_IDLE
-              : DEFAULT_POLL_INTERVAL_ACTIVE;
-          } catch (err) {
-            this.logger.error(`[sync] _isIdle threw (non-fatal): ${err && err.message}`);
-          }
-        }
-      } catch (err) {
-        this.logger.error(`[sync] inbound tick threw (non-fatal): ${err && err.message}`);
-      } finally {
-        if (this._running) this._scheduleInbound(nextDelay);
-      }
-    }, delayMs);
-    if (this._inTimer.unref) this._inTimer.unref();
-  }
-}
-
-module.exports = { SyncEngine, DEFAULT_OUTBOUND_INTERVAL };

package/src/proxy/sync/inbound.js

@@ -1,211 +0,0 @@
-'use strict';
-
-const { PROXY_PROTOCOL_VERSION } = require('../mailbox/store');
-const { AuthError } = require('../lifecycle/manager');
-const {
-  drainHubResponse,
-  hubFetch,
-  hubUnreachableBackoffMs,
-  isHubUnreachableError,
-  readHubResponseJson,
-  readHubResponseText,
-  sanitizeHubResponseForLog,
-  throwIfHubUnreachableResponse,
-} = require('../../gep/hubFetch');
-
-const DEFAULT_POLL_INTERVAL_ACTIVE = 10_000;
-const DEFAULT_POLL_INTERVAL_IDLE = 60_000;
-
-function toInboundStoreMessage(m, channel) {
-  return {
-    id: m.id,
-    type: m.type,
-    payload: m.payload,
-    channel,
-    priority: m.priority || 'normal',
-    refId: m.ref_id,
-    expiresAt: m.expires_at,
-  };
-}
-
-class InboundSync {
-  constructor({ store, hubUrl, getHeaders, logger }) {
-    this.store = store;
-    this.hubUrl = hubUrl;
-    this.logger = logger || console;
-    this.getHeaders = getHeaders;
-    this._hubUnreachableFailures = 0;
-    this._hubUnreachableUntil = 0;
-  }
-
-  _hubUnreachableWaitMs() {
-    return Math.max(0, this._hubUnreachableUntil - Date.now());
-  }
-
-  _recordHubReachable() {
-    this._hubUnreachableFailures = 0;
-    this._hubUnreachableUntil = 0;
-  }
-
-  _recordHubUnreachable(err) {
-    this._hubUnreachableFailures += 1;
-    const retryAfterMs = hubUnreachableBackoffMs(this._hubUnreachableFailures);
-    this._hubUnreachableUntil = Date.now() + retryAfterMs;
-    this.logger.warn?.(
-      `[inbound] Hub unreachable; backing off for ${Math.ceil(retryAfterMs / 1000)}s: ` +
-        `${err && err.message || err}`
-    );
-    return retryAfterMs;
-  }
-
-  async pull(channel = 'evomap-hub', limit = 50) {
-    const waitMs = this._hubUnreachableWaitMs();
-    if (waitMs > 0) {
-      return {
-        received: 0,
-        error: 'hub_unreachable_backoff',
-        hubUnreachable: true,
-        retryAfterMs: waitMs,
-      };
-    }
-
-    const cursorKey = `${channel}:inbound_cursor`;
-    const cursor = this.store.getCursor(cursorKey);
-
-    const endpoint = `${this.hubUrl}/a2a/mailbox/inbound`;
-
-    try {
-      const senderId = this.store.getState('node_id');
-      const res = await hubFetch(endpoint, {
-        method: 'POST',
-        headers: this.getHeaders(),
-        body: JSON.stringify({ sender_id: senderId, proxy_protocol_version: PROXY_PROTOCOL_VERSION, cursor, limit }),
-        signal: AbortSignal.timeout(35_000),
-      });
-
-      await throwIfHubUnreachableResponse(res, 'inbound pull');
-      this._recordHubReachable();
-
-      if (res.status === 403 || res.status === 401) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
-      }
-
-      if (!res.ok) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
-      }
-
-      const data = await readHubResponseJson(res);
-      const messages = data.messages || [];
-      let stored = 0;
-      let dropped = 0;
-
-      if (messages.length > 0) {
-        for (const m of messages) {
-          try {
-            this.store.writeInbound(toInboundStoreMessage(m, channel));
-            stored++;
-          } catch (err) {
-            if (err && err.code === 'MAILBOX_JSONL_LINE_TOO_LARGE') {
-              dropped++;
-              const msgId = m && m.id ? String(m.id) : '(missing id)';
-              this.logger.warn?.(`[inbound] dropped oversized inbound message ${msgId}: ${err.message}`);
-              continue;
-            }
-            throw err;
-          }
-        }
-      }
-
-      if (data.next_cursor) {
-        this.store.setCursor(cursorKey, data.next_cursor);
-      }
-
-      const result = { received: stored, cursor: data.next_cursor || cursor };
-      if (dropped > 0) result.dropped = dropped;
-      return result;
-    } catch (err) {
-      if (err instanceof AuthError) throw err;
-      if (isHubUnreachableError(err)) {
-        const retryAfterMs = this._recordHubUnreachable(err);
-        return {
-          received: 0,
-          error: 'hub_unreachable',
-          hubUnreachable: true,
-          retryAfterMs,
-        };
-      }
-      this.logger.error(`[inbound] pull failed: ${err.message}`);
-      return { received: 0, error: err.message };
-    }
-  }
-
-  async ackDelivered(channel = 'evomap-hub') {
-    const waitMs = this._hubUnreachableWaitMs();
-    if (waitMs > 0) {
-      return {
-        acked: 0,
-        error: 'hub_unreachable_backoff',
-        hubUnreachable: true,
-        retryAfterMs: waitMs,
-      };
-    }
-
-    const delivered = this.store.list({
-      type: '%',
-      direction: 'inbound',
-      status: 'delivered',
-      limit: 100,
-    }).filter(m => m.channel === channel);
-
-    if (delivered.length === 0) return { acked: 0 };
-
-    const endpoint = `${this.hubUrl}/a2a/mailbox/ack`;
-
-    try {
-      const senderId = this.store.getState('node_id');
-      // Round-8 (§21.5): drain the response body so the undici long-poll
-      // dispatcher pool is not leaked one socket per ack. ackDelivered
-      // is called every inbound poll cycle (default 1-10s); the
-      // pre-round-8 code captured no reference to res and never called
-      // .json()/.text()/body.cancel(), so each ack pinned a socket
-      // until GC. After a few minutes of activity the strict-pool was
-      // exhausted and proxy-mode heartbeats hung on next acquire --
-      // matches the "alive once then dead" user symptom in proxy mode.
-      const res = await hubFetch(endpoint, {
-        method: 'POST',
-        headers: this.getHeaders(),
-        body: JSON.stringify({ sender_id: senderId, message_ids: delivered.map(m => m.id) }),
-        signal: AbortSignal.timeout(10_000),
-      });
-      await throwIfHubUnreachableResponse(res, 'inbound ack');
-      this._recordHubReachable();
-      if (res.status === 403 || res.status === 401) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
-      }
-      if (!res.ok) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
-      }
-      await drainHubResponse(res);
-      return { acked: delivered.length };
-    } catch (err) {
-      if (err instanceof AuthError) throw err;
-      if (isHubUnreachableError(err)) {
-        const retryAfterMs = this._recordHubUnreachable(err);
-        return {
-          acked: 0,
-          error: 'hub_unreachable',
-          hubUnreachable: true,
-          retryAfterMs,
-        };
-      }
-      this.logger.error(`[inbound] ack failed: ${err.message}`);
-      return { acked: 0, error: err.message };
-    }
-  }
-}
-
-module.exports = { InboundSync, DEFAULT_POLL_INTERVAL_ACTIVE, DEFAULT_POLL_INTERVAL_IDLE };

package/src/proxy/sync/outbound.js

@@ -1,320 +0,0 @@
-'use strict';
-
-const { PROXY_PROTOCOL_VERSION } = require('../mailbox/store');
-const { AuthError } = require('../lifecycle/manager');
-const { isProxyTraceUploadPayloadAllowed, resolveTraceMode } = require('../trace/extractor');
-const {
-  hubFetch,
-  hubUnreachableBackoffMs,
-  isHubUnreachableError,
-  readHubResponseJson,
-  readHubResponseText,
-  sanitizeHubResponseForLog,
-  throwIfHubUnreachableResponse,
-} = require('../../gep/hubFetch');
-const { redactString } = require('../../gep/sanitize');
-
-const MAX_BATCH = 50;
-const MAX_RETRIES = 10;
-const DEFAULT_MAX_OUTBOUND_BODY_BYTES = 4 * 1024 * 1024;
-const MIN_ADAPTIVE_OUTBOUND_BODY_BYTES = 16 * 1024;
-const OUTBOUND_BODY_BYTES_STATE_KEY = 'outbound_sync_max_body_bytes';
-
-function sanitizeHubErrorMessage(value) {
-  if (typeof sanitizeHubResponseForLog === 'function') {
-    return sanitizeHubResponseForLog(value);
-  }
-
-  let text;
-  if (typeof value === 'string') {
-    text = value;
-  } else if (value && typeof value.message === 'string') {
-    text = value.message;
-  } else {
-    try { text = JSON.stringify(value); } catch { text = String(value || ''); }
-  }
-  return redactString(String(text || ''));
-}
-
-function resolveHardOutboundBodyBytes(env = process.env) {
-  const raw = Number(env.EVOMAP_OUTBOUND_SYNC_MAX_BODY_BYTES || env.EVOMAP_MAILBOX_OUTBOUND_MAX_BODY_BYTES);
-  const max = Number.isFinite(raw) && raw > 0
-    ? Math.floor(raw)
-    : DEFAULT_MAX_OUTBOUND_BODY_BYTES;
-  return Math.max(1, max);
-}
-
-function resolveMaxOutboundBodyBytes(env = process.env, store = null) {
-  let max = resolveHardOutboundBodyBytes(env);
-  try {
-    const adaptive = Number(store && typeof store.getState === 'function'
-      ? store.getState(OUTBOUND_BODY_BYTES_STATE_KEY)
-      : null);
-    if (Number.isFinite(adaptive) && adaptive > 0) max = Math.min(max, Math.floor(adaptive));
-  } catch { /* adaptive state is best-effort */ }
-  return Math.max(1, max);
-}
-
-function hubMessage(m) {
-  return {
-    id: m.id,
-    type: m.type,
-    payload: m.payload,
-    priority: m.priority,
-    ref_id: m.ref_id,
-    created_at: m.created_at,
-  };
-}
-
-function serializeOutboundBody(senderId, messages) {
-  return JSON.stringify({
-    sender_id: senderId,
-    proxy_protocol_version: PROXY_PROTOCOL_VERSION,
-    messages: messages.map(hubMessage),
-  });
-}
-
-function outboundEndpoint(hubUrl, senderId) {
-  const endpoint = new URL(`${String(hubUrl || '').replace(/\/+$/, '')}/a2a/mailbox/outbound`);
-  if (senderId) endpoint.searchParams.set('sender_id', senderId);
-  return endpoint.toString();
-}
-
-function outboundBodyBytes(senderId, messages) {
-  return Buffer.byteLength(serializeOutboundBody(senderId, messages), 'utf8');
-}
-
-function buildSizedOutboundBatch(senderId, messages, maxBodyBytes, hardMaxBodyBytes = maxBodyBytes) {
-  const selected = [];
-  const rejected = [];
-  let body = serializeOutboundBody(senderId, selected);
-  let bodyBytes = Buffer.byteLength(body, 'utf8');
-
-  for (const m of messages) {
-    const singleBytes = outboundBodyBytes(senderId, [m]);
-    if (singleBytes > hardMaxBodyBytes) {
-      rejected.push({
-        id: m.id,
-        status: 'rejected',
-        error: `outbound message exceeds max body bytes (${singleBytes} > ${hardMaxBodyBytes})`,
-      });
-      continue;
-    }
-    if (selected.length === 0 && singleBytes > maxBodyBytes) {
-      selected.push(m);
-      body = serializeOutboundBody(senderId, selected);
-      bodyBytes = Buffer.byteLength(body, 'utf8');
-      break;
-    }
-
-    const candidate = selected.concat(m);
-    const candidateBody = serializeOutboundBody(senderId, candidate);
-    const candidateBytes = Buffer.byteLength(candidateBody, 'utf8');
-    if (candidateBytes > maxBodyBytes) break;
-
-    selected.push(m);
-    body = candidateBody;
-    bodyBytes = candidateBytes;
-  }
-
-  return { selected, rejected, body, bodyBytes, maxBodyBytes };
-}
-
-class OutboundSync {
-  constructor({ store, hubUrl, getHeaders, logger }) {
-    this.store = store;
-    this.hubUrl = hubUrl;
-    this.logger = logger || console;
-    this.getHeaders = getHeaders;
-    this._hubUnreachableFailures = 0;
-    this._hubUnreachableUntil = 0;
-  }
-
-  _hubUnreachableWaitMs() {
-    return Math.max(0, this._hubUnreachableUntil - Date.now());
-  }
-
-  _recordHubReachable() {
-    this._hubUnreachableFailures = 0;
-    this._hubUnreachableUntil = 0;
-  }
-
-  _recordHubUnreachable(err) {
-    this._hubUnreachableFailures += 1;
-    const retryAfterMs = hubUnreachableBackoffMs(this._hubUnreachableFailures);
-    this._hubUnreachableUntil = Date.now() + retryAfterMs;
-    this.logger.warn?.(
-      `[outbound] Hub unreachable; backing off for ${Math.ceil(retryAfterMs / 1000)}s: ` +
-        `${err && err.message || err}`
-    );
-    return retryAfterMs;
-  }
-
-  async flush(channel = 'evomap-hub') {
-    const waitMs = this._hubUnreachableWaitMs();
-    if (waitMs > 0) {
-      return {
-        sent: 0,
-        error: 'hub_unreachable_backoff',
-        hubUnreachable: true,
-        retryAfterMs: waitMs,
-      };
-    }
-
-    const pendingBatch = this.store.pollOutbound({ channel, limit: MAX_BATCH });
-    if (pendingBatch.length === 0) return { sent: 0 };
-
-    let pending = pendingBatch;
-    const rejectedTraceUploads = [];
-    const traceUploadEnabled = resolveTraceMode(process.env, { store: this.store });
-    for (const m of pendingBatch) {
-      if (m.type !== 'proxy_trace') continue;
-      if (!traceUploadEnabled) {
-        rejectedTraceUploads.push({ id: m.id, error: 'proxy trace upload disabled' });
-      } else if (!isProxyTraceUploadPayloadAllowed(m.payload, process.env, { store: this.store })) {
-        rejectedTraceUploads.push({ id: m.id, error: 'proxy trace payload rejected' });
-      }
-    }
-    if (rejectedTraceUploads.length > 0) {
-      this.store.updateStatusBatch(rejectedTraceUploads.map(m => ({
-        id: m.id,
-        status: 'rejected',
-        error: m.error,
-      })));
-      const rejectedIds = new Set(rejectedTraceUploads.map(m => m.id));
-      pending = pendingBatch.filter(m => !rejectedIds.has(m.id));
-      if (pending.length === 0) return { sent: 0, dropped: rejectedTraceUploads.length };
-    }
-    let dropped = rejectedTraceUploads.length;
-
-    try {
-      const senderId = this.store.getState('node_id');
-      const endpoint = outboundEndpoint(this.hubUrl, senderId);
-      const prepared = buildSizedOutboundBatch(
-        senderId,
-        pending,
-        resolveMaxOutboundBodyBytes(process.env, this.store),
-        resolveHardOutboundBodyBytes(process.env)
-      );
-      if (prepared.rejected.length > 0) {
-        this.store.updateStatusBatch(prepared.rejected);
-        dropped += prepared.rejected.length;
-      }
-      pending = prepared.selected;
-      if (pending.length === 0) return { sent: 0, dropped };
-
-      const res = await hubFetch(endpoint, {
-        method: 'POST',
-        headers: this.getHeaders(),
-        body: prepared.body,
-        signal: AbortSignal.timeout(30_000),
-      });
-
-      if (res.status === 413) {
-        const errText = sanitizeHubErrorMessage(
-          await readHubResponseText(res).catch(() => 'request entity too large')
-        );
-        const error = `Hub 413 outbound payload too large: ${errText}`;
-        if (pending.length <= 1) {
-          this.store.updateStatusBatch(pending.map(m => ({
-            id: m.id,
-            status: 'rejected',
-            error,
-          })));
-          const result = {
-            sent: 0,
-            error: 'hub_payload_too_large',
-            payloadTooLarge: true,
-            dropped: dropped + pending.length,
-          };
-          return result;
-        }
-        const currentCeiling = Math.min(prepared.maxBodyBytes, Math.max(1, prepared.bodyBytes - 1));
-        const nextMax = currentCeiling > MIN_ADAPTIVE_OUTBOUND_BODY_BYTES
-          ? Math.max(MIN_ADAPTIVE_OUTBOUND_BODY_BYTES, Math.floor(currentCeiling / 2))
-          : Math.max(1, Math.floor(currentCeiling / 2));
-        try { this.store.setState(OUTBOUND_BODY_BYTES_STATE_KEY, nextMax); } catch { /* best effort */ }
-        this.logger.warn?.(
-          `[outbound] Hub 413 for ${pending.length} messages (${prepared.bodyBytes} bytes); ` +
-            `reducing outbound batch budget to ${nextMax} bytes`
-        );
-        const result = { sent: 0, error: 'hub_payload_too_large', payloadTooLarge: true };
-        if (dropped > 0) result.dropped = dropped;
-        return result;
-      }
-
-      await throwIfHubUnreachableResponse(res, 'outbound flush');
-      this._recordHubReachable();
-
-      if (res.status === 403 || res.status === 401) {
-        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
-        throw new AuthError(`Hub ${res.status}: ${errText}`, res.status);
-      }
-
-      if (!res.ok) {
-        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
-        throw new Error(`Hub returned ${res.status}: ${errText}`);
-      }
-
-      const data = await readHubResponseJson(res);
-      const results = data.results || [];
-
-      const updates = [];
-      const inboundMessages = [];
-
-      for (const r of results) {
-        if (r.status === 'accepted' || r.status === 'ok') {
-          updates.push({ id: r.id, status: 'synced' });
-        } else if (r.status === 'failed' || r.status === 'rejected') {
-          const msg = pending.find(m => m.id === r.id);
-          const error = sanitizeHubErrorMessage(r.error || 'rejected by hub');
-          if (msg && msg.retry_count < MAX_RETRIES) {
-            this.store.incrementRetry(r.id, error);
-          } else {
-            updates.push({ id: r.id, status: 'failed', error: sanitizeHubErrorMessage(r.error || 'max retries') });
-          }
-        }
-
-        if (r.response) {
-          inboundMessages.push({
-            type: `${r.original_type || 'unknown'}_result`,
-            payload: r.response,
-            refId: r.id,
-            channel,
-          });
-        }
-      }
-
-      if (updates.length > 0) this.store.updateStatusBatch(updates);
-      if (inboundMessages.length > 0) this.store.writeInboundBatch(inboundMessages);
-
-      this.store.setState('last_sync_at', new Date().toISOString());
-      const result = { sent: pending.length, synced: updates.length, responses: inboundMessages.length };
-      if (dropped > 0) result.dropped = dropped;
-      return result;
-    } catch (err) {
-      if (err instanceof AuthError) throw err;
-      if (isHubUnreachableError(err)) {
-        const retryAfterMs = this._recordHubUnreachable(err);
-        const result = {
-          sent: 0,
-          error: 'hub_unreachable',
-          hubUnreachable: true,
-          retryAfterMs,
-        };
-        if (dropped > 0) result.dropped = dropped;
-        return result;
-      }
-      const errMessage = sanitizeHubErrorMessage(err);
-      this.logger.error(`[outbound] flush failed: ${errMessage}`);
-      for (const m of pending) {
-        this.store.incrementRetry(m.id, errMessage);
-      }
-      const result = { sent: 0, error: errMessage };
-      if (dropped > 0) result.dropped = dropped;
-      return result;
-    }
-  }
-}
-
-module.exports = { OutboundSync, MAX_BATCH, MAX_RETRIES };