@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/negotiations/negotiation.consultation-policy.js

@@ -1,159 +0,0 @@
-/**
- * Read the centralized consultation-policy switch. Invalid, absent, and empty
- * values deliberately roll back to off.
- */
-export function negotiationConsultationPolicyMode() {
-    const raw = process.env.NEGOTIATION_CONSULTATION_POLICY_MODE;
-    return raw === "shadow" || raw === "on" ? raw : "off";
-}
-/**
- * Pure IND-508 eligibility policy. It intentionally never sees user text,
- * evaluator output, profiles, IDs, prompts, or messages; only safe protocol
- * enums and the exact binding/lifecycle booleans supplied by the graph.
- */
-export function assessConsultationEligibility(input) {
-    if (input.protocolVersion !== "v2"
-        || input.isFinalTurn
-        || input.screenedOut
-        || input.previouslyConsulted
-        || !input.hasExactResumeCoordinate
-        || !input.lifecycleValid
-        || isObviousTerminal(input.action))
-        return { eligible: false };
-    // ─── Pre-contact consultation (the opening turn) ──────────────────────────
-    // Before this branch the opening turn was a blanket exclusion, so the
-    // initiator's turn-0 vocabulary was binary: reach out, or pass with the
-    // counterparty never contacted. A third verdict is admissible when the
-    // blocking doubt is one only the client can settle — how their own criteria
-    // bound the search — and the pause costs the counterparty nothing, because
-    // nothing has been sent.
-    //
-    // The admission is deliberately NARROW, and narrower than the mid-flight
-    // rules below:
-    //
-    //  - INITIATOR ONLY. A turn-0 counterparty seat (tie-break inheritance) is
-    //    responding to an outreach, so its client's criteria are not what is
-    //    blocking; there is no pre-contact position to protect either.
-    //  - A MODEL-AUTHORED `ask_user` ONLY. Every rule below infers a
-    //    consultation from a draft that asked for something else, which needs
-    //    history to be a safe inference — and at turn 0 there is none. The
-    //    acting agent is the only party that has read the client's own signal,
-    //    so the pre-contact case is the one where volunteering the pause is the
-    //    evidence, not a substitute for it. This also keeps the distinction the
-    //    graph prompt draws — client-resolvable scope doubt consults;
-    //    counterparty evidence that contradicts the match passes silently —
-    //    resolvable HERE only as "the agent did not ask", which is exactly what
-    //    a contradiction-shaped doubt produces.
-    //
-    // The category is fixed rather than read off the draft: a pre-contact pause
-    // is by construction an unresolved constraint the OWNER controls. The
-    // consult counts as an ordinary ask round (the graph reads the same
-    // `negotiationAskRoundsCap` substrate before granting the action at all).
-    if (input.isOpeningTurn) {
-        return input.seat === "initiator" && input.action === "ask_user"
-            ? { eligible: true, reason: "unresolved_owner_constraint" }
-            : { eligible: false };
-    }
-    // A patient-side counter is a schema-constrained, source-safe signal that
-    // the owner must decide whether a consequential disclosure or permission is
-    // acceptable. This is reachable under the normal v2 action vocabulary; it
-    // deliberately does not inspect or depend on a model-produced `ask_user`.
-    if (input.ownSuggestedRole === "patient" && input.action === "counter") {
-        return { eligible: true, reason: "consequential_disclosure_permission" };
-    }
-    // Preserve observability for a valid legacy ask_user draft; production
-    // policy admission no longer depends on this action because the patient-side
-    // counter rule above is schema-constrained and independently reachable.
-    if (input.action === "ask_user") {
-        return { eligible: true, reason: "consequential_disclosure_permission" };
-    }
-    // A repeated run of safe counter/question action enums means the parties are
-    // not converging. This precedes action-local rules so the policy is stable.
-    const trailingActions = [...input.priorActions, input.action].slice(-3);
-    const trailingNonConvergent = trailingActions.length === 3
-        && trailingActions.every((action) => action === "counter" || action === "question");
-    if (trailingNonConvergent) {
-        return { eligible: true, reason: "repeated_non_convergence" };
-    }
-    if (input.ownSuggestedRole === "agent" && input.action === "counter") {
-        return { eligible: true, reason: "insufficient_commitment_authority" };
-    }
-    if (input.action === "question") {
-        return { eligible: true, reason: "unresolved_owner_constraint" };
-    }
-    return { eligible: false };
-}
-/** Fixed source-safe inputs that still traverse the existing questioner guard. */
-export function consultationPromptFor(reason) {
-    switch (reason) {
-        case "consequential_disclosure_permission":
-            return { disclosureSubject: "your permission", draftQuestion: "May I share the information needed to explore this collaboration?" };
-        case "repeated_non_convergence":
-            return { disclosureSubject: "your priorities", draftQuestion: "Which trade-off matters most as I decide how to proceed?" };
-        case "insufficient_commitment_authority":
-            return { disclosureSubject: "your decision authority", draftQuestion: "What commitments may I make on your behalf?" };
-        case "unresolved_owner_constraint":
-            return { disclosureSubject: "your preferences", draftQuestion: "What outcome would you prefer?" };
-    }
-}
-function isObviousTerminal(action) {
-    return action === "accept" || action === "reject" || action === "withdraw" || action === "decline";
-}
-// ─── Pre-contact consultation: bounds and recognition ────────────────────────
-/**
- * How many pre-contact consultations one intent may hold OPEN at once.
- *
- * A vague signal can surface many candidates in a batch, and the doubt that
- * blocks the first ("does 'academic linguistics' strictly bound this, or is
- * adjacent depth in scope?") is usually the same doubt that blocks all of
- * them. One answer generalizes: it lands in the signal's DM, and the DM is
- * injected into every later turn-0 decision on that signal. The cap exists
- * for the agent that does not internalize that and would interrogate its
- * client candidate-by-candidate.
- *
- * Two, not one: a second genuinely different question about the same signal
- * is plausible, a third is a pattern. Past the cap the action is simply not
- * offered and the seat falls back to today's binary reach-out-or-pass.
- */
-export const MAX_OPEN_PRE_CONTACT_CONSULTS_PER_INTENT = 2;
-/**
- * Whether a negotiation's own turns show it has never contacted the
- * counterparty — every turn it holds is a client-consultation park.
- *
- * This is what makes a post-consult resume still-the-opening. A mid-flight
- * consult always has an `outreach` behind it (the counterparty seat cannot
- * even speak before one), so this is false for every park the pre-contact
- * verdict did not create, and the resume rules it gates stay off the
- * mid-flight path by construction rather than by a flag.
- */
-export function isPreContactConsultResume(turns) {
-    return turns.length > 0 && turns.every((turn) => turn.action === "ask_user");
-}
-/**
- * Turn-context key stamped on a pre-contact park. Written at park time beside
- * the ask-user binding, read back by {@link countOpenPreContactConsults} — the
- * park row is the only durable record of the consultation, so the marker lives
- * with it rather than in a separate counter that could drift.
- */
-export const PRE_CONTACT_CONSULT_MARKER = "preContactConsult";
-/**
- * Count the pre-contact consultations currently open for one `(user, intent)`
- * scope, from the user's own negotiation tasks.
- *
- * "Open" is derived from the durable park itself — an `input_required` task
- * whose captured ask-user binding names this recipient pair and whose turn
- * context carries the pre-contact stamp — so answering, expiry, and resume all
- * retire a park from the count with no counter to keep in step. Mid-flight
- * consults carry no stamp and never count.
- */
-export function countOpenPreContactConsults(tasks, scope) {
-    return tasks.filter((task) => {
-        if (task.state !== "input_required" || task.id === scope.excludeTaskId)
-            return false;
-        const turnContext = task.metadata?.turnContext;
-        if (turnContext?.[PRE_CONTACT_CONSULT_MARKER] !== true)
-            return false;
-        const binding = turnContext.askUserBinding;
-        return binding?.recipientUserId === scope.userId && binding.recipientIntentId === scope.intentId;
-    }).length;
-}

package/dist/negotiations/negotiation.deadlock.contracts.d.ts

@@ -1,10 +0,0 @@
-/** Internal-only metadata persisted when a deadlock causes a stance shift. */
-export interface DeadlockShiftRecord {
-    reason: "consecutive_non_convergent";
-    consecutiveNonConvergent: number;
-    threshold: number;
-    /** Zero-based session turn index at which the shifted draft happened. */
-    shiftedAtTurn: number;
-    seat: "initiator" | "counterparty";
-    detectedAt: string;
-}

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

@@ -1,87 +0,0 @@
-/**
- * Deadlock detection + persuasion→bargaining mode shift (IND-428, backlog item 6).
- *
- * Grounding: Wells & Reed (2006), *Knowing When to Bargain* — a persuasion
- * dialogue (arguing the merits) that reaches a stalemate may execute a *legal
- * shift* into a negotiation dialogue (offering concessions). See
- * `docs/design/negotiation-dialogue-game.md` for the formal framing of the
- * turn protocol as a dialogue game.
- *
- * Design constraints (hard):
- * - **Deterministic**: deadlock is decided by pure inspection of the persisted
- *   turn history — never by an LLM.
- * - **Stance, not rules**: a detected deadlock changes the system agent's
- *   *drafting stance* only. Locutions, seat vocabularies (`allowedActionsFor`),
- *   termination, and turn-cap semantics are untouched.
- * - **Default-off**: gated on `NEGOTIATION_DEADLOCK_SHIFT_ENABLED === "true"`
- *   (strict literal) and applied only to v2 negotiations, checked alongside the
- *   protocol-version plumbing. When off, the legacy path is byte-identical.
- * - **Fail-open**: any detection error means "no deadlock" — advisory
- *   infrastructure never blocks a negotiation.
- */
-import { type NegotiatorStance } from "./negotiation.stance.contracts.js";
-export type { DeadlockShiftRecord } from "./negotiation.deadlock.contracts.js";
-/**
- * Whether the deadlock→bargaining mode shift is enabled, from the
- * `NEGOTIATION_DEADLOCK_SHIFT_ENABLED` env switch. Strict literal `"true"`
- * only — the deployment is byte-for-byte unchanged until the flag is flipped,
- * and rolling back is the same single switch.
- */
-export declare function configuredDeadlockShiftEnabled(): boolean;
-/**
- * Default deadlock threshold: 4 consecutive non-convergent turns. Sized
- * against the ambient turn cap (6): an outreach plus 4 unbroken counters
- * leaves exactly the closing turns to draft in the bargaining stance.
- */
-export declare const DEFAULT_DEADLOCK_THRESHOLD = 4;
-/**
- * Lower bound on the configurable threshold. Below 2 the "stalemate" signal is
- * meaningless — a single counter is ordinary dialogue, not a deadlock.
- */
-export declare const MIN_DEADLOCK_THRESHOLD = 2;
-/**
- * Consecutive non-convergent turns that constitute a deadlock, from
- * `NEGOTIATION_DEADLOCK_THRESHOLD`. Must be an integer >= 2; invalid,
- * non-integer, or out-of-range values fall back to the default (fail-open
- * toward the documented behavior, mirroring `askUserAnswerWindowMs`).
- */
-export declare function configuredDeadlockThreshold(): number;
-export interface DeadlockAssessment {
-    /** True when the trailing non-convergent run has reached the threshold. */
-    deadlocked: boolean;
-    /** Length of the maximal trailing run of counter/question turns. */
-    consecutiveNonConvergent: number;
-    /** The threshold the run was compared against. */
-    threshold: number;
-}
-/**
- * Deterministic stalemate detector: measures the maximal *trailing* run of
- * non-convergent turns (`counter`/`question`) in the persisted history and
- * compares it against the threshold. Continuation histories are included by
- * construction — the caller passes the full turn list, so a deadlock spanning
- * sessions still counts.
- *
- * Pure state inspection; no LLM, no I/O, no clock.
- */
-export declare function assessDeadlock(history: ReadonlyArray<{
-    action?: string;
-}>, threshold?: number): DeadlockAssessment;
-/**
- * Renders the deadlock-stance prompt section. Returns the empty string when
- * the shift is not active, so the rendered system prompt is byte-identical to
- * the legacy build on every non-shifted turn (mirrors
- * `renderNegotiatorMemorySection`). The `ask_user` escalation line renders
- * only when the caller already legally holds the action (`canAskUser`) — the
- * shift never invents a locution.
- *
- * IND-611: `stance` selects which resolution the shift drafts toward —
- * bargaining (`advocate`/`evaluator`, the default and today's behavior) or
- * stalemate (`skeptic`). Omitted → bargaining, byte-identical to before.
- */
-export declare function renderBargainingShiftSection(input: {
-    active: boolean;
-    userName: string;
-    canAskUser: boolean;
-    consecutiveNonConvergent: number;
-    stance?: NegotiatorStance;
-}): string;

package/dist/negotiations/negotiation.deadlock.js

@@ -1,150 +0,0 @@
-/**
- * Deadlock detection + persuasion→bargaining mode shift (IND-428, backlog item 6).
- *
- * Grounding: Wells & Reed (2006), *Knowing When to Bargain* — a persuasion
- * dialogue (arguing the merits) that reaches a stalemate may execute a *legal
- * shift* into a negotiation dialogue (offering concessions). See
- * `docs/design/negotiation-dialogue-game.md` for the formal framing of the
- * turn protocol as a dialogue game.
- *
- * Design constraints (hard):
- * - **Deterministic**: deadlock is decided by pure inspection of the persisted
- *   turn history — never by an LLM.
- * - **Stance, not rules**: a detected deadlock changes the system agent's
- *   *drafting stance* only. Locutions, seat vocabularies (`allowedActionsFor`),
- *   termination, and turn-cap semantics are untouched.
- * - **Default-off**: gated on `NEGOTIATION_DEADLOCK_SHIFT_ENABLED === "true"`
- *   (strict literal) and applied only to v2 negotiations, checked alongside the
- *   protocol-version plumbing. When off, the legacy path is byte-identical.
- * - **Fail-open**: any detection error means "no deadlock" — advisory
- *   infrastructure never blocks a negotiation.
- */
-import { stanceResolvesDeadlockByStalemate } from "./negotiation.stance.contracts.js";
-// ─── Configuration ───────────────────────────────────────────────────────────
-/**
- * Whether the deadlock→bargaining mode shift is enabled, from the
- * `NEGOTIATION_DEADLOCK_SHIFT_ENABLED` env switch. Strict literal `"true"`
- * only — the deployment is byte-for-byte unchanged until the flag is flipped,
- * and rolling back is the same single switch.
- */
-export function configuredDeadlockShiftEnabled() {
-    return process.env.NEGOTIATION_DEADLOCK_SHIFT_ENABLED === "true";
-}
-/**
- * Default deadlock threshold: 4 consecutive non-convergent turns. Sized
- * against the ambient turn cap (6): an outreach plus 4 unbroken counters
- * leaves exactly the closing turns to draft in the bargaining stance.
- */
-export const DEFAULT_DEADLOCK_THRESHOLD = 4;
-/**
- * Lower bound on the configurable threshold. Below 2 the "stalemate" signal is
- * meaningless — a single counter is ordinary dialogue, not a deadlock.
- */
-export const MIN_DEADLOCK_THRESHOLD = 2;
-/**
- * Consecutive non-convergent turns that constitute a deadlock, from
- * `NEGOTIATION_DEADLOCK_THRESHOLD`. Must be an integer >= 2; invalid,
- * non-integer, or out-of-range values fall back to the default (fail-open
- * toward the documented behavior, mirroring `askUserAnswerWindowMs`).
- */
-export function configuredDeadlockThreshold() {
-    const raw = process.env.NEGOTIATION_DEADLOCK_THRESHOLD;
-    if (raw) {
-        const parsed = Number(raw);
-        if (Number.isInteger(parsed) && parsed >= MIN_DEADLOCK_THRESHOLD)
-            return parsed;
-    }
-    return DEFAULT_DEADLOCK_THRESHOLD;
-}
-// ─── Detection ───────────────────────────────────────────────────────────────
-/**
- * The locutions that count toward a stalemate: challenges and information
- * requests that keep the dialogue open without converging. Everything else —
- * openings (`propose`/`outreach`: a fresh case is on the table), terminal
- * actions (the game is deciding, not stalling), and `ask_user` (new principal
- * input is about to arrive) — RESETS the run to zero. Unknown/missing actions
- * also reset (conservative: never manufacture a deadlock from unreadable data).
- */
-const NON_CONVERGENT_ACTIONS = new Set(["counter", "question"]);
-/**
- * Deterministic stalemate detector: measures the maximal *trailing* run of
- * non-convergent turns (`counter`/`question`) in the persisted history and
- * compares it against the threshold. Continuation histories are included by
- * construction — the caller passes the full turn list, so a deadlock spanning
- * sessions still counts.
- *
- * Pure state inspection; no LLM, no I/O, no clock.
- */
-export function assessDeadlock(history, threshold = DEFAULT_DEADLOCK_THRESHOLD) {
-    const effectiveThreshold = Number.isInteger(threshold) && threshold >= MIN_DEADLOCK_THRESHOLD
-        ? threshold
-        : DEFAULT_DEADLOCK_THRESHOLD;
-    let run = 0;
-    for (let i = history.length - 1; i >= 0; i--) {
-        const action = history[i]?.action;
-        if (typeof action === "string" && NON_CONVERGENT_ACTIONS.has(action)) {
-            run += 1;
-        }
-        else {
-            break;
-        }
-    }
-    return {
-        deadlocked: run >= effectiveThreshold,
-        consecutiveNonConvergent: run,
-        threshold: effectiveThreshold,
-    };
-}
-// ─── Internal shift record (task metadata JSONB, never public) ──────────────
-// ─── Prompt section (system agent drafting stance) ──────────────────────────
-const BARGAINING_SHIFT_SECTION = `
-
-DEADLOCK — SHIFT FROM PERSUASION TO BARGAINING. The last {consecutive} turns were counters/questions without convergence: the merits have been argued and restating them will not move the other side. For this turn, change stance:
-- Do NOT re-argue fit or repeat points already made.
-- Offer a concrete concession or scope reduction instead: a smaller first step (a single intro call, a scoped trial, a narrower version of the collaboration), dropping a contested requirement, or a trade on a dimension not yet contested.
-- Make the remaining objection priceable: name the specific smaller commitment that would resolve it.{askUserEscalation}
-- If no reduced scope would genuinely serve {userName}'s interests, conclude decisively with a terminal action from your allowed set rather than another repetitive counter.
-This shift changes your stance only — your available actions are unchanged.`;
-const BARGAINING_ASK_USER_ESCALATION = `
-- If a concession would require {userName}'s own input or permission (budget, availability, private details), escalate with "ask_user" instead of guessing.`;
-/**
- * Skeptic-stance deadlock resolution (IND-611). Under `NEGOTIATOR_STANCE=skeptic`
- * a stalemate resolves as a stalemate rather than by bargaining: the designed
- * outcome of persistent disagreement stops being "a smaller match" and becomes
- * "possibly no match". Same trigger, same threshold, same actions — only the
- * drafting stance differs. `advocate`/`evaluator` keep the bargaining section
- * byte-identical.
- */
-const STALEMATE_SHIFT_SECTION = `
-
-DEADLOCK — THE MERITS ARE EXHAUSTED. The last {consecutive} turns were counters/questions without convergence: the merits have been argued and restating them will not move the other side. For this turn, change stance:
-- Do NOT re-argue fit or repeat points already made.
-- Do NOT buy agreement with a concession or a reduced scope. A shrunken version of a match that could not be agreed on its merits is usually worth less of {userName}'s attention than the full one was, not more.
-- Name the ONE specific thing that would genuinely change your assessment. If it has not appeared after this many turns, it is unlikely to.
-- Absent that, conclude decisively with a terminal action from your allowed set. An unresolved disagreement is an acceptable outcome; a match made to end the disagreement is not.
-This shift changes your stance only — your available actions are unchanged.`;
-/**
- * Renders the deadlock-stance prompt section. Returns the empty string when
- * the shift is not active, so the rendered system prompt is byte-identical to
- * the legacy build on every non-shifted turn (mirrors
- * `renderNegotiatorMemorySection`). The `ask_user` escalation line renders
- * only when the caller already legally holds the action (`canAskUser`) — the
- * shift never invents a locution.
- *
- * IND-611: `stance` selects which resolution the shift drafts toward —
- * bargaining (`advocate`/`evaluator`, the default and today's behavior) or
- * stalemate (`skeptic`). Omitted → bargaining, byte-identical to before.
- */
-export function renderBargainingShiftSection(input) {
-    if (!input.active)
-        return "";
-    if (input.stance && stanceResolvesDeadlockByStalemate(input.stance)) {
-        return STALEMATE_SHIFT_SECTION
-            .replace("{consecutive}", String(input.consecutiveNonConvergent))
-            .replace(/{userName}/g, input.userName);
-    }
-    return BARGAINING_SHIFT_SECTION
-        .replace("{consecutive}", String(input.consecutiveNonConvergent))
-        .replace("{askUserEscalation}", input.canAskUser ? BARGAINING_ASK_USER_ESCALATION : "")
-        .replace(/{userName}/g, input.userName);
-}

package/dist/negotiations/negotiation.detail-reader.d.ts

@@ -1,94 +0,0 @@
-import type { NegotiationOpportunityLifecycle } from '../shared/interfaces/database.interface.js';
-import type { SeedAssessment, UserNegotiationContext } from './negotiation.state.js';
-export interface AuthorizedNegotiationDetailTask {
-    id: string;
-    conversationId: string;
-    state: string;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface AuthorizedNegotiationDetailMetadata {
-    sourceUserId?: string;
-    candidateUserId?: string;
-    initiatorUserId?: string;
-    protocolVersion?: string;
-    maxTurns?: number;
-    opportunityId?: string;
-    isContinuation?: boolean;
-    priorTurnCount?: number;
-    turnContext?: {
-        sourceUser: UserNegotiationContext;
-        candidateUser: UserNegotiationContext;
-        indexContext: {
-            networkId: string;
-            prompt?: string;
-        };
-        seedAssessment: SeedAssessment;
-        discoveryQuery?: string;
-    };
-}
-export interface NegotiationDetailMessage {
-    senderId: string;
-    parts: unknown[];
-    createdAt: Date;
-}
-export interface NegotiationDetailArtifact {
-    name: string | null;
-    parts: unknown[];
-}
-export interface AuthorizedNegotiationDetailReaderInput {
-    task: AuthorizedNegotiationDetailTask;
-    metadata: AuthorizedNegotiationDetailMetadata;
-    callerUserId: string;
-    callerRole: 'source' | 'candidate';
-    readMessages: (conversationId: string) => Promise<NegotiationDetailMessage[]>;
-    readArtifacts: (taskId: string) => Promise<NegotiationDetailArtifact[]>;
-    readLifecycleEvidence: (opportunityIds: string[], ownerUserId: string) => Promise<Record<string, NegotiationOpportunityLifecycle>>;
-}
-/**
- * Projects an already-authorized negotiation task into the caller's detail
- * response. Admission and scope/privacy decisions stay in the tools facade;
- * this reader owns only parallel reads and deterministic response shaping.
- */
-export declare function readAuthorizedNegotiationDetail(input: AuthorizedNegotiationDetailReaderInput): Promise<{
-    id: string;
-    conversationId: string;
-    conversationType: "agent_negotiation";
-    status: string;
-    role: "source" | "candidate";
-    seat: import("../index.js").NegotiationSeat;
-    protocolVersion: import("../index.js").NegotiationProtocolVersion;
-    allowedActions: readonly ("propose" | "accept" | "reject" | "counter" | "question" | "outreach" | "withdraw" | "decline" | "ask_user")[];
-    counterpartyId: string;
-    turnCount: number;
-    isUsersTurn: boolean;
-    isContinuation: boolean;
-    priorTurnCount: number;
-    turnsAdded: number;
-    turns: {
-        turnNumber: number;
-        speaker: string;
-        senderId: string;
-        action: string;
-        actionActor: "agent";
-        reasoning: string | null;
-        suggestedRoles: {} | null;
-        message: string | null;
-        createdAt: Date;
-    }[];
-    outcome: unknown;
-    lifecycle: import("./negotiation.lifecycle-narration.js").NegotiationLifecycleNarration;
-    context: {
-        discoveryQuery?: string | undefined;
-        ownUser: UserNegotiationContext;
-        otherUser: UserNegotiationContext;
-        indexContext: {
-            networkId: string;
-            prompt?: string;
-        };
-        seedAssessment: SeedAssessment;
-        isDiscoverer: boolean;
-    } | null;
-    createdAt: Date;
-    updatedAt: Date;
-}>;

package/dist/negotiations/negotiation.detail-reader.js

@@ -1,91 +0,0 @@
-import { expectedNegotiationSpeaker } from './negotiation.expected-speaker.js';
-import { buildLifecycleNarration } from './negotiation.lifecycle-narration.js';
-import { allowedActionsFor, readProtocolVersion, resolveSeat } from './negotiation.protocol.js';
-/**
- * Projects an already-authorized negotiation task into the caller's detail
- * response. Admission and scope/privacy decisions stay in the tools facade;
- * this reader owns only parallel reads and deterministic response shaping.
- */
-export async function readAuthorizedNegotiationDetail(input) {
-    const { task, metadata, callerUserId, callerRole } = input;
-    const isSource = callerRole === 'source';
-    const counterpartyId = isSource ? metadata.candidateUserId : metadata.sourceUserId;
-    const negotiationContext = metadata.turnContext
-        ? {
-            ownUser: isSource ? metadata.turnContext.sourceUser : metadata.turnContext.candidateUser,
-            otherUser: isSource ? metadata.turnContext.candidateUser : metadata.turnContext.sourceUser,
-            indexContext: metadata.turnContext.indexContext,
-            seedAssessment: metadata.turnContext.seedAssessment,
-            isDiscoverer: isSource,
-            ...(metadata.turnContext.discoveryQuery && { discoveryQuery: metadata.turnContext.discoveryQuery }),
-        }
-        : null;
-    const lifecycleOpportunityId = metadata.opportunityId?.trim() || undefined;
-    // These independent reads must stay concurrent: message/artifact latency must
-    // not delay lifecycle evidence, and missing lifecycle evidence remains fail-open.
-    const [messages, artifacts, opportunityLifecycles] = await Promise.all([
-        input.readMessages(task.conversationId),
-        input.readArtifacts(task.id),
-        input.readLifecycleEvidence(lifecycleOpportunityId ? [lifecycleOpportunityId] : [], callerUserId),
-    ]);
-    // Sender IDs, rather than parity, determine continuation turns. The parity
-    // fallback is retained for legacy rows that do not record a sender ID.
-    const turns = messages.map((message, index) => {
-        const dataPart = message.parts?.find((part) => part.kind === 'data');
-        const turnData = dataPart?.data;
-        const turnNumber = index + 1;
-        const speaker = message.senderId
-            ? (message.senderId === `agent:${metadata.sourceUserId}` ? 'source' : 'candidate')
-            : (turnNumber % 2 === 1 ? 'source' : 'candidate');
-        return {
-            turnNumber,
-            speaker,
-            senderId: message.senderId,
-            action: turnData?.action ?? 'unknown',
-            actionActor: 'agent',
-            reasoning: turnData?.assessment?.reasoning ?? null,
-            suggestedRoles: turnData?.assessment?.suggestedRoles ?? null,
-            message: turnData?.message ?? null,
-            createdAt: message.createdAt,
-        };
-    });
-    const outcomeArtifact = artifacts.find((artifact) => artifact.name === 'negotiation-outcome');
-    const outcome = outcomeArtifact
-        ? outcomeArtifact.parts?.find((part) => part.kind === 'data')?.data
-        : null;
-    const turnCount = messages.length;
-    const expectedSpeaker = expectedNegotiationSpeaker(metadata, messages);
-    const status = task.state === 'working' ? 'active'
-        : task.state === 'waiting_for_agent' ? 'waiting_for_agent'
-            : task.state === 'completed' ? 'completed'
-                : task.state;
-    const isUsersTurn = status !== 'completed' && expectedSpeaker === callerUserId;
-    const protocolVersion = readProtocolVersion(metadata) ?? 'v1';
-    const seat = resolveSeat(callerUserId, metadata);
-    const priorTurnCount = metadata.priorTurnCount ?? 0;
-    return {
-        id: task.id,
-        conversationId: task.conversationId,
-        conversationType: 'agent_negotiation',
-        status,
-        role: callerRole,
-        seat,
-        protocolVersion,
-        allowedActions: allowedActionsFor(protocolVersion, seat),
-        counterpartyId: counterpartyId ?? 'unknown',
-        turnCount,
-        isUsersTurn,
-        isContinuation: metadata.isContinuation ?? false,
-        priorTurnCount,
-        // Clamped: `turnCount` is match-scoped, but a task stamped before that
-        // change carries a conversation-wide `priorTurnCount`, which would other-
-        // wise report a negative delta for negotiations in flight across the deploy.
-        turnsAdded: Math.max(0, turnCount - priorTurnCount),
-        turns,
-        outcome,
-        lifecycle: buildLifecycleNarration(status, lifecycleOpportunityId ? opportunityLifecycles[lifecycleOpportunityId] : undefined),
-        context: negotiationContext,
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
-    };
-}

package/dist/negotiations/negotiation.expected-speaker.d.ts

@@ -1,33 +0,0 @@
-export interface NegotiationSpeakerParticipants {
-    sourceUserId?: unknown;
-    candidateUserId?: unknown;
-    /**
-     * The seat that opens this negotiation (v2 stamp). An unopened negotiation
-     * starts with its initiator; `sourceUserId` is the pre-stamp fallback, which
-     * is what the stamp defaults to anyway.
-     */
-    initiatorUserId?: unknown;
-}
-export interface NegotiationSpeakerMessage {
-    senderId?: unknown;
-    parts?: unknown;
-}
-/**
- * Resolves the participant whose agent owns the next canonical bilateral turn.
- *
- * `messages` must be THIS negotiation's messages (see
- * `getNegotiationMessages`), never the whole conversation. Two agents share one
- * DM across every match they are ever paired on, so conversation-scoped parity
- * makes a fresh negotiation inherit the turn order of an unrelated, concluded
- * one — handing the floor to the counterparty, who may `accept` immediately and
- * conclude the match before its initiator has spoken.
- *
- * Participant identities must be nonempty and distinct. Unrelated agent,
- * system, and owner-settlement messages are ignored while finding the latest
- * source/candidate message. An ordinary canonical message passes the floor to
- * the other participant; `ask_user` retains it for the consulting sender's
- * exact successor. A negotiation with no canonical history of its own has not
- * opened yet, so it starts with its initiator. Invalid participant metadata
- * always fails closed.
- */
-export declare function expectedNegotiationSpeaker(participants: NegotiationSpeakerParticipants, messages: readonly NegotiationSpeakerMessage[]): string | null;