@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

package/dist/negotiations/negotiation.reflect.js

@@ -1,145 +0,0 @@
-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 "./negotiation.memory.js";
-import { NEGOTIATOR_MEMORY_KINDS } from "./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/negotiations/negotiation.scope.d.ts

@@ -1,41 +0,0 @@
-/**
- * The boundary between a negotiation and the conversation it runs in.
- *
- * Two agents share one DM permanently — `getOrCreateDM` keys on the agent pair
- * alone — so that conversation accumulates every negotiation the pair has ever
- * had. A negotiation is a bounded episode about ONE match inside it.
- *
- * Every question about a negotiation's own state (whose turn it is, whether it
- * has opened, how many turns it has run) must be answered from the
- * negotiation's messages. Conversation-wide reads remain valid for CONTEXT —
- * what the pair discussed before — but must never decide state, or a fresh
- * match inherits the turn parity of an unrelated concluded one.
- *
- * Every surface that resolves the floor shares this rule. If the graph and the
- * respond/polling surfaces disagreed about a negotiation's scope, an external
- * agent would be told it is not its turn forever.
- */
-/** Minimal task-metadata shape needed to identify a negotiation. */
-export interface NegotiationScopeMetadata {
-    opportunityId?: unknown;
-}
-/**
- * The opportunity a negotiation belongs to, or null when the task carries no
- * opportunity. Keyed on opportunity rather than task because an `ask_user`
- * pause resumes into a successor task: both tasks' turns are one negotiation.
- */
-export declare function negotiationScopeKey(metadata: NegotiationScopeMetadata | null | undefined): string | null;
-/**
- * Reads the messages that constitute one negotiation.
- *
- * A task with no opportunity has no identity separate from its conversation
- * (direct and legacy invocations), so the conversation is its scope — there is
- * no other match it could be confused with.
- */
-export declare function readNegotiationMessages<M>(readers: {
-    byNegotiation: (opportunityId: string) => Promise<M[]>;
-    byConversation: (conversationId: string) => Promise<M[]>;
-}, scope: {
-    conversationId: string;
-    metadata: NegotiationScopeMetadata | null | undefined;
-}): Promise<M[]>;

package/dist/negotiations/negotiation.scope.js

@@ -1,39 +0,0 @@
-/**
- * The boundary between a negotiation and the conversation it runs in.
- *
- * Two agents share one DM permanently — `getOrCreateDM` keys on the agent pair
- * alone — so that conversation accumulates every negotiation the pair has ever
- * had. A negotiation is a bounded episode about ONE match inside it.
- *
- * Every question about a negotiation's own state (whose turn it is, whether it
- * has opened, how many turns it has run) must be answered from the
- * negotiation's messages. Conversation-wide reads remain valid for CONTEXT —
- * what the pair discussed before — but must never decide state, or a fresh
- * match inherits the turn parity of an unrelated concluded one.
- *
- * Every surface that resolves the floor shares this rule. If the graph and the
- * respond/polling surfaces disagreed about a negotiation's scope, an external
- * agent would be told it is not its turn forever.
- */
-/**
- * The opportunity a negotiation belongs to, or null when the task carries no
- * opportunity. Keyed on opportunity rather than task because an `ask_user`
- * pause resumes into a successor task: both tasks' turns are one negotiation.
- */
-export function negotiationScopeKey(metadata) {
-    const id = metadata?.opportunityId;
-    return typeof id === 'string' && id.length > 0 ? id : null;
-}
-/**
- * Reads the messages that constitute one negotiation.
- *
- * A task with no opportunity has no identity separate from its conversation
- * (direct and legacy invocations), so the conversation is its scope — there is
- * no other match it could be confused with.
- */
-export async function readNegotiationMessages(readers, scope) {
-    const opportunityId = negotiationScopeKey(scope.metadata);
-    return opportunityId
-        ? readers.byNegotiation(opportunityId)
-        : readers.byConversation(scope.conversationId);
-}

package/dist/negotiations/negotiation.screen.contracts.d.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-/**
- * negotiations/domain — screen-gate pure contracts (P2.1).
- *
- * Extracted from negotiation.screen.ts so that NegotiationGraphState and the
- * application-layer NegotiationScreener can share types without a domain →
- * application cycle.
- *
- * IND-550: canonical location for screen contract types.
- * Legacy path (negotiations/negotiation.screen.ts shim) re-exports from here
- * via the application layer.
- */
-export declare const NEGOTIATION_SCREEN_MODES: readonly ["off", "shadow", "enforce"];
-export type NegotiationScreenMode = (typeof NEGOTIATION_SCREEN_MODES)[number];
-/**
- * Resolve the screen mode from `NEGOTIATION_SCREEN_MODE`.
- *
- * Defaults to `off` when unset or unrecognized — the screen gate is an
- * explicit opt-in flip (same operational pattern as
- * `NEGOTIATION_PROTOCOL_VERSION` / `NEGOTIATOR_CHAT_ENABLED`): code ships
- * inert, the environment turns it on.
- */
-export declare function configuredScreenMode(): NegotiationScreenMode;
-/**
- * Structured screen decision — the outreach gate's verdict on whether this
- * match is worth the client's name before any turn is exchanged.
- */
-export declare const ScreenDecisionSchema: z.ZodObject<{
-    decision: z.ZodEnum<["reach_out", "pass"]>;
-    reasoning: z.ZodString;
-    /** Suggested opening angle for the outreach turn (only when reaching out). */
-    outreachAngle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    evidence: z.ZodObject<{
-        /** How well the counterparty's contexts/premises fit the client's need. */
-        counterpartyPremiseFit: z.ZodString;
-        /** How the client's intents align with what the counterparty seeks. */
-        intentAlignment: z.ZodString;
-        /** Prior-negotiation memory signals (P5.3). Filled only when negotiator memory was injected into the screen prompt. */
-        memoryHints: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        counterpartyPremiseFit: string;
-        intentAlignment: string;
-        memoryHints?: string | null | undefined;
-    }, {
-        counterpartyPremiseFit: string;
-        intentAlignment: string;
-        memoryHints?: string | null | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    reasoning: string;
-    evidence: {
-        counterpartyPremiseFit: string;
-        intentAlignment: string;
-        memoryHints?: string | null | undefined;
-    };
-    decision: "reach_out" | "pass";
-    outreachAngle?: string | null | undefined;
-}, {
-    reasoning: string;
-    evidence: {
-        counterpartyPremiseFit: string;
-        intentAlignment: string;
-        memoryHints?: string | null | undefined;
-    };
-    decision: "reach_out" | "pass";
-    outreachAngle?: string | null | undefined;
-}>;
-export type ScreenDecision = z.infer<typeof ScreenDecisionSchema>;
-/**
- * The record persisted to `tasks.metadata.screenDecision` and returned into
- * graph state. Extends the LLM decision with operational context so pass-rate
- * queries can group by mode and exclude failed-open rows.
- */
-export interface ScreenDecisionRecord extends ScreenDecision {
-    mode: NegotiationScreenMode;
-    /** True when the screen LLM call failed and the gate defaulted open. */
-    failedOpen?: boolean;
-    /** Error message when `failedOpen` is set. */
-    error?: string;
-    screenedAt: string;
-    durationMs: number;
-}
-/**
- * Whether an enforce-mode outreach screen blocks a negotiation before any
- * turn is exchanged. Shadow-mode pass decisions are recorded but never block.
- * Failed-open rows are treated as reach_out regardless of `decision`.
- */
-export declare function blocksNegotiationBeforeFirstTurn(decisionRecord: ScreenDecisionRecord | null | undefined, turnCount: number): boolean;

package/dist/negotiations/negotiation.screen.contracts.js

@@ -1,58 +0,0 @@
-import { z } from "zod";
-/**
- * negotiations/domain — screen-gate pure contracts (P2.1).
- *
- * Extracted from negotiation.screen.ts so that NegotiationGraphState and the
- * application-layer NegotiationScreener can share types without a domain →
- * application cycle.
- *
- * IND-550: canonical location for screen contract types.
- * Legacy path (negotiations/negotiation.screen.ts shim) re-exports from here
- * via the application layer.
- */
-export const NEGOTIATION_SCREEN_MODES = ["off", "shadow", "enforce"];
-/**
- * Resolve the screen mode from `NEGOTIATION_SCREEN_MODE`.
- *
- * Defaults to `off` when unset or unrecognized — the screen gate is an
- * explicit opt-in flip (same operational pattern as
- * `NEGOTIATION_PROTOCOL_VERSION` / `NEGOTIATOR_CHAT_ENABLED`): code ships
- * inert, the environment turns it on.
- */
-export function configuredScreenMode() {
-    const raw = process.env.NEGOTIATION_SCREEN_MODE;
-    if (raw === "shadow" || raw === "enforce" || raw === "off")
-        return raw;
-    return "off";
-}
-/**
- * Structured screen decision — the outreach gate's verdict on whether this
- * match is worth the client's name before any turn is exchanged.
- */
-export const ScreenDecisionSchema = z.object({
-    decision: z.enum(["reach_out", "pass"]),
-    reasoning: z.string(),
-    /** Suggested opening angle for the outreach turn (only when reaching out). */
-    outreachAngle: z.string().nullable().optional(),
-    evidence: z.object({
-        /** How well the counterparty's contexts/premises fit the client's need. */
-        counterpartyPremiseFit: z.string(),
-        /** How the client's intents align with what the counterparty seeks. */
-        intentAlignment: z.string(),
-        /** Prior-negotiation memory signals (P5.3). Filled only when negotiator memory was injected into the screen prompt. */
-        memoryHints: z.string().nullable().optional(),
-    }),
-});
-/**
- * Whether an enforce-mode outreach screen blocks a negotiation before any
- * turn is exchanged. Shadow-mode pass decisions are recorded but never block.
- * Failed-open rows are treated as reach_out regardless of `decision`.
- */
-export function blocksNegotiationBeforeFirstTurn(decisionRecord, turnCount) {
-    if (!decisionRecord)
-        return false;
-    return (decisionRecord.mode === "enforce" &&
-        !decisionRecord.failedOpen &&
-        decisionRecord.decision === "pass" &&
-        turnCount === 0);
-}

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

@@ -1,78 +0,0 @@
-import { createStructuredModel } from "../shared/agent/model.config.js";
-import type { UserNegotiationContext, SeedAssessment } from "../shared/schemas/negotiation-state.schema.js";
-import { type NegotiatorMemoryEntry } from "./negotiation.memory.js";
-import type { NegotiationTurn } from "./negotiation.state.js";
-import { type AttributedPriorDialogue } from "./negotiation.attribution.js";
-export { NEGOTIATION_SCREEN_MODES, configuredScreenMode, ScreenDecisionSchema, blocksNegotiationBeforeFirstTurn, } from "./negotiation.screen.contracts.js";
-export type { NegotiationScreenMode, ScreenDecision, ScreenDecisionRecord, } from "./negotiation.screen.contracts.js";
-import type { ScreenDecision } from "./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/negotiations/negotiation.screen.js

@@ -1,112 +0,0 @@
-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 "./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 "./negotiation.screen.contracts.js";
-import { ScreenDecisionSchema } from "./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.
-        //
-        // Deliberately NOT gated on `isContinuation`, which means "this negotiation
-        // has already spoken". The gate this section exists for is the opposite
-        // case — a FRESH signal against a counterparty the client has prior dialogue
-        // with (IND-563), which is precisely when duplicate outreach must be caught.
-        const hasAttributed = input.priorDialogueAttributed != null
-            && !attributedDialogueIsEmpty(input.priorDialogueAttributed);
-        const flatPriorDialogue = 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/negotiations/negotiation.stall-gap.d.ts

@@ -1,83 +0,0 @@
-/**
- * Post-stall gap authoring (conversational-questions plan).
- *
- * When a negotiation ends unconcluded — no opportunity, no explicit reject:
- * turn cap, timeout, or stall — the finalize node asks the negotiator for the
- * ONE question whose answer would let a retry conclude, and parks the
- * negotiation carrying that gap as an `ask_user` message in its own record.
- * This module owns that single extra model call.
- *
- * Grounding is exactly what mid-flight authoring (P3.2 / IND-401 A2H) uses:
- * this negotiation's transcript, plus the client's own negotiator DM for the
- * signal when the caller retrieved one. Same non-naming and non-echo rules;
- * the caller re-checks the output with `isSafeAuthoredNegotiationQuestion`
- * (identifiers in hand) before persisting anything.
- *
- * Fail-open contract: any model failure, timeout, or invalid output resolves
- * to null — the negotiation then stalls exactly as it did before this feature,
- * never half-parks.
- */
-import { createStructuredModel } from "../shared/agent/model.config.js";
-import { type StructuredQuestion } from "../shared/schemas/structured-question.schema.js";
-import { type NegotiationConsultationReason } from "../shared/schemas/negotiation-state.schema.js";
-import { type NegotiatorClientDmMessage } from "./negotiation.client-dm.js";
-import type { NegotiationTurn } from "./negotiation.state.js";
-/**
- * Fixed transcript reasoning for a post-stall park turn. Deliberately not
- * model-authored: assessment reasoning enters the shared A2A record, and the
- * park's "why" already lives in the guarded question itself — a second,
- * unguarded free-text channel would reopen the leak surface the question gate
- * closes.
- */
-export declare const NEGOTIATION_PARK_REASONING = "Negotiation parked pending the client's answer.";
-/** Why the negotiation failed to conclude, as finalize classified it. */
-export type NegotiationStallReason = "turn_cap" | "timeout" | "stalled";
-/** The authored gap: what a retry needs from the client, and why the pause is warranted. */
-export interface NegotiationStallGap {
-    reason: NegotiationConsultationReason;
-    question: StructuredQuestion;
-}
-export interface StallGapAuthorInput {
-    /** Display name of the client the question is addressed to. */
-    userName: string;
-    /** The client's signal this negotiation was about. */
-    signal: {
-        title: string;
-        description: string;
-    };
-    /** Why the match was suggested (evaluator output; context, never copy). */
-    seedReasoning: string;
-    /** This negotiation's full transcript, oldest first. */
-    history: NegotiationTurn[];
-    stallReason: NegotiationStallReason;
-    /** Recent excerpt of the client's negotiator DM for this signal, most recent last. */
-    clientDm?: NegotiatorClientDmMessage[];
-}
-export interface NegotiationStallGapAuthorConfig {
-    /** Hard ceiling on the model round-trip, in ms. Same resolution as the negotiator turn timeout. */
-    timeoutMs?: number;
-}
-/**
- * Authors the post-stall gap. One instance lives in the graph's dependency bag
- * beside `systemAgent`; the finalize node calls it at most once per stalled
- * session.
- */
-export declare class NegotiationStallGapAuthor {
-    private readonly timeoutMs;
-    constructor(config?: NegotiationStallGapAuthorConfig);
-    /**
-     * @returns The authored gap, or null when there is none to ask — the model
-     *          said so, produced invalid output after a retry, or failed. The
-     *          caller treats every null identically: terminal stall, no park.
-     */
-    author(input: StallGapAuthorInput): Promise<NegotiationStallGap | null>;
-    /**
-     * Raw structured-model round trip. Split out as a seam so tests can drive
-     * the validate→retry→null loop without a live provider — same pattern as
-     * `IndexNegotiator.callModel`.
-     */
-    protected callModel(model: ReturnType<typeof createStructuredModel>, chatMessages: Array<{
-        role: string;
-        content: string;
-    }>): Promise<unknown>;
-}