@affectively/aeon 1.0.0 → 1.2.0

package/dist/distributed/index.js

@@ -385,7 +385,9 @@ var SyncCoordinator = class extends EventEmitter {
    * Get active sync sessions
    */
   getActiveSyncSessions() {
-    return Array.from(this.sessions.values()).filter((s) => s.status === "active");
+    return Array.from(this.sessions.values()).filter(
+      (s) => s.status === "active"
+    );
   }
   /**
    * Get sessions for a node
@@ -403,8 +405,14 @@ var SyncCoordinator = class extends EventEmitter {
     const completed = sessions.filter((s) => s.status === "completed").length;
     const failed = sessions.filter((s) => s.status === "failed").length;
     const active = sessions.filter((s) => s.status === "active").length;
-    const totalItemsSynced = sessions.reduce((sum, s) => sum + s.itemsSynced, 0);
-    const totalConflicts = sessions.reduce((sum, s) => sum + s.conflictsDetected, 0);
+    const totalItemsSynced = sessions.reduce(
+      (sum, s) => sum + s.itemsSynced,
+      0
+    );
+    const totalConflicts = sessions.reduce(
+      (sum, s) => sum + s.conflictsDetected,
+      0
+    );
     return {
       totalNodes: this.nodes.size,
       onlineNodes: this.getOnlineNodes().length,
@@ -471,7 +479,9 @@ var SyncCoordinator = class extends EventEmitter {
         }
       }
     }, interval);
-    logger.debug("[SyncCoordinator] Heartbeat monitoring started", { interval });
+    logger.debug("[SyncCoordinator] Heartbeat monitoring started", {
+      interval
+    });
   }
   /**
    * Stop heartbeat monitoring
@@ -504,7 +514,8 @@ var SyncCoordinator = class extends EventEmitter {
 };
 
 // src/distributed/ReplicationManager.ts
-var ReplicationManager = class {
+var ReplicationManager = class _ReplicationManager {
+  static DEFAULT_PERSIST_KEY = "aeon:replication-state:v1";
   replicas = /* @__PURE__ */ new Map();
   policies = /* @__PURE__ */ new Map();
   replicationEvents = [];
@@ -513,6 +524,29 @@ var ReplicationManager = class {
   cryptoProvider = null;
   replicasByDID = /* @__PURE__ */ new Map();
   // DID -> replicaId
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(options) {
+    if (options?.persistence) {
+      this.persistence = {
+        ...options.persistence,
+        key: options.persistence.key ?? _ReplicationManager.DEFAULT_PERSIST_KEY,
+        autoPersist: options.persistence.autoPersist ?? true,
+        autoLoad: options.persistence.autoLoad ?? false,
+        persistDebounceMs: options.persistence.persistDebounceMs ?? 25
+      };
+    }
+    if (this.persistence?.autoLoad) {
+      void this.loadFromPersistence().catch((error) => {
+        logger.error("[ReplicationManager] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
   /**
    * Configure cryptographic provider for encrypted replication
    */
@@ -557,6 +591,7 @@ var ReplicationManager = class {
       details: { did: replica.did, encrypted, authenticated: true }
     };
     this.replicationEvents.push(event);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Authenticated replica registered", {
       replicaId: replica.id,
       did: replica.did,
@@ -586,7 +621,10 @@ var ReplicationManager = class {
       throw new Error("Crypto provider not initialized");
     }
     const dataBytes = new TextEncoder().encode(JSON.stringify(data));
-    const encrypted = await this.cryptoProvider.encrypt(dataBytes, targetReplicaDID);
+    const encrypted = await this.cryptoProvider.encrypt(
+      dataBytes,
+      targetReplicaDID
+    );
     const localDID = this.cryptoProvider.getLocalDID();
     return {
       ct: encrypted.ct,
@@ -655,10 +693,13 @@ var ReplicationManager = class {
       }))
     });
     if (!result.authorized) {
-      logger.warn("[ReplicationManager] Replica capability verification failed", {
-        replicaDID,
-        error: result.error
-      });
+      logger.warn(
+        "[ReplicationManager] Replica capability verification failed",
+        {
+          replicaDID,
+          error: result.error
+        }
+      );
     }
     return result;
   }
@@ -677,6 +718,7 @@ var ReplicationManager = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.replicationEvents.push(event);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Replica registered", {
       replicaId: replica.id,
       nodeId: replica.nodeId,
@@ -699,6 +741,7 @@ var ReplicationManager = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.replicationEvents.push(event);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Replica removed", { replicaId });
   }
   /**
@@ -714,6 +757,7 @@ var ReplicationManager = class {
       maxReplicationLag
     };
     this.policies.set(policy.id, policy);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Policy created", {
       policyId: policy.id,
       name,
@@ -756,12 +800,15 @@ var ReplicationManager = class {
       lagBytes,
       lagMillis
     });
+    this.schedulePersist();
   }
   /**
    * Get replicas for node
    */
   getReplicasForNode(nodeId) {
-    return Array.from(this.replicas.values()).filter((r) => r.nodeId === nodeId);
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.nodeId === nodeId
+    );
   }
   /**
    * Get healthy replicas
@@ -775,13 +822,17 @@ var ReplicationManager = class {
    * Get syncing replicas
    */
   getSyncingReplicas() {
-    return Array.from(this.replicas.values()).filter((r) => r.status === "syncing");
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.status === "syncing"
+    );
   }
   /**
    * Get failed replicas
    */
   getFailedReplicas() {
-    return Array.from(this.replicas.values()).filter((r) => r.status === "failed");
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.status === "failed"
+    );
   }
   /**
    * Check replication health for policy
@@ -842,7 +893,9 @@ var ReplicationManager = class {
     const syncing = this.getSyncingReplicas().length;
     const failed = this.getFailedReplicas().length;
     const total = this.replicas.size;
-    const replicationLags = Array.from(this.replicas.values()).map((r) => r.lagMillis);
+    const replicationLags = Array.from(this.replicas.values()).map(
+      (r) => r.lagMillis
+    );
     const avgLag = replicationLags.length > 0 ? replicationLags.reduce((a, b) => a + b) / replicationLags.length : 0;
     const maxLag = replicationLags.length > 0 ? Math.max(...replicationLags) : 0;
     return {
@@ -916,6 +969,155 @@ var ReplicationManager = class {
         return false;
     }
   }
+  /**
+   * Persist current replication state snapshot.
+   */
+  async saveToPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    const data = {
+      replicas: this.getAllReplicas(),
+      policies: this.getAllPolicies(),
+      syncStatus: Array.from(this.syncStatus.entries()).map(
+        ([nodeId, state]) => ({
+          nodeId,
+          synced: state.synced,
+          failed: state.failed
+        })
+      )
+    };
+    const envelope = {
+      version: 1,
+      updatedAt: Date.now(),
+      data
+    };
+    const serialize = this.persistence.serializer ?? ((value) => JSON.stringify(value));
+    await this.persistence.adapter.setItem(this.persistence.key, serialize(envelope));
+  }
+  /**
+   * Load replication snapshot from persistence.
+   */
+  async loadFromPersistence() {
+    if (!this.persistence) {
+      return { replicas: 0, policies: 0, syncStatus: 0 };
+    }
+    const raw = await this.persistence.adapter.getItem(this.persistence.key);
+    if (!raw) {
+      return { replicas: 0, policies: 0, syncStatus: 0 };
+    }
+    const deserialize = this.persistence.deserializer ?? ((value) => JSON.parse(value));
+    const envelope = deserialize(raw);
+    if (envelope.version !== 1 || !envelope.data) {
+      throw new Error("Invalid replication persistence payload");
+    }
+    if (!Array.isArray(envelope.data.replicas) || !Array.isArray(envelope.data.policies) || !Array.isArray(envelope.data.syncStatus)) {
+      throw new Error("Invalid replication persistence structure");
+    }
+    this.replicas.clear();
+    this.policies.clear();
+    this.syncStatus.clear();
+    this.replicasByDID.clear();
+    let importedReplicas = 0;
+    for (const replica of envelope.data.replicas) {
+      if (this.isValidReplica(replica)) {
+        this.replicas.set(replica.id, replica);
+        if (replica.did) {
+          this.replicasByDID.set(replica.did, replica.id);
+        }
+        importedReplicas++;
+      }
+    }
+    let importedPolicies = 0;
+    for (const policy of envelope.data.policies) {
+      if (this.isValidPolicy(policy)) {
+        this.policies.set(policy.id, policy);
+        importedPolicies++;
+      }
+    }
+    let importedSyncStatus = 0;
+    for (const status of envelope.data.syncStatus) {
+      if (typeof status.nodeId === "string" && typeof status.synced === "number" && typeof status.failed === "number") {
+        this.syncStatus.set(status.nodeId, {
+          synced: status.synced,
+          failed: status.failed
+        });
+        importedSyncStatus++;
+      }
+    }
+    logger.debug("[ReplicationManager] Loaded from persistence", {
+      key: this.persistence.key,
+      replicas: importedReplicas,
+      policies: importedPolicies,
+      syncStatus: importedSyncStatus
+    });
+    return {
+      replicas: importedReplicas,
+      policies: importedPolicies,
+      syncStatus: importedSyncStatus
+    };
+  }
+  /**
+   * Remove persisted replication snapshot.
+   */
+  async clearPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    await this.persistence.adapter.removeItem(this.persistence.key);
+  }
+  schedulePersist() {
+    if (!this.persistence || this.persistence.autoPersist === false) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      void this.persistSafely();
+    }, this.persistence.persistDebounceMs ?? 25);
+  }
+  async persistSafely() {
+    if (!this.persistence) {
+      return;
+    }
+    if (this.persistInFlight) {
+      this.persistPending = true;
+      return;
+    }
+    this.persistInFlight = true;
+    try {
+      await this.saveToPersistence();
+    } catch (error) {
+      logger.error("[ReplicationManager] Persistence write failed", {
+        key: this.persistence.key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.persistInFlight = false;
+      const shouldRunAgain = this.persistPending;
+      this.persistPending = false;
+      if (shouldRunAgain) {
+        void this.persistSafely();
+      }
+    }
+  }
+  isValidReplica(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const candidate = value;
+    const validStatus = candidate.status === "primary" || candidate.status === "secondary" || candidate.status === "syncing" || candidate.status === "failed";
+    return typeof candidate.id === "string" && typeof candidate.nodeId === "string" && validStatus && typeof candidate.lastSyncTime === "string" && typeof candidate.lagBytes === "number" && typeof candidate.lagMillis === "number";
+  }
+  isValidPolicy(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const candidate = value;
+    const validConsistency = candidate.consistencyLevel === "eventual" || candidate.consistencyLevel === "read-after-write" || candidate.consistencyLevel === "strong";
+    return typeof candidate.id === "string" && typeof candidate.name === "string" && typeof candidate.replicationFactor === "number" && validConsistency && typeof candidate.syncInterval === "number" && typeof candidate.maxReplicationLag === "number";
+  }
   /**
    * Clear all state (for testing)
    */
@@ -926,6 +1128,7 @@ var ReplicationManager = class {
     this.syncStatus.clear();
     this.replicasByDID.clear();
     this.cryptoProvider = null;
+    this.schedulePersist();
   }
   /**
    * Get the crypto provider (for advanced usage)
@@ -936,7 +1139,8 @@ var ReplicationManager = class {
 };
 
 // src/distributed/SyncProtocol.ts
-var SyncProtocol = class {
+var SyncProtocol = class _SyncProtocol {
+  static DEFAULT_PERSIST_KEY = "aeon:sync-protocol:v1";
   version = "1.0.0";
   messageQueue = [];
   messageMap = /* @__PURE__ */ new Map();
@@ -946,6 +1150,29 @@ var SyncProtocol = class {
   // Crypto support
   cryptoProvider = null;
   cryptoConfig = null;
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(options) {
+    if (options?.persistence) {
+      this.persistence = {
+        ...options.persistence,
+        key: options.persistence.key ?? _SyncProtocol.DEFAULT_PERSIST_KEY,
+        autoPersist: options.persistence.autoPersist ?? true,
+        autoLoad: options.persistence.autoLoad ?? false,
+        persistDebounceMs: options.persistence.persistDebounceMs ?? 25
+      };
+    }
+    if (this.persistence?.autoLoad) {
+      void this.loadFromPersistence().catch((error) => {
+        logger.error("[SyncProtocol] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
   /**
    * Configure cryptographic provider for authenticated/encrypted messages
    */
@@ -1033,6 +1260,7 @@ var SyncProtocol = class {
     }
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Authenticated handshake created", {
       messageId: message.messageId,
       did: localDID,
@@ -1051,6 +1279,7 @@ var SyncProtocol = class {
     const handshake = message.payload;
     if (!this.cryptoProvider || !this.cryptoConfig) {
       this.handshakes.set(message.sender, handshake);
+      this.schedulePersist();
       return { valid: true, handshake };
     }
     if (handshake.did && handshake.publicSigningKey) {
@@ -1093,6 +1322,7 @@ var SyncProtocol = class {
       }
     }
     this.handshakes.set(message.sender, handshake);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Authenticated handshake verified", {
       messageId: message.messageId,
       did: handshake.did
@@ -1116,7 +1346,10 @@ var SyncProtocol = class {
     };
     if (encrypt && message.receiver && this.cryptoConfig?.encryptionMode !== "none") {
       const payloadBytes = new TextEncoder().encode(JSON.stringify(payload));
-      const encrypted = await this.cryptoProvider.encrypt(payloadBytes, message.receiver);
+      const encrypted = await this.cryptoProvider.encrypt(
+        payloadBytes,
+        message.receiver
+      );
       message.payload = encrypted;
       message.auth.encrypted = true;
       logger.debug("[SyncProtocol] Message encrypted", {
@@ -1189,6 +1422,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Handshake message created", {
       messageId: message.messageId,
       nodeId,
@@ -1216,6 +1450,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Sync request created", {
       messageId: message.messageId,
       sessionId,
@@ -1246,6 +1481,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Sync response created", {
       messageId: message.messageId,
       sessionId,
@@ -1269,6 +1505,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     return message;
   }
   /**
@@ -1293,6 +1530,7 @@ var SyncProtocol = class {
       error,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    this.schedulePersist();
     logger.error("[SyncProtocol] Error message created", {
       messageId: message.messageId,
       errorCode: error.code,
@@ -1317,9 +1555,8 @@ var SyncProtocol = class {
     if (!message.timestamp) {
       errors.push("Timestamp is required");
     }
-    try {
-      new Date(message.timestamp);
-    } catch {
+    const timestampValue = new Date(message.timestamp);
+    if (Number.isNaN(timestampValue.getTime())) {
       errors.push("Invalid timestamp format");
     }
     return {
@@ -1338,7 +1575,9 @@ var SyncProtocol = class {
         messageId: message.messageId,
         error: error instanceof Error ? error.message : String(error)
       });
-      throw new Error(`Failed to serialize message: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `Failed to serialize message: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
@@ -1356,7 +1595,9 @@ var SyncProtocol = class {
       logger.error("[SyncProtocol] Message deserialization failed", {
         error: error instanceof Error ? error.message : String(error)
       });
-      throw new Error(`Failed to deserialize message: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `Failed to deserialize message: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
@@ -1369,6 +1610,7 @@ var SyncProtocol = class {
     const handshake = message.payload;
     const nodeId = message.sender;
     this.handshakes.set(nodeId, handshake);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Handshake processed", {
       nodeId,
       protocolVersion: handshake.protocolVersion,
@@ -1421,7 +1663,9 @@ var SyncProtocol = class {
       messagesByType[message.type] = (messagesByType[message.type] || 0) + 1;
     }
     const errorCount = this.protocolErrors.length;
-    const recoverableErrors = this.protocolErrors.filter((e) => e.error.recoverable).length;
+    const recoverableErrors = this.protocolErrors.filter(
+      (e) => e.error.recoverable
+    ).length;
     return {
       totalMessages: this.messageQueue.length,
       messagesByType,
@@ -1437,6 +1681,156 @@ var SyncProtocol = class {
   getErrors() {
     return [...this.protocolErrors];
   }
+  /**
+   * Persist protocol state for reconnect/replay.
+   */
+  async saveToPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    const data = {
+      protocolVersion: this.version,
+      messageCounter: this.messageCounter,
+      messageQueue: this.getAllMessages(),
+      handshakes: Array.from(this.handshakes.entries()).map(
+        ([nodeId, handshake]) => ({
+          nodeId,
+          handshake
+        })
+      ),
+      protocolErrors: this.getErrors()
+    };
+    const envelope = {
+      version: 1,
+      updatedAt: Date.now(),
+      data
+    };
+    const serialize = this.persistence.serializer ?? ((value) => JSON.stringify(value));
+    await this.persistence.adapter.setItem(this.persistence.key, serialize(envelope));
+  }
+  /**
+   * Load protocol state from persistence.
+   */
+  async loadFromPersistence() {
+    if (!this.persistence) {
+      return { messages: 0, handshakes: 0, errors: 0 };
+    }
+    const raw = await this.persistence.adapter.getItem(this.persistence.key);
+    if (!raw) {
+      return { messages: 0, handshakes: 0, errors: 0 };
+    }
+    const deserialize = this.persistence.deserializer ?? ((value) => JSON.parse(value));
+    const envelope = deserialize(raw);
+    if (envelope.version !== 1 || !envelope.data) {
+      throw new Error("Invalid sync protocol persistence payload");
+    }
+    if (!Array.isArray(envelope.data.messageQueue) || !Array.isArray(envelope.data.handshakes) || !Array.isArray(envelope.data.protocolErrors)) {
+      throw new Error("Invalid sync protocol persistence structure");
+    }
+    const nextMessages = [];
+    for (const message of envelope.data.messageQueue) {
+      const validation = this.validateMessage(message);
+      if (!validation.valid) {
+        throw new Error(
+          `Invalid persisted message ${message?.messageId ?? "unknown"}: ${validation.errors.join(", ")}`
+        );
+      }
+      nextMessages.push(message);
+    }
+    const nextHandshakes = /* @__PURE__ */ new Map();
+    for (const entry of envelope.data.handshakes) {
+      if (typeof entry.nodeId !== "string" || !this.isValidHandshake(entry.handshake)) {
+        throw new Error("Invalid persisted handshake payload");
+      }
+      nextHandshakes.set(entry.nodeId, entry.handshake);
+    }
+    const nextErrors = [];
+    for (const entry of envelope.data.protocolErrors) {
+      if (!this.isValidProtocolErrorEntry(entry)) {
+        throw new Error("Invalid persisted protocol error payload");
+      }
+      nextErrors.push(entry);
+    }
+    this.messageQueue = nextMessages;
+    this.messageMap = new Map(nextMessages.map((m) => [m.messageId, m]));
+    this.handshakes = nextHandshakes;
+    this.protocolErrors = nextErrors;
+    this.messageCounter = Math.max(
+      envelope.data.messageCounter || 0,
+      this.messageQueue.length
+    );
+    logger.debug("[SyncProtocol] Loaded from persistence", {
+      key: this.persistence.key,
+      messages: this.messageQueue.length,
+      handshakes: this.handshakes.size,
+      errors: this.protocolErrors.length
+    });
+    return {
+      messages: this.messageQueue.length,
+      handshakes: this.handshakes.size,
+      errors: this.protocolErrors.length
+    };
+  }
+  /**
+   * Clear persisted protocol checkpoint.
+   */
+  async clearPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    await this.persistence.adapter.removeItem(this.persistence.key);
+  }
+  schedulePersist() {
+    if (!this.persistence || this.persistence.autoPersist === false) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      void this.persistSafely();
+    }, this.persistence.persistDebounceMs ?? 25);
+  }
+  async persistSafely() {
+    if (!this.persistence) {
+      return;
+    }
+    if (this.persistInFlight) {
+      this.persistPending = true;
+      return;
+    }
+    this.persistInFlight = true;
+    try {
+      await this.saveToPersistence();
+    } catch (error) {
+      logger.error("[SyncProtocol] Persistence write failed", {
+        key: this.persistence.key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.persistInFlight = false;
+      const shouldRunAgain = this.persistPending;
+      this.persistPending = false;
+      if (shouldRunAgain) {
+        void this.persistSafely();
+      }
+    }
+  }
+  isValidHandshake(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const handshake = value;
+    const validState = handshake.state === "initiating" || handshake.state === "responding" || handshake.state === "completed";
+    return typeof handshake.protocolVersion === "string" && typeof handshake.nodeId === "string" && Array.isArray(handshake.capabilities) && handshake.capabilities.every((cap) => typeof cap === "string") && validState;
+  }
+  isValidProtocolErrorEntry(entry) {
+    if (typeof entry !== "object" || entry === null) {
+      return false;
+    }
+    const candidate = entry;
+    return typeof candidate.timestamp === "string" && typeof candidate.error?.code === "string" && typeof candidate.error.message === "string" && typeof candidate.error.recoverable === "boolean";
+  }
   /**
    * Generate message ID
    */
@@ -1455,6 +1849,7 @@ var SyncProtocol = class {
     this.messageCounter = 0;
     this.cryptoProvider = null;
     this.cryptoConfig = null;
+    this.schedulePersist();
   }
   /**
    * Get the crypto provider (for advanced usage)
@@ -1840,7 +2235,9 @@ var StateReconciler = class {
     }
     return {
       totalReconciliations: this.reconciliationHistory.length,
-      successfulReconciliations: this.reconciliationHistory.filter((r) => r.success).length,
+      successfulReconciliations: this.reconciliationHistory.filter(
+        (r) => r.success
+      ).length,
       totalConflictsResolved: resolvedConflicts,
       averageConflictsPerReconciliation: this.reconciliationHistory.length > 0 ? resolvedConflicts / this.reconciliationHistory.length : 0,
       strategyUsage,