@indexnetwork/protocol 21.0.0-rc.488.1 → 21.0.0-rc.489.1

package/dist/index.d.ts

@@ -125,8 +125,8 @@ export type { NegotiationAction, NegotiationConsultationReason, NegotiationSeat,
 export type { NegotiationGraphLike } from "./negotiations/negotiation.module.js";
 export { HERMES_OWNER_DIRECTIVE, HermesNegotiationResponseSchema, allowedHermesActionsFor, buildHermesNegotiationTurn, } from "./negotiations/negotiation.module.js";
 export type { HermesNegotiationAction, HermesNegotiationResponse, } from "./negotiations/negotiation.module.js";
-export { isNegotiationTurnCapReached, expectedNegotiationSpeaker, allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, isTerminalAction, isRejectLikeAction, readProtocolVersion, resolveSeat, seatViolationMessage } from "./negotiations/negotiation.module.js";
-export type { NegotiationSpeakerParticipants, NegotiationSpeakerMessage } from "./negotiations/negotiation.module.js";
+export { isNegotiationTurnCapReached, expectedNegotiationSpeaker, negotiationScopeKey, readNegotiationMessages, allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, isTerminalAction, isRejectLikeAction, readProtocolVersion, resolveSeat, seatViolationMessage } from "./negotiations/negotiation.module.js";
+export type { NegotiationSpeakerParticipants, NegotiationSpeakerMessage, NegotiationScopeMetadata } from "./negotiations/negotiation.module.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode } from "./negotiations/negotiation.module.js";
 export type { ConsultationEligibility, ConsultationEligibilityInput, NegotiationConsultationPolicyMode } from "./negotiations/negotiation.module.js";
 export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, negotiationQuestionSettlementId, } from "./negotiations/negotiation.module.js";

package/dist/index.js

@@ -112,6 +112,6 @@ export { CANONICAL_MCP_CAPABILITY_POLICY_OPTIONS } from "./mcp/mcp.authorization
 export { NegotiationConsultationReasonSchema } from "./shared/schemas/negotiation-state.schema.js";
 export { HERMES_OWNER_DIRECTIVE, HermesNegotiationResponseSchema, allowedHermesActionsFor, buildHermesNegotiationTurn, } from "./negotiations/negotiation.module.js";
 // ─── Negotiation seat rules (v2 client-advocate protocol) ───────────────────
-export { isNegotiationTurnCapReached, expectedNegotiationSpeaker, allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, isTerminalAction, isRejectLikeAction, readProtocolVersion, resolveSeat, seatViolationMessage } from "./negotiations/negotiation.module.js";
+export { isNegotiationTurnCapReached, expectedNegotiationSpeaker, negotiationScopeKey, readNegotiationMessages, allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, isTerminalAction, isRejectLikeAction, readProtocolVersion, resolveSeat, seatViolationMessage } from "./negotiations/negotiation.module.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode } from "./negotiations/negotiation.module.js";
 export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, negotiationQuestionSettlementId, } from "./negotiations/negotiation.module.js";

package/dist/negotiations/negotiation.agent.js

@@ -187,11 +187,19 @@ ${stanceQuerySatisfiedRule(stance, otherName, userName)}`
         const attributionPolicy = hasAttributedDialogue
             ? ' Prior turns from OTHER opportunities are background only — do not treat their conclusions as decisions about this opportunity.'
             : '';
-        const continuationHasHistory = hasAttributedDialogue || input.history.length > 0;
-        const continuationContext = input.isContinuation && continuationHasHistory
+        // The pair's shared DM carries every negotiation they have ever had. It is
+        // rendered whenever it exists — NOT only on continuations — because a fresh
+        // match in a long-running DM is exactly the case where that context is
+        // worth having. What it may not do is stand in for this negotiation's own
+        // exchange, so the policy line differs by whether this one has opened.
+        const hasPriorDialogue = hasAttributedDialogue || input.history.length > 0;
+        const priorDialoguePolicy = input.isContinuation
+            ? 'Policy: You are continuing a prior dialogue. If this signal is materially the same as one you previously evaluated, you may resolve quickly. If materially different, evaluate on its own merits.'
+            : 'Policy: This signal is NEW — you have not negotiated it before. The dialogue above concluded on other signals and is background only. Evaluate this one on its own merits and make your own case for it.';
+        const priorDialogueContext = hasPriorDialogue
             ? `\n\n--- Prior dialogue with this counterparty ---\n${attributionPreamble}${priorDialogueBody}\n\n--- New signal under evaluation ---\n${input.discoveryQuery
                 ? `Discovery query: "${input.discoveryQuery}"`
-                : `Seed assessment: ${input.seedAssessment.reasoning}`}\n\nPolicy: You are continuing a prior dialogue. If this signal is materially the same as one you previously evaluated, you may resolve quickly. If materially different, evaluate on its own merits.${attributionPolicy}`
+                : `Seed assessment: ${input.seedAssessment.reasoning}`}\n\n${priorDialoguePolicy}${attributionPolicy}`
             : '';
         const userAnswersContext = input.userAnswers && input.userAnswers.length > 0
             ? `\n\n--- ${userName}'s additional context (provided between sessions) ---\n${input.userAnswers.map((a) => {
@@ -222,7 +230,7 @@ Skills: ${input.otherUser.profile.skills?.join(", ") ?? "N/A"}
 Intents:
 ${input.otherUser.intents.map((i) => `- ${i.title}: ${i.description}`).join("\n")}
 
-Why this match was suggested: ${input.seedAssessment.reasoning}${input.isContinuation ? continuationContext : historyText}${userAnswersContext}${privateConsultationContext}
+Why this match was suggested: ${input.seedAssessment.reasoning}${hasPriorDialogue ? priorDialogueContext : historyText}${userAnswersContext}${privateConsultationContext}
 ${discoveryQueryReminder}
 ${input.history.length === 0 && !input.isContinuation ? (version === "v2" && seat === "initiator" ? "This is the opening turn. Make the outreach case." : "This is the opening turn. Propose the connection case.") : "Evaluate the latest arguments and respond."}`;
         const chatMessages = [

package/dist/negotiations/negotiation.detail-reader.js

@@ -77,7 +77,10 @@ export async function readAuthorizedNegotiationDetail(input) {
         isUsersTurn,
         isContinuation: metadata.isContinuation ?? false,
         priorTurnCount,
-        turnsAdded: turnCount - priorTurnCount,
+        // Clamped: `turnCount` is match-scoped, but a task stamped before that
+        // change carries a conversation-wide `priorTurnCount`, which would other-
+        // wise report a negative delta for negotiations in flight across the deploy.
+        turnsAdded: Math.max(0, turnCount - priorTurnCount),
         turns,
         outcome,
         lifecycle: buildLifecycleNarration(status, lifecycleOpportunityId ? opportunityLifecycles[lifecycleOpportunityId] : undefined),

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

@@ -1,6 +1,12 @@
 export interface NegotiationSpeakerParticipants {
     sourceUserId?: unknown;
     candidateUserId?: unknown;
+    /**
+     * The seat that opens this negotiation (v2 stamp). An unopened negotiation
+     * starts with its initiator; `sourceUserId` is the pre-stamp fallback, which
+     * is what the stamp defaults to anyway.
+     */
+    initiatorUserId?: unknown;
 }
 export interface NegotiationSpeakerMessage {
     senderId?: unknown;
@@ -9,11 +15,19 @@ export interface NegotiationSpeakerMessage {
 /**
  * Resolves the participant whose agent owns the next canonical bilateral turn.
  *
+ * `messages` must be THIS negotiation's messages (see
+ * `getNegotiationMessages`), never the whole conversation. Two agents share one
+ * DM across every match they are ever paired on, so conversation-scoped parity
+ * makes a fresh negotiation inherit the turn order of an unrelated, concluded
+ * one — handing the floor to the counterparty, who may `accept` immediately and
+ * conclude the match before its initiator has spoken.
+ *
  * 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.
+ * exact successor. A negotiation with no canonical history of its own has not
+ * opened yet, so it starts with its initiator. Invalid participant metadata
+ * always fails closed.
  */
 export declare function expectedNegotiationSpeaker(participants: NegotiationSpeakerParticipants, messages: readonly NegotiationSpeakerMessage[]): string | null;

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

@@ -18,12 +18,20 @@ function participantId(value) {
 /**
  * Resolves the participant whose agent owns the next canonical bilateral turn.
  *
+ * `messages` must be THIS negotiation's messages (see
+ * `getNegotiationMessages`), never the whole conversation. Two agents share one
+ * DM across every match they are ever paired on, so conversation-scoped parity
+ * makes a fresh negotiation inherit the turn order of an unrelated, concluded
+ * one — handing the floor to the counterparty, who may `accept` immediately and
+ * conclude the match before its initiator has spoken.
+ *
  * 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.
+ * exact successor. A negotiation with no canonical history of its own has not
+ * opened yet, so it starts with its initiator. Invalid participant metadata
+ * always fails closed.
  */
 export function expectedNegotiationSpeaker(participants, messages) {
     const source = participantId(participants.sourceUserId);
@@ -43,5 +51,9 @@ export function expectedNegotiationSpeaker(participants, messages) {
             ? sender
             : sender === source ? candidate : source;
     }
-    return source;
+    // Unopened: the initiator seat speaks first. Mirrors the
+    // `initiatorUserId ?? sourceUserId` precedence in `resolveSeat`, and falls
+    // back to source when the stamp is absent or names a non-participant.
+    const initiator = participantId(participants.initiatorUserId);
+    return initiator === candidate ? candidate : source;
 }

package/dist/negotiations/negotiation.graph.init.js

@@ -5,6 +5,7 @@ import { configuredProtocolVersion, readProtocolVersion } from "./negotiation.pr
 import { buildIntentSnapshots } from "./negotiation.intent-snapshot-provenance.js";
 import { holdsNegotiationConversationLock } from "./negotiation.task-lock-policy.js";
 import { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
+import { readNegotiationMessages } from "./negotiation.scope.js";
 import { buildSeededAttribution } from './negotiation.attribution.js';
 import { initLog, resolveTaskAttribution, turnsFromMessages } from "./negotiation.graph.shared.js";
 export async function initNode(state, deps) {
@@ -18,7 +19,12 @@ export async function initNode(state, deps) {
             ? { id: execution.conversationId }
             : await deps.database.getOrCreateDM(agentIdA, agentIdB, 'agent');
         // --- Lock gate: check for an active task on this conversation ---
-        const priorMessages = await deps.database.getMessagesForConversation(conversation.id);
+        // Two reads with two jobs. `conversationMessages` is the pair's whole shared
+        // DM — CONTEXT, including negotiations for other matches, which reaches the
+        // agent only as labelled prior dialogue. `negotiationMessages` is THIS
+        // match's own turns, and is the sole input to this negotiation's state:
+        // whether it has opened, whose turn it is, how far it has run.
+        const conversationMessages = await deps.database.getMessagesForConversation(conversation.id);
         if (Boolean(state.resumeFromTaskId) !== Boolean(state.continuationSettlementId)
             || Boolean(state.resumeFromTaskId) !== Boolean(execution))
             return { error: 'invalid continuation correlation' };
@@ -57,18 +63,24 @@ export async function initNode(state, deps) {
             });
             return { error: 'busy' };
         }
-        // --- Load prior messages and determine continuation ---
-        const priorTurns = turnsFromMessages(priorMessages);
+        // --- Load this negotiation's own prior turns ---
+        // Resolved through the shared scope rule, not a local copy of it: the graph
+        // and the respond/polling surfaces must agree on what "this negotiation's
+        // messages" means, or an external agent can be told it is not its turn
+        // forever. That rule also owns the unkeyed case — a run with no opportunity
+        // has no identity apart from its conversation.
+        const negotiationMessages = await readNegotiationMessages({
+            byNegotiation: (id) => deps.database.getNegotiationMessages(id),
+            byConversation: async () => conversationMessages,
+        }, {
+            conversationId: conversation.id,
+            metadata: { opportunityId: state.opportunityId },
+        });
+        const priorTurns = turnsFromMessages(negotiationMessages);
+        // `isContinuation` means THIS negotiation has already spoken — not that the
+        // pair has history. A fresh match in a long-running DM is not a
+        // continuation, and must still open.
         const isContinuation = priorTurns.length > 0;
-        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([
@@ -112,6 +124,19 @@ export async function initNode(state, deps) {
                 }
             }
         }
+        // --- Floor: derived from this negotiation's turns, after the seat is known ---
+        // Resolved here rather than above because an unopened negotiation starts
+        // with its initiator, which the tie-break may only just have settled.
+        const expectedSpeaker = expectedNegotiationSpeaker({
+            sourceUserId: state.sourceUser.id,
+            candidateUserId: state.candidateUser.id,
+            initiatorUserId,
+        }, negotiationMessages);
+        if (!expectedSpeaker)
+            return { error: 'invalid negotiation participants' };
+        const currentSpeaker = expectedSpeaker === state.sourceUser.id
+            ? 'source'
+            : 'candidate';
         // --- Protocol version: pinned per negotiation, re-stamped per match ---
         // A prior task for this same negotiation (exact continuation resume or
         // a re-run of the same opportunity) pins the version, so one
@@ -179,22 +204,26 @@ export async function initNode(state, deps) {
                 return [];
             })
             : [];
-        // Seed messages with prior turns (additive reducer appends new turns on top).
-        // taskId is preserved so the turn/screen nodes can separate this
-        // session's turns from seeded prior-task turns (IND-569).
-        const seedMessages = isContinuation ? priorMessages.map((m) => ({
+        // Seed messages with THIS negotiation's prior turns (additive reducer
+        // appends new turns on top). taskId is preserved so the turn/screen nodes
+        // can separate this session's turns from earlier sessions of the same
+        // negotiation (IND-569).
+        const seedMessages = negotiationMessages.map((m) => ({
             id: m.id,
             senderId: m.senderId,
             role: 'agent',
             parts: m.parts,
             createdAt: m.createdAt,
             taskId: m.taskId ?? null,
-        })) : [];
-        // IND-569: attribute seeded prior turns to their originating opportunity
-        // once, up front. Earlier-opportunity and legacy unattributed blocks are
-        // immutable for the session; the current block is composed per turn.
-        const priorAttribution = isContinuation
-            ? await buildSeededAttribution(priorMessages
+        }));
+        // IND-569: attribute the pair's whole shared DM to its originating
+        // negotiations, once, up front. Earlier-match and legacy unattributed
+        // blocks are immutable for the session; the current block is composed per
+        // turn. Keyed on the conversation, not on `isContinuation`: a fresh match
+        // has no turns of its own but the pair's history is exactly the context
+        // worth carrying into it.
+        const priorAttribution = conversationMessages.length > 0
+            ? await buildSeededAttribution(conversationMessages
                 .map((m) => ({ taskId: m.taskId ?? null, turn: turnsFromMessages([m])[0] }))
                 .filter((e) => Boolean(e.turn)), state.opportunityId, (taskId) => resolveTaskAttribution(deps, taskId))
             : null;

package/dist/negotiations/negotiation.graph.shared.d.ts

@@ -43,9 +43,11 @@ export declare function turnsFromMessages(messages: Array<{
 }>): NegotiationTurn[];
 /**
  * Whether `userId`'s side has already spent its one `ask_user` client
- * consultation in this conversation (P3.2 rationing: max one per negotiation
- * per side, checked against the full message history so continuations count
- * prior sessions' consultations too).
+ * consultation in THIS negotiation (P3.2 rationing: max one per negotiation per
+ * side). Callers pass `state.messages`, which carries this negotiation's turns
+ * across all of its sessions — so an earlier session of the same negotiation
+ * counts, while a consultation spent on a different match with the same
+ * counterparty does not.
  */
 export declare function hasPriorAskUser(messages: Array<{
     senderId: string;

package/dist/negotiations/negotiation.graph.shared.js

@@ -25,9 +25,11 @@ export function turnsFromMessages(messages) {
 }
 /**
  * Whether `userId`'s side has already spent its one `ask_user` client
- * consultation in this conversation (P3.2 rationing: max one per negotiation
- * per side, checked against the full message history so continuations count
- * prior sessions' consultations too).
+ * consultation in THIS negotiation (P3.2 rationing: max one per negotiation per
+ * side). Callers pass `state.messages`, which carries this negotiation's turns
+ * across all of its sessions — so an earlier session of the same negotiation
+ * counts, while a consultation spent on a different match with the same
+ * counterparty does not.
  */
 export function hasPriorAskUser(messages, userId) {
     const sender = `agent:${userId}`;
@@ -117,7 +119,9 @@ export async function resolveTaskAttribution(deps, taskId) {
  * (task-id-matched). Null when there is no seeded attribution.
  */
 export function buildAttributedDialogue(state) {
-    if (!state.isContinuation || !state.priorAttribution)
+    // Not gated on `isContinuation`: that now means "this negotiation has spoken",
+    // and the pair's earlier matches are context worth carrying into a fresh one.
+    if (!state.priorAttribution)
         return null;
     const currentSessionTurns = turnsFromMessages(state.messages.filter((m) => m.taskId === state.taskId));
     const dialogue = combineAttributedDialogue(state.priorAttribution, currentSessionTurns);

package/dist/negotiations/negotiation.module.d.ts

@@ -17,6 +17,7 @@ export { ASK_USER_LOCK_SLACK_MS, allowedActionsFor, askUserAnswerWindowMs, confi
 export { HERMES_OWNER_DIRECTIVE, HERMES_SHARED_MESSAGE_TEMPLATES, HermesNegotiationActionSchema, HermesNegotiationResponseSchema, HermesOwnerDirectiveSchema, HermesRoleAlignmentSchema, allowedHermesActionsFor, buildHermesNegotiationTurn, } from "./negotiation.hermes-contract.js";
 export { DEFAULT_NEGOTIATION_MAX_TURNS, isNegotiationTurnCapReached } from "./negotiation.turn-cap.js";
 export { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
+export { negotiationScopeKey, readNegotiationMessages } from "./negotiation.scope.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "./negotiation.consultation-policy.js";
 export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
 export { renderNegotiatorChatMemorySection } from "./negotiation.memory.js";
@@ -24,5 +25,6 @@ export type { ConsultationEligibility, ConsultationEligibilityInput, Negotiation
 export type { HermesNegotiationAction, HermesNegotiationResponse, HermesOwnerDirective, HermesRoleAlignment, } from "./negotiation.hermes-contract.js";
 export type { NegotiationGraphLike, NegotiationOutcome, NegotiationTurn, UserNegotiationContext, } from "./negotiation.state.js";
 export type { NegotiationSpeakerMessage, NegotiationSpeakerParticipants } from "./negotiation.expected-speaker.js";
+export type { NegotiationScopeMetadata } from "./negotiation.scope.js";
 export type { NegotiatorMemoryEntry } from "./negotiation.memory.js";
 export type { NegotiationToolDeps } from "./negotiation.tools.port.js";

package/dist/negotiations/negotiation.module.js

@@ -14,6 +14,7 @@ export { ASK_USER_LOCK_SLACK_MS, allowedActionsFor, askUserAnswerWindowMs, confi
 export { HERMES_OWNER_DIRECTIVE, HERMES_SHARED_MESSAGE_TEMPLATES, HermesNegotiationActionSchema, HermesNegotiationResponseSchema, HermesOwnerDirectiveSchema, HermesRoleAlignmentSchema, allowedHermesActionsFor, buildHermesNegotiationTurn, } from "./negotiation.hermes-contract.js";
 export { DEFAULT_NEGOTIATION_MAX_TURNS, isNegotiationTurnCapReached } from "./negotiation.turn-cap.js";
 export { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
+export { negotiationScopeKey, readNegotiationMessages } from "./negotiation.scope.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "./negotiation.consultation-policy.js";
 export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
 export { renderNegotiatorChatMemorySection } from "./negotiation.memory.js";

package/dist/negotiations/negotiation.scope.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The boundary between a negotiation and the conversation it runs in.
+ *
+ * Two agents share one DM permanently — `getOrCreateDM` keys on the agent pair
+ * alone — so that conversation accumulates every negotiation the pair has ever
+ * had. A negotiation is a bounded episode about ONE match inside it.
+ *
+ * Every question about a negotiation's own state (whose turn it is, whether it
+ * has opened, how many turns it has run) must be answered from the
+ * negotiation's messages. Conversation-wide reads remain valid for CONTEXT —
+ * what the pair discussed before — but must never decide state, or a fresh
+ * match inherits the turn parity of an unrelated concluded one.
+ *
+ * Every surface that resolves the floor shares this rule. If the graph and the
+ * respond/polling surfaces disagreed about a negotiation's scope, an external
+ * agent would be told it is not its turn forever.
+ */
+/** Minimal task-metadata shape needed to identify a negotiation. */
+export interface NegotiationScopeMetadata {
+    opportunityId?: unknown;
+}
+/**
+ * The opportunity a negotiation belongs to, or null when the task carries no
+ * opportunity. Keyed on opportunity rather than task because an `ask_user`
+ * pause resumes into a successor task: both tasks' turns are one negotiation.
+ */
+export declare function negotiationScopeKey(metadata: NegotiationScopeMetadata | null | undefined): string | null;
+/**
+ * Reads the messages that constitute one negotiation.
+ *
+ * A task with no opportunity has no identity separate from its conversation
+ * (direct and legacy invocations), so the conversation is its scope — there is
+ * no other match it could be confused with.
+ */
+export declare function readNegotiationMessages<M>(readers: {
+    byNegotiation: (opportunityId: string) => Promise<M[]>;
+    byConversation: (conversationId: string) => Promise<M[]>;
+}, scope: {
+    conversationId: string;
+    metadata: NegotiationScopeMetadata | null | undefined;
+}): Promise<M[]>;

package/dist/negotiations/negotiation.scope.js

@@ -0,0 +1,39 @@
+/**
+ * The boundary between a negotiation and the conversation it runs in.
+ *
+ * Two agents share one DM permanently — `getOrCreateDM` keys on the agent pair
+ * alone — so that conversation accumulates every negotiation the pair has ever
+ * had. A negotiation is a bounded episode about ONE match inside it.
+ *
+ * Every question about a negotiation's own state (whose turn it is, whether it
+ * has opened, how many turns it has run) must be answered from the
+ * negotiation's messages. Conversation-wide reads remain valid for CONTEXT —
+ * what the pair discussed before — but must never decide state, or a fresh
+ * match inherits the turn parity of an unrelated concluded one.
+ *
+ * Every surface that resolves the floor shares this rule. If the graph and the
+ * respond/polling surfaces disagreed about a negotiation's scope, an external
+ * agent would be told it is not its turn forever.
+ */
+/**
+ * The opportunity a negotiation belongs to, or null when the task carries no
+ * opportunity. Keyed on opportunity rather than task because an `ask_user`
+ * pause resumes into a successor task: both tasks' turns are one negotiation.
+ */
+export function negotiationScopeKey(metadata) {
+    const id = metadata?.opportunityId;
+    return typeof id === 'string' && id.length > 0 ? id : null;
+}
+/**
+ * Reads the messages that constitute one negotiation.
+ *
+ * A task with no opportunity has no identity separate from its conversation
+ * (direct and legacy invocations), so the conversation is its scope — there is
+ * no other match it could be confused with.
+ */
+export async function readNegotiationMessages(readers, scope) {
+    const opportunityId = negotiationScopeKey(scope.metadata);
+    return opportunityId
+        ? readers.byNegotiation(opportunityId)
+        : readers.byConversation(scope.conversationId);
+}

package/dist/negotiations/negotiation.screen.js

@@ -59,10 +59,14 @@ export class NegotiationScreener {
         };
         // IND-569: prefer the attributed rendering (labeled per-opportunity blocks)
         // when the graph supplies it; otherwise fall back to the flat prior-turn list.
-        const hasAttributed = input.isContinuation
-            && input.priorDialogueAttributed != null
+        //
+        // Deliberately NOT gated on `isContinuation`, which means "this negotiation
+        // has already spoken". The gate this section exists for is the opposite
+        // case — a FRESH signal against a counterparty the client has prior dialogue
+        // with (IND-563), which is precisely when duplicate outreach must be caught.
+        const hasAttributed = input.priorDialogueAttributed != null
             && !attributedDialogueIsEmpty(input.priorDialogueAttributed);
-        const flatPriorDialogue = input.isContinuation && input.priorDialogue && input.priorDialogue.length > 0
+        const flatPriorDialogue = input.priorDialogue && input.priorDialogue.length > 0
             ? input.priorDialogue
             : [];
         const priorDialogueBody = hasAttributed

package/dist/negotiations/negotiation.tools.js

@@ -9,6 +9,7 @@ import { readAuthorizedNegotiationDetail } from './negotiation.detail-reader.js'
 import { buildLifecycleNarration } from './negotiation.lifecycle-narration.js';
 import { isNegotiationTurnCapReached } from './negotiation.turn-cap.js';
 import { expectedNegotiationSpeaker } from './negotiation.expected-speaker.js';
+import { readNegotiationMessages } from './negotiation.scope.js';
 export { buildLifecycleNarration } from './negotiation.lifecycle-narration.js';
 const logger = protocolLogger('ChatTools:Negotiation');
 /**
@@ -150,8 +151,12 @@ export function createNegotiationTools(defineTool, deps) {
                     }
                     const isSource = meta.sourceUserId === context.userId;
                     const counterpartyId = isSource ? meta.candidateUserId : meta.sourceUserId;
-                    // Get messages for preview (and turns when narrative detail requested)
-                    const messages = await negotiationDatabase.getMessagesForConversation(task.conversationId);
+                    // This negotiation's own turns: the preview, turn count and floor all
+                    // describe THIS match, and the pair's DM also holds other matches.
+                    const messages = await readNegotiationMessages({
+                        byNegotiation: (id) => negotiationDatabase.getNegotiationMessages(id),
+                        byConversation: (id) => negotiationDatabase.getMessagesForConversation(id),
+                    }, { conversationId: task.conversationId, metadata: meta });
                     const lastMessage = messages[messages.length - 1];
                     const lastTurnData = lastMessage
                         ? lastMessage.parts?.find(p => p.kind === 'data')?.data
@@ -296,7 +301,10 @@ export function createNegotiationTools(defineTool, deps) {
                     metadata: meta,
                     callerUserId: context.userId,
                     callerRole: isSource ? 'source' : 'candidate',
-                    readMessages: (conversationId) => negotiationDatabase.getMessagesForConversation(conversationId),
+                    readMessages: (conversationId) => readNegotiationMessages({
+                        byNegotiation: (id) => negotiationDatabase.getNegotiationMessages(id),
+                        byConversation: (id) => negotiationDatabase.getMessagesForConversation(id),
+                    }, { conversationId, metadata: meta }),
                     readArtifacts: (taskId) => negotiationDatabase.getArtifactsForTask(taskId),
                     readLifecycleEvidence: (opportunityIds, ownerUserId) => readOpportunityLifecycles(negotiationDatabase, opportunityIds, ownerUserId),
                 });
@@ -386,7 +394,10 @@ export function createNegotiationTools(defineTool, deps) {
                 if (!allowedActionsFor(protocolVersion, seat).includes(query.action)) {
                     return error(seatViolationMessage(query.action, seat, protocolVersion));
                 }
-                const messages = await negotiationDatabase.getMessagesForConversation(task.conversationId);
+                const messages = await readNegotiationMessages({
+                    byNegotiation: (id) => negotiationDatabase.getNegotiationMessages(id),
+                    byConversation: (id) => negotiationDatabase.getMessagesForConversation(id),
+                }, { conversationId: task.conversationId, metadata: meta });
                 const turnCount = messages.length;
                 const expectedSpeaker = expectedNegotiationSpeaker(meta, messages);
                 if (expectedSpeaker !== context.userId) {

package/dist/opportunities/negotiation-context.loader.d.ts

@@ -24,7 +24,7 @@ import type { NegotiationOutcome, NegotiationTurn } from '../negotiations/negoti
  * Narrow slice of {@link NegotiationGraphDatabase} required by the loader. Kept
  * minimal so call sites can opt into a smaller surface.
  */
-export type NegotiationContextDatabase = Pick<NegotiationGraphDatabase, 'getNegotiationTaskForOpportunity' | 'getMessagesForConversation' | 'getArtifactsForTask'>;
+export type NegotiationContextDatabase = Pick<NegotiationGraphDatabase, 'getNegotiationTaskForOpportunity' | 'getNegotiationMessages' | 'getArtifactsForTask'>;
 /**
  * Snapshot of a negotiation surfaced to the presenter. `turns` and `outcome`
  * are only populated for post-negotiation statuses (pending/stalled/

package/dist/opportunities/negotiation-context.loader.js

@@ -42,7 +42,9 @@ export async function loadNegotiationContext(db, opportunityId, opportunityStatu
         return null;
     }
     const turnCap = readNumber(task.metadata, 'maxTurns') ?? 0;
-    const messages = await db.getMessagesForConversation(task.conversationId);
+    // Scoped to this opportunity: `turnCount`/`turns` describe THIS negotiation,
+    // and the pair's shared DM also holds concluded negotiations for other matches.
+    const messages = await db.getNegotiationMessages(opportunityId);
     const turns = extractTurns(messages);
     const turnCount = turns.length;
     if (opportunityStatus === 'negotiating') {

package/dist/shared/interfaces/database.capabilities.d.ts

@@ -97,4 +97,4 @@ export type HydeGraphDatabase = Pick<Database, 'getHydeDocument' | 'getHydeDocum
  *
  * Access layer: UserDatabase (own opportunities and profile)
  */
-export type RadarGraphDatabase = Pick<Database, 'getOpportunitiesForUser' | 'getOpportunity' | 'getProfile' | 'getActiveIntents' | 'getNetwork' | 'getUser'> & Pick<NegotiationGraphDatabase, 'getNegotiationTaskForOpportunity' | 'getMessagesForConversation' | 'getArtifactsForTask'>;
+export type RadarGraphDatabase = Pick<Database, 'getOpportunitiesForUser' | 'getOpportunity' | 'getProfile' | 'getActiveIntents' | 'getNetwork' | 'getUser'> & Pick<NegotiationGraphDatabase, 'getNegotiationTaskForOpportunity' | 'getNegotiationMessages' | 'getArtifactsForTask'>;

package/dist/shared/interfaces/database.negotiation.d.ts

@@ -274,6 +274,30 @@ export type NegotiationGraphDatabase = Pick<Database, 'getOrCreateDM' | 'getUser
         createdAt: Date;
         taskId?: string | null;
     }>>;
+    /**
+     * Gets the messages belonging to ONE negotiation — those written by tasks
+     * carrying `type: 'negotiation'` and the given `opportunityId` — ordered by
+     * creation time.
+     *
+     * A negotiation is keyed by opportunity, not by task: an `ask_user` pause
+     * parks its task and resumes into a pre-claimed successor, so one negotiation
+     * spans several tasks. This is the read behind every question ABOUT a
+     * negotiation (whose turn it is, whether it has opened, how many turns it has
+     * run). `getMessagesForConversation` remains the read for conversation-wide
+     * CONTEXT — prior matches between the same pair — which must never determine
+     * a negotiation's own state.
+     *
+     * Messages with no `taskId`, or whose task carries no opportunityId, are not
+     * part of any negotiation and are never returned here.
+     */
+    getNegotiationMessages(opportunityId: string): Promise<Array<{
+        id: string;
+        senderId: string;
+        role: 'user' | 'agent';
+        parts: unknown[];
+        createdAt: Date;
+        taskId?: string | null;
+    }>>;
     /** Gets artifacts for a task (e.g. negotiation outcome). */
     getArtifactsForTask(taskId: string): Promise<Array<{
         id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indexnetwork/protocol",
-  "version": "21.0.0-rc.488.1",
+  "version": "21.0.0-rc.489.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",