@indexnetwork/protocol 22.0.0-rc.496.1 → 22.0.0-rc.498.1

package/dist/negotiations/negotiation.agent.js

@@ -195,6 +195,12 @@ export class IndexNegotiator {
         // 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,
@@ -206,7 +212,7 @@ 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)
+            : V1_ACTION_RULES) + stanceActionRules(stance, seat)
             + (canAskUser
                 ? ASK_USER_RULE
                     + (preContactConsult ? PRE_CONTACT_ASK_USER_RULE + stancePreContactConsultRule(stance) : "")

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      | evidence provenance      | responder check          | deadlock  |
+ * |-------------|--------------------------------------|------------------|-------------------------|-------------------------|--------------------------|--------------------------|-----------|
+ * | `advocate`  | argue the case (today)               | none             | mandate (today)         | none (today)            | none (today)             | none (today)             | bargain   |
+ * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| prefer over assumption  | own record ≠ client's evidence | verify the opening | bargain   |
+ * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| + unverified = don't proceed | (same — no sharpening) | + probe before accepting | stalemate |
  *
  * Design constraints (hard):
  * - **`advocate` is byte-identical.** Every fragment below is additive and
@@ -35,7 +35,22 @@
  * 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.
+ *
+ * The seat parameter is a scoping tool, not a licence to fork: a duty both
+ * seats hold stays in the shared prefix even when the failure that motivated it
+ * showed up on one seat. `EVIDENCE_PROVENANCE_RULE` is the case in point — it
+ * was written for a responder accept, and it renders seat-blind, because an
+ * initiator can cite its own prior openings' claims exactly as readily.
  */
+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 +70,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 +88,19 @@ 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, the consult
+ * propensity and the evidence-provenance rule are duties of both seats, and
+ * the seat parameter must not become a reason to fork them.
+ *
+ * Order matters twice over. The seat-blind rules come first, so the initiator's
+ * rendering stays a strict PREFIX of the responder's — the invariant the stance
+ * spec checks by subtraction. And provenance lands immediately before the
+ * responder rules, so "ground the accept in what {userName} themselves stated"
+ * is already qualified by whose statements count when the responder reads it.
  */
-export declare function stanceActionRules(stance: NegotiatorStance): string;
+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

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      | evidence provenance      | responder check          | deadlock  |
+ * |-------------|--------------------------------------|------------------|-------------------------|-------------------------|--------------------------|--------------------------|-----------|
+ * | `advocate`  | argue the case (today)               | none             | mandate (today)         | none (today)            | none (today)             | none (today)             | bargain   |
+ * | `evaluator` | assess first, advocate if it survives | opportunity-cost | necessary-not-sufficient| prefer over assumption  | own record ≠ client's evidence | verify the opening | bargain   |
+ * | `skeptic`   | + "most matches are not worth making" | opportunity-cost | necessary-not-sufficient| + unverified = don't proceed | (same — no sharpening) | + probe before accepting | stalemate |
  *
  * Design constraints (hard):
  * - **`advocate` is byte-identical.** Every fragment below is additive and
@@ -35,6 +35,20 @@
  * 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.
+ *
+ * The seat parameter is a scoping tool, not a licence to fork: a duty both
+ * seats hold stays in the shared prefix even when the failure that motivated it
+ * showed up on one seat. `EVIDENCE_PROVENANCE_RULE` is the case in point — it
+ * was written for a responder accept, and it renders seat-blind, because an
+ * initiator can cite its own prior openings' claims exactly as readily.
  */
 export const NEGOTIATOR_STANCES = ["advocate", "evaluator", "skeptic"];
 export const DEFAULT_NEGOTIATOR_STANCE = "advocate";
@@ -63,6 +77,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 +162,115 @@ 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.`;
+/**
+ * Evidence provenance — assessing stances, BOTH seats.
+ *
+ * The third sibling of the consult-propensity and responder-verification
+ * fragments, and written for the way the second one was formally obeyed and
+ * substantively evaded. A responder accepted a first contact grounded — as the
+ * responder rule demands — in its OWN side's record rather than in the
+ * opening's characterization. But the record it reached for was its own prior
+ * conclusions, surfaced through memory and prior dialogue: "{userName}'s
+ * previous acceptances ... reinforce this strong alignment", from acceptances
+ * this same negotiator had made under a weaker bar. Circular verification —
+ * I accepted before, therefore accepting is grounded.
+ *
+ * So the rule the verification duty was missing: an agent's own output is not
+ * its client's evidence. Verification grounds in what a PERSON authored — never
+ * in what an agent concluded about them, on either side of the table. The
+ * fragment names exactly the client-authored sections this prompt actually
+ * renders (intents, profile, and the client's own answers between sessions),
+ * so the ground it points at is one the negotiator can see.
+ *
+ * Two boundaries it deliberately does not cross:
+ * - **It does not ban memory.** Memory keeps the job it has (advisory notes on
+ *   how to argue, what has been asked, what each side said); what changes is
+ *   only what may count as verification. A fragment that told the negotiator to
+ *   ignore its memory would fight `renderNegotiatorMemorySection` rather than
+ *   complete it.
+ * - **It does not forbid resolving a repeat signal quickly.** The continuation
+ *   policy in `negotiation.agent.ts` ("materially the same as one you
+ *   previously evaluated ... you may resolve quickly") governs how much EFFORT
+ *   a re-run deserves; this governs what counts as GROUNDS. The nearest
+ *   existing neighbor is the IND-569 attribution policy — "do not treat their
+ *   conclusions as decisions about this opportunity" — which scopes conclusions
+ *   across opportunities; this scopes them across the decision/evidence line.
+ *
+ * No `skeptic` sharpening: the prior that most matches are not worth making
+ * does not change what an unverified assertion is worth. It is worth nothing
+ * under either assessing stance, and a sharpening here would only restate the
+ * rule louder.
+ *
+ * Names no action and no mechanism, like every other fragment in this module.
+ */
+const EVIDENCE_PROVENANCE_RULE = `
+- YOUR OWN RECORD IS DECISIONS, NOT EVIDENCE: your earlier turns, the connections you proposed or accepted on {userName}'s behalf, and the conclusions you carry in memory are YOUR record — decisions you made for them, reached under whatever bar you applied at the time. Leaning on one ("they have been open to this before", "the fit was already established") re-asserts a judgment instead of checking it, and reads your own past eagerness back as {userName}'s interest. Ground the fit in what a person stated for themselves: {userName}'s own intents, profile, and the answers they gave you directly on your side; the counterparty's own intents and profile on theirs. Prior dialogue and memory keep their job — what has already been asked, what each side actually said, how to pitch this one — but they are the history of the argument, not grounds for it. A fit that was not verified does not become verified by having been asserted before.`;
+/**
+ * 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, the consult
+ * propensity and the evidence-provenance rule are duties of both seats, and
+ * the seat parameter must not become a reason to fork them.
+ *
+ * Order matters twice over. The seat-blind rules come first, so the initiator's
+ * rendering stays a strict PREFIX of the responder's — the invariant the stance
+ * spec checks by subtraction. And provenance lands immediately before the
+ * responder rules, so "ground the accept in what {userName} themselves stated"
+ * is already qualified by whose statements count when the responder reads it.
  */
-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 + EVIDENCE_PROVENANCE_RULE + responderRule;
 }
 /**
  * `skeptic` sharpening of the pre-contact consultation rule (the turn-0 third

package/package.json

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