@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

package/dist/opportunities/negotiation-context.loader.js

@@ -1,90 +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 { protocolLogger } from '../shared/observability/protocol.logger.js';
-const logger = protocolLogger('NegotiationContextLoader');
-const STATUSES_WITH_NO_NEGOTIATION = ['draft', 'latent', 'expired'];
-const NEGOTIATION_OUTCOME_ARTIFACT_NAME = 'negotiation-outcome';
-/**
- * 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 async function loadNegotiationContext(db, opportunityId, opportunityStatus) {
-    if (STATUSES_WITH_NO_NEGOTIATION.includes(opportunityStatus)) {
-        return null;
-    }
-    const task = await db.getNegotiationTaskForOpportunity(opportunityId);
-    if (!task) {
-        logger.verbose('No negotiation task found for opportunity', { opportunityId, opportunityStatus });
-        return null;
-    }
-    const turnCap = readNumber(task.metadata, 'maxTurns') ?? 0;
-    // Scoped to this opportunity: `turnCount`/`turns` describe THIS negotiation,
-    // and the pair's shared DM also holds concluded negotiations for other matches.
-    const messages = await db.getNegotiationMessages(opportunityId);
-    const turns = extractTurns(messages);
-    const turnCount = turns.length;
-    if (opportunityStatus === 'negotiating') {
-        return { status: opportunityStatus, conversationId: task.conversationId, turnCount, turnCap };
-    }
-    const artifacts = await db.getArtifactsForTask(task.id);
-    const outcome = extractOutcome(artifacts);
-    // P2.2: screened_out is the client's private gate decision, not a negotiation.
-    if (outcome?.reason === 'screened_out') {
-        return null;
-    }
-    return {
-        status: opportunityStatus,
-        conversationId: task.conversationId,
-        turnCount,
-        turnCap,
-        ...(outcome ? { outcome } : {}),
-        turns,
-    };
-}
-function readNumber(metadata, key) {
-    if (!metadata)
-        return undefined;
-    const value = metadata[key];
-    return typeof value === 'number' ? value : undefined;
-}
-function extractTurns(messages) {
-    const turns = [];
-    for (const message of messages) {
-        const dataPart = message.parts.find((p) => p.kind === 'data');
-        if (dataPart?.data) {
-            turns.push(dataPart.data);
-        }
-    }
-    return turns;
-}
-function extractOutcome(artifacts) {
-    const outcomeArtifact = artifacts.find((a) => a.name === NEGOTIATION_OUTCOME_ARTIFACT_NAME);
-    if (!outcomeArtifact)
-        return undefined;
-    const dataPart = outcomeArtifact.parts.find((p) => p.kind === 'data');
-    return dataPart?.data;
-}

package/dist/opportunities/negotiation-evidence/negotiation-evidence.env.d.ts

@@ -1,43 +0,0 @@
-/**
- * Centralized accessor + constants for the Lens C negotiation-evidence
- * question producer (IND-433).
- *
- *   NEGOTIATION_EVIDENCE_QUESTIONS_MODE   off | shadow | on — default off.
- *     - off (default): the lens never runs; zero reads, zero telemetry.
- *     - shadow (this issue): mine + verify neutral hypotheses over allowlisted
- *       negotiation evidence, emit AGGREGATE telemetry only. Persists no
- *       questions and changes no ranking, intent, premise, memory, policy,
- *       newborn-stamping, or push behavior.
- *     - on (future, IND-437): additionally synthesize/enqueue questions and
- *       suppress the older IND-296–299 transcript-question producer.
- *
- * All reads go through this module — do not read the variable via
- * `process.env` elsewhere. The value is read on every call (no caching) so
- * tests and long-lived processes observe changes.
- */
-/** Documented modes for the Lens C negotiation-evidence question producer. */
-export declare const NEGOTIATION_EVIDENCE_QUESTIONS_MODES: readonly ["off", "shadow", "on"];
-/** Mode for the Lens C negotiation-evidence question producer. */
-export type NegotiationEvidenceQuestionsMode = (typeof NEGOTIATION_EVIDENCE_QUESTIONS_MODES)[number];
-/**
- * Current NEGOTIATION_EVIDENCE_QUESTIONS_MODE (default off). Any value other
- * than an exact documented mode (after trimming) coerces to off — an
- * unrecognized flag must never silently enable the lens.
- */
-export declare function negotiationEvidenceQuestionsMode(): NegotiationEvidenceQuestionsMode;
-/**
- * Recurrence floor: a mined hypothesis is only retained when its verified
- * support spans at least this many DISTINCT opportunities (IND-433 `k=5`).
- * Continuation segments of one opportunity are grouped and count once, so this
- * is genuinely a cross-opportunity threshold — same-pair repetition cannot
- * inflate it.
- */
-export declare const NEGOTIATION_EVIDENCE_MIN_DISTINCT_OPPORTUNITIES = 5;
-/**
- * Max opportunities (already grouped, one per opportunity) whose allowlisted
- * evidence is sent to the miner in one pass. Bounds prompt size the same way
- * the Lens A miner caps its candidate pool.
- */
-export declare const NEGOTIATION_EVIDENCE_MAX_OPPORTUNITIES = 24;
-/** Max chars of allowlisted evidence content retained per evidence unit. */
-export declare const NEGOTIATION_EVIDENCE_MAX_CONTENT_CHARS = 400;

package/dist/opportunities/negotiation-evidence/negotiation-evidence.env.js

@@ -1,44 +0,0 @@
-/**
- * Centralized accessor + constants for the Lens C negotiation-evidence
- * question producer (IND-433).
- *
- *   NEGOTIATION_EVIDENCE_QUESTIONS_MODE   off | shadow | on — default off.
- *     - off (default): the lens never runs; zero reads, zero telemetry.
- *     - shadow (this issue): mine + verify neutral hypotheses over allowlisted
- *       negotiation evidence, emit AGGREGATE telemetry only. Persists no
- *       questions and changes no ranking, intent, premise, memory, policy,
- *       newborn-stamping, or push behavior.
- *     - on (future, IND-437): additionally synthesize/enqueue questions and
- *       suppress the older IND-296–299 transcript-question producer.
- *
- * All reads go through this module — do not read the variable via
- * `process.env` elsewhere. The value is read on every call (no caching) so
- * tests and long-lived processes observe changes.
- */
-/** Documented modes for the Lens C negotiation-evidence question producer. */
-export const NEGOTIATION_EVIDENCE_QUESTIONS_MODES = ["off", "shadow", "on"];
-/**
- * Current NEGOTIATION_EVIDENCE_QUESTIONS_MODE (default off). Any value other
- * than an exact documented mode (after trimming) coerces to off — an
- * unrecognized flag must never silently enable the lens.
- */
-export function negotiationEvidenceQuestionsMode() {
-    const raw = process.env.NEGOTIATION_EVIDENCE_QUESTIONS_MODE?.trim();
-    return raw === "shadow" || raw === "on" ? raw : "off";
-}
-/**
- * Recurrence floor: a mined hypothesis is only retained when its verified
- * support spans at least this many DISTINCT opportunities (IND-433 `k=5`).
- * Continuation segments of one opportunity are grouped and count once, so this
- * is genuinely a cross-opportunity threshold — same-pair repetition cannot
- * inflate it.
- */
-export const NEGOTIATION_EVIDENCE_MIN_DISTINCT_OPPORTUNITIES = 5;
-/**
- * Max opportunities (already grouped, one per opportunity) whose allowlisted
- * evidence is sent to the miner in one pass. Bounds prompt size the same way
- * the Lens A miner caps its candidate pool.
- */
-export const NEGOTIATION_EVIDENCE_MAX_OPPORTUNITIES = 24;
-/** Max chars of allowlisted evidence content retained per evidence unit. */
-export const NEGOTIATION_EVIDENCE_MAX_CONTENT_CHARS = 400;

package/dist/opportunities/negotiation-evidence/negotiation-evidence.extractor.d.ts

@@ -1,24 +0,0 @@
-import type { AllowlistedEvidence, EvidenceKind, EvidenceMiningScope, RawEvidenceSegment } from "./negotiation-evidence.types.js";
-/** Result of one extraction pass over a recipient+intent's segments. */
-export interface ExtractionResult {
-    /** Allowlisted evidence, grouped/deduped, one logical set per opportunity. */
-    evidence: AllowlistedEvidence[];
-    /** Distinct opportunities that produced at least one evidence unit. */
-    distinctOpportunities: number;
-    /** Candidate records rejected by allowlist / exclusion / provenance rules. */
-    excludedRecords: number;
-    /** Allowlisted evidence unit counts, by kind. */
-    evidenceCounts: Record<EvidenceKind, number>;
-}
-/**
- * Extract allowlisted evidence for one (recipient, intent) mining scope.
- *
- * Continuation grouping: segments are grouped by `opportunityId`; a single
- * opportunity contributes ONE deduped evidence set regardless of how many
- * continuation tasks it spans, so an opportunity counts once toward recurrence.
- *
- * Contamination guard: a segment whose recipient / intent / fingerprint /
- * network do not match the scope, or whose own recipient equals its
- * counterparty, is rejected wholesale (all records counted as excluded).
- */
-export declare function extractAllowlistedEvidence(scope: EvidenceMiningScope, segments: RawEvidenceSegment[]): ExtractionResult;

package/dist/opportunities/negotiation-evidence/negotiation-evidence.extractor.js

@@ -1,188 +0,0 @@
-/**
- * Lens C in-place evidence extraction (IND-433).
- *
- * Reads raw negotiation segments and projects ONLY the allowlist:
- *   - authoritative owner answers (answerer === recipient),
- *   - structured bilateral actions and coarse outcomes,
- *   - explicitly shared (tagged) message content.
- *
- * Everything else is dropped by construction. The function is pure and
- * deterministic so adversarial fixtures can prove that every excluded source
- * and every recipient / intent / opportunity / network / task / speaker
- * mismatch is rejected, and that same-pair continuations cannot inflate the
- * distinct-opportunity count.
- */
-import { NEGOTIATION_EVIDENCE_MAX_CONTENT_CHARS, NEGOTIATION_EVIDENCE_MAX_OPPORTUNITIES } from "./negotiation-evidence.env.js";
-const EMPTY_COUNTS = () => ({
-    owner_answer: 0,
-    bilateral_action: 0,
-    coarse_outcome: 0,
-    shared_message: 0,
-});
-/** Collapse whitespace + lowercase for dedup only (not for stored content). */
-function dedupKey(kind, speaker, content) {
-    return `${kind}\u0000${speaker}\u0000${content.toLowerCase().replace(/\s+/g, " ").trim()}`;
-}
-/** Bound + whitespace-normalize stored content. */
-function boundContent(raw) {
-    return raw.replace(/\s+/g, " ").trim().slice(0, NEGOTIATION_EVIDENCE_MAX_CONTENT_CHARS);
-}
-/**
- * A segment matches the pass scope only when EVERY provenance field is exactly
- * equal. A single mismatch rejects the whole segment (cross-recipient,
- * cross-intent, cross-fingerprint, or cross-network contamination).
- */
-function segmentMatchesScope(segment, scope) {
-    return (segment.recipientUserId === scope.recipientUserId &&
-        segment.intentId === scope.intentId &&
-        segment.intentFingerprint === scope.intentFingerprint &&
-        segment.networkId === scope.networkId);
-}
-/** Map a turn sender to owner/counterparty, or null when it is neither. */
-function mapSpeaker(senderUserId, segment) {
-    if (senderUserId === segment.recipientUserId)
-        return "owner";
-    if (senderUserId === segment.counterpartyUserId)
-        return "counterparty";
-    return null;
-}
-/** Count every raw record a segment carries (for excluded-record accounting). */
-function countSegmentRecords(segment) {
-    let n = segment.turns.length + (segment.ownerAnswers?.length ?? 0);
-    if (segment.outcome)
-        n += 1;
-    return n;
-}
-/**
- * Extract allowlisted evidence for one (recipient, intent) mining scope.
- *
- * Continuation grouping: segments are grouped by `opportunityId`; a single
- * opportunity contributes ONE deduped evidence set regardless of how many
- * continuation tasks it spans, so an opportunity counts once toward recurrence.
- *
- * Contamination guard: a segment whose recipient / intent / fingerprint /
- * network do not match the scope, or whose own recipient equals its
- * counterparty, is rejected wholesale (all records counted as excluded).
- */
-export function extractAllowlistedEvidence(scope, segments) {
-    const evidenceCounts = EMPTY_COUNTS();
-    let excludedRecords = 0;
-    // Group in-scope segments by opportunity (continuation grouping).
-    const byOpportunity = new Map();
-    for (const segment of segments) {
-        if (!segmentMatchesScope(segment, scope) || segment.recipientUserId === segment.counterpartyUserId) {
-            excludedRecords += countSegmentRecords(segment);
-            continue;
-        }
-        const group = byOpportunity.get(segment.opportunityId);
-        if (group)
-            group.push(segment);
-        else
-            byOpportunity.set(segment.opportunityId, [segment]);
-    }
-    const evidence = [];
-    let distinctOpportunities = 0;
-    for (const [opportunityId, group] of byOpportunity) {
-        if (distinctOpportunities >= NEGOTIATION_EVIDENCE_MAX_OPPORTUNITIES) {
-            // Cap opportunities per pass; remaining segments simply are not mined.
-            excludedRecords += group.reduce((n, s) => n + countSegmentRecords(s), 0);
-            continue;
-        }
-        const seen = new Set();
-        const opportunityEvidence = [];
-        const push = (segment, kind, speaker, rawContent) => {
-            const content = boundContent(rawContent);
-            if (content.length === 0)
-                return false;
-            const key = dedupKey(kind, speaker, content);
-            if (seen.has(key))
-                return true; // duplicate continuation content retains its first source
-            seen.add(key);
-            opportunityEvidence.push({
-                kind,
-                speaker,
-                content,
-                taskId: segment.taskId,
-                conversationId: segment.conversationId,
-            });
-            return true;
-        };
-        for (const segment of group) {
-            // Authoritative owner answers — answerer MUST be the recipient.
-            for (const answer of segment.ownerAnswers ?? []) {
-                if (answer.answererUserId !== segment.recipientUserId) {
-                    excludedRecords += 1;
-                    continue;
-                }
-                const parts = [...answer.selectedOptions, ...(answer.freeText ? [answer.freeText] : [])];
-                const content = parts.join(" | ");
-                if (!push(segment, "owner_answer", "owner", content))
-                    excludedRecords += 1;
-            }
-            // Turns → structured bilateral action + explicitly shared message.
-            for (const turn of segment.turns) {
-                const speaker = mapSpeaker(turn.senderUserId, segment);
-                if (speaker === null) {
-                    // Speaker mismatch: neither owner nor counterparty. Nothing from
-                    // this turn (action AND message) may be trusted.
-                    excludedRecords += 1;
-                    continue;
-                }
-                // Structured bilateral action (label only; reasoning never read).
-                const action = turn.action?.trim();
-                if (action)
-                    push(segment, "bilateral_action", "system", action);
-                // Explicitly shared message content only. Untagged → excluded.
-                const message = turn.message?.trim();
-                if (message) {
-                    if (turn.sharedTagged === true)
-                        push(segment, "shared_message", speaker, message);
-                    else
-                        excludedRecords += 1;
-                }
-            }
-            // Coarse outcome. `screened_out` is a private client gate → excluded.
-            const outcome = segment.outcome;
-            if (outcome) {
-                if (outcome.reason === "screened_out") {
-                    excludedRecords += 1;
-                }
-                else {
-                    const roles = (outcome.agreedRoles ?? [])
-                        .map((r) => `${r.role}`)
-                        .sort()
-                        .join(",");
-                    const content = [
-                        `hasOpportunity=${outcome.hasOpportunity}`,
-                        outcome.reason ? `reason=${outcome.reason}` : "",
-                        roles ? `roles=${roles}` : "",
-                    ]
-                        .filter(Boolean)
-                        .join(" ");
-                    push(segment, "coarse_outcome", "system", content);
-                }
-            }
-        }
-        if (opportunityEvidence.length === 0)
-            continue;
-        distinctOpportunities += 1;
-        const first = group[0];
-        opportunityEvidence.forEach((e, ordinal) => {
-            evidenceCounts[e.kind] += 1;
-            evidence.push({
-                evidenceId: `${e.kind}:${opportunityId}:${ordinal}`,
-                kind: e.kind,
-                speaker: e.speaker,
-                content: e.content,
-                recipientUserId: first.recipientUserId,
-                intentId: first.intentId,
-                intentFingerprint: first.intentFingerprint,
-                opportunityId,
-                taskId: e.taskId,
-                conversationId: e.conversationId,
-                networkId: first.networkId,
-            });
-        });
-    }
-    return { evidence, distinctOpportunities, excludedRecords, evidenceCounts };
-}

package/dist/opportunities/negotiation-evidence/negotiation-evidence.miner.d.ts

@@ -1,26 +0,0 @@
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-import type { AllowlistedEvidence, MinedEvidenceHypothesis } from "./negotiation-evidence.types.js";
-/** Config for NegotiationEvidenceMiner construction. */
-export interface NegotiationEvidenceMinerConfig {
-    /** Optional model config override (API key / base URL / model). */
-    modelConfig?: Parameters<typeof createStructuredModel>[3];
-}
-/**
- * Stateless hypothesis-mining agent. One `mine()` call = one structured LLM
- * pass. All support verification happens later, in the verifier.
- */
-export declare class NegotiationEvidenceMiner {
-    private model;
-    constructor(config?: NegotiationEvidenceMinerConfig);
-    /**
-     * Mine neutral hypotheses for one allowlisted evidence set.
-     *
-     * @returns Proposed hypotheses (may be empty). Throws on LLM failure —
-     *   callers run this fire-and-forget and must catch.
-     */
-    mine(evidence: AllowlistedEvidence[], options?: {
-        signal?: AbortSignal;
-    }): Promise<MinedEvidenceHypothesis[]>;
-}
-/** Builds the human message: one block per allowlisted evidence unit. */
-export declare function buildEvidencePrompt(evidence: AllowlistedEvidence[]): string;

package/dist/opportunities/negotiation-evidence/negotiation-evidence.miner.js

@@ -1,112 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-/**
- * NegotiationEvidenceMiner — one structured LLM pass that proposes neutral
- * clarification hypotheses over ALLOWLISTED negotiation evidence, with
- * code-side support verification delegated to the verifier (IND-433).
- *
- * The miner only ever sees the allowlisted projection (owner answers, bilateral
- * actions, coarse outcomes, explicitly shared messages) — never reasoning,
- * memories, disclosure subjects, or provenance. Every proposed hypothesis must
- * cite the `evidenceId`s that support it and quote a verbatim span from each;
- * unsupported or hallucinated references are discarded in code, not trusted
- * from the prompt.
- *
- * Follows the Lens A `PoolDiscriminatorMiner` pattern: constructor binds the
- * structured model once; a single public `mine()` per call.
- */
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { z } from "zod";
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../../shared/agent/model-signal.js";
-import { protocolLogger } from "../../shared/observability/protocol.logger.js";
-import { Timed } from "../../shared/observability/performance.js";
-const logger = protocolLogger("NegotiationEvidenceMiner");
-/** Max hypotheses requested from (and accepted out of) one mining pass. */
-const MAX_HYPOTHESES = 8;
-const HypothesisMiningResponseSchema = z.object({
-    hypotheses: z
-        .array(z.object({
-        statement: z
-            .string()
-            .describe("A neutral, non-identifying clarification hypothesis about the intent owner's preferences or context"),
-        claimType: z
-            .enum(["observation", "recipient_fact", "recipient_preference"])
-            .describe("observation = a neutral pattern; recipient_fact/recipient_preference = a claim ABOUT the intent owner (needs owner-authored or structured support)"),
-        supportRefs: z
-            .array(z.object({
-            evidenceId: z.string().describe("An evidenceId exactly as given in the evidence list"),
-            span: z
-                .string()
-                .max(200)
-                .describe("VERBATIM span (<=120 chars) copied from that evidence's content"),
-        }))
-            .min(1)
-            .describe("One or more support references; every hypothesis must be grounded"),
-    }))
-        .max(MAX_HYPOTHESES),
-});
-const SYSTEM_PROMPT = `You review ALLOWLISTED evidence gathered from a user's past negotiations and propose neutral clarification hypotheses about that user's (the "intent owner") preferences or context.
-
-You are given only a safe projection of evidence: the owner's own answers, structured bilateral actions, coarse outcomes, and explicitly shared messages. Each item has an id, a kind, and a speaker (owner | counterparty | system).
-
-Rules for every hypothesis:
-- State it neutrally and at an aggregate level. NEVER name or describe any specific person, and NEVER infer protected attributes (race, ethnicity, religion, gender, age, nationality, disability, politics, sexual orientation).
-- Ground it: cite the evidenceId(s) that support it and copy a short (<=120 chars) VERBATIM substring of that evidence's content as the span. Copy it exactly — spans are checked mechanically and paraphrased spans are discarded.
-- claimType:
-  - Use "recipient_fact" or "recipient_preference" only for a claim ABOUT the intent owner. Such claims may ONLY be supported by owner or system evidence — a counterparty statement can never establish a fact or preference about the owner.
-  - Use "observation" for a neutral pattern that a counterparty statement may also support.
-- Do not speculate beyond the evidence. If an item does not support a distinct hypothesis, ignore it.
-
-Prefer a few well-supported hypotheses over many weak ones. Propose at most ${MAX_HYPOTHESES}.`;
-/**
- * Stateless hypothesis-mining agent. One `mine()` call = one structured LLM
- * pass. All support verification happens later, in the verifier.
- */
-export class NegotiationEvidenceMiner {
-    constructor(config) {
-        this.model = createStructuredModel("negotiationEvidenceMiner", HypothesisMiningResponseSchema, { name: "negotiation_evidence_hypotheses" }, config?.modelConfig);
-    }
-    /**
-     * Mine neutral hypotheses for one allowlisted evidence set.
-     *
-     * @returns Proposed hypotheses (may be empty). Throws on LLM failure —
-     *   callers run this fire-and-forget and must catch.
-     */
-    async mine(evidence, options) {
-        if (evidence.length === 0)
-            return [];
-        const prompt = buildEvidencePrompt(evidence);
-        const raw = await invokeWithAbortSignal(this.model, [new SystemMessage(SYSTEM_PROMPT), new HumanMessage(prompt)], options?.signal);
-        const parsed = HypothesisMiningResponseSchema.safeParse(raw);
-        if (!parsed.success) {
-            logger.warn("Mining response failed schema validation", { issues: parsed.error.issues.length });
-            return [];
-        }
-        return parsed.data.hypotheses.slice(0, MAX_HYPOTHESES).map((h) => ({
-            statement: h.statement,
-            claimType: h.claimType,
-            supportRefs: h.supportRefs.map((r) => ({ evidenceId: r.evidenceId, span: r.span })),
-        }));
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], NegotiationEvidenceMiner.prototype, "mine", null);
-/** Builds the human message: one block per allowlisted evidence unit. */
-export function buildEvidencePrompt(evidence) {
-    const blocks = evidence
-        .map((e) => `[${e.evidenceId}] (${e.kind}, ${e.speaker})\n${e.content}`)
-        .join("\n\n");
-    return `Allowlisted evidence (${evidence.length} items, id in brackets):\n\n${blocks}`;
-}

package/dist/opportunities/negotiation-evidence/negotiation-evidence.shadow.d.ts

@@ -1,19 +0,0 @@
-import type { NegotiationEvidenceMiner } from "./negotiation-evidence.miner.js";
-import type { EvidenceMiningScope, NegotiationEvidenceShadowResult, RawEvidenceSegment } from "./negotiation-evidence.types.js";
-/** Input for one shadow mining pass. */
-export interface NegotiationEvidenceShadowInput {
-    /** The exact recipient + intent/fingerprint + network this pass is bound to. */
-    scope: EvidenceMiningScope;
-    /** Raw negotiation segments read in place (one or more per opportunity). */
-    segments: RawEvidenceSegment[];
-    /** Structured hypothesis miner (injectable seam). */
-    miner: Pick<NegotiationEvidenceMiner, "mine">;
-    /** Override the recurrence floor (defaults to the IND-433 `k=5`). */
-    minDistinctOpportunities?: number;
-    signal?: AbortSignal;
-}
-/**
- * Run one Lens C shadow pass. Throws only when *mining* fails (callers run
- * fire-and-forget and must catch); extraction and verification are pure.
- */
-export declare function runNegotiationEvidenceShadow(input: NegotiationEvidenceShadowInput): Promise<NegotiationEvidenceShadowResult>;

package/dist/opportunities/negotiation-evidence/negotiation-evidence.shadow.js

@@ -1,61 +0,0 @@
-/**
- * Lens C shadow orchestrator (IND-433).
- *
- * extract (allowlist, in place) → mine (neutral hypotheses) → verify (support
- * resolves to allowlisted evidence + speaker constraint) → recurrence gate
- * (>= k distinct opportunities). Returns aggregate telemetry plus the retained
- * hypotheses for OFFLINE review.
- *
- * This function performs NO persistence and NO user-visible action. It does
- * not create questions and changes no ranking, intent, premise, memory,
- * policy, newborn-stamping, or push behavior — those belong to the future
- * `on` mode (IND-437). Callers in shadow mode must log only
- * {@link NegotiationEvidenceShadowResult.telemetry} (aggregate-only) and must
- * not persist or route the retained hypotheses.
- */
-import { NEGOTIATION_EVIDENCE_MIN_DISTINCT_OPPORTUNITIES } from "./negotiation-evidence.env.js";
-import { extractAllowlistedEvidence } from "./negotiation-evidence.extractor.js";
-import { verifyHypotheses } from "./negotiation-evidence.verifier.js";
-/**
- * Run one Lens C shadow pass. Throws only when *mining* fails (callers run
- * fire-and-forget and must catch); extraction and verification are pure.
- */
-export async function runNegotiationEvidenceShadow(input) {
-    const { scope, segments } = input;
-    const minDistinct = input.minDistinctOpportunities ?? NEGOTIATION_EVIDENCE_MIN_DISTINCT_OPPORTUNITIES;
-    const extraction = extractAllowlistedEvidence(scope, segments);
-    const baseTelemetry = {
-        recipientUserId: scope.recipientUserId,
-        intentId: scope.intentId,
-        segments: segments.length,
-        distinctOpportunities: extraction.distinctOpportunities,
-        evidenceCounts: extraction.evidenceCounts,
-        excludedRecords: extraction.excludedRecords,
-    };
-    // Cheap exit: recurrence is impossible below the distinct-opportunity floor,
-    // so never spend an LLM call that could only be discarded.
-    if (extraction.distinctOpportunities < minDistinct) {
-        return {
-            telemetry: {
-                ...baseTelemetry,
-                hypothesesMined: 0,
-                hypothesesSupported: 0,
-                hypothesesRecurrent: 0,
-                hypothesesDiscarded: 0,
-            },
-            hypotheses: [],
-        };
-    }
-    const mined = await input.miner.mine(extraction.evidence, input.signal ? { signal: input.signal } : undefined);
-    const verification = verifyHypotheses(mined, extraction.evidence, minDistinct);
-    return {
-        telemetry: {
-            ...baseTelemetry,
-            hypothesesMined: mined.length,
-            hypothesesSupported: verification.supported,
-            hypothesesRecurrent: verification.recurrent,
-            hypothesesDiscarded: verification.discarded,
-        },
-        hypotheses: verification.retained,
-    };
-}