@indexnetwork/protocol 6.12.1-rc.404.1 → 6.14.0-rc.406.1

package/dist/negotiation/domain/negotiation.memory.js

@@ -0,0 +1,83 @@
+/**
+ * Memory kinds a reflection pass may distill (P5.1 `negotiator_memories.kind`).
+ * Plain text at the DB level (55P04 lesson) — adding kinds is code-only.
+ *
+ * IND-550: moved here from negotiation.reflect.ts so the domain layer owns the
+ * vocabulary and the application-layer reflector can import it without a cycle.
+ */
+export const NEGOTIATOR_MEMORY_KINDS = [
+    "playbook",
+    "disclosure_rule",
+    "counterparty_dossier",
+    "threshold",
+];
+const KIND_LABELS = {
+    playbook: "playbook",
+    disclosure_rule: "disclosure rule",
+    counterparty_dossier: "counterparty note",
+    threshold: "threshold",
+};
+function confidenceSuffix(entry) {
+    return typeof entry.confidence === "number"
+        ? ` (confidence ${Math.round(entry.confidence * 100) / 100})`
+        : "";
+}
+/**
+ * Renders the private negotiator-memory section for counterparty-facing
+ * prompts (the negotiation turn agent and the screen gate).
+ *
+ * Disclosure rules are HARD constraints — never soft hints; everything else
+ * is advisory, weighted by confidence. The section leads with the leak
+ * guard: memory text must never reach counterparty-visible fields.
+ *
+ * @returns Empty string when there are no entries (byte-identical prompts).
+ */
+export function renderNegotiatorMemorySection(entries, opts) {
+    if (entries.length === 0)
+        return "";
+    const disclosureRules = entries.filter((e) => e.kind === "disclosure_rule");
+    const advisory = entries.filter((e) => e.kind !== "disclosure_rule");
+    const lines = [
+        "",
+        "",
+        "PRIVATE NEGOTIATOR MEMORY — for your reasoning only. Never quote, paraphrase, or reveal any of it to the counterparty, and never mention that these notes exist.",
+    ];
+    if (disclosureRules.length > 0) {
+        lines.push("HARD DISCLOSURE CONSTRAINTS (absolute — these override every other goal, including reaching a deal):");
+        for (const rule of disclosureRules) {
+            lines.push(`- ${rule.content}`);
+        }
+    }
+    if (advisory.length > 0) {
+        lines.push("Advisory notes from prior negotiations and client conversations (weigh by confidence; the live context wins on conflict):");
+        for (const entry of advisory) {
+            lines.push(`- [${KIND_LABELS[entry.kind]}] ${entry.content}${confidenceSuffix(entry)}`);
+        }
+    }
+    if (opts?.memoryHintsInstruction) {
+        lines.push("Set evidence.memoryHints to a short note on how these memories informed your decision — describe the influence, never copy sensitive contents verbatim.");
+    }
+    return lines.join("\n");
+}
+/**
+ * Renders the memory section for the negotiator CHAT persona — the audience
+ * is the client themself, so disclosure rules are their own standing
+ * instructions (context, not secrets), and the client's live word always
+ * outranks a stored note.
+ *
+ * @returns Empty string when there are no entries (byte-identical prompts).
+ */
+export function renderNegotiatorChatMemorySection(entries) {
+    if (entries.length === 0)
+        return "";
+    const lines = [
+        "",
+        "## Your negotiator memory",
+        "Notes you have accumulated from negotiations and prior conversations with your client (private to the two of you; weigh by confidence):",
+    ];
+    for (const entry of entries) {
+        lines.push(`- [${KIND_LABELS[entry.kind]}] ${entry.content}${confidenceSuffix(entry)}`);
+    }
+    lines.push("Use these to inform reports and recommendations. If the client contradicts one, trust the client — their current word always outranks a stored note.");
+    return lines.join("\n");
+}

package/dist/negotiation/domain/negotiation.protocol.d.ts

@@ -0,0 +1,536 @@
+/**
+ * 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";
+import type { NegotiationAction, NegotiationSeat, NegotiationProtocolVersion } from "../../shared/schemas/negotiation-state.schema.js";
+/** Initiator seat, non-final turn: may reach out, push back, ask, or walk away — never accept. */
+export declare const InitiatorTurnSchema: z.ZodObject<{
+    action: z.ZodEnum<["outreach", "counter", "question", "withdraw"]>;
+    assessment: z.ZodObject<{
+        reasoning: z.ZodString;
+        suggestedRoles: z.ZodObject<{
+            ownUser: z.ZodEnum<["agent", "patient", "peer"]>;
+            otherUser: z.ZodEnum<["agent", "patient", "peer"]>;
+        }, "strip", z.ZodTypeAny, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    /** Present when action is `ask_user` (v2, P3.2). */
+    askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        disclosureSubject: z.ZodString;
+        draftQuestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    action: "counter" | "question" | "outreach" | "withdraw";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}, {
+    action: "counter" | "question" | "outreach" | "withdraw";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}>;
+/** Counterparty seat, non-final turn: the only seat that can accept. */
+export declare const CounterpartyTurnSchema: z.ZodObject<{
+    action: z.ZodEnum<["accept", "decline", "counter", "question"]>;
+    assessment: z.ZodObject<{
+        reasoning: z.ZodString;
+        suggestedRoles: z.ZodObject<{
+            ownUser: z.ZodEnum<["agent", "patient", "peer"]>;
+            otherUser: z.ZodEnum<["agent", "patient", "peer"]>;
+        }, "strip", z.ZodTypeAny, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    /** Present when action is `ask_user` (v2, P3.2). */
+    askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        disclosureSubject: z.ZodString;
+        draftQuestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    action: "accept" | "counter" | "question" | "decline";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}, {
+    action: "accept" | "counter" | "question" | "decline";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}>;
+/** Initiator seat, final allowed turn: commit to walking away or leave the door open. */
+export declare const FinalInitiatorTurnSchema: z.ZodObject<{
+    action: z.ZodEnum<["withdraw", "counter"]>;
+    assessment: z.ZodObject<{
+        reasoning: z.ZodString;
+        suggestedRoles: z.ZodObject<{
+            ownUser: z.ZodEnum<["agent", "patient", "peer"]>;
+            otherUser: z.ZodEnum<["agent", "patient", "peer"]>;
+        }, "strip", z.ZodTypeAny, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    /** Present when action is `ask_user` (v2, P3.2). */
+    askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        disclosureSubject: z.ZodString;
+        draftQuestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    action: "counter" | "withdraw";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}, {
+    action: "counter" | "withdraw";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}>;
+/** Counterparty seat, final allowed turn: must decide. */
+export declare const FinalCounterpartyTurnSchema: z.ZodObject<{
+    action: z.ZodEnum<["accept", "decline"]>;
+    assessment: z.ZodObject<{
+        reasoning: z.ZodString;
+        suggestedRoles: z.ZodObject<{
+            ownUser: z.ZodEnum<["agent", "patient", "peer"]>;
+            otherUser: z.ZodEnum<["agent", "patient", "peer"]>;
+        }, "strip", z.ZodTypeAny, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    /** Present when action is `ask_user` (v2, P3.2). */
+    askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        disclosureSubject: z.ZodString;
+        draftQuestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    action: "accept" | "decline";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}, {
+    action: "accept" | "decline";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}>;
+/** Initiator seat, non-final turn, with the client-consult pause available. */
+export declare const InitiatorAskUserTurnSchema: z.ZodObject<{
+    action: z.ZodEnum<["outreach", "counter", "question", "withdraw", "ask_user"]>;
+    assessment: z.ZodObject<{
+        reasoning: z.ZodString;
+        suggestedRoles: z.ZodObject<{
+            ownUser: z.ZodEnum<["agent", "patient", "peer"]>;
+            otherUser: z.ZodEnum<["agent", "patient", "peer"]>;
+        }, "strip", z.ZodTypeAny, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    /** Present when action is `ask_user` (v2, P3.2). */
+    askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        disclosureSubject: z.ZodString;
+        draftQuestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    action: "counter" | "question" | "outreach" | "withdraw" | "ask_user";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}, {
+    action: "counter" | "question" | "outreach" | "withdraw" | "ask_user";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}>;
+/** Counterparty seat, non-final turn, with the client-consult pause available. */
+export declare const CounterpartyAskUserTurnSchema: z.ZodObject<{
+    action: z.ZodEnum<["accept", "decline", "counter", "question", "ask_user"]>;
+    assessment: z.ZodObject<{
+        reasoning: z.ZodString;
+        suggestedRoles: z.ZodObject<{
+            ownUser: z.ZodEnum<["agent", "patient", "peer"]>;
+            otherUser: z.ZodEnum<["agent", "patient", "peer"]>;
+        }, "strip", z.ZodTypeAny, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }, {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }, {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    }>;
+    message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    /** Present when action is `ask_user` (v2, P3.2). */
+    askUser: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        disclosureSubject: z.ZodString;
+        draftQuestion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }, {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    action: "accept" | "counter" | "question" | "decline" | "ask_user";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}, {
+    action: "accept" | "counter" | "question" | "decline" | "ask_user";
+    assessment: {
+        reasoning: string;
+        suggestedRoles: {
+            ownUser: "agent" | "patient" | "peer";
+            otherUser: "agent" | "patient" | "peer";
+        };
+    };
+    message?: string | null | undefined;
+    askUser?: {
+        disclosureSubject: string;
+        draftQuestion?: string | null | undefined;
+    } | null | undefined;
+}>;
+/**
+ * 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 declare function allowedActionsFor(version: NegotiationProtocolVersion, seat: NegotiationSeat, isFinalTurn?: boolean, opts?: AskUserOpts): readonly NegotiationAction[];
+/**
+ * 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 declare function turnSchemaFor(version: NegotiationProtocolVersion, seat: NegotiationSeat, isFinalTurn: boolean, v1Schemas: {
+    system: z.ZodTypeAny;
+    final: z.ZodTypeAny;
+}, opts?: AskUserOpts): z.ZodTypeAny;
+/**
+ * Opt-in extension of the seat vocabulary with the `ask_user` client-consult
+ * pause (P3.2). Never granted on final-cap turns (the final turn must decide)
+ * and never under v1. Callers pass `{ askUser: true }` only when the full
+ * pause loop is available on their surface: the ask-user feature flag is on,
+ * a questioner enqueue and an answer-window timer are wired, the negotiation
+ * has an opportunity to resume against, and the acting side has not already
+ * consumed its one client question for this negotiation (rationing).
+ */
+export interface AskUserOpts {
+    askUser?: boolean;
+}
+/** Terminal actions end the negotiation immediately. */
+export declare function isTerminalAction(action: string | undefined | null): boolean;
+/** Reject-like actions map the opportunity to `rejected` (v1 reject, v2 withdraw/decline). */
+export declare function isRejectLikeAction(action: string | undefined | null): boolean;
+/**
+ * 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 declare function fallbackActionFor(version: NegotiationProtocolVersion, seat: NegotiationSeat, isFinalTurn: boolean): NegotiationAction;
+/** Seat-appropriate reject-like action for error paths. */
+export declare function rejectActionFor(version: NegotiationProtocolVersion, seat: NegotiationSeat): NegotiationAction;
+/**
+ * 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 declare function readProtocolVersion(metadata: {
+    protocolVersion?: unknown;
+} | null | undefined): NegotiationProtocolVersion | null;
+/**
+ * Protocol version for negotiations without a prior task for the same
+ * opportunity, 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 (only in-flight negotiations stay pinned to their
+ * stamped version).
+ */
+export declare function configuredProtocolVersion(): NegotiationProtocolVersion;
+/**
+ * Whether the `ask_user` client-consult pause (P3.2) is enabled, from the
+ * `NEGOTIATION_ASK_USER_ENABLED` env switch. Defaults to off — the deployment
+ * is byte-for-byte unchanged until the flag is flipped, and rolling back is
+ * the same single switch.
+ */
+export declare function configuredAskUserEnabled(): boolean;
+/** Default answer window for a paused `ask_user` negotiation: 24 hours. */
+export declare const DEFAULT_ASK_USER_WINDOW_MS: number;
+/**
+ * Answer window for a paused `ask_user` negotiation, in ms. Overridable via
+ * `NEGOTIATION_ASK_USER_WINDOW_MS` (dev/e2e use shorter windows to exercise
+ * the expiry path); invalid or non-positive values fall back to 24 h.
+ */
+export declare function askUserAnswerWindowMs(): number;
+/**
+ * Slack added on top of the answer window when deciding whether a paused
+ * (`input_required`) task still holds the conversation lock. Covers expiry
+ * worker delay: the lock must outlive the timer slightly, so ambient
+ * rediscovery cannot slip in between window expiry and the worker's resume.
+ */
+export declare const ASK_USER_LOCK_SLACK_MS: number;
+/**
+ * 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 declare function resolveSeat(userId: string, metadata: {
+    initiatorUserId?: unknown;
+    sourceUserId?: unknown;
+} | null | undefined): NegotiationSeat;
+/** Human-readable seat-violation message shared by respond surfaces. */
+export declare function seatViolationMessage(action: string, seat: NegotiationSeat, version: NegotiationProtocolVersion): string;