@tacitprotocol/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,960 @@
+// src/core/agent.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/identity/did.ts
+async function generateKeypair() {
+  const keyPair = await crypto.subtle.generateKey(
+    { name: "Ed25519" },
+    true,
+    ["sign", "verify"]
+  );
+  const pair = keyPair;
+  const publicKeyBuffer = await crypto.subtle.exportKey("raw", pair.publicKey);
+  const privateKeyBuffer = await crypto.subtle.exportKey("pkcs8", pair.privateKey);
+  return {
+    publicKey: new Uint8Array(publicKeyBuffer),
+    privateKey: new Uint8Array(privateKeyBuffer)
+  };
+}
+function publicKeyToDid(publicKey) {
+  const ED25519_MULTICODEC = new Uint8Array([237, 1]);
+  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKey.length);
+  prefixed.set(ED25519_MULTICODEC);
+  prefixed.set(publicKey, ED25519_MULTICODEC.length);
+  const encoded = base58btcEncode(prefixed);
+  return `did:key:z${encoded}`;
+}
+async function createIdentity() {
+  const { publicKey, privateKey } = await generateKeypair();
+  const did = publicKeyToDid(publicKey);
+  return {
+    did,
+    publicKey,
+    privateKey,
+    created: /* @__PURE__ */ new Date()
+  };
+}
+function resolveDid(did) {
+  if (!did.startsWith("did:key:z")) {
+    return null;
+  }
+  const encoded = did.slice("did:key:z".length);
+  const decoded = base58btcDecode(encoded);
+  const publicKey = decoded.slice(2);
+  return { publicKey };
+}
+async function sign(data, privateKey) {
+  const key = await crypto.subtle.importKey(
+    "pkcs8",
+    privateKey.buffer,
+    { name: "Ed25519" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("Ed25519", key, data.buffer);
+  return new Uint8Array(signature);
+}
+async function verify(data, signature, publicKey) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    publicKey.buffer,
+    { name: "Ed25519" },
+    false,
+    ["verify"]
+  );
+  return crypto.subtle.verify("Ed25519", key, signature.buffer, data.buffer);
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58btcEncode(bytes) {
+  if (bytes.length === 0) return "";
+  let zeros = 0;
+  for (const byte of bytes) {
+    if (byte !== 0) break;
+    zeros++;
+  }
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let result = "";
+  for (let i = 0; i < zeros; i++) result += "1";
+  for (let i = digits.length - 1; i >= 0; i--) result += BASE58_ALPHABET[digits[i]];
+  return result;
+}
+function base58btcDecode(str) {
+  if (str.length === 0) return new Uint8Array(0);
+  const bytes = [0];
+  for (const char of str) {
+    const value = BASE58_ALPHABET.indexOf(char);
+    if (value === -1) throw new Error(`Invalid base58 character: ${char}`);
+    let carry = value;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  let zeros = 0;
+  for (const char of str) {
+    if (char !== "1") break;
+    zeros++;
+  }
+  const result = new Uint8Array(zeros + bytes.length);
+  for (let i = 0; i < zeros; i++) result[i] = 0;
+  for (let i = 0; i < bytes.length; i++) result[zeros + i] = bytes[bytes.length - 1 - i];
+  return result;
+}
+
+// src/identity/authenticity.ts
+var DIMENSION_WEIGHTS = {
+  tenure: 0.2,
+  consistency: 0.3,
+  attestations: 0.25,
+  networkTrust: 0.25
+};
+var TRUST_LEVEL_THRESHOLDS = [
+  ["exemplary", 90],
+  ["trusted", 70],
+  ["established", 40],
+  ["emerging", 20],
+  ["new", 0]
+];
+var CONSISTENCY_WEIGHTS = {
+  intentStability: 0.3,
+  profileConsistency: 0.25,
+  responseReliability: 0.25,
+  interactionQuality: 0.2
+};
+var ATTESTATION_WEIGHTS = {
+  institutional: 0.4,
+  peer: 0.3,
+  transaction: 0.3
+};
+var DECAY_RATE_PER_DAY = 1e-3;
+var DECAY_GRACE_PERIOD_DAYS = 30;
+var AuthenticityEngine = class {
+  /**
+   * Compute the tenure dimension score.
+   * Linear growth over 365 days, capped at 1.0.
+   */
+  computeTenure(agentCreatedDate, now = /* @__PURE__ */ new Date()) {
+    const daysActive = (now.getTime() - agentCreatedDate.getTime()) / (1e3 * 60 * 60 * 24);
+    return Math.min(1, Math.max(0, daysActive / 365));
+  }
+  /**
+   * Compute the consistency dimension score.
+   * Based on behavioral stability signals over time.
+   */
+  computeConsistency(signals) {
+    return clamp(
+      signals.intentStability * CONSISTENCY_WEIGHTS.intentStability + signals.profileConsistency * CONSISTENCY_WEIGHTS.profileConsistency + signals.responseReliability * CONSISTENCY_WEIGHTS.responseReliability + signals.interactionQuality * CONSISTENCY_WEIGHTS.interactionQuality
+    );
+  }
+  /**
+   * Compute the attestation dimension score.
+   * Based on third-party verifiable credentials.
+   */
+  computeAttestations(credentials) {
+    if (credentials.length === 0) return 0;
+    let institutional = 0;
+    let peer = 0;
+    let transaction = 0;
+    for (const cred of credentials) {
+      if (isInstitutionalCredential(cred)) {
+        institutional += credentialWeight(cred);
+      } else if (isPeerAttestation(cred)) {
+        peer += credentialWeight(cred);
+      } else {
+        transaction += credentialWeight(cred);
+      }
+    }
+    institutional = Math.min(1, institutional);
+    peer = Math.min(1, peer);
+    transaction = Math.min(1, transaction);
+    return clamp(
+      institutional * ATTESTATION_WEIGHTS.institutional + peer * ATTESTATION_WEIGHTS.peer + transaction * ATTESTATION_WEIGHTS.transaction
+    );
+  }
+  /**
+   * Compute the network trust dimension score.
+   * Based on the quality of the agent's network relationships.
+   *
+   * This is a simplified version — production implementations
+   * should use a full PageRank-style algorithm.
+   */
+  computeNetworkTrust(signals) {
+    if (signals.totalInteractions === 0) return 0;
+    const successRate = signals.successfulIntros / Math.max(1, signals.totalIntros);
+    const positiveRate = signals.positiveInteractions / signals.totalInteractions;
+    const bidirectionalBonus = Math.min(1, signals.bidirectionalTrustEdges * 0.1);
+    return clamp(
+      successRate * 0.35 + positiveRate * 0.35 + bidirectionalBonus * 0.3
+    );
+  }
+  /**
+   * Compute the full authenticity vector from all dimensions.
+   */
+  computeVector(params) {
+    const now = /* @__PURE__ */ new Date();
+    const dimensions = {
+      tenure: this.computeTenure(params.agentCreatedDate, now),
+      consistency: this.computeConsistency(params.consistencySignals),
+      attestations: this.computeAttestations(params.credentials),
+      networkTrust: this.computeNetworkTrust(params.networkSignals)
+    };
+    let score = dimensions.tenure * DIMENSION_WEIGHTS.tenure + dimensions.consistency * DIMENSION_WEIGHTS.consistency + dimensions.attestations * DIMENSION_WEIGHTS.attestations + dimensions.networkTrust * DIMENSION_WEIGHTS.networkTrust;
+    if (params.lastActiveDate) {
+      const inactiveDays = (now.getTime() - params.lastActiveDate.getTime()) / (1e3 * 60 * 60 * 24);
+      if (inactiveDays > DECAY_GRACE_PERIOD_DAYS) {
+        const decayDays = inactiveDays - DECAY_GRACE_PERIOD_DAYS;
+        const decayFactor = Math.max(0, 1 - decayDays * DECAY_RATE_PER_DAY);
+        score *= decayFactor;
+      }
+    }
+    score = Math.round(score * 100);
+    return {
+      level: this.scoreToLevel(score),
+      score,
+      dimensions,
+      verifiableCredentials: params.credentials
+    };
+  }
+  /**
+   * Convert a numeric score to a trust level.
+   */
+  scoreToLevel(score) {
+    for (const [level, threshold] of TRUST_LEVEL_THRESHOLDS) {
+      if (score >= threshold) return level;
+    }
+    return "new";
+  }
+  /**
+   * Check if an agent meets minimum authenticity requirements.
+   */
+  meetsMinimum(vector, minScore) {
+    return vector.score >= minScore;
+  }
+};
+function clamp(value, min = 0, max = 1) {
+  return Math.min(max, Math.max(min, value));
+}
+var INSTITUTIONAL_TYPES = /* @__PURE__ */ new Set([
+  "EmploymentCredential",
+  "EducationCredential",
+  "ProfessionalCertification",
+  "GovernmentId",
+  "LicenseCredential"
+]);
+function isInstitutionalCredential(cred) {
+  return INSTITUTIONAL_TYPES.has(cred.type);
+}
+var PEER_TYPES = /* @__PURE__ */ new Set([
+  "PeerEndorsement",
+  "PeerAttestation",
+  "RecommendationCredential"
+]);
+function isPeerAttestation(cred) {
+  return PEER_TYPES.has(cred.type);
+}
+function credentialWeight(cred) {
+  const issued = new Date(cred.issued);
+  const ageYears = (Date.now() - issued.getTime()) / (1e3 * 60 * 60 * 24 * 365);
+  const ageFactor = Math.max(0.1, 1 - (ageYears - 1) * 0.1);
+  const baseWeight = INSTITUTIONAL_TYPES.has(cred.type) ? 0.5 : 0.3;
+  return baseWeight * ageFactor;
+}
+
+// src/core/agent.ts
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  globalHandlers = /* @__PURE__ */ new Set();
+  on(type, handler) {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(type).add(handler);
+  }
+  onAny(handler) {
+    this.globalHandlers.add(handler);
+  }
+  off(type, handler) {
+    this.handlers.get(type)?.delete(handler);
+  }
+  async emit(event) {
+    const handlers = this.handlers.get(event.type) ?? /* @__PURE__ */ new Set();
+    const all = [...handlers, ...this.globalHandlers];
+    for (const handler of all) {
+      try {
+        await handler(event);
+      } catch (error) {
+        console.error(`[Tacit] Event handler error for ${event.type}:`, error);
+      }
+    }
+  }
+};
+var TacitAgent = class {
+  identity = null;
+  config;
+  events = new EventBus();
+  authenticityEngine = new AuthenticityEngine();
+  intents = /* @__PURE__ */ new Map();
+  proposals = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor(config) {
+    this.config = {
+      relayUrl: "wss://relay.tacitprotocol.dev",
+      matchThresholds: {
+        autoPropose: 80,
+        suggest: 60
+      },
+      preferences: {
+        introductionStyle: "progressive",
+        initialAnonymity: true,
+        responseTime: "24h",
+        languages: ["en"]
+      },
+      ...config
+    };
+    if (config.identity) {
+      this.identity = config.identity;
+    }
+  }
+  // ─── Static Factory ───────────────────────────────────────────
+  /**
+   * Create a new agent identity.
+   * Returns an AgentIdentity that can be passed to the constructor.
+   */
+  static async createIdentity() {
+    return createIdentity();
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────
+  /**
+   * Connect the agent to the Tacit network via a relay node.
+   */
+  async connect() {
+    if (!this.identity) {
+      this.identity = await createIdentity();
+    }
+    this.connected = true;
+    await this.events.emit({
+      type: "connection:established",
+      endpoint: this.config.relayUrl
+    });
+  }
+  /**
+   * Disconnect the agent from the network.
+   * Active intents remain on the network until their TTL expires.
+   */
+  async disconnect() {
+    this.connected = false;
+  }
+  /**
+   * Check if the agent is connected to the network.
+   */
+  isConnected() {
+    return this.connected;
+  }
+  // ─── Identity ─────────────────────────────────────────────────
+  /**
+   * Get the agent's DID.
+   */
+  getDid() {
+    if (!this.identity) throw new Error("Agent has no identity. Call connect() first.");
+    return this.identity.did;
+  }
+  /**
+   * Get the agent's Agent Card.
+   */
+  getAgentCard() {
+    if (!this.identity) throw new Error("Agent has no identity. Call connect() first.");
+    return {
+      version: "0.1.0",
+      agent: {
+        did: this.identity.did,
+        name: this.config.profile?.name ?? "Unnamed Tacit",
+        description: this.config.profile?.description ?? "",
+        created: this.identity.created.toISOString(),
+        protocols: ["tacit/discovery/v0.1", "tacit/intro/v0.1"],
+        transport: {
+          type: "didcomm/v2",
+          endpoint: this.config.relayUrl
+        }
+      },
+      domains: this.config.profile ? [{
+        type: this.config.profile.domain,
+        seeking: [this.config.profile.seeking],
+        offering: [this.config.profile.offering],
+        context: {}
+      }] : [],
+      authenticity: this.getAuthenticity(),
+      preferences: {
+        introductionStyle: this.config.preferences?.introductionStyle ?? "progressive",
+        initialAnonymity: this.config.preferences?.initialAnonymity ?? true,
+        responseTime: this.config.preferences?.responseTime ?? "24h",
+        languages: this.config.preferences?.languages ?? ["en"]
+      }
+    };
+  }
+  /**
+   * Get the agent's current authenticity vector.
+   */
+  getAuthenticity() {
+    if (!this.identity) {
+      return {
+        level: "new",
+        score: 0,
+        dimensions: { tenure: 0, consistency: 0, attestations: 0, networkTrust: 0 },
+        verifiableCredentials: []
+      };
+    }
+    return this.authenticityEngine.computeVector({
+      agentCreatedDate: this.identity.created,
+      consistencySignals: {
+        intentStability: 1,
+        // New agent, no changes yet
+        profileConsistency: 1,
+        responseReliability: 0.5,
+        // No track record
+        interactionQuality: 0.5
+      },
+      credentials: [],
+      networkSignals: {
+        totalInteractions: 0,
+        positiveInteractions: 0,
+        totalIntros: 0,
+        successfulIntros: 0,
+        bidirectionalTrustEdges: 0
+      },
+      lastActiveDate: /* @__PURE__ */ new Date()
+    });
+  }
+  // ─── Intents ──────────────────────────────────────────────────
+  /**
+   * Publish an intent to the network.
+   */
+  async publishIntent(params) {
+    if (!this.identity) throw new Error("Agent has no identity. Call connect() first.");
+    const intent = {
+      id: `intent:${this.identity.did.split(":").pop()}:${Date.now()}`,
+      agentDid: this.identity.did,
+      type: params.type,
+      domain: params.domain,
+      intent: {
+        seeking: params.seeking,
+        context: params.context ?? {}
+      },
+      filters: {
+        minAuthenticityScore: params.filters?.minAuthenticityScore ?? 50,
+        requiredCredentials: params.filters?.requiredCredentials ?? [],
+        excludedDomains: []
+      },
+      privacyLevel: params.privacyLevel ?? "filtered",
+      ttl: params.ttlSeconds ?? 604800,
+      // 7 days default
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      signature: ""
+      // TODO: Sign with agent's private key
+    };
+    this.intents.set(intent.id, intent);
+    await this.events.emit({ type: "intent:published", intent });
+    return intent;
+  }
+  /**
+   * Withdraw an active intent.
+   */
+  async withdrawIntent(intentId) {
+    const intent = this.intents.get(intentId);
+    if (!intent) throw new Error(`Intent ${intentId} not found`);
+    this.intents.delete(intentId);
+  }
+  /**
+   * Get all active intents.
+   */
+  getActiveIntents() {
+    return Array.from(this.intents.values());
+  }
+  // ─── Proposals ────────────────────────────────────────────────
+  /**
+   * Handle an incoming match from the network.
+   * Called when another agent's intent is compatible with ours.
+   */
+  async handleMatch(match) {
+    const thresholds = this.config.matchThresholds;
+    if (match.score.overall >= thresholds.autoPropose) {
+      await this.proposeIntro(match);
+    } else if (match.score.overall >= thresholds.suggest) {
+      await this.events.emit({ type: "intent:matched", match });
+    }
+  }
+  /**
+   * Create and send an introduction proposal.
+   */
+  async proposeIntro(match) {
+    if (!this.identity) throw new Error("Agent has no identity.");
+    const proposal = {
+      id: `proposal:${uuidv4()}`,
+      type: "introduction",
+      initiator: {
+        agentDid: this.identity.did,
+        persona: {
+          displayName: this.config.profile?.name ?? "Anonymous",
+          context: this.config.profile?.seeking ?? "",
+          anonymityLevel: this.config.preferences?.initialAnonymity ? "pseudonymous" : "identified",
+          sessionId: uuidv4()
+        }
+      },
+      responder: {
+        agentDid: match.agents.responder
+      },
+      match: {
+        score: match.score.overall,
+        rationale: this.generateRationale(match),
+        domain: "professional"
+        // TODO: derive from intent
+      },
+      terms: {
+        initialReveal: "pseudonymous",
+        revealStages: ["domain_context", "professional_background", "identity"],
+        communicationChannel: "tacit_direct",
+        expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString()
+      },
+      status: "pending",
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      signature: ""
+      // TODO: Sign
+    };
+    this.proposals.set(proposal.id, proposal);
+    return proposal;
+  }
+  /**
+   * Accept an introduction proposal.
+   * This is the human's explicit consent (one half of double opt-in).
+   */
+  async acceptProposal(proposalId) {
+    const proposal = this.proposals.get(proposalId);
+    if (!proposal) throw new Error(`Proposal ${proposalId} not found`);
+    if (!this.identity) throw new Error("Agent has no identity.");
+    const isInitiator = proposal.initiator.agentDid === this.identity.did;
+    if (isInitiator) {
+      proposal.status = "accepted_by_initiator";
+    } else {
+      proposal.status = "accepted_by_responder";
+    }
+    await this.events.emit({ type: "proposal:accepted", proposal });
+  }
+  /**
+   * Decline an introduction proposal.
+   * The other party receives a generic "not a match" response.
+   */
+  async declineProposal(proposalId) {
+    const proposal = this.proposals.get(proposalId);
+    if (!proposal) throw new Error(`Proposal ${proposalId} not found`);
+    proposal.status = "declined";
+    this.proposals.delete(proposalId);
+    await this.events.emit({ type: "proposal:declined", proposalId });
+  }
+  /**
+   * Get all pending proposals.
+   */
+  getPendingProposals() {
+    return Array.from(this.proposals.values()).filter((p) => p.status === "pending");
+  }
+  // ─── Events ───────────────────────────────────────────────────
+  /**
+   * Subscribe to specific event types.
+   */
+  on(type, handler) {
+    this.events.on(type, handler);
+  }
+  /**
+   * Subscribe to all events.
+   */
+  onAny(handler) {
+    this.events.onAny(handler);
+  }
+  /**
+   * Unsubscribe from an event type.
+   */
+  off(type, handler) {
+    this.events.off(type, handler);
+  }
+  // ─── Helpers ──────────────────────────────────────────────────
+  generateRationale(match) {
+    const parts = [];
+    const b = match.score.breakdown;
+    if (b.intentAlignment > 0.8) parts.push("Strong intent alignment");
+    if (b.domainFit > 0.8) parts.push("Excellent domain fit");
+    if (b.authenticityCompatibility > 0.7) parts.push("High authenticity compatibility");
+    if (b.preferenceMatch > 0.7) parts.push("Good preference match");
+    return parts.length > 0 ? parts.join(". ") + "." : `Match score: ${match.score.overall}/100`;
+  }
+};
+
+// src/discovery/intent.ts
+var IntentBuilder = class {
+  partial = {};
+  constructor(agentDid) {
+    this.partial.agentDid = agentDid;
+    this.partial.id = `intent:${agentDid.split(":").pop()}:${Date.now()}`;
+    this.partial.created = (/* @__PURE__ */ new Date()).toISOString();
+    this.partial.privacyLevel = "filtered";
+    this.partial.ttl = 604800;
+    this.partial.filters = {
+      minAuthenticityScore: 50,
+      requiredCredentials: [],
+      excludedDomains: []
+    };
+  }
+  type(type) {
+    this.partial.type = type;
+    return this;
+  }
+  domain(domain) {
+    this.partial.domain = domain;
+    return this;
+  }
+  seeking(seeking) {
+    if (!this.partial.intent) {
+      this.partial.intent = { seeking: {}, context: {} };
+    }
+    this.partial.intent.seeking = seeking;
+    return this;
+  }
+  context(context) {
+    if (!this.partial.intent) {
+      this.partial.intent = { seeking: {}, context: {} };
+    }
+    this.partial.intent.context = context;
+    return this;
+  }
+  privacy(level) {
+    this.partial.privacyLevel = level;
+    return this;
+  }
+  ttl(seconds) {
+    this.partial.ttl = seconds;
+    return this;
+  }
+  minAuthenticity(score) {
+    this.partial.filters.minAuthenticityScore = score;
+    return this;
+  }
+  requireCredentials(...types) {
+    this.partial.filters.requiredCredentials = types;
+    return this;
+  }
+  build() {
+    if (!this.partial.type) throw new Error("Intent type is required");
+    if (!this.partial.domain) throw new Error("Intent domain is required");
+    if (!this.partial.intent?.seeking) throw new Error("Intent seeking is required");
+    return {
+      id: this.partial.id,
+      agentDid: this.partial.agentDid,
+      type: this.partial.type,
+      domain: this.partial.domain,
+      intent: this.partial.intent,
+      filters: this.partial.filters,
+      privacyLevel: this.partial.privacyLevel,
+      ttl: this.partial.ttl,
+      created: this.partial.created,
+      signature: ""
+      // Signed by agent before publishing
+    };
+  }
+};
+var IntentStore = class {
+  intents = /* @__PURE__ */ new Map();
+  add(intent) {
+    this.intents.set(intent.id, { intent, status: "active" });
+  }
+  get(id) {
+    return this.intents.get(id)?.intent;
+  }
+  getStatus(id) {
+    return this.intents.get(id)?.status;
+  }
+  setStatus(id, status) {
+    const entry = this.intents.get(id);
+    if (entry) entry.status = status;
+  }
+  withdraw(id) {
+    const entry = this.intents.get(id);
+    if (!entry) return false;
+    entry.status = "withdrawn";
+    return true;
+  }
+  /**
+   * Get all active intents (not expired, not withdrawn, not fulfilled).
+   */
+  getActive() {
+    const now = Date.now();
+    const active = [];
+    for (const [, entry] of this.intents) {
+      if (entry.status !== "active") continue;
+      const created = new Date(entry.intent.created).getTime();
+      if (now - created > entry.intent.ttl * 1e3) {
+        entry.status = "expired";
+        continue;
+      }
+      active.push(entry.intent);
+    }
+    return active;
+  }
+  /**
+   * Find intents that match a given query.
+   * This is the local equivalent of a relay query.
+   */
+  query(params) {
+    return this.getActive().filter((intent) => {
+      if (params.type && intent.type !== params.type) return false;
+      if (params.domain && intent.domain !== params.domain) return false;
+      if (params.keywords && params.keywords.length > 0) {
+        const intentText = JSON.stringify(intent.intent).toLowerCase();
+        const hasKeyword = params.keywords.some(
+          (kw) => intentText.includes(kw.toLowerCase())
+        );
+        if (!hasKeyword) return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Remove expired intents from the store.
+   */
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [id, entry] of this.intents) {
+      if (entry.status === "expired" || entry.status === "withdrawn" || entry.status === "fulfilled") {
+        this.intents.delete(id);
+        removed++;
+      }
+      if (entry.status === "active") {
+        const created = new Date(entry.intent.created).getTime();
+        if (now - created > entry.intent.ttl * 1e3) {
+          entry.status = "expired";
+          this.intents.delete(id);
+          removed++;
+        }
+      }
+    }
+    return removed;
+  }
+};
+
+// src/matching/scorer.ts
+import { v4 as uuidv42 } from "uuid";
+var SCORE_WEIGHTS = {
+  intentAlignment: 0.3,
+  domainFit: 0.25,
+  authenticityCompatibility: 0.2,
+  preferenceMatch: 0.15,
+  timingFit: 0.1
+};
+var DEFAULT_THRESHOLDS = {
+  autoPropose: 80,
+  suggest: 60
+};
+var MatchScorer = class {
+  thresholds;
+  constructor(thresholds) {
+    this.thresholds = {
+      autoPropose: thresholds?.autoPropose ?? DEFAULT_THRESHOLDS.autoPropose,
+      suggest: thresholds?.suggest ?? DEFAULT_THRESHOLDS.suggest
+    };
+  }
+  /**
+   * Score the compatibility between two agents based on their intents and cards.
+   */
+  score(params) {
+    const { initiator, responder } = params;
+    const breakdown = {
+      intentAlignment: this.scoreIntentAlignment(initiator.intent, responder.intent),
+      domainFit: this.scoreDomainFit(initiator.intent, responder.intent),
+      authenticityCompatibility: this.scoreAuthenticityCompatibility(
+        initiator.card.authenticity,
+        responder.card.authenticity,
+        initiator.intent,
+        responder.intent
+      ),
+      preferenceMatch: this.scorePreferenceMatch(initiator.card, responder.card),
+      timingFit: this.scoreTimingFit(initiator.intent, responder.intent)
+    };
+    const overall = Math.round(
+      breakdown.intentAlignment * SCORE_WEIGHTS.intentAlignment + breakdown.domainFit * SCORE_WEIGHTS.domainFit + breakdown.authenticityCompatibility * SCORE_WEIGHTS.authenticityCompatibility + breakdown.preferenceMatch * SCORE_WEIGHTS.preferenceMatch + breakdown.timingFit * SCORE_WEIGHTS.timingFit
+    ) * 100;
+    return {
+      matchId: `match:${uuidv42()}`,
+      agents: {
+        initiator: initiator.card.agent.did,
+        responder: responder.card.agent.did
+      },
+      score: {
+        overall: Math.min(100, Math.max(0, overall)),
+        breakdown
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Determine what action to take based on a match score.
+   */
+  determineAction(score) {
+    if (score >= this.thresholds.autoPropose) return "auto-propose";
+    if (score >= this.thresholds.suggest) return "suggest";
+    return "ignore";
+  }
+  // ─── Dimension Scorers ──────────────────────────────────────────
+  /**
+   * Score how well the two intents complement each other.
+   * A seeking-offering match scores highest.
+   */
+  scoreIntentAlignment(a, b) {
+    const aSeeking = flattenValues(a.intent.seeking);
+    const bSeeking = flattenValues(b.intent.seeking);
+    const aContext = flattenValues(a.intent.context);
+    const bContext = flattenValues(b.intent.context);
+    const aToB = computeOverlap(aSeeking, [...bSeeking, ...bContext]);
+    const bToA = computeOverlap(bSeeking, [...aSeeking, ...aContext]);
+    return (aToB + bToA) / 2;
+  }
+  /**
+   * Score the domain overlap between two intents.
+   */
+  scoreDomainFit(a, b) {
+    if (a.domain === b.domain) return 0.9;
+    const related = RELATED_DOMAINS.get(a.domain);
+    if (related?.includes(b.domain)) return 0.5;
+    return 0.1;
+  }
+  /**
+   * Score whether both agents meet each other's authenticity requirements.
+   */
+  scoreAuthenticityCompatibility(aAuth, bAuth, aIntent, bIntent) {
+    const aMinScore = aIntent.filters.minAuthenticityScore;
+    const bMinScore = bIntent.filters.minAuthenticityScore;
+    const aMeetsBMin = bAuth.score >= aMinScore;
+    const bMeetsAMin = aAuth.score >= bMinScore;
+    if (aMeetsBMin && bMeetsAMin) {
+      const aExcess = (bAuth.score - aMinScore) / (100 - aMinScore);
+      const bExcess = (aAuth.score - bMinScore) / (100 - bMinScore);
+      return 0.6 + (aExcess + bExcess) / 2 * 0.4;
+    }
+    if (aMeetsBMin || bMeetsAMin) {
+      return 0.3;
+    }
+    return 0;
+  }
+  /**
+   * Score preference compatibility (communication style, timing, language).
+   */
+  scorePreferenceMatch(a, b) {
+    let score = 0;
+    let factors = 0;
+    const langOverlap = a.preferences.languages.filter(
+      (l) => b.preferences.languages.includes(l)
+    );
+    if (langOverlap.length > 0) {
+      score += 1;
+    }
+    factors++;
+    if (a.preferences.introductionStyle === b.preferences.introductionStyle) {
+      score += 1;
+    } else {
+      score += 0.5;
+    }
+    factors++;
+    return factors > 0 ? score / factors : 0.5;
+  }
+  /**
+   * Score timing compatibility — are both intents active and aligned in urgency?
+   */
+  scoreTimingFit(a, b) {
+    const now = Date.now();
+    const aExpiry = new Date(a.created).getTime() + a.ttl * 1e3;
+    const bExpiry = new Date(b.created).getTime() + b.ttl * 1e3;
+    if (now > aExpiry || now > bExpiry) return 0;
+    const aUrgency = extractUrgency(a.intent.context);
+    const bUrgency = extractUrgency(b.intent.context);
+    if (aUrgency === bUrgency) return 1;
+    if (Math.abs(aUrgency - bUrgency) <= 1) return 0.7;
+    return 0.3;
+  }
+};
+function flattenValues(obj) {
+  const values = [];
+  for (const value of Object.values(obj)) {
+    if (typeof value === "string") {
+      values.push(value.toLowerCase());
+    } else if (Array.isArray(value)) {
+      values.push(...value.filter((v) => typeof v === "string").map((v) => v.toLowerCase()));
+    }
+  }
+  return values;
+}
+function computeOverlap(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  let matches = 0;
+  for (const term of a) {
+    for (const bTerm of b) {
+      if (term === bTerm || bTerm.includes(term) || term.includes(bTerm)) {
+        matches++;
+        break;
+      }
+    }
+  }
+  return matches / Math.max(a.length, 1);
+}
+function extractUrgency(context) {
+  const urgency = context["urgency"];
+  if (typeof urgency !== "string") return 1;
+  switch (urgency.toLowerCase()) {
+    case "immediate":
+    case "asap":
+      return 3;
+    case "active":
+    case "urgent":
+      return 2;
+    case "moderate":
+    case "normal":
+      return 1;
+    case "passive":
+    case "low":
+    case "whenever":
+      return 0;
+    default:
+      return 1;
+  }
+}
+var RELATED_DOMAINS = /* @__PURE__ */ new Map([
+  ["professional", ["commerce", "learning"]],
+  ["dating", []],
+  ["local-services", ["commerce"]],
+  ["learning", ["professional"]],
+  ["commerce", ["professional", "local-services"]]
+]);
+export {
+  AuthenticityEngine,
+  IntentBuilder,
+  IntentStore,
+  MatchScorer,
+  TacitAgent,
+  createIdentity,
+  publicKeyToDid,
+  resolveDid,
+  sign,
+  verify
+};