@indexnetwork/protocol 6.14.0-rc.406.1 → 8.0.1-rc.417.1

package/dist/negotiation/application/negotiation.graph.js

@@ -624,22 +624,19 @@ export class NegotiationGraphFactory {
                     });
                 }
                 traceEmitter?.({ type: "agent_end", name: agentName, durationMs: Date.now() - agentStart, summary: `${turn.action}` });
-                // 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;
-                    }
-                }
-                // IND-564: block a `withdraw` that comes before the initiator has opened
-                // (no in-task `outreach`) — this would retract a message never made and
-                // drop a spurious message into the shared thread. Exact ask_user resumes
-                // are exempt: the successor is the SAME logical negotiation resumed after
-                // the client answered, so post-consultation withdraw is legitimate.
+                // IND-564 / IND-611: the opening-withdraw guard runs BEFORE the turn-0
+                // opening force below. Order matters and used to be inverted: the force
+                // rewrote a turn-0 `withdraw` into `outreach` first, which (a) made this
+                // guard dead code for a v2 initiator on turn 0 and (b) sent an outreach
+                // whose surviving `reasoning` argued against the match to the
+                // counterparty. An honest turn-0 refusal is now allowed to stand and
+                // flows into the existing quiet `screened_out` path — no message is
+                // persisted, so the original guard's intent (never retract a message
+                // that was never made) is preserved rather than weakened.
+                //
+                // 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) {
                     turnLog.info('negotiation_opening_withdraw_screened_out', {
                         taskId: state.taskId,
@@ -651,6 +648,21 @@ export class NegotiationGraphFactory {
                     traceEmitter?.({ type: "agent_end", name: agentName, durationMs: Date.now() - agentStart, summary: "screened_out: opening withdraw" });
                     return { lastTurn: turn, firstTurnScreenedOut: true };
                 }
+                // 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.
+                //
+                // 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) {
+                    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;
+                    }
+                }
                 // IND-508 deterministic admission is evaluated only after the opening
                 // guard but before any turn is persisted. It consumes action/role enums
                 // only; free-form reasoning, messages, profiles, and evaluator inputs
@@ -1015,7 +1027,17 @@ export class NegotiationGraphFactory {
             // IND-564: an opening-move `withdraw` blocked before any message was
             // persisted is the same quiet screen-out outcome (no in-task outreach to
             // retract), reached from the turn node rather than the screen node.
-            const screenedOut = blocksNegotiationBeforeFirstTurn(state.screenDecision, state.turnCount) || state.firstTurnScreenedOut === true;
+            // Two DISTINCT routes reach the same quiet `screened_out` outcome, and
+            // they disagree about who authored the decision:
+            //  - the screen node blocked before any turn was drafted → the screen
+            //    decision is the reason;
+            //  - the acting agent refused on its opening turn (IND-611) → the
+            //    withdrawing TURN is the reason.
+            // They are collapsed into `screenedOut` for status/lifecycle purposes but
+            // must stay separate when attributing `outcome.reasoning` below.
+            const blockedByScreenNode = blocksNegotiationBeforeFirstTurn(state.screenDecision, state.turnCount);
+            const refusedAtOpeningTurn = state.firstTurnScreenedOut === true;
+            const screenedOut = blockedByScreenNode || refusedAtOpeningTurn;
             const atCap = !screenedOut && (state.maxTurns ?? 0) > 0 && state.turnCount >= state.maxTurns && !isTerminalAction(lastTurn?.action);
             let agreedRoles = [];
             if (hasOpportunity && history.length >= 2) {
@@ -1033,9 +1055,19 @@ export class NegotiationGraphFactory {
             const outcome = {
                 hasOpportunity,
                 agreedRoles,
-                reasoning: screenedOut
+                // IND-611: attribute the reasoning to whoever actually made the
+                // decision. Before the turn-0 refusal path existed, `screenedOut`
+                // implied the screen node, so preferring `screenDecision.reasoning`
+                // was always right. It is now wrong for an opening-turn refusal taken
+                // while the screen said `reach_out`: that record argues FOR the match,
+                // and surfacing it as the reason the agent did NOT reach out is exactly
+                // the dishonesty this work removes (IND-610 renders this string in the
+                // owner-only gate-decision card). The screen-node branch is unchanged.
+                reasoning: blockedByScreenNode
                     ? (state.screenDecision?.reasoning ?? lastTurn?.assessment?.reasoning ?? "")
-                    : (lastTurn?.assessment.reasoning ?? ""),
+                    : refusedAtOpeningTurn
+                        ? (lastTurn?.assessment?.reasoning ?? state.screenDecision?.reasoning ?? "")
+                        : (lastTurn?.assessment.reasoning ?? ""),
                 turnCount: state.turnCount,
                 ...(screenedOut
                     ? { reason: "screened_out" }
@@ -1242,7 +1274,7 @@ export class NegotiationGraphFactory {
  * @returns Only candidates that produced an opportunity
  */
 export async function negotiateCandidates(negotiationGraph, sourceUser, candidates, indexContext, opts) {
-    const { maxTurns, traceEmitter, indexContextOverrides, timeoutMs, onCandidateResolved, trigger, initiatorUserId, resumeFromTaskId, continuationSettlementId, continuationExecution, } = opts ?? {};
+    const { maxTurns, traceEmitter, indexContextOverrides, timeoutMs, onCandidateResolved, initiatorUserId, resumeFromTaskId, continuationSettlementId, continuationExecution, } = opts ?? {};
     // Local helper to emit events whose shape is wider than the declared
     // `TraceEmitter` union (mirrors the cast used in chat.agent at the relay sink
     // and inside turn/finalize nodes above).
@@ -1260,7 +1292,6 @@ export async function negotiateCandidates(negotiationGraph, sourceUser, candidat
                 candidateUserId: candidate.userId,
                 initiatorUserId: initiatorUserId ?? candidateSourceUser.id,
                 ...(candidateName && { candidateName }),
-                trigger: trigger ?? "ambient",
                 startedAt: start,
             });
         }
@@ -1347,8 +1378,7 @@ export async function negotiateCandidates(negotiationGraph, sourceUser, candidat
                 }
                 catch (hookErr) {
                     // Hook failures must not sink the candidate result — the aggregate
-                    // return is still useful, and the orchestrator branch logs its own
-                    // failures inline.
+                    // return remains useful to the caller.
                     negotiateCandidatesLog.error("onCandidateResolved hook threw", {
                         candidateUserId: candidate.userId,
                         error: hookErr,

package/dist/negotiation/domain/index.d.ts

@@ -7,6 +7,7 @@
  * - NegotiationGraphState and all graph state types (negotiation.state.ts)
  * - Seat-scoped protocol rules and action vocabulary (negotiation.protocol.ts)
  * - Screen-gate pure contracts: mode, decision record, block predicate (negotiation.screen.contracts.ts)
+ * - Negotiator stance contracts + prompt fragments (negotiation.stance.contracts.ts)
  * - Deadlock detection + bargaining prompt section (negotiation.deadlock.ts)
  * - Lifecycle narration mapper (negotiation.lifecycle-narration.ts)
  * - Task conversation-lock predicate (negotiation.task-lock-policy.ts)
@@ -30,6 +31,8 @@
  */
 export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "./negotiation.screen.contracts.js";
 export type { NegotiationScreenMode, ScreenDecision, ScreenDecisionRecord, } from "./negotiation.screen.contracts.js";
+export { NEGOTIATOR_STANCES, DEFAULT_NEGOTIATOR_STANCE, configuredNegotiatorStance, stanceAppliesValueBar, stanceQueryMatchIsNecessaryNotSufficient, stanceResolvesDeadlockByStalemate, stanceJobFraming, stanceActionRules, stanceQuerySatisfiedRule, } from "./negotiation.stance.contracts.js";
+export type { NegotiatorStance } from "./negotiation.stance.contracts.js";
 export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "./negotiation.state.js";
 export type { NegotiationTurn, NegotiationOutcome, UserNegotiationContext, SeedAssessment, NegotiationGraphLike, NegotiationMessage, } from "./negotiation.state.js";
 export { InitiatorTurnSchema, CounterpartyTurnSchema, FinalInitiatorTurnSchema, FinalCounterpartyTurnSchema, InitiatorAskUserTurnSchema, CounterpartyAskUserTurnSchema, allowedActionsFor, turnSchemaFor, isTerminalAction, isRejectLikeAction, fallbackActionFor, rejectActionFor, readProtocolVersion, configuredProtocolVersion, configuredAskUserEnabled, askUserAnswerWindowMs, ASK_USER_LOCK_SLACK_MS, DEFAULT_ASK_USER_WINDOW_MS, resolveSeat, seatViolationMessage, } from "./negotiation.protocol.js";

package/dist/negotiation/domain/index.js

@@ -7,6 +7,7 @@
  * - NegotiationGraphState and all graph state types (negotiation.state.ts)
  * - Seat-scoped protocol rules and action vocabulary (negotiation.protocol.ts)
  * - Screen-gate pure contracts: mode, decision record, block predicate (negotiation.screen.contracts.ts)
+ * - Negotiator stance contracts + prompt fragments (negotiation.stance.contracts.ts)
  * - Deadlock detection + bargaining prompt section (negotiation.deadlock.ts)
  * - Lifecycle narration mapper (negotiation.lifecycle-narration.ts)
  * - Task conversation-lock predicate (negotiation.task-lock-policy.ts)
@@ -30,6 +31,8 @@
  */
 // ── Screen contracts ──────────────────────────────────────────────────────────
 export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "./negotiation.screen.contracts.js";
+// ── Stance contracts (IND-611) ────────────────────────────────────────────────
+export { NEGOTIATOR_STANCES, DEFAULT_NEGOTIATOR_STANCE, configuredNegotiatorStance, stanceAppliesValueBar, stanceQueryMatchIsNecessaryNotSufficient, stanceResolvesDeadlockByStalemate, stanceJobFraming, stanceActionRules, stanceQuerySatisfiedRule, } from "./negotiation.stance.contracts.js";
 // ── Graph state and DTOs ──────────────────────────────────────────────────────
 export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "./negotiation.state.js";
 // ── Protocol rules ────────────────────────────────────────────────────────────

package/dist/negotiation/domain/negotiation.deadlock.d.ts

@@ -19,6 +19,7 @@
  * - **Fail-open**: any detection error means "no deadlock" — advisory
  *   infrastructure never blocks a negotiation.
  */
+import { type NegotiatorStance } from "./negotiation.stance.contracts.js";
 export type { DeadlockShiftRecord } from "./negotiation.deadlock.contracts.js";
 /**
  * Whether the deadlock→bargaining mode shift is enabled, from the
@@ -66,16 +67,21 @@ export declare function assessDeadlock(history: ReadonlyArray<{
     action?: string;
 }>, threshold?: number): DeadlockAssessment;
 /**
- * Renders the bargaining-stance prompt section. Returns the empty string when
+ * Renders the deadlock-stance prompt section. Returns the empty string when
  * the shift is not active, so the rendered system prompt is byte-identical to
  * the legacy build on every non-shifted turn (mirrors
  * `renderNegotiatorMemorySection`). The `ask_user` escalation line renders
  * only when the caller already legally holds the action (`canAskUser`) — the
  * shift never invents a locution.
+ *
+ * IND-611: `stance` selects which resolution the shift drafts toward —
+ * bargaining (`advocate`/`evaluator`, the default and today's behavior) or
+ * stalemate (`skeptic`). Omitted → bargaining, byte-identical to before.
  */
 export declare function renderBargainingShiftSection(input: {
     active: boolean;
     userName: string;
     canAskUser: boolean;
     consecutiveNonConvergent: number;
+    stance?: NegotiatorStance;
 }): string;

package/dist/negotiation/domain/negotiation.deadlock.js

@@ -1,3 +1,25 @@
+/**
+ * Deadlock detection + persuasion→bargaining mode shift (IND-428, backlog item 6).
+ *
+ * Grounding: Wells & Reed (2006), *Knowing When to Bargain* — a persuasion
+ * dialogue (arguing the merits) that reaches a stalemate may execute a *legal
+ * shift* into a negotiation dialogue (offering concessions). See
+ * `docs/design/negotiation-dialogue-game.md` for the formal framing of the
+ * turn protocol as a dialogue game.
+ *
+ * Design constraints (hard):
+ * - **Deterministic**: deadlock is decided by pure inspection of the persisted
+ *   turn history — never by an LLM.
+ * - **Stance, not rules**: a detected deadlock changes the system agent's
+ *   *drafting stance* only. Locutions, seat vocabularies (`allowedActionsFor`),
+ *   termination, and turn-cap semantics are untouched.
+ * - **Default-off**: gated on `NEGOTIATION_DEADLOCK_SHIFT_ENABLED === "true"`
+ *   (strict literal) and applied only to v2 negotiations, checked alongside the
+ *   protocol-version plumbing. When off, the legacy path is byte-identical.
+ * - **Fail-open**: any detection error means "no deadlock" — advisory
+ *   infrastructure never blocks a negotiation.
+ */
+import { stanceResolvesDeadlockByStalemate } from "./negotiation.stance.contracts.js";
 // ─── Configuration ───────────────────────────────────────────────────────────
 /**
  * Whether the deadlock→bargaining mode shift is enabled, from the
@@ -86,16 +108,41 @@ This shift changes your stance only — your available actions are unchanged.`;
 const BARGAINING_ASK_USER_ESCALATION = `
 - If a concession would require {userName}'s own input or permission (budget, availability, private details), escalate with "ask_user" instead of guessing.`;
 /**
- * Renders the bargaining-stance prompt section. Returns the empty string when
+ * Skeptic-stance deadlock resolution (IND-611). Under `NEGOTIATOR_STANCE=skeptic`
+ * a stalemate resolves as a stalemate rather than by bargaining: the designed
+ * outcome of persistent disagreement stops being "a smaller match" and becomes
+ * "possibly no match". Same trigger, same threshold, same actions — only the
+ * drafting stance differs. `advocate`/`evaluator` keep the bargaining section
+ * byte-identical.
+ */
+const STALEMATE_SHIFT_SECTION = `
+
+DEADLOCK — THE MERITS ARE EXHAUSTED. The last {consecutive} turns were counters/questions without convergence: the merits have been argued and restating them will not move the other side. For this turn, change stance:
+- Do NOT re-argue fit or repeat points already made.
+- Do NOT buy agreement with a concession or a reduced scope. A shrunken version of a match that could not be agreed on its merits is usually worth less of {userName}'s attention than the full one was, not more.
+- Name the ONE specific thing that would genuinely change your assessment. If it has not appeared after this many turns, it is unlikely to.
+- Absent that, conclude decisively with a terminal action from your allowed set. An unresolved disagreement is an acceptable outcome; a match made to end the disagreement is not.
+This shift changes your stance only — your available actions are unchanged.`;
+/**
+ * Renders the deadlock-stance prompt section. Returns the empty string when
  * the shift is not active, so the rendered system prompt is byte-identical to
  * the legacy build on every non-shifted turn (mirrors
  * `renderNegotiatorMemorySection`). The `ask_user` escalation line renders
  * only when the caller already legally holds the action (`canAskUser`) — the
  * shift never invents a locution.
+ *
+ * IND-611: `stance` selects which resolution the shift drafts toward —
+ * bargaining (`advocate`/`evaluator`, the default and today's behavior) or
+ * stalemate (`skeptic`). Omitted → bargaining, byte-identical to before.
  */
 export function renderBargainingShiftSection(input) {
     if (!input.active)
         return "";
+    if (input.stance && stanceResolvesDeadlockByStalemate(input.stance)) {
+        return STALEMATE_SHIFT_SECTION
+            .replace("{consecutive}", String(input.consecutiveNonConvergent))
+            .replace(/{userName}/g, input.userName);
+    }
     return BARGAINING_SHIFT_SECTION
         .replace("{consecutive}", String(input.consecutiveNonConvergent))
         .replace("{askUserEscalation}", input.canAskUser ? BARGAINING_ASK_USER_ESCALATION : "")

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

@@ -0,0 +1,85 @@
+/**
+ * negotiation/domain — negotiator stance contracts (IND-611).
+ *
+ * The acting negotiator prompt is structurally biased toward producing matches
+ * rather than finding valuable ones: it frames the job as advocacy, treats a
+ * discovery-query match as a mandate to connect, and carries no
+ * opportunity-cost term — the only decline bar is the purely negative "does not
+ * serve {userName}'s needs", so absence of harm reads as grounds to accept.
+ *
+ * `NEGOTIATOR_STANCE` makes that stance configurable instead of hard-coded:
+ *
+ * | stance      | framing                              | value bar        | query rule              | deadlock  |
+ * |-------------|--------------------------------------|------------------|-------------------------|-----------|
+ * | `advocate`  | argue the case (today)               | none             | mandate (today)         | bargain   |
+ * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| bargain   |
+ * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| stalemate |
+ *
+ * Design constraints (hard):
+ * - **`advocate` is byte-identical.** Every fragment below is additive and
+ *   gated; under `advocate` each renderer returns the exact legacy string, so
+ *   the rendered prompt is byte-for-byte the pre-IND-611 build. Existing prompt
+ *   specs are the guard.
+ * - **Prompt-only.** The stance changes drafting stance and nothing else:
+ *   no seat vocabulary change (`allowedActionsFor`), no schema change, no graph
+ *   routing change. In particular the continuation-screen bypass at
+ *   `negotiation.graph.ts` (`!state.continuationExecution`) is identical under
+ *   all three stances — deliberately deferred so evals isolate wording as the
+ *   single variable.
+ * - **Domain layer.** Placed here (not in `application/`) so both the
+ *   application-layer agent and the domain-layer deadlock renderer can read the
+ *   stance without a domain → application cycle.
+ * - **Fail-safe default.** Unset or unrecognized falls back to `advocate`
+ *   (today's behavior), same operational pattern as `configuredScreenMode()`.
+ *
+ * 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.
+ */
+export declare const NEGOTIATOR_STANCES: readonly ["advocate", "evaluator", "skeptic"];
+export type NegotiatorStance = (typeof NEGOTIATOR_STANCES)[number];
+export declare const DEFAULT_NEGOTIATOR_STANCE: NegotiatorStance;
+/**
+ * Resolve the negotiator stance from `NEGOTIATOR_STANCE`.
+ *
+ * Defaults to `advocate` when unset or unrecognized — the stance shift is an
+ * explicit opt-in flip (same operational pattern as `NEGOTIATION_SCREEN_MODE` /
+ * `NEGOTIATION_PROTOCOL_VERSION`): the code ships dark, the environment turns
+ * it on.
+ */
+export declare function configuredNegotiatorStance(): NegotiatorStance;
+/** Whether this stance applies the opportunity-cost value bar. */
+export declare function stanceAppliesValueBar(stance: NegotiatorStance): boolean;
+/**
+ * Whether this stance treats a discovery-query match as a precondition for
+ * continuing to evaluate rather than as a mandate to connect.
+ */
+export declare function stanceQueryMatchIsNecessaryNotSufficient(stance: NegotiatorStance): boolean;
+/** Whether a detected deadlock resolves by stalemate rather than bargaining. */
+export declare function stanceResolvesDeadlockByStalemate(stance: NegotiatorStance): boolean;
+/**
+ * The job-framing sentence for a stance. Under `advocate` this is the exact
+ * legacy sentence, so the rendered prompt is byte-identical.
+ *
+ * `{userName}` placeholders are left intact for the caller's existing global
+ * replace.
+ */
+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.
+ */
+export declare function stanceActionRules(stance: NegotiatorStance): string;
+/**
+ * The discovery-query satisfaction rule.
+ *
+ * `advocate` keeps today's mandate wording verbatim ("PROPOSE or ACCEPT the
+ * connection…"), which converts a filter into an instruction to connect.
+ * `evaluator`/`skeptic` make query satisfaction necessary-but-not-sufficient: a
+ * precondition for continuing to evaluate, never itself a reason to connect.
+ *
+ * Names are interpolated eagerly here: this fragment is spliced into the system
+ * prompt *after* the caller's global `{userName}` substitution has already run,
+ * so a placeholder would survive into the rendered prompt.
+ */
+export declare function stanceQuerySatisfiedRule(stance: NegotiatorStance, otherName: string, userName: string): string;

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

@@ -0,0 +1,140 @@
+/**
+ * negotiation/domain — negotiator stance contracts (IND-611).
+ *
+ * The acting negotiator prompt is structurally biased toward producing matches
+ * rather than finding valuable ones: it frames the job as advocacy, treats a
+ * discovery-query match as a mandate to connect, and carries no
+ * opportunity-cost term — the only decline bar is the purely negative "does not
+ * serve {userName}'s needs", so absence of harm reads as grounds to accept.
+ *
+ * `NEGOTIATOR_STANCE` makes that stance configurable instead of hard-coded:
+ *
+ * | stance      | framing                              | value bar        | query rule              | deadlock  |
+ * |-------------|--------------------------------------|------------------|-------------------------|-----------|
+ * | `advocate`  | argue the case (today)               | none             | mandate (today)         | bargain   |
+ * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| bargain   |
+ * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| stalemate |
+ *
+ * Design constraints (hard):
+ * - **`advocate` is byte-identical.** Every fragment below is additive and
+ *   gated; under `advocate` each renderer returns the exact legacy string, so
+ *   the rendered prompt is byte-for-byte the pre-IND-611 build. Existing prompt
+ *   specs are the guard.
+ * - **Prompt-only.** The stance changes drafting stance and nothing else:
+ *   no seat vocabulary change (`allowedActionsFor`), no schema change, no graph
+ *   routing change. In particular the continuation-screen bypass at
+ *   `negotiation.graph.ts` (`!state.continuationExecution`) is identical under
+ *   all three stances — deliberately deferred so evals isolate wording as the
+ *   single variable.
+ * - **Domain layer.** Placed here (not in `application/`) so both the
+ *   application-layer agent and the domain-layer deadlock renderer can read the
+ *   stance without a domain → application cycle.
+ * - **Fail-safe default.** Unset or unrecognized falls back to `advocate`
+ *   (today's behavior), same operational pattern as `configuredScreenMode()`.
+ *
+ * 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.
+ */
+export const NEGOTIATOR_STANCES = ["advocate", "evaluator", "skeptic"];
+export const DEFAULT_NEGOTIATOR_STANCE = "advocate";
+/**
+ * Resolve the negotiator stance from `NEGOTIATOR_STANCE`.
+ *
+ * Defaults to `advocate` when unset or unrecognized — the stance shift is an
+ * explicit opt-in flip (same operational pattern as `NEGOTIATION_SCREEN_MODE` /
+ * `NEGOTIATION_PROTOCOL_VERSION`): the code ships dark, the environment turns
+ * it on.
+ */
+export function configuredNegotiatorStance() {
+    const raw = process.env.NEGOTIATOR_STANCE;
+    if (raw === "advocate" || raw === "evaluator" || raw === "skeptic")
+        return raw;
+    return DEFAULT_NEGOTIATOR_STANCE;
+}
+/** Whether this stance applies the opportunity-cost value bar. */
+export function stanceAppliesValueBar(stance) {
+    return stance !== "advocate";
+}
+/**
+ * Whether this stance treats a discovery-query match as a precondition for
+ * continuing to evaluate rather than as a mandate to connect.
+ */
+export function stanceQueryMatchIsNecessaryNotSufficient(stance) {
+    return stance !== "advocate";
+}
+/** Whether a detected deadlock resolves by stalemate rather than bargaining. */
+export function stanceResolvesDeadlockByStalemate(stance) {
+    return stance === "skeptic";
+}
+// ─── Prompt fragments ────────────────────────────────────────────────────────
+/**
+ * The `advocate` job framing — byte-identical to the pre-IND-611 sentence that
+ * followed "Your job: Evaluate whether this connection genuinely serves
+ * {userName}'s interests given their role." in the system prompt.
+ */
+const ADVOCATE_FRAMING = `Argue their case honestly — acknowledge weaknesses, but advocate for genuine fit.`;
+/**
+ * `evaluator`: assessment precedes advocacy. Advocacy is still available — it is
+ * conditioned on the match surviving an honest judgment first.
+ */
+const EVALUATOR_FRAMING = `Assess before you advocate: first form an honest judgment about whether this connection is actually worth making for {userName}. Advocate only for a match that survives that judgment, and say so plainly when one does not.`;
+/**
+ * `skeptic`: the evaluator framing plus an explicit prior. Borrows the finite-
+ * attention framing already proven in the outreach gate prompt
+ * (`negotiation.screen.ts`) — {userName}'s name and attention are spent on
+ * every connection made for them.
+ */
+const SKEPTIC_FRAMING = `${EVALUATOR_FRAMING} Start from the prior that most candidate matches are NOT worth making: {userName}'s attention is finite and a mediocre connection costs them more than no connection. The burden is on the match to earn their time, not on you to find a way to say yes.`;
+/**
+ * The job-framing sentence for a stance. Under `advocate` this is the exact
+ * legacy sentence, so the rendered prompt is byte-identical.
+ *
+ * `{userName}` placeholders are left intact for the caller's existing global
+ * replace.
+ */
+export function stanceJobFraming(stance) {
+    switch (stance) {
+        case "evaluator":
+            return EVALUATOR_FRAMING;
+        case "skeptic":
+            return SKEPTIC_FRAMING;
+        default:
+            return ADVOCATE_FRAMING;
+    }
+}
+/**
+ * The opportunity-cost value bar, appended as an extra action rule.
+ *
+ * Today the only decline bar in the prompt is "does not serve {userName}'s
+ * needs" — a purely negative test, so absence of harm reads as grounds to
+ * proceed. This adds the missing positive bar without touching any seat's
+ * action vocabulary.
+ */
+const VALUE_BAR_RULE = `
+- OPPORTUNITY COST: {userName}'s attention is finite and their name is spent on every connection made on their behalf. The bar is "worth that spend", not "does no harm" — absence of a downside is NOT a reason to proceed. Ask what {userName} gives up by spending this attention here instead of on a better match, and say no when the answer is "too much".`;
+/**
+ * Extra action-rule lines contributed by the stance, appended after the seat's
+ * own rules. Empty under `advocate` → byte-identical.
+ */
+export function stanceActionRules(stance) {
+    return stanceAppliesValueBar(stance) ? VALUE_BAR_RULE : "";
+}
+/**
+ * The discovery-query satisfaction rule.
+ *
+ * `advocate` keeps today's mandate wording verbatim ("PROPOSE or ACCEPT the
+ * connection…"), which converts a filter into an instruction to connect.
+ * `evaluator`/`skeptic` make query satisfaction necessary-but-not-sufficient: a
+ * precondition for continuing to evaluate, never itself a reason to connect.
+ *
+ * Names are interpolated eagerly here: this fragment is spliced into the system
+ * prompt *after* the caller's global `{userName}` substitution has already run,
+ * so a placeholder would survive into the rendered prompt.
+ */
+export function stanceQuerySatisfiedRule(stance, otherName, userName) {
+    if (!stanceQueryMatchIsNecessaryNotSufficient(stance)) {
+        return `- If ${otherName} DOES satisfy the query: PROPOSE or ACCEPT the connection and evaluate fit normally using intents and profile data.`;
+    }
+    return `- If ${otherName} DOES satisfy the query: satisfying the query is a PRECONDITION for continuing to evaluate, NOT a reason to connect. Keep evaluating fit on intents and profile data, and decline when the connection would not be worth ${userName}'s attention.`;
+}

package/dist/negotiation/domain/negotiation.state.d.ts

@@ -401,9 +401,8 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
     turnCount: import("@langchain/langgraph").BaseChannel<number, number | import("@langchain/langgraph").OverwriteValue<number>, unknown>;
     maxTurns: import("@langchain/langgraph").BaseChannel<number | undefined, number | import("@langchain/langgraph").OverwriteValue<number | undefined> | undefined, unknown>;
     /**
-     * Park-window budget in milliseconds. Ambient callers pass `AMBIENT_PARK_WINDOW_MS`
-     * (5 minutes); orchestrator callers pass a shorter window. This annotation default
-     * is a safety net for any caller that omits the field — keep it aligned with
+     * Park-window budget in milliseconds. The annotation default is a safety net
+     * for any caller that omits the field — keep it aligned with
      * `AMBIENT_PARK_WINDOW_MS` in packages/protocol/src/negotiation/negotiation.tools.ts.
      * Inlined rather than imported to avoid a state↔tools cycle.
      */

package/dist/negotiation/domain/negotiation.state.js

@@ -237,9 +237,8 @@ export const NegotiationGraphState = Annotation.Root({
         default: () => undefined,
     }),
     /**
-     * Park-window budget in milliseconds. Ambient callers pass `AMBIENT_PARK_WINDOW_MS`
-     * (5 minutes); orchestrator callers pass a shorter window. This annotation default
-     * is a safety net for any caller that omits the field — keep it aligned with
+     * Park-window budget in milliseconds. The annotation default is a safety net
+     * for any caller that omits the field — keep it aligned with
      * `AMBIENT_PARK_WINDOW_MS` in packages/protocol/src/negotiation/negotiation.tools.ts.
      * Inlined rather than imported to avoid a state↔tools cycle.
      */

package/dist/negotiation/public/index.d.ts

@@ -33,6 +33,8 @@ export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTur
 export type { NegotiationTurn, NegotiationOutcome, UserNegotiationContext, SeedAssessment, NegotiationGraphLike, NegotiationMessage, } from "../domain/index.js";
 export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "../domain/index.js";
 export type { NegotiationScreenMode, ScreenDecision, ScreenDecisionRecord, } from "../domain/index.js";
+export { NEGOTIATOR_STANCES, DEFAULT_NEGOTIATOR_STANCE, configuredNegotiatorStance, stanceAppliesValueBar, stanceQueryMatchIsNecessaryNotSufficient, stanceResolvesDeadlockByStalemate, stanceJobFraming, stanceActionRules, stanceQuerySatisfiedRule, } from "../domain/index.js";
+export type { NegotiatorStance } from "../domain/index.js";
 export { assessDeadlock, configuredDeadlockShiftEnabled, configuredDeadlockThreshold, renderBargainingShiftSection, DEFAULT_DEADLOCK_THRESHOLD, MIN_DEADLOCK_THRESHOLD, } from "../domain/index.js";
 export type { DeadlockAssessment, DeadlockShiftRecord, } from "../domain/index.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "../domain/index.js";

package/dist/negotiation/public/index.js

@@ -34,6 +34,8 @@ export { allowedActionsFor, isTerminalAction, isRejectLikeAction, readProtocolVe
 export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "../domain/index.js";
 // ── Domain: screen contracts ──────────────────────────────────────────────────
 export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "../domain/index.js";
+// ── Domain: stance contracts (IND-611) ───────────────────────────────────────
+export { NEGOTIATOR_STANCES, DEFAULT_NEGOTIATOR_STANCE, configuredNegotiatorStance, stanceAppliesValueBar, stanceQueryMatchIsNecessaryNotSufficient, stanceResolvesDeadlockByStalemate, stanceJobFraming, stanceActionRules, stanceQuerySatisfiedRule, } from "../domain/index.js";
 // ── Domain: deadlock ──────────────────────────────────────────────────────────
 export { assessDeadlock, configuredDeadlockShiftEnabled, configuredDeadlockThreshold, renderBargainingShiftSection, DEFAULT_DEADLOCK_THRESHOLD, MIN_DEADLOCK_THRESHOLD, } from "../domain/index.js";
 // ── Domain: consultation policy ───────────────────────────────────────────────

package/dist/opportunity/application/index.d.ts

@@ -42,10 +42,7 @@ export * from "./opportunity.presenter.js";
 export * from "./opportunity.introducer.js";
 export * from "./opportunity.existing-negotiation.js";
 export * from "./opportunity.graph.js";
-export * from "./opportunity.discover.js";
 export * from "./opportunity.card-presentation.js";
-export * from "./opportunity.discovery-continuation-finalization.js";
-export * from "./opportunity.discovery-mcp-lifecycle-finalization.js";
 export * from "./opportunity.discovery-negotiation-summary.js";
 export * from "./negotiation-context.loader.js";
 export * from "./opportunity.feed-selection.js";

package/dist/opportunity/application/index.js

@@ -43,10 +43,7 @@ export * from "./opportunity.presenter.js";
 export * from "./opportunity.introducer.js";
 export * from "./opportunity.existing-negotiation.js";
 export * from "./opportunity.graph.js";
-export * from "./opportunity.discover.js";
 export * from "./opportunity.card-presentation.js";
-export * from "./opportunity.discovery-continuation-finalization.js";
-export * from "./opportunity.discovery-mcp-lifecycle-finalization.js";
 export * from "./opportunity.discovery-negotiation-summary.js";
 export * from "./negotiation-context.loader.js";
 export * from "./opportunity.feed-selection.js";