@indexnetwork/protocol 21.0.0-rc.489.1 → 21.0.0-rc.490.1

package/dist/negotiations/negotiation.question-safety.js

@@ -36,6 +36,71 @@ export function isSafeNegotiationQuestionText(value, options) {
     }
     return true;
 }
+/**
+ * Instruction-shaped text that must never survive into a rendered question.
+ *
+ * Applies ONLY to `isSafeAuthoredNegotiationQuestion` — deliberately not added
+ * to `isSafeNegotiationQuestionText`, which guards a live path whose verdicts
+ * must not move. The exposure is specific to the authored question: the client
+ * reads these strings verbatim on a card, and whatever they select comes BACK
+ * into the negotiator's prompt as a user answer. An option labelled "ignore
+ * previous instructions" is therefore a round-trip injection with a human
+ * clicking the button.
+ *
+ * Two families. Override phrasings ("ignore the above", "you are now a…"), and
+ * forged structure: role headers and the `--- section ---` delimiter this
+ * codebase actually uses to fence prompt sections (see
+ * `renderNegotiatorClientDmSection`), which is what a forged block would have
+ * to imitate to be read as one.
+ */
+const PROMPT_INJECTION_PATTERN = /\b(?:ignore|disregard|forget|override|bypass)\b[^.!?\n]{0,40}\b(?:instructions?|prompts?|rules?|directives?|guidelines?|everything\s+above|the\s+above|all\s+of\s+the\s+above)\b|\byou\s+are\s+now\s+(?:an?|the)\b|\bnew\s+instructions?\s*:|^\s*(?:#{1,6}\s*|\*{2}\s*)?(?:system|assistant|developer|human)\s*:|<\|[^|>]{0,40}\|>|\[\/?(?:INST|SYS)\]|^\s*-{3,}[^\n]*-{3,}\s*$/im;
+/**
+ * Whole-question gate for a question the NEGOTIATOR authored.
+ *
+ * The pre-A2H `disclosureSubject` never reached the client as written — the
+ * server templated the copy around it. An authored `StructuredQuestion` is
+ * rendered verbatim, so every visible field needs the same gate the subject
+ * got, and it needs it with the identifiers in hand.
+ *
+ * That is the capability the api-side `isSafeNegotiationQuestionPayload` lacks
+ * and cannot gain: at the DB boundary it holds only generic patterns, so it
+ * cannot tell that a perfectly well-formed question is naming THIS counterparty
+ * or paraphrasing THIS seed assessment. The turn node has both, which is why
+ * this runs here and not there.
+ *
+ * Fail-closed and non-rewriting, like every guard in this file: a caller that
+ * gets `false` drops the question and keeps the enum-only path, rather than
+ * shipping a repaired one.
+ *
+ * @param options.forbiddenIdentifiers Names that must not appear as words —
+ *        the counterparty's, at the call site.
+ * @param options.forbiddenSourceText Private inputs that must not be echoed —
+ *        the seed assessment's reasoning, at the call site.
+ */
+export function isSafeAuthoredNegotiationQuestion(question, options) {
+    if (!question || typeof question !== 'object')
+        return false;
+    // Re-checked rather than trusted from the schema: this gate also runs on
+    // turns that arrive from an external agent, and a rendered card with one
+    // option (or fifteen) is a broken card regardless of how it validated.
+    const questionOptions = question.options;
+    if (!Array.isArray(questionOptions) || questionOptions.length < 2 || questionOptions.length > 4)
+        return false;
+    const fields = [
+        question.title,
+        question.prompt,
+        ...questionOptions.flatMap((option) => [option?.label, option?.description]),
+    ];
+    for (const field of fields) {
+        if (typeof field !== 'string')
+            return false;
+        if (!isSafeNegotiationQuestionText(field, options))
+            return false;
+        if (PROMPT_INJECTION_PATTERN.test(field))
+            return false;
+    }
+    return true;
+}
 /** Validate the only structured fields allowed to enter the inflight Questioner prompt. */
 export function validateInflightAskUserFields(input) {
     const disclosureSubject = input.disclosureSubject?.trim();

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

@@ -40,10 +40,75 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     /** Present when action is `ask_user` (v2, P3.2). */
     askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         reason: z.ZodEnum<["unresolved_owner_constraint", "consequential_disclosure_permission", "repeated_non_convergence", "insufficient_commitment_authority"]>;
+        question: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            title: z.ZodString;
+            prompt: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                description: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                label: string;
+                description: string;
+            }, {
+                label: string;
+                description: string;
+            }>, "many">;
+            multiSelect: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        }, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        }>>>, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | undefined, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | null | undefined>;
     }, "strict", z.ZodTypeAny, {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | undefined;
     }, {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | null | undefined;
     }>>>;
 }, "strip", z.ZodTypeAny, {
     action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -57,6 +122,15 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     message?: string | null | undefined;
     askUser?: {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | undefined;
     } | null | undefined;
 }, {
     action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -70,6 +144,15 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     message?: string | null | undefined;
     askUser?: {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | null | undefined;
     } | null | undefined;
 }>;
 /** Restricted v1 turn schema for the system agent (no question action). */
@@ -414,6 +497,15 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
         message?: string | null | undefined;
         askUser?: {
             reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+            question?: {
+                prompt: string;
+                options: {
+                    label: string;
+                    description: string;
+                }[];
+                title: string;
+                multiSelect: boolean;
+            } | undefined;
         } | null | undefined;
     } | null, {
         action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -427,6 +519,15 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
         message?: string | null | undefined;
         askUser?: {
             reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+            question?: {
+                prompt: string;
+                options: {
+                    label: string;
+                    description: string;
+                }[];
+                title: string;
+                multiSelect: boolean;
+            } | undefined;
         } | null | undefined;
     } | import("@langchain/langgraph").OverwriteValue<{
         action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -440,6 +541,15 @@ export declare const NegotiationGraphState: import("@langchain/langgraph").Annot
         message?: string | null | undefined;
         askUser?: {
             reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+            question?: {
+                prompt: string;
+                options: {
+                    label: string;
+                    description: string;
+                }[];
+                title: string;
+                multiSelect: boolean;
+            } | undefined;
         } | null | undefined;
     } | null> | null, unknown>;
     /**

package/dist/questions/question.schema.d.ts

@@ -7,29 +7,21 @@
  */
 import { z } from "zod";
 import { UnderspecificationTypeSchema, type UnderspecificationType } from "../shared/schemas/underspecification.schema.js";
+import { QuestionOptionSchema, StructuredQuestionSchema, type QuestionOption } from "../shared/schemas/structured-question.schema.js";
 export { UnderspecificationTypeSchema };
-export declare const QuestionOptionSchema: z.ZodObject<{
-    /** Display text. Suffix " (Recommended)" on the safest path; list it first. */
-    label: z.ZodString;
-    /** Explains the consequence of choosing this option, not just its definition. */
-    description: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    label: string;
-    description: string;
-}, {
-    label: string;
-    description: string;
-}>;
+/**
+ * The renderer-facing quartet (title/prompt/options/multiSelect) lives in
+ * `shared/schemas/structured-question.schema.ts` so the negotiator can author a
+ * question without `shared/` importing this capability. Re-exported here so
+ * `questions/question.schema.js` stays the import site every caller already uses.
+ */
+export { QuestionOptionSchema, StructuredQuestionSchema };
+export type { StructuredQuestion } from "../shared/schemas/structured-question.schema.js";
 export declare const QuestionSchema: z.ZodObject<{
-    /** ≤12 chars. Noun of the decision domain — e.g. "Stage", "Timing", "Role". */
     title: z.ZodString;
-    /** ≤2 sentences, ≤400 chars. Ends in a question mark. */
     prompt: z.ZodString;
-    /** 2–4 options. No explicit "Other" — clients provide that automatically. */
     options: z.ZodArray<z.ZodObject<{
-        /** Display text. Suffix " (Recommended)" on the safest path; list it first. */
         label: z.ZodString;
-        /** Explains the consequence of choosing this option, not just its definition. */
         description: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         label: string;
@@ -38,8 +30,8 @@ export declare const QuestionSchema: z.ZodObject<{
         label: string;
         description: string;
     }>, "many">;
-    /** True when options are not mutually exclusive (priorities, bundles). */
     multiSelect: z.ZodBoolean;
+} & {
     /**
      * Optional provenance line rendered as a muted chip above the prompt
      * (e.g. "based on 18 people matching this intent"). Aggregate counts only —
@@ -77,15 +69,10 @@ export declare const QuestionSchema: z.ZodObject<{
 }>;
 export declare const QuestionStrategySchema: z.ZodEnum<["refine_intent", "surface_missing_detail", "open_adjacent_thread", "reflective_summary", "surface_emergent_knowledge"]>;
 export declare const QuestionWithStrategySchema: z.ZodObject<{
-    /** ≤12 chars. Noun of the decision domain — e.g. "Stage", "Timing", "Role". */
     title: z.ZodString;
-    /** ≤2 sentences, ≤400 chars. Ends in a question mark. */
     prompt: z.ZodString;
-    /** 2–4 options. No explicit "Other" — clients provide that automatically. */
     options: z.ZodArray<z.ZodObject<{
-        /** Display text. Suffix " (Recommended)" on the safest path; list it first. */
         label: z.ZodString;
-        /** Explains the consequence of choosing this option, not just its definition. */
         description: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         label: string;
@@ -94,8 +81,8 @@ export declare const QuestionWithStrategySchema: z.ZodObject<{
         label: string;
         description: string;
     }>, "many">;
-    /** True when options are not mutually exclusive (priorities, bundles). */
     multiSelect: z.ZodBoolean;
+} & {
     /**
      * Optional provenance line rendered as a muted chip above the prompt
      * (e.g. "based on 18 people matching this intent"). Aggregate counts only —
@@ -141,15 +128,10 @@ export declare const QuestionWithStrategySchema: z.ZodObject<{
 }>;
 export declare const QuestionGeneratorResponseSchema: z.ZodObject<{
     questions: z.ZodArray<z.ZodObject<{
-        /** ≤12 chars. Noun of the decision domain — e.g. "Stage", "Timing", "Role". */
         title: z.ZodString;
-        /** ≤2 sentences, ≤400 chars. Ends in a question mark. */
         prompt: z.ZodString;
-        /** 2–4 options. No explicit "Other" — clients provide that automatically. */
         options: z.ZodArray<z.ZodObject<{
-            /** Display text. Suffix " (Recommended)" on the safest path; list it first. */
             label: z.ZodString;
-            /** Explains the consequence of choosing this option, not just its definition. */
             description: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             label: string;
@@ -158,8 +140,8 @@ export declare const QuestionGeneratorResponseSchema: z.ZodObject<{
             label: string;
             description: string;
         }>, "many">;
-        /** True when options are not mutually exclusive (priorities, bundles). */
         multiSelect: z.ZodBoolean;
+    } & {
         /**
          * Optional provenance line rendered as a muted chip above the prompt
          * (e.g. "based on 18 people matching this intent"). Aggregate counts only —
@@ -230,7 +212,7 @@ export declare const QuestionGeneratorResponseSchema: z.ZodObject<{
         evidence?: string | null | undefined;
     }[];
 }>;
-export type QuestionOption = z.infer<typeof QuestionOptionSchema>;
+export type { QuestionOption };
 export type Question = z.infer<typeof QuestionSchema>;
 export type { UnderspecificationType };
 export type QuestionStrategy = z.infer<typeof QuestionStrategySchema>;

package/dist/questions/question.schema.js

@@ -7,22 +7,16 @@
  */
 import { z } from "zod";
 import { UnderspecificationTypeSchema } from "../shared/schemas/underspecification.schema.js";
+import { QuestionOptionSchema, StructuredQuestionSchema } from "../shared/schemas/structured-question.schema.js";
 export { UnderspecificationTypeSchema };
-export const QuestionOptionSchema = z.object({
-    /** Display text. Suffix " (Recommended)" on the safest path; list it first. */
-    label: z.string().min(1).max(120),
-    /** Explains the consequence of choosing this option, not just its definition. */
-    description: z.string().min(1).max(280),
-});
-export const QuestionSchema = z.object({
-    /** ≤12 chars. Noun of the decision domain — e.g. "Stage", "Timing", "Role". */
-    title: z.string().min(1).max(12),
-    /** ≤2 sentences, ≤400 chars. Ends in a question mark. */
-    prompt: z.string().min(1).max(400),
-    /** 2–4 options. No explicit "Other" — clients provide that automatically. */
-    options: z.array(QuestionOptionSchema).min(2).max(4),
-    /** True when options are not mutually exclusive (priorities, bundles). */
-    multiSelect: z.boolean(),
+/**
+ * The renderer-facing quartet (title/prompt/options/multiSelect) lives in
+ * `shared/schemas/structured-question.schema.ts` so the negotiator can author a
+ * question without `shared/` importing this capability. Re-exported here so
+ * `questions/question.schema.js` stays the import site every caller already uses.
+ */
+export { QuestionOptionSchema, StructuredQuestionSchema };
+export const QuestionSchema = StructuredQuestionSchema.extend({
     /**
      * Optional provenance line rendered as a muted chip above the prompt
      * (e.g. "based on 18 people matching this intent"). Aggregate counts only —

package/dist/shared/schemas/negotiation-state.schema.d.ts

@@ -25,16 +25,99 @@ export declare const NEGOTIATION_CONSULTATION_REASONS: readonly ["unresolved_own
 export declare const NegotiationConsultationReasonSchema: z.ZodEnum<["unresolved_owner_constraint", "consequential_disclosure_permission", "repeated_non_convergence", "insufficient_commitment_authority"]>;
 export type NegotiationConsultationReason = z.infer<typeof NegotiationConsultationReasonSchema>;
 /**
- * Payload for a v2 `ask_user` action. Agents may choose only a closed reason;
- * disclosure subjects and question wording are always rendered by fixed
- * server templates and can never carry model-authored instructions.
+ * Payload for a v2 `ask_user` action.
+ *
+ * `reason` stays the closed enum it has always been: it is admission metadata
+ * for the deterministic consultation policy, not copy. `question` is the
+ * channel through which the user's own personal agent — the only thing that
+ * should be writing questions — hands over the question it authored from the
+ * negotiation it is actually having. Free-form keys beyond these two are still
+ * rejected by `.strict()`.
  */
 export declare const AskUserPayloadSchema: z.ZodObject<{
     reason: z.ZodEnum<["unresolved_owner_constraint", "consequential_disclosure_permission", "repeated_non_convergence", "insufficient_commitment_authority"]>;
+    /**
+     * The question the negotiating agent wrote, in the structured shape the UI
+     * already renders. Optional: v1 turns, external agents, and the existing
+     * enum-only path must all keep validating, so a payload of `{ reason }`
+     * alone stays byte-identical in and out.
+     *
+     * Declared `.nullable().optional()` (not bare `.optional()`) so the enclosing
+     * turn schemas survive OpenAI/OpenRouter strict structured-output conversion,
+     * which rejects optional-without-nullable fields — the same constraint
+     * documented on `QuestionSchema.evidence`. The `.transform()` normalizes an
+     * LLM-returned `null` back to `undefined`, so a null is never persisted and
+     * `null` and omitted read as absent identically downstream.
+     */
+    question: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        title: z.ZodString;
+        prompt: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            description: string;
+        }, {
+            label: string;
+            description: string;
+        }>, "many">;
+        multiSelect: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    }, {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    }>>>, {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    } | undefined, {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    } | null | undefined>;
 }, "strict", z.ZodTypeAny, {
     reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+    question?: {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    } | undefined;
 }, {
     reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+    question?: {
+        prompt: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        title: string;
+        multiSelect: boolean;
+    } | null | undefined;
 }>;
 export type AskUserPayload = z.infer<typeof AskUserPayloadSchema>;
 export declare const NegotiationTurnSchema: z.ZodObject<{
@@ -68,10 +151,88 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     /** Present when action is `ask_user` (v2, P3.2). */
     askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         reason: z.ZodEnum<["unresolved_owner_constraint", "consequential_disclosure_permission", "repeated_non_convergence", "insufficient_commitment_authority"]>;
+        /**
+         * The question the negotiating agent wrote, in the structured shape the UI
+         * already renders. Optional: v1 turns, external agents, and the existing
+         * enum-only path must all keep validating, so a payload of `{ reason }`
+         * alone stays byte-identical in and out.
+         *
+         * Declared `.nullable().optional()` (not bare `.optional()`) so the enclosing
+         * turn schemas survive OpenAI/OpenRouter strict structured-output conversion,
+         * which rejects optional-without-nullable fields — the same constraint
+         * documented on `QuestionSchema.evidence`. The `.transform()` normalizes an
+         * LLM-returned `null` back to `undefined`, so a null is never persisted and
+         * `null` and omitted read as absent identically downstream.
+         */
+        question: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            title: z.ZodString;
+            prompt: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                description: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                label: string;
+                description: string;
+            }, {
+                label: string;
+                description: string;
+            }>, "many">;
+            multiSelect: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        }, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        }>>>, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | undefined, {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | null | undefined>;
     }, "strict", z.ZodTypeAny, {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | undefined;
     }, {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | null | undefined;
     }>>>;
 }, "strip", z.ZodTypeAny, {
     action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -85,6 +246,15 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     message?: string | null | undefined;
     askUser?: {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | undefined;
     } | null | undefined;
 }, {
     action: "propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user";
@@ -98,6 +268,15 @@ export declare const NegotiationTurnSchema: z.ZodObject<{
     message?: string | null | undefined;
     askUser?: {
         reason: "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+        question?: {
+            prompt: string;
+            options: {
+                label: string;
+                description: string;
+            }[];
+            title: string;
+            multiSelect: boolean;
+        } | null | undefined;
     } | null | undefined;
 }>;
 export type NegotiationTurn = z.infer<typeof NegotiationTurnSchema>;

package/dist/shared/schemas/negotiation-state.schema.js

@@ -4,6 +4,7 @@
  * LangGraph Annotation.Root stays in the domain file.
  */
 import { z } from "zod";
+import { StructuredQuestionSchema } from "./structured-question.schema.js";
 // ─── Zod schemas (available for runtime validation) ───────────────────────────
 /**
  * Union of every negotiation turn action across protocol versions.
@@ -29,12 +30,31 @@ export const NEGOTIATION_CONSULTATION_REASONS = [
 ];
 export const NegotiationConsultationReasonSchema = z.enum(NEGOTIATION_CONSULTATION_REASONS);
 /**
- * Payload for a v2 `ask_user` action. Agents may choose only a closed reason;
- * disclosure subjects and question wording are always rendered by fixed
- * server templates and can never carry model-authored instructions.
+ * Payload for a v2 `ask_user` action.
+ *
+ * `reason` stays the closed enum it has always been: it is admission metadata
+ * for the deterministic consultation policy, not copy. `question` is the
+ * channel through which the user's own personal agent — the only thing that
+ * should be writing questions — hands over the question it authored from the
+ * negotiation it is actually having. Free-form keys beyond these two are still
+ * rejected by `.strict()`.
  */
 export const AskUserPayloadSchema = z.object({
     reason: NegotiationConsultationReasonSchema,
+    /**
+     * The question the negotiating agent wrote, in the structured shape the UI
+     * already renders. Optional: v1 turns, external agents, and the existing
+     * enum-only path must all keep validating, so a payload of `{ reason }`
+     * alone stays byte-identical in and out.
+     *
+     * Declared `.nullable().optional()` (not bare `.optional()`) so the enclosing
+     * turn schemas survive OpenAI/OpenRouter strict structured-output conversion,
+     * which rejects optional-without-nullable fields — the same constraint
+     * documented on `QuestionSchema.evidence`. The `.transform()` normalizes an
+     * LLM-returned `null` back to `undefined`, so a null is never persisted and
+     * `null` and omitted read as absent identically downstream.
+     */
+    question: StructuredQuestionSchema.nullable().optional().transform((value) => value ?? undefined),
 }).strict();
 export const NegotiationTurnSchema = z.object({
     action: z.enum(NEGOTIATION_ACTIONS),