@cogitator-ai/swarms 0.4.20 → 0.6.0

package/dist/strategies/negotiation-strategy.js

@@ -4,12 +4,17 @@ import { BaseStrategy } from './base.js';
 import { TurnManager } from './negotiation/turn-manager.js';
 import { ConvergenceCalculator } from './negotiation/convergence.js';
 import { ApprovalIntegration } from './negotiation/approval.js';
+import { MEDIATOR_ID, NEGOTIATION_RULES_SECTION, NEGOTIATION_SECTION, isFullyAccepted, isOfferExpired, offerParties, readNegotiationState, } from '../shared/negotiation.js';
 export class NegotiationStrategy extends BaseStrategy {
     config;
     state;
+    agentNames = [];
     turnManager;
     convergenceCalculator;
     approvalIntegration;
+    reviewedOfferIds = new Set();
+    reviewedCoalitionIds = new Set();
+    lastMediationRound;
     constructor(coordinator, config = {}) {
         super(coordinator);
         this.config = { ...DEFAULT_NEGOTIATION_CONFIG, ...config };
@@ -22,45 +27,68 @@ export class NegotiationStrategy extends BaseStrategy {
         if (negotiatingAgents.length < 2) {
             throw new Error('Negotiation strategy requires at least 2 agents');
         }
-        const agentNames = negotiatingAgents.map((a) => a.agent.name);
-        this.initializeState(negotiationId, agentNames);
-        this.initializeHelpers(agentNames, negotiationId);
+        this.agentNames = negotiatingAgents.map((a) => a.agent.name);
+        this.reviewedOfferIds.clear();
+        this.reviewedCoalitionIds.clear();
+        this.lastMediationRound = undefined;
+        this.initializeState(negotiationId);
+        this.initializeHelpers(this.agentNames, negotiationId);
         this.coordinator.events.emit('negotiation:start', {
             negotiationId,
-            agents: agentNames,
+            agents: this.agentNames,
             config: this.config,
         }, 'system');
-        await this.runInitializationPhase(options, negotiatingAgents, agentResults);
-        for (let round = 1; round <= this.config.maxRounds; round++) {
-            this.state.round = round;
-            this.turnManager.setRound(round);
-            this.coordinator.events.emit('negotiation:round', { round, maxRounds: this.config.maxRounds }, 'system');
-            await this.runProposalPhase(options, negotiatingAgents, agentResults);
-            if (await this.checkForAgreement()) {
-                return this.finalizeResult(agentResults, 'agreement');
-            }
-            await this.runCounterPhase(options, negotiatingAgents, agentResults);
-            if (await this.checkForAgreement()) {
-                return this.finalizeResult(agentResults, 'agreement');
-            }
-            const metrics = this.convergenceCalculator.calculateOverallConvergence(this.state.offers, round);
-            this.state.convergenceHistory.push(metrics);
-            this.coordinator.events.emit('negotiation:convergence-update', { metrics, round }, 'system');
-            if (this.convergenceCalculator.isStagnant()) {
-                this.coordinator.events.emit('negotiation:stagnation-detected', { round, metrics }, 'system');
-                const mediationSuggestion = this.convergenceCalculator.suggestCompromise(this.state.offers);
-                if (mediationSuggestion) {
-                    this.coordinator.events.emit('negotiation:mediation-suggested', { suggestion: mediationSuggestion }, 'system');
-                    await this.runRefinementPhase(options, negotiatingAgents, agentResults, mediationSuggestion);
+        try {
+            await this.runInitializationPhase(options, negotiatingAgents, agentResults);
+            for (let round = 1; round <= this.config.maxRounds; round++) {
+                this.state.round = round;
+                this.turnManager.setRound(round);
+                this.updateBlackboard();
+                this.coordinator.events.emit('negotiation:round', { round, maxRounds: this.config.maxRounds }, 'system');
+                await this.runProposalPhase(options, negotiatingAgents, agentResults);
+                if (await this.checkForAgreement()) {
+                    return this.finalizeResult(agentResults, 'agreement');
+                }
+                await this.runCounterPhase(options, negotiatingAgents, agentResults);
+                if (await this.checkForAgreement()) {
+                    return this.finalizeResult(agentResults, 'agreement');
+                }
+                const metrics = this.convergenceCalculator.calculateOverallConvergence(this.state.offers, round);
+                this.state.convergenceHistory = [...this.state.convergenceHistory, metrics];
+                this.updateBlackboard();
+                this.coordinator.events.emit('negotiation:convergence-update', { metrics, round }, 'system');
+                if (this.convergenceCalculator.isStagnant() && this.lastMediationRound === undefined) {
+                    this.coordinator.events.emit('negotiation:stagnation-detected', { round, metrics }, 'system');
+                    const mediationSuggestion = this.convergenceCalculator.suggestCompromise(this.state.offers.filter((o) => o.from !== MEDIATOR_ID));
+                    if (mediationSuggestion) {
+                        this.lastMediationRound = round;
+                        this.coordinator.events.emit('negotiation:mediation-suggested', { suggestion: mediationSuggestion }, 'system');
+                        await this.runRefinementPhase(options, negotiatingAgents, agentResults, mediationSuggestion);
+                        if (await this.checkForAgreement()) {
+                            return this.finalizeResult(agentResults, 'agreement');
+                        }
+                    }
+                }
+                if (this.isDeadlocked(round)) {
+                    return this.handleDeadlock(options, agentResults);
                 }
             }
-            if (this.isDeadlocked()) {
-                return this.handleDeadlock(options, agents, agentResults);
-            }
+            return this.handleDeadlock(options, agentResults);
+        }
+        finally {
+            this.approvalIntegration?.cancelAll();
+        }
+    }
+    /**
+     * Answer a pending approval request (see the `negotiation:approval-required` event).
+     */
+    respondToApproval(requestId, response) {
+        if (!this.approvalIntegration) {
+            throw new Error('No approval gates are configured for this negotiation');
         }
-        return this.handleDeadlock(options, agents, agentResults);
+        this.approvalIntegration.submitResponse(requestId, response);
     }
-    initializeState(negotiationId, _agentNames) {
+    initializeState(negotiationId) {
         this.state = {
             negotiationId,
             phase: 'initialization',
@@ -76,7 +104,14 @@ export class NegotiationStrategy extends BaseStrategy {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
         };
-        this.coordinator.blackboard.write('negotiation', this.state, 'system');
+        const rules = {
+            maxOffersPerRound: this.config.maxOffersPerRound,
+            offerTimeout: this.config.offerTimeout,
+            allowCoalitions: this.config.allowCoalitions ?? true,
+            minCoalitionSize: this.config.minCoalitionSize ?? 2,
+        };
+        this.coordinator.blackboard.write(NEGOTIATION_RULES_SECTION, rules, 'system');
+        this.updateBlackboard();
     }
     initializeHelpers(agentNames, negotiationId) {
         this.turnManager = new TurnManager({
@@ -89,12 +124,45 @@ export class NegotiationStrategy extends BaseStrategy {
             stagnationThreshold: this.config.stagnationThreshold ?? 0.05,
             maxRoundsWithoutProgress: this.config.maxRoundsWithoutProgress ?? 3,
         });
-        if (this.config.approvalGates && this.config.approvalGates.length > 0) {
-            this.approvalIntegration = new ApprovalIntegration({
-                gates: this.config.approvalGates,
-                negotiationId,
-            });
+        this.approvalIntegration =
+            this.config.approvalGates && this.config.approvalGates.length > 0
+                ? new ApprovalIntegration({ gates: this.config.approvalGates, negotiationId })
+                : undefined;
+    }
+    /**
+     * Run one agent turn. A turn that exceeds `turnTimeout` is skipped instead of failing
+     * the negotiation; any other error propagates.
+     */
+    async runTurn(agent, prompt, options, phase, results, resultKey) {
+        const name = agent.agent.name;
+        const turnTimeout = this.config.turnTimeout;
+        const startedAt = Date.now();
+        this.state.currentTurn = name;
+        this.turnManager.startTurn();
+        this.updateBlackboard();
+        try {
+            const result = await this.coordinator.runAgent(name, prompt, this.buildAgentContext(agent, options), turnTimeout !== undefined && turnTimeout > 0 ? { timeout: turnTimeout } : undefined);
+            results.set(resultKey, result);
+            this.syncState();
+            this.state.turnHistory = [
+                ...this.state.turnHistory,
+                { agent: name, round: this.state.round, action: `${phase}_turn`, timestamp: Date.now() },
+            ];
         }
+        catch (error) {
+            const timedOut = turnTimeout !== undefined && turnTimeout > 0 && Date.now() - startedAt >= turnTimeout;
+            if (!timedOut)
+                throw error;
+            this.syncState();
+            this.state.turnHistory = [
+                ...this.state.turnHistory,
+                { agent: name, round: this.state.round, action: 'turn_skipped', timestamp: Date.now() },
+            ];
+            this.coordinator.events.emit('negotiation:turn', { agent: name, round: this.state.round, phase, skipped: true, reason: 'timeout' }, name);
+        }
+        this.state.lastActivityAt = Date.now();
+        this.updateBlackboard();
+        await this.reviewNewActivity();
     }
     async runInitializationPhase(options, agents, results) {
         this.state.phase = 'initialization';
@@ -102,15 +170,13 @@ export class NegotiationStrategy extends BaseStrategy {
         this.coordinator.events.emit('negotiation:phase-change', { phase: 'initialization' }, 'system');
         const initPrompt = this.buildInitializationPrompt(options.input);
         for (const agent of agents) {
-            const result = await this.coordinator.runAgent(agent.agent.name, initPrompt, this.buildAgentContext(agent, options));
-            results.set(`${agent.agent.name}_init`, result);
-            this.state.turnHistory.push({
-                agent: agent.agent.name,
-                round: 0,
-                action: 'declared_interests',
-                timestamp: Date.now(),
-            });
+            await this.runTurn(agent, initPrompt, options, 'init', results, `${agent.agent.name}_init`);
+            this.state.turnHistory = [
+                ...this.state.turnHistory,
+                { agent: agent.agent.name, round: 0, action: 'declared_interests', timestamp: Date.now() },
+            ];
         }
+        this.state.currentTurn = null;
         this.state.lastActivityAt = Date.now();
         this.updateBlackboard();
     }
@@ -120,12 +186,8 @@ export class NegotiationStrategy extends BaseStrategy {
         this.coordinator.events.emit('negotiation:phase-change', { phase: 'proposal', round: this.state.round }, 'system');
         const proposalPrompt = this.buildProposalPrompt(options.input);
         for (const agent of agents) {
-            this.state.currentTurn = agent.agent.name;
-            this.turnManager.startTurn();
-            this.updateBlackboard();
             this.coordinator.events.emit('negotiation:turn', { agent: agent.agent.name, round: this.state.round, phase: 'proposal' }, agent.agent.name);
-            const result = await this.coordinator.runAgent(agent.agent.name, proposalPrompt, this.buildAgentContext(agent, options));
-            results.set(`${agent.agent.name}_proposal_r${this.state.round}`, result);
+            await this.runTurn(agent, proposalPrompt, options, 'proposal', results, `${agent.agent.name}_proposal_r${this.state.round}`);
             this.turnManager.advance();
         }
         this.state.currentTurn = null;
@@ -144,18 +206,11 @@ export class NegotiationStrategy extends BaseStrategy {
         }
         const counterPrompt = this.buildCounterPrompt(options.input);
         for (const agent of agents) {
-            const offersToAgent = pendingOffers.filter((o) => {
-                const recipients = Array.isArray(o.to) ? o.to : [o.to];
-                return recipients.includes(agent.agent.name);
-            });
+            const offersToAgent = this.state.offers.filter((o) => o.status === 'pending' && this.isRecipient(o, agent.agent.name));
             if (offersToAgent.length === 0)
                 continue;
-            this.state.currentTurn = agent.agent.name;
-            this.turnManager.startTurn();
-            this.updateBlackboard();
             this.coordinator.events.emit('negotiation:turn', { agent: agent.agent.name, round: this.state.round, phase: 'counter' }, agent.agent.name);
-            const result = await this.coordinator.runAgent(agent.agent.name, counterPrompt, this.buildAgentContext(agent, options));
-            results.set(`${agent.agent.name}_counter_r${this.state.round}`, result);
+            await this.runTurn(agent, counterPrompt, options, 'counter', results, `${agent.agent.name}_counter_r${this.state.round}`);
             this.turnManager.advance();
         }
         this.state.currentTurn = null;
@@ -164,69 +219,145 @@ export class NegotiationStrategy extends BaseStrategy {
     }
     async runRefinementPhase(options, agents, results, suggestion) {
         this.state.phase = 'refinement';
+        const mediationOffer = {
+            id: `mediation_${nanoid(10)}`,
+            from: MEDIATOR_ID,
+            to: agents.map((a) => a.agent.name),
+            terms: suggestion.suggestedTerms,
+            reasoning: suggestion.rationale,
+            timestamp: Date.now(),
+            status: 'pending',
+            round: this.state.round,
+            phase: 'refinement',
+        };
+        this.state.offers = [
+            ...this.state.offers.map((o) => o.from === MEDIATOR_ID && o.status === 'pending'
+                ? { ...o, status: 'withdrawn' }
+                : o),
+            mediationOffer,
+        ];
+        this.reviewedOfferIds.add(mediationOffer.id);
         this.updateBlackboard();
         this.coordinator.events.emit('negotiation:phase-change', { phase: 'refinement', round: this.state.round }, 'system');
-        const refinementPrompt = this.buildRefinementPrompt(options.input, suggestion);
+        const refinementPrompt = this.buildRefinementPrompt(options.input, suggestion, mediationOffer.id);
         for (const agent of agents) {
-            this.state.currentTurn = agent.agent.name;
-            this.updateBlackboard();
-            const result = await this.coordinator.runAgent(agent.agent.name, refinementPrompt, this.buildAgentContext(agent, options));
-            results.set(`${agent.agent.name}_refinement_r${this.state.round}`, result);
+            await this.runTurn(agent, refinementPrompt, options, 'refinement', results, `${agent.agent.name}_refinement_r${this.state.round}`);
         }
         this.state.currentTurn = null;
         this.state.lastActivityAt = Date.now();
         this.updateBlackboard();
     }
-    async checkForAgreement() {
-        const acceptedOffers = this.state.offers.filter((o) => o.status === 'accepted');
-        if (acceptedOffers.length === 0)
-            return false;
-        const latestAccepted = acceptedOffers.sort((a, b) => b.timestamp - a.timestamp)[0];
-        const allPartiesAccepted = this.checkAllPartiesAccepted(latestAccepted);
-        if (!allPartiesAccepted)
-            return false;
-        const agreement = this.buildAgreement(latestAccepted);
-        this.state.agreement = agreement;
-        if (this.approvalIntegration) {
-            const gate = this.approvalIntegration.shouldTriggerApproval('agreement-reached', this.state, {
-                agreement,
+    /**
+     * Pick up changes made by negotiation tools during the last turn and expire stale offers.
+     */
+    syncState() {
+        const latest = readNegotiationState(this.coordinator.blackboard);
+        if (latest?.negotiationId === this.state.negotiationId) {
+            this.state = {
+                ...latest,
+                offers: [...latest.offers],
+                coalitions: [...latest.coalitions],
+                turnHistory: [...latest.turnHistory],
+                convergenceHistory: [...latest.convergenceHistory],
+                interests: { ...latest.interests },
+            };
+        }
+        const now = Date.now();
+        this.state.offers = this.state.offers.map((offer) => {
+            if (offer.status !== 'pending' || !isOfferExpired(offer, now))
+                return offer;
+            this.coordinator.events.emit('negotiation:offer-expired', { offerId: offer.id, from: offer.from }, 'system');
+            return { ...offer, status: 'expired' };
+        });
+    }
+    /**
+     * Route new offers and newly formed coalitions through the configured approval gates.
+     */
+    async reviewNewActivity() {
+        const newOffers = this.state.offers.filter((o) => !this.reviewedOfferIds.has(o.id));
+        const newCoalitions = this.state.coalitions.filter((c) => c.status === 'active' && !this.reviewedCoalitionIds.has(c.id));
+        for (const offer of newOffers)
+            this.reviewedOfferIds.add(offer.id);
+        for (const coalition of newCoalitions)
+            this.reviewedCoalitionIds.add(coalition.id);
+        if (!this.approvalIntegration)
+            return;
+        for (const offer of newOffers) {
+            const gate = this.approvalIntegration.shouldTriggerApproval('high-value-term', this.state, {
+                offer,
             });
-            if (gate) {
-                this.state.phase = 'agreement';
+            if (!gate)
+                continue;
+            const response = await this.approvalIntegration.requestApproval(gate, this.state, this.coordinator.events, { offer });
+            if (!response.approved) {
+                this.syncState();
+                this.state.offers = this.state.offers.map((o) => o.id === offer.id && o.status === 'pending' ? { ...o, status: 'withdrawn' } : o);
+                this.updateBlackboard();
+            }
+        }
+        for (const coalition of newCoalitions) {
+            const gate = this.approvalIntegration.shouldTriggerApproval('coalition-formed', this.state);
+            if (!gate)
+                continue;
+            const response = await this.approvalIntegration.requestApproval(gate, this.state, this.coordinator.events);
+            if (!response.approved) {
+                this.syncState();
+                this.state.coalitions = this.state.coalitions.map((c) => c.id === coalition.id ? { ...c, status: 'dissolved' } : c);
                 this.updateBlackboard();
-                const response = await this.approvalIntegration.requestApproval(gate, this.state, this.coordinator.events, { agreement });
-                if (!response.approved) {
-                    this.state.agreement = undefined;
-                    if (response.continueNegotiation) {
-                        return false;
+                this.coordinator.events.emit('negotiation:coalition-dissolved', { coalitionId: coalition.id, reason: 'approval_rejected' }, 'system');
+            }
+        }
+    }
+    isRecipient(offer, agentName) {
+        return (Array.isArray(offer.to) ? offer.to : [offer.to]).includes(agentName);
+    }
+    meetsQuorum(offer) {
+        const quorum = this.config.quorum;
+        if (quorum === undefined || quorum <= 0)
+            return true;
+        const required = quorum <= 1 ? Math.ceil(quorum * this.agentNames.length) : Math.ceil(quorum);
+        return new Set(offerParties(offer)).size >= required;
+    }
+    async checkForAgreement() {
+        const candidates = this.state.offers
+            .filter((o) => o.status === 'accepted' && isFullyAccepted(this.state, o))
+            .filter((o) => this.meetsQuorum(o))
+            .sort((a, b) => b.timestamp - a.timestamp);
+        for (const offer of candidates) {
+            const agreement = this.buildAgreement(offer);
+            if (this.approvalIntegration) {
+                const gate = this.approvalIntegration.shouldTriggerApproval('agreement-reached', this.state, { agreement });
+                if (gate) {
+                    this.state.phase = 'agreement';
+                    this.updateBlackboard();
+                    const response = await this.approvalIntegration.requestApproval(gate, this.state, this.coordinator.events, { agreement });
+                    if (!response.approved) {
+                        this.state.offers = this.state.offers.map((o) => o.id === offer.id ? { ...o, status: 'withdrawn' } : o);
+                        this.updateBlackboard();
+                        continue;
                     }
-                    return false;
+                    agreement.approvalStatus = 'approved';
+                    agreement.approvalResponse = {
+                        approvedBy: response.respondedBy,
+                        approvedAt: response.respondedAt,
+                        comment: response.comment,
+                    };
                 }
-                agreement.approvalStatus = 'approved';
-                agreement.approvalResponse = {
-                    approvedBy: response.respondedBy,
-                    approvedAt: response.respondedAt,
-                    comment: response.comment,
-                };
             }
+            this.state.agreement = agreement;
+            this.state.phase = 'agreement';
+            this.updateBlackboard();
+            return true;
         }
-        this.coordinator.events.emit('negotiation:agreement-reached', { agreement }, 'system');
-        return true;
-    }
-    checkAllPartiesAccepted(offer) {
-        const recipients = Array.isArray(offer.to) ? offer.to : [offer.to];
-        return recipients.every((recipient) => {
-            const acceptance = this.state.offers.find((o) => o.from === recipient && o.inResponseTo === offer.id && o.status === 'accepted');
-            return !!acceptance;
-        });
+        return false;
     }
     buildAgreement(offer) {
-        const recipients = Array.isArray(offer.to) ? offer.to : [offer.to];
-        const parties = [offer.from, ...recipients];
         const relatedOfferIds = [offer.id];
+        const visited = new Set(relatedOfferIds);
         let current = offer;
-        while (current.inResponseTo) {
+        while (current.inResponseTo && !visited.has(current.inResponseTo)) {
             relatedOfferIds.push(current.inResponseTo);
+            visited.add(current.inResponseTo);
             const parent = this.state.offers.find((o) => o.id === current.inResponseTo);
             if (!parent)
                 break;
@@ -234,33 +365,32 @@ export class NegotiationStrategy extends BaseStrategy {
         }
         return {
             id: `agreement_${nanoid(12)}`,
-            parties,
+            parties: Array.from(new Set(offerParties(offer))),
             terms: offer.terms,
-            reachedVia: 'consensus',
+            reachedVia: offer.from === MEDIATOR_ID ? 'compromise' : 'consensus',
             timestamp: Date.now(),
             sourceOffers: relatedOfferIds,
             requiresApproval: !!this.approvalIntegration,
         };
     }
-    isDeadlocked() {
+    isDeadlocked(round) {
         const latestMetrics = this.state.convergenceHistory[this.state.convergenceHistory.length - 1];
         if (!latestMetrics)
             return false;
-        if (latestMetrics.roundsWithoutProgress >= (this.config.maxRoundsWithoutProgress ?? 3)) {
+        const mediationFailed = this.lastMediationRound !== undefined && this.lastMediationRound < round;
+        if (mediationFailed &&
+            latestMetrics.roundsWithoutProgress >= (this.config.maxRoundsWithoutProgress ?? 3)) {
             return true;
         }
-        if (latestMetrics.convergenceTrend === 'declining' && latestMetrics.overallConvergence < 0.2) {
-            return true;
-        }
-        return false;
+        return latestMetrics.convergenceTrend === 'declining' && latestMetrics.overallConvergence < 0.2;
     }
-    async handleDeadlock(options, agents, results) {
+    async handleDeadlock(options, results) {
         this.state.phase = 'deadlock';
         this.updateBlackboard();
         this.coordinator.events.emit('negotiation:deadlock', { round: this.state.round, offers: this.state.offers.length }, 'system');
         switch (this.config.onDeadlock) {
             case 'escalate':
-                return this.escalate(options, agents, results);
+                return this.escalate(results);
             case 'supervisor-decides': {
                 const supervisors = this.coordinator.getAgentsByRole('supervisor');
                 if (supervisors.length > 0) {
@@ -277,7 +407,7 @@ export class NegotiationStrategy extends BaseStrategy {
                 return this.finalizeResult(results, 'deadlock');
         }
     }
-    async escalate(_options, _agents, results) {
+    async escalate(results) {
         this.state.phase = 'escalation';
         this.updateBlackboard();
         this.coordinator.events.emit('negotiation:escalation', { reason: 'deadlock', round: this.state.round }, 'system');
@@ -307,7 +437,9 @@ export class NegotiationStrategy extends BaseStrategy {
     }
     majorityRules(results) {
         const latestOffers = new Map();
-        for (const offer of this.state.offers) {
+        for (const offer of [...this.state.offers].sort((a, b) => a.timestamp - b.timestamp)) {
+            if (offer.from === MEDIATOR_ID)
+                continue;
             if (offer.status === 'pending' || offer.status === 'accepted') {
                 latestOffers.set(offer.from, offer);
             }
@@ -315,10 +447,11 @@ export class NegotiationStrategy extends BaseStrategy {
         const termVotes = new Map();
         for (const offer of latestOffers.values()) {
             for (const term of offer.terms) {
-                if (!termVotes.has(term.termId)) {
-                    termVotes.set(term.termId, new Map());
+                let valueVotes = termVotes.get(term.termId);
+                if (!valueVotes) {
+                    valueVotes = new Map();
+                    termVotes.set(term.termId, valueVotes);
                 }
-                const valueVotes = termVotes.get(term.termId);
                 const valueKey = JSON.stringify(term.value);
                 valueVotes.set(valueKey, (valueVotes.get(valueKey) ?? 0) + 1);
             }
@@ -337,15 +470,12 @@ export class NegotiationStrategy extends BaseStrategy {
                 .flatMap((o) => o.terms)
                 .find((t) => t.termId === termId);
             if (sampleTerm) {
-                majorityTerms.push({
-                    ...sampleTerm,
-                    value: winningValue,
-                });
+                majorityTerms.push({ ...sampleTerm, value: winningValue });
             }
         }
         const agreement = {
             id: `agreement_${nanoid(12)}`,
-            parties: Array.from(latestOffers.keys()),
+            parties: [...this.agentNames],
             terms: majorityTerms,
             reachedVia: 'majority',
             timestamp: Date.now(),
@@ -358,14 +488,14 @@ export class NegotiationStrategy extends BaseStrategy {
     }
     arbitrate(results) {
         this.coordinator.events.emit('negotiation:arbitration', { round: this.state.round }, 'system');
-        const pendingOffers = this.state.offers.filter((o) => o.status === 'pending' || o.status === 'countered');
-        if (pendingOffers.length === 0) {
+        const openOffers = this.state.offers.filter((o) => o.status === 'pending' || o.status === 'countered');
+        if (openOffers.length === 0) {
             return this.finalizeResult(results, 'deadlock');
         }
-        const arbitrationResult = this.performArbitration(pendingOffers);
+        const arbitrationResult = this.performArbitration(openOffers);
         const agreement = {
             id: `agreement_${nanoid(12)}`,
-            parties: Object.keys(this.state.interests),
+            parties: [...this.agentNames],
             terms: arbitrationResult.proposal.terms,
             reachedVia: 'arbitration',
             timestamp: Date.now(),
@@ -390,10 +520,12 @@ export class NegotiationStrategy extends BaseStrategy {
                 continue;
             const numericValues = termValues.filter((t) => typeof t.value === 'number');
             if (numericValues.length > 0) {
-                const totalWeight = numericValues.reduce((s, t) => s + t.priority, 0);
-                const weightedAvg = numericValues.reduce((s, t) => s + (t.value * t.priority) / totalWeight, 0);
+                const totalWeight = numericValues.reduce((s, t) => s + Math.max(t.priority, 0), 0);
+                const weightedAvg = totalWeight > 0
+                    ? numericValues.reduce((s, t) => s + (t.value * Math.max(t.priority, 0)) / totalWeight, 0)
+                    : numericValues.reduce((s, t) => s + t.value, 0) / numericValues.length;
                 arbitratedTerms.push({
-                    ...termValues[0],
+                    ...numericValues[0],
                     value: Math.round(weightedAvg * 100) / 100,
                     negotiable: false,
                 });
@@ -408,7 +540,7 @@ export class NegotiationStrategy extends BaseStrategy {
         const arbitratedOffer = {
             id: `arbitration_${nanoid(8)}`,
             from: 'arbitrator',
-            to: Object.keys(this.state.interests),
+            to: [...this.agentNames],
             terms: arbitratedTerms,
             reasoning: 'Terms determined by weighted average arbitration',
             timestamp: Date.now(),
@@ -435,7 +567,9 @@ export class NegotiationStrategy extends BaseStrategy {
             rounds: this.state.round,
             duration: Date.now() - this.state.startedAt,
         };
-        this.coordinator.events.emit(outcome === 'agreement' ? 'negotiation:agreement-reached' : 'negotiation:terminated', { result: negotiationResult }, 'system');
+        this.coordinator.events.emit(outcome === 'agreement' ? 'negotiation:agreement-reached' : 'negotiation:terminated', outcome === 'agreement'
+            ? { agreement: this.state.agreement, result: negotiationResult }
+            : { result: negotiationResult }, 'system');
         const output = this.buildFinalOutput(negotiationResult);
         return {
             output,
@@ -445,11 +579,10 @@ export class NegotiationStrategy extends BaseStrategy {
     }
     getFinalPositions() {
         const positions = {};
-        for (const agentName of Object.keys(this.state.interests)) {
-            const lastOffer = this.state.offers
+        for (const agentName of this.agentNames) {
+            positions[agentName] = this.state.offers
                 .filter((o) => o.from === agentName)
                 .sort((a, b) => b.timestamp - a.timestamp)[0];
-            positions[agentName] = lastOffer;
         }
         return positions;
     }
@@ -487,7 +620,7 @@ export class NegotiationStrategy extends BaseStrategy {
         return output;
     }
     updateBlackboard() {
-        this.coordinator.blackboard.write('negotiation', this.state, 'system');
+        this.coordinator.blackboard.write(NEGOTIATION_SECTION, { ...this.state }, 'system');
     }
     buildAgentContext(agent, options) {
         return {
@@ -547,7 +680,7 @@ Your task is to:
 Consider carefully which terms you can accept and which need modification. A counter-offer should move toward agreement while protecting your interests.
 `.trim();
     }
-    buildRefinementPrompt(topic, suggestion) {
+    buildRefinementPrompt(topic, suggestion, mediationOfferId) {
         const termsDescription = suggestion.suggestedTerms
             .map((t) => `  - ${t.label}: ${JSON.stringify(t.value)}`)
             .join('\n');
@@ -567,10 +700,12 @@ ${termsDescription}
 
 Rationale: ${suggestion.rationale}
 
-Please consider this compromise proposal. You may:
-1. Accept the suggested terms using 'accept_offer' if acceptable
-2. Make a counter-proposal using 'counter_offer' with minor modifications
-3. Reject and explain why using 'reject_offer'
+The compromise has been submitted as offer "${mediationOfferId}". You may:
+1. Accept it using 'accept_offer' with offerId "${mediationOfferId}" if acceptable
+2. Make a counter-proposal using 'counter_offer' (inResponseTo "${mediationOfferId}") with minor modifications
+3. Reject it using 'reject_offer' and explain why
+
+Agreement is reached when every party accepts the compromise.
 
 The goal is to break the deadlock and move toward agreement.
 `.trim();