@agentvault/agentvault 0.9.5 → 0.9.7

package/dist/cli.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // ../../node_modules/libsodium-sumo/dist/modules-sumo-esm/libsodium-sumo.mjs
-var __filename, __dirname, url, path, Module, Module, root, window_, crypto_, randomValuesStandard, crypto, randomValueNodeJS, _Module, libsodium_sumo_default;
+var __filename, __dirname, url, path, Module, Module, root, window_, crypto_, randomValuesStandard, crypto2, randomValueNodeJS, _Module, libsodium_sumo_default;
 var init_libsodium_sumo = __esm({
   async "../../node_modules/libsodium-sumo/dist/modules-sumo-esm/libsodium-sumo.mjs"() {
     try {
@@ -74,9 +74,9 @@ var init_libsodium_sumo = __esm({
         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();
@@ -40279,7 +40279,7 @@ var init_libsodium_sumo = __esm({
               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);
@@ -40289,9 +40289,9 @@ var init_libsodium_sumo = __esm({
                 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();
@@ -41339,7 +41339,7 @@ var init_libsodium_sumo = __esm({
           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);
@@ -41349,9 +41349,9 @@ var init_libsodium_sumo = __esm({
             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();
@@ -44783,6 +44783,22 @@ var init_ratchet = __esm({
         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);
@@ -45151,6 +45167,14 @@ var init_merkle = __esm({
   }
 });
 
+// ../crypto/dist/vc.js
+var init_vc = __esm({
+  async "../crypto/dist/vc.js"() {
+    "use strict";
+    await init_did();
+  }
+});
+
 // ../crypto/dist/transport.js
 function hexToBytes(hex) {
   return libsodium_wrappers_default.from_hex(hex);
@@ -45200,6 +45224,220 @@ var init_transport = __esm({
   }
 });
 
+// ../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 }
+  };
+}
+var init_telemetry = __esm({
+  "../crypto/dist/telemetry.js"() {
+    "use strict";
+  }
+});
+
+// ../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;
+var init_telemetry_reporter = __esm({
+  "../crypto/dist/telemetry-reporter.js"() {
+    "use strict";
+    init_telemetry();
+    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;
+        }
+      }
+    };
+  }
+});
+
 // ../crypto/dist/index.js
 var init_dist = __esm({
   async "../crypto/dist/index.js"() {
@@ -45211,7 +45449,10 @@ var init_dist = __esm({
     await init_did();
     init_scan_engine();
     await init_merkle();
+    await init_vc();
     await init_transport();
+    init_telemetry();
+    init_telemetry_reporter();
   }
 });
 
@@ -45393,12 +45634,13 @@ var init_channel = __esm({
       _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;
@@ -45427,6 +45669,10 @@ var init_channel = __esm({
       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;
@@ -45509,7 +45755,7 @@ var init_channel = __esm({
         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;
@@ -45971,6 +46217,11 @@ var init_channel = __esm({
           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();
@@ -46494,26 +46745,20 @@ var init_channel = __esm({
               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();
@@ -46533,10 +46778,8 @@ var init_channel = __esm({
               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) ?? "?"}...:`,
@@ -46868,9 +47111,7 @@ var init_channel = __esm({
             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();
@@ -46892,11 +47133,6 @@ var init_channel = __esm({
         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) {
@@ -46909,14 +47145,7 @@ var init_channel = __esm({
           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;
@@ -46951,6 +47180,7 @@ var init_channel = __esm({
         }
         if (messageType === "message") {
           const topicId = msgData.topic_id;
+          this._lastIncomingTopicId = topicId;
           let attachData;
           if (attachmentInfo) {
             try {
@@ -47009,13 +47239,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;
@@ -47140,29 +47364,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.
@@ -47264,12 +47481,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,
@@ -47399,7 +47656,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}`;
@@ -47409,24 +47665,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 {
@@ -47460,6 +47707,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;
@@ -47476,15 +47726,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;
       }