@indexnetwork/protocol 22.0.0-rc.495.1 → 22.0.0-rc.496.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,6 +179,18 @@ 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
@@ -171,7 +207,11 @@ export class IndexNegotiator {
         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 : "") : "");
+            + (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 +285,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 +340,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

@@ -70,6 +70,13 @@ export declare function stanceJobFraming(stance: NegotiatorStance): string;
  * own rules. Empty under `advocate` → byte-identical.
  */
 export declare function stanceActionRules(stance: NegotiatorStance): 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 stancePreContactConsultRule(stance: NegotiatorStance): string;
 /**
  * The discovery-query satisfaction rule.
  *

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

@@ -153,6 +153,31 @@ export function stanceActionRules(stance) {
         : CONSULT_PROPENSITY_RULE;
     return VALUE_BAR_RULE + consultRule;
 }
+/**
+ * `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.496.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",