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

package/dist/negotiations/negotiation.graph.init.js

@@ -1,256 +0,0 @@
-/**
- * Negotiation graph, stage 1: claim the conversation, task and seat.
- */
-import { configuredProtocolVersion, readProtocolVersion } from "./negotiation.protocol.js";
-import { buildIntentSnapshots } from "./negotiation.intent-snapshot-provenance.js";
-import { holdsNegotiationConversationLock } from "./negotiation.task-lock-policy.js";
-import { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
-import { readNegotiationMessages } from "./negotiation.scope.js";
-import { buildSeededAttribution } from './negotiation.attribution.js';
-import { initLog, resolveTaskAttribution, turnsFromMessages } from "./negotiation.graph.shared.js";
-export async function initNode(state, deps) {
-    try {
-        // Exact continuations reuse the prior conversation and preclaimed
-        // successor; they must not create any mutable state before the fence.
-        const agentIdA = `agent:${state.sourceUser.id}`;
-        const agentIdB = `agent:${state.candidateUser.id}`;
-        const execution = state.continuationExecution;
-        const conversation = execution
-            ? { id: execution.conversationId }
-            : await deps.database.getOrCreateDM(agentIdA, agentIdB, 'agent');
-        // --- Lock gate: check for an active task on this conversation ---
-        // Two reads with two jobs. `conversationMessages` is the pair's whole shared
-        // DM — CONTEXT, including negotiations for other matches, which reaches the
-        // agent only as labelled prior dialogue. `negotiationMessages` is THIS
-        // match's own turns, and is the sole input to this negotiation's state:
-        // whether it has opened, whose turn it is, how far it has run.
-        const conversationMessages = await deps.database.getMessagesForConversation(conversation.id);
-        if (Boolean(state.resumeFromTaskId) !== Boolean(state.continuationSettlementId)
-            || Boolean(state.resumeFromTaskId) !== Boolean(execution))
-            return { error: 'invalid continuation correlation' };
-        const exactContinuation = state.resumeFromTaskId && state.continuationSettlementId && execution
-            ? { taskId: state.resumeFromTaskId, settlementId: state.continuationSettlementId, execution }
-            : null;
-        const priorTask = exactContinuation
-            ? await deps.database.getTask(exactContinuation.taskId)
-            : state.opportunityId
-                ? await deps.database.getNegotiationTaskForOpportunity(state.opportunityId)
-                : null;
-        const claimedSuccessor = exactContinuation
-            ? await deps.database.getTask(exactContinuation.execution.successorTaskId)
-            : null;
-        if (exactContinuation) {
-            const settlement = priorTask?.metadata?.questionSettlement;
-            const storedExecution = claimedSuccessor?.metadata?.continuationExecution;
-            if (!priorTask
-                || priorTask.conversationId !== conversation.id
-                || priorTask.state !== 'canceled'
-                || priorTask.metadata?.opportunityId !== state.opportunityId
-                || settlement?.settlementId !== exactContinuation.settlementId
-                || settlement?.taskId !== exactContinuation.taskId
-                || !claimedSuccessor
-                || claimedSuccessor.conversationId !== conversation.id
-                || storedExecution?.token !== exactContinuation.execution.token
-                || storedExecution?.fence !== exactContinuation.execution.fence
-                || storedExecution?.status !== 'claimed')
-                return { error: 'invalid exact continuation task' };
-        }
-        const isLocked = !exactContinuation && !!priorTask && holdsNegotiationConversationLock(priorTask);
-        if (isLocked) {
-            initLog.info('Conversation locked by active task, returning busy', {
-                conversationId: conversation.id,
-                opportunityId: state.opportunityId,
-            });
-            return { error: 'busy' };
-        }
-        // --- Load this negotiation's own prior turns ---
-        // Resolved through the shared scope rule, not a local copy of it: the graph
-        // and the respond/polling surfaces must agree on what "this negotiation's
-        // messages" means, or an external agent can be told it is not its turn
-        // forever. That rule also owns the unkeyed case — a run with no opportunity
-        // has no identity apart from its conversation.
-        const negotiationMessages = await readNegotiationMessages({
-            byNegotiation: (id) => deps.database.getNegotiationMessages(id),
-            byConversation: async () => conversationMessages,
-        }, {
-            conversationId: conversation.id,
-            metadata: { opportunityId: state.opportunityId },
-        });
-        const priorTurns = turnsFromMessages(negotiationMessages);
-        // `isContinuation` means THIS negotiation has already spoken — not that the
-        // pair has history. A fresh match in a long-running DM is not a
-        // continuation, and must still open.
-        const isContinuation = priorTurns.length > 0;
-        // Determine scenario-based maxTurns
-        const scope = { action: 'manage:negotiations', scopeType: 'network', scopeId: state.indexContext.networkId };
-        const [sourceHasAgent, candidateHasAgent] = await Promise.all([
-            deps.dispatcher.hasExternalAgent(state.sourceUser.id, scope),
-            deps.dispatcher.hasExternalAgent(state.candidateUser.id, scope),
-        ]);
-        const ambientMax = Number(process.env.NEGOTIATION_MAX_TURNS_AMBIENT) || 6;
-        let maxTurns = state.maxTurns;
-        if (maxTurns == null) {
-            maxTurns = (sourceHasAgent && candidateHasAgent) ? 0 : ambientMax;
-        }
-        // --- Initiator seat resolution (v2: rigid per match, stamped at discovery) ---
-        // 1. Continuations inherit from the prior task for the same opportunity —
-        //    never re-derive, so the seat cannot flip between sessions.
-        // 2. Conversation-scoped tie-break: if another negotiation on this DM is
-        //    active and fresh (symmetric concurrent start under a different
-        //    opportunityId — the opportunity-scoped lock above cannot see it),
-        //    the first created task keeps the seat; this run inherits its stamp.
-        // 3. Otherwise: explicit stamp from the caller, falling back to the
-        //    session's sourceUser (pre-stamp heuristic behavior, unchanged).
-        const readInitiator = (metadata) => {
-            const v = metadata?.initiatorUserId;
-            return typeof v === 'string' && v.length > 0 ? v : null;
-        };
-        let initiatorUserId = readInitiator(priorTask?.metadata) ?? state.initiatorUserId ?? state.sourceUser.id;
-        // Conversation-scoped prior task: used only for the initiator tie-break
-        // (and only when active+fresh).
-        const convTask = !exactContinuation && !readInitiator(priorTask?.metadata)
-            ? await deps.database.getLatestNegotiationTaskForConversation?.(conversation.id).catch(() => null)
-            : null;
-        if (!readInitiator(priorTask?.metadata)) {
-            if (convTask && convTask.id !== priorTask?.id && holdsNegotiationConversationLock(convTask)) {
-                const convInitiator = readInitiator(convTask.metadata);
-                if (convInitiator) {
-                    initLog.info('Conversation-scoped tie-break: inheriting initiator seat from concurrent task', {
-                        conversationId: conversation.id,
-                        winningTaskId: convTask.id,
-                        initiatorUserId: convInitiator,
-                    });
-                    initiatorUserId = convInitiator;
-                }
-            }
-        }
-        // --- Floor: derived from this negotiation's turns, after the seat is known ---
-        // Resolved here rather than above because an unopened negotiation starts
-        // with its initiator, which the tie-break may only just have settled.
-        const expectedSpeaker = expectedNegotiationSpeaker({
-            sourceUserId: state.sourceUser.id,
-            candidateUserId: state.candidateUser.id,
-            initiatorUserId,
-        }, negotiationMessages);
-        if (!expectedSpeaker)
-            return { error: 'invalid negotiation participants' };
-        const currentSpeaker = expectedSpeaker === state.sourceUser.id
-            ? 'source'
-            : 'candidate';
-        // --- Protocol version: pinned per negotiation, re-stamped per match ---
-        // A prior task for this same negotiation (exact continuation resume or
-        // a re-run of the same opportunity) pins the version, so one
-        // negotiation never flips semantics mid-flight (absent field on a
-        // genuine prior = pre-v2 task = v1). Everything else — including
-        // continuations of older conversations between the same pair — stamps
-        // fresh from NEGOTIATION_PROTOCOL_VERSION, so a version cutover
-        // reaches existing pairs on their next new match instead of being
-        // pinned to v1 forever by conversation history.
-        const protocolVersion = priorTask
-            ? (readProtocolVersion(priorTask.metadata) ?? 'v1')
-            : configuredProtocolVersion();
-        const taskMetadata = {
-            type: 'negotiation',
-            sourceUserId: state.sourceUser.id,
-            initiatorUserId,
-            protocolVersion,
-            candidateUserId: state.candidateUser.id,
-            networkId: state.indexContext.networkId,
-            sourceIntentId: state.sourceIntentId,
-            candidateIntentId: state.candidateIntentId,
-            participantBindings: [
-                ...(state.sourceIntentId ? [{ userId: state.sourceUser.id, intentId: state.sourceIntentId, networkId: state.indexContext.networkId }] : []),
-                ...(state.candidateIntentId ? [{ userId: state.candidateUser.id, intentId: state.candidateIntentId, networkId: state.indexContext.networkId }] : []),
-            ],
-            intentSnapshots: buildIntentSnapshots(state.sourceUser, state.candidateUser),
-            ...(state.opportunityId && { opportunityId: state.opportunityId }),
-            maxTurns,
-            isContinuation,
-            priorTurnCount: priorTurns.length,
-            ...(exactContinuation ? {
-                resumeFromTaskId: exactContinuation.taskId,
-                continuationSettlementId: exactContinuation.settlementId,
-            } : {}),
-        };
-        if (state.opportunityId && Boolean(state.opportunityStatus) !== Boolean(state.opportunityUpdatedAt)) {
-            throw new Error('Negotiation attempt requires both opportunity status and updatedAt');
-        }
-        const task = exactContinuation
-            ? claimedSuccessor
-            : state.opportunityId && state.opportunityStatus && state.opportunityUpdatedAt
-                ? await deps.database.createNegotiationTaskForAttempt({
-                    conversationId: conversation.id,
-                    opportunityId: state.opportunityId,
-                    expectedStatus: state.opportunityStatus,
-                    expectedUpdatedAt: state.opportunityUpdatedAt,
-                    metadata: taskMetadata,
-                })
-                : await deps.database.createTask(conversation.id, taskMetadata);
-        if (!task) {
-            throw new Error('Negotiation attempt is stale or already claimed');
-        }
-        // Attempt-bound discovery atomically promoted the exact persisted state
-        // to `negotiating` while inserting the task. Legacy/direct invocations
-        // with only an opportunity ID retain the prior best-effort status update.
-        if (state.opportunityId && !state.opportunityUpdatedAt) {
-            await deps.database.updateOpportunityStatus(state.opportunityId, 'negotiating').catch((err) => {
-                initLog.error('Failed to set opportunity status to negotiating', { opportunityId: state.opportunityId, error: err });
-            });
-        }
-        // Load user answers collected by the questioner between sessions
-        const userAnswers = (isContinuation && state.opportunityId)
-            ? await deps.database.getOpportunityUserAnswers(state.opportunityId).catch((err) => {
-                initLog.error('Failed to load user answers', { opportunityId: state.opportunityId, error: err });
-                return [];
-            })
-            : [];
-        // Seed messages with THIS negotiation's prior turns (additive reducer
-        // appends new turns on top). taskId is preserved so the turn/screen nodes
-        // can separate this session's turns from earlier sessions of the same
-        // negotiation (IND-569).
-        const seedMessages = negotiationMessages.map((m) => ({
-            id: m.id,
-            senderId: m.senderId,
-            role: 'agent',
-            parts: m.parts,
-            createdAt: m.createdAt,
-            taskId: m.taskId ?? null,
-        }));
-        // IND-569: attribute the pair's whole shared DM to its originating
-        // negotiations, once, up front. Earlier-match and legacy unattributed
-        // blocks are immutable for the session; the current block is composed per
-        // turn. Keyed on the conversation, not on `isContinuation`: a fresh match
-        // has no turns of its own but the pair's history is exactly the context
-        // worth carrying into it.
-        const priorAttribution = conversationMessages.length > 0
-            ? await buildSeededAttribution(conversationMessages
-                .map((m) => ({ taskId: m.taskId ?? null, turn: turnsFromMessages([m])[0] }))
-                .filter((e) => Boolean(e.turn)), state.opportunityId, (taskId) => resolveTaskAttribution(deps, taskId))
-            : null;
-        return {
-            conversationId: conversation.id,
-            taskId: task.id,
-            currentSpeaker,
-            turnCount: 0,
-            maxTurns,
-            isContinuation,
-            initiatorUserId,
-            protocolVersion,
-            priorTurnCount: priorTurns.length,
-            ...(priorAttribution && { priorAttribution }),
-            ...(userAnswers.length > 0 && { userAnswers }),
-            ...(exactContinuation?.execution.consultation
-                ? { privateConsultation: exactContinuation.execution.consultation }
-                : {}),
-            ...(exactContinuation && (() => {
-                const turnContext = priorTask?.metadata?.turnContext;
-                const reason = turnContext?.consultationPolicyReason;
-                return typeof reason === 'string' ? { consultationPolicyReason: reason } : {};
-            })()),
-            ...(seedMessages.length > 0 && { messages: seedMessages }),
-        };
-    }
-    catch (err) {
-        return { error: `Init failed: ${err instanceof Error ? err.message : String(err)}` };
-    }
-}

package/dist/negotiations/negotiation.graph.js

@@ -1,94 +0,0 @@
-/**
- * Bilateral negotiation graph: init → screen → turn* → finalize.
- *
- * Every node is a top-level function in a sibling module, taking the graph
- * state and an explicit {@link NegotiationGraphDeps}. This file composes the
- * dependency bag and wires the edges — nothing else.
- */
-import { StateGraph } from "@langchain/langgraph";
-import { NegotiationGraphState } from "./negotiation.state.js";
-import { IndexNegotiator } from "./negotiation.agent.js";
-import { NegotiationStallGapAuthor } from "./negotiation.stall-gap.js";
-import { blocksNegotiationBeforeFirstTurn, NegotiationScreener } from "./negotiation.screen.js";
-import { configuredScreenMode } from "./negotiation.screen.contracts.js";
-import { isTerminalAction } from "./negotiation.protocol.js";
-import { isNegotiationTurnCapReached } from "./negotiation.turn-cap.js";
-import { initNode } from "./negotiation.graph.init.js";
-import { screenNode } from "./negotiation.graph.screen.js";
-import { turnNode } from "./negotiation.graph.turn.js";
-import { finalizeNode } from "./negotiation.graph.finalize.js";
-export { negotiateCandidates } from "./negotiation.candidates.js";
-/**
- * Factory for the bilateral negotiation LangGraph state machine.
- * @remarks Accepts an AgentDispatcher for per-turn agent resolution.
- */
-export class NegotiationGraphFactory {
-    constructor(database, dispatcher, timeoutQueue, questionerEnqueue, reflectEnqueue, memoryRetrieve, clientDmRetrieve) {
-        this.deps = {
-            database,
-            dispatcher,
-            timeoutQueue,
-            questionerEnqueue,
-            reflectEnqueue,
-            memoryRetrieve,
-            clientDmRetrieve,
-            systemAgent: new IndexNegotiator(),
-            stallGapAuthor: new NegotiationStallGapAuthor(),
-            screener: new NegotiationScreener(),
-        };
-    }
-    createGraph() {
-        const deps = this.deps;
-        return new StateGraph(NegotiationGraphState)
-            .addNode("init", (state) => initNode(state, deps))
-            .addNode("screen", (state) => screenNode(state, deps))
-            .addNode("turn", (state) => turnNode(state, deps))
-            .addNode("finalize", (state) => finalizeNode(state, deps))
-            .addConditionalEdges("turn", routeAfterTurn, {
-            turn: "turn",
-            finalize: "finalize",
-        })
-            .addConditionalEdges("init", routeAfterInit, { screen: "screen", turn: "turn", finalize: "finalize" })
-            // P2.2: enforce-mode pass → finalize (screened_out); everything else → turn.
-            .addConditionalEdges("screen", routeAfterScreen, { turn: "turn", finalize: "finalize" })
-            .addEdge("__start__", "init")
-            .addEdge("finalize", "__end__")
-            .compile();
-    }
-}
-/** After init: fail closed, run the outreach gate, or go straight to the first turn. */
-export function routeAfterInit(state) {
-    if (state.error)
-        return "finalize";
-    // Screen gate: fresh negotiations only (continuations already passed
-    // the gate when the dialogue opened); off disables the node entirely.
-    // IND-563: regular continuations (new opportunity, existing dm_pair)
-    // also run through the screen gate so stale matches are caught before
-    // re-engaging the counterparty. Exact ask_user resumes
-    // (continuationExecution) are mid-flight and must never be re-screened.
-    if (configuredScreenMode() !== "off" && !state.continuationExecution)
-        return "screen";
-    return "turn";
-}
-/** After the outreach gate: an enforced pass ends the negotiation before any turn. */
-export function routeAfterScreen(state) {
-    return blocksNegotiationBeforeFirstTurn(state.screenDecision, state.turnCount) ? "finalize" : "turn";
-}
-/** After a turn: keep going, or settle. */
-export function routeAfterTurn(state) {
-    if (state.status === 'waiting_for_agent')
-        return "finalize";
-    if (state.status === 'input_required')
-        return "finalize";
-    if (state.error)
-        return "finalize";
-    if (!state.lastTurn)
-        return "finalize";
-    // Terminal actions: accept (v1+v2), reject (v1), withdraw/decline (v2)
-    if (isTerminalAction(state.lastTurn.action))
-        return "finalize";
-    // question routes same as counter — next turn
-    if (isNegotiationTurnCapReached(state.turnCount, state.maxTurns))
-        return "finalize";
-    return "turn";
-}

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

@@ -1,23 +0,0 @@
-/**
- * Negotiation graph, stage 2: the outreach gate.
- */
-import { type ScreenDecisionRecord } from "./negotiation.screen.js";
-import type { NegotiationGraphDeps, NegotiationState } from "./negotiation.graph.shared.js";
-/**
- * Screen node (P2.1) — the outreach gate. Runs between init and the first
- * turn on FRESH negotiations only (routing skips it on continuations and
- * when NEGOTIATION_SCREEN_MODE=off). The reaching client's negotiator
- * decides whether the match is worth its client's name; in shadow mode the
- * decision is recorded (task metadata + trace event + log line) but never
- * blocks — the negotiation always proceeds to the first turn. In enforce
- * mode (P2.2) a `pass` routes straight to finalize: zero turns, zero
- * counterparty involvement, outcome `reason: "screened_out"`, opportunity
- * quietly `rejected` (init had already flipped it to `negotiating`).
- * A failed screen still fails OPEN in every mode.
- */
-export declare function screenNode(state: NegotiationState, deps: NegotiationGraphDeps): Promise<{
-    screenDecision: ScreenDecisionRecord;
-    memoryBySide: {
-        [x: string]: import("./negotiation.memory.js").NegotiatorMemoryEntry[];
-    };
-}>;

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

@@ -1,108 +0,0 @@
-/**
- * Negotiation graph, stage 2: the outreach gate.
- */
-import { requestContext } from "../shared/observability/request-context.js";
-import { configuredScreenMode } from "./negotiation.screen.contracts.js";
-import { buildAttributedDialogue, memoryQueryText, retrieveMemory, screenNodeLog, turnsFromMessages } from "./negotiation.graph.shared.js";
-/**
- * Screen node (P2.1) — the outreach gate. Runs between init and the first
- * turn on FRESH negotiations only (routing skips it on continuations and
- * when NEGOTIATION_SCREEN_MODE=off). The reaching client's negotiator
- * decides whether the match is worth its client's name; in shadow mode the
- * decision is recorded (task metadata + trace event + log line) but never
- * blocks — the negotiation always proceeds to the first turn. In enforce
- * mode (P2.2) a `pass` routes straight to finalize: zero turns, zero
- * counterparty involvement, outcome `reason: "screened_out"`, opportunity
- * quietly `rejected` (init had already flipped it to `negotiating`).
- * A failed screen still fails OPEN in every mode.
- */
-export async function screenNode(state, deps) {
-    const traceEmitter = requestContext.getStore()?.traceEmitter;
-    const emitWide = (event) => traceEmitter?.(event);
-    const mode = configuredScreenMode();
-    const start = Date.now();
-    // The client is the initiator seat's user — the side whose negotiator is
-    // reaching out. Fresh runs stamp initiatorUserId in init; fall back to
-    // sourceUser (what the stamp defaults to anyway).
-    const initiatorId = state.initiatorUserId ?? state.sourceUser.id;
-    const clientIsSource = initiatorId !== state.candidateUser.id;
-    const clientUser = clientIsSource ? state.sourceUser : state.candidateUser;
-    const counterpartyUser = clientIsSource ? state.candidateUser : state.sourceUser;
-    // P5.3: the client's own negotiator memory informs the outreach gate.
-    // Cached into state so the client's first turn reuses it.
-    const clientSide = clientIsSource ? "source" : "candidate";
-    const clientMemory = state.memoryBySide?.[clientSide]
-        ?? (deps.memoryRetrieve
-            ? await retrieveMemory(deps, clientUser.id, counterpartyUser.id, memoryQueryText(state, counterpartyUser), "screen")
-            : []);
-    let decision;
-    let failedOpen = false;
-    let screenError;
-    try {
-        const counterpartyContext = (await deps.database.getUserContext(counterpartyUser.id, null).catch(() => null))?.text ?? "";
-        const priorDialogueAttributed = buildAttributedDialogue(state);
-        decision = await deps.screener.invoke({
-            clientUser,
-            counterpartyUser,
-            ...(counterpartyContext && { counterpartyContext }),
-            ...(clientMemory.length > 0 && { memory: clientMemory }),
-            // discoveryQuery belongs to the discovery session's source user; only
-            // meaningful for the client when the client holds the source side.
-            ...(clientIsSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
-            seedAssessment: state.seedAssessment,
-            indexContext: state.indexContext,
-            isContinuation: state.isContinuation,
-            ...(state.messages.length > 0 && { priorDialogue: turnsFromMessages(state.messages) }),
-            ...(priorDialogueAttributed && { priorDialogueAttributed }),
-        });
-    }
-    catch (err) {
-        // Fail open: a screen failure must never block a negotiation.
-        failedOpen = true;
-        screenError = err instanceof Error ? err.message : String(err);
-        screenNodeLog.warn("Screen failed; proceeding open (reach_out)", {
-            taskId: state.taskId,
-            opportunityId: state.opportunityId || undefined,
-            error: screenError,
-        });
-        decision = {
-            decision: "reach_out",
-            reasoning: `screen_error: ${screenError}`,
-            evidence: { counterpartyPremiseFit: "", intentAlignment: "" },
-        };
-    }
-    const durationMs = Date.now() - start;
-    const record = {
-        ...decision,
-        mode,
-        ...(failedOpen && { failedOpen, error: screenError }),
-        screenedAt: new Date().toISOString(),
-        durationMs,
-    };
-    await deps.database.setTaskScreenDecision?.(state.taskId, record, state.continuationExecution).catch((err) => {
-        screenNodeLog.error("Failed to persist screen decision", { taskId: state.taskId, error: err });
-    });
-    screenNodeLog.info("negotiation_screen", {
-        taskId: state.taskId,
-        opportunityId: state.opportunityId || undefined,
-        decision: decision.decision,
-        mode,
-        failedOpen,
-        durationMs,
-    });
-    if (state.opportunityId) {
-        emitWide({
-            type: "negotiation_screen",
-            opportunityId: state.opportunityId,
-            negotiationConversationId: state.conversationId,
-            decision: decision.decision,
-            reasoning: decision.reasoning,
-            mode,
-            failedOpen,
-            durationMs,
-        });
-    }
-    // Routing happens on the conditional edge: shadow always proceeds to
-    // the first turn; enforce routes a (non-failed-open) pass to finalize.
-    return { screenDecision: record, memoryBySide: { [clientSide]: clientMemory } };
-}

package/dist/negotiations/negotiation.graph.shared.d.ts

@@ -1,111 +0,0 @@
-/**
- * Shared vocabulary for the negotiation graph's nodes.
- *
- * The nodes were closures inside `NegotiationGraphFactory.createGraph()`,
- * capturing the injected database, dispatcher and queues. They are top-level
- * functions now, each taking an explicit {@link NegotiationGraphDeps}; this
- * module owns the bag itself and the helpers more than one node needs.
- */
-import type { NegotiationGraphDatabase } from "../shared/interfaces/database.interface.js";
-import type { NegotiationTimeoutQueue } from "../shared/interfaces/negotiation-events.interface.js";
-import type { AgentDispatcher } from "../shared/interfaces/agent-dispatcher.interface.js";
-import { NegotiationGraphState, type NegotiationTurn, type UserNegotiationContext } from "./negotiation.state.js";
-import { IndexNegotiator } from "./negotiation.agent.js";
-import { NegotiationScreener } from "./negotiation.screen.js";
-import type { QuestionerEnqueueFn } from "../questions/question.module.js";
-import type { ReflectEnqueueFn } from "./negotiation.reflect.js";
-import type { NegotiatorMemoryEntry, NegotiatorMemoryRetrieveFn, NegotiatorMemoryScope } from "./negotiation.memory.js";
-import type { NegotiatorClientDmMessage, NegotiatorClientDmRetrieveFn } from "./negotiation.client-dm.js";
-import type { NegotiationStallGapAuthor } from "./negotiation.stall-gap.js";
-import { type AttributedPriorDialogue, type TaskAttribution } from './negotiation.attribution.js';
-/** The graph's channel state, as every node sees it. */
-export type NegotiationState = typeof NegotiationGraphState.State;
-/** Everything the negotiation nodes reach for. Composed once by the factory. */
-export interface NegotiationGraphDeps {
-    database: NegotiationGraphDatabase;
-    dispatcher: AgentDispatcher;
-    timeoutQueue?: NegotiationTimeoutQueue;
-    questionerEnqueue?: QuestionerEnqueueFn;
-    reflectEnqueue?: ReflectEnqueueFn;
-    memoryRetrieve?: NegotiatorMemoryRetrieveFn;
-    /**
-     * A2H read path: the acting user's own negotiator DM for this signal.
-     * System-agent grounding only — see `negotiation.client-dm.ts`; this must
-     * never be forwarded to an external seat via `NegotiationTurnPayload`.
-     */
-    clientDmRetrieve?: NegotiatorClientDmRetrieveFn;
-    /** In-process negotiator used when no personal agent answers. */
-    systemAgent: IndexNegotiator;
-    /** Authors the post-stall gap question at finalize (park-on-stall). */
-    stallGapAuthor?: NegotiationStallGapAuthor;
-    /** Outreach gate for fresh negotiations. */
-    screener: NegotiationScreener;
-}
-export declare const logger: import("../shared/observability/log.js").LoggerWithSource;
-export declare const initLog: import("../shared/observability/log.js").LoggerWithSource;
-export declare const screenNodeLog: import("../shared/observability/log.js").LoggerWithSource;
-export declare const turnLog: import("../shared/observability/log.js").LoggerWithSource;
-export declare const finalizeLog: import("../shared/observability/log.js").LoggerWithSource;
-export declare const negotiateCandidatesLog: import("../shared/observability/log.js").LoggerWithSource;
-/** Extracts the ordered NegotiationTurn list from A2A message data parts. */
-export declare function turnsFromMessages(messages: Array<{
-    parts: unknown[];
-}>): NegotiationTurn[];
-/**
- * Whether `userId`'s side has already spent its one `ask_user` client
- * consultation in THIS negotiation (P3.2 rationing: max one per negotiation per
- * side). Callers pass `state.messages`, which carries this negotiation's turns
- * across all of its sessions — so an earlier session of the same negotiation
- * counts, while a consultation spent on a different match with the same
- * counterparty does not.
- */
-export declare function hasPriorAskUser(messages: Array<{
-    senderId: string;
-    parts: unknown[];
-}>, userId: string): boolean;
-/**
- * How many ask rounds this negotiation has already spent, BOTH sides combined.
- * A round is one persisted `ask_user` park — a mid-flight client consultation
- * or a post-stall park — each of which suspends the negotiation on a human
- * answer. Same substrate as {@link hasPriorAskUser} (the negotiation's own
- * message record, spanning all of its sessions), read negotiation-wide rather
- * than per side: the cap this feeds bounds the park → answer → resume loop for
- * the negotiation as a whole, so two agents cannot ping-pong their humans
- * indefinitely.
- */
-export declare function countNegotiationAskRounds(messages: Array<{
-    senderId: string;
-    parts: unknown[];
-}>): number;
-/**
- * P5.3 memory retrieval — never throws, never blocks a negotiation. The
- * injected fn already resolves [] when NEGOTIATOR_MEMORY_INJECT is off;
- * this wrapper adds the graph-side failure guard.
- */
-export declare function retrieveMemory(deps: NegotiationGraphDeps, userId: string, counterpartyUserId: string, queryText: string, scope: NegotiatorMemoryScope): Promise<NegotiatorMemoryEntry[]>;
-/**
- * A2H client-DM retrieval — never throws, never blocks a negotiation. The
- * injected fn already resolves [] when the flag is off or the user has no
- * negotiator DM for this signal; this wrapper adds the graph-side failure
- * guard, exactly as `retrieveMemory` does for the memory seam.
- *
- * `userId` is always the ACTING user's — the seam has no counterparty field,
- * so the counterparty's DM cannot be requested from here.
- */
-export declare function retrieveClientDm(deps: NegotiationGraphDeps, userId: string, intentId: string): Promise<NegotiatorClientDmMessage[]>;
-/** Similarity query text: seed reasoning + counterparty context. */
-export declare function memoryQueryText(state: NegotiationState, counterparty: UserNegotiationContext): string;
-/**
- * IND-569: resolve a prior negotiation task's attribution metadata for the
- * per-opportunity prior-dialogue labels. Never throws — any failure returns
- * null so the turns degrade to the unattributed block instead of leaking
- * into the current opportunity's context.
- */
-export declare function resolveTaskAttribution(deps: NegotiationGraphDeps, taskId: string): Promise<TaskAttribution | null>;
-/**
- * IND-569: build the attributed prior dialogue passed to the screener and
- * turn prompts. Combines the immutable seeded attribution (earlier + legacy
- * unattributed blocks, resolved once in init) with this session's own turns
- * (task-id-matched). Null when there is no seeded attribution.
- */
-export declare function buildAttributedDialogue(state: NegotiationState): AttributedPriorDialogue | null;