@indexnetwork/protocol 4.5.0-rc.332.1 → 4.5.0-rc.334.1

package/dist/negotiation/negotiation.protocol.js

@@ -0,0 +1,152 @@
+/**
+ * Seat-scoped negotiation protocol rules (v2 client-advocate protocol).
+ *
+ * v2 fixes exactly one initiating seat per match (`metadata.initiatorUserId`,
+ * stamped at discovery time — IND-396) and makes consent asymmetric:
+ * **accept can only come from the counterparty seat**, schema-enforced.
+ *
+ * Vocabulary per seat (v2):
+ * - initiator:     `outreach | counter | question | withdraw`  (no accept)
+ * - counterparty:  `accept | decline | counter | question`
+ * - final turn:    initiator `withdraw | counter`; counterparty `accept | decline`
+ *
+ * v1 tasks keep the legacy vocabulary (`propose | accept | reject | counter |
+ * question`) — the version is inherited per conversation, never re-stamped, so
+ * in-flight v1 negotiations are grandfathered untouched.
+ *
+ * Outcome mapping is version-independent: `accept` → opportunity `pending`,
+ * `reject`/`withdraw`/`decline` → `rejected`, turn-cap → `stalled`.
+ */
+import { z } from "zod";
+// ─── Shared assessment fragment ──────────────────────────────────────────────
+const AssessmentSchema = z.object({
+    reasoning: z.string(),
+    suggestedRoles: z.object({
+        ownUser: z.enum(["agent", "patient", "peer"]),
+        otherUser: z.enum(["agent", "patient", "peer"]),
+    }),
+});
+function turnSchema(actions) {
+    return z.object({
+        action: z.enum(actions),
+        assessment: AssessmentSchema,
+        message: z.string().nullable().optional(),
+    });
+}
+// ─── v2 seat-scoped turn schemas ─────────────────────────────────────────────
+/** Initiator seat, non-final turn: may reach out, push back, ask, or walk away — never accept. */
+export const InitiatorTurnSchema = turnSchema(["outreach", "counter", "question", "withdraw"]);
+/** Counterparty seat, non-final turn: the only seat that can accept. */
+export const CounterpartyTurnSchema = turnSchema(["accept", "decline", "counter", "question"]);
+/** Initiator seat, final allowed turn: commit to walking away or leave the door open. */
+export const FinalInitiatorTurnSchema = turnSchema(["withdraw", "counter"]);
+/** Counterparty seat, final allowed turn: must decide. */
+export const FinalCounterpartyTurnSchema = turnSchema(["accept", "decline"]);
+// ─── Action vocabulary per version + seat ────────────────────────────────────
+const V1_ACTIONS = ["propose", "accept", "reject", "counter", "question"];
+const V1_FINAL_ACTIONS = ["accept", "reject"];
+const V2_INITIATOR_ACTIONS = ["outreach", "counter", "question", "withdraw"];
+const V2_COUNTERPARTY_ACTIONS = ["accept", "decline", "counter", "question"];
+const V2_FINAL_INITIATOR_ACTIONS = ["withdraw", "counter"];
+const V2_FINAL_COUNTERPARTY_ACTIONS = ["accept", "decline"];
+/**
+ * The set of actions a given seat may submit under a given protocol version.
+ *
+ * v1 ignores the seat entirely (legacy symmetric vocabulary) so pre-v2
+ * negotiations behave exactly as before.
+ */
+export function allowedActionsFor(version, seat, isFinalTurn = false) {
+    if (version !== "v2")
+        return isFinalTurn ? V1_FINAL_ACTIONS : V1_ACTIONS;
+    if (seat === "initiator")
+        return isFinalTurn ? V2_FINAL_INITIATOR_ACTIONS : V2_INITIATOR_ACTIONS;
+    return isFinalTurn ? V2_FINAL_COUNTERPARTY_ACTIONS : V2_COUNTERPARTY_ACTIONS;
+}
+/**
+ * Zod turn schema for a system-agent turn, selected by version + seat +
+ * final-turn flag. v1 returns the legacy schemas (seat-agnostic); v2 returns
+ * the seat-scoped schemas above, making an initiator `accept` structurally
+ * impossible rather than prompt-discouraged.
+ *
+ * The v1 legacy schemas are passed in by the caller (they live in
+ * `negotiation.state.ts`) to keep this module free of a state-module import.
+ */
+export function turnSchemaFor(version, seat, isFinalTurn, v1Schemas) {
+    if (version !== "v2")
+        return isFinalTurn ? v1Schemas.final : v1Schemas.system;
+    if (seat === "initiator")
+        return isFinalTurn ? FinalInitiatorTurnSchema : InitiatorTurnSchema;
+    return isFinalTurn ? FinalCounterpartyTurnSchema : CounterpartyTurnSchema;
+}
+// ─── Action semantics (version-independent) ──────────────────────────────────
+/** Terminal actions end the negotiation immediately. */
+export function isTerminalAction(action) {
+    return action === "accept" || action === "reject" || action === "withdraw" || action === "decline";
+}
+/** Reject-like actions map the opportunity to `rejected` (v1 reject, v2 withdraw/decline). */
+export function isRejectLikeAction(action) {
+    return action === "reject" || action === "withdraw" || action === "decline";
+}
+/**
+ * Conservative action when an agent produced schema-invalid output (after the
+ * retry) or an internal error needs a seat-valid terminal placeholder.
+ *
+ * Non-final turns fall back to `counter` (keeps the dialogue open — the AC's
+ * "conservative counter"). Final turns must decide: v1 → `reject`, v2
+ * counterparty → `decline`, v2 initiator → `counter` is still legal on the
+ * final turn so it stays `counter` (finalizes as turn-cap/stalled).
+ */
+export function fallbackActionFor(version, seat, isFinalTurn) {
+    if (!isFinalTurn)
+        return "counter";
+    if (version !== "v2")
+        return "reject";
+    return seat === "counterparty" ? "decline" : "counter";
+}
+/** Seat-appropriate reject-like action for error paths. */
+export function rejectActionFor(version, seat) {
+    if (version !== "v2")
+        return "reject";
+    return seat === "initiator" ? "withdraw" : "decline";
+}
+// ─── Metadata readers ────────────────────────────────────────────────────────
+/**
+ * Read the protocol version off task metadata. Returns null when the task
+ * predates version stamping (treat as v1 at the call site when the task is a
+ * genuine prior; fresh tasks stamp from {@link configuredProtocolVersion}).
+ */
+export function readProtocolVersion(metadata) {
+    const v = metadata?.protocolVersion;
+    return v === "v2" ? "v2" : v === "v1" ? "v1" : null;
+}
+/**
+ * Protocol version for genuinely fresh negotiations, from the
+ * `NEGOTIATION_PROTOCOL_VERSION` env switch. Defaults to `v1` when unset —
+ * v2 is opt-in per environment, and rolling back is the same single switch.
+ */
+export function configuredProtocolVersion() {
+    return process.env.NEGOTIATION_PROTOCOL_VERSION === "v2" ? "v2" : "v1";
+}
+/**
+ * Resolve the seat of `userId` on a negotiation task.
+ *
+ * Keys on `metadata.initiatorUserId` (the rigid v2 stamp), **never on turn
+ * parity** — continuations can start with either side speaking first, so
+ * parity misattributes seats across sessions. Pre-stamp tasks fall back to
+ * `sourceUserId` (the discovery-session opener), which is what the stamp
+ * defaults to anyway.
+ */
+export function resolveSeat(userId, metadata) {
+    const initiator = typeof metadata?.initiatorUserId === "string" && metadata.initiatorUserId.length > 0
+        ? metadata.initiatorUserId
+        : typeof metadata?.sourceUserId === "string"
+            ? metadata.sourceUserId
+            : undefined;
+    return initiator === userId ? "initiator" : "counterparty";
+}
+/** Human-readable seat-violation message shared by respond surfaces. */
+export function seatViolationMessage(action, seat, version) {
+    const allowed = allowedActionsFor(version, seat).join(", ");
+    return `Action "${action}" is not allowed for your seat (${seat}) under negotiation protocol ${version}. Allowed actions: ${allowed}.`;
+}
+//# sourceMappingURL=negotiation.protocol.js.map

package/dist/negotiation/negotiation.protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation.protocol.js","sourceRoot":"/","sources":["negotiation/negotiation.protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,gFAAgF;AAEhF,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC;QACvB,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QAC7C,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;KAChD,CAAC;CACH,CAAC,CAAC;AAEH,SAAS,UAAU,CAAwD,OAAU;IACnF,OAAO,CAAC,CAAC,MAAM,CAAC;QACd,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QACvB,UAAU,EAAE,gBAAgB;QAC5B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;KAC1C,CAAC,CAAC;AACL,CAAC;AAED,gFAAgF;AAEhF,kGAAkG;AAClG,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC,CAAC,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;AAE/F,wEAAwE;AACxE,MAAM,CAAC,MAAM,sBAAsB,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AAE/F,yFAAyF;AACzF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;AAE5E,0DAA0D;AAC1D,MAAM,CAAC,MAAM,2BAA2B,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAE7E,gFAAgF;AAEhF,MAAM,UAAU,GAAiC,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AACxG,MAAM,gBAAgB,GAAiC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAC5E,MAAM,oBAAoB,GAAiC,CAAC,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;AAC3G,MAAM,uBAAuB,GAAiC,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AAC3G,MAAM,0BAA0B,GAAiC,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AACzF,MAAM,6BAA6B,GAAiC,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AAE1F;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAmC,EACnC,IAAqB,EACrB,WAAW,GAAG,KAAK;IAEnB,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC;IACzE,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,WAAW,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,oBAAoB,CAAC;IACjG,OAAO,WAAW,CAAC,CAAC,CAAC,6BAA6B,CAAC,CAAC,CAAC,uBAAuB,CAAC;AAC/E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAmC,EACnC,IAAqB,EACrB,WAAoB,EACpB,SAAwD;IAExD,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC;IAC9E,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,WAAW,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,mBAAmB,CAAC;IAC9F,OAAO,WAAW,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,sBAAsB,CAAC;AAC5E,CAAC;AAED,gFAAgF;AAEhF,wDAAwD;AACxD,MAAM,UAAU,gBAAgB,CAAC,MAAiC;IAChE,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS,CAAC;AACrG,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,kBAAkB,CAAC,MAAiC;IAClE,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,UAAU,IAAI,MAAM,KAAK,SAAS,CAAC;AAC9E,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAmC,EACnC,IAAqB,EACrB,WAAoB;IAEpB,IAAI,CAAC,WAAW;QAAE,OAAO,SAAS,CAAC;IACnC,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,QAAQ,CAAC;IACtC,OAAO,IAAI,KAAK,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,eAAe,CAC7B,OAAmC,EACnC,IAAqB;IAErB,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,QAAQ,CAAC;IACtC,OAAO,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC;AACvD,CAAC;AAED,gFAAgF;AAEhF;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,QAA0D;IAE1D,MAAM,CAAC,GAAG,QAAQ,EAAE,eAAe,CAAC;IACpC,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB;IACvC,OAAO,OAAO,CAAC,GAAG,CAAC,4BAA4B,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AACzE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CACzB,MAAc,EACd,QAAkF;IAElF,MAAM,SAAS,GACb,OAAO,QAAQ,EAAE,eAAe,KAAK,QAAQ,IAAI,QAAQ,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC;QAClF,CAAC,CAAC,QAAQ,CAAC,eAAe;QAC1B,CAAC,CAAC,OAAO,QAAQ,EAAE,YAAY,KAAK,QAAQ;YAC1C,CAAC,CAAC,QAAQ,CAAC,YAAY;YACvB,CAAC,CAAC,SAAS,CAAC;IAClB,OAAO,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC;AAC7D,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,oBAAoB,CAClC,MAAc,EACd,IAAqB,EACrB,OAAmC;IAEnC,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5D,OAAO,WAAW,MAAM,mCAAmC,IAAI,gCAAgC,OAAO,sBAAsB,OAAO,GAAG,CAAC;AACzI,CAAC","sourcesContent":["/**\n * Seat-scoped negotiation protocol rules (v2 client-advocate protocol).\n *\n * v2 fixes exactly one initiating seat per match (`metadata.initiatorUserId`,\n * stamped at discovery time — IND-396) and makes consent asymmetric:\n * **accept can only come from the counterparty seat**, schema-enforced.\n *\n * Vocabulary per seat (v2):\n * - initiator:     `outreach | counter | question | withdraw`  (no accept)\n * - counterparty:  `accept | decline | counter | question`\n * - final turn:    initiator `withdraw | counter`; counterparty `accept | decline`\n *\n * v1 tasks keep the legacy vocabulary (`propose | accept | reject | counter |\n * question`) — the version is inherited per conversation, never re-stamped, so\n * in-flight v1 negotiations are grandfathered untouched.\n *\n * Outcome mapping is version-independent: `accept` → opportunity `pending`,\n * `reject`/`withdraw`/`decline` → `rejected`, turn-cap → `stalled`.\n */\nimport { z } from \"zod\";\n\nimport type { NegotiationAction, NegotiationSeat, NegotiationProtocolVersion } from \"../shared/schemas/negotiation-state.schema.js\";\n\n// ─── Shared assessment fragment ──────────────────────────────────────────────\n\nconst AssessmentSchema = z.object({\n  reasoning: z.string(),\n  suggestedRoles: z.object({\n    ownUser: z.enum([\"agent\", \"patient\", \"peer\"]),\n    otherUser: z.enum([\"agent\", \"patient\", \"peer\"]),\n  }),\n});\n\nfunction turnSchema<T extends [NegotiationAction, ...NegotiationAction[]]>(actions: T) {\n  return z.object({\n    action: z.enum(actions),\n    assessment: AssessmentSchema,\n    message: z.string().nullable().optional(),\n  });\n}\n\n// ─── v2 seat-scoped turn schemas ─────────────────────────────────────────────\n\n/** Initiator seat, non-final turn: may reach out, push back, ask, or walk away — never accept. */\nexport const InitiatorTurnSchema = turnSchema([\"outreach\", \"counter\", \"question\", \"withdraw\"]);\n\n/** Counterparty seat, non-final turn: the only seat that can accept. */\nexport const CounterpartyTurnSchema = turnSchema([\"accept\", \"decline\", \"counter\", \"question\"]);\n\n/** Initiator seat, final allowed turn: commit to walking away or leave the door open. */\nexport const FinalInitiatorTurnSchema = turnSchema([\"withdraw\", \"counter\"]);\n\n/** Counterparty seat, final allowed turn: must decide. */\nexport const FinalCounterpartyTurnSchema = turnSchema([\"accept\", \"decline\"]);\n\n// ─── Action vocabulary per version + seat ────────────────────────────────────\n\nconst V1_ACTIONS: readonly NegotiationAction[] = [\"propose\", \"accept\", \"reject\", \"counter\", \"question\"];\nconst V1_FINAL_ACTIONS: readonly NegotiationAction[] = [\"accept\", \"reject\"];\nconst V2_INITIATOR_ACTIONS: readonly NegotiationAction[] = [\"outreach\", \"counter\", \"question\", \"withdraw\"];\nconst V2_COUNTERPARTY_ACTIONS: readonly NegotiationAction[] = [\"accept\", \"decline\", \"counter\", \"question\"];\nconst V2_FINAL_INITIATOR_ACTIONS: readonly NegotiationAction[] = [\"withdraw\", \"counter\"];\nconst V2_FINAL_COUNTERPARTY_ACTIONS: readonly NegotiationAction[] = [\"accept\", \"decline\"];\n\n/**\n * The set of actions a given seat may submit under a given protocol version.\n *\n * v1 ignores the seat entirely (legacy symmetric vocabulary) so pre-v2\n * negotiations behave exactly as before.\n */\nexport function allowedActionsFor(\n  version: NegotiationProtocolVersion,\n  seat: NegotiationSeat,\n  isFinalTurn = false,\n): readonly NegotiationAction[] {\n  if (version !== \"v2\") return isFinalTurn ? V1_FINAL_ACTIONS : V1_ACTIONS;\n  if (seat === \"initiator\") return isFinalTurn ? V2_FINAL_INITIATOR_ACTIONS : V2_INITIATOR_ACTIONS;\n  return isFinalTurn ? V2_FINAL_COUNTERPARTY_ACTIONS : V2_COUNTERPARTY_ACTIONS;\n}\n\n/**\n * Zod turn schema for a system-agent turn, selected by version + seat +\n * final-turn flag. v1 returns the legacy schemas (seat-agnostic); v2 returns\n * the seat-scoped schemas above, making an initiator `accept` structurally\n * impossible rather than prompt-discouraged.\n *\n * The v1 legacy schemas are passed in by the caller (they live in\n * `negotiation.state.ts`) to keep this module free of a state-module import.\n */\nexport function turnSchemaFor(\n  version: NegotiationProtocolVersion,\n  seat: NegotiationSeat,\n  isFinalTurn: boolean,\n  v1Schemas: { system: z.ZodTypeAny; final: z.ZodTypeAny },\n): z.ZodTypeAny {\n  if (version !== \"v2\") return isFinalTurn ? v1Schemas.final : v1Schemas.system;\n  if (seat === \"initiator\") return isFinalTurn ? FinalInitiatorTurnSchema : InitiatorTurnSchema;\n  return isFinalTurn ? FinalCounterpartyTurnSchema : CounterpartyTurnSchema;\n}\n\n// ─── Action semantics (version-independent) ──────────────────────────────────\n\n/** Terminal actions end the negotiation immediately. */\nexport function isTerminalAction(action: string | undefined | null): boolean {\n  return action === \"accept\" || action === \"reject\" || action === \"withdraw\" || action === \"decline\";\n}\n\n/** Reject-like actions map the opportunity to `rejected` (v1 reject, v2 withdraw/decline). */\nexport function isRejectLikeAction(action: string | undefined | null): boolean {\n  return action === \"reject\" || action === \"withdraw\" || action === \"decline\";\n}\n\n/**\n * Conservative action when an agent produced schema-invalid output (after the\n * retry) or an internal error needs a seat-valid terminal placeholder.\n *\n * Non-final turns fall back to `counter` (keeps the dialogue open — the AC's\n * \"conservative counter\"). Final turns must decide: v1 → `reject`, v2\n * counterparty → `decline`, v2 initiator → `counter` is still legal on the\n * final turn so it stays `counter` (finalizes as turn-cap/stalled).\n */\nexport function fallbackActionFor(\n  version: NegotiationProtocolVersion,\n  seat: NegotiationSeat,\n  isFinalTurn: boolean,\n): NegotiationAction {\n  if (!isFinalTurn) return \"counter\";\n  if (version !== \"v2\") return \"reject\";\n  return seat === \"counterparty\" ? \"decline\" : \"counter\";\n}\n\n/** Seat-appropriate reject-like action for error paths. */\nexport function rejectActionFor(\n  version: NegotiationProtocolVersion,\n  seat: NegotiationSeat,\n): NegotiationAction {\n  if (version !== \"v2\") return \"reject\";\n  return seat === \"initiator\" ? \"withdraw\" : \"decline\";\n}\n\n// ─── Metadata readers ────────────────────────────────────────────────────────\n\n/**\n * Read the protocol version off task metadata. Returns null when the task\n * predates version stamping (treat as v1 at the call site when the task is a\n * genuine prior; fresh tasks stamp from {@link configuredProtocolVersion}).\n */\nexport function readProtocolVersion(\n  metadata: { protocolVersion?: unknown } | null | undefined,\n): NegotiationProtocolVersion | null {\n  const v = metadata?.protocolVersion;\n  return v === \"v2\" ? \"v2\" : v === \"v1\" ? \"v1\" : null;\n}\n\n/**\n * Protocol version for genuinely fresh negotiations, from the\n * `NEGOTIATION_PROTOCOL_VERSION` env switch. Defaults to `v1` when unset —\n * v2 is opt-in per environment, and rolling back is the same single switch.\n */\nexport function configuredProtocolVersion(): NegotiationProtocolVersion {\n  return process.env.NEGOTIATION_PROTOCOL_VERSION === \"v2\" ? \"v2\" : \"v1\";\n}\n\n/**\n * Resolve the seat of `userId` on a negotiation task.\n *\n * Keys on `metadata.initiatorUserId` (the rigid v2 stamp), **never on turn\n * parity** — continuations can start with either side speaking first, so\n * parity misattributes seats across sessions. Pre-stamp tasks fall back to\n * `sourceUserId` (the discovery-session opener), which is what the stamp\n * defaults to anyway.\n */\nexport function resolveSeat(\n  userId: string,\n  metadata: { initiatorUserId?: unknown; sourceUserId?: unknown } | null | undefined,\n): NegotiationSeat {\n  const initiator =\n    typeof metadata?.initiatorUserId === \"string\" && metadata.initiatorUserId.length > 0\n      ? metadata.initiatorUserId\n      : typeof metadata?.sourceUserId === \"string\"\n        ? metadata.sourceUserId\n        : undefined;\n  return initiator === userId ? \"initiator\" : \"counterparty\";\n}\n\n/** Human-readable seat-violation message shared by respond surfaces. */\nexport function seatViolationMessage(\n  action: string,\n  seat: NegotiationSeat,\n  version: NegotiationProtocolVersion,\n): string {\n  const allowed = allowedActionsFor(version, seat).join(\", \");\n  return `Action \"${action}\" is not allowed for your seat (${seat}) under negotiation protocol ${version}. Allowed actions: ${allowed}.`;\n}\n"]}

package/dist/negotiation/negotiation.screen.d.ts

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { createStructuredModel } from "../shared/agent/model.config.js";
+import type { UserNegotiationContext, SeedAssessment } from "../shared/schemas/negotiation-state.schema.js";
+/**
+ * Screen-gate modes (P2.1 — client-advocate protocol).
+ *
+ * - `off` — the screen node is skipped entirely; no LLM call, no telemetry.
+ * - `shadow` — the screen decision is made and recorded (task metadata +
+ *   trace event + log line) but NEVER blocks: every fresh negotiation still
+ *   proceeds to the first turn. Used to measure pass rates against observed
+ *   reject rates before enforcement.
+ * - `enforce` — reserved for P2.2. Until enforcement lands, `enforce` runs
+ *   identically to `shadow` (decision recorded, negotiation proceeds) and the
+ *   screen node logs a warning that enforcement is not yet implemented.
+ */
+export declare const NEGOTIATION_SCREEN_MODES: readonly ["off", "shadow", "enforce"];
+export type NegotiationScreenMode = (typeof NEGOTIATION_SCREEN_MODES)[number];
+/**
+ * Resolve the screen mode from `NEGOTIATION_SCREEN_MODE`.
+ *
+ * Defaults to `off` when unset or unrecognized — the screen gate is an
+ * explicit opt-in flip (same operational pattern as
+ * `NEGOTIATION_PROTOCOL_VERSION` / `NEGOTIATOR_CHAT_ENABLED`): code ships
+ * inert, the environment turns it on.
+ */
+export declare function configuredScreenMode(): NegotiationScreenMode;
+/**
+ * Structured screen decision — the outreach gate's verdict on whether this
+ * match is worth the client's name before any turn is exchanged.
+ */
+export declare const ScreenDecisionSchema: z.ZodObject<{
+    decision: z.ZodEnum<["reach_out", "pass"]>;
+    reasoning: z.ZodString;
+    /** Suggested opening angle for the outreach turn (only when reaching out). */
+    outreachAngle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    evidence: z.ZodObject<{
+        /** How well the counterparty's context/premises fit the client's need. */
+        counterpartyPremiseFit: z.ZodString;
+        /** How the client's intents align with what the counterparty seeks. */
+        intentAlignment: z.ZodString;
+        /** Prior-negotiation memory signals. Wired in P5.3 — always absent today. */
+        memoryHints: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        counterpartyPremiseFit: string;
+        intentAlignment: string;
+        memoryHints?: string | null | undefined;
+    }, {
+        counterpartyPremiseFit: string;
+        intentAlignment: string;
+        memoryHints?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    reasoning: string;
+    decision: "reach_out" | "pass";
+    evidence: {
+        counterpartyPremiseFit: string;
+        intentAlignment: string;
+        memoryHints?: string | null | undefined;
+    };
+    outreachAngle?: string | null | undefined;
+}, {
+    reasoning: string;
+    decision: "reach_out" | "pass";
+    evidence: {
+        counterpartyPremiseFit: string;
+        intentAlignment: string;
+        memoryHints?: string | null | undefined;
+    };
+    outreachAngle?: string | null | undefined;
+}>;
+export type ScreenDecision = z.infer<typeof ScreenDecisionSchema>;
+/**
+ * The record persisted to `tasks.metadata.screenDecision` and returned into
+ * graph state. Extends the LLM decision with operational context so pass-rate
+ * queries can group by mode and exclude failed-open rows.
+ */
+export interface ScreenDecisionRecord extends ScreenDecision {
+    mode: NegotiationScreenMode;
+    /** True when the screen LLM call failed and the gate defaulted open. */
+    failedOpen?: boolean;
+    /** Error message when `failedOpen` is set. */
+    error?: string;
+    screenedAt: string;
+    durationMs: number;
+}
+export interface NegotiationScreenerInput {
+    /** The client — the user whose negotiator is deciding whether to reach out. */
+    clientUser: UserNegotiationContext;
+    /** The counterparty the client's negotiator would be reaching out to. */
+    counterpartyUser: UserNegotiationContext;
+    /** The counterparty's `user_contexts` paragraph (empty string when absent). */
+    counterpartyContext?: string;
+    /** The explicit search query that triggered discovery (if any). */
+    discoveryQuery?: string;
+    seedAssessment: Omit<SeedAssessment, "actors">;
+    indexContext: {
+        networkId: string;
+        prompt?: string;
+    };
+}
+export interface NegotiationScreenerConfig {
+    /** Hard ceiling on the screen LLM round-trip, in ms (default 15000). */
+    timeoutMs?: number;
+}
+/**
+ * The outreach gate (P2.1). One structured LLM call deciding
+ * `reach_out | pass` for a fresh negotiation, from the reaching client's
+ * perspective. Throws on LLM/validation failure — the screen graph node owns
+ * the fail-open policy (a failed screen never blocks the negotiation).
+ */
+export declare class NegotiationScreener {
+    private readonly timeoutMs;
+    constructor(config?: NegotiationScreenerConfig);
+    /**
+     * Produce a screen decision for a fresh match.
+     * @throws When the LLM call times out or returns schema-invalid output.
+     */
+    invoke(input: NegotiationScreenerInput): Promise<ScreenDecision>;
+    /**
+     * Raw structured-model round trip. Split out as a seam so tests can drive
+     * the schema-validation and fail-open paths without a live provider.
+     */
+    protected callModel(model: ReturnType<typeof createStructuredModel>, chatMessages: Array<{
+        role: string;
+        content: string;
+    }>): Promise<unknown>;
+}
+//# sourceMappingURL=negotiation.screen.d.ts.map

package/dist/negotiation/negotiation.screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation.screen.d.ts","sourceRoot":"/","sources":["negotiation/negotiation.screen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,KAAK,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAK5G;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,uCAAwC,CAAC;AAE9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,qBAAqB,CAI5D;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;IAG/B,8EAA8E;;;QAG5E,0EAA0E;;QAE1E,uEAAuE;;QAEvE,6EAA6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG/E,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;GAIG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC1D,IAAI,EAAE,qBAAqB,CAAC;IAC5B,wEAAwE;IACxE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,+EAA+E;IAC/E,UAAU,EAAE,sBAAsB,CAAC;IACnC,yEAAyE;IACzE,gBAAgB,EAAE,sBAAsB,CAAC;IACzC,+EAA+E;IAC/E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,mEAAmE;IACnE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;IAC/C,YAAY,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACtD;AAqBD,MAAM,WAAW,yBAAyB;IACxC,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,MAAM,CAAC,EAAE,yBAAyB;IAM9C;;;OAGG;IACG,MAAM,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,cAAc,CAAC;IAgDtE;;;OAGG;cACa,SAAS,CACvB,KAAK,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,EAC/C,YAAY,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,GACrD,OAAO,CAAC,OAAO,CAAC;CAGpB"}

package/dist/negotiation/negotiation.screen.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { createStructuredModel } from "../shared/agent/model.config.js";
+import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
+import { protocolLogger } from "../shared/observability/protocol.logger.js";
+const screenLog = protocolLogger("NegotiationScreener");
+/**
+ * Screen-gate modes (P2.1 — client-advocate protocol).
+ *
+ * - `off` — the screen node is skipped entirely; no LLM call, no telemetry.
+ * - `shadow` — the screen decision is made and recorded (task metadata +
+ *   trace event + log line) but NEVER blocks: every fresh negotiation still
+ *   proceeds to the first turn. Used to measure pass rates against observed
+ *   reject rates before enforcement.
+ * - `enforce` — reserved for P2.2. Until enforcement lands, `enforce` runs
+ *   identically to `shadow` (decision recorded, negotiation proceeds) and the
+ *   screen node logs a warning that enforcement is not yet implemented.
+ */
+export const NEGOTIATION_SCREEN_MODES = ["off", "shadow", "enforce"];
+/**
+ * Resolve the screen mode from `NEGOTIATION_SCREEN_MODE`.
+ *
+ * Defaults to `off` when unset or unrecognized — the screen gate is an
+ * explicit opt-in flip (same operational pattern as
+ * `NEGOTIATION_PROTOCOL_VERSION` / `NEGOTIATOR_CHAT_ENABLED`): code ships
+ * inert, the environment turns it on.
+ */
+export function configuredScreenMode() {
+    const raw = process.env.NEGOTIATION_SCREEN_MODE;
+    if (raw === "shadow" || raw === "enforce" || raw === "off")
+        return raw;
+    return "off";
+}
+/**
+ * Structured screen decision — the outreach gate's verdict on whether this
+ * match is worth the client's name before any turn is exchanged.
+ */
+export const ScreenDecisionSchema = z.object({
+    decision: z.enum(["reach_out", "pass"]),
+    reasoning: z.string(),
+    /** Suggested opening angle for the outreach turn (only when reaching out). */
+    outreachAngle: z.string().nullable().optional(),
+    evidence: z.object({
+        /** How well the counterparty's context/premises fit the client's need. */
+        counterpartyPremiseFit: z.string(),
+        /** How the client's intents align with what the counterparty seeks. */
+        intentAlignment: z.string(),
+        /** Prior-negotiation memory signals. Wired in P5.3 — always absent today. */
+        memoryHints: z.string().nullable().optional(),
+    }),
+});
+const SYSTEM_PROMPT = `You are the outreach gate for {clientName}'s negotiator agent on a discovery network. Before any negotiation turn is exchanged, you decide whether this match is worth reaching out to on {clientName}'s behalf — their name and attention are spent with every outreach.
+
+Network context: {networkContext}
+
+Decide:
+- "reach_out" when the counterparty plausibly serves {clientName}'s stated needs and a concrete, honest opening case can be made. When reaching out, set outreachAngle to the strongest specific angle for the opening message.
+- "pass" when the match is generic, one-sided, or rests on vague overlap that would waste both parties' attention.
+
+Rules:
+{queryRule}
+- Judge concrete intent alignment, not topical adjacency.
+- Fill evidence.counterpartyPremiseFit with what (if anything) in the counterparty's context actually fits, and evidence.intentAlignment with how the intents line up. Be specific; cite the strongest signal either way.
+- Do NOT reference internal system details like scores, pre-screens, or evaluator outputs in reasoning that could be shown to users.`;
+const QUERY_RULE = `- {clientName} explicitly searched for "{discoveryQuery}". This query is the PRIMARY criterion: if the counterparty does not satisfy it, pass — background intents cannot rescue a query mismatch.`;
+const NO_QUERY_RULE = `- No explicit search query: judge against {clientName}'s active intents.`;
+const DEFAULT_SCREEN_TIMEOUT_MS = 15000;
+/**
+ * The outreach gate (P2.1). One structured LLM call deciding
+ * `reach_out | pass` for a fresh negotiation, from the reaching client's
+ * perspective. Throws on LLM/validation failure — the screen graph node owns
+ * the fail-open policy (a failed screen never blocks the negotiation).
+ */
+export class NegotiationScreener {
+    constructor(config) {
+        this.timeoutMs = config?.timeoutMs && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0
+            ? config.timeoutMs
+            : DEFAULT_SCREEN_TIMEOUT_MS;
+    }
+    /**
+     * Produce a screen decision for a fresh match.
+     * @throws When the LLM call times out or returns schema-invalid output.
+     */
+    async invoke(input) {
+        const model = createStructuredModel("negotiationScreener", ScreenDecisionSchema, { name: "negotiation_screener" });
+        const clientName = input.clientUser.profile.name ?? "your client";
+        const counterpartyName = input.counterpartyUser.profile.name ?? "the counterparty";
+        const networkContext = input.indexContext.prompt || "General discovery";
+        const queryRule = (input.discoveryQuery ? QUERY_RULE : NO_QUERY_RULE)
+            .replace(/{clientName}/g, clientName)
+            .replace(/{discoveryQuery}/g, input.discoveryQuery ?? "");
+        const systemPrompt = SYSTEM_PROMPT
+            .replace(/{clientName}/g, clientName)
+            .replace("{networkContext}", networkContext)
+            .replace("{queryRule}", queryRule);
+        const formatIntents = (intents) => intents.length > 0 ? intents.map((i) => `- ${i.title}: ${i.description}`).join("\n") : "- (none)";
+        const userMessage = `YOUR CLIENT (${clientName}):
+Bio: ${input.clientUser.profile.bio ?? "N/A"}
+${input.discoveryQuery ? `Search query: "${input.discoveryQuery}"\nBackground intents (secondary to the query):` : "Active intents:"}
+${formatIntents(input.clientUser.intents)}
+
+COUNTERPARTY (${counterpartyName}):
+Bio: ${input.counterpartyUser.profile.bio ?? "N/A"}
+${input.counterpartyContext ? `Context: ${input.counterpartyContext}\n` : ""}Active intents:
+${formatIntents(input.counterpartyUser.intents)}
+
+Why this match was suggested: ${input.seedAssessment.reasoning}
+
+Decide whether reaching out serves ${clientName}.`;
+        const chatMessages = [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userMessage },
+        ];
+        const result = await this.callModel(model, chatMessages);
+        const parsed = ScreenDecisionSchema.safeParse(result);
+        if (!parsed.success) {
+            screenLog.warn("Screen output failed schema validation", {
+                issues: parsed.error.issues.map((i) => i.message).slice(0, 3),
+            });
+            throw new Error(`Screen decision failed validation: ${parsed.error.issues[0]?.message ?? "unknown"}`);
+        }
+        return parsed.data;
+    }
+    /**
+     * Raw structured-model round trip. Split out as a seam so tests can drive
+     * the schema-validation and fail-open paths without a live provider.
+     */
+    async callModel(model, chatMessages) {
+        return invokeWithAbortSignal(model, chatMessages, AbortSignal.timeout(this.timeoutMs));
+    }
+}
+//# sourceMappingURL=negotiation.screen.js.map

package/dist/negotiation/negotiation.screen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation.screen.js","sourceRoot":"/","sources":["negotiation/negotiation.screen.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\n\nimport { createStructuredModel } from \"../shared/agent/model.config.js\";\nimport { invokeWithAbortSignal } from \"../shared/agent/model-signal.js\";\nimport type { UserNegotiationContext, SeedAssessment } from \"../shared/schemas/negotiation-state.schema.js\";\nimport { protocolLogger } from \"../shared/observability/protocol.logger.js\";\n\nconst screenLog = protocolLogger(\"NegotiationScreener\");\n\n/**\n * Screen-gate modes (P2.1 — client-advocate protocol).\n *\n * - `off` — the screen node is skipped entirely; no LLM call, no telemetry.\n * - `shadow` — the screen decision is made and recorded (task metadata +\n *   trace event + log line) but NEVER blocks: every fresh negotiation still\n *   proceeds to the first turn. Used to measure pass rates against observed\n *   reject rates before enforcement.\n * - `enforce` — reserved for P2.2. Until enforcement lands, `enforce` runs\n *   identically to `shadow` (decision recorded, negotiation proceeds) and the\n *   screen node logs a warning that enforcement is not yet implemented.\n */\nexport const NEGOTIATION_SCREEN_MODES = [\"off\", \"shadow\", \"enforce\"] as const;\n\nexport type NegotiationScreenMode = (typeof NEGOTIATION_SCREEN_MODES)[number];\n\n/**\n * Resolve the screen mode from `NEGOTIATION_SCREEN_MODE`.\n *\n * Defaults to `off` when unset or unrecognized — the screen gate is an\n * explicit opt-in flip (same operational pattern as\n * `NEGOTIATION_PROTOCOL_VERSION` / `NEGOTIATOR_CHAT_ENABLED`): code ships\n * inert, the environment turns it on.\n */\nexport function configuredScreenMode(): NegotiationScreenMode {\n  const raw = process.env.NEGOTIATION_SCREEN_MODE;\n  if (raw === \"shadow\" || raw === \"enforce\" || raw === \"off\") return raw;\n  return \"off\";\n}\n\n/**\n * Structured screen decision — the outreach gate's verdict on whether this\n * match is worth the client's name before any turn is exchanged.\n */\nexport const ScreenDecisionSchema = z.object({\n  decision: z.enum([\"reach_out\", \"pass\"]),\n  reasoning: z.string(),\n  /** Suggested opening angle for the outreach turn (only when reaching out). */\n  outreachAngle: z.string().nullable().optional(),\n  evidence: z.object({\n    /** How well the counterparty's context/premises fit the client's need. */\n    counterpartyPremiseFit: z.string(),\n    /** How the client's intents align with what the counterparty seeks. */\n    intentAlignment: z.string(),\n    /** Prior-negotiation memory signals. Wired in P5.3 — always absent today. */\n    memoryHints: z.string().nullable().optional(),\n  }),\n});\n\nexport type ScreenDecision = z.infer<typeof ScreenDecisionSchema>;\n\n/**\n * The record persisted to `tasks.metadata.screenDecision` and returned into\n * graph state. Extends the LLM decision with operational context so pass-rate\n * queries can group by mode and exclude failed-open rows.\n */\nexport interface ScreenDecisionRecord extends ScreenDecision {\n  mode: NegotiationScreenMode;\n  /** True when the screen LLM call failed and the gate defaulted open. */\n  failedOpen?: boolean;\n  /** Error message when `failedOpen` is set. */\n  error?: string;\n  screenedAt: string;\n  durationMs: number;\n}\n\nexport interface NegotiationScreenerInput {\n  /** The client — the user whose negotiator is deciding whether to reach out. */\n  clientUser: UserNegotiationContext;\n  /** The counterparty the client's negotiator would be reaching out to. */\n  counterpartyUser: UserNegotiationContext;\n  /** The counterparty's `user_contexts` paragraph (empty string when absent). */\n  counterpartyContext?: string;\n  /** The explicit search query that triggered discovery (if any). */\n  discoveryQuery?: string;\n  seedAssessment: Omit<SeedAssessment, \"actors\">;\n  indexContext: { networkId: string; prompt?: string };\n}\n\nconst SYSTEM_PROMPT = `You are the outreach gate for {clientName}'s negotiator agent on a discovery network. Before any negotiation turn is exchanged, you decide whether this match is worth reaching out to on {clientName}'s behalf — their name and attention are spent with every outreach.\n\nNetwork context: {networkContext}\n\nDecide:\n- \"reach_out\" when the counterparty plausibly serves {clientName}'s stated needs and a concrete, honest opening case can be made. When reaching out, set outreachAngle to the strongest specific angle for the opening message.\n- \"pass\" when the match is generic, one-sided, or rests on vague overlap that would waste both parties' attention.\n\nRules:\n{queryRule}\n- Judge concrete intent alignment, not topical adjacency.\n- Fill evidence.counterpartyPremiseFit with what (if anything) in the counterparty's context actually fits, and evidence.intentAlignment with how the intents line up. Be specific; cite the strongest signal either way.\n- Do NOT reference internal system details like scores, pre-screens, or evaluator outputs in reasoning that could be shown to users.`;\n\nconst QUERY_RULE = `- {clientName} explicitly searched for \"{discoveryQuery}\". This query is the PRIMARY criterion: if the counterparty does not satisfy it, pass — background intents cannot rescue a query mismatch.`;\nconst NO_QUERY_RULE = `- No explicit search query: judge against {clientName}'s active intents.`;\n\nconst DEFAULT_SCREEN_TIMEOUT_MS = 15_000;\n\nexport interface NegotiationScreenerConfig {\n  /** Hard ceiling on the screen LLM round-trip, in ms (default 15000). */\n  timeoutMs?: number;\n}\n\n/**\n * The outreach gate (P2.1). One structured LLM call deciding\n * `reach_out | pass` for a fresh negotiation, from the reaching client's\n * perspective. Throws on LLM/validation failure — the screen graph node owns\n * the fail-open policy (a failed screen never blocks the negotiation).\n */\nexport class NegotiationScreener {\n  private readonly timeoutMs: number;\n\n  constructor(config?: NegotiationScreenerConfig) {\n    this.timeoutMs = config?.timeoutMs && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0\n      ? config.timeoutMs\n      : DEFAULT_SCREEN_TIMEOUT_MS;\n  }\n\n  /**\n   * Produce a screen decision for a fresh match.\n   * @throws When the LLM call times out or returns schema-invalid output.\n   */\n  async invoke(input: NegotiationScreenerInput): Promise<ScreenDecision> {\n    const model = createStructuredModel(\"negotiationScreener\", ScreenDecisionSchema, { name: \"negotiation_screener\" });\n\n    const clientName = input.clientUser.profile.name ?? \"your client\";\n    const counterpartyName = input.counterpartyUser.profile.name ?? \"the counterparty\";\n    const networkContext = input.indexContext.prompt || \"General discovery\";\n    const queryRule = (input.discoveryQuery ? QUERY_RULE : NO_QUERY_RULE)\n      .replace(/{clientName}/g, clientName)\n      .replace(/{discoveryQuery}/g, input.discoveryQuery ?? \"\");\n\n    const systemPrompt = SYSTEM_PROMPT\n      .replace(/{clientName}/g, clientName)\n      .replace(\"{networkContext}\", networkContext)\n      .replace(\"{queryRule}\", queryRule);\n\n    const formatIntents = (intents: UserNegotiationContext[\"intents\"]): string =>\n      intents.length > 0 ? intents.map((i) => `- ${i.title}: ${i.description}`).join(\"\\n\") : \"- (none)\";\n\n    const userMessage = `YOUR CLIENT (${clientName}):\nBio: ${input.clientUser.profile.bio ?? \"N/A\"}\n${input.discoveryQuery ? `Search query: \"${input.discoveryQuery}\"\\nBackground intents (secondary to the query):` : \"Active intents:\"}\n${formatIntents(input.clientUser.intents)}\n\nCOUNTERPARTY (${counterpartyName}):\nBio: ${input.counterpartyUser.profile.bio ?? \"N/A\"}\n${input.counterpartyContext ? `Context: ${input.counterpartyContext}\\n` : \"\"}Active intents:\n${formatIntents(input.counterpartyUser.intents)}\n\nWhy this match was suggested: ${input.seedAssessment.reasoning}\n\nDecide whether reaching out serves ${clientName}.`;\n\n    const chatMessages = [\n      { role: \"system\", content: systemPrompt },\n      { role: \"user\", content: userMessage },\n    ];\n\n    const result = await this.callModel(model, chatMessages);\n    const parsed = ScreenDecisionSchema.safeParse(result);\n    if (!parsed.success) {\n      screenLog.warn(\"Screen output failed schema validation\", {\n        issues: parsed.error.issues.map((i) => i.message).slice(0, 3),\n      });\n      throw new Error(`Screen decision failed validation: ${parsed.error.issues[0]?.message ?? \"unknown\"}`);\n    }\n    return parsed.data;\n  }\n\n  /**\n   * Raw structured-model round trip. Split out as a seam so tests can drive\n   * the schema-validation and fail-open paths without a live provider.\n   */\n  protected async callModel(\n    model: ReturnType<typeof createStructuredModel>,\n    chatMessages: Array<{ role: string; content: string }>,\n  ): Promise<unknown> {\n    return invokeWithAbortSignal(model, chatMessages, AbortSignal.timeout(this.timeoutMs));\n  }\n}\n"]}

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

@@ -1,8 +1,14 @@
 import { z } from "zod";
 import type { NegotiationUserAnswer } from "../shared/interfaces/database.interface.js";
-/** Zod schema for a single negotiation turn (DataPart payload in A2A message). */
+import type { ScreenDecisionRecord } from "./negotiation.screen.js";
+import { type NegotiationProtocolVersion } from "../shared/schemas/negotiation-state.schema.js";
+/**
+ * Zod schema for a single negotiation turn (DataPart payload in A2A message).
+ * Accepts the full v1+v2 action union — which subset is valid for a given turn
+ * is enforced by the seat-scoped schemas in `negotiation.protocol.ts`.
+ */
 export declare const NegotiationTurnSchema: z.ZodObject<{
-    action: z.ZodEnum<["propose", "accept", "reject", "counter", "question"]>;
+    action: z.ZodEnum<["propose", "accept", "reject", "counter", "question", "outreach", "withdraw", "decline"]>;
     assessment: z.ZodObject<{
         reasoning: z.ZodString;
         suggestedRoles: z.ZodObject<{
@@ -30,7 +36,7 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     }>;
     message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
-    action: "propose" | "accept" | "reject" | "counter" | "question";
+    action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline";
     assessment: {
         reasoning: string;
         suggestedRoles: {
@@ -40,7 +46,7 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     };
     message?: string | null | undefined;
 }, {
-    action: "propose" | "accept" | "reject" | "counter" | "question";
+    action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline";
     assessment: {
         reasoning: string;
         suggestedRoles: {
@@ -50,7 +56,7 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     };
     message?: string | null | undefined;
 }>;
-/** Restricted turn schema for the system agent (no question action). */
+/** Restricted v1 turn schema for the system agent (no question action). */
 export declare const SystemNegotiationTurnSchema: z.ZodObject<{
     action: z.ZodEnum<["propose", "accept", "reject", "counter"]>;
     assessment: z.ZodObject<{
@@ -100,7 +106,7 @@ export declare const SystemNegotiationTurnSchema: z.ZodObject<{
     };
     message?: string | null | undefined;
 }>;
-/** Turn schema for system agent's final allowed turn (must decide). */
+/** v1 turn schema for system agent's final allowed turn (must decide). */
 export declare const FinalNegotiationTurnSchema: z.ZodObject<{
     action: z.ZodEnum<["accept", "reject"]>;
     assessment: z.ZodObject<{
@@ -273,6 +279,19 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
     initiatorUserId: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
     /** The explicit search query that triggered discovery (if any). */
     discoveryQuery: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
+    /**
+     * Negotiation protocol version for this session's task. Resolved by the
+     * init node: inherited from the prior task on the conversation when one
+     * exists (never re-stamped — a v1 conversation stays v1 mid-flight), else
+     * stamped from `NEGOTIATION_PROTOCOL_VERSION` for genuinely fresh runs.
+     */
+    protocolVersion: import("@langchain/langgraph").BaseChannel<NegotiationProtocolVersion, NegotiationProtocolVersion | import("@langchain/langgraph").OverwriteValue<NegotiationProtocolVersion>, unknown>;
+    /**
+     * Screen-gate decision for this fresh run (P2.1 shadow mode). Written by the
+     * screen node; null when the gate is off, on continuations, or before the
+     * node runs. Mirrors `tasks.metadata.screenDecision`.
+     */
+    screenDecision: import("@langchain/langgraph").BaseChannel<ScreenDecisionRecord | null, ScreenDecisionRecord | import("@langchain/langgraph").OverwriteValue<ScreenDecisionRecord | null> | null, unknown>;
     /** Whether this run is continuing a prior conversation with the same pair. */
     isContinuation: import("@langchain/langgraph").BaseChannel<boolean, boolean | import("@langchain/langgraph").OverwriteValue<boolean>, unknown>;
     opportunityId: import("@langchain/langgraph").BaseChannel<string, string | import("@langchain/langgraph").OverwriteValue<string>, unknown>;
@@ -291,7 +310,7 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
     timeoutMs: import("@langchain/langgraph").BaseChannel<number, number | import("@langchain/langgraph").OverwriteValue<number>, unknown>;
     currentSpeaker: import("@langchain/langgraph").BaseChannel<"source" | "candidate", "source" | "candidate" | import("@langchain/langgraph").OverwriteValue<"source" | "candidate">, unknown>;
     lastTurn: import("@langchain/langgraph").BaseChannel<{
-        action: "propose" | "accept" | "reject" | "counter" | "question";
+        action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline";
         assessment: {
             reasoning: string;
             suggestedRoles: {
@@ -301,7 +320,7 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
         };
         message?: string | null | undefined;
     } | null, {
-        action: "propose" | "accept" | "reject" | "counter" | "question";
+        action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline";
         assessment: {
             reasoning: string;
             suggestedRoles: {
@@ -311,7 +330,7 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
         };
         message?: string | null | undefined;
     } | import("@langchain/langgraph").OverwriteValue<{
-        action: "propose" | "accept" | "reject" | "counter" | "question";
+        action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline";
         assessment: {
             reasoning: string;
             suggestedRoles: {

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

@@ -1 +1 @@
-{"version":3,"file":"negotiation.state.d.ts","sourceRoot":"/","sources":["negotiation/negotiation.state.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAExF,kFAAkF;AAClF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUhC,CAAC;AAEH,wEAAwE;AACxE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUtC,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUrC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,mFAAmF;AACnF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,kDAAkD;AAClD,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvF,OAAO,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACtG;AAED,qDAAqD;AACrD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD;AAED,kEAAkE;AAClE,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,KAAK,EAAE;QACZ,UAAU,EAAE,sBAAsB,CAAC;QACnC,aAAa,EAAE,sBAAsB,CAAC;QACtC,YAAY,EAAE;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QACpD,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;QAC/C,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB;;;;;WAKG;QACH,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,GAAG,OAAO,CAAC;QACV,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAAC;QACnC,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAC;QAChC,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC,CAAC;CACJ;AAED,yDAAyD;AACzD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,4DAA4D;AAC5D,eAAO,MAAM,qBAAqB;;;;mBASM,MAAM;gBAAU,MAAM;;mBAAtB,MAAM;gBAAU,MAAM;;mBAAtB,MAAM;gBAAU,MAAM;;;IAS5D;;;;OAIG;;IAMH,mEAAmE;;IAKnE,8EAA8E;;;;;;;;IA6B9E;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAeH;;;;;OAKG;;IAMH,+EAA+E;;IAM/E,6EAA6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc7E,CAAC"}
+{"version":3,"file":"negotiation.state.d.ts","sourceRoot":"/","sources":["negotiation/negotiation.state.ts"],"names":[],"mappings":"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"}