@indexnetwork/protocol 4.5.0-rc.332.1 → 4.5.0-rc.334.1

package/dist/negotiation/negotiation.graph.js

@@ -3,9 +3,12 @@ import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
 import { requestContext } from "../shared/observability/request-context.js";
 import { NegotiationGraphState } from "./negotiation.state.js";
 import { IndexNegotiator } from "./negotiation.agent.js";
+import { allowedActionsFor, configuredProtocolVersion, fallbackActionFor, isRejectLikeAction, isTerminalAction, readProtocolVersion, rejectActionFor } from "./negotiation.protocol.js";
+import { NegotiationScreener, configuredScreenMode } from "./negotiation.screen.js";
 import { protocolLogger } from "../shared/observability/protocol.logger.js";
 const logger = protocolLogger("NegotiationGraph");
 const initLog = protocolLogger("NegotiationGraph:Init");
+const screenNodeLog = protocolLogger("NegotiationGraph:Screen");
 const turnLog = protocolLogger("NegotiationGraph:Turn");
 const finalizeLog = protocolLogger("NegotiationGraph:Finalize");
 const negotiateCandidatesLog = protocolLogger("NegotiationGraph:negotiateCandidates");
@@ -32,6 +35,7 @@ export class NegotiationGraphFactory {
     createGraph() {
         const { database, dispatcher, timeoutQueue, questionerEnqueue } = this;
         const systemAgent = new IndexNegotiator();
+        const screener = new NegotiationScreener();
         const initNode = async (state) => {
             try {
                 // Find-or-create the DM conversation for this agent pair (same as user DMs)
@@ -87,9 +91,13 @@ export class NegotiationGraphFactory {
                     return typeof v === 'string' && v.length > 0 ? v : null;
                 };
                 let initiatorUserId = readInitiator(priorTask?.metadata) ?? state.initiatorUserId ?? state.sourceUser.id;
+                // Conversation-scoped prior task: reused for both the initiator tie-break
+                // (only when active+fresh) and protocol-version inheritance (any prior
+                // task on the conversation pins the version).
+                const convTask = (!readInitiator(priorTask?.metadata) || !readProtocolVersion(priorTask?.metadata))
+                    ? await database.getLatestNegotiationTaskForConversation?.(conversation.id).catch(() => null)
+                    : null;
                 if (!readInitiator(priorTask?.metadata)) {
-                    const convTask = await database.getLatestNegotiationTaskForConversation?.(conversation.id)
-                        .catch(() => null);
                     if (convTask && convTask.id !== priorTask?.id && isActiveAndFresh(convTask)) {
                         const convInitiator = readInitiator(convTask.metadata);
                         if (convInitiator) {
@@ -102,10 +110,29 @@ export class NegotiationGraphFactory {
                         }
                     }
                 }
+                // --- Protocol version: inherited, never re-stamped ---
+                // Every session (including continuations) creates a new task row, so a
+                // naïve "stamp from env at init" would flip a v1 conversation to v2
+                // mid-flight. Rule: any prior negotiation task on this conversation pins
+                // the version (absent field on a genuine prior = pre-v2 task = v1);
+                // prior turns without a readable task also grandfather to v1; only
+                // genuinely fresh negotiations stamp from NEGOTIATION_PROTOCOL_VERSION.
+                let protocolVersion;
+                const priorVersionSource = priorTask ?? convTask;
+                if (priorVersionSource) {
+                    protocolVersion = readProtocolVersion(priorVersionSource.metadata) ?? 'v1';
+                }
+                else if (isContinuation) {
+                    protocolVersion = 'v1';
+                }
+                else {
+                    protocolVersion = configuredProtocolVersion();
+                }
                 const task = await database.createTask(conversation.id, {
                     type: 'negotiation',
                     sourceUserId: state.sourceUser.id,
                     initiatorUserId,
+                    protocolVersion,
                     candidateUserId: state.candidateUser.id,
                     networkId: state.indexContext.networkId,
                     ...(state.opportunityId && { opportunityId: state.opportunityId }),
@@ -141,6 +168,7 @@ export class NegotiationGraphFactory {
                     maxTurns,
                     isContinuation,
                     initiatorUserId,
+                    protocolVersion,
                     priorTurnCount: priorTurns.length,
                     ...(userAnswers.length > 0 && { userAnswers }),
                     ...(seedMessages.length > 0 && { messages: seedMessages }),
@@ -150,6 +178,99 @@ export class NegotiationGraphFactory {
                 return { error: `Init failed: ${err instanceof Error ? err.message : String(err)}` };
             }
         };
+        /**
+         * Screen node (P2.1) — the outreach gate. Runs between init and the first
+         * turn on FRESH negotiations only (routing skips it on continuations and
+         * when NEGOTIATION_SCREEN_MODE=off). The reaching client's negotiator
+         * decides whether the match is worth its client's name; in shadow mode the
+         * decision is recorded (task metadata + trace event + log line) but never
+         * blocks — the negotiation always proceeds to the first turn. `enforce`
+         * runs identically until P2.2 lands enforcement (by the time this node
+         * runs, init has already created the task and flipped the opportunity to
+         * `negotiating` — P2.2 owns making a blocking `pass` quiet/correct).
+         */
+        const screenNode = async (state) => {
+            const traceEmitter = requestContext.getStore()?.traceEmitter;
+            const emitWide = (event) => traceEmitter?.(event);
+            const mode = configuredScreenMode();
+            if (mode === "enforce") {
+                screenNodeLog.warn("NEGOTIATION_SCREEN_MODE=enforce requested but enforcement lands in P2.2; running shadow", {
+                    taskId: state.taskId,
+                });
+            }
+            const start = Date.now();
+            // The client is the initiator seat's user — the side whose negotiator is
+            // reaching out. Fresh runs stamp initiatorUserId in init; fall back to
+            // sourceUser (what the stamp defaults to anyway).
+            const initiatorId = state.initiatorUserId ?? state.sourceUser.id;
+            const clientIsSource = initiatorId !== state.candidateUser.id;
+            const clientUser = clientIsSource ? state.sourceUser : state.candidateUser;
+            const counterpartyUser = clientIsSource ? state.candidateUser : state.sourceUser;
+            let decision;
+            let failedOpen = false;
+            let screenError;
+            try {
+                const counterpartyContext = (await database.getUserContext(counterpartyUser.id, null).catch(() => null))?.text ?? "";
+                decision = await screener.invoke({
+                    clientUser,
+                    counterpartyUser,
+                    ...(counterpartyContext && { counterpartyContext }),
+                    // discoveryQuery belongs to the discovery session's source user; only
+                    // meaningful for the client when the client holds the source side.
+                    ...(clientIsSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
+                    seedAssessment: state.seedAssessment,
+                    indexContext: state.indexContext,
+                });
+            }
+            catch (err) {
+                // Fail open: a screen failure must never block a negotiation.
+                failedOpen = true;
+                screenError = err instanceof Error ? err.message : String(err);
+                screenNodeLog.warn("Screen failed; proceeding open (reach_out)", {
+                    taskId: state.taskId,
+                    opportunityId: state.opportunityId || undefined,
+                    error: screenError,
+                });
+                decision = {
+                    decision: "reach_out",
+                    reasoning: `screen_error: ${screenError}`,
+                    evidence: { counterpartyPremiseFit: "", intentAlignment: "" },
+                };
+            }
+            const durationMs = Date.now() - start;
+            const record = {
+                ...decision,
+                mode,
+                ...(failedOpen && { failedOpen, error: screenError }),
+                screenedAt: new Date().toISOString(),
+                durationMs,
+            };
+            await database.setTaskScreenDecision?.(state.taskId, record).catch((err) => {
+                screenNodeLog.error("Failed to persist screen decision", { taskId: state.taskId, error: err });
+            });
+            screenNodeLog.info("negotiation_screen", {
+                taskId: state.taskId,
+                opportunityId: state.opportunityId || undefined,
+                decision: decision.decision,
+                mode,
+                failedOpen,
+                durationMs,
+            });
+            if (state.opportunityId) {
+                emitWide({
+                    type: "negotiation_screen",
+                    opportunityId: state.opportunityId,
+                    negotiationConversationId: state.conversationId,
+                    decision: decision.decision,
+                    reasoning: decision.reasoning,
+                    mode,
+                    failedOpen,
+                    durationMs,
+                });
+            }
+            // Shadow (and pre-P2.2 enforce): always proceed to the first turn.
+            return { screenDecision: record };
+        };
         const turnNode = async (state) => {
             const traceEmitter = requestContext.getStore()?.traceEmitter;
             // Local helper to emit events whose shape is wider than the declared
@@ -167,6 +288,13 @@ export class NegotiationGraphFactory {
                 // Determine if this is the system agent's final allowed turn
                 const maxTurns = state.maxTurns ?? 0;
                 const isFinalTurn = maxTurns > 0 && (state.turnCount + 1) >= 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.
+                const version = state.protocolVersion ?? 'v1';
+                const seat = ownUser.id === (state.initiatorUserId ?? state.sourceUser.id)
+                    ? 'initiator'
+                    : 'counterparty';
                 const payload = {
                     negotiationId: state.taskId,
                     ownUser,
@@ -176,14 +304,25 @@ export class NegotiationGraphFactory {
                     history,
                     isFinalTurn,
                     isDiscoverer: isSource,
+                    seat,
+                    protocolVersion: version,
+                    allowedActions: [...allowedActionsFor(version, seat, isFinalTurn)],
                     ...(state.discoveryQuery && isSource && { discoveryQuery: state.discoveryQuery }),
                 };
                 const scope = { action: 'manage:negotiations', scopeType: 'network', scopeId: state.indexContext.networkId };
                 const dispatchResult = await dispatcher.dispatch(ownUser.id, scope, payload, { timeoutMs: state.timeoutMs });
                 let turn;
                 if (dispatchResult.handled) {
-                    // Personal agent responded
+                    // Personal agent responded. Under v2, coerce out-of-seat actions to
+                    // the conservative fallback — the polling/respond surfaces reject
+                    // these with a 400, but locally-dispatched turns land here directly.
                     turn = dispatchResult.turn;
+                    if (version === 'v2' && !allowedActionsFor(version, seat, isFinalTurn).includes(turn.action)) {
+                        turnLog.warn('Personal agent returned out-of-seat action, coercing to conservative fallback', {
+                            action: turn.action, seat, isFinalTurn,
+                        });
+                        turn = { ...turn, action: fallbackActionFor(version, seat, isFinalTurn) };
+                    }
                 }
                 else if (dispatchResult.reason === 'waiting') {
                     // Long timeout — graph suspends. Persist the full turn context so the
@@ -216,16 +355,24 @@ export class NegotiationGraphFactory {
                         history,
                         isFinalTurn,
                         isDiscoverer: isSource,
+                        seat,
+                        protocolVersion: version,
                         ...(state.discoveryQuery && isSource && { discoveryQuery: state.discoveryQuery }),
                         isContinuation: state.isContinuation,
                         ...(state.userAnswers.length > 0 && { userAnswers: state.userAnswers }),
                     });
                 }
                 traceEmitter?.({ type: "agent_end", name: agentName, durationMs: Date.now() - agentStart, summary: `${turn.action}` });
-                // First turn must be "propose" (unless continuing a prior conversation)
-                if (state.turnCount === 0 && !state.isContinuation && turn.action !== "propose") {
-                    turnLog.warn("Agent returned unexpected action on turn 0, forcing to propose", { action: turn.action });
-                    turn.action = "propose";
+                // First turn must open the negotiation (unless continuing a prior
+                // conversation): v1 → "propose"; v2 initiator → "outreach". A v2 turn-0
+                // speaker holding the counterparty seat (tie-break inheritance) is left
+                // unforced — it is responding, not opening.
+                if (state.turnCount === 0 && !state.isContinuation) {
+                    const openingAction = version === 'v2' ? 'outreach' : 'propose';
+                    if ((version !== 'v2' || seat === 'initiator') && turn.action !== openingAction) {
+                        turnLog.warn(`Agent returned unexpected action on turn 0, forcing to ${openingAction}`, { action: turn.action });
+                        turn.action = openingAction;
+                    }
                 }
                 const parts = [{ kind: "data", data: turn }];
                 const message = await database.createMessage({
@@ -267,9 +414,12 @@ export class NegotiationGraphFactory {
                 const errMsg = err instanceof Error ? err.message : String(err);
                 turnLog.error("Agent invocation failed", { error: errMsg, stack: err instanceof Error ? err.stack : undefined, turnCount: state.turnCount });
                 traceEmitter?.({ type: "agent_end", name: agentName, durationMs: Date.now() - agentStart, summary: `error: ${errMsg}` });
+                const errorSeat = (state.currentSpeaker === 'source' ? state.sourceUser.id : state.candidateUser.id) === (state.initiatorUserId ?? state.sourceUser.id)
+                    ? 'initiator'
+                    : 'counterparty';
                 return {
                     lastTurn: {
-                        action: "reject",
+                        action: rejectActionFor(state.protocolVersion ?? 'v1', errorSeat),
                         assessment: { reasoning: `Agent error: ${errMsg}`, suggestedRoles: { ownUser: "peer", otherUser: "peer" } },
                     },
                     turnCount: state.turnCount + 1,
@@ -284,9 +434,8 @@ export class NegotiationGraphFactory {
                 return "finalize";
             if (!state.lastTurn)
                 return "finalize";
-            if (state.lastTurn.action === "accept")
-                return "finalize";
-            if (state.lastTurn.action === "reject")
+            // Terminal actions: accept (v1+v2), reject (v1), withdraw/decline (v2)
+            if (isTerminalAction(state.lastTurn.action))
                 return "finalize";
             // question routes same as counter — next turn
             if ((state.maxTurns ?? 0) > 0 && state.turnCount >= state.maxTurns)
@@ -311,7 +460,7 @@ export class NegotiationGraphFactory {
             const history = turnsFromMessages(state.messages);
             const lastTurn = state.lastTurn;
             const hasOpportunity = lastTurn?.action === "accept";
-            const atCap = (state.maxTurns ?? 0) > 0 && state.turnCount >= state.maxTurns && lastTurn?.action !== "accept" && lastTurn?.action !== "reject";
+            const atCap = (state.maxTurns ?? 0) > 0 && state.turnCount >= state.maxTurns && !isTerminalAction(lastTurn?.action);
             let agreedRoles = [];
             if (hasOpportunity && history.length >= 2) {
                 const acceptTurn = history[history.length - 1];
@@ -352,7 +501,7 @@ export class NegotiationGraphFactory {
                 if (state.opportunityId) {
                     const nextStatus = lastTurn?.action === 'accept'
                         ? 'pending'
-                        : lastTurn?.action === 'reject'
+                        : isRejectLikeAction(lastTurn?.action)
                             ? 'rejected'
                             : 'stalled';
                     await database.updateOpportunityStatus(state.opportunityId, nextStatus).catch((err) => {
@@ -370,9 +519,7 @@ export class NegotiationGraphFactory {
                         ? "turn_cap"
                         : state.error && /timeout/i.test(state.error)
                             ? "timed_out"
-                            : lastTurn?.action === "reject"
-                                ? "rejected_stalled"
-                                : "rejected_stalled";
+                            : "rejected_stalled";
                 emitWide({
                     type: "negotiation_outcome",
                     opportunityId: state.opportunityId,
@@ -392,7 +539,7 @@ export class NegotiationGraphFactory {
             }
             // Enqueue question generation for stalled/capped negotiations (not accepted or explicitly rejected).
             // Require turnCount > 0 so early init/turn errors don't enqueue with empty context.
-            if (!hasOpportunity && lastTurn?.action !== 'reject' && state.turnCount > 0 && state.opportunityId && questionerEnqueue) {
+            if (!hasOpportunity && !isRejectLikeAction(lastTurn?.action) && state.turnCount > 0 && state.opportunityId && questionerEnqueue) {
                 const stallReason = atCap
                     ? 'turn_cap'
                     : (state.error && /timeout/i.test(state.error))
@@ -421,6 +568,7 @@ export class NegotiationGraphFactory {
         };
         const workflow = new StateGraph(NegotiationGraphState)
             .addNode("init", initNode)
+            .addNode("screen", screenNode)
             .addNode("turn", turnNode)
             .addNode("finalize", finalizeNode)
             .addConditionalEdges("turn", evaluateNode, {
@@ -428,8 +576,15 @@ export class NegotiationGraphFactory {
             finalize: "finalize",
         })
             .addConditionalEdges("init", (state) => {
-            return state.error ? "finalize" : "turn";
-        }, { turn: "turn", finalize: "finalize" })
+            if (state.error)
+                return "finalize";
+            // Screen gate: fresh negotiations only (continuations already passed
+            // the gate when the dialogue opened); off disables the node entirely.
+            if (!state.isContinuation && configuredScreenMode() !== "off")
+                return "screen";
+            return "turn";
+        }, { screen: "screen", turn: "turn", finalize: "finalize" })
+            .addEdge("screen", "turn")
             .addEdge("__start__", "init")
             .addEdge("finalize", "__end__");
         return workflow.compile();