@indexnetwork/protocol 4.17.0-rc.360.1 → 4.18.0-rc.362.1

package/dist/opportunity/negotiation-evidence/negotiation-evidence.types.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Lens C negotiation-evidence — shared types (IND-433).
+ *
+ * Lens C mines neutral clarification hypotheses from RECURRING negotiation
+ * evidence, read in place at mining time. It never builds a durable transcript
+ * projection and never summarizes an entire pair DM; the only content it will
+ * ever touch is a narrow, positively-constructed allowlist:
+ *
+ *   - authoritative owner answers (the recipient's own answers),
+ *   - structured bilateral actions / coarse outcomes, and
+ *   - explicitly shared message content.
+ *
+ * Everything else — screen/evaluator reasoning, agent chain-of-thought,
+ * `memoryHints`, private negotiator memories/reflections, disclosure subjects,
+ * untagged shared answers, and old synthesized digests — is excluded by
+ * construction (never mapped into an {@link AllowlistedEvidence}).
+ */
+/** The four allowlisted evidence families. Nothing else may be surfaced. */
+export type EvidenceKind = "owner_answer" | "bilateral_action" | "coarse_outcome" | "shared_message";
+/**
+ * Who authored an evidence unit. `system` covers structured bilateral facts
+ * (actions/outcomes) that belong to neither party's voice. The distinction is
+ * load-bearing: a counterparty statement may support an OBSERVATION but never
+ * a fact or preference ABOUT the recipient (IND-433).
+ */
+export type EvidenceSpeaker = "owner" | "counterparty" | "system";
+/**
+ * One unit of allowlisted evidence, extracted in place for exactly one
+ * (recipient, intent, opportunity, task) tuple. Provenance travels with the
+ * unit so cross-recipient / cross-intent / cross-opportunity / cross-network /
+ * cross-task / cross-speaker contamination is a pure-function rejection rather
+ * than a downstream concern.
+ */
+export interface AllowlistedEvidence {
+    /** Deterministic id, unique within one mining pass: `${kind}:${opportunityId}:${ordinal}`. */
+    evidenceId: string;
+    kind: EvidenceKind;
+    speaker: EvidenceSpeaker;
+    /** The only text a support reference may quote — bounded, exclusion-scrubbed. */
+    content: string;
+    recipientUserId: string;
+    intentId: string;
+    intentFingerprint: string;
+    opportunityId: string;
+    taskId: string;
+    conversationId: string;
+    networkId: string;
+}
+/**
+ * One raw negotiation turn as read in place. Untrusted: it still carries the
+ * fields Lens C must EXCLUDE (`reasoning`, `askUser`/disclosure). The extractor
+ * maps only the allowlisted projection of this record.
+ */
+export interface RawEvidenceTurn {
+    /** Turn author user id — mapped to owner/counterparty against the segment. */
+    senderUserId: string;
+    /** Structured bilateral action (propose/accept/counter/decline/...). */
+    action: string;
+    /** Free-text message body, if any. */
+    message?: string | null;
+    /**
+     * True only when this message was EXPLICITLY shared/consented for reuse.
+     * Untagged messages are excluded — Lens C never mines an untagged answer.
+     */
+    sharedTagged?: boolean;
+    /** Chain-of-thought — EXCLUDED. Present here only to prove it is dropped. */
+    reasoning?: string | null;
+    /** Disclosure subject — EXCLUDED. Present here only to prove it is dropped. */
+    disclosureSubject?: string | null;
+}
+/** Coarse, structured outcome facts (no evaluator reasoning). */
+export interface RawEvidenceOutcome {
+    hasOpportunity: boolean;
+    /** `turn_cap | timeout` are coarse; `screened_out` is a private gate → dropped. */
+    reason?: "turn_cap" | "timeout" | "screened_out";
+    /** Agreed collaboration roles, if any. */
+    agreedRoles?: Array<{
+        userId: string;
+        role: string;
+    }>;
+    /** Evaluator reasoning — EXCLUDED. Present here only to prove it is dropped. */
+    reasoning?: string | null;
+}
+/** Authoritative owner answer (the recipient's own answer to a question). */
+export interface RawEvidenceOwnerAnswer {
+    /** Answerer user id — must equal the segment recipient to be authoritative. */
+    answererUserId: string;
+    selectedOptions: string[];
+    freeText?: string;
+}
+/**
+ * All in-place negotiation data for ONE opportunity segment, scoped to an
+ * exact recipient + intent/fingerprint + opportunity + task. Continuations of
+ * the same opportunity arrive as separate segments sharing `opportunityId`;
+ * the extractor groups them and counts the opportunity once.
+ */
+export interface RawEvidenceSegment {
+    recipientUserId: string;
+    intentId: string;
+    intentFingerprint: string;
+    opportunityId: string;
+    taskId: string;
+    conversationId: string;
+    networkId: string;
+    /** The counterparty in this bilateral negotiation. */
+    counterpartyUserId: string;
+    turns: RawEvidenceTurn[];
+    outcome?: RawEvidenceOutcome | null;
+    ownerAnswers?: RawEvidenceOwnerAnswer[];
+}
+/** The scope a mining pass is bound to — every segment must match it exactly. */
+export interface EvidenceMiningScope {
+    recipientUserId: string;
+    intentId: string;
+    intentFingerprint: string;
+    networkId: string;
+}
+/**
+ * The three claim shapes a hypothesis may take. The speaker constraint is
+ * enforced against these: `recipient_fact` / `recipient_preference` require
+ * owner-authored (or structured bilateral) support; `observation` may also be
+ * supported by counterparty statements.
+ */
+export type HypothesisClaimType = "observation" | "recipient_fact" | "recipient_preference";
+/** A support reference proposed by the miner (before code-side verification). */
+export interface ProposedSupportRef {
+    /** Must resolve to an {@link AllowlistedEvidence} in the pass. */
+    evidenceId: string;
+    /** Verbatim span the miner copied from that evidence's content. */
+    span: string;
+}
+/** One hypothesis proposed by the miner. */
+export interface MinedEvidenceHypothesis {
+    /** Neutral, non-identifying clarification hypothesis. */
+    statement: string;
+    claimType: HypothesisClaimType;
+    supportRefs: ProposedSupportRef[];
+}
+/** A support reference that resolved against the allowlist. */
+export interface VerifiedSupportRef {
+    evidenceId: string;
+    kind: EvidenceKind;
+    speaker: EvidenceSpeaker;
+    opportunityId: string;
+}
+/**
+ * A hypothesis after verification + the recurrence gate. Retained hypotheses
+ * are returned for OFFLINE review only — shadow mode never persists or logs
+ * their text (see {@link NegotiationEvidenceTelemetry}).
+ */
+export interface RetainedEvidenceHypothesis {
+    statement: string;
+    claimType: HypothesisClaimType;
+    support: VerifiedSupportRef[];
+    /** Count of DISTINCT opportunities in `support` — the recurrence measure. */
+    distinctOpportunities: number;
+}
+/**
+ * Aggregate-only telemetry. Deliberately carries NO evidence content, NO
+ * hypothesis text, and NO spans — only counts — so it is safe to emit to
+ * routine logs without leaking internal negotiation content.
+ */
+export interface NegotiationEvidenceTelemetry {
+    recipientUserId: string;
+    intentId: string;
+    /** Raw segments supplied to the pass (pre-grouping). */
+    segments: number;
+    /** Distinct opportunities after continuation grouping. */
+    distinctOpportunities: number;
+    /** Allowlisted evidence unit counts, by kind. */
+    evidenceCounts: Record<EvidenceKind, number>;
+    /** Records dropped by allowlist / exclusion / provenance mismatch. */
+    excludedRecords: number;
+    hypothesesMined: number;
+    /** Hypotheses whose every support ref verified against the allowlist. */
+    hypothesesSupported: number;
+    /** Supported hypotheses that also met the distinct-opportunity floor. */
+    hypothesesRecurrent: number;
+    /** Hypotheses discarded (unsupported ref, speaker violation, or too rare). */
+    hypothesesDiscarded: number;
+}
+/** Result of one shadow mining pass. */
+export interface NegotiationEvidenceShadowResult {
+    /** Safe-to-log aggregate counts. */
+    telemetry: NegotiationEvidenceTelemetry;
+    /**
+     * Retained recurrent hypotheses for offline eval. In shadow mode the caller
+     * MUST NOT persist these or write them to routine logs.
+     */
+    hypotheses: RetainedEvidenceHypothesis[];
+}
+//# sourceMappingURL=negotiation-evidence.types.d.ts.map

package/dist/opportunity/negotiation-evidence/negotiation-evidence.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation-evidence.types.d.ts","sourceRoot":"/","sources":["opportunity/negotiation-evidence/negotiation-evidence.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GACpB,cAAc,GACd,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,CAAC;AAErB;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,cAAc,GAAG,QAAQ,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,8FAA8F;IAC9F,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,eAAe,CAAC;IACzB,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC;IAEhB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,iEAAiE;AACjE,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,OAAO,CAAC;IACxB,mFAAmF;IACnF,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,cAAc,CAAC;IACjD,0CAA0C;IAC1C,WAAW,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,6EAA6E;AAC7E,MAAM,WAAW,sBAAsB;IACrC,+EAA+E;IAC/E,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACpC,YAAY,CAAC,EAAE,sBAAsB,EAAE,CAAC;CACzC;AAED,iFAAiF;AACjF,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAC3B,aAAa,GACb,gBAAgB,GAChB,sBAAsB,CAAC;AAE3B,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;CACd;AAED,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,WAAW,EAAE,kBAAkB,EAAE,CAAC;CACnC;AAED,+DAA+D;AAC/D,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,eAAe,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC7C,sEAAsE;IACtE,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yEAAyE;IACzE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,wCAAwC;AACxC,MAAM,WAAW,+BAA+B;IAC9C,oCAAoC;IACpC,SAAS,EAAE,4BAA4B,CAAC;IACxC;;;OAGG;IACH,UAAU,EAAE,0BAA0B,EAAE,CAAC;CAC1C"}

package/dist/opportunity/negotiation-evidence/negotiation-evidence.types.js

@@ -0,0 +1,19 @@
+/**
+ * Lens C negotiation-evidence — shared types (IND-433).
+ *
+ * Lens C mines neutral clarification hypotheses from RECURRING negotiation
+ * evidence, read in place at mining time. It never builds a durable transcript
+ * projection and never summarizes an entire pair DM; the only content it will
+ * ever touch is a narrow, positively-constructed allowlist:
+ *
+ *   - authoritative owner answers (the recipient's own answers),
+ *   - structured bilateral actions / coarse outcomes, and
+ *   - explicitly shared message content.
+ *
+ * Everything else — screen/evaluator reasoning, agent chain-of-thought,
+ * `memoryHints`, private negotiator memories/reflections, disclosure subjects,
+ * untagged shared answers, and old synthesized digests — is excluded by
+ * construction (never mapped into an {@link AllowlistedEvidence}).
+ */
+export {};
+//# sourceMappingURL=negotiation-evidence.types.js.map

package/dist/opportunity/negotiation-evidence/negotiation-evidence.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation-evidence.types.js","sourceRoot":"/","sources":["opportunity/negotiation-evidence/negotiation-evidence.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG","sourcesContent":["/**\n * Lens C negotiation-evidence — shared types (IND-433).\n *\n * Lens C mines neutral clarification hypotheses from RECURRING negotiation\n * evidence, read in place at mining time. It never builds a durable transcript\n * projection and never summarizes an entire pair DM; the only content it will\n * ever touch is a narrow, positively-constructed allowlist:\n *\n *   - authoritative owner answers (the recipient's own answers),\n *   - structured bilateral actions / coarse outcomes, and\n *   - explicitly shared message content.\n *\n * Everything else — screen/evaluator reasoning, agent chain-of-thought,\n * `memoryHints`, private negotiator memories/reflections, disclosure subjects,\n * untagged shared answers, and old synthesized digests — is excluded by\n * construction (never mapped into an {@link AllowlistedEvidence}).\n */\n\n/** The four allowlisted evidence families. Nothing else may be surfaced. */\nexport type EvidenceKind =\n  | \"owner_answer\"\n  | \"bilateral_action\"\n  | \"coarse_outcome\"\n  | \"shared_message\";\n\n/**\n * Who authored an evidence unit. `system` covers structured bilateral facts\n * (actions/outcomes) that belong to neither party's voice. The distinction is\n * load-bearing: a counterparty statement may support an OBSERVATION but never\n * a fact or preference ABOUT the recipient (IND-433).\n */\nexport type EvidenceSpeaker = \"owner\" | \"counterparty\" | \"system\";\n\n/**\n * One unit of allowlisted evidence, extracted in place for exactly one\n * (recipient, intent, opportunity, task) tuple. Provenance travels with the\n * unit so cross-recipient / cross-intent / cross-opportunity / cross-network /\n * cross-task / cross-speaker contamination is a pure-function rejection rather\n * than a downstream concern.\n */\nexport interface AllowlistedEvidence {\n  /** Deterministic id, unique within one mining pass: `${kind}:${opportunityId}:${ordinal}`. */\n  evidenceId: string;\n  kind: EvidenceKind;\n  speaker: EvidenceSpeaker;\n  /** The only text a support reference may quote — bounded, exclusion-scrubbed. */\n  content: string;\n  // Provenance (used for keying + contamination rejection; never sent to the LLM).\n  recipientUserId: string;\n  intentId: string;\n  intentFingerprint: string;\n  opportunityId: string;\n  taskId: string;\n  conversationId: string;\n  networkId: string;\n}\n\n/**\n * One raw negotiation turn as read in place. Untrusted: it still carries the\n * fields Lens C must EXCLUDE (`reasoning`, `askUser`/disclosure). The extractor\n * maps only the allowlisted projection of this record.\n */\nexport interface RawEvidenceTurn {\n  /** Turn author user id — mapped to owner/counterparty against the segment. */\n  senderUserId: string;\n  /** Structured bilateral action (propose/accept/counter/decline/...). */\n  action: string;\n  /** Free-text message body, if any. */\n  message?: string | null;\n  /**\n   * True only when this message was EXPLICITLY shared/consented for reuse.\n   * Untagged messages are excluded — Lens C never mines an untagged answer.\n   */\n  sharedTagged?: boolean;\n  /** Chain-of-thought — EXCLUDED. Present here only to prove it is dropped. */\n  reasoning?: string | null;\n  /** Disclosure subject — EXCLUDED. Present here only to prove it is dropped. */\n  disclosureSubject?: string | null;\n}\n\n/** Coarse, structured outcome facts (no evaluator reasoning). */\nexport interface RawEvidenceOutcome {\n  hasOpportunity: boolean;\n  /** `turn_cap | timeout` are coarse; `screened_out` is a private gate → dropped. */\n  reason?: \"turn_cap\" | \"timeout\" | \"screened_out\";\n  /** Agreed collaboration roles, if any. */\n  agreedRoles?: Array<{ userId: string; role: string }>;\n  /** Evaluator reasoning — EXCLUDED. Present here only to prove it is dropped. */\n  reasoning?: string | null;\n}\n\n/** Authoritative owner answer (the recipient's own answer to a question). */\nexport interface RawEvidenceOwnerAnswer {\n  /** Answerer user id — must equal the segment recipient to be authoritative. */\n  answererUserId: string;\n  selectedOptions: string[];\n  freeText?: string;\n}\n\n/**\n * All in-place negotiation data for ONE opportunity segment, scoped to an\n * exact recipient + intent/fingerprint + opportunity + task. Continuations of\n * the same opportunity arrive as separate segments sharing `opportunityId`;\n * the extractor groups them and counts the opportunity once.\n */\nexport interface RawEvidenceSegment {\n  recipientUserId: string;\n  intentId: string;\n  intentFingerprint: string;\n  opportunityId: string;\n  taskId: string;\n  conversationId: string;\n  networkId: string;\n  /** The counterparty in this bilateral negotiation. */\n  counterpartyUserId: string;\n  turns: RawEvidenceTurn[];\n  outcome?: RawEvidenceOutcome | null;\n  ownerAnswers?: RawEvidenceOwnerAnswer[];\n}\n\n/** The scope a mining pass is bound to — every segment must match it exactly. */\nexport interface EvidenceMiningScope {\n  recipientUserId: string;\n  intentId: string;\n  intentFingerprint: string;\n  networkId: string;\n}\n\n/**\n * The three claim shapes a hypothesis may take. The speaker constraint is\n * enforced against these: `recipient_fact` / `recipient_preference` require\n * owner-authored (or structured bilateral) support; `observation` may also be\n * supported by counterparty statements.\n */\nexport type HypothesisClaimType =\n  | \"observation\"\n  | \"recipient_fact\"\n  | \"recipient_preference\";\n\n/** A support reference proposed by the miner (before code-side verification). */\nexport interface ProposedSupportRef {\n  /** Must resolve to an {@link AllowlistedEvidence} in the pass. */\n  evidenceId: string;\n  /** Verbatim span the miner copied from that evidence's content. */\n  span: string;\n}\n\n/** One hypothesis proposed by the miner. */\nexport interface MinedEvidenceHypothesis {\n  /** Neutral, non-identifying clarification hypothesis. */\n  statement: string;\n  claimType: HypothesisClaimType;\n  supportRefs: ProposedSupportRef[];\n}\n\n/** A support reference that resolved against the allowlist. */\nexport interface VerifiedSupportRef {\n  evidenceId: string;\n  kind: EvidenceKind;\n  speaker: EvidenceSpeaker;\n  opportunityId: string;\n}\n\n/**\n * A hypothesis after verification + the recurrence gate. Retained hypotheses\n * are returned for OFFLINE review only — shadow mode never persists or logs\n * their text (see {@link NegotiationEvidenceTelemetry}).\n */\nexport interface RetainedEvidenceHypothesis {\n  statement: string;\n  claimType: HypothesisClaimType;\n  support: VerifiedSupportRef[];\n  /** Count of DISTINCT opportunities in `support` — the recurrence measure. */\n  distinctOpportunities: number;\n}\n\n/**\n * Aggregate-only telemetry. Deliberately carries NO evidence content, NO\n * hypothesis text, and NO spans — only counts — so it is safe to emit to\n * routine logs without leaking internal negotiation content.\n */\nexport interface NegotiationEvidenceTelemetry {\n  recipientUserId: string;\n  intentId: string;\n  /** Raw segments supplied to the pass (pre-grouping). */\n  segments: number;\n  /** Distinct opportunities after continuation grouping. */\n  distinctOpportunities: number;\n  /** Allowlisted evidence unit counts, by kind. */\n  evidenceCounts: Record<EvidenceKind, number>;\n  /** Records dropped by allowlist / exclusion / provenance mismatch. */\n  excludedRecords: number;\n  hypothesesMined: number;\n  /** Hypotheses whose every support ref verified against the allowlist. */\n  hypothesesSupported: number;\n  /** Supported hypotheses that also met the distinct-opportunity floor. */\n  hypothesesRecurrent: number;\n  /** Hypotheses discarded (unsupported ref, speaker violation, or too rare). */\n  hypothesesDiscarded: number;\n}\n\n/** Result of one shadow mining pass. */\nexport interface NegotiationEvidenceShadowResult {\n  /** Safe-to-log aggregate counts. */\n  telemetry: NegotiationEvidenceTelemetry;\n  /**\n   * Retained recurrent hypotheses for offline eval. In shadow mode the caller\n   * MUST NOT persist these or write them to routine logs.\n   */\n  hypotheses: RetainedEvidenceHypothesis[];\n}\n"]}

package/dist/opportunity/negotiation-evidence/negotiation-evidence.verifier.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Lens C support-reference verification + recurrence gate (IND-433).
+ *
+ * A mined hypothesis is retained ONLY when:
+ *   1. it carries at least one support reference,
+ *   2. EVERY support reference resolves to an allowlisted evidence unit in
+ *      this pass AND quotes a verbatim span of that unit's content,
+ *   3. the speaker constraint holds — a claim that is a fact or preference
+ *      ABOUT the recipient may never rest on a counterparty statement, and
+ *   4. its verified support spans at least `minDistinctOpportunities` DISTINCT
+ *      opportunities (recurrence). Continuations were already grouped upstream,
+ *      so same-pair repetition cannot inflate this.
+ *
+ * Any failure discards the whole hypothesis — there is no partial retention.
+ */
+import type { AllowlistedEvidence, MinedEvidenceHypothesis, RetainedEvidenceHypothesis } from "./negotiation-evidence.types.js";
+/** Result of verifying a batch of mined hypotheses. */
+export interface VerificationResult {
+    /** Hypotheses that passed verification AND the recurrence gate. */
+    retained: RetainedEvidenceHypothesis[];
+    /** Hypotheses whose every support ref verified (pre-recurrence). */
+    supported: number;
+    /** Supported hypotheses that also met the distinct-opportunity floor. */
+    recurrent: number;
+    /** Hypotheses discarded for any reason (mined − recurrent). */
+    discarded: number;
+}
+/** True when `span` is a meaningful verbatim substring of `content`. */
+export declare function evidenceSpanMatches(content: string, span: string): boolean;
+/**
+ * Verify + recurrence-gate a batch of mined hypotheses against the allowlisted
+ * evidence produced for the same pass.
+ */
+export declare function verifyHypotheses(hypotheses: MinedEvidenceHypothesis[], evidence: AllowlistedEvidence[], minDistinctOpportunities: number): VerificationResult;
+//# sourceMappingURL=negotiation-evidence.verifier.d.ts.map

package/dist/opportunity/negotiation-evidence/negotiation-evidence.verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation-evidence.verifier.d.ts","sourceRoot":"/","sources":["opportunity/negotiation-evidence/negotiation-evidence.verifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAuB,uBAAuB,EAAE,0BAA0B,EAAsB,MAAM,iCAAiC,CAAC;AAEzK,uDAAuD;AACvD,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,QAAQ,EAAE,0BAA0B,EAAE,CAAC;IACvC,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;CACnB;AAwBD,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAI1E;AAqCD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,uBAAuB,EAAE,EACrC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,wBAAwB,EAAE,MAAM,GAC/B,kBAAkB,CA6BpB"}

package/dist/opportunity/negotiation-evidence/negotiation-evidence.verifier.js

@@ -0,0 +1,92 @@
+/** Minimum normalized span length that counts as meaningful verbatim evidence. */
+const MIN_SPAN_CHARS = 8;
+/** Lowercase, fold typographic punctuation, collapse whitespace. */
+function normalizeForMatch(s) {
+    return s
+        .toLowerCase()
+        .replace(/[\u2018\u2019\u02bc]/g, "'")
+        .replace(/[\u201c\u201d]/g, '"')
+        .replace(/[\u2013\u2014]/g, "-")
+        .replace(/\u2026/g, "...")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** Strip wrapping quotes / edge punctuation the LLM habitually adds. */
+function stripEdgePunctuation(s) {
+    return s
+        .replace(/^[\s"'.,;:!?()\u2018\u2019\u201c\u201d]+/, "")
+        .replace(/[\s"'.,;:!?()\u2018\u2019\u201c\u201d]+$/, "");
+}
+/** True when `span` is a meaningful verbatim substring of `content`. */
+export function evidenceSpanMatches(content, span) {
+    const haystack = normalizeForMatch(content);
+    const needle = normalizeForMatch(stripEdgePunctuation(span));
+    return needle.length >= MIN_SPAN_CHARS && haystack.includes(needle);
+}
+/**
+ * A `recipient_fact` / `recipient_preference` claim must not lean on a
+ * counterparty statement. `observation` claims accept any speaker.
+ */
+function speakerAllowedForClaim(claimType, evidence) {
+    if (claimType === "observation")
+        return true;
+    return evidence.speaker !== "counterparty";
+}
+/**
+ * Verify one hypothesis. Returns the verified support (deduped) when every
+ * reference resolves and satisfies the speaker constraint; otherwise null.
+ */
+function verifyHypothesis(hypothesis, byId) {
+    if (hypothesis.supportRefs.length === 0)
+        return null;
+    const verified = new Map();
+    for (const ref of hypothesis.supportRefs) {
+        const evidence = byId.get(ref.evidenceId);
+        if (!evidence)
+            return null; // reference to non-allowlisted / hallucinated id
+        if (!speakerAllowedForClaim(hypothesis.claimType, evidence))
+            return null;
+        if (!evidenceSpanMatches(evidence.content, ref.span))
+            return null;
+        verified.set(evidence.evidenceId, {
+            evidenceId: evidence.evidenceId,
+            kind: evidence.kind,
+            speaker: evidence.speaker,
+            opportunityId: evidence.opportunityId,
+        });
+    }
+    return [...verified.values()];
+}
+/**
+ * Verify + recurrence-gate a batch of mined hypotheses against the allowlisted
+ * evidence produced for the same pass.
+ */
+export function verifyHypotheses(hypotheses, evidence, minDistinctOpportunities) {
+    const byId = new Map(evidence.map((e) => [e.evidenceId, e]));
+    const retained = [];
+    let supported = 0;
+    let recurrent = 0;
+    for (const hypothesis of hypotheses) {
+        const support = verifyHypothesis(hypothesis, byId);
+        if (!support)
+            continue;
+        supported += 1;
+        const distinctOpportunities = new Set(support.map((s) => s.opportunityId)).size;
+        if (distinctOpportunities < minDistinctOpportunities)
+            continue;
+        recurrent += 1;
+        retained.push({
+            statement: hypothesis.statement,
+            claimType: hypothesis.claimType,
+            support,
+            distinctOpportunities,
+        });
+    }
+    return {
+        retained,
+        supported,
+        recurrent,
+        discarded: hypotheses.length - recurrent,
+    };
+}
+//# sourceMappingURL=negotiation-evidence.verifier.js.map

package/dist/opportunity/negotiation-evidence/negotiation-evidence.verifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation-evidence.verifier.js","sourceRoot":"/","sources":["opportunity/negotiation-evidence/negotiation-evidence.verifier.ts"],"names":[],"mappings":"AA6BA,kFAAkF;AAClF,MAAM,cAAc,GAAG,CAAC,CAAC;AAEzB,oEAAoE;AACpE,SAAS,iBAAiB,CAAC,CAAS;IAClC,OAAO,CAAC;SACL,WAAW,EAAE;SACb,OAAO,CAAC,uBAAuB,EAAE,GAAG,CAAC;SACrC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC;SAC/B,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC;SAC/B,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;SACzB,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC;SACpB,IAAI,EAAE,CAAC;AACZ,CAAC;AAED,wEAAwE;AACxE,SAAS,oBAAoB,CAAC,CAAS;IACrC,OAAO,CAAC;SACL,OAAO,CAAC,0CAA0C,EAAE,EAAE,CAAC;SACvD,OAAO,CAAC,0CAA0C,EAAE,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,mBAAmB,CAAC,OAAe,EAAE,IAAY;IAC/D,MAAM,QAAQ,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,iBAAiB,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7D,OAAO,MAAM,CAAC,MAAM,IAAI,cAAc,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACtE,CAAC;AAED;;;GAGG;AACH,SAAS,sBAAsB,CAAC,SAA8B,EAAE,QAA6B;IAC3F,IAAI,SAAS,KAAK,aAAa;QAAE,OAAO,IAAI,CAAC;IAC7C,OAAO,QAAQ,CAAC,OAAO,KAAK,cAAc,CAAC;AAC7C,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CACvB,UAAmC,EACnC,IAAsC;IAEtC,IAAI,UAAU,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAErD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA8B,CAAC;IACvD,KAAK,MAAM,GAAG,IAAI,UAAU,CAAC,WAAW,EAAE,CAAC;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC,CAAC,iDAAiD;QAC7E,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,SAAS,EAAE,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QACzE,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAClE,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,EAAE;YAChC,UAAU,EAAE,QAAQ,CAAC,UAAU;YAC/B,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,aAAa,EAAE,QAAQ,CAAC,aAAa;SACtC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;AAChC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAqC,EACrC,QAA+B,EAC/B,wBAAgC;IAEhC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,MAAM,QAAQ,GAAiC,EAAE,CAAC;IAClD,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,MAAM,UAAU,IAAI,UAAU,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,OAAO;YAAE,SAAS;QACvB,SAAS,IAAI,CAAC,CAAC;QAEf,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC;QAChF,IAAI,qBAAqB,GAAG,wBAAwB;YAAE,SAAS;QAC/D,SAAS,IAAI,CAAC,CAAC;QAEf,QAAQ,CAAC,IAAI,CAAC;YACZ,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,OAAO;YACP,qBAAqB;SACtB,CAAC,CAAC;IACL,CAAC;IAED,OAAO;QACL,QAAQ;QACR,SAAS;QACT,SAAS;QACT,SAAS,EAAE,UAAU,CAAC,MAAM,GAAG,SAAS;KACzC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Lens C support-reference verification + recurrence gate (IND-433).\n *\n * A mined hypothesis is retained ONLY when:\n *   1. it carries at least one support reference,\n *   2. EVERY support reference resolves to an allowlisted evidence unit in\n *      this pass AND quotes a verbatim span of that unit's content,\n *   3. the speaker constraint holds — a claim that is a fact or preference\n *      ABOUT the recipient may never rest on a counterparty statement, and\n *   4. its verified support spans at least `minDistinctOpportunities` DISTINCT\n *      opportunities (recurrence). Continuations were already grouped upstream,\n *      so same-pair repetition cannot inflate this.\n *\n * Any failure discards the whole hypothesis — there is no partial retention.\n */\nimport type { AllowlistedEvidence, HypothesisClaimType, MinedEvidenceHypothesis, RetainedEvidenceHypothesis, VerifiedSupportRef } from \"./negotiation-evidence.types.js\";\n\n/** Result of verifying a batch of mined hypotheses. */\nexport interface VerificationResult {\n  /** Hypotheses that passed verification AND the recurrence gate. */\n  retained: RetainedEvidenceHypothesis[];\n  /** Hypotheses whose every support ref verified (pre-recurrence). */\n  supported: number;\n  /** Supported hypotheses that also met the distinct-opportunity floor. */\n  recurrent: number;\n  /** Hypotheses discarded for any reason (mined − recurrent). */\n  discarded: number;\n}\n\n/** Minimum normalized span length that counts as meaningful verbatim evidence. */\nconst MIN_SPAN_CHARS = 8;\n\n/** Lowercase, fold typographic punctuation, collapse whitespace. */\nfunction normalizeForMatch(s: string): string {\n  return s\n    .toLowerCase()\n    .replace(/[\\u2018\\u2019\\u02bc]/g, \"'\")\n    .replace(/[\\u201c\\u201d]/g, '\"')\n    .replace(/[\\u2013\\u2014]/g, \"-\")\n    .replace(/\\u2026/g, \"...\")\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n\n/** Strip wrapping quotes / edge punctuation the LLM habitually adds. */\nfunction stripEdgePunctuation(s: string): string {\n  return s\n    .replace(/^[\\s\"'.,;:!?()\\u2018\\u2019\\u201c\\u201d]+/, \"\")\n    .replace(/[\\s\"'.,;:!?()\\u2018\\u2019\\u201c\\u201d]+$/, \"\");\n}\n\n/** True when `span` is a meaningful verbatim substring of `content`. */\nexport function evidenceSpanMatches(content: string, span: string): boolean {\n  const haystack = normalizeForMatch(content);\n  const needle = normalizeForMatch(stripEdgePunctuation(span));\n  return needle.length >= MIN_SPAN_CHARS && haystack.includes(needle);\n}\n\n/**\n * A `recipient_fact` / `recipient_preference` claim must not lean on a\n * counterparty statement. `observation` claims accept any speaker.\n */\nfunction speakerAllowedForClaim(claimType: HypothesisClaimType, evidence: AllowlistedEvidence): boolean {\n  if (claimType === \"observation\") return true;\n  return evidence.speaker !== \"counterparty\";\n}\n\n/**\n * Verify one hypothesis. Returns the verified support (deduped) when every\n * reference resolves and satisfies the speaker constraint; otherwise null.\n */\nfunction verifyHypothesis(\n  hypothesis: MinedEvidenceHypothesis,\n  byId: Map<string, AllowlistedEvidence>,\n): VerifiedSupportRef[] | null {\n  if (hypothesis.supportRefs.length === 0) return null;\n\n  const verified = new Map<string, VerifiedSupportRef>();\n  for (const ref of hypothesis.supportRefs) {\n    const evidence = byId.get(ref.evidenceId);\n    if (!evidence) return null; // reference to non-allowlisted / hallucinated id\n    if (!speakerAllowedForClaim(hypothesis.claimType, evidence)) return null;\n    if (!evidenceSpanMatches(evidence.content, ref.span)) return null;\n    verified.set(evidence.evidenceId, {\n      evidenceId: evidence.evidenceId,\n      kind: evidence.kind,\n      speaker: evidence.speaker,\n      opportunityId: evidence.opportunityId,\n    });\n  }\n  return [...verified.values()];\n}\n\n/**\n * Verify + recurrence-gate a batch of mined hypotheses against the allowlisted\n * evidence produced for the same pass.\n */\nexport function verifyHypotheses(\n  hypotheses: MinedEvidenceHypothesis[],\n  evidence: AllowlistedEvidence[],\n  minDistinctOpportunities: number,\n): VerificationResult {\n  const byId = new Map(evidence.map((e) => [e.evidenceId, e]));\n  const retained: RetainedEvidenceHypothesis[] = [];\n  let supported = 0;\n  let recurrent = 0;\n\n  for (const hypothesis of hypotheses) {\n    const support = verifyHypothesis(hypothesis, byId);\n    if (!support) continue;\n    supported += 1;\n\n    const distinctOpportunities = new Set(support.map((s) => s.opportunityId)).size;\n    if (distinctOpportunities < minDistinctOpportunities) continue;\n    recurrent += 1;\n\n    retained.push({\n      statement: hypothesis.statement,\n      claimType: hypothesis.claimType,\n      support,\n      distinctOpportunities,\n    });\n  }\n\n  return {\n    retained,\n    supported,\n    recurrent,\n    discarded: hypotheses.length - recurrent,\n  };\n}\n"]}

package/dist/opportunity/opportunity.graph.d.ts

@@ -42,8 +42,15 @@ export type OpportunityEvaluatorLike = {
 };
 import type { Embedder } from '../shared/interfaces/embedder.interface.js';
 import type { CreateOpportunityData, Opportunity } from '../shared/interfaces/database.interface.js';
-import type { NegotiationGraphLike } from "../negotiation/negotiation.state.js";
+import type { NegotiationGraphLike, UserNegotiationContext } from "../negotiation/negotiation.state.js";
 import type { AgentDispatcher } from "../shared/interfaces/agent-dispatcher.interface.js";
+interface NegotiationIntentSource {
+    id?: string | null;
+    summary?: string | null;
+    payload?: string | null;
+}
+/** Put an opportunity actor's exact intent first, then fill the bounded context without duplicates. */
+export declare function buildPrioritizedNegotiationIntents(activeIntents: readonly NegotiationIntentSource[], exactIntentId?: string | null, fallbackIntent?: NegotiationIntentSource | null): UserNegotiationContext['intents'];
 /** Input shape for the HyDE graph invoke call (query-based embedding). */
 export interface HydeGeneratorInvokeInput {
     sourceType: 'query';
@@ -1299,4 +1306,5 @@ export declare class OpportunityGraphFactory {
         };
     }, unknown, unknown, []>;
 }
+export {};
 //# sourceMappingURL=opportunity.graph.d.ts.map

package/dist/opportunity/opportunity.graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opportunity.graph.d.ts","sourceRoot":"/","sources":["opportunity/opportunity.graph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"opportunity.graph.d.ts","sourceRoot":"/","sources":["opportunity/opportunity.graph.ts"],"names":[],"mappings":"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"}

package/dist/opportunity/opportunity.graph.js

@@ -53,6 +53,37 @@ const negotiateExistingLog = protocolLogger('OpportunityGraph:NegotiateExisting'
 const routingLog = protocolLogger('OpportunityGraph:Routing');
 /** Time window for persist-node dedup. Suppresses a second opportunity with the same person while a recent one (within 30 days) is still in flight, so a person is not re-surfaced multiple times within a month (EDG-23). */
 const DEDUP_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
+const NEGOTIATION_INTENT_LIMIT = 5;
+/** Put an opportunity actor's exact intent first, then fill the bounded context without duplicates. */
+export function buildPrioritizedNegotiationIntents(activeIntents, exactIntentId, fallbackIntent) {
+    const exactId = typeof exactIntentId === 'string' && exactIntentId.trim().length > 0
+        ? exactIntentId
+        : null;
+    const exactActive = exactId
+        ? activeIntents.find((intent) => intent.id === exactId)
+        : undefined;
+    const ordered = [
+        ...(exactActive ? [exactActive] : []),
+        ...(!exactActive && fallbackIntent?.id === exactId ? [fallbackIntent] : []),
+        ...activeIntents,
+    ];
+    const seen = new Set();
+    const intents = [];
+    for (const intent of ordered) {
+        if (typeof intent.id !== 'string' || intent.id.trim().length === 0 || seen.has(intent.id))
+            continue;
+        seen.add(intent.id);
+        intents.push({
+            id: intent.id,
+            title: intent.summary ?? '',
+            description: intent.payload ?? '',
+            confidence: 1,
+        });
+        if (intents.length === NEGOTIATION_INTENT_LIMIT)
+            break;
+    }
+    return intents;
+}
 /** Default cap for source premises used by premise-to-premise discovery. Prevents BACKEND-5-style fan-out. */
 const DEFAULT_SOURCE_PREMISE_DISCOVERY_LIMIT = 40;
 function networkMembershipPairKey(userId, networkId) {
@@ -1801,14 +1832,21 @@ export class OpportunityGraphFactory {
                 // Use the same discoveryUserId pattern as evaluationNode
                 const discoveryUserId = (state.onBehalfOfUserId ?? state.userId);
                 const sourceAccount = await this.database.getUser(discoveryUserId).catch(() => null);
+                const sourceIntentInputs = (state.indexedIntents ?? []).map((intent) => ({
+                    id: intent.intentId,
+                    summary: intent.summary ?? null,
+                    payload: intent.payload ?? null,
+                }));
+                const sourceHasExactIntent = sourceIntentInputs.some((intent) => intent.id === state.triggerIntentId);
+                const sourceFallbackIntent = state.triggerIntentId && !sourceHasExactIntent
+                    ? await this.database.getIntent(state.triggerIntentId).catch(() => null)
+                    : null;
+                const ownedSourceFallback = sourceFallbackIntent?.userId === discoveryUserId
+                    ? sourceFallbackIntent
+                    : null;
                 const sourceUser = {
                     id: discoveryUserId,
-                    intents: state.indexedIntents?.slice(0, 5).map(i => ({
-                        id: i.intentId,
-                        title: i.summary ?? '',
-                        description: i.payload ?? '',
-                        confidence: 1,
-                    })) ?? [],
+                    intents: buildPrioritizedNegotiationIntents(sourceIntentInputs, state.triggerIntentId, ownedSourceFallback),
                     profile: {
                         name: state.sourceProfile?.identity?.name ?? sourceAccount?.name,
                         bio: state.sourceProfile?.identity?.bio ?? sourceAccount?.intro ?? undefined,
@@ -1834,8 +1872,7 @@ export class OpportunityGraphFactory {
                         });
                         return null;
                     }
-                    const candidateActor = opp.actors
-                        .find(a => a.userId !== discoveryUserId);
+                    const candidateActor = opp.actors.find(a => a.userId !== discoveryUserId);
                     if (!candidateActor) {
                         negotiateLog.verbose('Skipping opportunity: no candidateActor found', {
                             opportunityId: opp.id,
@@ -1853,27 +1890,17 @@ export class OpportunityGraphFactory {
                 });
                 const candidates = await Promise.all(candidateEntries.map(async ({ opp, candidateActor }) => {
                     const userId = candidateActor.userId;
+                    const candidateIntentId = candidateActor.intentId ?? candidateActor.intent;
                     const [profile, user, activeIntents, intent] = await Promise.all([
                         this.database.getProfile(userId).catch(() => null),
                         this.database.getUser(userId).catch(() => null),
                         this.database.getActiveIntents(userId).catch(() => []),
-                        candidateActor.intentId
-                            ? this.database.getIntent(candidateActor.intentId).catch(() => null)
+                        candidateIntentId
+                            ? this.database.getIntent(candidateIntentId).catch(() => null)
                             : null,
                     ]);
-                    const toNegIntent = (ai) => ({
-                        id: (ai.id ?? candidateActor.intentId),
-                        title: ai.summary ?? '',
-                        description: ai.payload ?? '',
-                        confidence: 1,
-                    });
-                    const triggerInActive = activeIntents.some(ai => ai.id === candidateActor.intentId);
-                    const triggerFallback = !triggerInActive && intent ? [toNegIntent(intent)] : [];
-                    const candidateIntents = [
-                        ...triggerFallback,
-                        ...activeIntents.filter(ai => ai.id === candidateActor.intentId).map(toNegIntent),
-                        ...activeIntents.filter(ai => ai.id !== candidateActor.intentId).map(toNegIntent),
-                    ].slice(0, 5);
+                    const ownedFallbackIntent = intent?.userId === userId ? intent : null;
+                    const candidateIntents = buildPrioritizedNegotiationIntents(activeIntents, candidateIntentId, ownedFallbackIntent);
                     return {
                         userId,
                         opportunityId: opp.id,
@@ -3385,6 +3412,8 @@ export class OpportunityGraphFactory {
                     negotiateExistingLog.warn('No candidate actor found', { opportunityId: state.opportunityId });
                     return {};
                 }
+                const sourceIntentId = sourceActor.intentId ?? sourceActor.intent;
+                const candidateIntentId = candidateActor.intentId ?? candidateActor.intent;
                 // Load user data for both actors in parallel
                 const [sourceUserAccount, sourceProfile, sourceIntents, candidateAccount, candidateProfile, candidateIntents] = await Promise.all([
                     this.database.getUser(sourceActor.userId).catch(() => null),
@@ -3394,22 +3423,26 @@ export class OpportunityGraphFactory {
                     this.database.getProfile(candidateActor.userId).catch(() => null),
                     this.database.getActiveIntents(candidateActor.userId).catch(() => []),
                 ]);
-                const toNegIntent = (ai) => ({
-                    id: ai.id,
-                    title: ai.summary ?? '',
-                    description: ai.payload ?? '',
-                    confidence: 1,
-                });
+                const sourceHasExactIntent = sourceIntents.some((intent) => intent.id === sourceIntentId);
+                const candidateHasExactIntent = candidateIntents.some((intent) => intent.id === candidateIntentId);
+                const [sourceFallbackIntent, candidateFallbackIntent] = await Promise.all([
+                    sourceIntentId && !sourceHasExactIntent
+                        ? this.database.getIntent(sourceIntentId).catch(() => null)
+                        : null,
+                    candidateIntentId && !candidateHasExactIntent
+                        ? this.database.getIntent(candidateIntentId).catch(() => null)
+                        : null,
+                ]);
                 const sourceUser = {
                     id: sourceActor.userId,
-                    intents: sourceIntents.slice(0, 5).map(toNegIntent),
+                    intents: buildPrioritizedNegotiationIntents(sourceIntents, sourceIntentId, sourceFallbackIntent?.userId === sourceActor.userId ? sourceFallbackIntent : null),
                     profile: {
                         name: sourceProfile?.identity?.name ?? sourceUserAccount?.name,
                         bio: sourceProfile?.identity?.bio ?? sourceUserAccount?.intro ?? undefined,
                         location: sourceProfile?.identity?.location ?? sourceUserAccount?.location ?? undefined,
                     },
                 };
-                const candidateIntentsForNeg = candidateIntents.slice(0, 5).map(toNegIntent);
+                const candidateIntentsForNeg = buildPrioritizedNegotiationIntents(candidateIntents, candidateIntentId, candidateFallbackIntent?.userId === candidateActor.userId ? candidateFallbackIntent : null);
                 const candidate = {
                     userId: candidateActor.userId,
                     opportunityId: opp.id,