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

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

@@ -0,0 +1,194 @@
+import { z } from "zod";
+import { createStructuredModel } from "../../shared/agent/model.config.js";
+export { NEGOTIATOR_MEMORY_KINDS } from "../domain/negotiation.memory.js";
+export type { DistilledMemoryKind } from "../domain/negotiation.memory.js";
+/** 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>;
+}

package/dist/negotiation/application/negotiation.reflect.js

@@ -0,0 +1,145 @@
+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";
+// Memory vocabulary lives in the domain layer; re-export for backward compat.
+export { NEGOTIATOR_MEMORY_KINDS } from "../domain/negotiation.memory.js";
+import { NEGOTIATOR_MEMORY_KINDS } from "../domain/negotiation.memory.js";
+const reflectLog = protocolLogger("NegotiationReflector");
+/** 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));
+    }
+}

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

@@ -0,0 +1,78 @@
+import { createStructuredModel } from "../../shared/agent/model.config.js";
+import type { UserNegotiationContext, SeedAssessment } from "../../shared/schemas/negotiation-state.schema.js";
+import { type NegotiatorMemoryEntry } from "../domain/negotiation.memory.js";
+import type { NegotiationTurn } from "../domain/negotiation.state.js";
+import { type AttributedPriorDialogue } from "../negotiation.attribution.js";
+export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "../domain/negotiation.screen.contracts.js";
+export type { NegotiationScreenMode, ScreenDecision, ScreenDecisionRecord, } from "../domain/negotiation.screen.contracts.js";
+import type { ScreenDecision } from "../domain/negotiation.screen.contracts.js";
+export interface NegotiationScreenerInput {
+    /** The client — the user whose negotiator is deciding whether to reach out. */
+    clientUser: UserNegotiationContext;
+    /** The counterparty the client's negotiator would be reaching out to. */
+    counterpartyUser: UserNegotiationContext;
+    /** The counterparty's `user_contexts` paragraph (empty string when absent). */
+    counterpartyContext?: string;
+    /** The explicit search query that triggered discovery (if any). */
+    discoveryQuery?: string;
+    seedAssessment: Omit<SeedAssessment, "actors">;
+    indexContext: {
+        networkId: string;
+        prompt?: string;
+    };
+    /**
+     * Retrieved negotiator memories for the client (P5.3 read path). Rendered
+     * as a private prompt section with a memoryHints instruction. Absent/empty
+     * → the prompt is byte-identical to before.
+     */
+    memory?: NegotiatorMemoryEntry[];
+    /**
+     * Whether this screen is for a continuation — a match against a counterparty
+     * this client already has prior dialogue with (IND-563). When set with
+     * `priorDialogue`, the gate evaluates the NEW signal on its own merits with
+     * that dialogue as context. Absent → the prompt is byte-identical to before.
+     */
+    isContinuation?: boolean;
+    /**
+     * Prior negotiation turns with this counterparty (continuations only).
+     * Rendered as read-only context so the gate can tell a materially-new signal
+     * from a rehash of an already-settled one. Never treated as this task's own
+     * outreach.
+     */
+    priorDialogue?: NegotiationTurn[];
+    /**
+     * Attributed form of the prior dialogue (IND-569). When present it supersedes
+     * the flat `priorDialogue` list: earlier concluded opportunities and legacy
+     * unattributed turns render as labeled, separated blocks so the gate can see
+     * which prior turns belonged to OTHER opportunities. Absent → the flat
+     * `priorDialogue` rendering is used (byte-identical to before).
+     */
+    priorDialogueAttributed?: AttributedPriorDialogue;
+}
+export interface NegotiationScreenerConfig {
+    /** Hard ceiling on the screen LLM round-trip, in ms (default 15000). */
+    timeoutMs?: number;
+}
+/**
+ * The outreach gate (P2.1). One structured LLM call deciding
+ * `reach_out | pass` for a fresh negotiation, from the reaching client's
+ * perspective. Throws on LLM/validation failure — the screen graph node owns
+ * the fail-open policy (a failed screen never blocks the negotiation).
+ */
+export declare class NegotiationScreener {
+    private readonly timeoutMs;
+    constructor(config?: NegotiationScreenerConfig);
+    /**
+     * Produce a screen decision for a fresh match.
+     * @throws When the LLM call times out or returns schema-invalid output.
+     */
+    invoke(input: NegotiationScreenerInput): Promise<ScreenDecision>;
+    /**
+     * Raw structured-model round trip. Split out as a seam so tests can drive
+     * the schema-validation and fail-open paths without a live provider.
+     */
+    protected callModel(model: ReturnType<typeof createStructuredModel>, chatMessages: Array<{
+        role: string;
+        content: string;
+    }>): Promise<unknown>;
+}

package/dist/negotiation/application/negotiation.screen.js

@@ -0,0 +1,108 @@
+import { createStructuredModel } from "../../shared/agent/model.config.js";
+import { invokeWithAbortSignal } from "../../shared/agent/model-signal.js";
+import { protocolLogger } from "../../shared/observability/protocol.logger.js";
+import { renderNegotiatorMemorySection } from "../domain/negotiation.memory.js";
+import { attributedDialogueIsEmpty, renderAttributedPriorDialogue } from "../negotiation.attribution.js";
+// Re-export domain screen contracts for backward-compat consumers of this module path.
+export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "../domain/negotiation.screen.contracts.js";
+import { ScreenDecisionSchema } from "../domain/negotiation.screen.contracts.js";
+const screenLog = protocolLogger("NegotiationScreener");
+const SYSTEM_PROMPT = `You are the outreach gate for {clientName}'s negotiator agent on a discovery network. Before any negotiation turn is exchanged, you decide whether this match is worth reaching out to on {clientName}'s behalf — their name and attention are spent with every outreach.
+
+Network context: {networkContext}
+
+Decide:
+- "reach_out" when the counterparty plausibly serves {clientName}'s stated needs and a concrete, honest opening case can be made. When reaching out, set outreachAngle to the strongest specific angle for the opening message.
+- "pass" when the match is generic, one-sided, or rests on vague overlap that would waste both parties' attention.
+
+Rules:
+{queryRule}
+- Judge concrete intent alignment, not topical adjacency.
+- Fill evidence.counterpartyPremiseFit with what (if anything) in the counterparty's context actually fits, and evidence.intentAlignment with how the intents line up. Be specific; cite the strongest signal either way.
+- Do NOT reference internal system details like scores, pre-screens, or evaluator outputs in reasoning that could be shown to users.{negotiatorMemory}`;
+const QUERY_RULE = `- {clientName} explicitly searched for "{discoveryQuery}". This query is the PRIMARY criterion: if the counterparty does not satisfy it, pass — background intents cannot rescue a query mismatch.`;
+const NO_QUERY_RULE = `- No explicit search query: judge against {clientName}'s active intents.`;
+const DEFAULT_SCREEN_TIMEOUT_MS = 15000;
+/**
+ * The outreach gate (P2.1). One structured LLM call deciding
+ * `reach_out | pass` for a fresh negotiation, from the reaching client's
+ * perspective. Throws on LLM/validation failure — the screen graph node owns
+ * the fail-open policy (a failed screen never blocks the negotiation).
+ */
+export class NegotiationScreener {
+    constructor(config) {
+        this.timeoutMs = config?.timeoutMs && Number.isFinite(config.timeoutMs) && config.timeoutMs > 0
+            ? config.timeoutMs
+            : DEFAULT_SCREEN_TIMEOUT_MS;
+    }
+    /**
+     * Produce a screen decision for a fresh match.
+     * @throws When the LLM call times out or returns schema-invalid output.
+     */
+    async invoke(input) {
+        const model = createStructuredModel("negotiationScreener", ScreenDecisionSchema, { name: "negotiation_screener" });
+        const clientName = input.clientUser.profile.name ?? "your client";
+        const counterpartyName = input.counterpartyUser.profile.name ?? "the counterparty";
+        const networkContext = input.indexContext.prompt || "General discovery";
+        const queryRule = (input.discoveryQuery ? QUERY_RULE : NO_QUERY_RULE)
+            .replace(/{clientName}/g, clientName)
+            .replace(/{discoveryQuery}/g, input.discoveryQuery ?? "");
+        const systemPrompt = SYSTEM_PROMPT
+            .replace(/{clientName}/g, clientName)
+            .replace("{networkContext}", networkContext)
+            .replace("{queryRule}", queryRule)
+            .replace("{negotiatorMemory}", renderNegotiatorMemorySection(input.memory ?? [], { memoryHintsInstruction: true }));
+        const formatIntents = (intents) => intents.length > 0 ? intents.map((i) => `- ${i.title}: ${i.description}`).join("\n") : "- (none)";
+        const formatScreenTurn = (t, i) => {
+            const msgPart = t.message ? ` — ${t.message}` : "";
+            return `Turn ${i + 1}: ${t.action} — ${t.assessment.reasoning}${msgPart}`;
+        };
+        // IND-569: prefer the attributed rendering (labeled per-opportunity blocks)
+        // when the graph supplies it; otherwise fall back to the flat prior-turn list.
+        const hasAttributed = input.isContinuation
+            && input.priorDialogueAttributed != null
+            && !attributedDialogueIsEmpty(input.priorDialogueAttributed);
+        const flatPriorDialogue = input.isContinuation && input.priorDialogue && input.priorDialogue.length > 0
+            ? input.priorDialogue
+            : [];
+        const priorDialogueBody = hasAttributed
+            ? renderAttributedPriorDialogue(input.priorDialogueAttributed, formatScreenTurn)
+            : (flatPriorDialogue.length > 0 ? flatPriorDialogue.map(formatScreenTurn).join("\n") : "");
+        const priorDialogueContext = priorDialogueBody
+            ? `\n\n--- Prior dialogue with ${counterpartyName} (already spoken) ---\n${priorDialogueBody}\n\nThis is a NEW signal against a counterparty ${clientName} has prior dialogue with. Some turns above may belong to OTHER, already-concluded opportunities (each block is labeled); they are background only. Judge the new signal on its own merits: if it is materially the same as what was already discussed, pass unless something concrete changed; if materially different, judge it fresh. Do NOT reach out again on generic overlap just because they spoke before.`
+            : "";
+        const userMessage = `YOUR CLIENT (${clientName}):
+Bio: ${input.clientUser.profile.bio ?? "N/A"}
+${input.discoveryQuery ? `Search query: "${input.discoveryQuery}"\nBackground intents (secondary to the query):` : "Active intents:"}
+${formatIntents(input.clientUser.intents)}
+
+COUNTERPARTY (${counterpartyName}):
+Bio: ${input.counterpartyUser.profile.bio ?? "N/A"}
+${input.counterpartyContext ? `Context: ${input.counterpartyContext}\n` : ""}Active intents:
+${formatIntents(input.counterpartyUser.intents)}
+
+Why this match was suggested: ${input.seedAssessment.reasoning}${priorDialogueContext}
+
+Decide whether reaching out serves ${clientName}.`;
+        const chatMessages = [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: userMessage },
+        ];
+        const result = await this.callModel(model, chatMessages);
+        const parsed = ScreenDecisionSchema.safeParse(result);
+        if (!parsed.success) {
+            screenLog.warn("Screen output failed schema validation", {
+                issues: parsed.error.issues.map((i) => i.message).slice(0, 3),
+            });
+            throw new Error(`Screen decision failed validation: ${parsed.error.issues[0]?.message ?? "unknown"}`);
+        }
+        return parsed.data;
+    }
+    /**
+     * Raw structured-model round trip. Split out as a seam so tests can drive
+     * the schema-validation and fail-open paths without a live provider.
+     */
+    async callModel(model, chatMessages) {
+        return invokeWithAbortSignal(model, chatMessages, AbortSignal.timeout(this.timeoutMs));
+    }
+}

package/dist/negotiation/application/negotiation.summarizer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NegotiationSummarizer — pure LLM pass that compresses one DiscoveryNegotiation
+ * (potentially several KB of turn reasoning + outcome reasoning) into a
+ * DiscoveryNegotiationDigest (≤256 bytes structured). The digest is what the decision-
+ * question generator consumes, replacing the raw negotiation blob.
+ *
+ * Why: a 10-candidate discovery turn used to produce a 60+ KB prompt for the
+ * question generator, which stalled upstream Gemini/OpenRouter routes and
+ * dropped the connection at ~3 minutes. Per-negotiation summarization caps
+ * the question-generator input at a fixed, predictable size.
+ */
+import { type DiscoveryNegotiationDigest } from "../../shared/schemas/negotiation-digest.schema.js";
+import type { DiscoveryNegotiation } from "../../shared/schemas/discovery-question.schema.js";
+export declare class NegotiationSummarizer {
+    private model;
+    constructor();
+    summarize(negotiation: DiscoveryNegotiation, options?: {
+        signal?: AbortSignal;
+    }): Promise<DiscoveryNegotiationDigest | null>;
+}
+/**
+ * Deterministic fallback when the LLM summarizer fails or isn't wired. Produces
+ * a minimal but valid digest so the question generator still has *some* signal.
+ */
+export declare function buildFallbackDigest(n: DiscoveryNegotiation): DiscoveryNegotiationDigest;

package/dist/negotiation/application/negotiation.summarizer.js

@@ -0,0 +1,101 @@
+/**
+ * NegotiationSummarizer — pure LLM pass that compresses one DiscoveryNegotiation
+ * (potentially several KB of turn reasoning + outcome reasoning) into a
+ * DiscoveryNegotiationDigest (≤256 bytes structured). The digest is what the decision-
+ * question generator consumes, replacing the raw negotiation blob.
+ *
+ * Why: a 10-candidate discovery turn used to produce a 60+ KB prompt for the
+ * question generator, which stalled upstream Gemini/OpenRouter routes and
+ * dropped the connection at ~3 minutes. Per-negotiation summarization caps
+ * the question-generator input at a fixed, predictable size.
+ */
+import { HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { createStructuredModel } from "../../shared/agent/model.config.js";
+import { invokeWithAbortSignal } from "../../shared/agent/model-signal.js";
+import { protocolLogger } from "../../shared/observability/protocol.logger.js";
+import { DiscoveryNegotiationDigestSchema } from "../../shared/schemas/negotiation-digest.schema.js";
+const logger = protocolLogger("NegotiationSummarizer");
+const SYSTEM_PROMPT = `You summarize one negotiation between a seeker's agent and a candidate's agent into a structured digest for downstream decision-question generation.
+
+Output requirements (ALL fields — set optional fields to null when not applicable):
+- counterpartyHint: copy the input field verbatim, truncated to ≤120 chars.
+- indexContext: copy the input field verbatim, truncated to ≤120 chars.
+- outcomeRole: "opportunity" when hasOpportunity=true, else "no-opportunity".
+- outcomeReason: when outcomeRole="no-opportunity", set to "turn_cap" / "timeout" / "screened_out" if the input's reason matches; else "rejected" (if a turn explicitly rejected) or "stalled". When outcomeRole="opportunity", set to null. "screened_out" means the seeker's own agent chose not to reach out before any turn was exchanged — never describe it as the candidate declining or stalling.
+- keyTake: ONE sentence (≤180 chars). Describe the decisive moment, the alignment gap, or the recurring signal — anything a question generator could use to formulate a clarifying question. NOT a generic outcome restatement. Anchor in a concrete detail from the negotiation if possible (a role mismatch, a missing input the candidate flagged, a pivot one party suggested).
+- suggestedRoles: when both parties agreed on roles (the last turn's suggestedRoles), copy them from input. Otherwise set to null.
+
+Do not include candidate identity, PII, names, or IDs. Reuse only counterpartyHint and indexContext as provided.`;
+function buildUserPrompt(n) {
+    const turnLines = n.turns
+        .map((t, i) => `[${i + 1}] action=${t.action} roles=${t.suggestedRoles.ownUser}↔${t.suggestedRoles.otherUser} reasoning=${t.reasoning}`)
+        .join("\n");
+    return [
+        `counterpartyHint: ${n.counterpartyHint}`,
+        `indexContext: ${n.indexContext}`,
+        `turns (${n.turns.length}):`,
+        turnLines || "(no turns)",
+        `outcome.hasOpportunity: ${n.outcome.hasOpportunity}`,
+        `outcome.reasoning: ${n.outcome.reasoning}`,
+        n.outcome.reason ? `outcome.reason: ${n.outcome.reason}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export class NegotiationSummarizer {
+    constructor() {
+        this.model = createStructuredModel("negotiationSummarizer", DiscoveryNegotiationDigestSchema, {
+            name: "negotiation_digest",
+        });
+    }
+    async summarize(negotiation, options) {
+        const user = buildUserPrompt(negotiation);
+        let raw;
+        try {
+            raw = await invokeWithAbortSignal(this.model, [new SystemMessage(SYSTEM_PROMPT), new HumanMessage(user)], options?.signal);
+        }
+        catch (err) {
+            const aborted = options?.signal?.aborted ?? false;
+            if (aborted) {
+                logger.info("NegotiationSummarizer aborted by signal", {
+                    reason: options?.signal?.reason instanceof Error ? options.signal.reason.message : String(options?.signal?.reason ?? "unknown"),
+                });
+            }
+            else {
+                logger.warn("NegotiationSummarizer LLM call failed", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return null;
+        }
+        const parsed = DiscoveryNegotiationDigestSchema.safeParse(raw);
+        if (!parsed.success) {
+            logger.warn("NegotiationSummarizer parse failed", { error: parsed.error.message });
+            return null;
+        }
+        return parsed.data;
+    }
+}
+/**
+ * Deterministic fallback when the LLM summarizer fails or isn't wired. Produces
+ * a minimal but valid digest so the question generator still has *some* signal.
+ */
+export function buildFallbackDigest(n) {
+    const outcomeRole = n.outcome.hasOpportunity ? "opportunity" : "no-opportunity";
+    const lastTurn = n.turns[n.turns.length - 1];
+    const keyTakeRaw = n.outcome.reasoning && n.outcome.reasoning.trim().length > 0
+        ? n.outcome.reasoning
+        : `${n.turns.length} turn(s); ended ${outcomeRole}`;
+    return {
+        counterpartyHint: n.counterpartyHint.slice(0, 120),
+        indexContext: n.indexContext.slice(0, 120),
+        outcomeRole,
+        outcomeReason: outcomeRole === "no-opportunity"
+            ? (n.outcome.reason ?? "stalled")
+            : null,
+        keyTake: keyTakeRaw.slice(0, 180),
+        suggestedRoles: lastTurn?.action === "accept" && lastTurn.suggestedRoles
+            ? lastTurn.suggestedRoles
+            : null,
+    };
+}