@tjamescouch/agentchat 0.9.0 → 0.11.0

package/bin/agentchat.js

@@ -95,7 +95,11 @@ program
       console.log('Message sent');
       process.exit(0);
     } catch (err) {
-      console.error('Error:', err.message);
+      if (err.code === 'ECONNREFUSED') {
+        console.error('Error: Connection refused. Is the server running?');
+      } else {
+        console.error('Error:', err.message || err.code || err);
+      }
       process.exit(1);
     }
   });
@@ -142,7 +146,12 @@ program
       });
 
     } catch (err) {
-      console.error('Error:', err.message);
+      if (err.code === 'ECONNREFUSED') {
+        console.error('Error: Connection refused. Is the server running?');
+        console.error(`  Try: agentchat serve --port 8080`);
+      } else {
+        console.error('Error:', err.message || err.code || err);
+      }
       process.exit(1);
     }
   });
@@ -358,6 +367,7 @@ program
   .option('-p, --payment-code <code>', 'Your payment code (BIP47, address)')
   .option('-e, --expires <seconds>', 'Expiration time in seconds', '300')
   .option('-t, --terms <terms>', 'Additional terms')
+  .option('-s, --elo-stake <n>', 'ELO points to stake on this proposal')
   .action(async (server, agent, task, options) => {
     try {
       const client = new AgentChatClient({ server, identity: options.identity });
@@ -369,7 +379,8 @@ program
         currency: options.currency,
         payment_code: options.paymentCode,
         terms: options.terms,
-        expires: parseInt(options.expires)
+        expires: parseInt(options.expires),
+        elo_stake: options.eloStake ? parseInt(options.eloStake) : undefined
       });
 
       console.log('Proposal sent:');
@@ -377,6 +388,7 @@ program
       console.log(`  To: ${proposal.to}`);
       console.log(`  Task: ${proposal.task}`);
       if (proposal.amount) console.log(`  Amount: ${proposal.amount} ${proposal.currency || ''}`);
+      if (proposal.elo_stake) console.log(`  ELO Stake: ${proposal.elo_stake}`);
       if (proposal.expires) console.log(`  Expires: ${new Date(proposal.expires).toISOString()}`);
       console.log(`\nUse this ID to track responses.`);
 
@@ -394,16 +406,20 @@ program
   .description('Accept a proposal')
   .option('-i, --identity <file>', 'Path to identity file (required)', DEFAULT_IDENTITY_PATH)
   .option('-p, --payment-code <code>', 'Your payment code for receiving payment')
+  .option('-s, --elo-stake <n>', 'ELO points to stake (as acceptor)')
   .action(async (server, proposalId, options) => {
     try {
       const client = new AgentChatClient({ server, identity: options.identity });
       await client.connect();
 
-      const response = await client.accept(proposalId, options.paymentCode);
+      const eloStake = options.eloStake ? parseInt(options.eloStake) : undefined;
+      const response = await client.accept(proposalId, options.paymentCode, eloStake);
 
       console.log('Proposal accepted:');
       console.log(`  Proposal ID: ${response.proposal_id}`);
       console.log(`  Status: ${response.status}`);
+      if (response.proposer_stake) console.log(`  Proposer Stake: ${response.proposer_stake} ELO`);
+      if (response.acceptor_stake) console.log(`  Your Stake: ${response.acceptor_stake} ELO`);
 
       client.disconnect();
       process.exit(0);

package/lib/client.js

@@ -297,7 +297,8 @@ export class AgentChatClient extends EventEmitter {
       currency: proposal.currency,
       payment_code: proposal.payment_code,
       terms: proposal.terms,
-      expires: proposal.expires
+      expires: proposal.expires,
+      elo_stake: proposal.elo_stake
     };
 
     // Sign the proposal
@@ -337,19 +338,21 @@ export class AgentChatClient extends EventEmitter {
    * Accept a proposal
    * @param {string} proposalId - The proposal ID to accept
    * @param {string} [payment_code] - Your payment code for receiving payment
+   * @param {number} [elo_stake] - ELO points to stake as acceptor
    */
-  async accept(proposalId, payment_code = null) {
+  async accept(proposalId, payment_code = null, elo_stake = null) {
     if (!this._identity || !this._identity.privkey) {
       throw new Error('Accepting proposals requires persistent identity.');
     }
 
-    const sigContent = getAcceptSigningContent(proposalId, payment_code || '');
+    const sigContent = getAcceptSigningContent(proposalId, payment_code || '', elo_stake || '');
     const sig = this._identity.sign(sigContent);
 
     const msg = {
       type: ClientMessageType.ACCEPT,
       proposal_id: proposalId,
       payment_code,
+      elo_stake,
       sig
     };
 

package/lib/proposals.js

@@ -45,6 +45,10 @@ export class ProposalStore {
       created_at: now,
       updated_at: now,
       sig: proposal.sig,
+      // ELO staking
+      proposer_stake: proposal.elo_stake || null,
+      acceptor_stake: null,
+      stakes_escrowed: false,
       // Response tracking
       response_sig: null,
       response_payment_code: null,
@@ -82,8 +86,13 @@ export class ProposalStore {
 
   /**
    * Accept a proposal
+   * @param {string} id - Proposal ID
+   * @param {string} acceptorId - Agent accepting the proposal
+   * @param {string} sig - Signature of acceptance
+   * @param {string} payment_code - Optional payment code
+   * @param {number} acceptor_stake - Optional ELO stake from acceptor
    */
-  accept(id, acceptorId, sig, payment_code = null) {
+  accept(id, acceptorId, sig, payment_code = null, acceptor_stake = null) {
     const proposal = this.get(id);
     if (!proposal) {
       return { error: 'PROPOSAL_NOT_FOUND' };
@@ -106,6 +115,7 @@ export class ProposalStore {
     proposal.status = ProposalStatus.ACCEPTED;
     proposal.response_sig = sig;
     proposal.response_payment_code = payment_code;
+    proposal.acceptor_stake = acceptor_stake;
     proposal.updated_at = Date.now();
 
     return { proposal };
@@ -296,7 +306,8 @@ export function formatProposal(proposal) {
     expires: proposal.expires,
     status: proposal.status,
     created_at: proposal.created_at,
-    sig: proposal.sig
+    sig: proposal.sig,
+    elo_stake: proposal.proposer_stake
   };
 }
 
@@ -317,7 +328,9 @@ export function formatProposalResponse(proposal, responseType) {
         from: proposal.from,
         to: proposal.to,
         payment_code: proposal.response_payment_code,
-        sig: proposal.response_sig
+        sig: proposal.response_sig,
+        proposer_stake: proposal.proposer_stake,
+        acceptor_stake: proposal.acceptor_stake
       };
 
     case 'reject':
@@ -337,7 +350,11 @@ export function formatProposalResponse(proposal, responseType) {
         completed_by: proposal.completed_by,
         completed_at: proposal.completed_at,
         proof: proposal.completion_proof,
-        sig: proposal.completion_sig
+        sig: proposal.completion_sig,
+        elo_stakes: {
+          proposer: proposal.proposer_stake || 0,
+          acceptor: proposal.acceptor_stake || 0
+        }
       };
 
     case 'dispute':
@@ -348,7 +365,11 @@ export function formatProposalResponse(proposal, responseType) {
         disputed_by: proposal.disputed_by,
         disputed_at: proposal.disputed_at,
         reason: proposal.dispute_reason,
-        sig: proposal.dispute_sig
+        sig: proposal.dispute_sig,
+        elo_stakes: {
+          proposer: proposal.proposer_stake || 0,
+          acceptor: proposal.acceptor_stake || 0
+        }
       };
 
     default:
@@ -367,16 +388,20 @@ export function getProposalSigningContent(proposal) {
     proposal.amount || '',
     proposal.currency || '',
     proposal.payment_code || '',
-    proposal.expires || ''
+    proposal.expires || '',
+    proposal.elo_stake || ''
   ];
   return fields.join('|');
 }
 
 /**
  * Create accept content string for signing
+ * @param {string} proposalId - The proposal being accepted
+ * @param {string} payment_code - Optional payment code
+ * @param {number} elo_stake - Optional ELO stake from acceptor
  */
-export function getAcceptSigningContent(proposalId, payment_code = '') {
-  return `ACCEPT|${proposalId}|${payment_code}`;
+export function getAcceptSigningContent(proposalId, payment_code = '', elo_stake = '') {
+  return `ACCEPT|${proposalId}|${payment_code}|${elo_stake}`;
 }
 
 /**

package/lib/protocol.js

@@ -65,7 +65,10 @@ export const ErrorCode = {
   PROPOSAL_EXPIRED: 'PROPOSAL_EXPIRED',
   INVALID_PROPOSAL: 'INVALID_PROPOSAL',
   SIGNATURE_REQUIRED: 'SIGNATURE_REQUIRED',
-  NOT_PROPOSAL_PARTY: 'NOT_PROPOSAL_PARTY'
+  NOT_PROPOSAL_PARTY: 'NOT_PROPOSAL_PARTY',
+  // Staking errors
+  INSUFFICIENT_REPUTATION: 'INSUFFICIENT_REPUTATION',
+  INVALID_STAKE: 'INVALID_STAKE'
 };
 
 // Proposal status
@@ -250,20 +253,40 @@ export function validateClientMessage(raw) {
       if (!msg.sig) {
         return { valid: false, error: 'Proposals must be signed' };
       }
-      // Optional fields: amount, currency, payment_code, expires, terms
+      // Optional fields: amount, currency, payment_code, expires, terms, elo_stake
       if (msg.expires !== undefined && typeof msg.expires !== 'number') {
         return { valid: false, error: 'expires must be a number (seconds)' };
       }
+      if (msg.elo_stake !== undefined) {
+        if (typeof msg.elo_stake !== 'number' || msg.elo_stake < 0 || !Number.isInteger(msg.elo_stake)) {
+          return { valid: false, error: 'elo_stake must be a non-negative integer' };
+        }
+      }
       break;
 
     case ClientMessageType.ACCEPT:
+      // Accept requires: proposal_id and signature
+      if (!msg.proposal_id) {
+        return { valid: false, error: 'Missing proposal_id' };
+      }
+      if (!msg.sig) {
+        return { valid: false, error: 'Accept must be signed' };
+      }
+      // Optional: elo_stake for acceptor's stake
+      if (msg.elo_stake !== undefined) {
+        if (typeof msg.elo_stake !== 'number' || msg.elo_stake < 0 || !Number.isInteger(msg.elo_stake)) {
+          return { valid: false, error: 'elo_stake must be a non-negative integer' };
+        }
+      }
+      break;
+
     case ClientMessageType.REJECT:
-      // Accept/Reject require: proposal_id and signature
+      // Reject requires: proposal_id and signature
       if (!msg.proposal_id) {
         return { valid: false, error: 'Missing proposal_id' };
       }
       if (!msg.sig) {
-        return { valid: false, error: 'Accept/Reject must be signed' };
+        return { valid: false, error: 'Reject must be signed' };
       }
       break;
 

package/lib/reputation.js

@@ -21,6 +21,7 @@ export const DEFAULT_RATINGS_PATH = path.join(AGENTCHAT_DIR, 'ratings.json');
 // ELO constants
 export const DEFAULT_RATING = 1200;
 export const ELO_DIVISOR = 400; // Standard ELO divisor
+export const MINIMUM_RATING = 100; // Floor - can't drop below this
 
 // K-factor thresholds
 const K_FACTOR_NEW = 32;        // < 30 transactions
@@ -127,6 +128,7 @@ export class ReputationStore {
   constructor(ratingsPath = DEFAULT_RATINGS_PATH) {
     this.ratingsPath = ratingsPath;
     this._ratings = null; // Lazy load
+    this._escrows = new Map(); // proposalId → escrow record
   }
 
   /**
@@ -210,6 +212,125 @@ export class ReputationStore {
     return getKFactor(record.transactions);
   }
 
+  /**
+   * Get total escrowed ELO for an agent
+   */
+  getEscrowedAmount(agentId) {
+    const id = this._normalizeId(agentId);
+    let total = 0;
+    for (const escrow of this._escrows.values()) {
+      if (escrow.status === 'active') {
+        if (escrow.from.agent_id === id) {
+          total += escrow.from.stake;
+        }
+        if (escrow.to.agent_id === id) {
+          total += escrow.to.stake;
+        }
+      }
+    }
+    return total;
+  }
+
+  /**
+   * Get available rating for staking (rating - escrowed - minimum floor)
+   */
+  async getAvailableRating(agentId) {
+    const record = await this.getRating(agentId);
+    const escrowed = this.getEscrowedAmount(agentId);
+    const available = record.rating - escrowed - MINIMUM_RATING;
+    return Math.max(0, available);
+  }
+
+  /**
+   * Check if agent can stake the requested amount
+   */
+  async canStake(agentId, amount) {
+    if (!amount || amount <= 0) {
+      return { canStake: true, available: await this.getAvailableRating(agentId) };
+    }
+
+    const available = await this.getAvailableRating(agentId);
+
+    if (amount > available) {
+      return {
+        canStake: false,
+        available,
+        reason: `Insufficient ELO. Available: ${available}, Requested: ${amount}`
+      };
+    }
+
+    return { canStake: true, available };
+  }
+
+  /**
+   * Create escrow for a proposal
+   * Called when proposal is accepted with stakes
+   */
+  async createEscrow(proposalId, fromStake, toStake, expiresAt = null) {
+    // Validate both parties can stake
+    if (fromStake.stake > 0) {
+      const canFrom = await this.canStake(fromStake.agent_id, fromStake.stake);
+      if (!canFrom.canStake) {
+        return { success: false, error: `Proposer: ${canFrom.reason}` };
+      }
+    }
+
+    if (toStake.stake > 0) {
+      const canTo = await this.canStake(toStake.agent_id, toStake.stake);
+      if (!canTo.canStake) {
+        return { success: false, error: `Acceptor: ${canTo.reason}` };
+      }
+    }
+
+    const escrow = {
+      proposal_id: proposalId,
+      created_at: Date.now(),
+      from: {
+        agent_id: this._normalizeId(fromStake.agent_id),
+        stake: fromStake.stake || 0
+      },
+      to: {
+        agent_id: this._normalizeId(toStake.agent_id),
+        stake: toStake.stake || 0
+      },
+      status: 'active',
+      expires_at: expiresAt,
+      settled_at: null,
+      settlement_reason: null
+    };
+
+    this._escrows.set(proposalId, escrow);
+    return { success: true, escrow };
+  }
+
+  /**
+   * Get escrow for a proposal
+   */
+  getEscrow(proposalId) {
+    return this._escrows.get(proposalId) || null;
+  }
+
+  /**
+   * Release escrow (return stakes to both parties, no rating change)
+   * Used for proposal expiration
+   */
+  releaseEscrow(proposalId) {
+    const escrow = this._escrows.get(proposalId);
+    if (!escrow) {
+      return { released: false, error: 'Escrow not found' };
+    }
+
+    if (escrow.status !== 'active') {
+      return { released: false, error: `Escrow already ${escrow.status}` };
+    }
+
+    escrow.status = 'released';
+    escrow.settled_at = Date.now();
+    escrow.settlement_reason = 'expired';
+
+    return { released: true, escrow };
+  }
+
   /**
    * Update rating for an agent
    */
@@ -233,7 +354,7 @@ export class ReputationStore {
   }
 
   /**
-   * Process a COMPLETE receipt - both parties gain
+   * Process a COMPLETE receipt - both parties gain (halved gains with staking)
    *
    * @param {object} receipt - The COMPLETE receipt
    * @returns {object} Rating changes for both parties
@@ -243,6 +364,7 @@ export class ReputationStore {
     const party1 = receipt.proposal?.from || receipt.from;
     const party2 = receipt.proposal?.to || receipt.to;
     const amount = receipt.proposal?.amount || receipt.amount || 0;
+    const proposalId = receipt.proposal_id;
 
     if (!party1 || !party2) {
       throw new Error('Receipt missing party information');
@@ -252,12 +374,32 @@ export class ReputationStore {
     const rating1 = await this.getRating(party1);
     const rating2 = await this.getRating(party2);
 
-    // Calculate gains
+    // Calculate gains (halved for staking model)
     const k1 = getKFactor(rating1.transactions);
     const k2 = getKFactor(rating2.transactions);
 
-    const gain1 = calculateCompletionGain(rating1.rating, rating2.rating, k1, amount);
-    const gain2 = calculateCompletionGain(rating2.rating, rating1.rating, k2, amount);
+    const fullGain1 = calculateCompletionGain(rating1.rating, rating2.rating, k1, amount);
+    const fullGain2 = calculateCompletionGain(rating2.rating, rating1.rating, k2, amount);
+
+    // Half the gains (staking model: split gains to balance inflation)
+    const gain1 = Math.max(1, Math.round(fullGain1 / 2));
+    const gain2 = Math.max(1, Math.round(fullGain2 / 2));
+
+    // Settle escrow if exists (return stakes)
+    let escrowSettlement = null;
+    if (proposalId) {
+      const escrow = this._escrows.get(proposalId);
+      if (escrow && escrow.status === 'active') {
+        escrow.status = 'settled';
+        escrow.settled_at = Date.now();
+        escrow.settlement_reason = 'completed';
+        escrowSettlement = {
+          proposer_stake: escrow.from.stake,
+          acceptor_stake: escrow.to.stake,
+          settlement: 'returned'
+        };
+      }
+    }
 
     // Apply updates
     const updated1 = await this._updateAgent(party1, gain1);
@@ -266,7 +408,7 @@ export class ReputationStore {
     // Save
     await this.save();
 
-    return {
+    const result = {
       [party1]: {
         oldRating: rating1.rating,
         newRating: updated1.rating,
@@ -280,12 +422,19 @@ export class ReputationStore {
         transactions: updated2.transactions
       }
     };
+
+    if (escrowSettlement) {
+      result._escrow = escrowSettlement;
+    }
+
+    return result;
   }
 
   /**
    * Process a DISPUTE receipt
    * If disputed_by is set, they are the "winner" (counterparty is at fault)
    * Otherwise, both parties lose (mutual fault)
+   * Stakes are transferred to winner or burned on mutual fault
    *
    * @param {object} receipt - The DISPUTE receipt
    * @returns {object} Rating changes for both parties
@@ -295,6 +444,7 @@ export class ReputationStore {
     const party2 = receipt.proposal?.to || receipt.to;
     const disputedBy = receipt.disputed_by;
     const amount = receipt.proposal?.amount || receipt.amount || 0;
+    const proposalId = receipt.proposal_id;
 
     if (!party1 || !party2) {
       throw new Error('Receipt missing party information');
@@ -306,24 +456,68 @@ export class ReputationStore {
     const k1 = getKFactor(rating1.transactions);
     const k2 = getKFactor(rating2.transactions);
 
+    // Get escrow info for stake calculations
+    let escrow = null;
+    let stake1 = 0, stake2 = 0;
+    if (proposalId) {
+      escrow = this._escrows.get(proposalId);
+      if (escrow && escrow.status === 'active') {
+        stake1 = escrow.from.agent_id === this._normalizeId(party1)
+          ? escrow.from.stake
+          : escrow.to.stake;
+        stake2 = escrow.from.agent_id === this._normalizeId(party2)
+          ? escrow.from.stake
+          : escrow.to.stake;
+      }
+    }
+
     let change1, change2;
+    let escrowSettlement = null;
 
     if (disputedBy) {
       // The disputer is the "winner", counterparty at fault
       const atFault = disputedBy === party1 ? party2 : party1;
-      const winner = disputedBy === party1 ? party1 : party2;
 
       if (atFault === party1) {
-        change1 = calculateDisputeLoss(rating1.rating, rating2.rating, k1, amount);
-        change2 = Math.round(Math.abs(change1) * 0.5); // Winner gains half of loser's loss
+        // Party1 at fault: loses ELO + loses stake to party2
+        change1 = calculateDisputeLoss(rating1.rating, rating2.rating, k1, amount) - stake1;
+        change2 = Math.round(Math.abs(calculateDisputeLoss(rating1.rating, rating2.rating, k1, amount)) * 0.5) + stake1;
+        escrowSettlement = {
+          proposer_stake: escrow?.from.stake || 0,
+          acceptor_stake: escrow?.to.stake || 0,
+          settlement: 'transferred',
+          transferred_to: party2,
+          transferred_amount: stake1
+        };
       } else {
-        change2 = calculateDisputeLoss(rating2.rating, rating1.rating, k2, amount);
-        change1 = Math.round(Math.abs(change2) * 0.5);
+        // Party2 at fault: loses ELO + loses stake to party1
+        change2 = calculateDisputeLoss(rating2.rating, rating1.rating, k2, amount) - stake2;
+        change1 = Math.round(Math.abs(calculateDisputeLoss(rating2.rating, rating1.rating, k2, amount)) * 0.5) + stake2;
+        escrowSettlement = {
+          proposer_stake: escrow?.from.stake || 0,
+          acceptor_stake: escrow?.to.stake || 0,
+          settlement: 'transferred',
+          transferred_to: party1,
+          transferred_amount: stake2
+        };
       }
     } else {
-      // Mutual fault - both lose
-      change1 = calculateDisputeLoss(rating1.rating, rating2.rating, k1, amount);
-      change2 = calculateDisputeLoss(rating2.rating, rating1.rating, k2, amount);
+      // Mutual fault - both lose ELO + both stakes burned
+      change1 = calculateDisputeLoss(rating1.rating, rating2.rating, k1, amount) - stake1;
+      change2 = calculateDisputeLoss(rating2.rating, rating1.rating, k2, amount) - stake2;
+      escrowSettlement = {
+        proposer_stake: escrow?.from.stake || 0,
+        acceptor_stake: escrow?.to.stake || 0,
+        settlement: 'burned',
+        burned_amount: stake1 + stake2
+      };
+    }
+
+    // Settle escrow
+    if (escrow && escrow.status === 'active') {
+      escrow.status = 'settled';
+      escrow.settled_at = Date.now();
+      escrow.settlement_reason = 'disputed';
     }
 
     const updated1 = await this._updateAgent(party1, change1);
@@ -331,7 +525,7 @@ export class ReputationStore {
 
     await this.save();
 
-    return {
+    const result = {
       [party1]: {
         oldRating: rating1.rating,
         newRating: updated1.rating,
@@ -345,6 +539,12 @@ export class ReputationStore {
         transactions: updated2.transactions
       }
     };
+
+    if (escrowSettlement) {
+      result._escrow = escrowSettlement;
+    }
+
+    return result;
   }
 
   /**

package/lib/server.js

@@ -23,6 +23,7 @@ import {
   isProposalMessage
 } from './protocol.js';
 import { ProposalStore, formatProposal, formatProposalResponse } from './proposals.js';
+import { ReputationStore } from './reputation.js';
 
 export class AgentChatServer {
   constructor(options = {}) {
@@ -75,6 +76,9 @@ export class AgentChatServer {
     // Skills registry: agentId -> { skills: [], registered_at, sig }
     this.skillsRegistry = new Map();
 
+    // Reputation store for ELO ratings
+    this.reputationStore = new ReputationStore();
+
     this.wss = null;
     this.httpServer = null;  // For TLS mode
   }
@@ -681,7 +685,8 @@ export class AgentChatServer {
       payment_code: msg.payment_code,
       terms: msg.terms,
       expires: msg.expires,
-      sig: msg.sig
+      sig: msg.sig,
+      elo_stake: msg.elo_stake || null
     });
 
     this._log('proposal', { id: proposal.id, from: agent.id, to: targetId });
@@ -696,7 +701,7 @@ export class AgentChatServer {
     this._send(ws, outMsg);
   }
 
-  _handleAccept(ws, msg) {
+  async _handleAccept(ws, msg) {
     const agent = this.agents.get(ws);
     if (!agent) {
       this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
@@ -708,11 +713,40 @@ export class AgentChatServer {
       return;
     }
 
+    // Get proposal first to check stakes
+    const existingProposal = this.proposals.get(msg.proposal_id);
+    if (!existingProposal) {
+      this._send(ws, createError(ErrorCode.PROPOSAL_NOT_FOUND, 'Proposal not found'));
+      return;
+    }
+
+    const proposerStake = existingProposal.proposer_stake || 0;
+    const acceptorStake = msg.elo_stake || 0;
+
+    // Validate proposer can stake (if they declared a stake)
+    if (proposerStake > 0) {
+      const canProposerStake = await this.reputationStore.canStake(existingProposal.from, proposerStake);
+      if (!canProposerStake.canStake) {
+        this._send(ws, createError(ErrorCode.INSUFFICIENT_REPUTATION, `Proposer: ${canProposerStake.reason}`));
+        return;
+      }
+    }
+
+    // Validate acceptor can stake (if they declared a stake)
+    if (acceptorStake > 0) {
+      const canAcceptorStake = await this.reputationStore.canStake(`@${agent.id}`, acceptorStake);
+      if (!canAcceptorStake.canStake) {
+        this._send(ws, createError(ErrorCode.INSUFFICIENT_REPUTATION, canAcceptorStake.reason));
+        return;
+      }
+    }
+
     const result = this.proposals.accept(
       msg.proposal_id,
       `@${agent.id}`,
       msg.sig,
-      msg.payment_code
+      msg.payment_code,
+      acceptorStake
     );
 
     if (result.error) {
@@ -721,7 +755,29 @@ export class AgentChatServer {
     }
 
     const proposal = result.proposal;
-    this._log('accept', { id: proposal.id, by: agent.id });
+
+    // Create escrow if either party has a stake
+    if (proposerStake > 0 || acceptorStake > 0) {
+      const escrowResult = await this.reputationStore.createEscrow(
+        proposal.id,
+        { agent_id: proposal.from, stake: proposerStake },
+        { agent_id: proposal.to, stake: acceptorStake },
+        proposal.expires
+      );
+
+      if (escrowResult.success) {
+        proposal.stakes_escrowed = true;
+        this._log('escrow_created', {
+          proposal_id: proposal.id,
+          proposer_stake: proposerStake,
+          acceptor_stake: acceptorStake
+        });
+      } else {
+        this._log('escrow_error', { proposal_id: proposal.id, error: escrowResult.error });
+      }
+    }
+
+    this._log('accept', { id: proposal.id, by: agent.id, proposer_stake: proposerStake, acceptor_stake: acceptorStake });
 
     // Notify the proposal creator
     const creatorId = proposal.from.slice(1);
@@ -780,7 +836,7 @@ export class AgentChatServer {
     this._send(ws, outMsg);
   }
 
-  _handleComplete(ws, msg) {
+  async _handleComplete(ws, msg) {
     const agent = this.agents.get(ws);
     if (!agent) {
       this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
@@ -807,9 +863,29 @@ export class AgentChatServer {
     const proposal = result.proposal;
     this._log('complete', { id: proposal.id, by: agent.id });
 
+    // Update reputation ratings (includes escrow settlement)
+    let ratingChanges = null;
+    try {
+      ratingChanges = await this.reputationStore.processCompletion({
+        type: 'COMPLETE',
+        proposal_id: proposal.id,
+        from: proposal.from,
+        to: proposal.to,
+        amount: proposal.amount
+      });
+      this._log('reputation_updated', {
+        proposal_id: proposal.id,
+        changes: ratingChanges,
+        escrow: ratingChanges?._escrow
+      });
+    } catch (err) {
+      this._log('reputation_error', { error: err.message });
+    }
+
     // Notify both parties
     const outMsg = createMessage(ServerMessageType.COMPLETE, {
-      ...formatProposalResponse(proposal, 'complete')
+      ...formatProposalResponse(proposal, 'complete'),
+      rating_changes: ratingChanges
     });
 
     // Notify the other party
@@ -823,7 +899,7 @@ export class AgentChatServer {
     this._send(ws, outMsg);
   }
 
-  _handleDispute(ws, msg) {
+  async _handleDispute(ws, msg) {
     const agent = this.agents.get(ws);
     if (!agent) {
       this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
@@ -850,9 +926,30 @@ export class AgentChatServer {
     const proposal = result.proposal;
     this._log('dispute', { id: proposal.id, by: agent.id, reason: msg.reason });
 
+    // Update reputation ratings (includes escrow settlement)
+    let ratingChanges = null;
+    try {
+      ratingChanges = await this.reputationStore.processDispute({
+        type: 'DISPUTE',
+        proposal_id: proposal.id,
+        from: proposal.from,
+        to: proposal.to,
+        amount: proposal.amount,
+        disputed_by: `@${agent.id}`
+      });
+      this._log('reputation_updated', {
+        proposal_id: proposal.id,
+        changes: ratingChanges,
+        escrow: ratingChanges?._escrow
+      });
+    } catch (err) {
+      this._log('reputation_error', { error: err.message });
+    }
+
     // Notify both parties
     const outMsg = createMessage(ServerMessageType.DISPUTE, {
-      ...formatProposalResponse(proposal, 'dispute')
+      ...formatProposalResponse(proposal, 'dispute'),
+      rating_changes: ratingChanges
     });
 
     // Notify the other party
@@ -907,7 +1004,7 @@ export class AgentChatServer {
     }
   }
 
-  _handleSearchSkills(ws, msg) {
+  async _handleSearchSkills(ws, msg) {
     const agent = this.agents.get(ws);
     if (!agent) {
       this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
@@ -955,8 +1052,26 @@ export class AgentChatServer {
       }
     }
 
-    // Sort by registration time (newest first)
-    results.sort((a, b) => b.registered_at - a.registered_at);
+    // Enrich results with reputation data
+    const uniqueAgentIds = [...new Set(results.map(r => r.agent_id))];
+    const ratingCache = new Map();
+    for (const agentId of uniqueAgentIds) {
+      const ratingInfo = await this.reputationStore.getRating(agentId);
+      ratingCache.set(agentId, ratingInfo);
+    }
+
+    // Add rating info to each result
+    for (const result of results) {
+      const ratingInfo = ratingCache.get(result.agent_id);
+      result.rating = ratingInfo.rating;
+      result.transactions = ratingInfo.transactions;
+    }
+
+    // Sort by rating (highest first), then by registration time
+    results.sort((a, b) => {
+      if (b.rating !== a.rating) return b.rating - a.rating;
+      return b.registered_at - a.registered_at;
+    });
 
     // Limit results
     const limit = query.limit || 50;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tjamescouch/agentchat",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Real-time IRC-like communication protocol for AI agents",
   "main": "lib/client.js",
   "files": [