@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/negotiations/negotiation.stall-gap.js

@@ -1,152 +0,0 @@
-/**
- * Post-stall gap authoring (conversational-questions plan).
- *
- * When a negotiation ends unconcluded — no opportunity, no explicit reject:
- * turn cap, timeout, or stall — the finalize node asks the negotiator for the
- * ONE question whose answer would let a retry conclude, and parks the
- * negotiation carrying that gap as an `ask_user` message in its own record.
- * This module owns that single extra model call.
- *
- * Grounding is exactly what mid-flight authoring (P3.2 / IND-401 A2H) uses:
- * this negotiation's transcript, plus the client's own negotiator DM for the
- * signal when the caller retrieved one. Same non-naming and non-echo rules;
- * the caller re-checks the output with `isSafeAuthoredNegotiationQuestion`
- * (identifiers in hand) before persisting anything.
- *
- * Fail-open contract: any model failure, timeout, or invalid output resolves
- * to null — the negotiation then stalls exactly as it did before this feature,
- * never half-parks.
- */
-import { z } from "zod";
-import { createStructuredModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-import { StructuredQuestionSchema } from "../shared/schemas/structured-question.schema.js";
-import { NegotiationConsultationReasonSchema } from "../shared/schemas/negotiation-state.schema.js";
-import { renderNegotiatorClientDmSection } from "./negotiation.client-dm.js";
-import { resolveTurnTimeoutMs } from "./negotiation.agent.js";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-const stallGapLog = protocolLogger("NegotiationStallGapAuthor");
-/**
- * Fixed transcript reasoning for a post-stall park turn. Deliberately not
- * model-authored: assessment reasoning enters the shared A2A record, and the
- * park's "why" already lives in the guarded question itself — a second,
- * unguarded free-text channel would reopen the leak surface the question gate
- * closes.
- */
-export const NEGOTIATION_PARK_REASONING = "Negotiation parked pending the client's answer.";
-const STALL_REASON_LABELS = {
-    turn_cap: "the turn limit was reached without agreement",
-    timeout: "the negotiation timed out",
-    stalled: "the exchange stalled without reaching a conclusion",
-};
-/**
- * Structured output for the gap call. `hasGap: false` is a first-class answer:
- * when no single client answer would change a retry's outcome, the negotiation
- * must stall terminally rather than park on a filler question. Nullable
- * declarations mirror `AskUserPayloadSchema.question` — strict structured-output
- * conversion rejects optional-without-nullable, and a returned null reads as
- * absent.
- */
-const StallGapOutputSchema = z.object({
-    hasGap: z.boolean(),
-    reason: NegotiationConsultationReasonSchema.nullable().optional().transform((value) => value ?? undefined),
-    question: StructuredQuestionSchema.nullable().optional().transform((value) => value ?? undefined),
-});
-const SYSTEM_PROMPT = `You are the Index Negotiator, an AI agent acting on behalf of {userName}. A negotiation you conducted for them about a potential connection has just ended without conclusion: {stallReasonLabel}.
-
-Your job now is a single decision: is there ONE piece of information only {userName} holds whose answer would let a retry of this negotiation reach a conclusion? Read the exchange below and judge where it actually stuck.
-
-- If no single answer from {userName} would change a retry's outcome — the match is simply weak, the counterparty is the blocker, or the stall had nothing to do with missing input from {userName} — set hasGap to false and omit the question. Do not invent a question to have something to ask; asking costs {userName} attention and pauses nothing useful.
-- If yes, set hasGap to true and author the question:
-  - reason: exactly one closed server category recording WHY the pause is warranted: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority". It is not the wording {userName} sees.
-  - title: at most 12 characters — a noun for the decision domain, e.g. "Stage", "Timing", "Budget", "Scope".
-  - prompt: at most 2 sentences and 400 characters, ending in a question mark. Ask about the specific thing that was actually stuck in this negotiation, in {userName}'s own terms, grounded in the exchange below. Never a generic template.
-  - options: 2–4 of {userName}'s real decision options. Each label at most 120 characters; each description at most 280 characters, stating the CONSEQUENCE of choosing that option — what the retry would do with it — not what it means. Never add an "Other" option; clients provide a free-text fallback automatically.
-  - multiSelect: true ONLY when the options are not mutually exclusive; false for a single either/or decision.
-  - Do not name, quote, or describe the counterparty. {userName} can read the transcript, but the question itself must stand on its own without their identity or profile in it.
-  - Do NOT reference internal system details like scores, pre-screens, or evaluator outputs.{dmGroundingRule}`;
-/**
- * Appended only when the call actually carries a client-DM excerpt, mirroring
- * `ASK_USER_DM_GROUNDING_RULE`: a call with no DM must not carry a rule that
- * dangles with nothing in the prompt to check against.
- */
-const DM_GROUNDING_RULE = `
-  - Ground the question in your conversation with {userName} about this signal (shown below) as well as in the exchange. Do NOT ask what they have already answered there: if their own words settle the point, there is no gap on it. Use their terms for the thing at stake — the words, numbers, and framing they used, not your paraphrase of them.`;
-function formatTurnLine(turn, index) {
-    const msgPart = turn.message ? ` — message: ${turn.message}` : "";
-    return `Turn ${index + 1}: ${turn.action} — reasoning: ${turn.assessment.reasoning}${msgPart}`;
-}
-/**
- * Authors the post-stall gap. One instance lives in the graph's dependency bag
- * beside `systemAgent`; the finalize node calls it at most once per stalled
- * session.
- */
-export class NegotiationStallGapAuthor {
-    constructor(config) {
-        this.timeoutMs = resolveTurnTimeoutMs(config?.timeoutMs);
-    }
-    /**
-     * @returns The authored gap, or null when there is none to ask — the model
-     *          said so, produced invalid output after a retry, or failed. The
-     *          caller treats every null identically: terminal stall, no park.
-     */
-    async author(input) {
-        const clientDm = input.clientDm ?? [];
-        const model = createStructuredModel("negotiator", StallGapOutputSchema, { name: "negotiation_stall_gap" });
-        const systemPrompt = SYSTEM_PROMPT
-            .replace("{stallReasonLabel}", STALL_REASON_LABELS[input.stallReason])
-            .replace("{dmGroundingRule}", clientDm.length > 0 ? DM_GROUNDING_RULE : "")
-            .replace(/{userName}/g, input.userName);
-        const transcript = input.history.length > 0
-            ? `\n\nNegotiation transcript:\n${input.history.map(formatTurnLine).join("\n")}`
-            : "";
-        const userMessage = `{userName}'s signal under negotiation:
-- ${input.signal.title}: ${input.signal.description}
-
-Why this match was suggested: ${input.seedReasoning}${transcript}${renderNegotiatorClientDmSection(clientDm, input.userName)}
-
-Decide whether one question to {userName} would let a retry conclude, and author it if so.`.replace(/{userName}/g, input.userName);
-        const chatMessages = [
-            { role: "system", content: systemPrompt },
-            { role: "user", content: userMessage },
-        ];
-        try {
-            // Same validate → retry-once → give-up loop as the negotiator turn,
-            // except giving up resolves to null (terminal stall) instead of a
-            // fallback action — there is no conservative fallback question.
-            for (let attempt = 0; attempt < 2; attempt++) {
-                const result = await this.callModel(model, chatMessages);
-                const parsed = StallGapOutputSchema.safeParse(result);
-                if (!parsed.success) {
-                    stallGapLog.warn("Stall-gap output failed schema validation", {
-                        attempt: attempt + 1,
-                        issues: parsed.error.issues.map((issue) => issue.message).slice(0, 3),
-                    });
-                    continue;
-                }
-                if (!parsed.data.hasGap)
-                    return null;
-                if (!parsed.data.question || !parsed.data.reason) {
-                    stallGapLog.warn("Stall-gap output claimed a gap without question or reason", { attempt: attempt + 1 });
-                    continue;
-                }
-                return { reason: parsed.data.reason, question: parsed.data.question };
-            }
-            return null;
-        }
-        catch (err) {
-            stallGapLog.warn("Stall-gap authoring failed; negotiation stalls without a park", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-            return null;
-        }
-    }
-    /**
-     * Raw structured-model round trip. Split out as a seam so tests can drive
-     * the validate→retry→null loop without a live provider — same pattern as
-     * `IndexNegotiator.callModel`.
-     */
-    async callModel(model, chatMessages) {
-        return invokeWithAbortSignal(model, chatMessages, AbortSignal.timeout(this.timeoutMs));
-    }
-}

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

@@ -1,123 +0,0 @@
-/**
- * negotiations/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              | 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
- *   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.
- *
- * 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;
-/**
- * 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 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;
-/**
- * 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.
- *
- * `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, seat: NegotiationSeat): string;
-/**
- * Stance contribution to the pre-contact consultation rule. Empty under
- * `advocate` and `evaluator` — the base seat-level rule already states when
- * the verdict applies, and only the skeptic's not-worth-making prior changes
- * which way a close call should fall.
- */
-export declare function stancePreContactConsultRule(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/negotiations/negotiation.stance.contracts.js

@@ -1,317 +0,0 @@
-/**
- * negotiations/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              | 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
- *   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.
- *
- * 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";
-/**
- * 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 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";
-}
-// ─── 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".`;
-/**
- * Consult propensity — assessing stances only.
- *
- * The assessing stances demand a judgment ("is this actually worth making for
- * {userName}?") that sometimes turns on a fact only the client holds: their
- * current priorities, their real constraints, what "alignment" would mean to
- * them. The legacy failure mode is resolving that gap by assumption —
- * guessing, conceding, or accepting on vibes. This rule names the resolution
- * path instead: consult the client.
- *
- * Deliberately names no action and no mechanism: like every fragment here it
- * renders into all seats and protocol versions, including seats with no
- * consultation vocabulary, so the seat's own rules decide HOW a consultation
- * happens and whether one is still available this turn. This only sets when
- * the agent should WANT one — which is also why it stays conditional on the
- * uncertainty being client-resolvable: no "always"/"regardless" wording that
- * would fight the per-negotiation consultation cap
- * (`negotiationAskRoundsCap`).
- */
-const CONSULT_PROPENSITY_RULE = `
-- CONSULT, DON'T ASSUME: when your judgment turns on a fact about {userName}'s OWN intent that you do not hold — their current priorities, their real constraints, what "alignment" would actually mean to them — prefer consulting {userName} over resolving that uncertainty by assumption. Guessing their answer, conceding to keep things moving, or proceeding because nothing contradicts the match are all ways of deciding for them what only they can decide.`;
-/**
- * `skeptic` sharpening of the consult rule, appended to the same bullet (the
- * same additive pattern as `SKEPTIC_FRAMING` over `EVALUATOR_FRAMING`): under
- * the not-worth-making prior an unverified alignment assumption is itself a
- * 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, seat) {
-    if (!stanceAppliesValueBar(stance))
-        return "";
-    const consultRule = stance === "skeptic"
-        ? CONSULT_PROPENSITY_RULE + SKEPTIC_CONSULT_SHARPENING
-        : CONSULT_PROPENSITY_RULE;
-    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
- * 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.
- *
- * `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.`;
-}