@agentvault/agentvault 0.9.5 → 0.9.7

package/dist/crypto-helpers.js

@@ -0,0 +1,4 @@
+// Re-export transport utilities from shared @agentvault/crypto package.
+// Plugin code continues importing from ./crypto-helpers.js — no import changes needed.
+export { hexToBytes, bytesToHex, base64ToBytes, bytesToBase64, encryptedMessageToTransport, transportToEncryptedMessage, } from "@agentvault/crypto";
+//# sourceMappingURL=crypto-helpers.js.map

package/dist/crypto-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-helpers.js","sourceRoot":"","sources":["../src/crypto-helpers.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,uFAAuF;AACvF,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,EACb,2BAA2B,EAC3B,2BAA2B,GAE5B,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -73,9 +73,9 @@ if (typeof Module.getRandomValue === "undefined") {
     Module.getRandomValue = randomValuesStandard;
   } catch (e) {
     try {
-      crypto = null;
+      crypto2 = null;
       randomValueNodeJS = function() {
-        var buf = crypto["randomBytes"](4);
+        var buf = crypto2["randomBytes"](4);
         return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
       };
       randomValueNodeJS();
@@ -88,7 +88,7 @@ if (typeof Module.getRandomValue === "undefined") {
 var window_;
 var crypto_;
 var randomValuesStandard;
-var crypto;
+var crypto2;
 var randomValueNodeJS;
 var _Module = Module;
 Module.ready = new Promise(function(resolve2, reject) {
@@ -40283,7 +40283,7 @@ Module.ready = new Promise(function(resolve2, reject) {
           try {
             var window_ = "object" === typeof window ? window : self;
             var crypto_ = typeof window_.crypto !== "undefined" ? window_.crypto : window_.msCrypto;
-            crypto_ = crypto_ === void 0 ? crypto : crypto_;
+            crypto_ = crypto_ === void 0 ? crypto2 : crypto_;
             var randomValuesStandard = function() {
               var buf = new Uint32Array(1);
               crypto_.getRandomValues(buf);
@@ -40293,9 +40293,9 @@ Module.ready = new Promise(function(resolve2, reject) {
             Module3.getRandomValue = randomValuesStandard;
           } catch (e) {
             try {
-              var crypto = null;
+              var crypto2 = null;
               var randomValueNodeJS = function() {
-                var buf = crypto["randomBytes"](4);
+                var buf = crypto2["randomBytes"](4);
                 return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
               };
               randomValueNodeJS();
@@ -41343,7 +41343,7 @@ Module.ready = new Promise(function(resolve2, reject) {
       try {
         var window_ = "object" === typeof window ? window : self;
         var crypto_ = typeof window_.crypto !== "undefined" ? window_.crypto : window_.msCrypto;
-        crypto_ = crypto_ === void 0 ? crypto : crypto_;
+        crypto_ = crypto_ === void 0 ? crypto2 : crypto_;
         var randomValuesStandard = function() {
           var buf = new Uint32Array(1);
           crypto_.getRandomValues(buf);
@@ -41353,9 +41353,9 @@ Module.ready = new Promise(function(resolve2, reject) {
         Module2.getRandomValue = randomValuesStandard;
       } catch (e) {
         try {
-          var crypto = null;
+          var crypto2 = null;
           var randomValueNodeJS = function() {
-            var buf = crypto["randomBytes"](4);
+            var buf = crypto2["randomBytes"](4);
             return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
           };
           randomValueNodeJS();
@@ -44766,6 +44766,22 @@ var DoubleRatchet = class _DoubleRatchet {
     const currentDhHex = this.state.dhReceivingPublicKey ? libsodium_wrappers_default.to_hex(this.state.dhReceivingPublicKey) : null;
     if (currentDhHex === null && this.state.receivingChain) {
       this.state.dhReceivingPublicKey = message.header.dhPublicKey;
+    } else if (currentDhHex === null && !this.state.receivingChain) {
+      if (message.header.messageNumber === 0) {
+        try {
+          const { messageKey: testKey, nextChainKey: nextChainKey2 } = kdfChainKey(this.state.rootKey);
+          const ad2 = serializeHeader(message.header);
+          const ptBytes = libsodium_wrappers_default.crypto_aead_xchacha20poly1305_ietf_decrypt(null, message.ciphertext, ad2, message.nonce, testKey);
+          this.state.dhReceivingPublicKey = message.header.dhPublicKey;
+          this.state.receivingChain = {
+            chainKey: nextChainKey2,
+            messageNumber: 1
+          };
+          return libsodium_wrappers_default.to_string(ptBytes);
+        } catch {
+        }
+      }
+      this.dhRatchetReceive(message.header.dhPublicKey);
     } else if (headerDhHex !== currentDhHex) {
       if (this.state.receivingChain && this.state.dhReceivingPublicKey) {
         this.skipMessages(this.state.receivingChain, message.header.previousChainLength, this.state.dhReceivingPublicKey);
@@ -45149,6 +45165,208 @@ function transportToEncryptedMessage(transport) {
   };
 }
 
+// ../crypto/dist/telemetry.js
+function randomHex(byteCount) {
+  const bytes = new Uint8Array(byteCount);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    hex += bytes[i2].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function generateTraceId() {
+  return randomHex(16);
+}
+function generateSpanId() {
+  return randomHex(8);
+}
+function buildLlmSpan(opts) {
+  const now = Date.now();
+  const attributes = {
+    "ai.agent.llm.model": opts.model,
+    "ai.agent.llm.latency_ms": opts.latencyMs,
+    "ai.agent.llm.tokens_input": opts.tokensInput,
+    "ai.agent.llm.tokens_output": opts.tokensOutput
+  };
+  if (opts.provider !== void 0) {
+    attributes["ai.agent.llm.provider"] = opts.provider;
+  }
+  const isError = opts.status === "error";
+  const status = isError ? { code: 2, ...opts.statusMessage ? { message: opts.statusMessage } : {} } : { code: 0 };
+  return {
+    traceId: opts.traceId ?? generateTraceId(),
+    spanId: opts.spanId ?? generateSpanId(),
+    parentSpanId: opts.parentSpanId,
+    name: "llm.inference",
+    kind: "internal",
+    startTime: now - opts.latencyMs,
+    endTime: now,
+    attributes,
+    status
+  };
+}
+function buildToolSpan(opts) {
+  const now = Date.now();
+  const attributes = {
+    "ai.agent.tool.name": opts.toolName,
+    "ai.agent.tool.latency_ms": opts.latencyMs,
+    "ai.agent.tool.success": opts.success
+  };
+  const status = opts.success ? { code: 0 } : { code: 2, ...opts.errorMessage ? { message: opts.errorMessage } : {} };
+  return {
+    traceId: opts.traceId ?? generateTraceId(),
+    spanId: opts.spanId ?? generateSpanId(),
+    parentSpanId: opts.parentSpanId,
+    name: "tool.execute",
+    kind: "internal",
+    startTime: now - opts.latencyMs,
+    endTime: now,
+    attributes,
+    status
+  };
+}
+function buildErrorSpan(opts) {
+  const now = Date.now();
+  return {
+    traceId: opts.traceId ?? generateTraceId(),
+    spanId: opts.spanId ?? generateSpanId(),
+    parentSpanId: opts.parentSpanId,
+    name: "error",
+    kind: opts.spanKind ?? "internal",
+    startTime: now,
+    endTime: now,
+    attributes: {
+      "ai.agent.error.type": opts.errorType,
+      "ai.agent.error.message": opts.errorMessage
+    },
+    status: { code: 2, message: opts.errorMessage }
+  };
+}
+
+// ../crypto/dist/telemetry-reporter.js
+function toOtlpAttributes(attrs) {
+  return Object.entries(attrs).map(([key, val]) => {
+    if (typeof val === "string") {
+      return { key, value: { stringValue: val } };
+    }
+    if (typeof val === "boolean") {
+      return { key, value: { boolValue: val } };
+    }
+    if (Number.isInteger(val)) {
+      return { key, value: { intValue: val } };
+    }
+    return { key, value: { doubleValue: val } };
+  });
+}
+function spanToOtlp(span) {
+  const otlp = {
+    traceId: span.traceId,
+    spanId: span.spanId,
+    name: span.name,
+    kind: span.kind,
+    startTimeUnixNano: String(span.startTime * 1e6),
+    endTimeUnixNano: String(span.endTime * 1e6),
+    attributes: toOtlpAttributes(span.attributes)
+  };
+  if (span.parentSpanId !== void 0) {
+    otlp.parentSpanId = span.parentSpanId;
+  }
+  if (span.status) {
+    otlp.status = span.status;
+  }
+  if (span.events && span.events.length > 0) {
+    otlp.events = span.events;
+  }
+  return otlp;
+}
+var TelemetryReporter = class {
+  _apiBase;
+  _hubId;
+  _authHeader;
+  _fetch;
+  _buffer = [];
+  _timer = null;
+  constructor(config) {
+    this._apiBase = config.apiBase.replace(/\/+$/, "");
+    this._hubId = config.hubId;
+    this._authHeader = config.authHeader;
+    this._fetch = config.fetchImpl ?? globalThis.fetch;
+  }
+  /** Number of spans waiting to be flushed. */
+  get pendingCount() {
+    return this._buffer.length;
+  }
+  // -- Report methods ---------------------------------------------------------
+  /** Record an LLM inference call. */
+  reportLlmCall(opts) {
+    this._buffer.push(buildLlmSpan(opts));
+  }
+  /** Record a tool/function invocation. */
+  reportToolCall(opts) {
+    this._buffer.push(buildToolSpan(opts));
+  }
+  /** Record an error event. */
+  reportError(opts) {
+    this._buffer.push(buildErrorSpan(opts));
+  }
+  /** Record an arbitrary pre-built span. */
+  reportCustomSpan(span) {
+    this._buffer.push(span);
+  }
+  // -- Flush ------------------------------------------------------------------
+  /**
+   * POST all buffered spans to the backend ingest endpoint.
+   *
+   * - On success (HTTP 2xx): clears the buffer.
+   * - On failure: keeps spans in the buffer for retry.
+   * - Never throws — telemetry is best-effort.
+   */
+  async flush() {
+    if (this._buffer.length === 0) {
+      return;
+    }
+    const spans = this._buffer;
+    this._buffer = [];
+    try {
+      const response = await this._fetch(`${this._apiBase}/api/v1/telemetry/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: this._authHeader
+        },
+        body: JSON.stringify({
+          hub_id: this._hubId,
+          spans: spans.map(spanToOtlp)
+        })
+      });
+      if (!response.ok) {
+        this._buffer = spans.concat(this._buffer);
+      }
+    } catch {
+      this._buffer = spans.concat(this._buffer);
+    }
+  }
+  // -- Auto-flush -------------------------------------------------------------
+  /**
+   * Start a periodic flush timer.
+   * @param intervalMs  Flush interval in milliseconds (default 30 000).
+   */
+  startAutoFlush(intervalMs = 3e4) {
+    this.stopAutoFlush();
+    this._timer = setInterval(() => {
+      void this.flush();
+    }, intervalMs);
+  }
+  /** Stop the periodic flush timer. Safe to call when not started. */
+  stopAutoFlush() {
+    if (this._timer !== null) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+};
+
 // src/state.ts
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -45292,12 +45510,13 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
   _lastWakeTick = Date.now();
   _pendingPollTimer = null;
   _syncMessageIds = null;
-  /** Recently handled message IDs via WS — survives reconnects so sync skips them. Max 500. */
-  _recentlyHandledIds = /* @__PURE__ */ new Set();
   /** Queued A2A messages for responder channels not yet activated (no first initiator message received). */
   _a2aPendingQueue = {};
   _scanEngine = null;
   _scanRuleSetVersion = 0;
+  _telemetryReporter = null;
+  /** Topic ID from the most recent inbound message — used as fallback for replies. */
+  _lastIncomingTopicId;
   // Liveness detection: server sends app-level {"event":"ping"} every 30s.
   // We check every 30s; if no data received in 90s (3 missed pings), connection is dead.
   static PING_INTERVAL_MS = 3e4;
@@ -45326,6 +45545,10 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
   get sessionCount() {
     return this._sessions.size;
   }
+  /** Returns the TelemetryReporter instance (available after WebSocket connect). */
+  get telemetry() {
+    return this._telemetryReporter;
+  }
   async start() {
     this._stopped = false;
     await libsodium_wrappers_default.ready;
@@ -45408,7 +45631,7 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
     if (this._sessions.size === 0) {
       throw new Error("No active sessions");
     }
-    const topicId = options?.topicId ?? this._persisted?.defaultTopicId;
+    const topicId = options?.topicId ?? this._lastIncomingTopicId ?? this._persisted?.defaultTopicId;
     const messageType = options?.messageType ?? "text";
     const priority = options?.priority ?? "normal";
     const parentSpanId = options?.parentSpanId;
@@ -45870,6 +46093,11 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
       clearTimeout(this._reconnectTimer);
       this._reconnectTimer = null;
     }
+    if (this._telemetryReporter) {
+      this._telemetryReporter.stopAutoFlush();
+      await this._telemetryReporter.flush();
+      this._telemetryReporter = null;
+    }
     if (this._ws) {
       this._ws.removeAllListeners();
       this._ws.close();
@@ -46393,26 +46621,20 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
           this._scanEngine = new ScanEngine();
           await this._fetchScanRules();
         }
+        if (!this._telemetryReporter && this._persisted?.deviceJwt && this._persisted?.hubAddress) {
+          this._telemetryReporter = new TelemetryReporter({
+            apiBase: this.config.apiUrl,
+            hubId: this._persisted.hubAddress,
+            authHeader: `Bearer ${this._persisted.deviceJwt}`
+          });
+          this._telemetryReporter.startAutoFlush(3e4);
+        }
         this.emit("ready");
       } catch (openErr) {
         console.error("[SecureChannel] Error in WS open handler:", openErr);
         this.emit("error", openErr);
       }
     });
-    const _onUnhandledRejection = (reason) => {
-      console.error("[SecureChannel] UNHANDLED REJECTION (would crash process):", reason);
-    };
-    const _onUncaughtException = (err) => {
-      console.error("[SecureChannel] UNCAUGHT EXCEPTION (would crash process):", err);
-    };
-    process.on("unhandledRejection", _onUnhandledRejection);
-    process.on("uncaughtException", _onUncaughtException);
-    ws.on("close", (code, reason) => {
-      const reasonStr = reason?.toString() || "";
-      console.log(`[SecureChannel] WS CLOSED: code=${code} reason=${JSON.stringify(reasonStr)}`);
-      process.removeListener("unhandledRejection", _onUnhandledRejection);
-      process.removeListener("uncaughtException", _onUncaughtException);
-    });
     ws.on("message", async (raw) => {
       this._lastServerMessage = Date.now();
       this._lastWakeTick = Date.now();
@@ -46432,10 +46654,8 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
           return;
         }
         if (data.event === "message") {
-          console.log(`[SecureChannel] \u2190 Direct message received: msg=${data.data?.message_id?.slice(0, 8) ?? "?"} conv=${data.data?.conversation_id?.slice(0, 8) ?? "?"}`);
           try {
             await this._handleIncomingMessage(data.data);
-            console.log(`[SecureChannel] \u2190 Direct message processed OK: msg=${data.data?.message_id?.slice(0, 8) ?? "?"}`);
           } catch (msgErr) {
             console.error(
               `[SecureChannel] Message handler failed for conv ${data.data?.conversation_id?.slice(0, 8) ?? "?"}...:`,
@@ -46767,9 +46987,7 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
         this.emit("error", err);
       }
     });
-    ws.on("close", (code, reason) => {
-      const reasonStr = reason?.toString() || "";
-      console.log(`[SecureChannel] WS close handler: code=${code} reason=${JSON.stringify(reasonStr)}`);
+    ws.on("close", () => {
       this._stopPing();
       this._stopWakeDetector();
       this._stopPendingPoll();
@@ -46791,11 +47009,6 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
     if (this._syncMessageIds?.has(msgData.message_id)) {
       return;
     }
-    this._recentlyHandledIds.add(msgData.message_id);
-    if (this._recentlyHandledIds.size > 500) {
-      const all = [...this._recentlyHandledIds];
-      this._recentlyHandledIds = new Set(all.slice(all.length - 400));
-    }
     const convId = msgData.conversation_id;
     const session = this._sessions.get(convId);
     if (!session) {
@@ -46808,14 +47021,7 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
       header_blob: msgData.header_blob,
       ciphertext: msgData.ciphertext
     });
-    let plaintext;
-    try {
-      plaintext = session.ratchet.decrypt(encrypted);
-    } catch (decryptErr) {
-      console.error(`[SecureChannel] Direct message decrypt FAILED for conv ${convId.slice(0, 8)}...: ${String(decryptErr)}`);
-      throw decryptErr;
-    }
-    console.log(`[SecureChannel] Direct message decrypted OK for conv ${convId.slice(0, 8)}...`);
+    const plaintext = session.ratchet.decrypt(encrypted);
     this._sendAck(msgData.message_id);
     if (!session.activated) {
       session.activated = true;
@@ -46850,6 +47056,7 @@ var SecureChannel = class _SecureChannel extends EventEmitter {
     }
     if (messageType === "message") {
       const topicId = msgData.topic_id;
+      this._lastIncomingTopicId = topicId;
       let attachData;
       if (attachmentInfo) {
         try {
@@ -46908,13 +47115,7 @@ ${messageText}`;
       Promise.resolve(this.config.onMessage?.(emitText, metadata)).catch((err) => {
         console.error("[SecureChannel] onMessage callback error:", err);
       });
-      console.log(`[SecureChannel] Relaying sync to ${this._sessions.size - 1} siblings for conv ${convId.slice(0, 8)}...`);
-      try {
-        await this._relaySyncToSiblings(convId, session.ownerDeviceId, messageText, topicId);
-        console.log(`[SecureChannel] Sync relay complete for conv ${convId.slice(0, 8)}...`);
-      } catch (relayErr) {
-        console.error(`[SecureChannel] Sync relay FAILED: ${String(relayErr)}`);
-      }
+      await this._relaySyncToSiblings(convId, session.ownerDeviceId, messageText, topicId);
     }
     if (this._persisted) {
       this._persisted.lastMessageTimestamp = msgData.created_at;
@@ -47039,29 +47240,22 @@ ${messageText}`;
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       topicId
     });
-    let relayed = 0;
     for (const [siblingConvId, siblingSession] of this._sessions) {
       if (siblingConvId === sourceConvId) continue;
       if (!siblingSession.activated) continue;
-      try {
-        const syncEncrypted = siblingSession.ratchet.encrypt(syncPayload);
-        const syncTransport = encryptedMessageToTransport(syncEncrypted);
-        this._ws.send(
-          JSON.stringify({
-            event: "message",
-            data: {
-              conversation_id: siblingConvId,
-              header_blob: syncTransport.header_blob,
-              ciphertext: syncTransport.ciphertext
-            }
-          })
-        );
-        relayed++;
-      } catch (err) {
-        console.error(`[SecureChannel] Sync send failed for sibling ${siblingConvId.slice(0, 8)}...: ${String(err)}`);
-      }
+      const syncEncrypted = siblingSession.ratchet.encrypt(syncPayload);
+      const syncTransport = encryptedMessageToTransport(syncEncrypted);
+      this._ws.send(
+        JSON.stringify({
+          event: "message",
+          data: {
+            conversation_id: siblingConvId,
+            header_blob: syncTransport.header_blob,
+            ciphertext: syncTransport.ciphertext
+          }
+        })
+      );
     }
-    console.log(`[SecureChannel] _relaySyncToSiblings: relayed to ${relayed}/${this._sessions.size - 1} siblings`);
   }
   /**
    * Send stored message history to a newly-activated session.
@@ -47163,12 +47357,52 @@ ${messageText}`;
       );
       return;
     }
-    const session = this._sessions.get(convId);
+    let session = this._sessions.get(convId);
     if (!session) {
       console.warn(
-        `[SecureChannel] No session for room conv ${convId.slice(0, 8)}..., skipping`
+        `[SecureChannel] No session for room conv ${convId.slice(0, 8)}..., fetching room data`
       );
-      return;
+      try {
+        const roomRes = await fetch(
+          `${this.config.apiUrl}/api/v1/rooms/${msgData.room_id}`,
+          {
+            headers: {
+              Authorization: `Bearer ${this._persisted.deviceJwt}`
+            }
+          }
+        );
+        if (roomRes.ok) {
+          const roomData = await roomRes.json();
+          await this.joinRoom({
+            roomId: roomData.id,
+            name: roomData.name,
+            members: (roomData.members || []).map((m2) => ({
+              deviceId: m2.device_id,
+              entityType: m2.entity_type,
+              displayName: m2.display_name,
+              identityPublicKey: m2.identity_public_key,
+              ephemeralPublicKey: m2.ephemeral_public_key
+            })),
+            conversations: (roomData.conversations || []).map((c2) => ({
+              id: c2.id,
+              participantA: c2.participant_a,
+              participantB: c2.participant_b
+            }))
+          });
+          session = this._sessions.get(convId);
+        }
+      } catch (fetchErr) {
+        console.error(
+          `[SecureChannel] Failed to fetch room data for ${msgData.room_id}:`,
+          fetchErr
+        );
+      }
+      if (!session) {
+        console.warn(
+          `[SecureChannel] Still no session for room conv ${convId.slice(0, 8)}... after refresh, skipping`
+        );
+        return;
+      }
     }
     const encrypted = transportToEncryptedMessage({
       header_blob: msgData.header_blob,
@@ -47298,7 +47532,6 @@ ${messageText}`;
     const PAGE_SIZE = 200;
     let since = this._persisted.lastMessageTimestamp;
     let totalProcessed = 0;
-    let totalSkipped = 0;
     try {
       for (let page = 0; page < MAX_PAGES; page++) {
         const url = `${this.config.apiUrl}/api/v1/devices/${this._deviceId}/messages?since=${encodeURIComponent(since)}&limit=${PAGE_SIZE}`;
@@ -47308,24 +47541,15 @@ ${messageText}`;
         if (!res.ok) break;
         const messages = await res.json();
         if (messages.length === 0) break;
-        console.log(`[SecureChannel] Sync page ${page}: ${messages.length} messages since ${since}`);
         for (const msg of messages) {
           if (msg.sender_device_id === this._deviceId) continue;
           if (this._syncMessageIds.has(msg.id)) continue;
           this._syncMessageIds.add(msg.id);
-          if (this._recentlyHandledIds.has(msg.id)) {
-            this._persisted.lastMessageTimestamp = msg.created_at;
-            since = msg.created_at;
-            totalSkipped++;
-            continue;
-          }
           const session = this._sessions.get(msg.conversation_id);
           if (!session) {
             console.warn(
               `[SecureChannel] No session for conversation ${msg.conversation_id} during sync, skipping`
             );
-            this._persisted.lastMessageTimestamp = msg.created_at;
-            since = msg.created_at;
             continue;
           }
           try {
@@ -47359,6 +47583,9 @@ ${messageText}`;
                 topicId
               };
               this.emit("message", messageText, metadata);
+              Promise.resolve(this.config.onMessage?.(messageText, metadata)).catch((err) => {
+                console.error("[SecureChannel] onMessage callback error:", err);
+              });
             }
             this._persisted.lastMessageTimestamp = msg.created_at;
             since = msg.created_at;
@@ -47375,15 +47602,10 @@ ${messageText}`;
         await this._persistState();
         if (messages.length < PAGE_SIZE) break;
       }
-      if (totalProcessed > 0 || totalSkipped > 0) {
-        console.log(`[SecureChannel] Sync complete: ${totalProcessed} processed, ${totalSkipped} skipped (already handled via WS)`);
-      }
-    } catch (outerErr) {
-      console.warn(`[SecureChannel] Sync interrupted: ${String(outerErr)}`);
-      try {
-        await this._persistState();
-      } catch {
+      if (totalProcessed > 0) {
+        console.log(`[SecureChannel] Synced ${totalProcessed} missed messages`);
       }
+    } catch {
     }
     this._syncMessageIds = null;
   }