@indexnetwork/protocol 11.0.2-rc.456.1 → 11.2.0-rc.458.1

package/dist/negotiation/application/negotiation.graph.js

@@ -9,9 +9,11 @@ import { blocksNegotiationBeforeFirstTurn, NegotiationScreener } from "./negotia
 import { configuredScreenMode } from "../domain/negotiation.screen.contracts.js";
 import { assessDeadlock, configuredDeadlockShiftEnabled, configuredDeadlockThreshold } from "../domain/negotiation.deadlock.js";
 import { protocolLogger } from "../../shared/observability/protocol.logger.js";
-import { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, negotiationQuestionSettlementId, validateInflightAskUserFields } from '../domain/negotiation.question-safety.js';
+import { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, negotiationQuestionSettlementId } from '../domain/negotiation.question-safety.js';
 import { buildIntentSnapshots } from "../domain/negotiation.intent-snapshot-provenance.js";
 import { holdsNegotiationConversationLock } from "../domain/negotiation.task-lock-policy.js";
+import { isNegotiationTurnCapReached } from "../domain/negotiation.turn-cap.js";
+import { expectedNegotiationSpeaker } from "../domain/negotiation.expected-speaker.js";
 import { attributedDialogueIsEmpty, buildSeededAttribution, combineAttributedDialogue } from '../negotiation.attribution.js';
 const logger = protocolLogger("NegotiationGraph");
 const initLog = protocolLogger("NegotiationGraph:Init");
@@ -196,22 +198,15 @@ export class NegotiationGraphFactory {
                 // --- Load prior messages and determine continuation ---
                 const priorTurns = turnsFromMessages(priorMessages);
                 const isContinuation = priorTurns.length > 0;
-                // Determine currentSpeaker from last prior message. An `ask_user` last
-                // turn does NOT pass the floor: the sender paused to consult its own
-                // client, so on resume the same side speaks again — now armed with the
-                // client's answer (or its recorded absence). Flipping here would hand
-                // the turn to the counterparty, who has nothing to respond to.
-                let currentSpeaker = 'source';
-                if (isContinuation && priorMessages.length > 0) {
-                    const lastMessage = priorMessages[priorMessages.length - 1];
-                    const lastAction = turnsFromMessages([lastMessage])[0]?.action;
-                    if (lastAction === 'ask_user') {
-                        currentSpeaker = lastMessage.senderId === agentIdA ? 'source' : 'candidate';
-                    }
-                    else {
-                        currentSpeaker = lastMessage.senderId === agentIdA ? 'candidate' : 'source';
-                    }
-                }
+                const expectedSpeaker = expectedNegotiationSpeaker({
+                    sourceUserId: state.sourceUser.id,
+                    candidateUserId: state.candidateUser.id,
+                }, priorMessages);
+                if (!expectedSpeaker)
+                    return { error: 'invalid negotiation participants' };
+                const currentSpeaker = expectedSpeaker === state.sourceUser.id
+                    ? 'source'
+                    : 'candidate';
                 // Determine scenario-based maxTurns
                 const scope = { action: 'manage:negotiations', scopeType: 'network', scopeId: state.indexContext.networkId };
                 const [sourceHasAgent, candidateHasAgent] = await Promise.all([
@@ -485,9 +480,8 @@ export class NegotiationGraphFactory {
                 const ownUser = isSource ? state.sourceUser : state.candidateUser;
                 const otherUser = isSource ? state.candidateUser : state.sourceUser;
                 const ownIntentId = isSource ? state.sourceIntentId : state.candidateIntentId;
-                // Determine if this is the system agent's final allowed turn
-                const maxTurns = state.maxTurns ?? 0;
-                const isFinalTurn = maxTurns > 0 && (state.turnCount + 1) >= maxTurns;
+                // Determine if this is the system agent's final allowed turn.
+                const isFinalTurn = isNegotiationTurnCapReached(state.turnCount + 1, state.maxTurns);
                 // Seat attribution keys on initiatorUserId (rigid v2 stamp), never on
                 // parity or source/candidate position — under the conversation-scoped
                 // tie-break this run's source may hold the counterparty seat.
@@ -558,6 +552,17 @@ export class NegotiationGraphFactory {
                     ...(state.privateConsultation?.recipientUserId === ownUser.id
                         ? { privateConsultation: state.privateConsultation }
                         : {}),
+                    ...(state.continuationExecution
+                        ? {
+                            timeoutContinuation: {
+                                priorTaskId: state.continuationExecution.taskId,
+                                settlementId: state.continuationExecution.settlementId,
+                                successorTaskId: state.continuationExecution.successorTaskId,
+                                token: state.continuationExecution.token,
+                                fence: state.continuationExecution.fence,
+                            },
+                        }
+                        : {}),
                 };
                 const scope = { action: 'manage:negotiations', scopeType: 'network', scopeId: state.indexContext.networkId };
                 const dispatchResult = await dispatcher.dispatch(ownUser.id, scope, payload, { timeoutMs: state.timeoutMs });
@@ -595,7 +600,7 @@ export class NegotiationGraphFactory {
                             ? { privateConsultation: state.privateConsultation }
                             : {}),
                     }, state.continuationExecution);
-                    await database.updateTaskState(state.taskId, "waiting_for_agent", undefined, state.continuationExecution);
+                    await database.updateTaskState(state.taskId, "waiting_for_agent", undefined, state.continuationExecution, dispatchResult.resumeToken);
                     return { status: 'waiting_for_agent' };
                 }
                 else {
@@ -703,7 +708,7 @@ export class NegotiationGraphFactory {
                                 reasoning: 'Client consultation required.',
                                 suggestedRoles: turn.assessment.suggestedRoles,
                             },
-                            askUser: consultationPromptFor(consultationPolicyReason),
+                            askUser: { reason: consultationPolicyReason },
                         };
                         emitConsultationTelemetry('asked', consultationPolicyReason);
                     }
@@ -775,27 +780,10 @@ export class NegotiationGraphFactory {
                 // like the waiting_for_agent suspend; the answer (or window expiry)
                 // resumes via the run-existing continuation path.
                 if (turn.action === 'ask_user') {
-                    const counterparty = isSource ? state.candidateUser : state.sourceUser;
-                    const safeAskUser = validateInflightAskUserFields({
-                        disclosureSubject: turn.askUser?.disclosureSubject,
-                        draftQuestion: turn.askUser?.draftQuestion,
-                        forbiddenIdentifiers: [
-                            counterparty.id,
-                            counterparty.profile.name ?? '',
-                            state.opportunityId,
-                            state.taskId,
-                            state.indexContext.networkId,
-                            isSource ? state.candidateIntentId ?? '' : state.sourceIntentId ?? '',
-                        ],
-                        forbiddenSourceText: [
-                            counterparty.profile.bio ?? '',
-                            counterparty.profile.location ?? '',
-                            ...counterparty.intents.flatMap((intent) => [intent.title, intent.description]),
-                            state.seedAssessment.reasoning,
-                            state.indexContext.prompt,
-                            state.discoveryQuery ?? '',
-                        ],
-                    });
+                    const consultationReason = turn.askUser?.reason;
+                    const safeAskUser = consultationReason
+                        ? consultationPromptFor(consultationReason)
+                        : null;
                     const settlementId = negotiationQuestionSettlementId(state.taskId);
                     const askUserBinding = await database.captureNegotiationAskUserBinding({
                         taskId: state.taskId,
@@ -810,7 +798,7 @@ export class NegotiationGraphFactory {
                             indexContext: state.indexContext,
                             seedAssessment: state.seedAssessment,
                             ...(isSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
-                            ...(consultationPolicyReason && { consultationPolicyReason }),
+                            ...(consultationReason && { consultationPolicyReason: consultationReason }),
                         },
                         ...(state.continuationExecution ? { continuationExecution: state.continuationExecution } : {}),
                     });
@@ -852,10 +840,8 @@ export class NegotiationGraphFactory {
                             context: {
                                 negotiationId: state.taskId,
                                 counterpartyHint: NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY,
-                                disclosureSubject: safeAskUser.disclosureSubject,
-                                ...(safeAskUser.draftQuestion && { draftQuestion: safeAskUser.draftQuestion }),
                                 indexContext: NEGOTIATION_QUESTION_GENERIC_NETWORK,
-                                ...(consultationPolicyReason && { consultationPolicyReason }),
+                                consultationPolicyReason: consultationReason,
                                 ...(userContext && { userContext }),
                             },
                         }).catch((error) => {
@@ -965,7 +951,7 @@ export class NegotiationGraphFactory {
             if (isTerminalAction(state.lastTurn.action))
                 return "finalize";
             // question routes same as counter — next turn
-            if ((state.maxTurns ?? 0) > 0 && state.turnCount >= state.maxTurns)
+            if (isNegotiationTurnCapReached(state.turnCount, state.maxTurns))
                 return "finalize";
             return "turn";
         };
@@ -1038,7 +1024,7 @@ export class NegotiationGraphFactory {
             const blockedByScreenNode = blocksNegotiationBeforeFirstTurn(state.screenDecision, state.turnCount);
             const refusedAtOpeningTurn = state.firstTurnScreenedOut === true;
             const screenedOut = blockedByScreenNode || refusedAtOpeningTurn;
-            const atCap = !screenedOut && (state.maxTurns ?? 0) > 0 && state.turnCount >= state.maxTurns && !isTerminalAction(lastTurn?.action);
+            const atCap = !screenedOut && isNegotiationTurnCapReached(state.turnCount, state.maxTurns) && !isTerminalAction(lastTurn?.action);
             let agreedRoles = [];
             if (hasOpportunity && history.length >= 2) {
                 const acceptTurn = history[history.length - 1];

package/dist/negotiation/application/negotiation.tools.js

@@ -7,6 +7,8 @@ import { protocolLogger } from '../../shared/observability/protocol.logger.js';
 import { focusedIntentId, focusedNetworkId } from '../../shared/agent/tool.scope.js';
 import { readAuthorizedNegotiationDetail } from './negotiation.detail-reader.js';
 import { buildLifecycleNarration } from '../domain/negotiation.lifecycle-narration.js';
+import { isNegotiationTurnCapReached } from '../domain/negotiation.turn-cap.js';
+import { expectedNegotiationSpeaker } from '../domain/negotiation.expected-speaker.js';
 export { buildLifecycleNarration } from '../domain/negotiation.lifecycle-narration.js';
 const logger = protocolLogger('ChatTools:Negotiation');
 /**
@@ -154,21 +156,14 @@ export function createNegotiationTools(defineTool, deps) {
                     const lastTurnData = lastMessage
                         ? lastMessage.parts?.find(p => p.kind === 'data')?.data
                         : undefined;
-                    // Determine whose turn it is from the last message's sender — not
-                    // parity, which misattributes across continuation sessions. Rows
-                    // without senderId (legacy) fall back to parity.
                     const turnCount = messages.length;
-                    const lastSenderId = turnCount > 0 ? messages[turnCount - 1].senderId : null;
-                    const currentSpeaker = lastSenderId
-                        ? (lastSenderId === `agent:${meta.sourceUserId}` ? 'candidate' : 'source')
-                        : (turnCount % 2 === 0 ? 'source' : 'candidate');
+                    const expectedSpeaker = expectedNegotiationSpeaker(meta, messages);
                     // Map task state to tool status
                     const status = task.state === 'working' ? 'active'
                         : task.state === 'waiting_for_agent' ? 'waiting_for_agent'
                             : task.state === 'completed' ? 'completed'
                                 : task.state;
-                    const isUsersTurn = status !== 'completed' &&
-                        ((isSource && currentSpeaker === 'source') || (!isSource && currentSpeaker === 'candidate'));
+                    const isUsersTurn = status !== 'completed' && expectedSpeaker === context.userId;
                     const base = {
                         id: task.id,
                         counterpartyId: counterpartyId ?? 'unknown',
@@ -355,6 +350,15 @@ export function createNegotiationTools(defineTool, deps) {
                 if (meta?.type !== 'negotiation') {
                     return error('Negotiation not found.');
                 }
+                const timeoutContinuation = meta.continuationExecution
+                    ? {
+                        priorTaskId: meta.continuationExecution.priorTaskId,
+                        settlementId: meta.continuationExecution.settlementId,
+                        successorTaskId: meta.continuationExecution.successorTaskId,
+                        token: meta.continuationExecution.token,
+                        fence: meta.continuationExecution.fence,
+                    }
+                    : undefined;
                 // Network-scope check (mirrors get_negotiation): a network-bound agent
                 // must not act on negotiations outside its bound network.
                 const scopedNetworkId = focusedNetworkId(context);
@@ -382,17 +386,10 @@ export function createNegotiationTools(defineTool, deps) {
                 if (!allowedActionsFor(protocolVersion, seat).includes(query.action)) {
                     return error(seatViolationMessage(query.action, seat, protocolVersion));
                 }
-                // Determine whose turn it is from the last message's sender — not
-                // parity, which misattributes across continuation sessions. Rows
-                // without senderId (legacy) fall back to the parity heuristic.
                 const messages = await negotiationDatabase.getMessagesForConversation(task.conversationId);
                 const turnCount = messages.length;
-                const lastSenderId = turnCount > 0 ? messages[turnCount - 1].senderId : null;
-                const paritySpeaker = turnCount % 2 === 0 ? 'source' : 'candidate';
-                const isUsersTurn = lastSenderId
-                    ? lastSenderId !== `agent:${context.userId}`
-                    : ((isSource && paritySpeaker === 'source') || (!isSource && paritySpeaker === 'candidate'));
-                if (!isUsersTurn) {
+                const expectedSpeaker = expectedNegotiationSpeaker(meta, messages);
+                if (expectedSpeaker !== context.userId) {
                     return error('It is not your turn to respond in this negotiation.');
                 }
                 // The caller is the current speaker (verified above).
@@ -402,8 +399,8 @@ export function createNegotiationTools(defineTool, deps) {
                     return error(`A message is required when using "${query.action}". Explain what you want to change or clarify.`);
                 }
                 // ── Cancel pending timeout ──
-                if (deps.negotiationTimeoutQueue) {
-                    await deps.negotiationTimeoutQueue.cancelTimeout(task.id);
+                if (deps.negotiationTimeoutQueue && meta.negotiationParkGeneration) {
+                    await deps.negotiationTimeoutQueue.cancelTimeout(task.id, meta.negotiationParkGeneration);
                 }
                 // ── Build and persist the external agent's turn ──
                 const turnData = {
@@ -451,8 +448,7 @@ export function createNegotiationTools(defineTool, deps) {
                     });
                 }
                 // ── Handle counter/question: check if under max turns ──
-                const maxTurns = meta.maxTurns ?? 6; // Read from task metadata; fallback to system default
-                if (newTurnCount >= maxTurns) {
+                if (isNegotiationTurnCapReached(newTurnCount, meta.maxTurns)) {
                     // Max turns reached — finalize with turn_cap
                     const allMessages = [...messages, { id: turnMessage.id, senderId: turnMessage.senderId, role: turnMessage.role, parts: turnMessage.parts, createdAt: turnMessage.createdAt }];
                     const history = turnsFromMessages(allMessages);
@@ -480,7 +476,7 @@ export function createNegotiationTools(defineTool, deps) {
                 // Build the current turn history for dispatcher payload
                 const allMessagesWithTurn = [...messages, { id: turnMessage.id, senderId: turnMessage.senderId, role: turnMessage.role, parts: turnMessage.parts, createdAt: turnMessage.createdAt }];
                 const historyForDispatch = turnsFromMessages(allMessagesWithTurn);
-                const isFinalTurn = newTurnCount + 1 >= maxTurns;
+                const isFinalTurn = isNegotiationTurnCapReached(newTurnCount + 1, meta.maxTurns);
                 const ownUserCtx = { id: counterpartyUserId, intents: [], profile: {} };
                 const otherUserCtx = { id: context.userId, intents: [], profile: {} };
                 const seedAssessment = { reasoning: 'Continued negotiation', valencyRole: 'peer' };
@@ -496,16 +492,15 @@ export function createNegotiationTools(defineTool, deps) {
                     seat: counterpartySeat,
                     protocolVersion,
                     allowedActions: [...allowedActionsFor(protocolVersion, counterpartySeat, isFinalTurn)],
+                    ...(timeoutContinuation ? { timeoutContinuation } : {}),
                 };
                 const scope = { action: 'negotiation.respond', scopeType: 'negotiation', scopeId: task.id };
                 const timeoutMs = AMBIENT_PARK_WINDOW_MS;
                 const dispatchResult = await deps.agentDispatcher?.dispatch(counterpartyUserId, scope, dispatchPayload, { timeoutMs });
                 if (dispatchResult?.handled === false && dispatchResult.reason === 'waiting') {
-                    // Counterparty's agent acknowledged — yield and wait
-                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent');
-                    if (deps.negotiationTimeoutQueue) {
-                        await deps.negotiationTimeoutQueue.enqueueTimeout(task.id, newTurnCount, timeoutMs);
-                    }
+                    // The dispatcher armed this exact generation before acknowledging;
+                    // persist that same token with the waiting state.
+                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent', undefined, undefined, dispatchResult.resumeToken);
                     return success({
                         message: `${query.action === 'question' ? 'Question' : query.action === 'propose' ? 'Proposal' : query.action === 'outreach' ? 'Outreach' : 'Counter-proposal'} submitted. Waiting for counterparty response.`,
                         negotiationId: task.id,
@@ -597,7 +592,7 @@ export function createNegotiationTools(defineTool, deps) {
                     });
                 }
                 // Counterparty countered/questioned — check if max turns reached
-                if (finalTurnCount >= maxTurns) {
+                if (isNegotiationTurnCapReached(finalTurnCount, meta.maxTurns)) {
                     const fullHistory = [...historyForDispatch, aiTurn];
                     const outcome = buildNegotiationOutcome(fullHistory, finalTurnCount, 'counter', meta.sourceUserId, meta.candidateUserId, counterpartySpeaker === 'source' ? 'candidate' : 'source');
                     await negotiationDatabase.updateTaskState(task.id, 'completed');
@@ -624,19 +619,22 @@ export function createNegotiationTools(defineTool, deps) {
                     indexContext: { networkId: '' },
                     seedAssessment,
                     history: [...historyForDispatch, aiTurn],
-                    isFinalTurn: finalTurnCount + 1 >= maxTurns,
+                    isFinalTurn: isNegotiationTurnCapReached(finalTurnCount + 1, meta.maxTurns),
                     isDiscoverer: true,
                     seat,
                     protocolVersion,
-                    allowedActions: [...allowedActionsFor(protocolVersion, seat, finalTurnCount + 1 >= maxTurns)],
+                    allowedActions: [...allowedActionsFor(protocolVersion, seat, isNegotiationTurnCapReached(finalTurnCount + 1, meta.maxTurns))],
+                    ...(timeoutContinuation ? { timeoutContinuation } : {}),
                 };
                 const userDispatchResult = await deps.agentDispatcher?.dispatch(context.userId, scope, userDispatchPayload, { timeoutMs });
                 if (!userDispatchResult || (userDispatchResult.handled === false && userDispatchResult.reason === 'no_agent')) {
-                    // No agent for user — set back to waiting_for_agent so they can use respond_to_negotiation
-                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent');
+                    // No agent for user — arm and persist one exact generation so they
+                    // can still use respond_to_negotiation while fallback is bounded.
+                    const parkGeneration = crypto.randomUUID();
                     if (deps.negotiationTimeoutQueue) {
-                        await deps.negotiationTimeoutQueue.enqueueTimeout(task.id, finalTurnCount, timeoutMs);
+                        await deps.negotiationTimeoutQueue.enqueueTimeout(task.id, finalTurnCount, timeoutMs, parkGeneration, timeoutContinuation);
                     }
+                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent', undefined, undefined, parkGeneration);
                     return success({
                         message: `${query.action === 'question' ? 'Question' : 'Counter'} submitted. Counterparty responded. Your turn to respond.`,
                         negotiationId: task.id,
@@ -647,11 +645,8 @@ export function createNegotiationTools(defineTool, deps) {
                     });
                 }
                 if (userDispatchResult.handled === false && userDispatchResult.reason === 'waiting') {
-                    // User's agent acknowledged — yield and wait
-                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent');
-                    if (deps.negotiationTimeoutQueue) {
-                        await deps.negotiationTimeoutQueue.enqueueTimeout(task.id, finalTurnCount, timeoutMs);
-                    }
+                    // The dispatcher armed this exact generation before acknowledging.
+                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent', undefined, undefined, userDispatchResult.resumeToken);
                     return success({
                         message: `${query.action === 'question' ? 'Question' : 'Counter'} submitted. Counterparty countered back. Waiting for your agent's response.`,
                         negotiationId: task.id,
@@ -693,7 +688,7 @@ export function createNegotiationTools(defineTool, deps) {
                             outcome,
                         });
                     }
-                    if (userTurnCount >= maxTurns) {
+                    if (isNegotiationTurnCapReached(userTurnCount, meta.maxTurns)) {
                         const fullHistory = [...historyForDispatch, aiTurn, userAgentTurn];
                         const outcome = buildNegotiationOutcome(fullHistory, userTurnCount, 'counter', meta.sourceUserId, meta.candidateUserId, isSource ? 'candidate' : 'source');
                         await negotiationDatabase.updateTaskState(task.id, 'completed');
@@ -712,11 +707,13 @@ export function createNegotiationTools(defineTool, deps) {
                             outcome,
                         });
                     }
-                    // User's agent countered/questioned — arm timeout for counterparty's next turn
-                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent');
+                    // User's agent countered/questioned — arm one exact generation for
+                    // the counterparty's next turn.
+                    const parkGeneration = crypto.randomUUID();
                     if (deps.negotiationTimeoutQueue) {
-                        await deps.negotiationTimeoutQueue.enqueueTimeout(task.id, userTurnCount, timeoutMs);
+                        await deps.negotiationTimeoutQueue.enqueueTimeout(task.id, userTurnCount, timeoutMs, parkGeneration, timeoutContinuation);
                     }
+                    await negotiationDatabase.updateTaskState(task.id, 'waiting_for_agent', undefined, undefined, parkGeneration);
                     return success({
                         message: `Your agent responded with ${userAgentTurn.action}. Waiting for counterparty.`,
                         negotiationId: task.id,

package/dist/negotiation/domain/index.d.ts

@@ -35,7 +35,12 @@ export { NEGOTIATOR_STANCES, DEFAULT_NEGOTIATOR_STANCE, configuredNegotiatorStan
 export type { NegotiatorStance } from "./negotiation.stance.contracts.js";
 export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "./negotiation.state.js";
 export type { NegotiationTurn, NegotiationOutcome, UserNegotiationContext, SeedAssessment, NegotiationGraphLike, NegotiationMessage, } from "./negotiation.state.js";
+export { DEFAULT_NEGOTIATION_MAX_TURNS, isNegotiationTurnCapReached, } from "./negotiation.turn-cap.js";
+export { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
+export type { NegotiationSpeakerParticipants, NegotiationSpeakerMessage, } from "./negotiation.expected-speaker.js";
 export { InitiatorTurnSchema, CounterpartyTurnSchema, FinalInitiatorTurnSchema, FinalCounterpartyTurnSchema, InitiatorAskUserTurnSchema, CounterpartyAskUserTurnSchema, allowedActionsFor, turnSchemaFor, isTerminalAction, isRejectLikeAction, fallbackActionFor, rejectActionFor, readProtocolVersion, configuredProtocolVersion, configuredAskUserEnabled, askUserAnswerWindowMs, ASK_USER_LOCK_SLACK_MS, DEFAULT_ASK_USER_WINDOW_MS, resolveSeat, seatViolationMessage, } from "./negotiation.protocol.js";
+export { HERMES_OWNER_DIRECTIVE, HERMES_SHARED_MESSAGE_TEMPLATES, HermesNegotiationActionSchema, HermesNegotiationResponseSchema, HermesOwnerDirectiveSchema, HermesRoleAlignmentSchema, allowedHermesActionsFor, buildHermesNegotiationTurn, } from "./negotiation.hermes-contract.js";
+export type { HermesNegotiationAction, HermesNegotiationResponse, HermesOwnerDirective, HermesRoleAlignment, } from "./negotiation.hermes-contract.js";
 export { configuredDeadlockShiftEnabled, configuredDeadlockThreshold, assessDeadlock, renderBargainingShiftSection, DEFAULT_DEADLOCK_THRESHOLD, MIN_DEADLOCK_THRESHOLD, } from "./negotiation.deadlock.js";
 export type { DeadlockAssessment } from "./negotiation.deadlock.js";
 export type { DeadlockShiftRecord } from "./negotiation.deadlock.contracts.js";

package/dist/negotiation/domain/index.js

@@ -36,7 +36,11 @@ export { NEGOTIATOR_STANCES, DEFAULT_NEGOTIATOR_STANCE, configuredNegotiatorStan
 // ── Graph state and DTOs ──────────────────────────────────────────────────────
 export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "./negotiation.state.js";
 // ── Protocol rules ────────────────────────────────────────────────────────────
+export { DEFAULT_NEGOTIATION_MAX_TURNS, isNegotiationTurnCapReached, } from "./negotiation.turn-cap.js";
+export { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
 export { InitiatorTurnSchema, CounterpartyTurnSchema, FinalInitiatorTurnSchema, FinalCounterpartyTurnSchema, InitiatorAskUserTurnSchema, CounterpartyAskUserTurnSchema, allowedActionsFor, turnSchemaFor, isTerminalAction, isRejectLikeAction, fallbackActionFor, rejectActionFor, readProtocolVersion, configuredProtocolVersion, configuredAskUserEnabled, askUserAnswerWindowMs, ASK_USER_LOCK_SLACK_MS, DEFAULT_ASK_USER_WINDOW_MS, resolveSeat, seatViolationMessage, } from "./negotiation.protocol.js";
+// ── Hermes structural response contract ──────────────────────────────────────
+export { HERMES_OWNER_DIRECTIVE, HERMES_SHARED_MESSAGE_TEMPLATES, HermesNegotiationActionSchema, HermesNegotiationResponseSchema, HermesOwnerDirectiveSchema, HermesRoleAlignmentSchema, allowedHermesActionsFor, buildHermesNegotiationTurn, } from "./negotiation.hermes-contract.js";
 // ── Deadlock detection ────────────────────────────────────────────────────────
 export { configuredDeadlockShiftEnabled, configuredDeadlockThreshold, assessDeadlock, renderBargainingShiftSection, DEFAULT_DEADLOCK_THRESHOLD, MIN_DEADLOCK_THRESHOLD, } from "./negotiation.deadlock.js";
 // ── Lifecycle narration ───────────────────────────────────────────────────────

package/dist/negotiation/domain/negotiation.consultation-policy.d.ts

@@ -1,8 +1,7 @@
-import type { NegotiationAction, NegotiationProtocolVersion, NegotiationSeat } from "../../shared/schemas/negotiation-state.schema.js";
+import type { NegotiationAction, NegotiationConsultationReason, NegotiationProtocolVersion, NegotiationSeat } from "../../shared/schemas/negotiation-state.schema.js";
+export type { NegotiationConsultationReason } from "../../shared/schemas/negotiation-state.schema.js";
 /** Independent rollout modes for IND-508's deterministic consultation policy. */
 export type NegotiationConsultationPolicyMode = "off" | "shadow" | "on";
-/** Stable, content-free categories emitted by the consultation funnel. */
-export type NegotiationConsultationReason = "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
 /** The only data the policy may inspect: action/role enums and routing coordinates. */
 export interface ConsultationEligibilityInput {
     protocolVersion: NegotiationProtocolVersion;

package/dist/negotiation/domain/negotiation.expected-speaker.d.ts

@@ -0,0 +1,19 @@
+export interface NegotiationSpeakerParticipants {
+    sourceUserId?: unknown;
+    candidateUserId?: unknown;
+}
+export interface NegotiationSpeakerMessage {
+    senderId?: unknown;
+    parts?: unknown;
+}
+/**
+ * Resolves the participant whose agent owns the next canonical bilateral turn.
+ *
+ * Participant identities must be nonempty and distinct. Unrelated agent,
+ * system, and owner-settlement messages are ignored while finding the latest
+ * source/candidate message. An ordinary canonical message passes the floor to
+ * the other participant; `ask_user` retains it for the consulting sender's
+ * exact successor. A valid conversation with no canonical history starts with
+ * the source participant. Invalid participant metadata always fails closed.
+ */
+export declare function expectedNegotiationSpeaker(participants: NegotiationSpeakerParticipants, messages: readonly NegotiationSpeakerMessage[]): string | null;

package/dist/negotiation/domain/negotiation.expected-speaker.js

@@ -0,0 +1,47 @@
+function canonicalAction(message) {
+    if (!Array.isArray(message.parts))
+        return null;
+    for (const part of message.parts) {
+        if (!part || typeof part !== 'object' || Array.isArray(part))
+            continue;
+        const partRecord = part;
+        if (partRecord.kind !== 'data' || !partRecord.data || typeof partRecord.data !== 'object' || Array.isArray(partRecord.data))
+            continue;
+        const action = partRecord.data.action;
+        return typeof action === 'string' ? action : null;
+    }
+    return null;
+}
+function participantId(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+/**
+ * Resolves the participant whose agent owns the next canonical bilateral turn.
+ *
+ * Participant identities must be nonempty and distinct. Unrelated agent,
+ * system, and owner-settlement messages are ignored while finding the latest
+ * source/candidate message. An ordinary canonical message passes the floor to
+ * the other participant; `ask_user` retains it for the consulting sender's
+ * exact successor. A valid conversation with no canonical history starts with
+ * the source participant. Invalid participant metadata always fails closed.
+ */
+export function expectedNegotiationSpeaker(participants, messages) {
+    const source = participantId(participants.sourceUserId);
+    const candidate = participantId(participants.candidateUserId);
+    if (!source || !candidate || source === candidate)
+        return null;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        const sender = message?.senderId === `agent:${source}`
+            ? source
+            : message?.senderId === `agent:${candidate}`
+                ? candidate
+                : null;
+        if (!sender)
+            continue;
+        return canonicalAction(message) === 'ask_user'
+            ? sender
+            : sender === source ? candidate : source;
+    }
+    return source;
+}

package/dist/negotiation/domain/negotiation.hermes-contract.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import type { NegotiationAction, NegotiationTurn } from '../../shared/schemas/negotiation-state.schema.js';
+/** Model-visible directives for the dedicated Hermes negotiation bridge. */
+export declare const HermesNegotiationActionSchema: z.ZodEnum<["accept", "decline", "request_time", "continue"]>;
+export type HermesNegotiationAction = z.infer<typeof HermesNegotiationActionSchema>;
+export declare const HermesRoleAlignmentSchema: z.ZodEnum<["peers", "owner_leads", "counterparty_leads"]>;
+export type HermesRoleAlignment = z.infer<typeof HermesRoleAlignmentSchema>;
+/**
+ * No model-authored prose is accepted at this boundary. Strict parsing also
+ * prevents model-selected run IDs or capabilities from entering tool arguments.
+ */
+export declare const HermesNegotiationResponseSchema: z.ZodObject<{
+    action: z.ZodEnum<["accept", "decline", "request_time", "continue"]>;
+    roleAlignment: z.ZodEnum<["peers", "owner_leads", "counterparty_leads"]>;
+}, "strict", z.ZodTypeAny, {
+    action: "accept" | "decline" | "request_time" | "continue";
+    roleAlignment: "peers" | "owner_leads" | "counterparty_leads";
+}, {
+    action: "accept" | "decline" | "request_time" | "continue";
+    roleAlignment: "peers" | "owner_leads" | "counterparty_leads";
+}>;
+export type HermesNegotiationResponse = z.infer<typeof HermesNegotiationResponseSchema>;
+/** Only privacy-reviewed server prose can enter the shared transcript. */
+export declare const HERMES_SHARED_MESSAGE_TEMPLATES: Readonly<Record<HermesNegotiationAction, string>>;
+export declare const HermesOwnerDirectiveSchema: z.ZodEnum<["protect_private_context"]>;
+export type HermesOwnerDirective = z.infer<typeof HermesOwnerDirectiveSchema>;
+export declare const HERMES_OWNER_DIRECTIVE: HermesOwnerDirective;
+/** Project exact seat/version actions into the closed Hermes vocabulary. */
+export declare function allowedHermesActionsFor(allowedActions: readonly NegotiationAction[]): HermesNegotiationAction[];
+/** Build the complete persisted turn without using any model-authored prose. */
+export declare function buildHermesNegotiationTurn(input: HermesNegotiationResponse, allowedActions: readonly NegotiationAction[]): NegotiationTurn | null;

package/dist/negotiation/domain/negotiation.hermes-contract.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+/** Model-visible directives for the dedicated Hermes negotiation bridge. */
+export const HermesNegotiationActionSchema = z.enum([
+    'accept',
+    'decline',
+    'request_time',
+    'continue',
+]);
+export const HermesRoleAlignmentSchema = z.enum([
+    'peers',
+    'owner_leads',
+    'counterparty_leads',
+]);
+/**
+ * No model-authored prose is accepted at this boundary. Strict parsing also
+ * prevents model-selected run IDs or capabilities from entering tool arguments.
+ */
+export const HermesNegotiationResponseSchema = z.object({
+    action: HermesNegotiationActionSchema,
+    roleAlignment: HermesRoleAlignmentSchema,
+}).strict();
+/** Only privacy-reviewed server prose can enter the shared transcript. */
+export const HERMES_SHARED_MESSAGE_TEMPLATES = Object.freeze({
+    accept: 'I am ready to proceed with this opportunity.',
+    decline: 'I am going to decline this opportunity.',
+    request_time: 'I need more time before deciding.',
+    continue: 'I am open to continuing within the current scope.',
+});
+export const HermesOwnerDirectiveSchema = z.enum(['protect_private_context']);
+export const HERMES_OWNER_DIRECTIVE = 'protect_private_context';
+const ACTION_CANDIDATES = Object.freeze({
+    accept: ['accept'],
+    decline: ['decline', 'withdraw', 'reject'],
+    request_time: ['counter', 'outreach', 'propose'],
+    continue: ['question', 'outreach', 'propose', 'counter'],
+});
+const ACTION_ORDER = [
+    'accept',
+    'decline',
+    'request_time',
+    'continue',
+];
+/** Project exact seat/version actions into the closed Hermes vocabulary. */
+export function allowedHermesActionsFor(allowedActions) {
+    const allowed = new Set(allowedActions);
+    return ACTION_ORDER.filter((action) => ACTION_CANDIDATES[action].some((candidate) => allowed.has(candidate)));
+}
+function protocolActionFor(action, allowedActions) {
+    const allowed = new Set(allowedActions);
+    return ACTION_CANDIDATES[action].find((candidate) => allowed.has(candidate)) ?? null;
+}
+function suggestedRolesFor(alignment) {
+    if (alignment === 'owner_leads')
+        return { ownUser: 'agent', otherUser: 'patient' };
+    if (alignment === 'counterparty_leads')
+        return { ownUser: 'patient', otherUser: 'agent' };
+    return { ownUser: 'peer', otherUser: 'peer' };
+}
+/** Build the complete persisted turn without using any model-authored prose. */
+export function buildHermesNegotiationTurn(input, allowedActions) {
+    const action = protocolActionFor(input.action, allowedActions);
+    if (!action)
+        return null;
+    return {
+        action,
+        message: HERMES_SHARED_MESSAGE_TEMPLATES[input.action],
+        assessment: {
+            reasoning: `Hermes selected the closed ${input.action} directive.`,
+            suggestedRoles: suggestedRolesFor(input.roleAlignment),
+        },
+    };
+}