@indexnetwork/protocol 21.1.0-rc.493.1 → 22.0.0-rc.495.1

package/dist/mcp/mcp.authorization-policy.js

@@ -60,7 +60,6 @@ export const HERMES_AGENT_MCP_TOOL_PERMISSIONS = defineMcpToolPermissionMap({
     create_premise: { action: 'manage:premises', reach: 'principal' },
     update_premise: { action: 'manage:premises', reach: 'principal' },
     retract_premise: { action: 'manage:premises', reach: 'principal' },
-    read_pending_questions: { action: 'manage:identity', reach: 'principal' },
     read_activity_summary: { action: 'manage:identity', reach: 'principal' },
     read_docs: { action: 'manage:identity', reach: 'principal' },
 });
@@ -127,29 +126,6 @@ export const CANONICAL_MCP_TOOL_ACCESS_RULES = defineMcpToolAccessRules({
     read_intent_indexes: { access: 'authenticated', reach: 'network' },
     create_intent_index: { access: 'permission', actions: ['manage:intents'], reach: 'network' },
     delete_intent_index: { access: 'permission', actions: ['manage:intents'], reach: 'network' },
-    // Question tools inherit the exact affected object's permission in-handler.
-    read_pending_questions: {
-        access: 'permission',
-        actions: [
-            'manage:identity',
-            'manage:premises',
-            'manage:intents',
-            'manage:opportunities',
-            'manage:negotiations',
-        ],
-        reach: 'principal',
-    },
-    answer_pending_question: {
-        access: 'permission',
-        actions: [
-            'manage:identity',
-            'manage:premises',
-            'manage:intents',
-            'manage:opportunities',
-            'manage:negotiations',
-        ],
-        reach: 'principal',
-    },
     // Communities.
     read_networks: { access: 'authenticated', reach: 'network' },
     read_network_memberships: { access: 'authenticated', reach: 'network' },

package/dist/negotiations/negotiation.agent.js

@@ -238,9 +238,18 @@ ${stanceQuerySatisfiedRule(stance, otherName, userName)}`
         // worth having. What it may not do is stand in for this negotiation's own
         // exchange, so the policy line differs by whether this one has opened.
         const hasPriorDialogue = hasAttributedDialogue || input.history.length > 0;
+        // Three states, not two. `isContinuation` only says whether this
+        // negotiation spoke in an EARLIER session; on any turn after the opening
+        // it is still false while this negotiation is visibly mid-exchange. Under
+        // the old two-way split such a turn was told the signal was new and to
+        // "make your own case for it" — which, for the initiator seat, reads as
+        // an instruction to re-open, and produced a fresh outreach on every one
+        // of its turns instead of a reply.
         const priorDialoguePolicy = input.isContinuation
             ? 'Policy: You are continuing a prior dialogue. If this signal is materially the same as one you previously evaluated, you may resolve quickly. If materially different, evaluate on its own merits.'
-            : 'Policy: This signal is NEW — you have not negotiated it before. The dialogue above concluded on other signals and is background only. Evaluate this one on its own merits and make your own case for it.';
+            : input.history.length > 0
+                ? 'Policy: This negotiation is already under way — the turns above under the current opportunity are THIS exchange. Respond to the counterparty\'s latest turn; do not restate or re-pitch your opening.'
+                : 'Policy: This signal is NEW — you have not negotiated it before. The dialogue above concluded on other signals and is background only. Evaluate this one on its own merits and make your own case for it.';
         const priorDialogueContext = hasPriorDialogue
             ? `\n\n--- Prior dialogue with this counterparty ---\n${attributionPreamble}${priorDialogueBody}\n\n--- New signal under evaluation ---\n${input.discoveryQuery
                 ? `Discovery query: "${input.discoveryQuery}"`

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

@@ -45,6 +45,7 @@ export declare function turnNode(state: NegotiationState, deps: NegotiationGraph
         role: "agent";
         parts: unknown;
         createdAt: Date;
+        taskId: string;
     }[];
     turnCount: number;
     lastTurn: {
@@ -82,6 +83,7 @@ export declare function turnNode(state: NegotiationState, deps: NegotiationGraph
         role: "agent";
         parts: unknown;
         createdAt: Date;
+        taskId: string;
     }[];
     turnCount: number;
     currentSpeaker: "source" | "candidate";

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

@@ -495,6 +495,7 @@ export async function turnNode(state, deps) {
                         role: "agent",
                         parts: message.parts,
                         createdAt: message.createdAt,
+                        taskId: state.taskId,
                     }],
                 turnCount: state.turnCount + 1,
                 lastTurn: turn,
@@ -518,12 +519,20 @@ export async function turnNode(state, deps) {
             });
         }
         return {
+            // `taskId` is what makes this turn part of THIS session's block in the
+            // attributed prior dialogue (IND-569). Persisted with the current task
+            // id above; carried onto the state message so `buildAttributedDialogue`
+            // can match it. Dropping it silently emptied the "[Current opportunity —
+            // under negotiation now]" block, which — because the attributed
+            // rendering replaces the flat history in the prompt — left every turn
+            // after the opening blind to the exchange it was answering.
             messages: [{
                     id: message.id,
                     senderId: message.senderId,
                     role: "agent",
                     parts: message.parts,
                     createdAt: message.createdAt,
+                    taskId: state.taskId,
                 }],
             turnCount: state.turnCount + 1,
             currentSpeaker: (isSource ? "candidate" : "source"),

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

@@ -24,7 +24,7 @@ export { DEFAULT_NEGOTIATION_MAX_TURNS, isNegotiationTurnCapReached } from "./ne
 export { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
 export { negotiationScopeKey, readNegotiationMessages } from "./negotiation.scope.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "./negotiation.consultation-policy.js";
-export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeAuthoredNegotiationQuestion, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
+export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, isSafeAuthoredNegotiationQuestion, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
 export { renderNegotiatorChatMemorySection } from "./negotiation.memory.js";
 export type { ConsultationEligibility, ConsultationEligibilityInput, NegotiationConsultationPolicyMode, NegotiationConsultationReason, } from "./negotiation.consultation-policy.js";
 export type { HermesNegotiationAction, HermesNegotiationResponse, HermesOwnerDirective, HermesRoleAlignment, } from "./negotiation.hermes-contract.js";

package/dist/negotiations/negotiation.module.js

@@ -19,5 +19,5 @@ export { DEFAULT_NEGOTIATION_MAX_TURNS, isNegotiationTurnCapReached } from "./ne
 export { expectedNegotiationSpeaker } from "./negotiation.expected-speaker.js";
 export { negotiationScopeKey, readNegotiationMessages } from "./negotiation.scope.js";
 export { assessConsultationEligibility, consultationPromptFor, negotiationConsultationPolicyMode, } from "./negotiation.consultation-policy.js";
-export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY, isSafeAuthoredNegotiationQuestion, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
+export { NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY, NEGOTIATION_QUESTION_GENERIC_NETWORK, isSafeAuthoredNegotiationQuestion, isSafeNegotiationQuestionText, negotiationQuestionSettlementId, validateInflightAskUserFields, } from "./negotiation.question-safety.js";
 export { renderNegotiatorChatMemorySection } from "./negotiation.memory.js";

package/dist/negotiations/negotiation.question-safety.d.ts

@@ -2,7 +2,6 @@ import type { StructuredQuestion } from '../shared/schemas/structured-question.s
 /** Fixed prompt-safe labels; producers must not replace them with raw network/counterparty text. */
 export declare const NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY = "the other participant";
 export declare const NEGOTIATION_QUESTION_GENERIC_NETWORK = "the selected network";
-export declare const NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY = "a potential collaboration that may require clarification before you decide";
 /**
  * Deterministically reject question context copied from private negotiation inputs.
  * This guard never rewrites content: unsafe or ambiguous text yields no card while

package/dist/negotiations/negotiation.question-safety.js

@@ -2,7 +2,6 @@ import { hasUnsupportedOpportunityClaim } from '../shared/utils/claim-safety.js'
 /** Fixed prompt-safe labels; producers must not replace them with raw network/counterparty text. */
 export const NEGOTIATION_QUESTION_GENERIC_COUNTERPARTY = 'the other participant';
 export const NEGOTIATION_QUESTION_GENERIC_NETWORK = 'the selected network';
-export const NEGOTIATION_QUESTION_GENERIC_UPTAKE_ACTIVITY = 'a potential collaboration that may require clarification before you decide';
 const INTERNAL_ID_PATTERN = /\b(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|(?:task|intent|network|opportunity|user|match)[_-]?id)\b/i;
 const PRIVATE_SOURCE_PATTERN = /\b(?:private transcript|raw transcript|assessment(?:\.reasoning)?|seed assessment|evaluator reasoning|match reason|matchReason|internal metadata|counterparty profile)\b/i;
 function normalize(value) {

package/dist/negotiations/negotiation.tools.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { success, error } from '../shared/agent/tool.helpers.js';
 import { IndexNegotiator } from './negotiation.agent.js';
-import { allowedActionsFor, isTerminalAction, readProtocolVersion, rejectActionFor, resolveSeat, seatViolationMessage } from './negotiation.protocol.js';
+import { allowedActionsFor, isRejectLikeAction, isTerminalAction, readProtocolVersion, rejectActionFor, resolveSeat, seatViolationMessage } from './negotiation.protocol.js';
 import { NEGOTIATION_ACTIONS } from '../shared/schemas/negotiation-state.schema.js';
 import { protocolLogger } from '../shared/observability/protocol.logger.js';
 import { focusedIntentId, focusedNetworkId } from '../shared/agent/tool.scope.js';
@@ -53,6 +53,58 @@ async function readOpportunityLifecycles(database, opportunityIds, ownerUserId)
         return {};
     }
 }
+/**
+ * Terminal opportunity status for a negotiation concluded through this tool.
+ * Version-independent mapping, identical to the graph's finalize node:
+ * `accept` → `pending` (the owner gate is still ahead), reject-like →
+ * `rejected`, anything else (the turn cap) → `stalled`.
+ */
+function terminalOpportunityStatus(lastAction) {
+    if (lastAction === 'accept')
+        return 'pending';
+    return isRejectLikeAction(lastAction) ? 'rejected' : 'stalled';
+}
+/**
+ * Conclude a negotiation reached through `respond_to_negotiation`: complete
+ * the task, write the outcome artifact, and advance the opportunity out of
+ * `negotiating`.
+ *
+ * The status write goes through `updateOpportunityStatus` — the same waist the
+ * graph's finalize node uses — because that method is what carries the
+ * post-commit opportunity-transition emit. Writing the column any other way
+ * (or, as this path did before, not at all) leaves the transition hook blind:
+ * neither side's question-message is regenerated or pruned, radar buckets keep
+ * counting a finished negotiation, and the expiry sweep still sees a phantom
+ * active opportunity.
+ *
+ * The status write is best-effort, mirroring finalize: the task is already
+ * completed and the artifact written, so a failed status flip is logged rather
+ * than turned into a tool error the caller would read as "the conclude did not
+ * happen".
+ */
+async function concludeNegotiation(database, input) {
+    await database.updateTaskState(input.taskId, 'completed');
+    await database.createArtifact({
+        taskId: input.taskId,
+        name: 'negotiation-outcome',
+        parts: [{ kind: 'data', data: input.outcome }],
+        metadata: { hasOpportunity: input.outcome.hasOpportunity, turnCount: input.turnCount },
+    });
+    if (!input.opportunityId)
+        return;
+    const status = terminalOpportunityStatus(input.lastAction);
+    try {
+        await database.updateOpportunityStatus(input.opportunityId, status);
+    }
+    catch (err) {
+        logger.error('Failed to update opportunity status on MCP conclude', {
+            taskId: input.taskId,
+            opportunityId: input.opportunityId,
+            status,
+            err,
+        });
+    }
+}
 /** Extracts the ordered NegotiationTurn list from A2A message data parts. */
 function turnsFromMessages(messages) {
     return messages
@@ -437,12 +489,12 @@ export function createNegotiationTools(defineTool, deps) {
                     const history = turnsFromMessages(allMessages);
                     const nextSpeaker = currentSpeaker === 'source' ? 'candidate' : 'source';
                     const outcome = buildNegotiationOutcome(history, newTurnCount, query.action, meta.sourceUserId, meta.candidateUserId, nextSpeaker);
-                    await negotiationDatabase.updateTaskState(task.id, 'completed');
-                    await negotiationDatabase.createArtifact({
+                    await concludeNegotiation(negotiationDatabase, {
                         taskId: task.id,
-                        name: 'negotiation-outcome',
-                        parts: [{ kind: 'data', data: outcome }],
-                        metadata: { hasOpportunity: outcome.hasOpportunity, turnCount: newTurnCount },
+                        ...(meta.opportunityId ? { opportunityId: meta.opportunityId } : {}),
+                        lastAction: query.action,
+                        outcome,
+                        turnCount: newTurnCount,
                     });
                     return success({
                         message: query.action === 'accept'
@@ -465,12 +517,12 @@ export function createNegotiationTools(defineTool, deps) {
                     const history = turnsFromMessages(allMessages);
                     const nextSpeakerForCap = currentSpeaker === 'source' ? 'candidate' : 'source';
                     const outcome = buildNegotiationOutcome(history, newTurnCount, 'counter', meta.sourceUserId, meta.candidateUserId, nextSpeakerForCap);
-                    await negotiationDatabase.updateTaskState(task.id, 'completed');
-                    await negotiationDatabase.createArtifact({
+                    await concludeNegotiation(negotiationDatabase, {
                         taskId: task.id,
-                        name: 'negotiation-outcome',
-                        parts: [{ kind: 'data', data: outcome }],
-                        metadata: { hasOpportunity: false, turnCount: newTurnCount },
+                        ...(meta.opportunityId ? { opportunityId: meta.opportunityId } : {}),
+                        lastAction: 'counter',
+                        outcome,
+                        turnCount: newTurnCount,
                     });
                     return success({
                         message: 'Maximum turns reached. Negotiation finalized without opportunity.',
@@ -586,12 +638,12 @@ export function createNegotiationTools(defineTool, deps) {
                 if (isTerminalAction(aiTurn.action)) {
                     const fullHistory = [...historyForDispatch, aiTurn];
                     const outcome = buildNegotiationOutcome(fullHistory, finalTurnCount, aiTurn.action, meta.sourceUserId, meta.candidateUserId, counterpartySpeaker === 'source' ? 'candidate' : 'source');
-                    await negotiationDatabase.updateTaskState(task.id, 'completed');
-                    await negotiationDatabase.createArtifact({
+                    await concludeNegotiation(negotiationDatabase, {
                         taskId: task.id,
-                        name: 'negotiation-outcome',
-                        parts: [{ kind: 'data', data: outcome }],
-                        metadata: { hasOpportunity: outcome.hasOpportunity, turnCount: finalTurnCount },
+                        ...(meta.opportunityId ? { opportunityId: meta.opportunityId } : {}),
+                        lastAction: aiTurn.action,
+                        outcome,
+                        turnCount: finalTurnCount,
                     });
                     return success({
                         message: `${query.action === 'question' ? 'Question' : query.action === 'propose' ? 'Proposal' : 'Counter'} submitted. Counterparty responded with ${aiTurn.action}.`,
@@ -606,12 +658,12 @@ export function createNegotiationTools(defineTool, deps) {
                 if (isNegotiationTurnCapReached(finalTurnCount, meta.maxTurns)) {
                     const fullHistory = [...historyForDispatch, aiTurn];
                     const outcome = buildNegotiationOutcome(fullHistory, finalTurnCount, 'counter', meta.sourceUserId, meta.candidateUserId, counterpartySpeaker === 'source' ? 'candidate' : 'source');
-                    await negotiationDatabase.updateTaskState(task.id, 'completed');
-                    await negotiationDatabase.createArtifact({
+                    await concludeNegotiation(negotiationDatabase, {
                         taskId: task.id,
-                        name: 'negotiation-outcome',
-                        parts: [{ kind: 'data', data: outcome }],
-                        metadata: { hasOpportunity: false, turnCount: finalTurnCount },
+                        ...(meta.opportunityId ? { opportunityId: meta.opportunityId } : {}),
+                        lastAction: 'counter',
+                        outcome,
+                        turnCount: finalTurnCount,
                     });
                     return success({
                         message: 'Counterparty responded but max turns reached. Negotiation finalized.',
@@ -683,12 +735,12 @@ export function createNegotiationTools(defineTool, deps) {
                         const fullHistory = [...historyForDispatch, aiTurn, userAgentTurn];
                         const userSpeaker = isSource ? 'source' : 'candidate';
                         const outcome = buildNegotiationOutcome(fullHistory, userTurnCount, userAgentTurn.action, meta.sourceUserId, meta.candidateUserId, userSpeaker === 'source' ? 'candidate' : 'source');
-                        await negotiationDatabase.updateTaskState(task.id, 'completed');
-                        await negotiationDatabase.createArtifact({
+                        await concludeNegotiation(negotiationDatabase, {
                             taskId: task.id,
-                            name: 'negotiation-outcome',
-                            parts: [{ kind: 'data', data: outcome }],
-                            metadata: { hasOpportunity: outcome.hasOpportunity, turnCount: userTurnCount },
+                            ...(meta.opportunityId ? { opportunityId: meta.opportunityId } : {}),
+                            lastAction: userAgentTurn.action,
+                            outcome,
+                            turnCount: userTurnCount,
                         });
                         return success({
                             message: `Your agent ${userAgentTurn.action}ed the counterparty's response.`,
@@ -702,12 +754,12 @@ export function createNegotiationTools(defineTool, deps) {
                     if (isNegotiationTurnCapReached(userTurnCount, meta.maxTurns)) {
                         const fullHistory = [...historyForDispatch, aiTurn, userAgentTurn];
                         const outcome = buildNegotiationOutcome(fullHistory, userTurnCount, 'counter', meta.sourceUserId, meta.candidateUserId, isSource ? 'candidate' : 'source');
-                        await negotiationDatabase.updateTaskState(task.id, 'completed');
-                        await negotiationDatabase.createArtifact({
+                        await concludeNegotiation(negotiationDatabase, {
                             taskId: task.id,
-                            name: 'negotiation-outcome',
-                            parts: [{ kind: 'data', data: outcome }],
-                            metadata: { hasOpportunity: false, turnCount: userTurnCount },
+                            ...(meta.opportunityId ? { opportunityId: meta.opportunityId } : {}),
+                            lastAction: 'counter',
+                            outcome,
+                            turnCount: userTurnCount,
                         });
                         return success({
                             message: 'Your agent responded but max turns reached. Negotiation finalized.',

package/dist/opportunities/opportunity.graph.d.ts

@@ -733,7 +733,7 @@ export declare class OpportunityGraphFactory {
             seedAssessmentScore?: number | undefined;
         }[]> | undefined;
         discoverySummary?: import("../shared/schemas/discovery-question.schema.js").DiscoverySummary | import("@langchain/langgraph").OverwriteValue<import("../shared/schemas/discovery-question.schema.js").DiscoverySummary | null> | null | undefined;
-    }, "scope" | "__start__" | "discovery" | "prep" | "evaluation" | "persist" | "negotiate" | "resolve" | "ranking", {
+    }, "scope" | "__start__" | "prep" | "discovery" | "evaluation" | "persist" | "negotiate" | "resolve" | "ranking", {
         userId: import("@langchain/langgraph").BaseChannel<import("./opportunity.graph.shared.js").Id<"users">, import("./opportunity.graph.shared.js").Id<"users"> | import("@langchain/langgraph").OverwriteValue<import("./opportunity.graph.shared.js").Id<"users">>, unknown>;
         searchQuery: import("@langchain/langgraph").BaseChannel<string | undefined, string | import("@langchain/langgraph").OverwriteValue<string | undefined> | undefined, unknown>;
         networkId: import("@langchain/langgraph").BaseChannel<import("./opportunity.graph.shared.js").Id<"networks"> | undefined, import("./opportunity.graph.shared.js").Id<"networks"> | import("@langchain/langgraph").OverwriteValue<import("./opportunity.graph.shared.js").Id<"networks"> | undefined> | undefined, unknown>;

package/dist/opportunities/opportunity.tools.cards.d.ts

@@ -8,7 +8,6 @@
 import { type OpportunityOwnerAction, type OpportunityOwnerApprovalVerdict } from "./opportunity.owner-approval.js";
 export declare function stripLeadingNarratorName(remark: string, narratorName: string): string;
 import type { Opportunity } from "../shared/interfaces/database.interface.js";
-import type { PendingQuestionSummary } from "../shared/schemas/pending-question.schema.js";
 export declare const logger: import("../shared/observability/log.js").LoggerWithSource;
 /**
  * Build the agent-facing profile link for a counterpart — always the Index web
@@ -72,18 +71,6 @@ export declare function attachOpportunityAppLink(card: Record<string, unknown> &
 }, opts: {
     frontendUrl: string | undefined;
 }): void;
-export interface PublicUptakeQuestion {
-    id: string;
-    title: string;
-    prompt: string;
-    options: Array<{
-        label: string;
-        description: string;
-    }>;
-    multiSelect: boolean;
-}
-export declare function publicUptakeQuestion(question: PendingQuestionSummary): PublicUptakeQuestion;
-export declare function uptakeAdvisory(opportunityId: string, questions: PublicUptakeQuestion[]): string;
 /**
  * IND-593: stable fail-closed denial for the owner-approval boundary. The
  * `missing` reason carries the fresh, server-derived interaction challenge the

package/dist/opportunities/opportunity.tools.cards.js

@@ -111,28 +111,6 @@ export function attachOpportunityAppLink(card, opts) {
     if (appUrl)
         card.appUrl = appUrl;
 }
-export function publicUptakeQuestion(question) {
-    return {
-        id: question.id,
-        title: question.title,
-        prompt: question.prompt,
-        options: question.options,
-        multiSelect: question.multiSelect,
-    };
-}
-export function uptakeAdvisory(opportunityId, questions) {
-    return JSON.stringify({
-        success: false,
-        error: "Resolve the pending uptake questions or explicitly continue anyway.",
-        advisory: {
-            code: "unresolved_uptake_questions",
-            advisoryOnly: true,
-            opportunityId,
-            questions,
-            acknowledgedUptakeQuestionIds: questions.map((question) => question.id),
-        },
-    });
-}
 /**
  * IND-593: stable fail-closed denial for the owner-approval boundary. The
  * `missing` reason carries the fresh, server-derived interaction challenge the

package/dist/opportunities/opportunity.tools.js

@@ -10,14 +10,13 @@ import { requestContext } from "../shared/observability/request-context.js";
 import { success, error, UUID_REGEX } from "../shared/agent/tool.helpers.js";
 import { focusedIntentId, focusedNetworkId } from "../shared/agent/tool.scope.js";
 import { OpportunityPresenter, gatherPresenterContext } from "./opportunity.presentation.js";
-import { isUptakeGuardEnabled } from "../questions/question.module.js";
 import { admitOpportunityUpdate } from "./opportunity.update-admission.js";
 import { opportunityOwnerActionForStatus } from "./opportunity.owner-approval.js";
 import { ownerApprovalProvenanceFor } from "./opportunity.owner-provenance.js";
 export { buildOpportunityPresentation } from "./opportunity.presentation.js";
 import { sendOpportunity, updateOpportunityStatus } from "./opportunity.graph.modes.js";
 import { createListOpportunitiesTool } from "./opportunity.tools.list.js";
-import { confirmDeliveryError, logger, ownerApprovalDenial, publicUptakeQuestion, uptakeAdvisory } from "./opportunity.tools.cards.js";
+import { confirmDeliveryError, logger, ownerApprovalDenial } from "./opportunity.tools.cards.js";
 export { attachOpportunityAppLink, attachProfileLink, buildMinimalOpportunityCard, buildNegotiationUrl, buildOpportunityAppUrl, buildProfileUrl } from "./opportunity.tools.cards.js";
 export function createOpportunityTools(defineTool, deps) {
     const { database, userDb, systemDb, graphs, cache } = deps;
@@ -36,13 +35,12 @@ export function createOpportunityTools(defineTool, deps) {
             "- `rejected`: Decline a received opportunity.\n" +
             "- `expired`: Mark as expired (typically done by the system after timeout).\n\n" +
             "**When to use:** After list_opportunities returns persisted opportunity cards. " +
-            "The user clicks 'Send' (pending), 'Accept', or 'Reject' on the card, and the agent calls this tool. " +
-            "An accepted transition may first return a non-success uptake advisory with preparatory questions. Surface those questions, then retry with all returned question ids in acknowledgedUptakeQuestionIds; acknowledgement confirms presentation, not an answer.\n\n" +
+            "The user clicks 'Send' (pending), 'Accept', or 'Reject' on the card, and the agent calls this tool.\n\n" +
             "**Owner approval (agents):** Agent-driven send/accept/reject transitions require an explicit owner-issued approval proof. " +
             "Call without ownerApprovalProof first: the denial returns an approval challenge (interactionId, expiresAt) bound to the exact opportunity, action, owner, and agent. " +
             "Relay that challenge to the owner for explicit approval, then retry once with the issued ownerApprovalProof. " +
-            "Proofs are single-use and expire; acknowledgedUptakeQuestionIds, negotiation approvals, and advisory values are never substitutes.\n\n" +
-            "**Returns:** Confirmation with the new status and notification details (who was notified), or a structured uptake advisory without mutation.",
+            "Proofs are single-use and expire; negotiation approvals and advisory values are never substitutes.\n\n" +
+            "**Returns:** Confirmation with the new status and notification details (who was notified).",
         querySchema: z.object({
             opportunityId: z
                 .string()
@@ -58,10 +56,6 @@ export function createOpportunityTools(defineTool, deps) {
                 .describe("Opaque owner-issued approval proof for this exact transition (agents only). Obtained after the owner " +
                 "explicitly approves the interaction challenge returned by a proof-less call. The opportunity, action, " +
                 "owner, agent, and interaction binding is always derived server-side; only this token is presented."),
-            acknowledgedUptakeQuestionIds: z
-                .array(z.string().min(1))
-                .optional()
-                .describe("On an acknowledged retry after an uptake advisory, include every question id returned by that advisory."),
             scopeType: z
                 .enum(['intent'])
                 .optional()
@@ -137,61 +131,6 @@ export function createOpportunityTools(defineTool, deps) {
                 if (verdict.kind === 'denied')
                     return ownerApprovalDenial(opportunityId, ownerAction, verdict);
             }
-            // The caller actor's own network is the exact question lookup boundary,
-            // even for an otherwise unscoped request. A focused network may only be
-            // equal to this after the guard above.
-            // Unscoped callers query all of their exact opportunity questions; a
-            // network-scoped caller is clamped to the bound network. Selecting the
-            // first duplicate actor row would miss a valid question on another
-            // shared network.
-            const uptakeNetworkId = scopedNetworkId;
-            // Soft uptake interlock: only acceptance is advisory-gated. All existing
-            // actor/scope/privacy guards run first so the question lookup cannot be
-            // used to probe opportunities or networks the caller cannot access.
-            if (query.status === "accepted" && isUptakeGuardEnabled() && deps.findPendingQuestions) {
-                try {
-                    const pending = await deps.findPendingQuestions(context.userId, {
-                        sourceType: "opportunity",
-                        sourceId: opportunityId,
-                        modes: ["negotiation"],
-                        purpose: "uptake",
-                        ...(uptakeNetworkId ? { networkId: uptakeNetworkId } : {}),
-                    });
-                    // Defense in depth if a host overlooks one or more filters. Actor
-                    // internals are checked here and never serialized into the advisory.
-                    const exactPending = pending.filter((question) => {
-                        if (question.sourceType !== "opportunity" ||
-                            question.sourceId !== opportunityId ||
-                            question.mode !== "negotiation" ||
-                            question.purpose !== "uptake") {
-                            return false;
-                        }
-                        if (!question.actors?.some((actor) => actor.userId === context.userId))
-                            return false;
-                        if (uptakeNetworkId && !question.actors.some((actor) => actor.userId === context.userId && actor.networkId === uptakeNetworkId)) {
-                            return false;
-                        }
-                        return true;
-                    });
-                    const acknowledged = new Set(query.acknowledgedUptakeQuestionIds ?? []);
-                    if (exactPending.some((question) => !acknowledged.has(question.id))) {
-                        return uptakeAdvisory(opportunityId, exactPending.map(publicUptakeQuestion));
-                    }
-                }
-                catch (err) {
-                    logger.warn("update_opportunity: uptake question lookup failed open", {
-                        opportunityId,
-                        userId: context.userId,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                    deps.reportToolError?.(err, {
-                        subsystem: "opportunity",
-                        operation: "opportunity.uptake_lookup",
-                        toolName: "update_opportunity",
-                        userId: context.userId,
-                    });
-                }
-            }
             const isSend = query.status === "pending";
             const _updateGraphStart = Date.now();
             const _updateTraceEmitter = requestContext.getStore()?.traceEmitter;

package/dist/opportunities/opportunity.tools.port.d.ts

@@ -11,6 +11,6 @@ export interface OpportunityOwnerApprovalDeps {
     opportunityOwnerApproval?: OpportunityOwnerApprovalAuthority;
 }
 /** Host capabilities consumed by opportunity discovery, delivery, and presentation tools. */
-export type OpportunityToolDeps = Pick<ToolRegistryCompositionDeps, "database" | "userDb" | "systemDb" | "cache" | "chatSummary" | "opportunityPresentation" | "questionerEnqueue" | "findPendingQuestions" | "negotiationSummary" | "negotiationDatabase" | "deliveryLedger" | "frontendUrl" | "stampNewbornOpportunities" | "reportToolError" | "opportunityOperations"> & OpportunityOwnerApprovalDeps & {
+export type OpportunityToolDeps = Pick<ToolRegistryCompositionDeps, "database" | "userDb" | "systemDb" | "cache" | "chatSummary" | "opportunityPresentation" | "questionerEnqueue" | "negotiationSummary" | "negotiationDatabase" | "deliveryLedger" | "frontendUrl" | "stampNewbornOpportunities" | "reportToolError" | "opportunityOperations"> & OpportunityOwnerApprovalDeps & {
     graphs: Pick<ToolRegistryCompositionDeps["graphs"], "index" | "networkMembership" | "opportunity">;
 };

package/dist/questions/question.env.d.ts

@@ -1,26 +1,11 @@
 /**
- * questions/question.env — centralized question-generation env accessors.
+ * questions/question.env — leftover question env constants.
  *
- * Naming scheme (one prefix, hierarchical):
- *
- *   QUESTIONER_ENABLED                  master switch — QuestionerQueue worker +
- *                                       enqueue closures at every composition site.
- *   QUESTIONER_UPTAKE_ENABLED           per-surface switch — advisory pre-accept uptake
- *                                       interlock. Requires the master switch.
- *   QUESTIONER_UPTAKE_AUTHORITY_THRESHOLD
- *                                       authority threshold (0-100, default 70).
- *   QUESTIONER_CHAT_WAIT_TIMEOUT_MS     how long the blocking ask_user_question chat
- *                                       tool waits for an inline answer (default 4 min).
- *   QUESTIONER_INTENT_DAILY_CAP         refinement questions one intent may generate
- *                                       per rolling 24h, recovery + pool combined
- *                                       (default 2; 0 disables refinement).
- *
- * All reads go through this module — do not read these variables via
- * `process.env` elsewhere. Values are read on every call (no caching) so tests
- * and long-lived processes observe changes.
+ * The QUESTIONER_* runtime flags are retired with the card generators
+ * (conversational-questions plan); park-path routing is always on. What
+ * remains are the historical budget constants still referenced by the
+ * questions-table adapter until its surface drops.
  */
-export declare const CHAT_QUESTION_WAIT_TIMEOUT_MS_DEFAULT = 240000;
-export declare const UPTAKE_AUTHORITY_THRESHOLD_DEFAULT = 70;
 /**
  * Refinement questions a single intent may generate per rolling window.
  *
@@ -40,18 +25,3 @@ export declare const INTENT_QUESTION_DAILY_CAP_DEFAULT = 2;
  * have granted the second burst a full fresh allowance.
  */
 export declare const INTENT_QUESTION_DAILY_WINDOW_HOURS = 24;
-/** Master switch: is any background question generation enabled? */
-export declare function isQuestionerEnabled(): boolean;
-/** Advisory uptake interlock. Flag-off by default and subordinate to the master switch. */
-export declare function isUptakeGuardEnabled(): boolean;
-/** Authority threshold below which hosts may generate uptake questions. */
-export declare function uptakeAuthorityThreshold(): number;
-/** Wait budget for the blocking ask_user_question chat tool. */
-export declare function chatQuestionWaitTimeoutMs(): number;
-/**
- * Per-intent refinement budget over {@link INTENT_QUESTION_DAILY_WINDOW_HOURS}.
- *
- * Zero is a meaningful setting — it disables background refinement entirely
- * without touching the master switch — so this does not reuse `positiveIntEnv`.
- */
-export declare function intentQuestionDailyCap(): number;