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

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.js

@@ -22,7 +22,7 @@ export { negotiateCandidates } from "./negotiation.candidates.js";
  * @remarks Accepts an AgentDispatcher for per-turn agent resolution.
  */
 export class NegotiationGraphFactory {
-    constructor(database, dispatcher, timeoutQueue, questionerEnqueue, reflectEnqueue, memoryRetrieve) {
+    constructor(database, dispatcher, timeoutQueue, questionerEnqueue, reflectEnqueue, memoryRetrieve, clientDmRetrieve) {
         this.deps = {
             database,
             dispatcher,
@@ -30,6 +30,7 @@ export class NegotiationGraphFactory {
             questionerEnqueue,
             reflectEnqueue,
             memoryRetrieve,
+            clientDmRetrieve,
             systemAgent: new IndexNegotiator(),
             screener: new NegotiationScreener(),
         };

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

@@ -15,6 +15,7 @@ import { NegotiationScreener } from "./negotiation.screen.js";
 import type { QuestionerEnqueueFn } from "../questions/question.module.js";
 import type { ReflectEnqueueFn } from "./negotiation.reflect.js";
 import type { NegotiatorMemoryEntry, NegotiatorMemoryRetrieveFn, NegotiatorMemoryScope } from "./negotiation.memory.js";
+import type { NegotiatorClientDmMessage, NegotiatorClientDmRetrieveFn } from "./negotiation.client-dm.js";
 import { type AttributedPriorDialogue, type TaskAttribution } from './negotiation.attribution.js';
 /** The graph's channel state, as every node sees it. */
 export type NegotiationState = typeof NegotiationGraphState.State;
@@ -26,6 +27,12 @@ export interface NegotiationGraphDeps {
     questionerEnqueue?: QuestionerEnqueueFn;
     reflectEnqueue?: ReflectEnqueueFn;
     memoryRetrieve?: NegotiatorMemoryRetrieveFn;
+    /**
+     * A2H read path: the acting user's own negotiator DM for this signal.
+     * System-agent grounding only — see `negotiation.client-dm.ts`; this must
+     * never be forwarded to an external seat via `NegotiationTurnPayload`.
+     */
+    clientDmRetrieve?: NegotiatorClientDmRetrieveFn;
     /** In-process negotiator used when no personal agent answers. */
     systemAgent: IndexNegotiator;
     /** Outreach gate for fresh negotiations. */
@@ -43,9 +50,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;
@@ -57,6 +66,16 @@ export declare function hasPriorAskUser(messages: Array<{
  * this wrapper adds the graph-side failure guard.
  */
 export declare function retrieveMemory(deps: NegotiationGraphDeps, userId: string, counterpartyUserId: string, queryText: string, scope: NegotiatorMemoryScope): Promise<NegotiatorMemoryEntry[]>;
+/**
+ * A2H client-DM retrieval — never throws, never blocks a negotiation. The
+ * injected fn already resolves [] when the flag is off or the user has no
+ * negotiator DM for this signal; this wrapper adds the graph-side failure
+ * guard, exactly as `retrieveMemory` does for the memory seam.
+ *
+ * `userId` is always the ACTING user's — the seam has no counterparty field,
+ * so the counterparty's DM cannot be requested from here.
+ */
+export declare function retrieveClientDm(deps: NegotiationGraphDeps, userId: string, intentId: string): Promise<NegotiatorClientDmMessage[]>;
 /** Similarity query text: seed reasoning + counterparty context. */
 export declare function memoryQueryText(state: NegotiationState, counterparty: UserNegotiationContext): 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}`;
@@ -58,6 +60,29 @@ export async function retrieveMemory(deps, userId, counterpartyUserId, queryText
         return [];
     }
 }
+/**
+ * A2H client-DM retrieval — never throws, never blocks a negotiation. The
+ * injected fn already resolves [] when the flag is off or the user has no
+ * negotiator DM for this signal; this wrapper adds the graph-side failure
+ * guard, exactly as `retrieveMemory` does for the memory seam.
+ *
+ * `userId` is always the ACTING user's — the seam has no counterparty field,
+ * so the counterparty's DM cannot be requested from here.
+ */
+export async function retrieveClientDm(deps, userId, intentId) {
+    if (!deps.clientDmRetrieve)
+        return [];
+    try {
+        return await deps.clientDmRetrieve({ userId, intentId });
+    }
+    catch (err) {
+        logger.warn("Negotiator client DM retrieval failed; proceeding without it", {
+            userId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return [];
+    }
+}
 /** Similarity query text: seed reasoning + counterparty context. */
 export function memoryQueryText(state, counterparty) {
     return [
@@ -117,7 +142,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.graph.turn.d.ts

@@ -22,6 +22,15 @@ export declare function turnNode(state: NegotiationState, deps: NegotiationGraph
         message?: string | null | undefined;
         askUser?: {
             reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+            question?: {
+                prompt: string;
+                options: {
+                    label: string;
+                    description: string;
+                }[];
+                title: string;
+                multiSelect: boolean;
+            } | undefined;
         } | null | undefined;
     };
     firstTurnScreenedOut: boolean;
@@ -50,6 +59,15 @@ export declare function turnNode(state: NegotiationState, deps: NegotiationGraph
         message?: string | null | undefined;
         askUser?: {
             reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+            question?: {
+                prompt: string;
+                options: {
+                    label: string;
+                    description: string;
+                }[];
+                title: string;
+                multiSelect: boolean;
+            } | undefined;
         } | null | undefined;
     };
     status: "input_required";
@@ -79,6 +97,15 @@ export declare function turnNode(state: NegotiationState, deps: NegotiationGraph
         message?: string | null | undefined;
         askUser?: {
             reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+            question?: {
+                prompt: string;
+                options: {
+                    label: string;
+                    description: string;
+                }[];
+                title: string;
+                multiSelect: boolean;
+            } | undefined;
         } | null | undefined;
     };
     memoryBySide: {

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

@@ -6,9 +6,9 @@ import { allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, fal
 import { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode } from "./negotiation.consultation-policy.js";
 import { blocksNegotiationBeforeFirstTurn } from "./negotiation.screen.js";
 import { assessDeadlock, configuredDeadlockShiftEnabled, configuredDeadlockThreshold } from "./negotiation.deadlock.js";
-import { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, negotiationQuestionSettlementId } from './negotiation.question-safety.js';
+import { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, isSafeAuthoredNegotiationQuestion, negotiationQuestionSettlementId } from './negotiation.question-safety.js';
 import { isNegotiationTurnCapReached } from "./negotiation.turn-cap.js";
-import { buildAttributedDialogue, hasPriorAskUser, memoryQueryText, retrieveMemory, turnLog, turnsFromMessages } from "./negotiation.graph.shared.js";
+import { buildAttributedDialogue, hasPriorAskUser, memoryQueryText, retrieveClientDm, retrieveMemory, turnLog, turnsFromMessages } from "./negotiation.graph.shared.js";
 export async function turnNode(state, deps) {
     const traceEmitter = requestContext.getStore()?.traceEmitter;
     // Local helper to emit events whose shape is wider than the declared
@@ -150,6 +150,27 @@ export async function turnNode(state, deps) {
         else {
             // No personal agent or timeout — run system agent
             const agentPriorDialogue = buildAttributedDialogue(state);
+            // ─── A2H: the acting user's own negotiator DM for this signal ──────
+            // Retrieved HERE, inside the system-agent branch, rather than beside
+            // `ownMemory` above. Two reasons, and the first is the constraint:
+            //
+            // 1. `payload` is built and dispatched before this point, so the
+            //    excerpt cannot reach an external agent by a later edit — the
+            //    value does not exist in that scope. Memory is safe to forward
+            //    (distilled standing rules); a verbatim excerpt of the client's
+            //    private thread with their own negotiator is not, and an external
+            //    registered agent can hold the personal-agent seat.
+            // 2. A dispatched turn never reads it, so it never pays for the query.
+            //
+            // Gated on `askUserAvailable`: the grant is settled before the model
+            // runs, so the DM is present on exactly the turns where the agent may
+            // consult its client — the turns where knowing what they already said
+            // changes what it asks. Fetching it on every turn would move the
+            // prompt for every negotiation, not just the consulting ones.
+            // `askUserAvailable` already requires a non-empty `ownIntentId`.
+            const clientDm = askUserAvailable
+                ? await retrieveClientDm(deps, ownUser.id, ownIntentId)
+                : [];
             turn = await deps.systemAgent.invoke({
                 ownUser,
                 otherUser,
@@ -167,6 +188,7 @@ export async function turnNode(state, deps) {
                 ...(askUserAvailable && { canAskUser: true }),
                 ...(bargainingMode && { bargaining: { consecutiveNonConvergent: deadlock.consecutiveNonConvergent } }),
                 ...(ownMemory.length > 0 && { memory: ownMemory }),
+                ...(clientDm.length > 0 && { clientDm }),
                 ...(state.privateConsultation?.recipientUserId === ownUser.id
                     ? { privateConsultation: state.privateConsultation }
                     : {}),
@@ -307,6 +329,46 @@ export async function turnNode(state, deps) {
                 });
             }
         }
+        // ─── Authored ask_user question: identifier-aware safety gate ─────────
+        // The agent now writes the question its client reads verbatim (the
+        // pre-A2H `disclosureSubject` was only an input to server-templated copy),
+        // and an external registered agent can hold the personal-agent seat — so
+        // this runs on every turn, dispatched or system, not just our own.
+        //
+        // Placed BEFORE persistence deliberately. The turn is about to become a
+        // message in the shared conversation, so a rejected question must not
+        // survive there either; and issue 6 reads the field back off the persisted
+        // turn, which means dropping it here is what makes that read safe by
+        // construction rather than by remembering to re-check.
+        //
+        // Rejection is a DOWNGRADE, never a failure: the turn, its action, and
+        // `askUser.reason` all stand, so the consultation proceeds on today's
+        // enum-only path — the same shape a v1 turn or an older agent produces.
+        // A guard that could fail a turn would let malformed model output stall a
+        // negotiation, which is strictly worse than asking a generic question.
+        //
+        // The two inputs are exactly what the api-side payload guard can never
+        // have: it sees the question at the DB boundary with no idea who the
+        // counterparty is or what the evaluator wrote, so it cannot tell that a
+        // well-formed question is naming them or paraphrasing it.
+        if (turn.askUser?.question) {
+            const counterpartyName = otherUser.profile?.name?.trim();
+            const seedReasoning = state.seedAssessment?.reasoning?.trim();
+            const safeAuthoredQuestion = isSafeAuthoredNegotiationQuestion(turn.askUser.question, {
+                ...(counterpartyName ? { forbiddenIdentifiers: [counterpartyName] } : {}),
+                ...(seedReasoning ? { forbiddenSourceText: [seedReasoning] } : {}),
+            });
+            if (!safeAuthoredQuestion) {
+                turnLog.warn('Dropping unsafe authored ask_user question; consultation continues without it', {
+                    taskId: state.taskId,
+                    opportunityId: state.opportunityId || undefined,
+                    seat,
+                    handledExternally: dispatchResult.handled,
+                });
+                const { question: _rejected, ...askUserWithoutQuestion } = turn.askUser;
+                turn = { ...turn, askUser: askUserWithoutQuestion };
+            }
+        }
         const parts = [{ kind: "data", data: turn }];
         const message = await deps.database.createMessage({
             conversationId: state.conversationId,

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

@@ -17,12 +17,15 @@ 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 { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeAuthoredNegotiationQuestion, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
 export { renderNegotiatorChatMemorySection } from "./negotiation.memory.js";
 export type { ConsultationEligibility, ConsultationEligibilityInput, NegotiationConsultationPolicyMode, NegotiationConsultationReason, } from "./negotiation.consultation-policy.js";
 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 { NegotiatorClientDmMessage, NegotiatorClientDmQuery, NegotiatorClientDmRetrieveFn, } from "./negotiation.client-dm.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 { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeAuthoredNegotiationQuestion, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
 export { renderNegotiatorChatMemorySection } from "./negotiation.memory.js";