@indexnetwork/protocol 22.0.0-rc.495.1 → 22.0.0-rc.497.1

package/dist/negotiations/negotiation.agent.js

@@ -5,7 +5,8 @@ import { turnSchemaFor, fallbackActionFor } from "./negotiation.protocol.js";
 import { renderNegotiatorMemorySection } from "./negotiation.memory.js";
 import { renderNegotiatorClientDmSection } from "./negotiation.client-dm.js";
 import { renderBargainingShiftSection } from "./negotiation.deadlock.js";
-import { configuredNegotiatorStance, stanceActionRules, stanceJobFraming, stanceQuerySatisfiedRule } from "./negotiation.stance.contracts.js";
+import { configuredNegotiatorStance, stanceActionRules, stanceJobFraming, stancePreContactConsultRule, stanceQuerySatisfiedRule } from "./negotiation.stance.contracts.js";
+import { isPreContactConsultResume } from "./negotiation.consultation-policy.js";
 import { attributedDialogueIsEmpty, renderAttributedPriorDialogue } from "./negotiation.attribution.js";
 import { protocolLogger } from "../shared/observability/protocol.logger.js";
 const agentLog = protocolLogger("IndexNegotiator");
@@ -93,6 +94,29 @@ const ASK_USER_RULE = `
  */
 const ASK_USER_DM_GROUNDING_RULE = `
 - Ground the question in your conversation with {userName} about this signal (shown below) as well as in the exchange above. Do NOT ask what they have already answered there: if their own words settle the point, act on them and spend your one consultation on what is genuinely still open. Use their terms for the thing at stake — the words, numbers, and framing they used, not your paraphrase of them.`;
+/**
+ * The turn-0 third verdict, appended to `ASK_USER_RULE` on an opening
+ * initiator turn that holds the grant.
+ *
+ * Base seat-level, deliberately NOT a stance fragment. The stance renderers
+ * carry a byte-identity constraint between stances (`advocate` must render the
+ * legacy string), so delivering this through them would make the verdict
+ * available under some stances and not others — while the vocabulary the graph
+ * grants is the same for all three. A stance may still lean on a close call;
+ * that is `stancePreContactConsultRule`, appended after this.
+ *
+ * The two halves matter equally. The first says the pause is FREE: the whole
+ * cost of an outreach is that it reaches someone, and this one has not, so the
+ * pause is invisible and an unanswered pause lands exactly where a pass would.
+ * The second draws the line the admission policy cannot see — a doubt about
+ * the client's OWN criteria is theirs to settle; a candidate who plainly
+ * contradicts the signal is the agent's to judge, and asking about that spends
+ * the client's attention to confirm something already known.
+ */
+const PRE_CONTACT_ASK_USER_RULE = `
+- BEFORE ANY CONTACT, "ask_user" is a THIRD verdict on this opening turn, alongside reaching out and letting the match pass. Nothing has been sent and nothing is sent while you wait: the counterparty is never told this match was considered, and if {userName} does not answer in time the match simply passes — the same outcome as passing now, reached later.
+- Use it when ONE fact you do not hold is what stands between you and the decision, and only {userName} holds it: how their own criteria bound this search, what they meant by a term in their own signal, whether a strong candidate just outside the literal wording is in scope. Ask about the SIGNAL's scope, not about this candidate — their answer has to hold for the next candidate too.
+- Do NOT use it when the evidence in front of you already decides: if this candidate plainly does not satisfy what {userName} asked for, pass, and pass silently. A contradiction is yours to judge; making {userName} confirm it spends their attention on a decision you could already make.`;
 /** v2 counterparty seat: receiving stance — acceptance is this seat's decision alone. */
 const V2_COUNTERPARTY_RULES = `- You hold the RECEIVING seat: the other side reached out to {userName}. Whether to accept is YOUR seat's decision alone.
 - Evaluate the initiator's arguments. Either:
@@ -155,10 +179,28 @@ export class IndexNegotiator {
         // otherwise render the client's private thread with no rule explaining
         // what it is for.
         const clientDm = canAskUser ? input.clientDm ?? [] : [];
+        // The opening initiator turn: nothing has been sent, so a granted
+        // consultation is the pre-contact verdict rather than a mid-exchange
+        // pause. Derived, not passed: the graph grants `canAskUser` on a turn-0
+        // initiator turn only when the pre-contact admission and its per-signal
+        // bound both hold, so the grant plus the turn's own shape is the fact.
+        const preContactConsult = canAskUser && seat === "initiator"
+            && input.history.length === 0 && input.isContinuation !== true;
+        // The resume after such a pause. The negotiation's whole record is its own
+        // consultation park, so this is still the opening decision — the client
+        // answered, and the seat now reaches out or lets the match pass.
+        const preContactResume = version === "v2" && seat === "initiator"
+            && isPreContactConsultResume(input.history);
         // Negotiator stance (IND-611). Resolved from the environment once per turn
         // via the domain contract, exactly like `configuredScreenMode()`. Under the
         // `advocate` default every stance fragment below is the legacy string, so
         // the rendered prompt is byte-identical to the pre-IND-611 build.
+        //
+        // `stanceActionRules` also takes the resolved `seat`: the responder
+        // verification rules are a duty of the seat that did NOT open, so they
+        // render only there. The resolved seat, not `input.seat`, so the v1
+        // `isDiscoverer` fallback decides it there too — under v1 the discoverer
+        // is likewise the side that opens.
         const stance = configuredNegotiatorStance();
         const schema = turnSchemaFor(version, seat, isFinalTurn, {
             system: SystemNegotiationTurnSchema,
@@ -170,8 +212,12 @@ export class IndexNegotiator {
         const networkContext = input.indexContext.prompt || "General discovery";
         const actionRules = (version === "v2"
             ? (seat === "initiator" ? V2_INITIATOR_RULES : V2_COUNTERPARTY_RULES)
-            : V1_ACTION_RULES) + stanceActionRules(stance)
-            + (canAskUser ? ASK_USER_RULE + (clientDm.length > 0 ? ASK_USER_DM_GROUNDING_RULE : "") : "");
+            : V1_ACTION_RULES) + stanceActionRules(stance, seat)
+            + (canAskUser
+                ? ASK_USER_RULE
+                    + (preContactConsult ? PRE_CONTACT_ASK_USER_RULE + stancePreContactConsultRule(stance) : "")
+                    + (clientDm.length > 0 ? ASK_USER_DM_GROUNDING_RULE : "")
+                : "");
         const finalTurnInstruction = input.isFinalTurn
             ? (version === "v2"
                 ? (seat === "initiator"
@@ -245,11 +291,20 @@ ${stanceQuerySatisfiedRule(stance, otherName, userName)}`
         // "make your own case for it" — which, for the initiator seat, reads as
         // an instruction to re-open, and produced a fresh outreach on every one
         // of its turns instead of a reply.
-        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.'
-            : input.history.length > 0
-                ? 'Policy: This negotiation is already under way — the turns above under the current opportunity are THIS exchange. Respond to the counterparty\'s latest turn; do not restate or re-pitch your opening.'
-                : '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.';
+        //
+        // A pre-contact resume is checked FIRST. It reads as a continuation to
+        // every existing test here (`isContinuation` is true — the negotiation has
+        // spoken), but the only thing it said was its own pause, and both the
+        // continuation policy ("you may resolve quickly") and the mid-exchange
+        // policy ("respond to the counterparty's latest turn") describe an
+        // exchange that has not happened.
+        const priorDialoguePolicy = preContactResume
+            ? `Policy: You have NOT contacted ${otherName} about this signal. The only turn above is your own pause to consult ${userName} before deciding — there is no exchange to respond to, and nothing has been sent. This is still the opening decision.`
+            : 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.'
+                : input.history.length > 0
+                    ? 'Policy: This negotiation is already under way — the turns above under the current opportunity are THIS exchange. Respond to the counterparty\'s latest turn; do not restate or re-pitch your opening.'
+                    : '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}"`
@@ -291,7 +346,11 @@ ${input.otherUser.intents.map((i) => `- ${i.title}: ${i.description}`).join("\n"
 
 Why this match was suggested: ${input.seedAssessment.reasoning}${hasPriorDialogue ? priorDialogueContext : historyText}${clientDmContext}${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."}`;
+${preContactResume
+            ? `You paused this opening turn to ask ${userName} the one thing you could not decide without. Their answer is above. Take the opening decision now: "outreach" to make the case, or "withdraw" to let the match pass without ever contacting ${otherName}.`
+            : 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 = [
             { role: "system", content: systemPrompt },
             { role: "user", content: userMessage },

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

@@ -36,3 +36,60 @@ export declare function consultationPromptFor(reason: NegotiationConsultationRea
     disclosureSubject: string;
     draftQuestion: string;
 };
+/**
+ * How many pre-contact consultations one intent may hold OPEN at once.
+ *
+ * A vague signal can surface many candidates in a batch, and the doubt that
+ * blocks the first ("does 'academic linguistics' strictly bound this, or is
+ * adjacent depth in scope?") is usually the same doubt that blocks all of
+ * them. One answer generalizes: it lands in the signal's DM, and the DM is
+ * injected into every later turn-0 decision on that signal. The cap exists
+ * for the agent that does not internalize that and would interrogate its
+ * client candidate-by-candidate.
+ *
+ * Two, not one: a second genuinely different question about the same signal
+ * is plausible, a third is a pattern. Past the cap the action is simply not
+ * offered and the seat falls back to today's binary reach-out-or-pass.
+ */
+export declare const MAX_OPEN_PRE_CONTACT_CONSULTS_PER_INTENT = 2;
+/**
+ * Whether a negotiation's own turns show it has never contacted the
+ * counterparty — every turn it holds is a client-consultation park.
+ *
+ * This is what makes a post-consult resume still-the-opening. A mid-flight
+ * consult always has an `outreach` behind it (the counterparty seat cannot
+ * even speak before one), so this is false for every park the pre-contact
+ * verdict did not create, and the resume rules it gates stay off the
+ * mid-flight path by construction rather than by a flag.
+ */
+export declare function isPreContactConsultResume(turns: readonly {
+    action: NegotiationAction;
+}[]): boolean;
+/**
+ * Turn-context key stamped on a pre-contact park. Written at park time beside
+ * the ask-user binding, read back by {@link countOpenPreContactConsults} — the
+ * park row is the only durable record of the consultation, so the marker lives
+ * with it rather than in a separate counter that could drift.
+ */
+export declare const PRE_CONTACT_CONSULT_MARKER = "preContactConsult";
+/** Minimal task shape the open-consult count reads; matches `getTasksForUser`. */
+export interface PreContactConsultTaskRow {
+    id: string;
+    state: string;
+    metadata: Record<string, unknown> | null;
+}
+/**
+ * Count the pre-contact consultations currently open for one `(user, intent)`
+ * scope, from the user's own negotiation tasks.
+ *
+ * "Open" is derived from the durable park itself — an `input_required` task
+ * whose captured ask-user binding names this recipient pair and whose turn
+ * context carries the pre-contact stamp — so answering, expiry, and resume all
+ * retire a park from the count with no counter to keep in step. Mid-flight
+ * consults carry no stamp and never count.
+ */
+export declare function countOpenPreContactConsults(tasks: readonly PreContactConsultTaskRow[], scope: {
+    userId: string;
+    intentId: string;
+    excludeTaskId?: string;
+}): number;

package/dist/negotiations/negotiation.consultation-policy.js

@@ -13,7 +13,6 @@ export function negotiationConsultationPolicyMode() {
  */
 export function assessConsultationEligibility(input) {
     if (input.protocolVersion !== "v2"
-        || input.isOpeningTurn
         || input.isFinalTurn
         || input.screenedOut
         || input.previouslyConsulted
@@ -21,6 +20,40 @@ export function assessConsultationEligibility(input) {
         || !input.lifecycleValid
         || isObviousTerminal(input.action))
         return { eligible: false };
+    // ─── Pre-contact consultation (the opening turn) ──────────────────────────
+    // Before this branch the opening turn was a blanket exclusion, so the
+    // initiator's turn-0 vocabulary was binary: reach out, or pass with the
+    // counterparty never contacted. A third verdict is admissible when the
+    // blocking doubt is one only the client can settle — how their own criteria
+    // bound the search — and the pause costs the counterparty nothing, because
+    // nothing has been sent.
+    //
+    // The admission is deliberately NARROW, and narrower than the mid-flight
+    // rules below:
+    //
+    //  - INITIATOR ONLY. A turn-0 counterparty seat (tie-break inheritance) is
+    //    responding to an outreach, so its client's criteria are not what is
+    //    blocking; there is no pre-contact position to protect either.
+    //  - A MODEL-AUTHORED `ask_user` ONLY. Every rule below infers a
+    //    consultation from a draft that asked for something else, which needs
+    //    history to be a safe inference — and at turn 0 there is none. The
+    //    acting agent is the only party that has read the client's own signal,
+    //    so the pre-contact case is the one where volunteering the pause is the
+    //    evidence, not a substitute for it. This also keeps the distinction the
+    //    graph prompt draws — client-resolvable scope doubt consults;
+    //    counterparty evidence that contradicts the match passes silently —
+    //    resolvable HERE only as "the agent did not ask", which is exactly what
+    //    a contradiction-shaped doubt produces.
+    //
+    // The category is fixed rather than read off the draft: a pre-contact pause
+    // is by construction an unresolved constraint the OWNER controls. The
+    // consult counts as an ordinary ask round (the graph reads the same
+    // `negotiationAskRoundsCap` substrate before granting the action at all).
+    if (input.isOpeningTurn) {
+        return input.seat === "initiator" && input.action === "ask_user"
+            ? { eligible: true, reason: "unresolved_owner_constraint" }
+            : { eligible: false };
+    }
     // A patient-side counter is a schema-constrained, source-safe signal that
     // the owner must decide whether a consequential disclosure or permission is
     // acceptable. This is reachable under the normal v2 action vocabulary; it
@@ -66,3 +99,61 @@ export function consultationPromptFor(reason) {
 function isObviousTerminal(action) {
     return action === "accept" || action === "reject" || action === "withdraw" || action === "decline";
 }
+// ─── Pre-contact consultation: bounds and recognition ────────────────────────
+/**
+ * How many pre-contact consultations one intent may hold OPEN at once.
+ *
+ * A vague signal can surface many candidates in a batch, and the doubt that
+ * blocks the first ("does 'academic linguistics' strictly bound this, or is
+ * adjacent depth in scope?") is usually the same doubt that blocks all of
+ * them. One answer generalizes: it lands in the signal's DM, and the DM is
+ * injected into every later turn-0 decision on that signal. The cap exists
+ * for the agent that does not internalize that and would interrogate its
+ * client candidate-by-candidate.
+ *
+ * Two, not one: a second genuinely different question about the same signal
+ * is plausible, a third is a pattern. Past the cap the action is simply not
+ * offered and the seat falls back to today's binary reach-out-or-pass.
+ */
+export const MAX_OPEN_PRE_CONTACT_CONSULTS_PER_INTENT = 2;
+/**
+ * Whether a negotiation's own turns show it has never contacted the
+ * counterparty — every turn it holds is a client-consultation park.
+ *
+ * This is what makes a post-consult resume still-the-opening. A mid-flight
+ * consult always has an `outreach` behind it (the counterparty seat cannot
+ * even speak before one), so this is false for every park the pre-contact
+ * verdict did not create, and the resume rules it gates stay off the
+ * mid-flight path by construction rather than by a flag.
+ */
+export function isPreContactConsultResume(turns) {
+    return turns.length > 0 && turns.every((turn) => turn.action === "ask_user");
+}
+/**
+ * Turn-context key stamped on a pre-contact park. Written at park time beside
+ * the ask-user binding, read back by {@link countOpenPreContactConsults} — the
+ * park row is the only durable record of the consultation, so the marker lives
+ * with it rather than in a separate counter that could drift.
+ */
+export const PRE_CONTACT_CONSULT_MARKER = "preContactConsult";
+/**
+ * Count the pre-contact consultations currently open for one `(user, intent)`
+ * scope, from the user's own negotiation tasks.
+ *
+ * "Open" is derived from the durable park itself — an `input_required` task
+ * whose captured ask-user binding names this recipient pair and whose turn
+ * context carries the pre-contact stamp — so answering, expiry, and resume all
+ * retire a park from the count with no counter to keep in step. Mid-flight
+ * consults carry no stamp and never count.
+ */
+export function countOpenPreContactConsults(tasks, scope) {
+    return tasks.filter((task) => {
+        if (task.state !== "input_required" || task.id === scope.excludeTaskId)
+            return false;
+        const turnContext = task.metadata?.turnContext;
+        if (turnContext?.[PRE_CONTACT_CONSULT_MARKER] !== true)
+            return false;
+        const binding = turnContext.askUserBinding;
+        return binding?.recipientUserId === scope.userId && binding.recipientIntentId === scope.intentId;
+    }).length;
+}

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

@@ -3,12 +3,48 @@
  */
 import { requestContext } from "../shared/observability/request-context.js";
 import { allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, fallbackActionFor, negotiationAskRoundsCap, rejectActionFor } from "./negotiation.protocol.js";
-import { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode } from "./negotiation.consultation-policy.js";
+import { assessConsultationEligibility, consultationPromptFor, countOpenPreContactConsults, isPreContactConsultResume, MAX_OPEN_PRE_CONTACT_CONSULTS_PER_INTENT, negotiationConsultationPolicyMode, PRE_CONTACT_CONSULT_MARKER } 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, isSafeAuthoredNegotiationQuestion, negotiationQuestionSettlementId } from './negotiation.question-safety.js';
 import { isNegotiationTurnCapReached } from "./negotiation.turn-cap.js";
 import { buildAttributedDialogue, countNegotiationAskRounds, hasPriorAskUser, memoryQueryText, retrieveClientDm, retrieveMemory, turnLog, turnsFromMessages } from "./negotiation.graph.shared.js";
+/**
+ * Whether this signal may open another pre-contact consultation.
+ *
+ * The count comes from the user's own parked negotiation tasks — the durable
+ * parks themselves — rather than a stored counter, so an answered, expired, or
+ * resumed park frees its slot with nothing to keep in step. The acting task is
+ * excluded: it is `working` at this point, but a retried turn on a task that
+ * already parked must not count itself out.
+ *
+ * Fails OPEN. This bound defends against an agent that would re-ask the same
+ * signal-level question candidate by candidate; it is not the safety gate. The
+ * per-negotiation ration and the ask-rounds cap already hold that line from
+ * the message record, and neither depends on this query — so a database blip
+ * must not silently retire the turn-0 verdict.
+ */
+async function preContactConsultsUnderCap(deps, userId, intentId, actingTaskId) {
+    try {
+        const parked = await deps.database.getTasksForUser(userId, { state: 'input_required' });
+        const open = countOpenPreContactConsults(parked, { userId, intentId, excludeTaskId: actingTaskId });
+        if (open >= MAX_OPEN_PRE_CONTACT_CONSULTS_PER_INTENT) {
+            turnLog.info('negotiation_pre_contact_consult_capped', {
+                userId, intentId, open, cap: MAX_OPEN_PRE_CONTACT_CONSULTS_PER_INTENT,
+            });
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        turnLog.warn('Pre-contact consult cap check failed; proceeding without the per-signal bound', {
+            userId,
+            intentId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return true;
+    }
+}
 export async function turnNode(state, deps) {
     const traceEmitter = requestContext.getStore()?.traceEmitter;
     // Local helper to emit events whose shape is wider than the declared
@@ -45,7 +81,24 @@ export async function turnNode(state, deps) {
         // also persist `ask_user` messages — count against the same budget,
         // and a negotiation near its cap cannot spend a further round here.
         const policyMode = negotiationConsultationPolicyMode();
-        const askUserAvailable = version === 'v2'
+        // The opening turn, before anything is sent. `outreachOpened` is per-run
+        // and history is this negotiation's own record, so this is true exactly
+        // once per negotiation — and stays true across a pre-contact park, whose
+        // resume re-enters holding nothing but its own `ask_user` turn.
+        const isFreshOpeningTurn = state.turnCount === 0 && !state.isContinuation;
+        const isPreContactResume = state.turnCount === 0 && isPreContactConsultResume(history);
+        // Pre-contact consultation (the turn-0 third verdict). The initiator may
+        // consult its client BEFORE deciding whether to reach out, so the seat's
+        // opening vocabulary stops being binary. Everything downstream is the
+        // shipped consult loop unchanged: same park, same binding, same question
+        // routing, same expiry. Only admission moves.
+        //
+        // Bounded twice over. Per negotiation by the same ration and ask-rounds
+        // cap the mid-flight consult reads (this consult IS round 1). Per signal
+        // by the open-park count below, so one vague intent cannot interrogate
+        // its client candidate-by-candidate.
+        const preContactConsultShapeAvailable = isFreshOpeningTurn && seat === 'initiator';
+        const askUserWiringAvailable = version === 'v2'
             && !isFinalTurn
             && configuredAskUserEnabled()
             && !!deps.questionerEnqueue
@@ -53,9 +106,12 @@ export async function turnNode(state, deps) {
             && !!state.opportunityId
             && !!ownIntentId
             && !!state.indexContext.networkId
-            && !(state.turnCount === 0 && !state.isContinuation)
+            && (!isFreshOpeningTurn || preContactConsultShapeAvailable)
             && !hasPriorAskUser(state.messages, ownUser.id)
             && countNegotiationAskRounds(state.messages) < negotiationAskRoundsCap();
+        const askUserAvailable = askUserWiringAvailable
+            && (!preContactConsultShapeAvailable
+                || await preContactConsultsUnderCap(deps, ownUser.id, ownIntentId, state.taskId));
         // ─── Deadlock detection → persuasion→bargaining stance (IND-428) ──────
         // Deterministic trailing-run inspection of the persisted history — no
         // LLM in the decision. Gated on the strict default-off flag AND v2,
@@ -215,7 +271,17 @@ export async function turnNode(state, deps) {
         // Exact ask_user resumes are exempt: the successor is the SAME logical
         // negotiation resumed after the client answered, so post-consultation
         // withdraw is legitimate.
-        if (turn.action === 'withdraw' && !state.outreachOpened && !state.continuationExecution) {
+        //
+        // A PRE-CONTACT resume is exempt from that exemption. The exemption exists
+        // because a mid-flight consult has an outreach behind it — there is a
+        // message on the table, and walking away from it is a real move. A
+        // pre-contact park has nothing behind it: the counterparty was never
+        // contacted, so the post-consult refusal is still the opening refusal and
+        // must land on the same quiet `screened_out` outcome the unconsulted pass
+        // lands on. This is also what makes an UNANSWERED pre-contact consult
+        // resolve to today's behavior — the expiry worker resumes through exactly
+        // this path.
+        if (turn.action === 'withdraw' && !state.outreachOpened && (!state.continuationExecution || isPreContactResume)) {
             turnLog.info('negotiation_opening_withdraw_screened_out', {
                 taskId: state.taskId,
                 opportunityId: state.opportunityId || undefined,
@@ -234,11 +300,21 @@ export async function turnNode(state, deps) {
         // A legitimate turn-0 refusal never reaches here: the opening-withdraw
         // guard above already returned. What remains are genuinely malformed
         // openings (a turn-0 `counter`/`question`), which are still coerced.
-        if (state.turnCount === 0 && !state.isContinuation) {
+        //
+        // A pre-contact resume is coerced by the same rule: nothing was ever sent,
+        // so the negotiation still has to OPEN, and a `counter`/`question` there
+        // would make the counterparty's first sight of this match a mid-exchange
+        // reply. An admissible `ask_user` is the one non-opening action left to
+        // stand — it is the turn-0 third verdict, not a malformed opening.
+        if (isFreshOpeningTurn || isPreContactResume) {
             const openingAction = version === 'v2' ? 'outreach' : 'propose';
-            if ((version !== 'v2' || seat === 'initiator') && turn.action !== openingAction) {
+            const consultingInstead = turn.action === 'ask_user' && askUserAvailable;
+            if ((version !== 'v2' || seat === 'initiator') && turn.action !== openingAction && !consultingInstead) {
                 turnLog.warn(`Agent returned unexpected action on turn 0, forcing to ${openingAction}`, { action: turn.action });
-                turn.action = openingAction;
+                // Rebind rather than mutate: `turn` may be the very object a dispatched
+                // personal agent returned, and every other rewrite in this function
+                // already replaces it instead of editing it in place.
+                turn = { ...turn, action: openingAction };
             }
         }
         // IND-508 deterministic admission is evaluated only after the opening
@@ -249,7 +325,7 @@ export async function turnNode(state, deps) {
         const policyEligibility = policyMode === 'off' ? { eligible: false } : assessConsultationEligibility({
             protocolVersion: version,
             seat,
-            isOpeningTurn: state.turnCount === 0 && !state.isContinuation,
+            isOpeningTurn: isFreshOpeningTurn,
             isFinalTurn,
             screenedOut: blocksNegotiationBeforeFirstTurn(state.screenDecision, state.turnCount),
             action: turn.action,
@@ -272,17 +348,36 @@ export async function turnNode(state, deps) {
         if (policyEligibility.eligible && policyEligibility.reason) {
             emitConsultationTelemetry('eligible', policyEligibility.reason);
             if (policyMode === 'on') {
-                consultationPolicyReason = policyEligibility.reason;
-                turn = {
-                    ...turn,
-                    action: 'ask_user',
-                    message: null,
-                    assessment: {
-                        reasoning: 'Client consultation required.',
-                        suggestedRoles: turn.assessment.suggestedRoles,
-                    },
-                    askUser: { reason: consultationPolicyReason },
-                };
+                // Two shapes reach here and the policy owes them different things.
+                //
+                // A draft that asked for something ELSE is REPLACED: the policy
+                // inferred the consultation, so nothing in that draft was written to
+                // be read by the client, and its reasoning/message may carry material
+                // the client's question must not (the disclosure and authority
+                // categories are inferred from exactly such drafts).
+                //
+                // A draft that already IS `ask_user` is only ADMITTED. Here the policy
+                // is the gate, not the author: the agent volunteered the pause and
+                // wrote the question its client reads, and it is the only party that
+                // has read this negotiation. Overwriting `askUser` would discard that
+                // question and park on a server template — which is what the
+                // pre-contact verdict has nothing to fall back on, since a turn-0
+                // park has no transcript for the client to read instead. The authored
+                // payload still faces the identifier-aware safety gate below.
+                const draftedOwnConsultation = turn.action === 'ask_user' && !!turn.askUser;
+                consultationPolicyReason = draftedOwnConsultation ? turn.askUser.reason : policyEligibility.reason;
+                if (!draftedOwnConsultation) {
+                    turn = {
+                        ...turn,
+                        action: 'ask_user',
+                        message: null,
+                        assessment: {
+                            reasoning: 'Client consultation required.',
+                            suggestedRoles: turn.assessment.suggestedRoles,
+                        },
+                        askUser: { reason: consultationPolicyReason },
+                    };
+                }
                 emitConsultationTelemetry('asked', consultationPolicyReason);
             }
         }
@@ -412,6 +507,11 @@ export async function turnNode(state, deps) {
                     seedAssessment: state.seedAssessment,
                     ...(isSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
                     ...(consultationReason && { consultationPolicyReason: consultationReason }),
+                    // Marks a park the counterparty has never been contacted about, so
+                    // the per-signal open-consult cap can count these without counting
+                    // mid-flight consults. Read back by `countOpenPreContactConsults`;
+                    // the park row is the only durable record, so the stamp lives on it.
+                    ...(isFreshOpeningTurn ? { [PRE_CONTACT_CONSULT_MARKER]: true } : {}),
                 },
                 ...(state.continuationExecution ? { continuationExecution: state.continuationExecution } : {}),
             });

package/dist/negotiations/negotiation.stance.contracts.d.ts

@@ -9,11 +9,11 @@
  *
  * `NEGOTIATOR_STANCE` makes that stance configurable instead of hard-coded:
  *
- * | stance      | framing                              | value bar        | query rule              | consult propensity      | deadlock  |
- * |-------------|--------------------------------------|------------------|-------------------------|-------------------------|-----------|
- * | `advocate`  | argue the case (today)               | none             | mandate (today)         | none (today)            | bargain   |
- * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| prefer over assumption  | bargain   |
- * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| + unverified = don't proceed | stalemate |
+ * | stance      | framing                              | value bar        | query rule              | consult propensity      | responder check          | deadlock  |
+ * |-------------|--------------------------------------|------------------|-------------------------|-------------------------|--------------------------|-----------|
+ * | `advocate`  | argue the case (today)               | none             | mandate (today)         | none (today)            | none (today)             | bargain   |
+ * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| prefer over assumption  | verify the opening       | bargain   |
+ * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| + unverified = don't proceed | + probe before accepting | stalemate |
  *
  * Design constraints (hard):
  * - **`advocate` is byte-identical.** Every fragment below is additive and
@@ -35,7 +35,16 @@
  * Fragments deliberately never contain the literal `ask_user` or a quoted
  * `"withdraw"`: they render into every seat and protocol version, and the seat
  * specs pin that those tokens appear only where the seat legally holds them.
+ *
+ * One family of fragments is the exception to that seat-blindness by
+ * construction rather than by accident: the responder verification rules
+ * (`stanceVerifiesResponderFit`) address a duty only the RESPONDING seat has —
+ * reading someone else's opening — so `stanceActionRules` takes the seat and
+ * renders them only there. They still name no action and no mechanism, so the
+ * seat's own rules and the graph's grants stay the sole authority on what this
+ * turn may actually do.
  */
+import type { NegotiationSeat } from "../shared/schemas/negotiation-state.schema.js";
 export declare const NEGOTIATOR_STANCES: readonly ["advocate", "evaluator", "skeptic"];
 export type NegotiatorStance = (typeof NEGOTIATOR_STANCES)[number];
 export declare const DEFAULT_NEGOTIATOR_STANCE: NegotiatorStance;
@@ -55,6 +64,11 @@ export declare function stanceAppliesValueBar(stance: NegotiatorStance): boolean
  * continuing to evaluate rather than as a mandate to connect.
  */
 export declare function stanceQueryMatchIsNecessaryNotSufficient(stance: NegotiatorStance): boolean;
+/**
+ * Whether this stance asks the RESPONDING seat to verify the opening's account
+ * of the fit before accepting it, rather than reading that account as evidence.
+ */
+export declare function stanceVerifiesResponderFit(stance: NegotiatorStance): boolean;
 /** Whether a detected deadlock resolves by stalemate rather than bargaining. */
 export declare function stanceResolvesDeadlockByStalemate(stance: NegotiatorStance): boolean;
 /**
@@ -68,8 +82,20 @@ export declare function stanceJobFraming(stance: NegotiatorStance): string;
 /**
  * Extra action-rule lines contributed by the stance, appended after the seat's
  * own rules. Empty under `advocate` → byte-identical.
+ *
+ * `seat` scopes the responder verification rules to the seat that did NOT
+ * open. Everything else here is seat-blind: the value bar and the consult
+ * propensity are duties of both seats, and the seat parameter must not become
+ * a reason to fork them.
+ */
+export declare function stanceActionRules(stance: NegotiatorStance, seat: NegotiationSeat): string;
+/**
+ * Stance contribution to the pre-contact consultation rule. Empty under
+ * `advocate` and `evaluator` — the base seat-level rule already states when
+ * the verdict applies, and only the skeptic's not-worth-making prior changes
+ * which way a close call should fall.
  */
-export declare function stanceActionRules(stance: NegotiatorStance): string;
+export declare function stancePreContactConsultRule(stance: NegotiatorStance): string;
 /**
  * The discovery-query satisfaction rule.
  *

package/dist/negotiations/negotiation.stance.contracts.js

@@ -9,11 +9,11 @@
  *
  * `NEGOTIATOR_STANCE` makes that stance configurable instead of hard-coded:
  *
- * | stance      | framing                              | value bar        | query rule              | consult propensity      | deadlock  |
- * |-------------|--------------------------------------|------------------|-------------------------|-------------------------|-----------|
- * | `advocate`  | argue the case (today)               | none             | mandate (today)         | none (today)            | bargain   |
- * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| prefer over assumption  | bargain   |
- * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| + unverified = don't proceed | stalemate |
+ * | stance      | framing                              | value bar        | query rule              | consult propensity      | responder check          | deadlock  |
+ * |-------------|--------------------------------------|------------------|-------------------------|-------------------------|--------------------------|-----------|
+ * | `advocate`  | argue the case (today)               | none             | mandate (today)         | none (today)            | none (today)             | bargain   |
+ * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| prefer over assumption  | verify the opening       | bargain   |
+ * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| + unverified = don't proceed | + probe before accepting | stalemate |
  *
  * Design constraints (hard):
  * - **`advocate` is byte-identical.** Every fragment below is additive and
@@ -35,6 +35,14 @@
  * Fragments deliberately never contain the literal `ask_user` or a quoted
  * `"withdraw"`: they render into every seat and protocol version, and the seat
  * specs pin that those tokens appear only where the seat legally holds them.
+ *
+ * One family of fragments is the exception to that seat-blindness by
+ * construction rather than by accident: the responder verification rules
+ * (`stanceVerifiesResponderFit`) address a duty only the RESPONDING seat has —
+ * reading someone else's opening — so `stanceActionRules` takes the seat and
+ * renders them only there. They still name no action and no mechanism, so the
+ * seat's own rules and the graph's grants stay the sole authority on what this
+ * turn may actually do.
  */
 export const NEGOTIATOR_STANCES = ["advocate", "evaluator", "skeptic"];
 export const DEFAULT_NEGOTIATOR_STANCE = "advocate";
@@ -63,6 +71,13 @@ export function stanceAppliesValueBar(stance) {
 export function stanceQueryMatchIsNecessaryNotSufficient(stance) {
     return stance !== "advocate";
 }
+/**
+ * Whether this stance asks the RESPONDING seat to verify the opening's account
+ * of the fit before accepting it, rather than reading that account as evidence.
+ */
+export function stanceVerifiesResponderFit(stance) {
+    return stance !== "advocate";
+}
 /** Whether a detected deadlock resolves by stalemate rather than bargaining. */
 export function stanceResolvesDeadlockByStalemate(stance) {
     return stance === "skeptic";
@@ -141,17 +156,91 @@ const CONSULT_PROPENSITY_RULE = `
  * reason not to proceed, and consulting the client is how it gets verified.
  */
 const SKEPTIC_CONSULT_SHARPENING = ` For you this is a gate, not a preference: an UNVERIFIED assumption that the two sides' intents actually align is a reason NOT to proceed, and consulting {userName} is how that assumption gets verified.`;
+/**
+ * Responder verification — assessing stances, RESPONDING seat only.
+ *
+ * Two structural gaps this closes, both visible in the failure it was written
+ * for: a first-contact outreach accepted in one exchange, on reasoning that
+ * restated the opening's own fit claim back as the reason for accepting.
+ *
+ * 1. The opening enters the prompt as if it were evidence. It is not: it is
+ *    advocacy authored by the counterparty's agent, and its most load-bearing
+ *    move is characterizing what THIS client wants. Nothing else in the prompt
+ *    tells the responding seat to treat that characterization as a claim.
+ * 2. `VALUE_BAR_RULE` has no bite in this seat. "Most matches are not worth
+ *    making" reads as being about MAKING matches, and a responder frames its
+ *    decision as "would my client be open to connecting?" — nearly costless,
+ *    nearly certain to be yes. So the same opportunity-cost currency is
+ *    restated in the terms this seat actually spends it: accepting puts a
+ *    connection in front of the client for approval.
+ *
+ * Conditional by construction: the steer applies where the fit case RESTS on
+ * the initiator's interpretation. A match the client's own criteria and the
+ * counterparty's own evidence support independently may still be accepted on
+ * first contact — which is why no "always"/"never accept" wording appears here
+ * and a spec pins its absence.
+ *
+ * Names no action and no mechanism, like every other fragment in this module:
+ * "one more exchange" and "consulting {userName}" describe the move, and the
+ * seat's own rules decide which token carries it (and whether the grant for it
+ * is even live this turn).
+ */
+const RESPONDER_VERIFICATION_RULE = `
+- THE OPENING IS ADVOCACY, NOT EVIDENCE: what reached {userName} was written by the other side's agent to make this match sound worth taking, and its account of the fit — what {userName} is looking for, why the two sides line up — is that agent's CLAIM about {userName}, not a fact you have checked. Test it against {userName}'s OWN intent and against what the counterparty's own profile and intents actually show. Restating the opening's fit claim back as your reason is agreement, not verification.
+- WHAT ACCEPTING SPENDS: accepting is not the free or agreeable option — it puts a connection in front of {userName} for approval and spends the same finite attention the bar above governs. "Would {userName} be open to connecting?" is a bar almost anything clears, and it is not the bar. An accept on the first exchange has to be grounded in what {userName} themselves stated they were looking for, met by evidence about the counterparty that stands up without the opening's reading of it. Where the case for fit still rests on how the other agent characterized {userName}'s needs, the cheap move is one more exchange — put the specific gap to them, or counter with what would have to be true — and where the doubt is about {userName}'s own criteria rather than the counterparty's evidence, consulting {userName} settles it instead.`;
+/**
+ * `skeptic` sharpening of the responder rule, appended to the same bullet (the
+ * same additive pattern as `SKEPTIC_CONSULT_SHARPENING`): under the
+ * not-worth-making prior, closing on the opening alone is the exception rather
+ * than the default. The escape hatch is restated explicitly here because this
+ * is where the pressure is highest and an over-read would turn a lean into a
+ * ban on first-contact accepts.
+ */
+const SKEPTIC_RESPONDER_SHARPENING = ` For you an accept on the first exchange is the exception, not the default: where the fit case still rests on the opening's own characterization, probe once before accepting — one exchange costs the counterparty nothing and {userName} very little, while an accept you cannot ground spends their attention on a match no one has checked. Where {userName}'s stated criteria and the counterparty's own evidence carry the fit without that characterization, accepting straight away is still the right call.`;
 /**
  * Extra action-rule lines contributed by the stance, appended after the seat's
  * own rules. Empty under `advocate` → byte-identical.
+ *
+ * `seat` scopes the responder verification rules to the seat that did NOT
+ * open. Everything else here is seat-blind: the value bar and the consult
+ * propensity are duties of both seats, and the seat parameter must not become
+ * a reason to fork them.
  */
-export function stanceActionRules(stance) {
+export function stanceActionRules(stance, seat) {
     if (!stanceAppliesValueBar(stance))
         return "";
     const consultRule = stance === "skeptic"
         ? CONSULT_PROPENSITY_RULE + SKEPTIC_CONSULT_SHARPENING
         : CONSULT_PROPENSITY_RULE;
-    return VALUE_BAR_RULE + consultRule;
+    const responderRule = seat === "counterparty" && stanceVerifiesResponderFit(stance)
+        ? RESPONDER_VERIFICATION_RULE + (stance === "skeptic" ? SKEPTIC_RESPONDER_SHARPENING : "")
+        : "";
+    return VALUE_BAR_RULE + consultRule + responderRule;
+}
+/**
+ * `skeptic` sharpening of the pre-contact consultation rule (the turn-0 third
+ * verdict). Appended to the base rule in `negotiation.agent.ts`, which renders
+ * it only on an opening initiator turn that actually holds the grant — so
+ * unlike every other fragment here this one is not seat- and version-blind,
+ * and does not need to be: it can never reach a seat without the vocabulary.
+ *
+ * The base rule sets when consulting is warranted. This sets which way to lean
+ * when it is genuinely a toss-up, and the skeptic's prior is what makes the
+ * lean asymmetric: under "most matches are not worth making" a pass is the
+ * cheap default, which is exactly why an unverified pass deserves the same
+ * suspicion as an unverified acceptance. Both decide for the client.
+ *
+ * Names no action and no mechanism, like the rest of this module.
+ */
+const SKEPTIC_PRE_CONTACT_LEAN = ` When it is genuinely close, lean toward asking rather than passing. Your prior is that most matches are not worth making — which makes passing the cheap answer, and a pass you reached by GUESSING at {userName}'s own criteria decides for them just as much as a connection you made by guessing. Nothing has been spent yet: the pause costs the counterparty nothing and costs {userName} one question.`;
+/**
+ * Stance contribution to the pre-contact consultation rule. Empty under
+ * `advocate` and `evaluator` — the base seat-level rule already states when
+ * the verdict applies, and only the skeptic's not-worth-making prior changes
+ * which way a close call should fall.
+ */
+export function stancePreContactConsultRule(stance) {
+    return stance === "skeptic" ? SKEPTIC_PRE_CONTACT_LEAN : "";
 }
 /**
  * The discovery-query satisfaction rule.

package/package.json

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