@rookdaemon/agora 0.3.0 → 0.4.1

package/dist/{chunk-JUOGKXFN.js → chunk-IOHECZYT.js}

@@ -1,129 +1,32 @@
-// src/identity/keypair.ts
-import { sign, verify, generateKeyPairSync } from "crypto";
-function generateKeyPair() {
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
-  return {
-    publicKey: publicKey.export({ type: "spki", format: "der" }).toString("hex"),
-    privateKey: privateKey.export({ type: "pkcs8", format: "der" }).toString("hex")
-  };
-}
-function signMessage(message, privateKeyHex) {
-  const messageBuffer = typeof message === "string" ? Buffer.from(message) : message;
-  const privateKey = Buffer.from(privateKeyHex, "hex");
-  const signature = sign(null, messageBuffer, {
-    key: privateKey,
-    format: "der",
-    type: "pkcs8"
-  });
-  return signature.toString("hex");
-}
-function verifySignature(message, signatureHex, publicKeyHex) {
-  const messageBuffer = typeof message === "string" ? Buffer.from(message) : message;
-  const signature = Buffer.from(signatureHex, "hex");
-  const publicKey = Buffer.from(publicKeyHex, "hex");
-  try {
-    return verify(null, messageBuffer, {
-      key: publicKey,
-      format: "der",
-      type: "spki"
-    }, signature);
-  } catch {
-    return false;
-  }
-}
-function exportKeyPair(keyPair) {
-  return {
-    publicKey: keyPair.publicKey,
-    privateKey: keyPair.privateKey
-  };
-}
-function importKeyPair(publicKeyHex, privateKeyHex) {
-  const hexPattern = /^[0-9a-f]+$/i;
-  if (!hexPattern.test(publicKeyHex)) {
-    throw new Error("Invalid public key: must be a hex string");
-  }
-  if (!hexPattern.test(privateKeyHex)) {
-    throw new Error("Invalid private key: must be a hex string");
-  }
-  return {
-    publicKey: publicKeyHex,
-    privateKey: privateKeyHex
-  };
-}
+import {
+  createEnvelope,
+  generateKeyPair,
+  verifyEnvelope
+} from "./chunk-D7Y66GFC.js";
 
 // src/transport/peer-config.ts
 import { readFileSync, writeFileSync, existsSync } from "fs";
-function loadPeerConfig(path2) {
-  const content = readFileSync(path2, "utf-8");
+function loadPeerConfig(path) {
+  const content = readFileSync(path, "utf-8");
   return JSON.parse(content);
 }
-function savePeerConfig(path2, config) {
+function savePeerConfig(path, config) {
   const content = JSON.stringify(config, null, 2);
-  writeFileSync(path2, content, "utf-8");
+  writeFileSync(path, content, "utf-8");
 }
-function initPeerConfig(path2) {
-  if (existsSync(path2)) {
-    return loadPeerConfig(path2);
+function initPeerConfig(path) {
+  if (existsSync(path)) {
+    return loadPeerConfig(path);
   }
   const identity = generateKeyPair();
   const config = {
     identity,
     peers: {}
   };
-  savePeerConfig(path2, config);
+  savePeerConfig(path, config);
   return config;
 }
 
-// src/message/envelope.ts
-import { createHash } from "crypto";
-function stableStringify(value) {
-  if (value === null || value === void 0) return JSON.stringify(value);
-  if (typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) {
-    return "[" + value.map(stableStringify).join(",") + "]";
-  }
-  const keys = Object.keys(value).sort();
-  const pairs = keys.map((k) => JSON.stringify(k) + ":" + stableStringify(value[k]));
-  return "{" + pairs.join(",") + "}";
-}
-function canonicalize(type, sender, timestamp, payload, inReplyTo) {
-  const obj = { payload, sender, timestamp, type };
-  if (inReplyTo !== void 0) {
-    obj.inReplyTo = inReplyTo;
-  }
-  return stableStringify(obj);
-}
-function computeId(canonical) {
-  return createHash("sha256").update(canonical).digest("hex");
-}
-function createEnvelope(type, sender, privateKey, payload, timestamp = Date.now(), inReplyTo) {
-  const canonical = canonicalize(type, sender, timestamp, payload, inReplyTo);
-  const id = computeId(canonical);
-  const signature = signMessage(canonical, privateKey);
-  return {
-    id,
-    type,
-    sender,
-    timestamp,
-    ...inReplyTo !== void 0 ? { inReplyTo } : {},
-    payload,
-    signature
-  };
-}
-function verifyEnvelope(envelope) {
-  const { id, type, sender, timestamp, payload, signature, inReplyTo } = envelope;
-  const canonical = canonicalize(type, sender, timestamp, payload, inReplyTo);
-  const expectedId = computeId(canonical);
-  if (id !== expectedId) {
-    return { valid: false, reason: "id_mismatch" };
-  }
-  const sigValid = verifySignature(canonical, signature, sender);
-  if (!sigValid) {
-    return { valid: false, reason: "signature_invalid" };
-  }
-  return { valid: true };
-}
-
 // src/transport/http.ts
 async function sendToPeer(config, peerPublicKey, type, payload, inReplyTo) {
   const peer = config.peers.get(peerPublicKey);
@@ -149,27 +52,36 @@ async function sendToPeer(config, peerPublicKey, type, payload, inReplyTo) {
     sessionKey: `agora:${envelope.sender.substring(0, 16)}`,
     deliver: false
   };
-  try {
-    const response = await fetch(`${peer.url}/agent`, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${peer.token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(webhookPayload)
-    });
-    return {
-      ok: response.ok,
-      status: response.status,
-      error: response.ok ? void 0 : await response.text()
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      status: 0,
-      error: err instanceof Error ? err.message : String(err)
-    };
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (peer.token) {
+    headers["Authorization"] = `Bearer ${peer.token}`;
   }
+  const requestBody = JSON.stringify(webhookPayload);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const response = await fetch(`${peer.url}/agent`, {
+        method: "POST",
+        headers,
+        body: requestBody
+      });
+      return {
+        ok: response.ok,
+        status: response.status,
+        error: response.ok ? void 0 : await response.text()
+      };
+    } catch (err) {
+      if (attempt === 1) {
+        return {
+          ok: false,
+          status: 0,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  }
+  return { ok: false, status: 0, error: "Unexpected send failure" };
 }
 function decodeInboundEnvelope(message, knownPeers) {
   const prefix = "[AGORA_ENVELOPE]";
@@ -291,408 +203,10 @@ async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
   });
 }
 
-// src/relay/store.ts
-import * as fs from "fs";
-import * as path from "path";
-var MessageStore = class {
-  storageDir;
-  constructor(storageDir) {
-    this.storageDir = storageDir;
-    fs.mkdirSync(storageDir, { recursive: true });
-  }
-  recipientDir(publicKey) {
-    const safe = publicKey.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return path.join(this.storageDir, safe);
-  }
-  save(recipientKey, message) {
-    const dir = this.recipientDir(recipientKey);
-    fs.mkdirSync(dir, { recursive: true });
-    const filename = `${Date.now()}-${crypto.randomUUID()}.json`;
-    fs.writeFileSync(path.join(dir, filename), JSON.stringify(message));
-  }
-  load(recipientKey) {
-    const dir = this.recipientDir(recipientKey);
-    if (!fs.existsSync(dir)) return [];
-    const files = fs.readdirSync(dir).sort();
-    const messages = [];
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue;
-      try {
-        const data = fs.readFileSync(path.join(dir, file), "utf8");
-        messages.push(JSON.parse(data));
-      } catch {
-      }
-    }
-    return messages;
-  }
-  clear(recipientKey) {
-    const dir = this.recipientDir(recipientKey);
-    if (!fs.existsSync(dir)) return;
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-      if (file.endsWith(".json")) {
-        fs.unlinkSync(path.join(dir, file));
-      }
-    }
-  }
-};
-
-// src/relay/server.ts
-import { EventEmitter } from "events";
-import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
-var RelayServer = class extends EventEmitter {
-  wss = null;
-  agents = /* @__PURE__ */ new Map();
-  identity;
-  storagePeers = [];
-  store = null;
-  constructor(options) {
-    super();
-    if (options) {
-      if ("identity" in options && options.identity) {
-        this.identity = options.identity;
-      } else if ("publicKey" in options && "privateKey" in options) {
-        this.identity = { publicKey: options.publicKey, privateKey: options.privateKey };
-      }
-      const opts = options;
-      if (opts.storagePeers?.length && opts.storageDir) {
-        this.storagePeers = opts.storagePeers;
-        this.store = new MessageStore(opts.storageDir);
-      }
-    }
-  }
-  /**
-   * Start the relay server
-   * @param port - Port to listen on
-   * @param host - Optional host (default: all interfaces)
-   */
-  start(port, host) {
-    return new Promise((resolve, reject) => {
-      try {
-        this.wss = new WebSocketServer({ port, host: host ?? "0.0.0.0" });
-        let resolved = false;
-        this.wss.on("error", (error) => {
-          this.emit("error", error);
-          if (!resolved) {
-            resolved = true;
-            reject(error);
-          }
-        });
-        this.wss.on("listening", () => {
-          if (!resolved) {
-            resolved = true;
-            resolve();
-          }
-        });
-        this.wss.on("connection", (socket) => {
-          this.handleConnection(socket);
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  /**
-   * Stop the relay server
-   */
-  async stop() {
-    return new Promise((resolve, reject) => {
-      if (!this.wss) {
-        resolve();
-        return;
-      }
-      for (const agent of this.agents.values()) {
-        agent.socket.close();
-      }
-      this.agents.clear();
-      this.wss.close((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          this.wss = null;
-          resolve();
-        }
-      });
-    });
-  }
-  /**
-   * Get all connected agents
-   */
-  getAgents() {
-    return new Map(this.agents);
-  }
-  /**
-   * Handle incoming connection
-   */
-  handleConnection(socket) {
-    let agentPublicKey = null;
-    socket.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "register" && !agentPublicKey) {
-          if (!msg.publicKey || typeof msg.publicKey !== "string") {
-            this.sendError(socket, "Invalid registration: missing or invalid publicKey");
-            socket.close();
-            return;
-          }
-          const publicKey = msg.publicKey;
-          const name = msg.name;
-          agentPublicKey = publicKey;
-          const existing = this.agents.get(publicKey);
-          if (existing) {
-            existing.socket.close();
-          }
-          const agent = {
-            publicKey,
-            name,
-            socket,
-            lastSeen: Date.now()
-          };
-          this.agents.set(publicKey, agent);
-          this.emit("agent-registered", publicKey);
-          let peers = Array.from(this.agents.values()).filter((a) => a.publicKey !== publicKey).map((a) => ({ publicKey: a.publicKey, name: a.name }));
-          for (const storagePeer of this.storagePeers) {
-            if (storagePeer !== publicKey && !this.agents.has(storagePeer)) {
-              peers.push({ publicKey: storagePeer, name: void 0 });
-            }
-          }
-          socket.send(JSON.stringify({
-            type: "registered",
-            publicKey,
-            peers
-          }));
-          this.broadcastPeerEvent("peer_online", publicKey, name);
-          if (this.store && this.storagePeers.includes(publicKey)) {
-            const queued = this.store.load(publicKey);
-            for (const stored of queued) {
-              socket.send(JSON.stringify({
-                type: "message",
-                from: stored.from,
-                name: stored.name,
-                envelope: stored.envelope
-              }));
-            }
-            this.store.clear(publicKey);
-          }
-          return;
-        }
-        if (!agentPublicKey) {
-          this.sendError(socket, "Not registered: send registration message first");
-          socket.close();
-          return;
-        }
-        if (msg.type === "message") {
-          if (!msg.to || typeof msg.to !== "string") {
-            this.sendError(socket, 'Invalid message: missing or invalid "to" field');
-            return;
-          }
-          if (!msg.envelope || typeof msg.envelope !== "object") {
-            this.sendError(socket, 'Invalid message: missing or invalid "envelope" field');
-            return;
-          }
-          const envelope = msg.envelope;
-          const verification = verifyEnvelope(envelope);
-          if (!verification.valid) {
-            this.sendError(socket, `Invalid envelope: ${verification.reason || "verification failed"}`);
-            return;
-          }
-          if (envelope.sender !== agentPublicKey) {
-            this.sendError(socket, "Envelope sender does not match registered public key");
-            return;
-          }
-          const senderAgent = this.agents.get(agentPublicKey);
-          if (senderAgent) {
-            senderAgent.lastSeen = Date.now();
-          }
-          if (envelope.type === "peer_list_request" && this.identity && msg.to === this.identity.publicKey) {
-            this.handlePeerListRequest(envelope, socket, agentPublicKey);
-            return;
-          }
-          const recipient = this.agents.get(msg.to);
-          if (!recipient || recipient.socket.readyState !== WebSocket2.OPEN) {
-            if (this.store && this.storagePeers.includes(msg.to)) {
-              const senderAgent2 = this.agents.get(agentPublicKey);
-              this.store.save(msg.to, {
-                from: agentPublicKey,
-                name: senderAgent2?.name,
-                envelope
-              });
-              this.emit("message-relayed", agentPublicKey, msg.to, envelope);
-            } else {
-              this.sendError(socket, "Recipient not connected");
-            }
-            return;
-          }
-          try {
-            const senderAgent2 = this.agents.get(agentPublicKey);
-            const relayMessage = {
-              type: "message",
-              from: agentPublicKey,
-              name: senderAgent2?.name,
-              envelope
-            };
-            recipient.socket.send(JSON.stringify(relayMessage));
-            this.emit("message-relayed", agentPublicKey, msg.to, envelope);
-          } catch (err) {
-            this.sendError(socket, "Failed to relay message");
-            this.emit("error", err);
-          }
-          return;
-        }
-        if (msg.type === "broadcast") {
-          if (!msg.envelope || typeof msg.envelope !== "object") {
-            this.sendError(socket, 'Invalid broadcast: missing or invalid "envelope" field');
-            return;
-          }
-          const envelope = msg.envelope;
-          const verification = verifyEnvelope(envelope);
-          if (!verification.valid) {
-            this.sendError(socket, `Invalid envelope: ${verification.reason || "verification failed"}`);
-            return;
-          }
-          if (envelope.sender !== agentPublicKey) {
-            this.sendError(socket, "Envelope sender does not match registered public key");
-            return;
-          }
-          const senderAgentBroadcast = this.agents.get(agentPublicKey);
-          if (senderAgentBroadcast) {
-            senderAgentBroadcast.lastSeen = Date.now();
-          }
-          const senderAgent = this.agents.get(agentPublicKey);
-          const relayMessage = {
-            type: "message",
-            from: agentPublicKey,
-            name: senderAgent?.name,
-            envelope
-          };
-          const messageStr = JSON.stringify(relayMessage);
-          for (const agent of this.agents.values()) {
-            if (agent.publicKey !== agentPublicKey && agent.socket.readyState === WebSocket2.OPEN) {
-              try {
-                agent.socket.send(messageStr);
-              } catch (err) {
-                this.emit("error", err);
-              }
-            }
-          }
-          return;
-        }
-        if (msg.type === "ping") {
-          socket.send(JSON.stringify({ type: "pong" }));
-          return;
-        }
-        this.sendError(socket, `Unknown message type: ${msg.type}`);
-      } catch (err) {
-        this.emit("error", new Error(`Message parsing failed: ${err instanceof Error ? err.message : String(err)}`));
-        this.sendError(socket, "Invalid message format");
-      }
-    });
-    socket.on("close", () => {
-      if (agentPublicKey) {
-        const agent = this.agents.get(agentPublicKey);
-        const agentName = agent?.name;
-        this.agents.delete(agentPublicKey);
-        this.emit("agent-disconnected", agentPublicKey);
-        if (!this.storagePeers.includes(agentPublicKey)) {
-          this.broadcastPeerEvent("peer_offline", agentPublicKey, agentName);
-        }
-      }
-    });
-    socket.on("error", (error) => {
-      this.emit("error", error);
-    });
-  }
-  /**
-   * Send an error message to a client
-   */
-  sendError(socket, message) {
-    try {
-      if (socket.readyState === WebSocket2.OPEN) {
-        socket.send(JSON.stringify({ type: "error", message }));
-      }
-    } catch (err) {
-      this.emit("error", new Error(`Failed to send error message: ${err instanceof Error ? err.message : String(err)}`));
-    }
-  }
-  /**
-   * Broadcast a peer event to all connected agents
-   */
-  broadcastPeerEvent(eventType, publicKey, name) {
-    const message = {
-      type: eventType,
-      publicKey,
-      name
-    };
-    const messageStr = JSON.stringify(message);
-    for (const agent of this.agents.values()) {
-      if (agent.publicKey !== publicKey && agent.socket.readyState === WebSocket2.OPEN) {
-        try {
-          agent.socket.send(messageStr);
-        } catch (err) {
-          this.emit("error", new Error(`Failed to send ${eventType} event: ${err instanceof Error ? err.message : String(err)}`));
-        }
-      }
-    }
-  }
-  /**
-   * Handle peer list request from an agent
-   */
-  handlePeerListRequest(envelope, socket, requesterPublicKey) {
-    if (!this.identity) {
-      this.sendError(socket, "Relay does not support peer discovery (no identity configured)");
-      return;
-    }
-    const { filters } = envelope.payload;
-    const now = Date.now();
-    let peers = Array.from(this.agents.values());
-    peers = peers.filter((p) => p.publicKey !== requesterPublicKey);
-    if (filters?.activeWithin) {
-      peers = peers.filter((p) => now - p.lastSeen < filters.activeWithin);
-    }
-    if (filters?.limit && filters.limit > 0) {
-      peers = peers.slice(0, filters.limit);
-    }
-    const response = {
-      peers: peers.map((p) => ({
-        publicKey: p.publicKey,
-        metadata: p.name || p.metadata ? {
-          name: p.name,
-          version: p.metadata?.version,
-          capabilities: p.metadata?.capabilities
-        } : void 0,
-        lastSeen: p.lastSeen
-      })),
-      totalPeers: this.agents.size - 1,
-      // Exclude requester from count
-      relayPublicKey: this.identity.publicKey
-    };
-    const responseEnvelope = createEnvelope(
-      "peer_list_response",
-      this.identity.publicKey,
-      this.identity.privateKey,
-      response,
-      Date.now(),
-      envelope.id
-      // Reply to the request
-    );
-    const relayMessage = {
-      type: "message",
-      from: this.identity.publicKey,
-      name: "relay",
-      envelope: responseEnvelope
-    };
-    try {
-      socket.send(JSON.stringify(relayMessage));
-    } catch (err) {
-      this.emit("error", new Error(`Failed to send peer list response: ${err instanceof Error ? err.message : String(err)}`));
-    }
-  }
-};
-
 // src/relay/client.ts
-import { EventEmitter as EventEmitter2 } from "events";
-import WebSocket3 from "ws";
-var RelayClient = class extends EventEmitter2 {
+import { EventEmitter } from "events";
+import WebSocket2 from "ws";
+var RelayClient = class extends EventEmitter {
   ws = null;
   config;
   reconnectAttempts = 0;
@@ -714,7 +228,7 @@ var RelayClient = class extends EventEmitter2 {
    * Connect to the relay server
    */
   async connect() {
-    if (this.ws && (this.ws.readyState === WebSocket3.CONNECTING || this.ws.readyState === WebSocket3.OPEN)) {
+    if (this.ws && (this.ws.readyState === WebSocket2.CONNECTING || this.ws.readyState === WebSocket2.OPEN)) {
       return;
     }
     this.shouldReconnect = true;
@@ -792,7 +306,7 @@ var RelayClient = class extends EventEmitter2 {
   async doConnect() {
     return new Promise((resolve, reject) => {
       try {
-        this.ws = new WebSocket3(this.config.relayUrl);
+        this.ws = new WebSocket2(this.config.relayUrl);
         let resolved = false;
         const resolveOnce = (callback) => {
           if (!resolved) {
@@ -928,7 +442,7 @@ var RelayClient = class extends EventEmitter2 {
   startPingInterval() {
     this.stopPingInterval();
     this.pingInterval = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket3.OPEN) {
+      if (this.ws && this.ws.readyState === WebSocket2.OPEN) {
         const ping = { type: "ping" };
         this.ws.send(JSON.stringify(ping));
       }
@@ -957,8 +471,8 @@ var RelayClient = class extends EventEmitter2 {
 };
 
 // src/discovery/peer-discovery.ts
-import { EventEmitter as EventEmitter3 } from "events";
-var PeerDiscoveryService = class extends EventEmitter3 {
+import { EventEmitter as EventEmitter2 } from "events";
+var PeerDiscoveryService = class extends EventEmitter2 {
   config;
   constructor(config) {
     super();
@@ -1211,7 +725,7 @@ function validateRevealRecord(record) {
 }
 
 // src/reputation/store.ts
-import { promises as fs2 } from "fs";
+import { promises as fs } from "fs";
 import { dirname } from "path";
 var ReputationStore = class {
   filePath;
@@ -1227,7 +741,7 @@ var ReputationStore = class {
    */
   async load() {
     try {
-      const content = await fs2.readFile(this.filePath, "utf-8");
+      const content = await fs.readFile(this.filePath, "utf-8");
       const lines = content.trim().split("\n").filter((line) => line.length > 0);
       for (const line of lines) {
         try {
@@ -1283,9 +797,9 @@ var ReputationStore = class {
    * Append a record to the JSONL file
    */
   async appendToFile(record) {
-    await fs2.mkdir(dirname(this.filePath), { recursive: true });
+    await fs.mkdir(dirname(this.filePath), { recursive: true });
     const line = JSON.stringify(record) + "\n";
-    await fs2.appendFile(this.filePath, line, "utf-8");
+    await fs.appendFile(this.filePath, line, "utf-8");
   }
   /**
    * Add a verification record
@@ -1459,9 +973,9 @@ function verifyVerificationSignature(record) {
 }
 
 // src/reputation/commit-reveal.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 function hashPrediction(prediction) {
-  return createHash2("sha256").update(prediction).digest("hex");
+  return createHash("sha256").update(prediction).digest("hex");
 }
 function createCommit(agent, privateKey, domain, prediction, timestamp, expiryMs) {
   const commitment = hashPrediction(prediction);
@@ -1550,7 +1064,7 @@ function verdictWeight(verdict) {
       return 0;
   }
 }
-function computeTrustScore(agent, domain, verifications, currentTime) {
+function computeTrustScore(agent, domain, verifications, currentTime, options) {
   const relevantVerifications = verifications.filter(
     (v) => v.target === agent && v.domain === domain
   );
@@ -1564,17 +1078,34 @@ function computeTrustScore(agent, domain, verifications, currentTime) {
       topVerifiers: []
     };
   }
+  const maxDepth = options?.maxDepth ?? 3;
+  const visitedAgents = options?.visitedAgents;
+  const getVerifierScore = options?.getVerifierScore;
+  if (visitedAgents) {
+    visitedAgents.add(agent);
+  }
   let totalWeight = 0;
   const verifierWeights = /* @__PURE__ */ new Map();
   for (const verification of relevantVerifications) {
     const deltaTime = currentTime - verification.timestamp;
     const decayFactor = decay(deltaTime);
     const verdict = verdictWeight(verification.verdict);
-    const weight = verdict * verification.confidence * decayFactor;
+    let verifierTrustWeight;
+    if (!getVerifierScore || maxDepth <= 0) {
+      verifierTrustWeight = 1;
+    } else if (visitedAgents?.has(verification.verifier)) {
+      verifierTrustWeight = 0.5;
+    } else {
+      verifierTrustWeight = getVerifierScore(verification.verifier, domain);
+    }
+    const weight = verdict * verification.confidence * decayFactor * verifierTrustWeight;
     totalWeight += weight;
-    const currentVerifierWeight = verifierWeights.get(verification.verifier) || 0;
+    const currentVerifierWeight = verifierWeights.get(verification.verifier) ?? 0;
     verifierWeights.set(verification.verifier, currentVerifierWeight + Math.abs(weight));
   }
+  if (visitedAgents) {
+    visitedAgents.delete(agent);
+  }
   const rawScore = totalWeight / Math.max(relevantVerifications.length, 1);
   const normalizedScore = Math.max(0, Math.min(1, (rawScore + 1) / 2));
   const lastVerified = Math.max(...relevantVerifications.map((v) => v.timestamp));
@@ -1602,23 +1133,12 @@ function computeTrustScores(agent, verifications, currentTime) {
 var computeAllTrustScores = computeTrustScores;
 
 export {
-  generateKeyPair,
-  signMessage,
-  verifySignature,
-  exportKeyPair,
-  importKeyPair,
   loadPeerConfig,
   savePeerConfig,
   initPeerConfig,
-  canonicalize,
-  computeId,
-  createEnvelope,
-  verifyEnvelope,
   sendToPeer,
   decodeInboundEnvelope,
   sendViaRelay,
-  MessageStore,
-  RelayServer,
   RelayClient,
   PeerDiscoveryService,
   DEFAULT_BOOTSTRAP_RELAYS,
@@ -1642,4 +1162,4 @@ export {
   computeTrustScores,
   computeAllTrustScores
 };
-//# sourceMappingURL=chunk-JUOGKXFN.js.map
+//# sourceMappingURL=chunk-IOHECZYT.js.map