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

package/dist/negotiations/negotiation.answer-consumption.d.ts

@@ -1,223 +0,0 @@
-/**
- * Answer consumption: route a client's DM reply to its parked negotiations and
- * resume them (conversational-questions plan, "Answers").
- *
- * The delivery surface decides that a chat reply answers a question-message
- * and maps the reply's content onto block refs; this module owns everything
- * after that decision — the RESUME SEAM. Given a routed answer and the block
- * it answers, it re-resolves each referenced negotiation to its current park
- * and resumes it exactly once:
- *
- * - A mid-flight consult park (`input_required` task with a captured ask-user
- *   binding) resumes through the same durable settlement → exact continuation
- *   path the card answer used: settle the exact task, then enqueue the
- *   settlement-keyed resume. The settle is a CAS on the parked task, so a
- *   second delivery finds it already settled and only re-enqueues the
- *   idempotent continuation — never a double resume.
- * - A post-stall park (completed task on a stalled opportunity whose trailing
- *   turn is the authored `ask_user` gap, `NEGOTIATION_PARK_REASONING`) resumes
- *   as a fresh negotiation attempt: the answer is recorded on the opportunity
- *   (where continuation prompts already read it via
- *   `getOpportunityUserAnswers`) and a retry is enqueued. Exactly-once is the
- *   attempt claim: concurrent retries race `createNegotiationTaskForAttempt`
- *   and all but one lose.
- *
- * Idempotency is a property of the negotiation, not of any settlement record
- * kept here: re-resolution + the `input_required` admission gate (mid-flight)
- * and the atomic attempt claim (post-stall) make a repeated delivery a no-op.
- * A ref that matches nothing in the block resumes NOTHING — misrouting resumes
- * the wrong negotiation with the wrong fact, which is worse than asking again —
- * and is reported back so the delivery surface can ask a clarifying follow-up.
- *
- * A resumed negotiation may park again; the ask-rounds cap (#1430) bounds that
- * loop at park time. This module deliberately adds no second counter.
- */
-import type { NegotiationGraphDatabase, NegotiationUserAnswer } from "../shared/interfaces/database.interface.js";
-import type { QuestionBlock, QuestionBlockQuestion } from "../shared/schemas/question-block.schema.js";
-/** One answer the delivery agent routed onto a block ref. */
-export interface RoutedAnswer {
-    /** The block ref the reply was matched to — primary or alsoUnblocks alike. */
-    ref: string;
-    /** The client's answer for that question, as free text. */
-    answerText: string;
-}
-/** A resolved route: the owning question and every negotiation its answer resumes. */
-export interface AnswerRoute {
-    question: QuestionBlockQuestion;
-    /** Primary first, then `alsoUnblocks` — one answer resumes them all. */
-    opportunityIds: string[];
-}
-/**
- * Resolve a matched ref to its question and full resume set. The block schema
- * guarantees every ref appears exactly once across the whole block, so this is
- * a lookup — ambiguity is a producer-side error that cannot reach here through
- * a parsed block. Returns null for a ref the block does not carry: the caller
- * must ask a clarifying follow-up, never resume speculatively.
- */
-export declare function routeAnswerRef(block: QuestionBlock, ref: string): AnswerRoute | null;
-/** The minimal ask-user binding a mid-flight resume needs, read off task metadata. */
-interface AskUserResumeBinding {
-    settlementId: string;
-    recipientUserId: string;
-    recipientIntentId: string;
-    networkId: string;
-    opportunityId: string;
-}
-/** What answering a given ref would resume, as re-resolved right now. */
-export type ParkClassification = {
-    kind: "inflight";
-    taskId: string;
-    binding: AskUserResumeBinding;
-} | {
-    kind: "post_stall";
-    taskId: string;
-}
-/** No negotiation task exists for the ref at all. */
- | {
-    kind: "no_negotiation";
-}
-/** A negotiation exists but holds no live park — already resumed, expired, or terminal. */
- | {
-    kind: "not_parked";
-}
-/** Parked, but awaiting the OTHER side's client — this user's answer must not resume it. */
- | {
-    kind: "wrong_recipient";
-};
-/**
- * Re-resolve a negotiation ref to its current park. This is the exact task
- * re-resolution the graph itself uses (`getNegotiationTaskForOpportunity`),
- * never a snapshot: answer routing branches on what the negotiation is NOW,
- * so a park that was answered, expired, or superseded since the block was
- * authored classifies as `not_parked` and the answer no-ops.
- */
-export declare function classifyParkedNegotiation(database: Pick<NegotiationGraphDatabase, "getNegotiationTaskForOpportunity" | "getNegotiationMessages">, input: {
-    opportunityId: string;
-    userId: string;
-}): Promise<ParkClassification>;
-/** Everything a mid-flight settle needs; all fields come from the re-resolved binding. */
-export interface InflightAnswerSettlementInput {
-    taskId: string;
-    settlementId: string;
-    opportunityId: string;
-    recipientUserId: string;
-    recipientIntentId: string;
-    networkId: string;
-    answer: {
-        selectedOptions: string[];
-        freeText?: string;
-        answeredAt: string;
-    };
-}
-/**
- * - `settled`: this call closed the exact `input_required` task and durably
- *   stored the answer for the continuation claim to read.
- * - `already_settled`: an earlier delivery settled it; the stored settlement
- *   stands. Resuming is still correct — the continuation enqueue and claim are
- *   settlement-keyed and idempotent, so re-enqueueing recovers a lost job
- *   without a double resume.
- * - `lost`: the admission gate refused — the task is no longer
- *   `input_required` (answer-window expiry or another path won). No resume.
- */
-export type InflightAnswerSettlementResult = "settled" | "already_settled" | "lost";
-export interface NegotiationAnswerConsumptionPorts {
-    /** The same reads the negotiation graph resolves parks with. */
-    database: Pick<NegotiationGraphDatabase, "getNegotiationTaskForOpportunity" | "getNegotiationMessages">;
-    /**
-     * Settle the exact mid-flight consult: CAS the `input_required` task closed
-     * under the deterministic settlement lock and durably store the answer where
-     * the continuation claim reads its private consultation. Implementations
-     * must be answer-vs-timeout safe (the expiry worker races this) and must
-     * report a repeat delivery as `already_settled`, never settle twice.
-     */
-    settleInflightAnswer(input: InflightAnswerSettlementInput): Promise<InflightAnswerSettlementResult>;
-    /**
-     * Enqueue the exact durable continuation — the same settlement-keyed resume
-     * the card answer path enqueues. Must be idempotent per settlementId.
-     */
-    enqueueInflightResume(input: {
-        opportunityId: string;
-        userId: string;
-        taskId: string;
-        settlementId: string;
-        recipientIntentId: string;
-        networkId: string;
-    }): Promise<void>;
-    /**
-     * Append the routed answer to the opportunity's `userAnswers`, where
-     * continuation prompts already read between-session context. Implementations
-     * MUST ignore an append whose `questionId` is already present — that key is
-     * deterministic per park, so a repeated delivery records nothing twice.
-     */
-    recordOpportunityAnswer(input: {
-        opportunityId: string;
-        answer: NegotiationUserAnswer;
-    }): Promise<void>;
-    /**
-     * Enqueue a fresh negotiate-existing retry of the stalled opportunity.
-     * `parkTaskId` identifies the answered park; implementations should dedupe
-     * on it. Over-enqueueing is safe regardless: every retry races the atomic
-     * attempt claim and all but one lose.
-     */
-    enqueueStalledRetry(input: {
-        opportunityId: string;
-        userId: string;
-        parkTaskId: string;
-    }): Promise<void>;
-}
-/** Deterministic identity of a post-stall park's recorded answer (dedup key, never rendered). */
-export declare function negotiationParkAnswerId(parkTaskId: string): string;
-export type NegotiationAnswerResumeOutcome = "resumed_inflight" | "resumed_retry" | "not_parked" | "no_negotiation" | "wrong_recipient";
-export interface NegotiationAnswerInput {
-    /** The negotiation to resume: one ref out of a routed answer's resume set. */
-    opportunityId: string;
-    /** The answering client — the park must be awaiting THIS user's side. */
-    userId: string;
-    answerText: string;
-    /** ISO timestamp of the reply; defaults to now. */
-    answeredAt?: string;
-}
-/**
- * Resume one parked negotiation with a routed answer, exactly once. Both
- * outcomes that resume enqueue asynchronously — the negotiation continues on
- * its queue, not inline. Every other outcome resumes nothing. Throws only on
- * port failure; every step is safe to repeat, so the caller may simply
- * redeliver.
- */
-export declare function resumeParkedNegotiation(ports: NegotiationAnswerConsumptionPorts, input: NegotiationAnswerInput): Promise<NegotiationAnswerResumeOutcome>;
-export interface QuestionBlockAnswerConsumptionInput {
-    /** The parsed block the reply answers (see `parseQuestionMessage`). */
-    block: QuestionBlock;
-    /** The replying client — the DM's owner. */
-    userId: string;
-    /** The reply's content routed onto block refs; empty when nothing matched. */
-    answers: RoutedAnswer[];
-    /** ISO timestamp of the reply; defaults to now. */
-    answeredAt?: string;
-}
-export interface QuestionBlockAnswerConsumptionResult {
-    resumed: Array<{
-        opportunityId: string;
-        outcome: "resumed_inflight" | "resumed_retry";
-    }>;
-    skipped: Array<{
-        opportunityId: string;
-        outcome: "not_parked" | "no_negotiation" | "wrong_recipient" | "duplicate_route" | "failed";
-    }>;
-    /** Routed answers whose ref the block does not carry — resume nothing, ask again. */
-    unmatched: RoutedAnswer[];
-    /**
-     * True when the reply left something unresolved on the routing side: no
-     * answer matched at all, or a ref matched nothing in the block. The caller
-     * owns the clarifying follow-up; this seam only ever refuses to guess.
-     */
-    needsClarification: boolean;
-}
-/**
- * Consume a client reply against the block it answers: resolve each routed
- * answer to its question, then resume the primary negotiation and every
- * `alsoUnblocks` ref with that answer, exactly once each. Failures are
- * per-negotiation — one broken target never blocks the rest of the reply.
- */
-export declare function consumeQuestionBlockAnswers(ports: NegotiationAnswerConsumptionPorts, input: QuestionBlockAnswerConsumptionInput): Promise<QuestionBlockAnswerConsumptionResult>;
-export {};

package/dist/negotiations/negotiation.answer-consumption.js

@@ -1,275 +0,0 @@
-/**
- * Answer consumption: route a client's DM reply to its parked negotiations and
- * resume them (conversational-questions plan, "Answers").
- *
- * The delivery surface decides that a chat reply answers a question-message
- * and maps the reply's content onto block refs; this module owns everything
- * after that decision — the RESUME SEAM. Given a routed answer and the block
- * it answers, it re-resolves each referenced negotiation to its current park
- * and resumes it exactly once:
- *
- * - A mid-flight consult park (`input_required` task with a captured ask-user
- *   binding) resumes through the same durable settlement → exact continuation
- *   path the card answer used: settle the exact task, then enqueue the
- *   settlement-keyed resume. The settle is a CAS on the parked task, so a
- *   second delivery finds it already settled and only re-enqueues the
- *   idempotent continuation — never a double resume.
- * - A post-stall park (completed task on a stalled opportunity whose trailing
- *   turn is the authored `ask_user` gap, `NEGOTIATION_PARK_REASONING`) resumes
- *   as a fresh negotiation attempt: the answer is recorded on the opportunity
- *   (where continuation prompts already read it via
- *   `getOpportunityUserAnswers`) and a retry is enqueued. Exactly-once is the
- *   attempt claim: concurrent retries race `createNegotiationTaskForAttempt`
- *   and all but one lose.
- *
- * Idempotency is a property of the negotiation, not of any settlement record
- * kept here: re-resolution + the `input_required` admission gate (mid-flight)
- * and the atomic attempt claim (post-stall) make a repeated delivery a no-op.
- * A ref that matches nothing in the block resumes NOTHING — misrouting resumes
- * the wrong negotiation with the wrong fact, which is worse than asking again —
- * and is reported back so the delivery surface can ask a clarifying follow-up.
- *
- * A resumed negotiation may park again; the ask-rounds cap (#1430) bounds that
- * loop at park time. This module deliberately adds no second counter.
- */
-import { NEGOTIATION_PARK_REASONING } from "./negotiation.stall-gap.js";
-import { negotiationQuestionSettlementId } from "./negotiation.question-safety.js";
-import { turnsFromMessages } from "./negotiation.graph.shared.js";
-import { protocolLogger } from "../shared/observability/protocol.logger.js";
-const answerLog = protocolLogger("NegotiationAnswerConsumption");
-/**
- * Resolve a matched ref to its question and full resume set. The block schema
- * guarantees every ref appears exactly once across the whole block, so this is
- * a lookup — ambiguity is a producer-side error that cannot reach here through
- * a parsed block. Returns null for a ref the block does not carry: the caller
- * must ask a clarifying follow-up, never resume speculatively.
- */
-export function routeAnswerRef(block, ref) {
-    for (const question of block.questions) {
-        const opportunityIds = [question.opportunityId, ...(question.alsoUnblocks ?? [])];
-        if (opportunityIds.includes(ref))
-            return { question, opportunityIds };
-    }
-    return null;
-}
-function nonEmptyString(value) {
-    return typeof value === "string" && value.length > 0;
-}
-function readAskUserResumeBinding(metadata) {
-    const turnContext = metadata?.turnContext;
-    const binding = turnContext?.askUserBinding;
-    if (!binding
-        || !nonEmptyString(binding.settlementId)
-        || !nonEmptyString(binding.recipientUserId)
-        || !nonEmptyString(binding.recipientIntentId)
-        || !nonEmptyString(binding.networkId)
-        || !nonEmptyString(binding.opportunityId))
-        return null;
-    return {
-        settlementId: binding.settlementId,
-        recipientUserId: binding.recipientUserId,
-        recipientIntentId: binding.recipientIntentId,
-        networkId: binding.networkId,
-        opportunityId: binding.opportunityId,
-    };
-}
-/**
- * The trailing canonical turn of a negotiation's own messages, when it is the
- * authored post-stall gap. Non-turn messages are skipped, mirroring
- * `turnsFromMessages`; any other trailing turn means the negotiation is not
- * parked post-stall.
- */
-function trailingParkMessage(messages) {
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const message = messages[index];
-        const turn = turnsFromMessages([message])[0];
-        if (!turn)
-            continue;
-        return turn.action === "ask_user" && turn.assessment?.reasoning === NEGOTIATION_PARK_REASONING
-            ? { senderId: message.senderId, taskId: message.taskId, turn }
-            : null;
-    }
-    return null;
-}
-/**
- * Re-resolve a negotiation ref to its current park. This is the exact task
- * re-resolution the graph itself uses (`getNegotiationTaskForOpportunity`),
- * never a snapshot: answer routing branches on what the negotiation is NOW,
- * so a park that was answered, expired, or superseded since the block was
- * authored classifies as `not_parked` and the answer no-ops.
- */
-export async function classifyParkedNegotiation(database, input) {
-    const task = await database.getNegotiationTaskForOpportunity(input.opportunityId);
-    if (!task)
-        return { kind: "no_negotiation" };
-    if (task.state === "input_required") {
-        const binding = readAskUserResumeBinding(task.metadata);
-        if (!binding
-            || binding.opportunityId !== input.opportunityId
-            || binding.settlementId !== negotiationQuestionSettlementId(task.id)) {
-            answerLog.warn("input_required negotiation task carries no coherent ask-user binding; answer cannot resume it", {
-                taskId: task.id,
-                opportunityId: input.opportunityId,
-            });
-            return { kind: "not_parked" };
-        }
-        if (binding.recipientUserId !== input.userId)
-            return { kind: "wrong_recipient" };
-        return { kind: "inflight", taskId: task.id, binding };
-    }
-    if (task.state === "completed") {
-        const messages = await database.getNegotiationMessages(input.opportunityId);
-        const park = trailingParkMessage(messages);
-        if (!park)
-            return { kind: "not_parked" };
-        // The gap was written by the finalizing session's task — the most recent
-        // one. A trailing park from an older task means state has moved on.
-        if (park.taskId != null && park.taskId !== task.id)
-            return { kind: "not_parked" };
-        if (park.senderId !== `agent:${input.userId}`)
-            return { kind: "wrong_recipient" };
-        return { kind: "post_stall", taskId: task.id };
-    }
-    // submitted/working/waiting_for_agent: a session is live (possibly the very
-    // resume a first delivery triggered); canceled: a settled consult awaiting
-    // its successor; failed/rejected: terminal. None hold an answerable park.
-    return { kind: "not_parked" };
-}
-/** Deterministic identity of a post-stall park's recorded answer (dedup key, never rendered). */
-export function negotiationParkAnswerId(parkTaskId) {
-    return `negotiation-park-answer-v1-${parkTaskId}`;
-}
-/**
- * Resume one parked negotiation with a routed answer, exactly once. Both
- * outcomes that resume enqueue asynchronously — the negotiation continues on
- * its queue, not inline. Every other outcome resumes nothing. Throws only on
- * port failure; every step is safe to repeat, so the caller may simply
- * redeliver.
- */
-export async function resumeParkedNegotiation(ports, input) {
-    const classification = await classifyParkedNegotiation(ports.database, {
-        opportunityId: input.opportunityId,
-        userId: input.userId,
-    });
-    const answeredAt = input.answeredAt ?? new Date().toISOString();
-    if (classification.kind === "inflight") {
-        const settlement = await ports.settleInflightAnswer({
-            taskId: classification.taskId,
-            settlementId: classification.binding.settlementId,
-            opportunityId: input.opportunityId,
-            recipientUserId: classification.binding.recipientUserId,
-            recipientIntentId: classification.binding.recipientIntentId,
-            networkId: classification.binding.networkId,
-            answer: { selectedOptions: [], freeText: input.answerText, answeredAt },
-        });
-        if (settlement === "lost") {
-            answerLog.info("negotiation_answer_settlement_lost", {
-                taskId: classification.taskId,
-                opportunityId: input.opportunityId,
-            });
-            return "not_parked";
-        }
-        // Settlement is durable; enqueue after it, never before — a crash between
-        // the two is recovered by redelivery (`already_settled` → enqueue again).
-        await ports.enqueueInflightResume({
-            opportunityId: input.opportunityId,
-            userId: classification.binding.recipientUserId,
-            taskId: classification.taskId,
-            settlementId: classification.binding.settlementId,
-            recipientIntentId: classification.binding.recipientIntentId,
-            networkId: classification.binding.networkId,
-        });
-        answerLog.info("negotiation_answer_resumed_inflight", {
-            taskId: classification.taskId,
-            opportunityId: input.opportunityId,
-            settlement,
-        });
-        return "resumed_inflight";
-    }
-    if (classification.kind === "post_stall") {
-        // Record before enqueueing: the retry's continuation prompt must see the
-        // answer. The deterministic id makes the append idempotent, so the
-        // crash-recovery order (record, then enqueue, redeliver on failure) holds.
-        await ports.recordOpportunityAnswer({
-            opportunityId: input.opportunityId,
-            answer: {
-                questionId: negotiationParkAnswerId(classification.taskId),
-                selectedOptions: [],
-                freeText: input.answerText,
-                answeredAt,
-            },
-        });
-        await ports.enqueueStalledRetry({
-            opportunityId: input.opportunityId,
-            userId: input.userId,
-            parkTaskId: classification.taskId,
-        });
-        answerLog.info("negotiation_answer_resumed_retry", {
-            taskId: classification.taskId,
-            opportunityId: input.opportunityId,
-        });
-        return "resumed_retry";
-    }
-    if (classification.kind === "wrong_recipient") {
-        answerLog.warn("Answer routed to a negotiation parked on the counterparty's side; not resuming", {
-            opportunityId: input.opportunityId,
-        });
-    }
-    return classification.kind;
-}
-/**
- * Consume a client reply against the block it answers: resolve each routed
- * answer to its question, then resume the primary negotiation and every
- * `alsoUnblocks` ref with that answer, exactly once each. Failures are
- * per-negotiation — one broken target never blocks the rest of the reply.
- */
-export async function consumeQuestionBlockAnswers(ports, input) {
-    const answeredAt = input.answeredAt ?? new Date().toISOString();
-    const result = {
-        resumed: [],
-        skipped: [],
-        unmatched: [],
-        needsClarification: false,
-    };
-    const consumedQuestions = new Set();
-    for (const answer of input.answers) {
-        const route = routeAnswerRef(input.block, answer.ref);
-        if (!route) {
-            result.unmatched.push(answer);
-            continue;
-        }
-        // Two routed answers can name refs of the same question; the first wins.
-        // The later one is surfaced as a duplicate rather than silently merged —
-        // choosing between conflicting phrasings is the delivery agent's job.
-        if (consumedQuestions.has(route.question.opportunityId)) {
-            result.skipped.push({ opportunityId: route.question.opportunityId, outcome: "duplicate_route" });
-            continue;
-        }
-        consumedQuestions.add(route.question.opportunityId);
-        for (const opportunityId of route.opportunityIds) {
-            try {
-                const outcome = await resumeParkedNegotiation(ports, {
-                    opportunityId,
-                    userId: input.userId,
-                    answerText: answer.answerText,
-                    answeredAt,
-                });
-                if (outcome === "resumed_inflight" || outcome === "resumed_retry") {
-                    result.resumed.push({ opportunityId, outcome });
-                }
-                else {
-                    result.skipped.push({ opportunityId, outcome });
-                }
-            }
-            catch (err) {
-                answerLog.error("Failed to resume an answered negotiation; continuing with the rest of the reply", {
-                    opportunityId,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                result.skipped.push({ opportunityId, outcome: "failed" });
-            }
-        }
-    }
-    result.needsClarification = input.answers.length === 0 || result.unmatched.length > 0;
-    return result;
-}

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

@@ -1,91 +0,0 @@
-import type { NegotiationTurn } from "./negotiation.state.js";
-/**
- * Prior-dialogue attribution (IND-569).
- *
- * On a continuation negotiation the negotiator agent is seeded with every
- * prior turn this pair exchanged — across ALL past opportunities on the shared
- * DM. Rendered flat, the agent cannot tell which turns belonged to a different,
- * already-concluded opportunity versus the one it is negotiating right now.
- * That undifferentiated context lets stale turns from another opportunity read
- * as if they were part of the current exchange (and, since they cross a trust
- * boundary into the prompt, as if they were current instructions).
- *
- * This module groups seeded prior turns by their originating opportunity so the
- * prompt can label each earlier negotiation explicitly, keep legacy
- * unattributed turns in their own block, and separate the current opportunity's
- * own turns. The grouping is pure (DB access is injected via `resolveTask`) so
- * it is unit-testable without a live database.
- */
-/** Best-effort attribution metadata for one prior negotiation task. */
-export interface TaskAttribution {
-    /** The opportunity the task negotiated (grouping key). Null when unresolved. */
-    opportunityId: string | null;
-    /** Human-facing intent/opportunity title for the header (best-effort). */
-    opportunityTitle: string | null;
-    /** Coarse conclusion label (e.g. `accepted` | `declined` | `not pursued`). */
-    outcome: string | null;
-    /** ISO timestamp the prior negotiation concluded (task.updatedAt), or null. */
-    concludedAt: string | null;
-}
-/** A concluded prior negotiation on a DIFFERENT opportunity with this counterparty. */
-export interface EarlierNegotiationGroup {
-    /** Opportunity id (grouping key). */
-    opportunityId: string;
-    /** Human-facing intent/opportunity title; null when it could not be resolved. */
-    opportunityTitle: string | null;
-    /** Coarse conclusion label; null when it could not be resolved. */
-    outcome: string | null;
-    /** ISO timestamp the prior negotiation concluded, or null. */
-    concludedAt: string | null;
-    /** The turns exchanged in that earlier negotiation, in order. */
-    turns: NegotiationTurn[];
-}
-/**
- * The immutable slice of attributed prior dialogue derived once from the
- * seeded prior messages (init node): everything that existed before this
- * session's task. `currentSeeded` holds prior turns that belong to the SAME
- * opportunity now being negotiated (e.g. an earlier session of it), which must
- * join the current block rather than an earlier one.
- */
-export interface SeededAttribution {
-    earlier: EarlierNegotiationGroup[];
-    unattributed: NegotiationTurn[];
-    currentSeeded: NegotiationTurn[];
-}
-/**
- * Attributed prior dialogue passed to the negotiator agent and the outreach
- * screener (IND-569). `current` combines same-opportunity seeded turns with
- * the turns exchanged in this session.
- */
-export interface AttributedPriorDialogue {
-    /** Prior concluded negotiations on OTHER opportunities, grouped + labeled. */
-    earlier: EarlierNegotiationGroup[];
-    /** Legacy/unattributed prior turns (null task_id) — never mixed into current. */
-    unattributed: NegotiationTurn[];
-    /** The current opportunity's own turns (same-opportunity seeded + this session). */
-    current: NegotiationTurn[];
-}
-/** True when the attributed dialogue carries no turns in any block. */
-export declare function attributedDialogueIsEmpty(d: AttributedPriorDialogue): boolean;
-/**
- * Partition seeded prior turns into earlier-opportunity groups, an unattributed
- * block, and same-opportunity turns. Pure over the injected `resolveTask` — the
- * caller supplies a DB-backed resolver (graph) or a fake (tests). Any task that
- * fails to resolve, or carries no opportunity, degrades to the unattributed
- * block so an attribution failure NEVER leaks a stale turn into the current
- * opportunity's context.
- */
-export declare function buildSeededAttribution(entries: Array<{
-    taskId?: string | null;
-    turn: NegotiationTurn;
-}>, currentOpportunityId: string, resolveTask: (taskId: string) => Promise<TaskAttribution | null>): Promise<SeededAttribution>;
-/** Combine the immutable seeded attribution with this session's own turns. */
-export declare function combineAttributedDialogue(seeded: SeededAttribution, currentSessionTurns: NegotiationTurn[]): AttributedPriorDialogue;
-/**
- * Render the attributed prior dialogue into labeled prompt blocks. `formatTurn`
- * lets each surface (negotiator agent / screener) keep its own per-turn line
- * format while sharing the block structure. Only non-empty blocks are emitted;
- * earlier and unattributed blocks are re-indexed from 1 within their block so
- * turn numbers never imply a single flat exchange across opportunities.
- */
-export declare function renderAttributedPriorDialogue(dialogue: AttributedPriorDialogue, formatTurn: (turn: NegotiationTurn, index: number) => string): string;