@indexnetwork/protocol 6.8.0-rc.395.1 → 6.10.0-rc.397.1

package/dist/negotiation/negotiation.graph.js

@@ -4,9 +4,11 @@ import { requestContext } from "../shared/observability/request-context.js";
 import { NegotiationGraphState } from "./negotiation.state.js";
 import { IndexNegotiator } from "./negotiation.agent.js";
 import { ASK_USER_LOCK_SLACK_MS, allowedActionsFor, askUserAnswerWindowMs, configuredAskUserEnabled, configuredProtocolVersion, fallbackActionFor, isRejectLikeAction, isTerminalAction, readProtocolVersion, rejectActionFor } from "./negotiation.protocol.js";
+import { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode } from "./negotiation.consultation-policy.js";
 import { NegotiationScreener, configuredScreenMode } from "./negotiation.screen.js";
 import { assessDeadlock, configuredDeadlockShiftEnabled, configuredDeadlockThreshold } from "./negotiation.deadlock.js";
 import { protocolLogger } from "../shared/observability/protocol.logger.js";
+import { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, negotiationQuestionSettlementId, validateInflightAskUserFields } from './negotiation.question-safety.js';
 const logger = protocolLogger("NegotiationGraph");
 const initLog = protocolLogger("NegotiationGraph:Init");
 const screenNodeLog = protocolLogger("NegotiationGraph:Screen");
@@ -108,10 +110,14 @@ export class NegotiationGraphFactory {
         ].filter(Boolean).join("\n");
         const initNode = async (state) => {
             try {
-                // Find-or-create the DM conversation for this agent pair (same as user DMs)
+                // 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 conversation = await database.getOrCreateDM(agentIdA, agentIdB, 'agent');
+                const execution = state.continuationExecution;
+                const conversation = execution
+                    ? { id: execution.conversationId }
+                    : await database.getOrCreateDM(agentIdA, agentIdB, 'agent');
                 // --- Lock gate: check for an active task on this conversation ---
                 const priorMessages = await database.getMessagesForConversation(conversation.id);
                 const activeStates = ['submitted', 'working', 'input_required', 'waiting_for_agent', 'claimed'];
@@ -128,10 +134,37 @@ export class NegotiationGraphFactory {
                         : 5 * 60 * 1000;
                     return (Date.now() - new Date(t.updatedAt).getTime()) < freshnessMs;
                 };
-                const priorTask = state.opportunityId
-                    ? await database.getNegotiationTaskForOpportunity(state.opportunityId)
+                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 isLocked = !!priorTask && isActiveAndFresh(priorTask);
+                const priorTask = exactContinuation
+                    ? await database.getTask(exactContinuation.taskId)
+                    : state.opportunityId
+                        ? await database.getNegotiationTaskForOpportunity(state.opportunityId)
+                        : null;
+                const claimedSuccessor = exactContinuation
+                    ? await 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 && isActiveAndFresh(priorTask);
                 if (isLocked) {
                     initLog.info('Conversation locked by active task, returning busy', {
                         conversationId: conversation.id,
@@ -186,7 +219,7 @@ export class NegotiationGraphFactory {
                 // Conversation-scoped prior task: reused for both the initiator tie-break
                 // (only when active+fresh) and protocol-version inheritance (any prior
                 // task on the conversation pins the version).
-                const convTask = (!readInitiator(priorTask?.metadata) || !readProtocolVersion(priorTask?.metadata))
+                const convTask = !exactContinuation && (!readInitiator(priorTask?.metadata) || !readProtocolVersion(priorTask?.metadata))
                     ? await database.getLatestNegotiationTaskForConversation?.(conversation.id).catch(() => null)
                     : null;
                 if (!readInitiator(priorTask?.metadata)) {
@@ -227,24 +260,36 @@ export class NegotiationGraphFactory {
                     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 = state.opportunityId && state.opportunityStatus && state.opportunityUpdatedAt
-                    ? await database.createNegotiationTaskForAttempt({
-                        conversationId: conversation.id,
-                        opportunityId: state.opportunityId,
-                        expectedStatus: state.opportunityStatus,
-                        expectedUpdatedAt: state.opportunityUpdatedAt,
-                        metadata: taskMetadata,
-                    })
-                    : await database.createTask(conversation.id, taskMetadata);
+                const task = exactContinuation
+                    ? claimedSuccessor
+                    : state.opportunityId && state.opportunityStatus && state.opportunityUpdatedAt
+                        ? await database.createNegotiationTaskForAttempt({
+                            conversationId: conversation.id,
+                            opportunityId: state.opportunityId,
+                            expectedStatus: state.opportunityStatus,
+                            expectedUpdatedAt: state.opportunityUpdatedAt,
+                            metadata: taskMetadata,
+                        })
+                        : await database.createTask(conversation.id, taskMetadata);
                 if (!task) {
                     throw new Error('Negotiation attempt is stale or already claimed');
                 }
@@ -282,6 +327,14 @@ export class NegotiationGraphFactory {
                     protocolVersion,
                     priorTurnCount: priorTurns.length,
                     ...(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 }),
                 };
             }
@@ -360,7 +413,7 @@ export class NegotiationGraphFactory {
                 screenedAt: new Date().toISOString(),
                 durationMs,
             };
-            await database.setTaskScreenDecision?.(state.taskId, record).catch((err) => {
+            await 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", {
@@ -410,6 +463,7 @@ export class NegotiationGraphFactory {
                 const isSource = state.currentSpeaker === "source";
                 const ownUser = isSource ? state.sourceUser : state.candidateUser;
                 const otherUser = isSource ? state.candidateUser : state.sourceUser;
+                const ownIntentId = isSource ? state.sourceIntentId : state.candidateIntentId;
                 // Determine if this is the system agent's final allowed turn
                 const maxTurns = state.maxTurns ?? 0;
                 const isFinalTurn = maxTurns > 0 && (state.turnCount + 1) >= maxTurns;
@@ -420,19 +474,20 @@ export class NegotiationGraphFactory {
                 const seat = ownUser.id === (state.initiatorUserId ?? state.sourceUser.id)
                     ? 'initiator'
                     : 'counterparty';
-                // ask_user availability (P3.2): flag on, full pause loop wired
+                // Legacy ask_user availability (P3.2): flag on, full pause loop wired
                 // (questioner + answer-window timer + an opportunity to resume
                 // against), v2 non-final non-opening turn, and this side's one client
-                // consultation not yet spent (rationing). Chat-triggered runs get no
-                // special casing — the pause exits the graph at the turn boundary, so
-                // the stream never blocks on a question; the resume is always an async
-                // continuation.
+                // consultation not yet spent (rationing). Shadow is observational and
+                // must preserve this legacy path byte-for-byte except for telemetry.
+                const policyMode = negotiationConsultationPolicyMode();
                 const askUserAvailable = version === 'v2'
                     && !isFinalTurn
                     && configuredAskUserEnabled()
                     && !!questionerEnqueue
                     && !!timeoutQueue?.enqueueAskUserExpiry
                     && !!state.opportunityId
+                    && !!ownIntentId
+                    && !!state.indexContext.networkId
                     && !(state.turnCount === 0 && !state.isContinuation)
                     && !hasPriorAskUser(state.messages, ownUser.id);
                 // ─── Deadlock detection → persuasion→bargaining stance (IND-428) ──────
@@ -479,6 +534,9 @@ export class NegotiationGraphFactory {
                     allowedActions: [...allowedActionsFor(version, seat, isFinalTurn, { askUser: askUserAvailable })],
                     ...(state.discoveryQuery && isSource && { discoveryQuery: state.discoveryQuery }),
                     ...(ownMemory.length > 0 && { negotiatorMemory: ownMemory }),
+                    ...(state.privateConsultation?.recipientUserId === ownUser.id
+                        ? { privateConsultation: state.privateConsultation }
+                        : {}),
                 };
                 const scope = { action: 'manage:negotiations', scopeType: 'network', scopeId: state.indexContext.networkId };
                 const dispatchResult = await dispatcher.dispatch(ownUser.id, scope, payload, { timeoutMs: state.timeoutMs });
@@ -512,8 +570,11 @@ export class NegotiationGraphFactory {
                         // candidate-side turns would make the pickup prompt frame the
                         // search as "your user searched for X" for the wrong user.
                         ...(isSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
-                    });
-                    await database.updateTaskState(state.taskId, "waiting_for_agent");
+                        ...(state.privateConsultation && state.privateConsultation.recipientUserId === ownUser.id
+                            ? { privateConsultation: state.privateConsultation }
+                            : {}),
+                    }, state.continuationExecution);
+                    await database.updateTaskState(state.taskId, "waiting_for_agent", undefined, state.continuationExecution);
                     return { status: 'waiting_for_agent' };
                 }
                 else {
@@ -534,6 +595,9 @@ export class NegotiationGraphFactory {
                         ...(askUserAvailable && { canAskUser: true }),
                         ...(bargainingMode && { bargaining: { consecutiveNonConvergent: deadlock.consecutiveNonConvergent } }),
                         ...(ownMemory.length > 0 && { memory: ownMemory }),
+                        ...(state.privateConsultation?.recipientUserId === ownUser.id
+                            ? { privateConsultation: state.privateConsultation }
+                            : {}),
                     });
                 }
                 traceEmitter?.({ type: "agent_end", name: agentName, durationMs: Date.now() - agentStart, summary: `${turn.action}` });
@@ -548,11 +612,55 @@ export class NegotiationGraphFactory {
                         turn.action = openingAction;
                     }
                 }
-                // Safety net: an ask_user that slipped past availability gating (e.g. a
-                // locally-dispatched agent ignoring allowedActions, or rationing already
-                // spent) is coerced to the conservative fallback BEFORE persisting — a
-                // pause we cannot resume must never enter the turn history.
-                if (turn.action === 'ask_user' && !askUserAvailable) {
+                // IND-508 deterministic admission is evaluated only after the opening
+                // guard but before any turn is persisted. It consumes action/role enums
+                // only; free-form reasoning, messages, profiles, and evaluator inputs
+                // are intentionally unavailable to the policy.
+                let consultationPolicyReason;
+                const policyEligibility = policyMode === 'off' ? { eligible: false } : assessConsultationEligibility({
+                    protocolVersion: version,
+                    seat,
+                    isOpeningTurn: state.turnCount === 0 && !state.isContinuation,
+                    isFinalTurn,
+                    screenedOut: isScreenBlocked(state),
+                    action: turn.action,
+                    ownSuggestedRole: turn.assessment?.suggestedRoles?.ownUser,
+                    priorActions: history.map((prior) => prior.action),
+                    previouslyConsulted: hasPriorAskUser(state.messages, ownUser.id),
+                    hasExactResumeCoordinate: Boolean(configuredAskUserEnabled()
+                        && questionerEnqueue
+                        && timeoutQueue?.enqueueAskUserExpiry
+                        && state.taskId
+                        && state.opportunityId
+                        && ownIntentId
+                        && state.indexContext.networkId),
+                    lifecycleValid: Boolean(state.taskId && state.opportunityId && ownIntentId && state.indexContext.networkId),
+                });
+                const emitConsultationTelemetry = (stage, reason) => {
+                    turnLog.info('negotiation_consultation_policy', { stage, mode: policyMode, reason });
+                    emitWide({ type: 'negotiation_consultation_policy', stage, mode: policyMode, reason });
+                };
+                if (policyEligibility.eligible && policyEligibility.reason) {
+                    emitConsultationTelemetry('eligible', policyEligibility.reason);
+                    if (policyMode === 'on') {
+                        consultationPolicyReason = policyEligibility.reason;
+                        turn = {
+                            ...turn,
+                            action: 'ask_user',
+                            message: null,
+                            assessment: {
+                                reasoning: 'Client consultation required.',
+                                suggestedRoles: turn.assessment.suggestedRoles,
+                            },
+                            askUser: consultationPromptFor(consultationPolicyReason),
+                        };
+                        emitConsultationTelemetry('asked', consultationPolicyReason);
+                    }
+                }
+                // Safety net: off/shadow retain legacy behavior. In on, a spontaneous
+                // ask_user is admissible only when the deterministic policy just
+                // authorized it, so no unbounded pause can enter shared history.
+                if (turn.action === 'ask_user' && (!askUserAvailable || (policyMode === 'on' && !consultationPolicyReason))) {
                     turnLog.warn('ask_user emitted while unavailable, coercing to conservative fallback', {
                         seat, isFinalTurn, taskId: state.taskId,
                     });
@@ -576,7 +684,7 @@ export class NegotiationGraphFactory {
                         seat,
                         detectedAt: new Date().toISOString(),
                     };
-                    await database.setTaskDeadlockShift?.(state.taskId, deadlockShiftRecord).catch((err) => {
+                    await database.setTaskDeadlockShift?.(state.taskId, deadlockShiftRecord, state.continuationExecution).catch((err) => {
                         turnLog.error('Failed to persist deadlock shift record', { taskId: state.taskId, error: err });
                     });
                     turnLog.info('negotiation_deadlock_shift', {
@@ -606,6 +714,7 @@ export class NegotiationGraphFactory {
                     role: "agent",
                     parts,
                     taskId: state.taskId,
+                    ...(state.continuationExecution ? { continuationExecution: state.continuationExecution } : {}),
                 });
                 // ─── ask_user pause (P3.2) ────────────────────────────────────────────
                 // The negotiator consults its OWN client: persist the turn (done above),
@@ -615,50 +724,103 @@ export class NegotiationGraphFactory {
                 // like the waiting_for_agent suspend; the answer (or window expiry)
                 // resumes via the run-existing continuation path.
                 if (turn.action === 'ask_user') {
-                    const disclosureSubject = turn.askUser?.disclosureSubject?.trim()
-                        || turn.message
-                        || turn.assessment.reasoning;
-                    const draftQuestion = turn.askUser?.draftQuestion ?? turn.message ?? undefined;
-                    await database.setTaskTurnContext(state.taskId, {
-                        sourceUser: state.sourceUser,
-                        candidateUser: state.candidateUser,
-                        indexContext: state.indexContext,
-                        seedAssessment: state.seedAssessment,
-                        ...(isSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
+                    const counterparty = isSource ? state.candidateUser : state.sourceUser;
+                    const safeAskUser = validateInflightAskUserFields({
+                        disclosureSubject: turn.askUser?.disclosureSubject,
+                        draftQuestion: turn.askUser?.draftQuestion,
+                        forbiddenIdentifiers: [
+                            counterparty.id,
+                            counterparty.profile.name ?? '',
+                            state.opportunityId,
+                            state.taskId,
+                            state.indexContext.networkId,
+                            isSource ? state.candidateIntentId ?? '' : state.sourceIntentId ?? '',
+                        ],
+                        forbiddenSourceText: [
+                            counterparty.profile.bio ?? '',
+                            counterparty.profile.location ?? '',
+                            ...counterparty.intents.flatMap((intent) => [intent.title, intent.description]),
+                            state.seedAssessment.reasoning,
+                            state.indexContext.prompt,
+                            state.discoveryQuery ?? '',
+                        ],
+                    });
+                    const settlementId = negotiationQuestionSettlementId(state.taskId);
+                    const askUserBinding = await database.captureNegotiationAskUserBinding({
+                        taskId: state.taskId,
+                        settlementId,
+                        recipientUserId: ownUser.id,
+                        recipientIntentId: ownIntentId,
+                        opportunityId: state.opportunityId,
+                        networkId: state.indexContext.networkId,
+                        turnContext: {
+                            sourceUser: state.sourceUser,
+                            candidateUser: state.candidateUser,
+                            indexContext: state.indexContext,
+                            seedAssessment: state.seedAssessment,
+                            ...(isSource && state.discoveryQuery && { discoveryQuery: state.discoveryQuery }),
+                            ...(consultationPolicyReason && { consultationPolicyReason }),
+                        },
+                        ...(state.continuationExecution ? { continuationExecution: state.continuationExecution } : {}),
                     });
-                    // Arm the timer BEFORE flipping state: a timer against a task that
-                    // never reaches input_required no-ops harmlessly at fire time, while
-                    // an input_required task without a timer would strand until the lock
-                    // slack expires.
+                    // Arm the timer BEFORE flipping state: it is the durable recovery
+                    // trigger even when generation enqueues no job or persists no row.
                     const windowMs = askUserAnswerWindowMs();
                     await timeoutQueue.enqueueAskUserExpiry(state.taskId, {
+                        settlementId,
                         opportunityId: state.opportunityId,
                         userId: ownUser.id,
-                        disclosureSubject,
+                        recipientIntentId: ownIntentId,
+                        networkId: state.indexContext.networkId,
+                        intentFingerprint: askUserBinding.intentFingerprint,
+                        opportunityStatus: askUserBinding.opportunityStatus,
+                        opportunityUpdatedAt: askUserBinding.opportunityUpdatedAt,
+                        counterpartyUserId: askUserBinding.counterpartyUserId,
+                        counterpartyIntentId: askUserBinding.counterpartyIntentId,
                     }, windowMs);
-                    // Counterparty referenced by attributes, never identity — the
-                    // negotiation_inflight preset's referential-closure contract.
-                    const counterpartyHint = [
-                        otherUser.profile.bio,
-                        otherUser.profile.location,
-                        otherUser.profile.skills?.length ? `skills: ${otherUser.profile.skills.join(', ')}` : undefined,
-                    ].filter(Boolean).join('; ') || 'a potential match on the network';
-                    const userContext = (await database.getUserContext(ownUser.id, null).catch(() => null))?.text ?? '';
-                    await questionerEnqueue({
-                        mode: 'negotiation_inflight',
-                        userId: ownUser.id,
-                        sourceType: 'opportunity',
-                        sourceId: state.opportunityId,
-                        context: {
-                            negotiationId: state.taskId,
-                            counterpartyHint,
-                            disclosureSubject,
-                            ...(draftQuestion && { draftQuestion }),
-                            indexContext: state.indexContext.prompt,
-                            ...(userContext && { userContext }),
-                        },
-                    });
-                    await database.updateTaskState(state.taskId, 'input_required');
+                    // Persistence admission requires the exact task to be input_required.
+                    // Flip before enqueue; if the structured ask_user fields fail the
+                    // deterministic privacy gate, the timer alone closes the exact task.
+                    await database.updateTaskState(state.taskId, 'input_required', undefined, state.continuationExecution);
+                    if (safeAskUser) {
+                        const userContext = (await database.getUserContext(ownUser.id, null).catch(() => null))?.text ?? '';
+                        await questionerEnqueue({
+                            mode: 'negotiation_inflight',
+                            purpose: 'inflight_consultation',
+                            userId: ownUser.id,
+                            sourceType: 'opportunity',
+                            sourceId: state.opportunityId,
+                            negotiation: {
+                                purpose: 'inflight_consultation',
+                                recipientUserId: ownUser.id,
+                                recipientIntentId: ownIntentId,
+                                opportunityId: state.opportunityId,
+                                taskId: state.taskId,
+                                networkId: state.indexContext.networkId,
+                            },
+                            context: {
+                                negotiationId: state.taskId,
+                                counterpartyHint: NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY,
+                                disclosureSubject: safeAskUser.disclosureSubject,
+                                ...(safeAskUser.draftQuestion && { draftQuestion: safeAskUser.draftQuestion }),
+                                indexContext: NEGOTIATION_QUESTION_GENERIC_NETWORK,
+                                ...(consultationPolicyReason && { consultationPolicyReason }),
+                                ...(userContext && { userContext }),
+                            },
+                        }).catch((error) => {
+                            turnLog.error('Failed to enqueue safe ask_user question; timeout recovery remains armed', {
+                                taskId: state.taskId,
+                                opportunityId: state.opportunityId,
+                                error,
+                            });
+                        });
+                    }
+                    else {
+                        turnLog.warn('Skipping unsafe or incomplete ask_user question generation', {
+                            taskId: state.taskId,
+                            opportunityId: state.opportunityId,
+                        });
+                    }
                     turnLog.info('negotiation_ask_user_pause', {
                         taskId: state.taskId,
                         opportunityId: state.opportunityId,
@@ -673,7 +835,7 @@ export class NegotiationGraphFactory {
                         negotiationConversationId: state.conversationId,
                         turnIndex: state.turnCount,
                         actor: isSource ? 'source' : 'candidate',
-                        disclosureSubject,
+                        questionGenerationSafe: Boolean(safeAskUser),
                         windowMs,
                     });
                     return {
@@ -690,7 +852,7 @@ export class NegotiationGraphFactory {
                         ...(deadlockShiftRecord && { deadlockShift: deadlockShiftRecord }),
                     };
                 }
-                await database.updateTaskState(state.taskId, "working");
+                await database.updateTaskState(state.taskId, "working", undefined, state.continuationExecution);
                 if (state.opportunityId) {
                     emitWide({
                         type: "negotiation_turn",
@@ -757,6 +919,17 @@ export class NegotiationGraphFactory {
         const finalizeNode = async (state) => {
             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({
@@ -767,7 +940,7 @@ export class NegotiationGraphFactory {
                         isContinuation: state.isContinuation,
                     });
                 }
-                return {};
+                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.
@@ -781,7 +954,7 @@ export class NegotiationGraphFactory {
                         isContinuation: state.isContinuation,
                     });
                 }
-                return {};
+                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,
@@ -827,12 +1000,21 @@ export class NegotiationGraphFactory {
                         : {}),
             };
             try {
-                await database.updateTaskState(state.taskId, "completed");
+                await database.updateTaskState(state.taskId, "completed", undefined, state.continuationExecution);
                 await database.createArtifact({
                     taskId: state.taskId,
                     name: "negotiation-outcome",
                     parts: [{ kind: "data", data: outcome }],
-                    metadata: { hasOpportunity, turnCount: state.turnCount },
+                    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,
@@ -852,7 +1034,7 @@ export class NegotiationGraphFactory {
                         : (screenedOut || isRejectLikeAction(lastTurn?.action))
                             ? 'rejected'
                             : 'stalled';
-                    await database.updateOpportunityStatus(state.opportunityId, nextStatus).catch((err) => {
+                    await database.updateOpportunityStatus(state.opportunityId, nextStatus, undefined, state.continuationExecution).catch((err) => {
                         finalizeLog.error("Failed to update opportunity status", { opportunityId: state.opportunityId, nextStatus, error: err });
                     });
                 }
@@ -887,11 +1069,26 @@ export class NegotiationGraphFactory {
                     }),
                 });
             }
+            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 (reflectEnqueue && state.turnCount > 0) {
+            if (reflectEnqueue && state.turnCount > 0 && !state.continuationExecution) {
                 reflectEnqueue({
                     negotiationId: state.taskId,
                     conversationId: state.conversationId,
@@ -915,24 +1112,36 @@ export class NegotiationGraphFactory {
             }
             // 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 && questionerEnqueue) {
+            if (!hasOpportunity && !isRejectLikeAction(lastTurn?.action) && state.turnCount > 0 && state.opportunityId && state.sourceIntentId && state.indexContext.networkId && questionerEnqueue && !state.continuationExecution) {
                 const stallReason = atCap
                     ? 'turn_cap'
                     : (state.error && /timeout/i.test(state.error))
                         ? 'timeout'
                         : 'stalled';
                 const userContext = (await database.getUserContext(state.sourceUser.id, null))?.text ?? '';
+                const sourceIntent = state.sourceUser.intents.find((intent) => intent.id === state.sourceIntentId);
                 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: `${state.candidateUser.profile.name ?? 'Unknown'}${state.candidateUser.profile.bio ? ', ' + state.candidateUser.profile.bio : ''}`,
-                        indexContext: state.indexContext.prompt,
+                        counterpartyHint: NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY,
+                        indexContext: NEGOTIATION_QUESTION_GENERIC_NETWORK,
                         outcomeReason: stallReason,
-                        keyTake: outcome.reasoning,
+                        recipientIntent: sourceIntent
+                            ? `${sourceIntent.title}: ${sourceIntent.description}`
+                            : 'the signal attached to this match',
                         userContext,
                     },
                 }).catch((err) => finalizeLog.error('Failed to enqueue negotiation question generation', {
@@ -940,7 +1149,20 @@ export class NegotiationGraphFactory {
                     error: err,
                 }));
             }
-            return { outcome, status: 'completed' };
+            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 };
         };
         const workflow = new StateGraph(NegotiationGraphState)
             .addNode("init", initNode)
@@ -972,7 +1194,7 @@ export class NegotiationGraphFactory {
  * @returns Only candidates that produced an opportunity
  */
 export async function negotiateCandidates(negotiationGraph, sourceUser, candidates, indexContext, opts) {
-    const { maxTurns, traceEmitter, indexContextOverrides, timeoutMs, onCandidateResolved, trigger, initiatorUserId } = opts ?? {};
+    const { maxTurns, traceEmitter, indexContextOverrides, timeoutMs, onCandidateResolved, trigger, initiatorUserId, resumeFromTaskId, continuationSettlementId, continuationExecution, } = opts ?? {};
     // Local helper to emit events whose shape is wider than the declared
     // `TraceEmitter` union (mirrors the cast used in chat.agent at the relay sink
     // and inside turn/finalize nodes above).
@@ -1001,6 +1223,8 @@ export async function negotiateCandidates(negotiationGraph, sourceUser, candidat
             const result = await invokeWithAbortSignal(negotiationGraph, {
                 sourceUser,
                 candidateUser: candidate.candidateUser,
+                ...(candidate.sourceIntentId && { sourceIntentId: candidate.sourceIntentId }),
+                ...(candidate.candidateIntentId && { candidateIntentId: candidate.candidateIntentId }),
                 indexContext: candidateIndexContext,
                 seedAssessment: {
                     reasoning: candidate.reasoning,
@@ -1011,6 +1235,11 @@ export async function negotiateCandidates(negotiationGraph, sourceUser, candidat
                 ...(candidate.opportunityStatus && { opportunityStatus: candidate.opportunityStatus }),
                 ...(candidate.opportunityUpdatedAt && { opportunityUpdatedAt: candidate.opportunityUpdatedAt }),
                 ...(initiatorUserId && { initiatorUserId }),
+                ...(resumeFromTaskId && continuationSettlementId && continuationExecution ? {
+                    resumeFromTaskId,
+                    continuationSettlementId,
+                    continuationExecution,
+                } : {}),
                 ...(maxTurns !== undefined && { maxTurns }),
                 ...(timeoutMs !== undefined && { timeoutMs }),
             });
@@ -1064,6 +1293,7 @@ export async function negotiateCandidates(negotiationGraph, sourceUser, candidat
                         accepted,
                         turns: turnHistory,
                         outcome: resolvedOutcome,
+                        ...(result.continuationReceipt ? { continuationReceipt: result.continuationReceipt } : {}),
                     });
                 }
                 catch (hookErr) {