@highway1/core 0.1.63 → 0.1.76

package/dist/index.d.ts

@@ -59,23 +59,120 @@ declare function signMessage(payload: Uint8Array, privateKey: Uint8Array, public
  */
 declare function verifyMessage(signedMessage: SignedMessage, expectedPublicKey: Uint8Array): Promise<boolean>;
 
+/**
+ * Agent Aliases - CVP-0014 Part 1
+ *
+ * Local petname-to-DID mapping for easier agent addressing.
+ * Aliases are stored in ~/.clawiverse/config.json under the "aliases" key.
+ *
+ * Note: This module provides the core logic. The actual config storage
+ * is handled by the CLI layer (packages/cli/src/config.ts).
+ */
+interface AliasMap {
+    [alias: string]: string;
+}
+/**
+ * Validate alias name according to CVP-0014 rules:
+ * - Lowercase alphanumeric + hyphens: [a-z0-9][a-z0-9-]*
+ * - Max 32 characters
+ * - Cannot start with "did:" (reserved for DID prefix detection)
+ */
+declare function validateAliasName(alias: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Resolve a DID from various input formats:
+ * 1. If input starts with "did:" → return as-is
+ * 2. If input matches a local alias → return the mapped DID (caller must provide aliases)
+ * 3. Otherwise → return undefined (caller can attempt discovery)
+ */
+declare function resolveDid(input: string, aliases: AliasMap): string | undefined;
+/**
+ * Reverse lookup: find alias for a DID
+ * Returns the first matching alias, or undefined if no alias exists
+ */
+declare function reverseAlias(did: string, aliases: AliasMap): string | undefined;
+/**
+ * Format DID for display with optional alias
+ * Returns: "alias" if alias exists, otherwise full DID
+ */
+declare function formatDidWithAlias(did: string, aliases: AliasMap): string;
+/**
+ * Format DID for detailed display with alias
+ * Returns: "alias (did:...)" if alias exists, otherwise full DID
+ */
+declare function formatDidWithAliasDetailed(did: string, aliases: AliasMap, truncate?: boolean): string;
+
+interface DIDDocument {
+    '@context': string[];
+    id: string;
+    verificationMethod: VerificationMethod[];
+    authentication: string[];
+    assertionMethod: string[];
+    keyAgreement?: string[];
+    service?: ServiceEndpoint[];
+}
+interface VerificationMethod {
+    id: string;
+    type: string;
+    controller: string;
+    publicKeyMultibase: string;
+}
+interface ServiceEndpoint {
+    id: string;
+    type: string;
+    serviceEndpoint: string;
+}
+/**
+ * Create a DID Document for a did:clawiverse identity
+ */
+declare function createDIDDocument(publicKey: Uint8Array, services?: ServiceEndpoint[]): DIDDocument;
+/**
+ * Validate a DID Document structure
+ */
+declare function validateDIDDocument(doc: unknown): doc is DIDDocument;
+
+interface AnonymousIdentity {
+    did: string;
+    publicKey: string;
+    privateKey: string;
+    agentCard: {
+        name: string;
+        description: string;
+        capabilities: string[];
+    };
+}
+/**
+ * Generate an anonymous identity for frictionless onboarding
+ * Creates identity with pattern "Agent-{last8chars_of_DID}" and generic description
+ */
+declare function generateAnonymousIdentity(): Promise<AnonymousIdentity>;
+
 /**
  * Trust Score System
  *
  * Tracks agent reputation based on interactions, endorsements,
  * and network behavior.
  */
+/**
+ * Trust status for an agent
+ */
+type TrustStatus = 'unknown' | 'known' | 'suspicious' | 'blocked' | 'allowed';
 /**
  * Trust Score Metrics
  */
 interface TrustScore {
     interactionScore: number;
     endorsements: number;
+    endorsementScore: number;
     completionRate: number;
     responseTime: number;
     uptime: number;
     lastUpdated: number;
     totalInteractions: number;
+    recentSuccessRate: number;
+    status: TrustStatus;
 }
 /**
  * Interaction Record
@@ -95,6 +192,7 @@ interface Interaction {
 interface InteractionStats {
     totalInteractions: number;
     successRate: number;
+    recentSuccessRate: number;
     avgResponseTime: number;
     lastInteraction: number;
 }
@@ -103,11 +201,15 @@ interface InteractionStats {
  */
 declare class TrustMetrics {
     /**
-     * Calculate trust score from interaction history
+     * Calculate trust score from interaction history.
+     * @param endorsementScore - Average endorsement score (0-1), not count
      */
-    calculateScore(stats: InteractionStats, endorsements: number, uptime: number): TrustScore;
+    calculateScore(stats: InteractionStats, endorsementScore: number, uptime: number): TrustScore;
+    private deriveStatus;
     /**
      * Calculate overall trust level (0-1)
+     * @param score - TrustScore
+     * @param endorsementScore - Average endorsement score (0-1)
      */
     calculateOverallTrust(score: TrustScore): number;
     /**
@@ -202,7 +304,7 @@ declare function downgradeToLegacyCard(card: AgentCard): LegacyAgentCard;
  */
 
 declare const RELAY_PROTOCOL_VERSION = 1;
-type RelayMessageType = 'HELLO' | 'WELCOME' | 'SEND' | 'DELIVER' | 'DISCOVER' | 'DISCOVERED' | 'PING' | 'PONG' | 'ACK' | 'DELIVERY_REPORT' | 'FETCH_CARD' | 'CARD' | 'GOODBYE' | 'INDEX_SYNC' | 'ROUTE' | 'SYNC_HELLO' | 'SYNC_REQUEST' | 'SYNC_RESPONSE' | 'SYNC_PUSH' | 'SYNC_RECONCILE';
+type RelayMessageType = 'HELLO' | 'WELCOME' | 'SEND' | 'DELIVER' | 'DISCOVER' | 'DISCOVERED' | 'PING' | 'PONG' | 'ACK' | 'DELIVERY_REPORT' | 'FETCH_CARD' | 'CARD' | 'GOODBYE' | 'INDEX_SYNC' | 'ROUTE' | 'SYNC_HELLO' | 'SYNC_REQUEST' | 'SYNC_RESPONSE' | 'SYNC_PUSH' | 'SYNC_RECONCILE' | 'ENDORSE' | 'ENDORSE_ACK' | 'TRUST_QUERY' | 'TRUST_RESULT' | 'PUBLISH_CARD' | 'UNPUBLISH_CARD';
 interface HelloMessage {
     type: 'HELLO';
     protocolVersion: number;
@@ -325,7 +427,40 @@ interface SyncReconcileMessage {
     type: 'SYNC_RECONCILE';
     dids: string[];
 }
-type RelayMessage = HelloMessage | WelcomeMessage | SendMessage | DeliverMessage | DiscoverMessage | DiscoveredMessage | AckMessage | DeliveryReportMessage | PingMessage | PongMessage | FetchCardMessage | CardMessage | GoodbyeMessage | IndexSyncMessage | RouteMessage | SyncHelloMessage | SyncRequestMessage | SyncResponseMessage | SyncPushMessage | SyncReconcileMessage;
+interface TrustQueryMessage {
+    type: 'TRUST_QUERY';
+    target: string;
+    domain?: string;
+    since?: number;
+    cursor?: string;
+}
+interface TrustResultEndorsement {
+    version: 2;
+    from: string;
+    to: string;
+    score: number;
+    domain?: string;
+    reason: string;
+    timestamp: number;
+    expires?: number;
+    signature: string;
+}
+interface TrustResultMessage {
+    type: 'TRUST_RESULT';
+    target: string;
+    endorsements: TrustResultEndorsement[];
+    endorsementCount: number;
+    averageScore: number;
+    nextCursor?: string;
+}
+interface PublishCardMessage {
+    type: 'PUBLISH_CARD';
+    card?: AgentCard;
+}
+interface UnpublishCardMessage {
+    type: 'UNPUBLISH_CARD';
+}
+type RelayMessage = HelloMessage | WelcomeMessage | SendMessage | DeliverMessage | DiscoverMessage | DiscoveredMessage | AckMessage | DeliveryReportMessage | PingMessage | PongMessage | FetchCardMessage | CardMessage | GoodbyeMessage | IndexSyncMessage | RouteMessage | SyncHelloMessage | SyncRequestMessage | SyncResponseMessage | SyncPushMessage | SyncReconcileMessage | TrustQueryMessage | TrustResultMessage | PublishCardMessage | UnpublishCardMessage;
 
 /**
  * CVP-0011: WebSocket relay client with reconnection logic
@@ -351,6 +486,9 @@ interface RelayClient {
     sendEnvelope(toDid: string, envelopeBytes: Uint8Array): Promise<void>;
     discover(query: string, minTrust?: number, limit?: number): Promise<DiscoveredAgent[]>;
     fetchCard(did: string): Promise<AgentCard | null>;
+    queryTrust(target: string, domain?: string, since?: number, cursor?: string): Promise<TrustResultMessage>;
+    publishCard(card?: AgentCard): Promise<void>;
+    unpublishCard(): Promise<void>;
     onDeliver(handler: MessageDeliveryHandler): void;
     onDeliveryReport(handler: DeliveryReportHandler): void;
     isConnected(): boolean;
@@ -467,12 +605,15 @@ declare function isValidContext(context: unknown): boolean;
  * Agent Card Encoder - Dual Encoding Support
  *
  * Provides bidirectional conversion between:
- * - CBOR (compact binary) for DHT storage
+ * - CBOR (compact binary) for relay/discovery storage compatibility
  * - JSON-LD (semantic) for Web publishing
  */
 
 /**
- * Encode Agent Card as CBOR for DHT storage
+ * Encode Agent Card as compact CBOR.
+ *
+ * The helper keeps its historical name because older APIs referenced
+ * "DHT encoding", but the current architecture uses relay-backed discovery.
  */
 declare function encodeForDHT(card: AgentCard): Uint8Array;
 /**
@@ -500,14 +641,10 @@ declare function getEncodedSize(card: AgentCard): {
 };
 
 /**
- * Search Index for Agent Discovery
- *
- * Maintains a local index of discovered agents for fast semantic search
+ * CVP-0011: Relay-backed discovery operations
+ * Keeps a legacy discovery-operations shape, but is fully backed by relay queries.
  */
 
-/**
- * Semantic Query Interface
- */
 interface SemanticQuery {
     text?: string;
     capability?: string;
@@ -519,68 +656,6 @@ interface SemanticQuery {
     };
     limit?: number;
 }
-/**
- * Search Result with Score
- */
-interface SearchResult {
-    card: AgentCard;
-    score: number;
-}
-/**
- * Search Index Implementation
- */
-declare class SearchIndex {
-    private cards;
-    private lunrIndex?;
-    private fuse?;
-    private needsRebuild;
-    /**
-     * Add or update an Agent Card in the index
-     */
-    indexAgentCard(card: AgentCard): void;
-    /**
-     * Remove an Agent Card from the index
-     */
-    removeAgentCard(did: string): void;
-    /**
-     * Search for agents matching a query
-     */
-    search(query: SemanticQuery): SearchResult[];
-    /**
-     * Get all indexed cards
-     */
-    getAllCards(): AgentCard[];
-    /**
-     * Clear the index
-     */
-    clear(): void;
-    /**
-     * Get index size
-     */
-    size(): number;
-    /**
-     * Rebuild search indexes
-     */
-    private rebuild;
-    /**
-     * Search by text using Lunr
-     */
-    private searchByText;
-    /**
-     * Search by capability using Fuse
-     */
-    private searchByCapability;
-    /**
-     * Apply filters to search results
-     */
-    private applyFilters;
-}
-
-/**
- * CVP-0011: Relay-backed discovery operations
- * Implements the same DHTOperations interface shape but backed by relay queries
- */
-
 interface RelayIndexOperations {
     publishAgentCard: (card: AgentCard) => Promise<void>;
     queryAgentCard: (did: string) => Promise<AgentCard | null>;
@@ -596,161 +671,32 @@ interface RelayIndexOperations {
  */
 declare function createRelayIndexOperations(client: RelayClient): RelayIndexOperations;
 
-/**
- * Capability Matcher
- *
- * Matches semantic queries against agent capabilities
- */
-
-/**
- * Capability Matcher
- */
-declare class CapabilityMatcher {
-    /**
-     * Match a query against a capability
-     * Returns a score between 0 and 1
-     */
-    match(query: SemanticQuery, capability: Capability): number;
-    /**
-     * Extract keywords from natural language text
-     */
-    extractKeywords(text: string): string[];
-    /**
-     * Match keywords against capability
-     */
-    matchKeywords(keywords: string[], capability: Capability): number;
-    /**
-     * Check if query matches capability type hierarchy
-     */
-    matchesType(query: string, type: string): boolean;
-    /**
-     * Fuzzy string matching using Levenshtein distance
-     */
-    private fuzzyMatch;
-    /**
-     * Calculate Levenshtein distance between two strings
-     */
-    private levenshteinDistance;
-}
-
-interface ResolvedDID {
-    peerId: string;
-    multiaddrs: string[];
-}
-interface DHTOperations {
-    publishAgentCard: (card: AgentCard) => Promise<void>;
-    queryAgentCard: (did: string) => Promise<AgentCard | null>;
-    queryByCapability: (capability: string) => Promise<AgentCard[]>;
-    searchSemantic: (query: SemanticQuery) => Promise<AgentCard[]>;
-    resolveDID: (did: string) => Promise<ResolvedDID | null>;
-    queryRelayPeers: () => Promise<string[]>;
-}
-
-/**
- * Semantic Search Engine
- *
- * Provides intelligent agent discovery through semantic search
- * with local-first strategy and network fallback
- */
-
-/**
- * Semantic Search Engine
- */
-declare class SemanticSearchEngine {
-    private dht?;
-    private index;
-    private matcher;
-    constructor(dht?: DHTOperations | undefined);
-    /**
-     * Main search interface
-     * Local-first with network fallback
-     */
-    search(query: SemanticQuery): Promise<AgentCard[]>;
-    /**
-     * Index an Agent Card for local search
-     */
-    indexAgentCard(card: AgentCard): void;
-    /**
-     * Remove an Agent Card from local index
-     */
-    removeAgentCard(did: string): void;
-    /**
-     * Get all indexed cards
-     */
-    getAllIndexedCards(): AgentCard[];
-    /**
-     * Clear local index
-     */
-    clearIndex(): void;
-    /**
-     * Get index size
-     */
-    getIndexSize(): number;
-    /**
-     * Search network via DHT
-     */
-    private searchNetwork;
-    /**
-     * Merge local and network results, removing duplicates
-     */
-    private mergeResults;
-    /**
-     * Score a card against a query
-     */
-    private scoreCard;
-    /**
-     * Extract primary capability from natural language text
-     */
-    private extractPrimaryCapability;
-}
-/**
- * Create a semantic search engine
- */
-declare function createSemanticSearch(dht?: DHTOperations): SemanticSearchEngine;
-
+type LegacyMessageEnvelopeType = 'request' | 'response' | 'notification';
+type MessageEnvelopeType = 'message' | 'reply';
+type AnyMessageEnvelopeType = MessageEnvelopeType | LegacyMessageEnvelopeType;
 interface MessageEnvelope {
     id: string;
     from: string;
     to: string;
-    type: 'request' | 'response' | 'notification';
+    type: MessageEnvelopeType;
     protocol: string;
     payload: unknown;
     timestamp: number;
     signature: string;
     replyTo?: string;
+    threadId?: string;
 }
-/**
- * Create a message envelope
- */
-declare function createEnvelope(from: string, to: string, type: 'request' | 'response' | 'notification', protocol: string, payload: unknown, replyTo?: string): Omit<MessageEnvelope, 'signature'>;
-/**
- * Sign a message envelope
- */
+declare function normalizeEnvelopeType(type: string): MessageEnvelopeType | undefined;
+declare function normalizeEnvelope(msg: unknown): MessageEnvelope | undefined;
+declare function createEnvelope(from: string, to: string, type: AnyMessageEnvelopeType, protocol: string, payload: unknown, replyTo?: string, threadId?: string): Omit<MessageEnvelope, 'signature'>;
 declare function signEnvelope(envelope: Omit<MessageEnvelope, 'signature'>, signFn: (data: Uint8Array) => Promise<Uint8Array>): Promise<MessageEnvelope>;
-/**
- * Verify a message envelope signature
- */
 declare function verifyEnvelope(envelope: MessageEnvelope, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>): Promise<boolean>;
-/**
- * Validate message envelope structure
- */
 declare function validateEnvelope(msg: unknown): msg is MessageEnvelope;
+declare function generateThreadId(): string;
 
-/**
- * Encode a message envelope to CBOR
- */
 declare function encodeMessage(envelope: MessageEnvelope): Uint8Array;
-/**
- * Decode a CBOR message to envelope
- */
 declare function decodeMessage(data: Uint8Array): MessageEnvelope;
-/**
- * Encode message to JSON (for debugging/logging)
- */
 declare function encodeMessageJSON(envelope: MessageEnvelope): string;
-/**
- * Decode JSON message to envelope
- */
 declare function decodeMessageJSON(json: string): MessageEnvelope;
 
 type MessageHandler = (envelope: MessageEnvelope) => Promise<MessageEnvelope | void>;
@@ -758,13 +704,10 @@ interface MessageRouter {
     registerHandler: (protocol: string, handler: MessageHandler) => void;
     unregisterHandler: (protocol: string) => void;
     registerCatchAllHandler: (handler: MessageHandler) => void;
-    sendMessage: (envelope: MessageEnvelope) => Promise<MessageEnvelope | void>;
+    sendMessage: (envelope: MessageEnvelope) => Promise<void>;
     start: () => Promise<void>;
     stop: () => Promise<void>;
 }
-/**
- * Create a message router using relay client (CVP-0011)
- */
 declare function createMessageRouter(relayClient: RelayClient, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>): MessageRouter;
 
 /**
@@ -792,6 +735,7 @@ interface StoredMessage {
     sentAt?: number;
     readAt?: number;
     trustScore?: number;
+    trustStatus?: TrustStatus;
     error?: string;
 }
 /**
@@ -803,9 +747,24 @@ interface MessageFilter {
     protocol?: string | string[];
     minTrustScore?: number;
     maxAge?: number;
-    type?: 'request' | 'response' | 'notification';
+    type?: MessageEnvelopeType;
+    replyTo?: string | string[];
     unreadOnly?: boolean;
     status?: MessageStatus | MessageStatus[];
+    threadId?: string;
+}
+/**
+ * Session metadata for conversation threads (CVP-0014)
+ */
+interface SessionMeta {
+    threadId: string;
+    peerDid: string;
+    startedAt: number;
+    lastMessageAt: number;
+    messageCount: number;
+    title?: string;
+    archived?: boolean;
+    archivedAt?: number;
 }
 /**
  * Pagination options
@@ -866,6 +825,7 @@ interface DefenseResult {
     allowed: boolean;
     reason?: 'blocked' | 'duplicate' | 'trust_too_low' | 'rate_limited' | 'invalid';
     trustScore?: number;
+    trustStatus?: TrustStatus;
     remainingTokens?: number;
     resetTime?: number;
 }
@@ -927,6 +887,8 @@ declare class MessageStorage {
     queryMessages(direction: 'inbound' | 'outbound', filter?: MessageFilter, pagination?: PaginationOptions): Promise<MessagePage>;
     private matchesFilter;
     countMessages(direction: 'inbound' | 'outbound', filter?: MessageFilter): Promise<number>;
+    private normalizeStoredMessage;
+    private requireStoredMessage;
     putBlock(entry: BlocklistEntry): Promise<void>;
     getBlock(did: string): Promise<BlocklistEntry | null>;
     deleteBlock(did: string): Promise<void>;
@@ -941,15 +903,52 @@ declare class MessageStorage {
     putRateLimit(state: RateLimitState): Promise<void>;
     getRateLimit(did: string): Promise<RateLimitState | null>;
     cleanupRateLimits(maxAgeMs: number): Promise<void>;
+    private updateSessionMeta;
+    getSession(threadId: string): Promise<{
+        peerDid: string;
+        threadId: string;
+        messageCount: number;
+        lastMessageAt: number;
+        startedAt?: number;
+        title?: string;
+        archived?: boolean;
+        archivedAt?: number;
+    } | null>;
+    listSessions(peerDid?: string, limit?: number, includeArchived?: boolean): Promise<Array<{
+        peerDid: string;
+        threadId: string;
+        messageCount: number;
+        lastMessageAt: number;
+        startedAt?: number;
+        title?: string;
+        archived?: boolean;
+        archivedAt?: number;
+    }>>;
+    archiveSession(threadId: string): Promise<void>;
+    unarchiveSession(threadId: string): Promise<void>;
+    listArchivedSessions(peerDid?: string, limit?: number): Promise<Array<{
+        peerDid: string;
+        threadId: string;
+        messageCount: number;
+        lastMessageAt: number;
+        startedAt?: number;
+        title?: string;
+        archived?: boolean;
+        archivedAt?: number;
+    }>>;
+    searchSessions(query: string, limit?: number): Promise<Array<{
+        peerDid: string;
+        threadId: string;
+        messageCount: number;
+        lastMessageAt: number;
+        startedAt?: number;
+        title?: string;
+        archived?: boolean;
+        archivedAt?: number;
+    }>>;
+    queryMessagesByThread(threadId: string, pagination?: PaginationOptions): Promise<MessagePage>;
 }
 
-/**
- * Message Queue
- *
- * Persistent inbox/outbox backed by LevelDB.
- * Supports real-time subscriptions and pagination.
- */
-
 interface MessageQueueConfig {
     dbPath: string;
 }
@@ -967,7 +966,7 @@ declare class MessageQueue {
     deleteMessage(id: string): Promise<void>;
     getOutbox(pagination?: PaginationOptions): Promise<MessagePage>;
     retryMessage(id: string): Promise<void>;
-    enqueueInbound(envelope: MessageEnvelope, trustScore?: number): Promise<StoredMessage>;
+    enqueueInbound(envelope: MessageEnvelope, trustScore?: number, trustStatus?: StoredMessage['trustStatus']): Promise<StoredMessage>;
     enqueueOutbound(envelope: MessageEnvelope): Promise<StoredMessage>;
     markOutboundDelivered(id: string): Promise<void>;
     markOutboundFailed(id: string, error: string): Promise<void>;
@@ -984,7 +983,7 @@ declare class MessageQueue {
  * Protects the network from Sybil attacks through:
  * - Entry cost (Hashcash challenges)
  * - Progressive trust (rate limiting for new agents)
- * - DHT region protection (prefer established peers)
+ * - Discovery hardening (prefer established peers)
  */
 /**
  * Hashcash Challenge
@@ -1107,7 +1106,7 @@ declare class InteractionHistory {
  */
 
 /**
- * Endorsement Record
+ * Endorsement Record v1 (legacy)
  */
 interface Endorsement {
     from: string;
@@ -1117,6 +1116,33 @@ interface Endorsement {
     timestamp: number;
     signature: string;
 }
+/**
+ * Endorsement Record v2 (CVP-0017)
+ */
+interface EndorsementV2 {
+    version: 2;
+    from: string;
+    to: string;
+    score: number;
+    domain?: string;
+    reason: string;
+    timestamp: number;
+    expires?: number;
+    signature: string;
+}
+/**
+ * Domain velocity categories for time decay
+ */
+declare const FAST_DOMAINS: string[];
+declare const SLOW_DOMAINS: string[];
+/**
+ * Default expiration by domain (in days)
+ */
+declare function getDefaultExpiration(domain?: string): number;
+/**
+ * Validate domain string
+ */
+declare function validateDomain(domain: string): boolean;
 /**
  * Sign function type
  */
@@ -1133,13 +1159,25 @@ declare class EndorsementManager {
     private getPublicKey;
     constructor(db: Level<string, Endorsement>, getPublicKey: (did: string) => Promise<Uint8Array>);
     /**
-     * Create an endorsement
+     * Create an endorsement (v2)
+     */
+    endorseV2(fromDid: string, toDid: string, score: number, reason: string, signFn: SignFunction, domain?: string, expires?: number): Promise<EndorsementV2>;
+    /**
+     * Create an endorsement (v1 - legacy)
      */
     endorse(fromDid: string, toDid: string, score: number, reason: string, signFn: SignFunction): Promise<Endorsement>;
     /**
-     * Verify endorsement signature
+     * Verify endorsement signature (v2)
+     */
+    verifyV2(endorsement: EndorsementV2, verifyFn: VerifyFunction): Promise<boolean>;
+    /**
+     * Verify endorsement signature (v1)
      */
     verify(endorsement: Endorsement, verifyFn: VerifyFunction): Promise<boolean>;
+    /**
+     * Upgrade v1 endorsement to v2
+     */
+    upgradeEndorsement(e: Endorsement): EndorsementV2;
     /**
      * Publish endorsement to local database
      */
@@ -1160,6 +1198,143 @@ declare class EndorsementManager {
      * Delete an endorsement
      */
     deleteEndorsement(fromDid: string, toDid: string): Promise<void>;
+    /**
+     * Publish endorsement to relay (CVP-0017)
+     */
+    publishToRelay(relay: {
+        publishEndorsement: (e: EndorsementV2) => Promise<{
+            id: string;
+            stored: boolean;
+            error?: string;
+        }>;
+    }, endorsement: EndorsementV2): Promise<{
+        id: string;
+        stored: boolean;
+        error?: string;
+    }>;
+    /**
+     * Query endorsements from relay (CVP-0017)
+     */
+    queryFromRelay(relay: {
+        queryTrust: (target: string, domain?: string, since?: number) => Promise<{
+            endorsements: EndorsementV2[];
+            endorsementCount?: number;
+            averageScore?: number;
+        }>;
+    }, target: string, domain?: string, since?: number): Promise<{
+        endorsements: EndorsementV2[];
+        total: number;
+        averageScore: number;
+    }>;
+}
+
+/**
+ * CVP-0017: Trust Computation Engine
+ *
+ * Implements EigenTrust-lite algorithm with:
+ * - Recursive endorser weighting (endorsements from trusted agents count more)
+ * - Domain-aware time decay (fast/slow/default domains)
+ * - Collusion detection (Tarjan's SCC algorithm)
+ * - Configurable recursion depth (default 3, max 6)
+ * - Seed peer bootstrapping
+ */
+
+/**
+ * Trust computation configuration
+ */
+interface TrustConfig {
+    seedPeers?: string[];
+    maxRecursionDepth?: number;
+    decayHalfLife?: {
+        default?: number;
+        [domain: string]: number | undefined;
+    };
+    localInteractionWeight?: number;
+    networkEndorsementWeight?: number;
+}
+/**
+ * Trust computation result
+ */
+interface TrustResult {
+    score: number;
+    localScore: number;
+    networkScore: number;
+    endorsementCount: number;
+    collusionDetected: boolean;
+    computedAt: number;
+}
+/**
+ * Trust Computer
+ */
+declare class TrustComputer {
+    private config;
+    private cache;
+    private readonly CACHE_TTL;
+    private sccPenaltyCache;
+    private sccCacheExpiresAt;
+    private readonly SCC_CACHE_TTL;
+    private endorsementsByTarget;
+    constructor(config?: TrustConfig);
+    /**
+     * Compute trust score for a target DID.
+     * allEndorsements: flat list of all endorsements known to the caller (used for recursive weight lookup).
+     */
+    compute(target: string, endorsements: EndorsementV2[], localInteractionScore?: number, localInteractionCount?: number, domain?: string, allEndorsements?: EndorsementV2[]): TrustResult;
+    /**
+     * Compute network trust score using EigenTrust-lite
+     */
+    private computeNetworkTrust;
+    /**
+     * Get endorser weight (recursive EigenTrust-lite).
+     * Uses endorsementsByTarget populated by compute() for local graph traversal.
+     */
+    private getEndorserWeight;
+    /**
+     * Compute time decay for an endorsement
+     */
+    private computeTimeDecay;
+    /**
+     * Get decay half-life for a domain
+     */
+    private getDecayHalfLife;
+    /**
+     * Detect collusion using Tarjan's SCC algorithm
+     */
+    private detectCollusion;
+    /**
+     * Build endorsement graph
+     */
+    private buildGraph;
+    /**
+     * Find strongly connected components using Tarjan's algorithm
+     */
+    private findSCCs;
+    /**
+     * Rebuild the SCC penalty cache from a full endorsement graph.
+     * Called lazily when the cache is stale.
+     */
+    private rebuildSccPenaltyCache;
+    /**
+     * Get collusion penalty for an endorser.
+     * Returns 0.1 if the endorser is in a detected collusion cluster, 1.0 otherwise.
+     */
+    private getCollusionPenalty;
+    /**
+     * Filter endorsements by domain
+     */
+    private filterByDomain;
+    /**
+     * Get cache key
+     */
+    private getCacheKey;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<TrustConfig>): void;
 }
 
 /**
@@ -1179,6 +1354,7 @@ declare class TrustSystem {
     private sybilDefense;
     private trustCache;
     private readonly CACHE_TTL;
+    private uptimeTracker;
     constructor(config: TrustSystemConfig);
     /**
      * Initialize the trust system
@@ -1192,6 +1368,19 @@ declare class TrustSystem {
      * Record an interaction
      */
     recordInteraction(interaction: Interaction): Promise<void>;
+    /**
+     * Record agent coming online (for uptime tracking)
+     */
+    recordOnline(agentDid: string): void;
+    /**
+     * Record agent going offline (for uptime tracking)
+     */
+    recordOffline(agentDid: string): void;
+    /**
+     * Get uptime ratio for an agent (0.0 - 1.0)
+     * Based on time since first seen vs total online time.
+     */
+    getUptime(agentDid: string): number;
     /**
      * Get trust score for an agent
      */
@@ -1219,7 +1408,7 @@ declare class TrustSystem {
     /**
      * Verify Sybil defense challenge
      */
-    verifyChallenge(solution: any): boolean;
+    verifyChallenge(solution: ChallengeSolution): boolean;
     /**
      * Get peer trust level
      */
@@ -1371,4 +1560,4 @@ declare class MessagingError extends ClawiverseError {
     constructor(message: string, details?: unknown);
 }
 
-export { type AckMessage, type AgentCard, type AllowlistEntry, type BlocklistEntry, CLAWIVERSE_CONTEXT, type Capability, CapabilityMatcher, type CapabilityParameter, CapabilityTypes, type CardMessage, type Challenge, type ChallengeSolution, ClawiverseError, DEFAULT_RATE_LIMIT_TIERS, type DefenseConfig, DefenseMiddleware, type DefenseResult, type DeliverMessage, type DeliveryReportHandler, type DeliveryReportMessage, type DiscoverMessage, type DiscoveredAgent, type DiscoveredMessage, DiscoveryError, type Endorsement, EndorsementManager, type FetchCardMessage, type GoodbyeMessage, type HelloMessage, IdentityError, type IndexSyncMessage, type Interaction, InteractionHistory, type InteractionStats, type KeyPair, type LegacyAgentCard, LogLevel, Logger, type MessageCallback, type MessageDeliveryHandler, type MessageDirection, type MessageEnvelope, type MessageFilter, type MessageHandler, type MessagePage, MessageQueue, type MessageQueueConfig, type MessageRouter, type MessageStatus, MessageStorage, MessagingError, type PaginationOptions, ParameterTypes, type PeerTrustLevel, type PingMessage, type PongMessage, type PresenceProof, type QueueStats, RELAY_PROTOCOL_VERSION, type RateLimitResult, type RateLimitState, type RateLimitTiers, type RelayClient, type RelayClientConfig, type RelayIndexOperations, type RelayMessage, type RelayMessageType, type RouteMessage, SCHEMA_ORG_CONTEXT, SearchIndex, type SearchResult, type SeenEntry, type SemanticQuery, SemanticSearchEngine, type SendMessage, type SignFunction, type SignedMessage, type StoredMessage, type SubscriptionFilter, SybilDefense, type SyncEvent, type SyncHelloMessage, type SyncPushMessage, type SyncReconcileMessage, type SyncRequestMessage, type SyncResponseMessage, TokenBucket, type TokenBucketConfig, TransportError, TrustMetrics, type TrustScore, TrustSystem, type TrustSystemConfig, type VerifyFunction, type WelcomeMessage, clawiverseContext, createAgentCard, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createRelayClient, createRelayIndexOperations, createSemanticSearch, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, generateKeyPair, getAgentCardContext, getEncodedSize, getTierConfig, importKeyPair, isLegacyCard, isValidContext, matchesCapability, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateDID, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };
+export { type AckMessage, type AgentCard, type AliasMap, type AllowlistEntry, type AnonymousIdentity, type AnyMessageEnvelopeType, type BlocklistEntry, CLAWIVERSE_CONTEXT, type Capability, type CapabilityParameter, CapabilityTypes, type CardMessage, type Challenge, type ChallengeSolution, ClawiverseError, DEFAULT_RATE_LIMIT_TIERS, type DIDDocument, type DefenseConfig, DefenseMiddleware, type DefenseResult, type DeliverMessage, type DeliveryReportHandler, type DeliveryReportMessage, type DiscoverMessage, type DiscoveredAgent, type DiscoveredMessage, DiscoveryError, type Endorsement, EndorsementManager, type EndorsementV2, FAST_DOMAINS, type FetchCardMessage, type GoodbyeMessage, type HelloMessage, IdentityError, type IndexSyncMessage, type Interaction, InteractionHistory, type InteractionStats, type KeyPair, type LegacyAgentCard, type LegacyMessageEnvelopeType, LogLevel, Logger, type MessageCallback, type MessageDeliveryHandler, type MessageDirection, type MessageEnvelope, type MessageEnvelopeType, type MessageFilter, type MessageHandler, type MessagePage, MessageQueue, type MessageQueueConfig, type MessageRouter, type MessageStatus, MessageStorage, MessagingError, type PaginationOptions, ParameterTypes, type PeerTrustLevel, type PingMessage, type PongMessage, type PresenceProof, type PublishCardMessage, type QueueStats, RELAY_PROTOCOL_VERSION, type RateLimitResult, type RateLimitState, type RateLimitTiers, type RelayClient, type RelayClientConfig, type RelayIndexOperations, type RelayMessage, type RelayMessageType, type RouteMessage, SCHEMA_ORG_CONTEXT, SLOW_DOMAINS, type SeenEntry, type SemanticQuery, type SendMessage, type ServiceEndpoint, type SessionMeta, type SignFunction, type SignedMessage, type StoredMessage, type SubscriptionFilter, SybilDefense, type SyncEvent, type SyncHelloMessage, type SyncPushMessage, type SyncReconcileMessage, type SyncRequestMessage, type SyncResponseMessage, TokenBucket, type TokenBucketConfig, TransportError, TrustComputer, type TrustConfig, TrustMetrics, type TrustQueryMessage, type TrustResult, type TrustResultEndorsement, type TrustResultMessage, type TrustScore, type TrustStatus, TrustSystem, type TrustSystemConfig, type UnpublishCardMessage, type VerificationMethod, type VerifyFunction, type WelcomeMessage, clawiverseContext, createAgentCard, createDIDDocument, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createRelayClient, createRelayIndexOperations, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, formatDidWithAlias, formatDidWithAliasDetailed, generateAnonymousIdentity, generateKeyPair, generateThreadId, getAgentCardContext, getDefaultExpiration, getEncodedSize, getTierConfig, importKeyPair, isLegacyCard, isValidContext, matchesCapability, normalizeEnvelope, normalizeEnvelopeType, resolveDid, reverseAlias, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateAliasName, validateDID, validateDIDDocument, validateDomain, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };