@indexnetwork/protocol 14.3.2-rc.477.1 → 16.1.1-rc.478.1

package/dist/negotiations/application/negotiation.graph.finalize.js

@@ -0,0 +1,280 @@
+/**
+ * Negotiation graph, stage 4: persist the outcome and fan out follow-ups.
+ */
+import { requestContext } from "../../shared/observability/request-context.js";
+import { isRejectLikeAction, isTerminalAction } from "../domain/negotiation.protocol.js";
+import { blocksNegotiationBeforeFirstTurn } from "./negotiation.screen.js";
+import { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK } from '../domain/negotiation.question-safety.js';
+import { isNegotiationTurnCapReached } from "../domain/negotiation.turn-cap.js";
+import { finalizeLog, turnsFromMessages } from "./negotiation.graph.shared.js";
+export async function finalizeNode(state, deps) {
+    const traceEmitter = requestContext.getStore()?.traceEmitter;
+    const emitWide = (event) => traceEmitter?.(event);
+    const pauseReceipt = (outcome) => state.continuationExecution
+        ? {
+            continuationReceipt: {
+                priorTaskId: state.continuationExecution.taskId,
+                settlementId: state.continuationExecution.settlementId,
+                successorTaskId: state.continuationExecution.successorTaskId,
+                fence: state.continuationExecution.fence,
+                outcome,
+            },
+        }
+        : undefined;
+    if (state.status === 'waiting_for_agent') {
+        if (state.opportunityId) {
+            emitWide({
+                type: "negotiation_outcome",
+                opportunityId: state.opportunityId,
+                outcome: "waiting_for_agent",
+                turnCount: state.turnCount,
+                isContinuation: state.isContinuation,
+            });
+        }
+        return pauseReceipt('waiting_for_agent') ?? {};
+    }
+    // ask_user pause: no outcome, no completed state — the task stays
+    // input_required until the client answers or the window expires.
+    if (state.status === 'input_required') {
+        if (state.opportunityId) {
+            emitWide({
+                type: "negotiation_outcome",
+                opportunityId: state.opportunityId,
+                outcome: "input_required",
+                turnCount: state.turnCount,
+                isContinuation: state.isContinuation,
+            });
+        }
+        return pauseReceipt('input_required') ?? {};
+    }
+    // Init can fail closed before an attempt owns a task. Such a rejection is
+    // not a completed negotiation and must not write through an empty task ID,
+    // create an artifact, or advance the opportunity lifecycle.
+    if (!state.taskId) {
+        finalizeLog.info('Skipping outcome persistence because no negotiation task was claimed', {
+            opportunityId: state.opportunityId || undefined,
+            error: state.error || undefined,
+        });
+        return {};
+    }
+    const history = turnsFromMessages(state.messages);
+    const lastTurn = state.lastTurn;
+    const hasOpportunity = lastTurn?.action === "accept";
+    // P2.2: the client's own outreach gate declined before any turn — the
+    // negotiation never happened from the counterparty's perspective.
+    // IND-564: an opening-move `withdraw` blocked before any message was
+    // persisted is the same quiet screen-out outcome (no in-task outreach to
+    // retract), reached from the turn node rather than the screen node.
+    // Two DISTINCT routes reach the same quiet `screened_out` outcome, and
+    // they disagree about who authored the decision:
+    //  - the screen node blocked before any turn was drafted → the screen
+    //    decision is the reason;
+    //  - the acting agent refused on its opening turn (IND-611) → the
+    //    withdrawing TURN is the reason.
+    // They are collapsed into `screenedOut` for status/lifecycle purposes but
+    // must stay separate when attributing `outcome.reasoning` below.
+    const blockedByScreenNode = blocksNegotiationBeforeFirstTurn(state.screenDecision, state.turnCount);
+    const refusedAtOpeningTurn = state.firstTurnScreenedOut === true;
+    const screenedOut = blockedByScreenNode || refusedAtOpeningTurn;
+    const atCap = !screenedOut && isNegotiationTurnCapReached(state.turnCount, state.maxTurns) && !isTerminalAction(lastTurn?.action);
+    let agreedRoles = [];
+    if (hasOpportunity && history.length >= 2) {
+        const acceptTurn = history[history.length - 1];
+        const precedingTurn = history[history.length - 2];
+        const accepterIsSource = state.currentSpeaker === "candidate";
+        const [sourceRole, candidateRole] = accepterIsSource
+            ? [acceptTurn.assessment.suggestedRoles.ownUser, precedingTurn.assessment.suggestedRoles.ownUser]
+            : [precedingTurn.assessment.suggestedRoles.ownUser, acceptTurn.assessment.suggestedRoles.ownUser];
+        agreedRoles = [
+            { userId: state.sourceUser.id, role: sourceRole },
+            { userId: state.candidateUser.id, role: candidateRole },
+        ];
+    }
+    const outcome = {
+        hasOpportunity,
+        agreedRoles,
+        // IND-611: attribute the reasoning to whoever actually made the
+        // decision. Before the turn-0 refusal path existed, `screenedOut`
+        // implied the screen node, so preferring `screenDecision.reasoning`
+        // was always right. It is now wrong for an opening-turn refusal taken
+        // while the screen said `reach_out`: that record argues FOR the match,
+        // and surfacing it as the reason the agent did NOT reach out is exactly
+        // the dishonesty this work removes (IND-610 renders this string in the
+        // owner-only gate-decision card). The screen-node branch is unchanged.
+        reasoning: blockedByScreenNode
+            ? (state.screenDecision?.reasoning ?? lastTurn?.assessment?.reasoning ?? "")
+            : refusedAtOpeningTurn
+                ? (lastTurn?.assessment?.reasoning ?? state.screenDecision?.reasoning ?? "")
+                : (lastTurn?.assessment.reasoning ?? ""),
+        turnCount: state.turnCount,
+        ...(screenedOut
+            ? { reason: "screened_out" }
+            : atCap
+                ? { reason: "turn_cap" }
+                : {}),
+    };
+    try {
+        await deps.database.updateTaskState(state.taskId, "completed", undefined, state.continuationExecution);
+        await deps.database.createArtifact({
+            taskId: state.taskId,
+            name: "negotiation-outcome",
+            parts: [{ kind: "data", data: outcome }],
+            metadata: {
+                hasOpportunity,
+                turnCount: state.turnCount,
+                ...(state.continuationExecution ? {
+                    continuationOutcome: hasOpportunity
+                        ? 'accepted'
+                        : (screenedOut || isRejectLikeAction(lastTurn?.action)) ? 'rejected' : 'stalled',
+                } : {}),
+            },
+            ...(state.continuationExecution ? { continuationExecution: state.continuationExecution } : {}),
+        });
+        finalizeLog.info('Session complete', {
+            conversationId: state.conversationId,
+            taskId: state.taskId,
+            isContinuation: state.isContinuation,
+            turnsAdded: state.turnCount,
+            priorTurnCount: state.priorTurnCount,
+            outcome: hasOpportunity ? 'accepted' : screenedOut ? 'screened_out' : (atCap ? 'turn_cap' : (lastTurn?.action ?? 'unknown')),
+            opportunityId: state.opportunityId || undefined,
+        });
+        if (state.opportunityId) {
+            // screened_out → 'rejected': quiet terminal status (hidden from
+            // default lists), never 'stalled' — with zero turns the generic
+            // mapping would misfile the client's own gate decision.
+            const nextStatus = lastTurn?.action === 'accept'
+                ? 'pending'
+                : (screenedOut || isRejectLikeAction(lastTurn?.action))
+                    ? 'rejected'
+                    : 'stalled';
+            await deps.database.updateOpportunityStatus(state.opportunityId, nextStatus, undefined, state.continuationExecution).catch((err) => {
+                finalizeLog.error("Failed to update opportunity status", { opportunityId: state.opportunityId, nextStatus, error: err });
+            });
+        }
+    }
+    catch (err) {
+        finalizeLog.error("Failed to persist outcome", { error: err });
+    }
+    if (state.opportunityId) {
+        const emittedOutcome = hasOpportunity
+            ? "accepted"
+            : screenedOut
+                ? "screened_out"
+                : atCap
+                    ? "turn_cap"
+                    : state.error && /timeout/i.test(state.error)
+                        ? "timed_out"
+                        : "rejected_stalled";
+        emitWide({
+            type: "negotiation_outcome",
+            opportunityId: state.opportunityId,
+            outcome: emittedOutcome,
+            turnCount: state.turnCount,
+            isContinuation: state.isContinuation,
+            turnsAdded: state.turnCount,
+            priorTurnCount: state.priorTurnCount,
+            ...(outcome.reasoning && { reasoning: outcome.reasoning }),
+            ...(hasOpportunity && agreedRoles.length >= 2 && {
+                agreedRoles: {
+                    ownUser: agreedRoles[0]?.role,
+                    otherUser: agreedRoles[1]?.role,
+                },
+            }),
+        });
+    }
+    if (state.consultationPolicyReason) {
+        // Stable, content-free terminal funnel telemetry. This executes only
+        // after a fenced continuation has reached its terminal outcome.
+        finalizeLog.info('negotiation_consultation_policy', {
+            stage: 'terminal_outcome',
+            reason: state.consultationPolicyReason,
+            outcome: hasOpportunity ? 'accepted' : (screenedOut || isRejectLikeAction(lastTurn?.action)) ? 'rejected' : 'stalled',
+        });
+        emitWide({
+            type: 'negotiation_consultation_policy',
+            stage: 'terminal_outcome',
+            reason: state.consultationPolicyReason,
+            outcome: hasOpportunity ? 'accepted' : (screenedOut || isRejectLikeAction(lastTurn?.action)) ? 'rejected' : 'stalled',
+        });
+    }
+    // Enqueue post-negotiation reflection (P5.2 memory write path) — fire
+    // and forget: a reflection failure must never affect the outcome. Only
+    // sessions that actually exchanged turns teach anything; init/turn
+    // errors with turnCount 0 are skipped.
+    if (deps.reflectEnqueue && state.turnCount > 0 && !state.continuationExecution) {
+        deps.reflectEnqueue({
+            negotiationId: state.taskId,
+            conversationId: state.conversationId,
+            ...(state.opportunityId && { opportunityId: state.opportunityId }),
+            sourceUser: {
+                id: state.sourceUser.id,
+                ...(state.sourceUser.profile.name && { name: state.sourceUser.profile.name }),
+                ...(state.sourceUser.profile.bio && { bio: state.sourceUser.profile.bio }),
+            },
+            candidateUser: {
+                id: state.candidateUser.id,
+                ...(state.candidateUser.profile.name && { name: state.candidateUser.profile.name }),
+                ...(state.candidateUser.profile.bio && { bio: state.candidateUser.profile.bio }),
+            },
+            initiatorUserId: state.initiatorUserId ?? state.sourceUser.id,
+            outcome: { hasOpportunity, reasoning: outcome.reasoning, turnCount: state.turnCount },
+        }).catch((err) => finalizeLog.error('Failed to enqueue negotiation reflection', {
+            taskId: state.taskId,
+            error: err,
+        }));
+    }
+    // Enqueue question generation for stalled/capped negotiations (not accepted or explicitly rejected).
+    // Require turnCount > 0 so early init/turn errors don't enqueue with empty context.
+    if (!hasOpportunity && !isRejectLikeAction(lastTurn?.action) && state.turnCount > 0 && state.opportunityId && state.sourceIntentId && state.indexContext.networkId && deps.questionerEnqueue && !state.continuationExecution) {
+        const stallReason = atCap
+            ? 'turn_cap'
+            : (state.error && /timeout/i.test(state.error))
+                ? 'timeout'
+                : 'stalled';
+        const userContext = (await deps.database.getUserContext(state.sourceUser.id, null))?.text ?? '';
+        const sourceIntent = state.sourceUser.intents.find((intent) => intent.id === state.sourceIntentId);
+        deps.questionerEnqueue({
+            mode: 'negotiation',
+            purpose: 'stalled_followup',
+            userId: state.sourceUser.id,
+            sourceType: 'opportunity',
+            sourceId: state.opportunityId,
+            negotiation: {
+                purpose: 'stalled_followup',
+                recipientUserId: state.sourceUser.id,
+                recipientIntentId: state.sourceIntentId,
+                opportunityId: state.opportunityId,
+                taskId: state.taskId,
+                networkId: state.indexContext.networkId,
+            },
+            context: {
+                negotiationId: state.taskId,
+                counterpartyHint: NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY,
+                indexContext: NEGOTIATION_QUESTION_GENERIC_NETWORK,
+                outcomeReason: stallReason,
+                recipientIntent: sourceIntent
+                    ? `${sourceIntent.title}: ${sourceIntent.description}`
+                    : 'the signal attached to this match',
+                userContext,
+            },
+        }).catch((err) => finalizeLog.error('Failed to enqueue negotiation question generation', {
+            opportunityId: state.opportunityId,
+            error: err,
+        }));
+    }
+    const terminalReceipt = state.continuationExecution
+        ? {
+            continuationReceipt: {
+                priorTaskId: state.continuationExecution.taskId,
+                settlementId: state.continuationExecution.settlementId,
+                successorTaskId: state.continuationExecution.successorTaskId,
+                fence: state.continuationExecution.fence,
+                outcome: hasOpportunity
+                    ? 'accepted'
+                    : (screenedOut || isRejectLikeAction(lastTurn?.action)) ? 'rejected' : 'stalled',
+            },
+        }
+        : undefined;
+    return { outcome, status: 'completed', ...terminalReceipt };
+}

package/dist/negotiations/application/negotiation.graph.init.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Negotiation graph, stage 1: claim the conversation, task and seat.
+ */
+import { type NegotiationConsultationReason } from "../domain/negotiation.consultation-policy.js";
+import type { NegotiationProtocolVersion } from "../../shared/schemas/negotiation-state.schema.js";
+import type { NegotiationGraphDeps, NegotiationState } from "./negotiation.graph.shared.js";
+export declare function initNode(state: NegotiationState, deps: NegotiationGraphDeps): Promise<{
+    error: string;
+} | {
+    messages?: {
+        id: string;
+        senderId: string;
+        role: "agent";
+        parts: unknown[];
+        createdAt: Date;
+        taskId: string | null;
+    }[] | undefined;
+    privateConsultation?: import("../../shared/interfaces/database.negotiation.js").NegotiationPrivateConsultation | undefined;
+    userAnswers?: import("../../shared/interfaces/database.negotiation.js").NegotiationUserAnswer[] | undefined;
+    priorAttribution?: import("../negotiation.attribution.js").SeededAttribution | undefined;
+    conversationId: string;
+    taskId: string;
+    currentSpeaker: "source" | "candidate";
+    turnCount: number;
+    maxTurns: number;
+    isContinuation: boolean;
+    initiatorUserId: string;
+    protocolVersion: NegotiationProtocolVersion;
+    priorTurnCount: number;
+    error?: undefined;
+} | {
+    messages?: {
+        id: string;
+        senderId: string;
+        role: "agent";
+        parts: unknown[];
+        createdAt: Date;
+        taskId: string | null;
+    }[] | undefined;
+    consultationPolicyReason: NegotiationConsultationReason;
+    privateConsultation?: import("../../shared/interfaces/database.negotiation.js").NegotiationPrivateConsultation | undefined;
+    userAnswers?: import("../../shared/interfaces/database.negotiation.js").NegotiationUserAnswer[] | undefined;
+    priorAttribution?: import("../negotiation.attribution.js").SeededAttribution | undefined;
+    conversationId: string;
+    taskId: string;
+    currentSpeaker: "source" | "candidate";
+    turnCount: number;
+    maxTurns: number;
+    isContinuation: boolean;
+    initiatorUserId: string;
+    protocolVersion: NegotiationProtocolVersion;
+    priorTurnCount: number;
+    error?: undefined;
+}>;

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

@@ -0,0 +1,227 @@
+/**
+ * Negotiation graph, stage 1: claim the conversation, task and seat.
+ */
+import { configuredProtocolVersion, readProtocolVersion } from "../domain/negotiation.protocol.js";
+import { buildIntentSnapshots } from "../domain/negotiation.intent-snapshot-provenance.js";
+import { holdsNegotiationConversationLock } from "../domain/negotiation.task-lock-policy.js";
+import { expectedNegotiationSpeaker } from "../domain/negotiation.expected-speaker.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 ---
+        const priorMessages = 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 prior messages and determine continuation ---
+        const priorTurns = turnsFromMessages(priorMessages);
+        const isContinuation = priorTurns.length > 0;
+        const expectedSpeaker = expectedNegotiationSpeaker({
+            sourceUserId: state.sourceUser.id,
+            candidateUserId: state.candidateUser.id,
+        }, priorMessages);
+        if (!expectedSpeaker)
+            return { error: 'invalid negotiation participants' };
+        const currentSpeaker = expectedSpeaker === state.sourceUser.id
+            ? 'source'
+            : 'candidate';
+        // 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;
+                }
+            }
+        }
+        // --- 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 prior turns (additive reducer appends new turns on top).
+        // taskId is preserved so the turn/screen nodes can separate this
+        // session's turns from seeded prior-task turns (IND-569).
+        const seedMessages = isContinuation ? priorMessages.map((m) => ({
+            id: m.id,
+            senderId: m.senderId,
+            role: 'agent',
+            parts: m.parts,
+            createdAt: m.createdAt,
+            taskId: m.taskId ?? null,
+        })) : [];
+        // IND-569: attribute seeded prior turns to their originating opportunity
+        // once, up front. Earlier-opportunity and legacy unattributed blocks are
+        // immutable for the session; the current block is composed per turn.
+        const priorAttribution = isContinuation
+            ? await buildSeededAttribution(priorMessages
+                .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)}` };
+    }
+}