@indexnetwork/protocol 6.12.1-rc.404.1 → 6.13.22-rc.405.1

package/dist/negotiation/negotiation.protocol.js

@@ -1,203 +1,5 @@
 /**
- * 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`.
+ * Thin backward-compat shim — IND-550.
+ * Canonical location: negotiation/domain/negotiation.protocol.ts
  */
-import { z } from "zod";
-import { AskUserPayloadSchema } from "../shared/schemas/negotiation-state.schema.js";
-// ─── 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(),
-        /** Present when action is `ask_user` (v2, P3.2). */
-        askUser: AskUserPayloadSchema.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"]);
-// ─── v2 ask_user variants (P3.2, flag-gated) ────────────────────────────────
-// Non-final turns only: the final-cap turn must decide, never pause. Selected
-// via the `opts.askUser` parameter on allowedActionsFor/turnSchemaFor — the
-// base schemas above stay byte-identical for every existing caller.
-/** Initiator seat, non-final turn, with the client-consult pause available. */
-export const InitiatorAskUserTurnSchema = turnSchema(["outreach", "counter", "question", "withdraw", "ask_user"]);
-/** Counterparty seat, non-final turn, with the client-consult pause available. */
-export const CounterpartyAskUserTurnSchema = turnSchema(["accept", "decline", "counter", "question", "ask_user"]);
-// ─── 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"];
-const V2_INITIATOR_ASK_USER_ACTIONS = [...V2_INITIATOR_ACTIONS, "ask_user"];
-const V2_COUNTERPARTY_ASK_USER_ACTIONS = [...V2_COUNTERPARTY_ACTIONS, "ask_user"];
-/**
- * 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, opts) {
-    if (version !== "v2")
-        return isFinalTurn ? V1_FINAL_ACTIONS : V1_ACTIONS;
-    const askUser = opts?.askUser === true && !isFinalTurn;
-    if (seat === "initiator") {
-        return isFinalTurn ? V2_FINAL_INITIATOR_ACTIONS : (askUser ? V2_INITIATOR_ASK_USER_ACTIONS : V2_INITIATOR_ACTIONS);
-    }
-    return isFinalTurn ? V2_FINAL_COUNTERPARTY_ACTIONS : (askUser ? V2_COUNTERPARTY_ASK_USER_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, opts) {
-    if (version !== "v2")
-        return isFinalTurn ? v1Schemas.final : v1Schemas.system;
-    const askUser = opts?.askUser === true && !isFinalTurn;
-    if (seat === "initiator") {
-        return isFinalTurn ? FinalInitiatorTurnSchema : (askUser ? InitiatorAskUserTurnSchema : InitiatorTurnSchema);
-    }
-    return isFinalTurn ? FinalCounterpartyTurnSchema : (askUser ? CounterpartyAskUserTurnSchema : 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 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 function configuredProtocolVersion() {
-    return process.env.NEGOTIATION_PROTOCOL_VERSION === "v2" ? "v2" : "v1";
-}
-/**
- * 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 function configuredAskUserEnabled() {
-    return process.env.NEGOTIATION_ASK_USER_ENABLED === "true";
-}
-/** Default answer window for a paused `ask_user` negotiation: 24 hours. */
-export const DEFAULT_ASK_USER_WINDOW_MS = 24 * 60 * 60 * 1000;
-/**
- * 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 function askUserAnswerWindowMs() {
-    const raw = process.env.NEGOTIATION_ASK_USER_WINDOW_MS;
-    if (raw) {
-        const parsed = Number(raw);
-        if (Number.isFinite(parsed) && parsed > 0)
-            return parsed;
-    }
-    return DEFAULT_ASK_USER_WINDOW_MS;
-}
-/**
- * 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 const ASK_USER_LOCK_SLACK_MS = 60 * 60 * 1000;
-/**
- * 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
+export * from "./domain/negotiation.protocol.js";

package/dist/negotiation/negotiation.question-safety.d.ts

@@ -1,26 +1,5 @@
-/** Fixed prompt-safe labels; producers must not replace them with raw network/counterparty text. */
-export declare const NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY = "the other participant";
-export declare const NEGOTIATION_QUESTION_GENERIC_NETWORK = "the selected network";
-export declare const NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY = "a potential collaboration that may require clarification before you decide";
 /**
- * Deterministically reject question context copied from private negotiation inputs.
- * This guard never rewrites content: unsafe or ambiguous text yields no card while
- * the already-armed timeout retains the conservative continuation path.
+ * Thin backward-compat shim — IND-550.
+ * Canonical location: negotiation/domain/negotiation.question-safety.ts
  */
-export declare function isSafeNegotiationQuestionText(value: string, options?: {
-    forbiddenIdentifiers?: string[];
-    forbiddenSourceText?: string[];
-}): boolean;
-/** Validate the only structured fields allowed to enter the inflight Questioner prompt. */
-export declare function validateInflightAskUserFields(input: {
-    disclosureSubject?: string | null;
-    draftQuestion?: string | null;
-    forbiddenIdentifiers?: string[];
-    forbiddenSourceText?: string[];
-}): {
-    disclosureSubject: string;
-    draftQuestion?: string;
-} | null;
-/** Stable, non-secret settlement/outbox key derived only from the exact paused task. */
-export declare function negotiationQuestionSettlementId(taskId: string): string;
-//# sourceMappingURL=negotiation.question-safety.d.ts.map
+export * from "./domain/negotiation.question-safety.js";

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

@@ -1,56 +1,5 @@
-import { hasUnsupportedOpportunityClaim } from '../opportunity/opportunity.claim-safety.js';
-/** Fixed prompt-safe labels; producers must not replace them with raw network/counterparty text. */
-export const NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY = 'the other participant';
-export const NEGOTIATION_QUESTION_GENERIC_NETWORK = 'the selected network';
-export const NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY = 'a potential collaboration that may require clarification before you decide';
-const INTERNAL_ID_PATTERN = /\b(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|(?:task|intent|network|opportunity|user|match)[_-]?id)\b/i;
-const PRIVATE_SOURCE_PATTERN = /\b(?:private transcript|raw transcript|assessment(?:\.reasoning)?|seed assessment|evaluator reasoning|match reason|matchReason|internal metadata|counterparty profile)\b/i;
-function normalize(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
-}
 /**
- * Deterministically reject question context copied from private negotiation inputs.
- * This guard never rewrites content: unsafe or ambiguous text yields no card while
- * the already-armed timeout retains the conservative continuation path.
+ * Thin backward-compat shim — IND-550.
+ * Canonical location: negotiation/domain/negotiation.question-safety.ts
  */
-export function isSafeNegotiationQuestionText(value, options) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0 || trimmed.length > 600)
-        return false;
-    if (INTERNAL_ID_PATTERN.test(trimmed) || PRIVATE_SOURCE_PATTERN.test(trimmed))
-        return false;
-    if (hasUnsupportedOpportunityClaim(trimmed))
-        return false;
-    const normalized = normalize(trimmed);
-    for (const identifier of options?.forbiddenIdentifiers ?? []) {
-        const forbidden = normalize(identifier);
-        if (forbidden.length >= 3 && new RegExp(`(?:^| )${forbidden.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?: |$)`).test(normalized)) {
-            return false;
-        }
-    }
-    for (const source of options?.forbiddenSourceText ?? []) {
-        const forbidden = normalize(source);
-        if (forbidden.length >= 24 && (normalized.includes(forbidden) || forbidden.includes(normalized))) {
-            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();
-    if (!disclosureSubject || !isSafeNegotiationQuestionText(disclosureSubject, input))
-        return null;
-    const draftQuestion = input.draftQuestion?.trim();
-    if (draftQuestion && !isSafeNegotiationQuestionText(draftQuestion, input))
-        return null;
-    return {
-        disclosureSubject,
-        ...(draftQuestion ? { draftQuestion } : {}),
-    };
-}
-/** Stable, non-secret settlement/outbox key derived only from the exact paused task. */
-export function negotiationQuestionSettlementId(taskId) {
-    return `negotiation-question-settlement-v1-${taskId}`;
-}
-//# sourceMappingURL=negotiation.question-safety.js.map
+export * from "./domain/negotiation.question-safety.js";

package/dist/negotiation/negotiation.reflect.d.ts

@@ -1,199 +1,6 @@
-import { z } from "zod";
-import { createStructuredModel } from "../shared/agent/model.config.js";
 /**
- * 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.
+ * Thin backward-compat shim — IND-550.
+ * Canonical location: negotiation/application/negotiation.reflect.ts
+ * DistilledMemoryKind / NEGOTIATOR_MEMORY_KINDS re-exported from domain via application.
  */
-export declare const NEGOTIATOR_MEMORY_KINDS: readonly ["playbook", "disclosure_rule", "counterparty_dossier", "threshold"];
-export type DistilledMemoryKind = (typeof NEGOTIATOR_MEMORY_KINDS)[number];
-/** Hard ceiling on entries distilled per reflection pass (per side). */
-export declare const MAX_DISTILLED_MEMORIES = 3;
-/**
- * One distilled memory entry as produced by the reflection LLM. The caller
- * owns persistence: it resolves `aboutCounterparty` to a `subjectUserId`,
- * computes the embedding, and attaches provenance `sourceRefs`.
- */
-export declare const DistilledMemorySchema: z.ZodObject<{
-    kind: z.ZodEnum<["playbook", "disclosure_rule", "counterparty_dossier", "threshold"]>;
-    /** Self-contained operational statement, useful without the transcript. */
-    content: z.ZodString;
-    /** Evidence strength, 0..1. Explicit client statements score high. */
-    confidence: z.ZodNumber;
-    /**
-     * True when the entry is about the counterparty (kind should be
-     * `counterparty_dossier`); false for client-side rules and playbooks.
-     */
-    aboutCounterparty: z.ZodBoolean;
-    /** Turn indexes (0-based, into the provided transcript) evidencing this entry. */
-    turnIndexes: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
-}, "strip", z.ZodTypeAny, {
-    kind: "threshold" | "playbook" | "disclosure_rule" | "counterparty_dossier";
-    confidence: number;
-    content: string;
-    aboutCounterparty: boolean;
-    turnIndexes: number[];
-}, {
-    kind: "threshold" | "playbook" | "disclosure_rule" | "counterparty_dossier";
-    confidence: number;
-    content: string;
-    aboutCounterparty: boolean;
-    turnIndexes?: number[] | undefined;
-}>;
-export type DistilledMemory = z.infer<typeof DistilledMemorySchema>;
-export declare const ReflectionResultSchema: z.ZodObject<{
-    memories: z.ZodArray<z.ZodObject<{
-        kind: z.ZodEnum<["playbook", "disclosure_rule", "counterparty_dossier", "threshold"]>;
-        /** Self-contained operational statement, useful without the transcript. */
-        content: z.ZodString;
-        /** Evidence strength, 0..1. Explicit client statements score high. */
-        confidence: z.ZodNumber;
-        /**
-         * True when the entry is about the counterparty (kind should be
-         * `counterparty_dossier`); false for client-side rules and playbooks.
-         */
-        aboutCounterparty: z.ZodBoolean;
-        /** Turn indexes (0-based, into the provided transcript) evidencing this entry. */
-        turnIndexes: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        kind: "threshold" | "playbook" | "disclosure_rule" | "counterparty_dossier";
-        confidence: number;
-        content: string;
-        aboutCounterparty: boolean;
-        turnIndexes: number[];
-    }, {
-        kind: "threshold" | "playbook" | "disclosure_rule" | "counterparty_dossier";
-        confidence: number;
-        content: string;
-        aboutCounterparty: boolean;
-        turnIndexes?: number[] | undefined;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    memories: {
-        kind: "threshold" | "playbook" | "disclosure_rule" | "counterparty_dossier";
-        confidence: number;
-        content: string;
-        aboutCounterparty: boolean;
-        turnIndexes: number[];
-    }[];
-}, {
-    memories: {
-        kind: "threshold" | "playbook" | "disclosure_rule" | "counterparty_dossier";
-        confidence: number;
-        content: string;
-        aboutCounterparty: boolean;
-        turnIndexes?: number[] | undefined;
-    }[];
-}>;
-export type ReflectionResult = z.infer<typeof ReflectionResultSchema>;
-/** A transcript row projected into the reflecting client's perspective. */
-export interface ReflectionTranscriptEntry {
-    index: number;
-    speaker: "client" | "counterparty";
-    action: string;
-    message?: string;
-    reasoning?: string;
-}
-export interface NegotiationReflectionInput {
-    /** The user whose negotiator is reflecting (memories land on their agent). */
-    clientUser: {
-        id: string;
-        name?: string;
-        bio?: string;
-    };
-    counterpartyUser: {
-        id: string;
-        name?: string;
-        bio?: string;
-    };
-    /** The client's seat in this negotiation. */
-    seat: "initiator" | "counterparty";
-    outcome: {
-        hasOpportunity: boolean;
-        reasoning: string;
-        turnCount: number;
-    };
-    transcript: ReflectionTranscriptEntry[];
-    /** Network prompt for context (optional). */
-    indexContext?: string;
-}
-export interface ChatReflectionInput {
-    clientUser: {
-        id: string;
-        name?: string;
-    };
-    /** The negotiator DM messages, oldest first. */
-    messages: Array<{
-        role: "user" | "assistant";
-        content: string;
-    }>;
-}
-/**
- * Payload the finalize node hands to the injected {@link ReflectEnqueueFn}.
- * Carries user display context so the reflect worker never re-loads profiles;
- * turn history is loaded from the conversation by the worker (payloads stay
- * small in Redis).
- */
-export interface NegotiationReflectJobData {
-    negotiationId: string;
-    conversationId: string;
-    opportunityId?: string;
-    sourceUser: {
-        id: string;
-        name?: string;
-        bio?: string;
-    };
-    candidateUser: {
-        id: string;
-        name?: string;
-        bio?: string;
-    };
-    initiatorUserId: string;
-    outcome: {
-        hasOpportunity: boolean;
-        reasoning: string;
-        turnCount: number;
-    };
-}
-/**
- * Injected enqueue callback for post-negotiation reflection (P5.2). The
- * protocol package has no BullMQ access — services/api wires this at its
- * composition roots, exactly like `QuestionerEnqueueFn`. Called fire-and-
- * forget from the finalize node: a reflection failure must never affect the
- * negotiation outcome.
- */
-export type ReflectEnqueueFn = (job: NegotiationReflectJobData) => Promise<void>;
-export interface NegotiationReflectorConfig {
-    /** Hard ceiling on the reflection LLM round-trip, in ms (default 20000). */
-    timeoutMs?: number;
-}
-/**
- * The memory distiller (P5.2). One structured LLM call per reflection pass,
- * producing ≤ {@link MAX_DISTILLED_MEMORIES} private memory entries for one
- * client's negotiator. Throws on LLM/validation failure — callers (the reflect
- * queue worker) own the swallow-and-log policy, since reflection must never
- * affect a negotiation outcome.
- */
-export declare class NegotiationReflector {
-    private readonly timeoutMs;
-    constructor(config?: NegotiationReflectorConfig);
-    /**
-     * Distill memories from a finished negotiation, from one side's perspective.
-     * @throws When the LLM call times out or returns schema-invalid output.
-     */
-    reflectNegotiation(input: NegotiationReflectionInput): Promise<DistilledMemory[]>;
-    /**
-     * Distill stated preferences/corrections from a client ↔ negotiator chat.
-     * @throws When the LLM call times out or returns schema-invalid output.
-     */
-    reflectChat(input: ChatReflectionInput): Promise<DistilledMemory[]>;
-    private distill;
-    /**
-     * Raw structured-model round trip. Split out as a seam so tests can drive
-     * the schema-validation path without a live provider.
-     */
-    protected callModel(model: ReturnType<typeof createStructuredModel>, chatMessages: Array<{
-        role: string;
-        content: string;
-    }>): Promise<unknown>;
-}
-//# sourceMappingURL=negotiation.reflect.d.ts.map
+export * from "./application/negotiation.reflect.js";

package/dist/negotiation/negotiation.reflect.js

@@ -1,153 +1,6 @@
-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 reflectLog = protocolLogger("NegotiationReflector");
 /**
- * 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.
+ * Thin backward-compat shim — IND-550.
+ * Canonical location: negotiation/application/negotiation.reflect.ts
+ * DistilledMemoryKind / NEGOTIATOR_MEMORY_KINDS re-exported from domain via application.
  */
-export const NEGOTIATOR_MEMORY_KINDS = [
-    "playbook",
-    "disclosure_rule",
-    "counterparty_dossier",
-    "threshold",
-];
-/** Hard ceiling on entries distilled per reflection pass (per side). */
-export const MAX_DISTILLED_MEMORIES = 3;
-/**
- * One distilled memory entry as produced by the reflection LLM. The caller
- * owns persistence: it resolves `aboutCounterparty` to a `subjectUserId`,
- * computes the embedding, and attaches provenance `sourceRefs`.
- */
-export const DistilledMemorySchema = z.object({
-    kind: z.enum(NEGOTIATOR_MEMORY_KINDS),
-    /** Self-contained operational statement, useful without the transcript. */
-    content: z.string().min(1),
-    /** Evidence strength, 0..1. Explicit client statements score high. */
-    confidence: z.number().min(0).max(1),
-    /**
-     * True when the entry is about the counterparty (kind should be
-     * `counterparty_dossier`); false for client-side rules and playbooks.
-     */
-    aboutCounterparty: z.boolean(),
-    /** Turn indexes (0-based, into the provided transcript) evidencing this entry. */
-    turnIndexes: z.array(z.number().int().min(0)).default([]),
-});
-export const ReflectionResultSchema = z.object({
-    memories: z.array(DistilledMemorySchema).max(MAX_DISTILLED_MEMORIES),
-});
-const NEGOTIATION_SYSTEM_PROMPT = `You are the private post-negotiation reflection process for {clientName}'s negotiator agent. The negotiation is over; your job is to distill AT MOST ${MAX_DISTILLED_MEMORIES} durable operational memory entries that will make {clientName}'s negotiator better in FUTURE negotiations. These memories are private to {clientName}'s agent — the counterparty never sees them.
-
-Memory kinds:
-- "playbook": a tactic or pattern that worked or failed (e.g. "Opening with the specific shared-interest angle got engagement; generic intros stalled").
-- "disclosure_rule": what {clientName} is or is not willing to share/commit (only when the transcript actually evidences it).
-- "counterparty_dossier": a durable fact about the counterparty useful in future dealings with THEM specifically (set aboutCounterparty=true).
-- "threshold": a concrete boundary observed (e.g. minimum scope, timing constraints, deal-breakers).
-
-Rules:
-- Record ONLY what future negotiations need. No summaries, no play-by-play, no identity facts about {clientName} (their profile already covers those).
-- Every entry MUST cite the transcript turn indexes that evidence it in turnIndexes.
-- Each content string must be self-contained and actionable without the transcript.
-- Set confidence by evidence strength: explicit statements ≈ 0.8-0.9, inferred patterns ≈ 0.4-0.6.
-- aboutCounterparty=true ONLY for counterparty_dossier entries.
-- Return an empty memories array when nothing durable was learned — most short or failed negotiations teach nothing. Do not force entries.`;
-const CHAT_SYSTEM_PROMPT = `You are the private reflection process for {clientName}'s negotiator agent, reviewing a direct chat between {clientName} (the client) and their negotiator. Distill AT MOST ${MAX_DISTILLED_MEMORIES} durable operational memory entries capturing the client's STATED preferences, corrections, and instructions.
-
-Memory kinds:
-- "playbook": how the client wants negotiations approached (style, priorities).
-- "disclosure_rule": what the client said they will or won't share/commit.
-- "threshold": concrete boundaries the client stated (rates, scope, timing, deal-breakers).
-
-Rules:
-- Only distill what the CLIENT stated or clearly confirmed — never invent preferences from the negotiator's own suggestions.
-- Do NOT produce counterparty_dossier entries; this is a client-side conversation. Always set aboutCounterparty=false.
-- Each content string must be self-contained and actionable.
-- turnIndexes cite 0-based indexes into the provided message list.
-- Set confidence by how explicit the client was (direct instruction ≈ 0.9, implied preference ≈ 0.5).
-- Return an empty memories array when the chat contains no durable guidance — casual Q&A usually doesn't.`;
-const DEFAULT_REFLECT_TIMEOUT_MS = 20000;
-/**
- * The memory distiller (P5.2). One structured LLM call per reflection pass,
- * producing ≤ {@link MAX_DISTILLED_MEMORIES} private memory entries for one
- * client's negotiator. Throws on LLM/validation failure — callers (the reflect
- * queue worker) own the swallow-and-log policy, since reflection must never
- * affect a negotiation outcome.
- */
-export class NegotiationReflector {
-    constructor(config) {
-        this.timeoutMs = config?.timeoutMs && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0
-            ? config.timeoutMs
-            : DEFAULT_REFLECT_TIMEOUT_MS;
-    }
-    /**
-     * Distill memories from a finished negotiation, from one side's perspective.
-     * @throws When the LLM call times out or returns schema-invalid output.
-     */
-    async reflectNegotiation(input) {
-        const clientName = input.clientUser.name ?? "the client";
-        const counterpartyName = input.counterpartyUser.name ?? "the counterparty";
-        const systemPrompt = NEGOTIATION_SYSTEM_PROMPT.replace(/{clientName}/g, clientName);
-        const transcriptText = input.transcript.length > 0
-            ? input.transcript.map((t) => {
-                const who = t.speaker === "client" ? `${clientName}'s negotiator` : `${counterpartyName}'s negotiator`;
-                const parts = [`[${t.index}] ${who} → ${t.action}`];
-                if (t.message)
-                    parts.push(`message: ${t.message}`);
-                if (t.reasoning)
-                    parts.push(`reasoning: ${t.reasoning}`);
-                return parts.join("\n  ");
-            }).join("\n")
-            : "(no turns)";
-        const userMessage = `CLIENT: ${clientName}${input.clientUser.bio ? ` — ${input.clientUser.bio}` : ""}
-SEAT: ${input.seat === "initiator" ? "initiator (client's negotiator reached out)" : "counterparty (client's negotiator was reached)"}
-COUNTERPARTY: ${counterpartyName}${input.counterpartyUser.bio ? ` — ${input.counterpartyUser.bio}` : ""}
-${input.indexContext ? `NETWORK CONTEXT: ${input.indexContext}\n` : ""}
-OUTCOME: ${input.outcome.hasOpportunity ? "accepted" : "not accepted"} after ${input.outcome.turnCount} turn(s) — ${input.outcome.reasoning}
-
-TRANSCRIPT:
-${transcriptText}
-
-Distill the durable memories (or return an empty array).`;
-        return this.distill(systemPrompt, userMessage);
-    }
-    /**
-     * Distill stated preferences/corrections from a client ↔ negotiator chat.
-     * @throws When the LLM call times out or returns schema-invalid output.
-     */
-    async reflectChat(input) {
-        const clientName = input.clientUser.name ?? "the client";
-        const systemPrompt = CHAT_SYSTEM_PROMPT.replace(/{clientName}/g, clientName);
-        const chatText = input.messages
-            .map((m, i) => `[${i}] ${m.role === "user" ? clientName : "negotiator"}: ${m.content}`)
-            .join("\n");
-        const userMessage = `CHAT between ${clientName} and their negotiator (oldest first):
-${chatText}
-
-Distill the client's durable guidance (or return an empty array).`;
-        return this.distill(systemPrompt, userMessage);
-    }
-    async distill(systemPrompt, userMessage) {
-        const model = createStructuredModel("negotiationReflector", ReflectionResultSchema, { name: "negotiation_reflector" });
-        const result = await this.callModel(model, [
-            { role: "system", content: systemPrompt },
-            { role: "user", content: userMessage },
-        ]);
-        const parsed = ReflectionResultSchema.safeParse(result);
-        if (!parsed.success) {
-            reflectLog.warn("Reflection output failed schema validation", {
-                issues: parsed.error.issues.map((i) => i.message).slice(0, 3),
-            });
-            throw new Error(`Reflection failed validation: ${parsed.error.issues[0]?.message ?? "unknown"}`);
-        }
-        return parsed.data.memories.slice(0, MAX_DISTILLED_MEMORIES);
-    }
-    /**
-     * Raw structured-model round trip. Split out as a seam so tests can drive
-     * the schema-validation path without a live provider.
-     */
-    async callModel(model, chatMessages) {
-        return invokeWithAbortSignal(model, chatMessages, AbortSignal.timeout(this.timeoutMs));
-    }
-}
-//# sourceMappingURL=negotiation.reflect.js.map
+export * from "./application/negotiation.reflect.js";