@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/opportunities/discriminator/discriminator.question.js

@@ -1,155 +0,0 @@
-import { POOL_DISCRIMINATOR_MIN_POOL_SIZE, POOL_QUESTION_MAX_DISCRIMINATORS, POOL_QUESTION_MIN_EVIDENCE_RATE, POOL_QUESTION_MIN_VOI } from "./discriminator.env.js";
-/** Fixed option appended to every pool question — the no-preference escape. */
-export const BOTH_MATTER_LABEL = "Both matter";
-/** Max words in a chip-style option label (prototype voice: terse, glanceable). */
-const MAX_LABEL_WORDS = 5;
-/** Question title (≤12 chars, per QuestionSchema). */
-const POOL_QUESTION_TITLE = "Matches";
-/**
- * Converts a scored discriminator into the compact snapshot form stored on
- * the question row (verified assignments only; unknowns dropped).
- */
-export function toQuestionDiscriminator(d) {
-    const sideCounts = {};
-    for (const side of d.sides)
-        sideCounts[side] = 0;
-    const assignments = [];
-    for (const a of d.assignments) {
-        if (a.side === null || !a.verified)
-            continue;
-        if (!(a.side in sideCounts))
-            continue;
-        sideCounts[a.side] += 1;
-        assignments.push({ opportunityId: a.id, side: a.side });
-    }
-    return {
-        label: d.label,
-        questionSeed: d.questionSeed,
-        sides: d.sides,
-        sideCounts,
-        voi: d.voi,
-        evidenceRate: d.evidenceRate,
-        ...(d.embedding ? { embedding: d.embedding } : {}),
-        ...(d.embeddingModel ? { embeddingModel: d.embeddingModel } : {}),
-        assignments,
-    };
-}
-/**
- * Filters a mining pass down to question-eligible discriminators:
- * VoI ≥ {@link POOL_QUESTION_MIN_VOI}, evidenceRate ≥
- * {@link POOL_QUESTION_MIN_EVIDENCE_RATE}, capped at
- * {@link POOL_QUESTION_MAX_DISCRIMINATORS}. Input is already VoI-sorted.
- */
-export function selectQuestionDiscriminators(discriminators) {
-    return discriminators
-        .filter((d) => d.voi >= POOL_QUESTION_MIN_VOI && d.evidenceRate >= POOL_QUESTION_MIN_EVIDENCE_RATE)
-        .slice(0, POOL_QUESTION_MAX_DISCRIMINATORS);
-}
-/** Truncates a side label to the chip word budget. */
-function chipLabel(side) {
-    const words = side.trim().split(/\s+/);
-    return words.slice(0, MAX_LABEL_WORDS).join(" ");
-}
-/**
- * Miner seeds are sometimes written from the intent owner's POV ("Do I
- * prefer…"). The question is asked TO the owner, so normalize to second
- * person. Conservative verb-pair map + bare pronoun/possessive swaps.
- */
-function toSecondPerson(seed) {
-    return seed
-        .replace(/\b(do|should|would|could|can|will) I\b/gi, (_, verb) => `${verb.toLowerCase()} you`)
-        .replace(/\bam I\b/gi, "are you")
-        .replace(/\bI\b/g, "you")
-        .replace(/\bmy\b/gi, "your")
-        // Third-person seeds ("Is the user primarily involved…") — the question is
-        // asked TO the owner, never ABOUT them.
-        .replace(/\b(is|was) (?:the|this) (user|owner|discoverer|client)\b/gi, "are you")
-        .replace(/\bdoes (?:the|this) (user|owner|discoverer|client)\b/gi, "do you")
-        .replace(/\b(?:the|this) (user|owner|discoverer|client)'s\b/gi, "your")
-        .replace(/\b(?:the|this) (user|owner|discoverer|client)\b/gi, "you");
-}
-/**
- * Catch-all: after normalization the prompt must be second-person. Any
- * residual third-person reference to the owner means an unanticipated seed
- * shape slipped through — the deterministic two-sided template (always
- * second-person) is the safe fallback.
- */
-function isStillThirdPerson(prompt) {
-    return /\b(?:the|this|a) (?:user|owner|discoverer|client)\b/i.test(prompt);
-}
-/**
- * A good discriminator prompt names BOTH sides so the chips read as a real
- * choice. When the seed mentions fewer than two sides (e.g. "Do you prefer
- * hands-on prototyping?"), fall back to a deterministic two-sided template.
- */
-function mentionsSide(seed, side) {
-    const lowerSeed = seed.toLowerCase();
-    return side
-        .toLowerCase()
-        .split(/[^a-z0-9-]+/)
-        .filter((w) => w.length > 3)
-        .some((w) => lowerSeed.includes(w));
-}
-/** Ensures the prompt reads as one second-person, two-sided question. */
-function toPrompt(questionSeed, sides) {
-    let p = toSecondPerson(questionSeed.trim().replace(/\s+/g, " "));
-    const sidesMentioned = sides.filter((s) => mentionsSide(p, s)).length;
-    if (sidesMentioned < 2 || isStillThirdPerson(p)) {
-        const last = sides[sides.length - 1];
-        const head = sides.slice(0, -1).join(", ");
-        p = `Which matters more here: ${head} or ${last}`;
-    }
-    // Sentence-case the first character (template + normalization can lowercase it).
-    p = p.charAt(0).toUpperCase() + p.slice(1);
-    if (!/[?]$/.test(p))
-        p = p.replace(/[.!]+$/, "") + "?";
-    return p.slice(0, 400);
-}
-/**
- * Builds the pool_discovery question. Returns null when the pool is below
- * the k-anonymity floor or the discriminator shape is unusable (guards are
- * duplicated here so no caller can bypass them).
- */
-export function synthesizePoolQuestion(input) {
-    const { discriminator: d, poolSize } = input;
-    if (poolSize < POOL_DISCRIMINATOR_MIN_POOL_SIZE)
-        return null;
-    if (d.sides.length < 2 || d.sides.length > 3)
-        return null;
-    // Evidence chip: aggregate count + the intent it belongs to, so the card is
-    // self-identifying on every surface (QuestionSchema caps evidence at 160).
-    const snippet = input.intentText?.trim().replace(/\s+/g, " ") ?? "";
-    const evidence = snippet.length > 0
-        ? `based on ${poolSize} people matching “${snippet.slice(0, 110)}${snippet.length > 110 ? "…" : ""}”`
-        : `based on ${poolSize} people matching this intent`;
-    const sideOptions = d.sides.map((side) => ({
-        label: chipLabel(side),
-        description: `${d.sideCounts[side] ?? 0} of your ${poolSize} current matches lean this way`,
-    }));
-    const options = [
-        ...sideOptions,
-        {
-            label: BOTH_MATTER_LABEL,
-            description: "No preference — keep the current ranking",
-        },
-    ];
-    return {
-        payload: {
-            title: POOL_QUESTION_TITLE,
-            prompt: toPrompt(d.questionSeed, d.sides),
-            options,
-            multiSelect: false,
-            evidence,
-        },
-        pool: {
-            poolSize,
-            opportunityIds: [...input.opportunityIds],
-            minedAt: input.minedAt,
-            ...(input.runId ? { runId: input.runId } : {}),
-            ...(snippet.length > 0 ? { intentText: snippet.slice(0, 160) } : {}),
-            ...(input.intentFingerprint ? { intentFingerprint: input.intentFingerprint } : {}),
-            discriminator: d,
-            alternates: input.alternates,
-        },
-    };
-}

package/dist/opportunities/discriminator/discriminator.scorer.d.ts

@@ -1,32 +0,0 @@
-/**
- * Pool-axis VoI scorer — pure functions, no LLM, no I/O (IND-417).
- *
- * VoI = H_norm × coverage^1.5 × novelty
- *
- *   H_norm    score-weighted entropy over the axis sides, normalized by
- *             log2(k). Entropy is computed over candidate *score mass*
- *             (confidence weights), not head counts, so a balanced split of
- *             low-confidence junk-tail candidates doesn't inflate VoI.
- *   coverage  fraction of total pool score mass with a verified side
- *             assignment. The ^1.5 exponent is the anti-vague-axis knob:
- *             axes the LLM couldn't ground in evidence lose fast.
- *   novelty   1 − max cosine similarity between the axis embedding and
- *             reference embeddings (existing premises, intent sentences).
- *             An axis the user has already answered elsewhere scores ~0.
- */
-import type { MinedDiscriminator, PoolCandidate, ScoredDiscriminator } from "./discriminator.types.js";
-/** Cosine similarity of two equal-length vectors, in [-1, 1]. 0 for degenerate input. */
-export declare function cosineSimilarity(a: number[], b: number[]): number;
-/**
- * Novelty of an axis vs reference texts: 1 − max cosine similarity, clamped
- * to [0, 1]. No references → 1 (fully novel).
- */
-export declare function computeNovelty(axisEmbedding: number[], referenceEmbeddings: number[][]): number;
-/**
- * Score one mined axis against its pool.
- *
- * @param axis        Mined axis with verified assignments (one per candidate).
- * @param candidates  The pool (provides score mass per candidate id).
- * @param novelty     Precomputed novelty in [0,1] (see {@link computeNovelty}).
- */
-export declare function scoreDiscriminator(axis: MinedDiscriminator, candidates: PoolCandidate[], novelty: number): ScoredDiscriminator;

package/dist/opportunities/discriminator/discriminator.scorer.js

@@ -1,105 +0,0 @@
-/**
- * Pool-axis VoI scorer — pure functions, no LLM, no I/O (IND-417).
- *
- * VoI = H_norm × coverage^1.5 × novelty
- *
- *   H_norm    score-weighted entropy over the axis sides, normalized by
- *             log2(k). Entropy is computed over candidate *score mass*
- *             (confidence weights), not head counts, so a balanced split of
- *             low-confidence junk-tail candidates doesn't inflate VoI.
- *   coverage  fraction of total pool score mass with a verified side
- *             assignment. The ^1.5 exponent is the anti-vague-axis knob:
- *             axes the LLM couldn't ground in evidence lose fast.
- *   novelty   1 − max cosine similarity between the axis embedding and
- *             reference embeddings (existing premises, intent sentences).
- *             An axis the user has already answered elsewhere scores ~0.
- */
-/** Cosine similarity of two equal-length vectors, in [-1, 1]. 0 for degenerate input. */
-export function cosineSimilarity(a, b) {
-    if (a.length === 0 || a.length !== b.length)
-        return 0;
-    let dot = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    if (normA === 0 || normB === 0)
-        return 0;
-    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-/**
- * Novelty of an axis vs reference texts: 1 − max cosine similarity, clamped
- * to [0, 1]. No references → 1 (fully novel).
- */
-export function computeNovelty(axisEmbedding, referenceEmbeddings) {
-    if (referenceEmbeddings.length === 0)
-        return 1;
-    let maxSim = 0;
-    for (const ref of referenceEmbeddings) {
-        const sim = cosineSimilarity(axisEmbedding, ref);
-        if (sim > maxSim)
-            maxSim = sim;
-    }
-    return Math.min(1, Math.max(0, 1 - maxSim));
-}
-/**
- * Weight for one candidate's score mass. Negative/NaN scores contribute 0;
- * when the whole pool has zero mass the caller falls back to count weights.
- */
-function massOf(score) {
-    return Number.isFinite(score) && score > 0 ? score : 0;
-}
-/**
- * Score one mined axis against its pool.
- *
- * @param axis        Mined axis with verified assignments (one per candidate).
- * @param candidates  The pool (provides score mass per candidate id).
- * @param novelty     Precomputed novelty in [0,1] (see {@link computeNovelty}).
- */
-export function scoreDiscriminator(axis, candidates, novelty) {
-    const massById = new Map();
-    let totalMass = 0;
-    for (const c of candidates) {
-        const m = massOf(c.score);
-        massById.set(c.id, m);
-        totalMass += m;
-    }
-    // Degenerate pool (all zero/invalid scores): fall back to count weights.
-    const useCounts = totalMass <= 0;
-    if (useCounts) {
-        totalMass = candidates.length;
-        for (const c of candidates)
-            massById.set(c.id, 1);
-    }
-    const sideMass = new Map();
-    let assignedMass = 0;
-    for (const a of axis.assignments) {
-        if (a.side === null || !a.verified)
-            continue;
-        if (!axis.sides.includes(a.side))
-            continue;
-        const m = massById.get(a.id) ?? 0;
-        if (m <= 0)
-            continue;
-        sideMass.set(a.side, (sideMass.get(a.side) ?? 0) + m);
-        assignedMass += m;
-    }
-    const k = axis.sides.length;
-    let entropy = 0;
-    if (assignedMass > 0 && k >= 2) {
-        let h = 0;
-        for (const mass of sideMass.values()) {
-            const p = mass / assignedMass;
-            if (p > 0)
-                h -= p * Math.log2(p);
-        }
-        entropy = h / Math.log2(k);
-    }
-    const coverage = totalMass > 0 ? assignedMass / totalMass : 0;
-    const clampedNovelty = Math.min(1, Math.max(0, novelty));
-    const voi = entropy * Math.pow(coverage, 1.5) * clampedNovelty;
-    return { ...axis, entropy, coverage, novelty: clampedNovelty, voi };
-}

package/dist/opportunities/discriminator/discriminator.shadow.d.ts

@@ -1,32 +0,0 @@
-import type { EmbeddingGenerator } from "../../shared/interfaces/embedder.interface.js";
-import type { PoolDiscriminatorMiner } from "./discriminator.miner.js";
-import type { PoolCandidate, DiscriminatorShadowResult } from "./discriminator.types.js";
-/** Input for one shadow mining+scoring pass. */
-export interface DiscriminatorShadowInput {
-    /** Intent payload (+ summary) or search query that produced the pool. */
-    intentText: string;
-    /** The pool (already filtered/capped by the caller). */
-    candidates: PoolCandidate[];
-    /**
-     * Novelty references: the intent owner's active premise texts and intent
-     * sentences. An axis semantically equal to any reference scores ~0.
-     */
-    referenceTexts: string[];
-    /** Legacy/model-mismatched resolved axes re-embedded with an independent budget. */
-    priorReferenceTexts?: string[];
-    /** Fresh resolved-axis vectors generated by the current embedding model. */
-    priorReferenceEmbeddings?: number[][];
-    /** Model used for current axis embeddings and persisted metadata. */
-    embeddingModel?: string;
-    /** Retain generated axis vectors on results for durable question snapshots. */
-    retainEmbeddings?: boolean;
-    miner: Pick<PoolDiscriminatorMiner, "mine">;
-    embedder: EmbeddingGenerator;
-    signal?: AbortSignal;
-}
-/**
- * Runs miner → embeddings → scorer. Throws only when *mining* fails (callers
- * are fire-and-forget); embedding failures degrade to novelty = 1 for all
- * discriminators rather than dropping the pass.
- */
-export declare function runPoolDiscriminatorShadow(input: DiscriminatorShadowInput): Promise<DiscriminatorShadowResult>;

package/dist/opportunities/discriminator/discriminator.shadow.js

@@ -1,90 +0,0 @@
-/**
- * Shadow orchestrator: mine discriminators for a pool, embed them, score VoI, and
- * return the log payload (IND-417). No persistence, no questions, no UI —
- * P1 output is consumed only by structured logs for human review.
- */
-import { protocolLogger } from "../../shared/observability/protocol.logger.js";
-import { computeNovelty, scoreDiscriminator } from "./discriminator.scorer.js";
-const logger = protocolLogger("PoolDiscriminatorShadow");
-/** Max ordinary current-intent/premise text references compared for novelty. */
-const MAX_REFERENCE_TEXTS = 24;
-/** Text embedded per discriminator for the novelty comparison. */
-function discriminatorEmbeddingText(d) {
-    return `${d.label} — ${d.questionSeed}`;
-}
-/**
- * Runs miner → embeddings → scorer. Throws only when *mining* fails (callers
- * are fire-and-forget); embedding failures degrade to novelty = 1 for all
- * discriminators rather than dropping the pass.
- */
-export async function runPoolDiscriminatorShadow(input) {
-    const { candidates } = input;
-    const mined = await input.miner.mine({ intentText: input.intentText, candidates }, input.signal ? { signal: input.signal } : undefined);
-    if (mined.length === 0) {
-        return { poolSize: candidates.length, discriminators: [] };
-    }
-    const references = input.referenceTexts
-        .map((t) => t.trim())
-        .filter((t) => t.length > 0)
-        .slice(0, MAX_REFERENCE_TEXTS);
-    const priorReferenceTexts = (input.priorReferenceTexts ?? [])
-        .map((text) => text.trim())
-        .filter((text) => text.length > 0);
-    const priorReferenceEmbeddings = (input.priorReferenceEmbeddings ?? [])
-        .filter((embedding) => embedding.length > 0);
-    const hasPriorReferenceHistory = priorReferenceTexts.length > 0 || priorReferenceEmbeddings.length > 0;
-    let novelties = mined.map(() => 1);
-    let discriminatorEmbeddings = null;
-    let priorReferenceComparisonUnavailable = false;
-    const shouldEmbed = input.retainEmbeddings
-        || references.length > 0
-        || hasPriorReferenceHistory;
-    if (shouldEmbed) {
-        try {
-            const texts = [
-                ...mined.map(discriminatorEmbeddingText),
-                ...references,
-                ...priorReferenceTexts,
-            ];
-            const embeddings = (await input.embedder.generate(texts));
-            if (embeddings.length !== texts.length || embeddings.some((embedding) => !Array.isArray(embedding) || embedding.length === 0)) {
-                throw new Error("Embedding provider returned an invalid batch");
-            }
-            const comparisonEmbeddings = [...embeddings, ...priorReferenceEmbeddings];
-            const dimension = comparisonEmbeddings[0]?.length;
-            if (dimension !== undefined && comparisonEmbeddings.some((embedding) => embedding.length !== dimension)) {
-                throw new Error("Embedding comparison batch contains incompatible vector dimensions");
-            }
-            discriminatorEmbeddings = embeddings.slice(0, mined.length);
-            const referenceEmbeddings = [
-                ...priorReferenceEmbeddings,
-                ...embeddings.slice(mined.length),
-            ];
-            novelties = discriminatorEmbeddings.map((embedding) => computeNovelty(embedding, referenceEmbeddings));
-        }
-        catch (err) {
-            logger.warn("Novelty embedding failed; defaulting novelty to 1", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-            priorReferenceComparisonUnavailable = hasPriorReferenceHistory;
-        }
-    }
-    const discriminators = mined
-        .map((d, i) => {
-        const scored = scoreDiscriminator(d, candidates, novelties[i]);
-        const embedding = input.retainEmbeddings ? discriminatorEmbeddings?.[i] : undefined;
-        return embedding
-            ? {
-                ...scored,
-                embedding,
-                ...(input.embeddingModel ? { embeddingModel: input.embeddingModel } : {}),
-            }
-            : scored;
-    })
-        .sort((a, b) => b.voi - a.voi);
-    return {
-        poolSize: candidates.length,
-        discriminators,
-        ...(priorReferenceComparisonUnavailable ? { priorReferenceComparisonUnavailable: true } : {}),
-    };
-}

package/dist/opportunities/discriminator/discriminator.types.d.ts

@@ -1,93 +0,0 @@
-/**
- * Pool discriminator mining — shared types (IND-416 / IND-417).
- *
- * A "pool discriminator" is a preference dimension that splits a discovery-run
- * candidate pool into meaningfully different groups (e.g. "hands-on builders
- * vs advisors"). Discriminators are mined by one structured LLM pass, then
- * scored deterministically (VoI = entropy × coverage^1.5 × novelty) so the
- * highest value question can eventually be asked to the intent owner.
- *
- * Vocabulary note: the LLM wire format (prompt + response schema in the miner)
- * speaks of "axes" with mutually exclusive "sides" — the clearest way to
- * explain the concept to the model. Everything the rest of the codebase
- * touches (types, exports, logs) uses "discriminator".
- *
- * P1 (shadow) uses these types for log-only output; later phases reuse them
- * for question synthesis and answer application.
- */
-/** One candidate in the pool as supplied to the miner LLM. */
-export interface PoolCandidate {
-    /** Opportunity id (stable key for later answer application). */
-    id: string;
-    /**
-     * The exact public-context string shown to the LLM for this candidate
-     * (name + bio + matchReason + headline + premise snippets, ≤400 chars).
-     * Evidence spans are substring-verified against this exact string.
-     */
-    publicContext: string;
-    /** Candidate confidence/score — the mass used for score-weighted entropy. */
-    score: number;
-}
-/** Input envelope for one mining pass. */
-export interface DiscriminatorMiningInput {
-    /** Intent payload (+ summary) or ad-hoc search query that produced the pool. */
-    intentText: string;
-    candidates: PoolCandidate[];
-}
-/**
- * One candidate assignment on a discriminator, after code-side evidence verification.
- * `side === null` means unknown (LLM abstained, evidence failed verification,
- * or the candidate was missing from the LLM output).
- */
-export interface VerifiedAssignment {
-    /** Candidate (opportunity) id. */
-    id: string;
-    /** Verified side label (one of the discriminator's sides), or null = unknown. */
-    side: string | null;
-    /** The evidence span quoted by the LLM (kept for logging/audit), if any. */
-    evidence: string | null;
-    /**
-     * True when the LLM proposed a side AND its evidence span substring-matched
-     * the candidate's publicContext. False for demoted-to-unknown proposals.
-     */
-    verified: boolean;
-}
-/** One mined discriminator after evidence verification (pre-scoring). */
-export interface MinedDiscriminator {
-    /** Short discriminator label, e.g. "Hands-on builders vs strategic advisors". */
-    label: string;
-    /** A question the intent owner could be asked to resolve the discriminator. */
-    questionSeed: string;
-    /** 2–3 mutually exclusive side labels. */
-    sides: string[];
-    /** Exactly one entry per pool candidate. */
-    assignments: VerifiedAssignment[];
-    /**
-     * verified-proposals / total side proposals from the LLM for this discriminator
-     * (0 when the LLM proposed no sides at all). The hallucination health metric.
-     */
-    evidenceRate: number;
-}
-/** A mined discriminator with its deterministic VoI score components. */
-export interface ScoredDiscriminator extends MinedDiscriminator {
-    /** Current discriminator embedding retained for durable semantic dedup. */
-    embedding?: number[];
-    /** Model that generated {@link embedding}. */
-    embeddingModel?: string;
-    /** Normalized score-weighted entropy over sides, in [0,1]. */
-    entropy: number;
-    /** Assigned score mass / total pool score mass, in [0,1]. */
-    coverage: number;
-    /** 1 − max cosine similarity vs reference texts (premises/intent), in [0,1]. */
-    novelty: number;
-    /** entropy × coverage^1.5 × novelty. */
-    voi: number;
-}
-/** Result of one shadow mining+scoring pass (the log payload shape). */
-export interface DiscriminatorShadowResult {
-    poolSize: number;
-    /** Scored discriminators, sorted by VoI descending. */
-    discriminators: ScoredDiscriminator[];
-    /** Historical-axis comparison could not be completed due to invalid embeddings. */
-    priorReferenceComparisonUnavailable?: boolean;
-}

package/dist/opportunities/discriminator/discriminator.types.js

@@ -1,18 +0,0 @@
-/**
- * Pool discriminator mining — shared types (IND-416 / IND-417).
- *
- * A "pool discriminator" is a preference dimension that splits a discovery-run
- * candidate pool into meaningfully different groups (e.g. "hands-on builders
- * vs advisors"). Discriminators are mined by one structured LLM pass, then
- * scored deterministically (VoI = entropy × coverage^1.5 × novelty) so the
- * highest value question can eventually be asked to the intent owner.
- *
- * Vocabulary note: the LLM wire format (prompt + response schema in the miner)
- * speaks of "axes" with mutually exclusive "sides" — the clearest way to
- * explain the concept to the model. Everything the rest of the codebase
- * touches (types, exports, logs) uses "discriminator".
- *
- * P1 (shadow) uses these types for log-only output; later phases reuse them
- * for question synthesis and answer application.
- */
-export {};

package/dist/opportunities/negotiation-context.loader.d.ts

@@ -1,59 +0,0 @@
-/**
- * Negotiation context loader: given an opportunity, fetches the attached
- * negotiation task's transcript and outcome so the card presenter can
- * explain *why* the opportunity surfaced.
- *
- * For `draft`, `latent`, and `expired` opportunities, no negotiation has
- * happened (or no longer matters) so the loader returns null.
- *
- * For `negotiating` opportunities, only `turnCount` / `turnCap` are returned
- * — the presenter renders a templated chip without invoking the LLM.
- *
- * For `pending`, `stalled`, `accepted`, and `rejected` opportunities, the
- * full transcript and outcome are included so the prompt can ground its
- * explanation in concrete turn content.
- *
- * Screened-out negotiations (P2.2 — the client's own outreach gate declined
- * before any turn was exchanged) return null: presentation treats them as
- * never-happened, so no card, feed, or digest surface can frame the client's
- * private gate decision as a "counterparty declined" event.
- */
-import type { NegotiationGraphDatabase, OpportunityStatus } from '../shared/interfaces/database.interface.js';
-import type { NegotiationOutcome, NegotiationTurn } from '../negotiations/negotiation.module.js';
-/**
- * Narrow slice of {@link NegotiationGraphDatabase} required by the loader. Kept
- * minimal so call sites can opt into a smaller surface.
- */
-export type NegotiationContextDatabase = Pick<NegotiationGraphDatabase, 'getNegotiationTaskForOpportunity' | 'getNegotiationMessages' | 'getArtifactsForTask'>;
-/**
- * Snapshot of a negotiation surfaced to the presenter. `turns` and `outcome`
- * are only populated for post-negotiation statuses (pending/stalled/
- * accepted/rejected); `negotiating` gets only the counters.
- */
-export interface NegotiationContext {
-    status: OpportunityStatus;
-    /**
-     * Conversation/task id of the A2A negotiation that produced this opportunity.
-     * Lets callers deep-link to the negotiation trace (e.g. `/chat/:conversationId`).
-     * Present whenever a negotiation task exists (i.e. context is non-null).
-     */
-    conversationId: string;
-    turnCount: number;
-    /** Max turns allowed for this negotiation (0 = unlimited). */
-    turnCap: number;
-    /** Only present when status is not `negotiating`. */
-    outcome?: NegotiationOutcome;
-    /** Only present when status is not `negotiating`. */
-    turns?: NegotiationTurn[];
-}
-/**
- * Loads the negotiation context for an opportunity.
- *
- * @param db - Narrow slice of NegotiationGraphDatabase.
- * @param opportunityId - Opportunity to load negotiation context for.
- * @param opportunityStatus - Current opportunity status. Used to gate loading
- *   and to decide which fields to populate.
- * @returns NegotiationContext, or null when no meaningful negotiation exists
- *   (draft/latent/expired) or when the task lookup fails.
- */
-export declare function loadNegotiationContext(db: NegotiationContextDatabase, opportunityId: string, opportunityStatus: OpportunityStatus): Promise<NegotiationContext | null>;