@indexnetwork/protocol 6.12.0-rc.403.1 → 6.13.22-rc.405.1

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

@@ -0,0 +1,48 @@
+/**
+ * negotiation/domain — pure negotiation types, protocol rules, and deterministic
+ * policy functions.
+ *
+ * ## What lives here
+ *
+ * - NegotiationGraphState and all graph state types (negotiation.state.ts)
+ * - Seat-scoped protocol rules and action vocabulary (negotiation.protocol.ts)
+ * - Screen-gate pure contracts: mode, decision record, block predicate (negotiation.screen.contracts.ts)
+ * - Deadlock detection + bargaining prompt section (negotiation.deadlock.ts)
+ * - Lifecycle narration mapper (negotiation.lifecycle-narration.ts)
+ * - Task conversation-lock predicate (negotiation.task-lock-policy.ts)
+ * - Immutable intent-snapshot provenance builder (negotiation.intent-snapshot-provenance.ts)
+ * - IND-508 consultation policy: eligibility funnel + prompt pairs (negotiation.consultation-policy.ts)
+ * - Privacy-gate for question text (negotiation.question-safety.ts)
+ * - Memory vocabulary, renderer, retrieve-fn type (negotiation.memory.ts)
+ *
+ * ## What does NOT live here
+ *
+ * - NegotiationScreener (LLM agent) → negotiation/application
+ * - NegotiationGraphFactory, negotiateCandidates (LangGraph) → negotiation/application
+ * - IndexNegotiator (LLM structured model) → negotiation/application
+ * - NegotiationReflector (LLM memory write) → negotiation/application
+ * - NegotiationSummarizer (LLM digest) → negotiation/application
+ * - NegotiationInsightsGenerator (LLM narrative) → negotiation/application
+ * - createNegotiationTools (MCP tool factory) → negotiation/application
+ * - NegotiationToolDeps (host port) → negotiation/ports
+ *
+ * IND-550: canonical domain layer for the negotiation capability.
+ */
+export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "./negotiation.screen.contracts.js";
+export type { NegotiationScreenMode, ScreenDecision, ScreenDecisionRecord, } from "./negotiation.screen.contracts.js";
+export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "./negotiation.state.js";
+export type { NegotiationTurn, NegotiationOutcome, UserNegotiationContext, SeedAssessment, NegotiationGraphLike, NegotiationMessage, } from "./negotiation.state.js";
+export { InitiatorTurnSchema, CounterpartyTurnSchema, FinalInitiatorTurnSchema, FinalCounterpartyTurnSchema, InitiatorAskUserTurnSchema, CounterpartyAskUserTurnSchema, allowedActionsFor, turnSchemaFor, isTerminalAction, isRejectLikeAction, fallbackActionFor, rejectActionFor, readProtocolVersion, configuredProtocolVersion, configuredAskUserEnabled, askUserAnswerWindowMs, ASK_USER_LOCK_SLACK_MS, DEFAULT_ASK_USER_WINDOW_MS, resolveSeat, seatViolationMessage, } from "./negotiation.protocol.js";
+export { configuredDeadlockShiftEnabled, configuredDeadlockThreshold, assessDeadlock, renderBargainingShiftSection, DEFAULT_DEADLOCK_THRESHOLD, MIN_DEADLOCK_THRESHOLD, } from "./negotiation.deadlock.js";
+export type { DeadlockAssessment } from "./negotiation.deadlock.js";
+export type { DeadlockShiftRecord } from "./negotiation.deadlock.contracts.js";
+export { buildLifecycleNarration } from "./negotiation.lifecycle-narration.js";
+export type { NegotiationLifecycleNarration } from "./negotiation.lifecycle-narration.js";
+export { holdsNegotiationConversationLock } from "./negotiation.task-lock-policy.js";
+export { buildIntentSnapshots } from "./negotiation.intent-snapshot-provenance.js";
+export type { IntentSnapshot } from "./negotiation.intent-snapshot-provenance.js";
+export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "./negotiation.consultation-policy.js";
+export type { NegotiationConsultationPolicyMode, NegotiationConsultationReason, ConsultationEligibility, ConsultationEligibilityInput, } from "./negotiation.consultation-policy.js";
+export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeNegotiationQuestionText, validateInflightAskUserFields, negotiationQuestionSettlementId, } from "./negotiation.question-safety.js";
+export { NEGOTIATOR_MEMORY_KINDS, renderNegotiatorMemorySection, renderNegotiatorChatMemorySection, } from "./negotiation.memory.js";
+export type { DistilledMemoryKind, NegotiatorMemoryEntry, NegotiatorMemoryScope, NegotiatorMemoryRetrieveFn, NegotiatorMemoryQuery, } from "./negotiation.memory.js";

package/dist/negotiation/domain/index.js

@@ -0,0 +1,50 @@
+/**
+ * negotiation/domain — pure negotiation types, protocol rules, and deterministic
+ * policy functions.
+ *
+ * ## What lives here
+ *
+ * - NegotiationGraphState and all graph state types (negotiation.state.ts)
+ * - Seat-scoped protocol rules and action vocabulary (negotiation.protocol.ts)
+ * - Screen-gate pure contracts: mode, decision record, block predicate (negotiation.screen.contracts.ts)
+ * - Deadlock detection + bargaining prompt section (negotiation.deadlock.ts)
+ * - Lifecycle narration mapper (negotiation.lifecycle-narration.ts)
+ * - Task conversation-lock predicate (negotiation.task-lock-policy.ts)
+ * - Immutable intent-snapshot provenance builder (negotiation.intent-snapshot-provenance.ts)
+ * - IND-508 consultation policy: eligibility funnel + prompt pairs (negotiation.consultation-policy.ts)
+ * - Privacy-gate for question text (negotiation.question-safety.ts)
+ * - Memory vocabulary, renderer, retrieve-fn type (negotiation.memory.ts)
+ *
+ * ## What does NOT live here
+ *
+ * - NegotiationScreener (LLM agent) → negotiation/application
+ * - NegotiationGraphFactory, negotiateCandidates (LangGraph) → negotiation/application
+ * - IndexNegotiator (LLM structured model) → negotiation/application
+ * - NegotiationReflector (LLM memory write) → negotiation/application
+ * - NegotiationSummarizer (LLM digest) → negotiation/application
+ * - NegotiationInsightsGenerator (LLM narrative) → negotiation/application
+ * - createNegotiationTools (MCP tool factory) → negotiation/application
+ * - NegotiationToolDeps (host port) → negotiation/ports
+ *
+ * IND-550: canonical domain layer for the negotiation capability.
+ */
+// ── Screen contracts ──────────────────────────────────────────────────────────
+export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "./negotiation.screen.contracts.js";
+// ── Graph state and DTOs ──────────────────────────────────────────────────────
+export { NegotiationTurnSchema, SystemNegotiationTurnSchema, FinalNegotiationTurnSchema, NegotiationOutcomeSchema, NegotiationGraphState, } from "./negotiation.state.js";
+// ── Protocol rules ────────────────────────────────────────────────────────────
+export { InitiatorTurnSchema, CounterpartyTurnSchema, FinalInitiatorTurnSchema, FinalCounterpartyTurnSchema, InitiatorAskUserTurnSchema, CounterpartyAskUserTurnSchema, allowedActionsFor, turnSchemaFor, isTerminalAction, isRejectLikeAction, fallbackActionFor, rejectActionFor, readProtocolVersion, configuredProtocolVersion, configuredAskUserEnabled, askUserAnswerWindowMs, ASK_USER_LOCK_SLACK_MS, DEFAULT_ASK_USER_WINDOW_MS, resolveSeat, seatViolationMessage, } from "./negotiation.protocol.js";
+// ── Deadlock detection ────────────────────────────────────────────────────────
+export { configuredDeadlockShiftEnabled, configuredDeadlockThreshold, assessDeadlock, renderBargainingShiftSection, DEFAULT_DEADLOCK_THRESHOLD, MIN_DEADLOCK_THRESHOLD, } from "./negotiation.deadlock.js";
+// ── Lifecycle narration ───────────────────────────────────────────────────────
+export { buildLifecycleNarration } from "./negotiation.lifecycle-narration.js";
+// ── Task lock policy ──────────────────────────────────────────────────────────
+export { holdsNegotiationConversationLock } from "./negotiation.task-lock-policy.js";
+// ── Intent snapshot provenance ────────────────────────────────────────────────
+export { buildIntentSnapshots } from "./negotiation.intent-snapshot-provenance.js";
+// ── Consultation policy ───────────────────────────────────────────────────────
+export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "./negotiation.consultation-policy.js";
+// ── Question safety ───────────────────────────────────────────────────────────
+export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeNegotiationQuestionText, validateInflightAskUserFields, negotiationQuestionSettlementId, } from "./negotiation.question-safety.js";
+// ── Memory vocabulary and renderers ──────────────────────────────────────────
+export { NEGOTIATOR_MEMORY_KINDS, renderNegotiatorMemorySection, renderNegotiatorChatMemorySection, } from "./negotiation.memory.js";

package/dist/negotiation/domain/negotiation.consultation-policy.d.ts

@@ -0,0 +1,39 @@
+import type { NegotiationAction, NegotiationProtocolVersion, NegotiationSeat } from "../../shared/schemas/negotiation-state.schema.js";
+/** Independent rollout modes for IND-508's deterministic consultation policy. */
+export type NegotiationConsultationPolicyMode = "off" | "shadow" | "on";
+/** Stable, content-free categories emitted by the consultation funnel. */
+export type NegotiationConsultationReason = "unresolved_owner_constraint" | "consequential_disclosure_permission" | "repeated_non_convergence" | "insufficient_commitment_authority";
+/** The only data the policy may inspect: action/role enums and routing coordinates. */
+export interface ConsultationEligibilityInput {
+    protocolVersion: NegotiationProtocolVersion;
+    seat: NegotiationSeat;
+    isOpeningTurn: boolean;
+    isFinalTurn: boolean;
+    screenedOut: boolean;
+    action: NegotiationAction;
+    ownSuggestedRole: "agent" | "patient" | "peer" | undefined;
+    priorActions: readonly NegotiationAction[];
+    previouslyConsulted: boolean;
+    hasExactResumeCoordinate: boolean;
+    lifecycleValid: boolean;
+}
+export interface ConsultationEligibility {
+    eligible: boolean;
+    reason?: NegotiationConsultationReason;
+}
+/**
+ * Read the centralized consultation-policy switch. Invalid, absent, and empty
+ * values deliberately roll back to off.
+ */
+export declare function negotiationConsultationPolicyMode(): NegotiationConsultationPolicyMode;
+/**
+ * Pure IND-508 eligibility policy. It intentionally never sees user text,
+ * evaluator output, profiles, IDs, prompts, or messages; only safe protocol
+ * enums and the exact binding/lifecycle booleans supplied by the graph.
+ */
+export declare function assessConsultationEligibility(input: ConsultationEligibilityInput): ConsultationEligibility;
+/** Fixed source-safe inputs that still traverse the existing questioner guard. */
+export declare function consultationPromptFor(reason: NegotiationConsultationReason): {
+    disclosureSubject: string;
+    draftQuestion: string;
+};

package/dist/negotiation/domain/negotiation.consultation-policy.js

@@ -0,0 +1,68 @@
+/**
+ * Read the centralized consultation-policy switch. Invalid, absent, and empty
+ * values deliberately roll back to off.
+ */
+export function negotiationConsultationPolicyMode() {
+    const raw = process.env.NEGOTIATION_CONSULTATION_POLICY_MODE;
+    return raw === "shadow" || raw === "on" ? raw : "off";
+}
+/**
+ * Pure IND-508 eligibility policy. It intentionally never sees user text,
+ * evaluator output, profiles, IDs, prompts, or messages; only safe protocol
+ * enums and the exact binding/lifecycle booleans supplied by the graph.
+ */
+export function assessConsultationEligibility(input) {
+    if (input.protocolVersion !== "v2"
+        || input.isOpeningTurn
+        || input.isFinalTurn
+        || input.screenedOut
+        || input.previouslyConsulted
+        || !input.hasExactResumeCoordinate
+        || !input.lifecycleValid
+        || isObviousTerminal(input.action))
+        return { eligible: false };
+    // A patient-side counter is a schema-constrained, source-safe signal that
+    // the owner must decide whether a consequential disclosure or permission is
+    // acceptable. This is reachable under the normal v2 action vocabulary; it
+    // deliberately does not inspect or depend on a model-produced `ask_user`.
+    if (input.ownSuggestedRole === "patient" && input.action === "counter") {
+        return { eligible: true, reason: "consequential_disclosure_permission" };
+    }
+    // Preserve observability for a valid legacy ask_user draft; production
+    // policy admission no longer depends on this action because the patient-side
+    // counter rule above is schema-constrained and independently reachable.
+    if (input.action === "ask_user") {
+        return { eligible: true, reason: "consequential_disclosure_permission" };
+    }
+    // A repeated run of safe counter/question action enums means the parties are
+    // not converging. This precedes action-local rules so the policy is stable.
+    const trailingActions = [...input.priorActions, input.action].slice(-3);
+    const trailingNonConvergent = trailingActions.length === 3
+        && trailingActions.every((action) => action === "counter" || action === "question");
+    if (trailingNonConvergent) {
+        return { eligible: true, reason: "repeated_non_convergence" };
+    }
+    if (input.ownSuggestedRole === "agent" && input.action === "counter") {
+        return { eligible: true, reason: "insufficient_commitment_authority" };
+    }
+    if (input.action === "question") {
+        return { eligible: true, reason: "unresolved_owner_constraint" };
+    }
+    return { eligible: false };
+}
+/** Fixed source-safe inputs that still traverse the existing questioner guard. */
+export function consultationPromptFor(reason) {
+    switch (reason) {
+        case "consequential_disclosure_permission":
+            return { disclosureSubject: "your permission", draftQuestion: "May we share the information needed to explore this collaboration?" };
+        case "repeated_non_convergence":
+            return { disclosureSubject: "your priorities", draftQuestion: "Which trade-off matters most as we decide how to proceed?" };
+        case "insufficient_commitment_authority":
+            return { disclosureSubject: "your decision authority", draftQuestion: "What commitments may we make on your behalf?" };
+        case "unresolved_owner_constraint":
+            return { disclosureSubject: "your preferences", draftQuestion: "What outcome would you prefer?" };
+    }
+}
+function isObviousTerminal(action) {
+    return action === "accept" || action === "reject" || action === "withdraw" || action === "decline";
+}

package/dist/negotiation/domain/negotiation.deadlock.contracts.d.ts

@@ -0,0 +1,10 @@
+/** Internal-only metadata persisted when a deadlock causes a stance shift. */
+export interface DeadlockShiftRecord {
+    reason: "consecutive_non_convergent";
+    consecutiveNonConvergent: number;
+    threshold: number;
+    /** Zero-based session turn index at which the shifted draft happened. */
+    shiftedAtTurn: number;
+    seat: "initiator" | "counterparty";
+    detectedAt: string;
+}

package/dist/negotiation/domain/negotiation.deadlock.contracts.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,81 @@
+/**
+ * Deadlock detection + persuasion→bargaining mode shift (IND-428, backlog item 6).
+ *
+ * Grounding: Wells & Reed (2006), *Knowing When to Bargain* — a persuasion
+ * dialogue (arguing the merits) that reaches a stalemate may execute a *legal
+ * shift* into a negotiation dialogue (offering concessions). See
+ * `docs/design/negotiation-dialogue-game.md` for the formal framing of the
+ * turn protocol as a dialogue game.
+ *
+ * Design constraints (hard):
+ * - **Deterministic**: deadlock is decided by pure inspection of the persisted
+ *   turn history — never by an LLM.
+ * - **Stance, not rules**: a detected deadlock changes the system agent's
+ *   *drafting stance* only. Locutions, seat vocabularies (`allowedActionsFor`),
+ *   termination, and turn-cap semantics are untouched.
+ * - **Default-off**: gated on `NEGOTIATION_DEADLOCK_SHIFT_ENABLED === "true"`
+ *   (strict literal) and applied only to v2 negotiations, checked alongside the
+ *   protocol-version plumbing. When off, the legacy path is byte-identical.
+ * - **Fail-open**: any detection error means "no deadlock" — advisory
+ *   infrastructure never blocks a negotiation.
+ */
+export type { DeadlockShiftRecord } from "./negotiation.deadlock.contracts.js";
+/**
+ * Whether the deadlock→bargaining mode shift is enabled, from the
+ * `NEGOTIATION_DEADLOCK_SHIFT_ENABLED` env switch. Strict literal `"true"`
+ * only — the deployment is byte-for-byte unchanged until the flag is flipped,
+ * and rolling back is the same single switch.
+ */
+export declare function configuredDeadlockShiftEnabled(): boolean;
+/**
+ * Default deadlock threshold: 4 consecutive non-convergent turns. Sized
+ * against the ambient turn cap (6): an outreach plus 4 unbroken counters
+ * leaves exactly the closing turns to draft in the bargaining stance.
+ */
+export declare const DEFAULT_DEADLOCK_THRESHOLD = 4;
+/**
+ * Lower bound on the configurable threshold. Below 2 the "stalemate" signal is
+ * meaningless — a single counter is ordinary dialogue, not a deadlock.
+ */
+export declare const MIN_DEADLOCK_THRESHOLD = 2;
+/**
+ * Consecutive non-convergent turns that constitute a deadlock, from
+ * `NEGOTIATION_DEADLOCK_THRESHOLD`. Must be an integer >= 2; invalid,
+ * non-integer, or out-of-range values fall back to the default (fail-open
+ * toward the documented behavior, mirroring `askUserAnswerWindowMs`).
+ */
+export declare function configuredDeadlockThreshold(): number;
+export interface DeadlockAssessment {
+    /** True when the trailing non-convergent run has reached the threshold. */
+    deadlocked: boolean;
+    /** Length of the maximal trailing run of counter/question turns. */
+    consecutiveNonConvergent: number;
+    /** The threshold the run was compared against. */
+    threshold: number;
+}
+/**
+ * Deterministic stalemate detector: measures the maximal *trailing* run of
+ * non-convergent turns (`counter`/`question`) in the persisted history and
+ * compares it against the threshold. Continuation histories are included by
+ * construction — the caller passes the full turn list, so a deadlock spanning
+ * sessions still counts.
+ *
+ * Pure state inspection; no LLM, no I/O, no clock.
+ */
+export declare function assessDeadlock(history: ReadonlyArray<{
+    action?: string;
+}>, threshold?: number): DeadlockAssessment;
+/**
+ * Renders the bargaining-stance prompt section. Returns the empty string when
+ * the shift is not active, so the rendered system prompt is byte-identical to
+ * the legacy build on every non-shifted turn (mirrors
+ * `renderNegotiatorMemorySection`). The `ask_user` escalation line renders
+ * only when the caller already legally holds the action (`canAskUser`) — the
+ * shift never invents a locution.
+ */
+export declare function renderBargainingShiftSection(input: {
+    active: boolean;
+    userName: string;
+    canAskUser: boolean;
+    consecutiveNonConvergent: number;
+}): string;

package/dist/negotiation/domain/negotiation.deadlock.js

@@ -0,0 +1,103 @@
+// ─── Configuration ───────────────────────────────────────────────────────────
+/**
+ * Whether the deadlock→bargaining mode shift is enabled, from the
+ * `NEGOTIATION_DEADLOCK_SHIFT_ENABLED` env switch. Strict literal `"true"`
+ * only — the deployment is byte-for-byte unchanged until the flag is flipped,
+ * and rolling back is the same single switch.
+ */
+export function configuredDeadlockShiftEnabled() {
+    return process.env.NEGOTIATION_DEADLOCK_SHIFT_ENABLED === "true";
+}
+/**
+ * Default deadlock threshold: 4 consecutive non-convergent turns. Sized
+ * against the ambient turn cap (6): an outreach plus 4 unbroken counters
+ * leaves exactly the closing turns to draft in the bargaining stance.
+ */
+export const DEFAULT_DEADLOCK_THRESHOLD = 4;
+/**
+ * Lower bound on the configurable threshold. Below 2 the "stalemate" signal is
+ * meaningless — a single counter is ordinary dialogue, not a deadlock.
+ */
+export const MIN_DEADLOCK_THRESHOLD = 2;
+/**
+ * Consecutive non-convergent turns that constitute a deadlock, from
+ * `NEGOTIATION_DEADLOCK_THRESHOLD`. Must be an integer >= 2; invalid,
+ * non-integer, or out-of-range values fall back to the default (fail-open
+ * toward the documented behavior, mirroring `askUserAnswerWindowMs`).
+ */
+export function configuredDeadlockThreshold() {
+    const raw = process.env.NEGOTIATION_DEADLOCK_THRESHOLD;
+    if (raw) {
+        const parsed = Number(raw);
+        if (Number.isInteger(parsed) && parsed >= MIN_DEADLOCK_THRESHOLD)
+            return parsed;
+    }
+    return DEFAULT_DEADLOCK_THRESHOLD;
+}
+// ─── Detection ───────────────────────────────────────────────────────────────
+/**
+ * The locutions that count toward a stalemate: challenges and information
+ * requests that keep the dialogue open without converging. Everything else —
+ * openings (`propose`/`outreach`: a fresh case is on the table), terminal
+ * actions (the game is deciding, not stalling), and `ask_user` (new principal
+ * input is about to arrive) — RESETS the run to zero. Unknown/missing actions
+ * also reset (conservative: never manufacture a deadlock from unreadable data).
+ */
+const NON_CONVERGENT_ACTIONS = new Set(["counter", "question"]);
+/**
+ * Deterministic stalemate detector: measures the maximal *trailing* run of
+ * non-convergent turns (`counter`/`question`) in the persisted history and
+ * compares it against the threshold. Continuation histories are included by
+ * construction — the caller passes the full turn list, so a deadlock spanning
+ * sessions still counts.
+ *
+ * Pure state inspection; no LLM, no I/O, no clock.
+ */
+export function assessDeadlock(history, threshold = DEFAULT_DEADLOCK_THRESHOLD) {
+    const effectiveThreshold = Number.isInteger(threshold) && threshold >= MIN_DEADLOCK_THRESHOLD
+        ? threshold
+        : DEFAULT_DEADLOCK_THRESHOLD;
+    let run = 0;
+    for (let i = history.length - 1; i >= 0; i--) {
+        const action = history[i]?.action;
+        if (typeof action === "string" && NON_CONVERGENT_ACTIONS.has(action)) {
+            run += 1;
+        }
+        else {
+            break;
+        }
+    }
+    return {
+        deadlocked: run >= effectiveThreshold,
+        consecutiveNonConvergent: run,
+        threshold: effectiveThreshold,
+    };
+}
+// ─── Internal shift record (task metadata JSONB, never public) ──────────────
+// ─── Prompt section (system agent drafting stance) ──────────────────────────
+const BARGAINING_SHIFT_SECTION = `
+
+DEADLOCK — SHIFT FROM PERSUASION TO BARGAINING. The last {consecutive} turns were counters/questions without convergence: the merits have been argued and restating them will not move the other side. For this turn, change stance:
+- Do NOT re-argue fit or repeat points already made.
+- Offer a concrete concession or scope reduction instead: a smaller first step (a single intro call, a scoped trial, a narrower version of the collaboration), dropping a contested requirement, or a trade on a dimension not yet contested.
+- Make the remaining objection priceable: name the specific smaller commitment that would resolve it.{askUserEscalation}
+- If no reduced scope would genuinely serve {userName}'s interests, conclude decisively with a terminal action from your allowed set rather than another repetitive counter.
+This shift changes your stance only — your available actions are unchanged.`;
+const BARGAINING_ASK_USER_ESCALATION = `
+- If a concession would require {userName}'s own input or permission (budget, availability, private details), escalate with "ask_user" instead of guessing.`;
+/**
+ * Renders the bargaining-stance prompt section. Returns the empty string when
+ * the shift is not active, so the rendered system prompt is byte-identical to
+ * the legacy build on every non-shifted turn (mirrors
+ * `renderNegotiatorMemorySection`). The `ask_user` escalation line renders
+ * only when the caller already legally holds the action (`canAskUser`) — the
+ * shift never invents a locution.
+ */
+export function renderBargainingShiftSection(input) {
+    if (!input.active)
+        return "";
+    return BARGAINING_SHIFT_SECTION
+        .replace("{consecutive}", String(input.consecutiveNonConvergent))
+        .replace("{askUserEscalation}", input.canAskUser ? BARGAINING_ASK_USER_ESCALATION : "")
+        .replace(/{userName}/g, input.userName);
+}

package/dist/negotiation/domain/negotiation.intent-snapshot-provenance.d.ts

@@ -0,0 +1,21 @@
+export interface IntentSnapshot {
+    userId: string;
+    intentId: string;
+    title: string;
+    description: string;
+}
+type IntentSnapshotSource = {
+    id?: unknown;
+    intents?: Array<{
+        id?: unknown;
+        title?: unknown;
+        description?: unknown;
+    } | null | undefined>;
+};
+/**
+ * Captures immutable, internal-only intent provenance at negotiation task
+ * creation. Invalid records are excluded and each participant/intent pair is
+ * kept once, so later mutable user context cannot rewrite task history.
+ */
+export declare function buildIntentSnapshots(sourceUser: IntentSnapshotSource, candidateUser: IntentSnapshotSource): IntentSnapshot[];
+export {};

package/dist/negotiation/domain/negotiation.intent-snapshot-provenance.js

@@ -0,0 +1,28 @@
+/**
+ * Captures immutable, internal-only intent provenance at negotiation task
+ * creation. Invalid records are excluded and each participant/intent pair is
+ * kept once, so later mutable user context cannot rewrite task history.
+ */
+export function buildIntentSnapshots(sourceUser, candidateUser) {
+    const snapshots = [];
+    const seen = new Set();
+    for (const user of [sourceUser, candidateUser]) {
+        if (typeof user.id !== "string" || user.id.trim().length === 0)
+            continue;
+        for (const intent of Array.isArray(user.intents) ? user.intents : []) {
+            if (typeof intent?.id !== "string" || intent.id.trim().length === 0)
+                continue;
+            const key = `${user.id}\u0000${intent.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            snapshots.push({
+                userId: user.id,
+                intentId: intent.id,
+                title: typeof intent.title === "string" ? intent.title : "",
+                description: typeof intent.description === "string" ? intent.description : "",
+            });
+        }
+    }
+    return snapshots;
+}

package/dist/negotiation/domain/negotiation.lifecycle-narration.d.ts

@@ -0,0 +1,18 @@
+import type { NegotiationOpportunityLifecycle, OpportunityStatus } from '../../shared/interfaces/database.interface.js';
+declare const DIRECT_CONVERSATION_EVIDENCE_UNAVAILABLE: "not_provided";
+type NegotiationConnectionState = 'potential_match_awaiting_owner_review' | 'owner_accepted' | 'accepted_without_owner_evidence' | 'rejected' | 'negotiation_stalled' | 'draft_not_sent' | 'expired' | 'agents_negotiating' | 'latent' | 'unknown';
+export interface NegotiationLifecycleNarration {
+    agentNegotiation: 'concluded' | 'in_progress' | 'awaiting_agent' | 'unknown';
+    opportunityStatus: OpportunityStatus | null;
+    connectionState: NegotiationConnectionState;
+    ownerAction: 'accepted' | 'not_recorded';
+    directConversationEvidence: typeof DIRECT_CONVERSATION_EVIDENCE_UNAVAILABLE;
+    lifecycleLabel: string;
+}
+/**
+ * Builds additive, lifecycle-explicit narration metadata. Task completion only
+ * means the agents concluded; it never establishes owner acceptance or an H2H
+ * conversation.
+ */
+export declare function buildLifecycleNarration(negotiationStatus: string, opportunity?: NegotiationOpportunityLifecycle): NegotiationLifecycleNarration;
+export {};

package/dist/negotiation/domain/negotiation.lifecycle-narration.js

@@ -0,0 +1,87 @@
+const DIRECT_CONVERSATION_EVIDENCE_UNAVAILABLE = 'not_provided';
+/**
+ * Builds additive, lifecycle-explicit narration metadata. Task completion only
+ * means the agents concluded; it never establishes owner acceptance or an H2H
+ * conversation.
+ */
+export function buildLifecycleNarration(negotiationStatus, opportunity) {
+    const agentNegotiation = negotiationStatus === 'completed'
+        ? 'concluded'
+        : negotiationStatus === 'active'
+            ? 'in_progress'
+            : negotiationStatus === 'waiting_for_agent'
+                ? 'awaiting_agent'
+                : 'unknown';
+    const common = {
+        agentNegotiation,
+        opportunityStatus: opportunity?.status ?? null,
+        ownerAction: opportunity?.acceptedByOwner ? 'accepted' : 'not_recorded',
+        directConversationEvidence: DIRECT_CONVERSATION_EVIDENCE_UNAVAILABLE,
+    };
+    switch (opportunity?.status) {
+        case 'pending':
+            return {
+                ...common,
+                connectionState: 'potential_match_awaiting_owner_review',
+                lifecycleLabel: negotiationStatus === 'completed'
+                    ? "Agents concluded with a potential match; awaiting the owner's review."
+                    : "A potential match is awaiting the owner's review.",
+            };
+        case 'accepted':
+            return opportunity.acceptedByOwner
+                ? {
+                    ...common,
+                    connectionState: 'owner_accepted',
+                    lifecycleLabel: 'The owner explicitly accepted this opportunity.',
+                }
+                : {
+                    ...common,
+                    connectionState: 'accepted_without_owner_evidence',
+                    lifecycleLabel: 'The opportunity is accepted; this result does not record an owner acceptance.',
+                };
+        case 'rejected':
+            return {
+                ...common,
+                connectionState: 'rejected',
+                lifecycleLabel: 'The opportunity was rejected; no connection was established.',
+            };
+        case 'stalled':
+            return {
+                ...common,
+                connectionState: 'negotiation_stalled',
+                lifecycleLabel: 'The agent negotiation stalled; no connection was established.',
+            };
+        case 'draft':
+            return {
+                ...common,
+                connectionState: 'draft_not_sent',
+                lifecycleLabel: 'The opportunity is still a draft; it has not been sent or accepted.',
+            };
+        case 'expired':
+            return {
+                ...common,
+                connectionState: 'expired',
+                lifecycleLabel: 'The opportunity expired; no connection was established.',
+            };
+        case 'negotiating':
+            return {
+                ...common,
+                connectionState: 'agents_negotiating',
+                lifecycleLabel: 'The agents are still negotiating; no owner decision is recorded.',
+            };
+        case 'latent':
+            return {
+                ...common,
+                connectionState: 'latent',
+                lifecycleLabel: 'The potential match is latent; no owner decision is recorded.',
+            };
+        default:
+            return {
+                ...common,
+                connectionState: 'unknown',
+                lifecycleLabel: negotiationStatus === 'completed'
+                    ? 'The agent negotiation concluded; the current opportunity lifecycle is unavailable.'
+                    : 'The current opportunity lifecycle is unavailable.',
+            };
+    }
+}

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

@@ -0,0 +1,65 @@
+/**
+ * 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 declare const NEGOTIATOR_MEMORY_KINDS: readonly ["playbook", "disclosure_rule", "counterparty_dossier", "threshold"];
+export type DistilledMemoryKind = (typeof NEGOTIATOR_MEMORY_KINDS)[number];
+/**
+ * A single memory entry as injected into prompts. A projection of the
+ * `negotiator_memories` row: content + kind + confidence only — ids,
+ * embeddings, and provenance never enter the prompt.
+ */
+export interface NegotiatorMemoryEntry {
+    kind: DistilledMemoryKind;
+    content: string;
+    /** Anti-poisoning weight (0..1); rendered so the model can weigh hints. */
+    confidence?: number;
+}
+/** Where a retrieval is happening — lets the read service tune top-k/scope. */
+export type NegotiatorMemoryScope = "screen" | "turn";
+/** Query the graph hands to the injected retrieval function. */
+export interface NegotiatorMemoryQuery {
+    /** The user whose negotiator's own memory is being retrieved. */
+    userId: string;
+    /** The other side of this negotiation (dossier subject). */
+    counterpartyUserId: string;
+    /** Free-text similarity query (seed reasoning + counterparty context). */
+    queryText: string;
+    scope: NegotiatorMemoryScope;
+}
+/**
+ * Injected retrieval seam (services/api implements it over the
+ * `negotiator_memories` store). MUST resolve to `[]` on any failure or when
+ * `NEGOTIATOR_MEMORY_INJECT` is off — memory must never break a negotiation.
+ */
+export type NegotiatorMemoryRetrieveFn = (query: NegotiatorMemoryQuery) => Promise<NegotiatorMemoryEntry[]>;
+export interface RenderNegotiatorMemoryOptions {
+    /**
+     * When true (screen node), instructs the model to reflect memory influence
+     * into `evidence.memoryHints` — without copying sensitive text verbatim.
+     */
+    memoryHintsInstruction?: boolean;
+}
+/**
+ * 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 declare function renderNegotiatorMemorySection(entries: NegotiatorMemoryEntry[], opts?: RenderNegotiatorMemoryOptions): string;
+/**
+ * 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 declare function renderNegotiatorChatMemorySection(entries: NegotiatorMemoryEntry[]): string;