@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

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

@@ -1,103 +0,0 @@
-/**
- * Centralized accessors for pool-question environment variables (IND-416).
- *
- *   POOL_QUESTIONS_MINING   off | shadow — P1 shadow axis mining on
- *                           discovery-run completion. `shadow` mines and
- *                           scores axes and logs them; no questions are
- *                           generated and no user-facing behavior changes.
- *                           Any value other than "shadow" (including unset)
- *                           means off.
- *
- * 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.
- */
-/** Mining mode for pool discriminator axes. */
-export type PoolQuestionsMiningMode = "off" | "shadow";
-/** Current POOL_QUESTIONS_MINING mode (default off). */
-export declare function poolQuestionsMiningMode(): PoolQuestionsMiningMode;
-/** Question mode for pool discriminators (IND-418). */
-export type PoolQuestionsMode = "off" | "on";
-/**
- * Current POOL_QUESTIONS_MODE (default off). When "on", the mining hook also
- * enqueues a pool_discovery question for the top eligible discriminator
- * (still subject to the QUESTIONER_ENABLED master gate and per-intent budget).
- * "on" implies mining runs even when POOL_QUESTIONS_MINING is off.
- */
-export declare function poolQuestionsMode(): PoolQuestionsMode;
-/** Push delivery mode for high-VoI pool questions (IND-421). */
-export type PoolQuestionsPushMode = "off" | "on";
-/**
- * Current POOL_QUESTIONS_PUSH mode (default off). Callers must additionally
- * require pool-question mode and negotiator availability before delivery.
- */
-export declare function poolQuestionsPushMode(): PoolQuestionsPushMode;
-/** Visit-triggered pool-mining mode (IND-439 visibility-audit slice). */
-export type PoolQuestionsVisitTriggerMode = "off" | "on";
-/**
- * Current POOL_QUESTIONS_VISIT_TRIGGER mode (default off). When "on", an
- * intent owner's intent-page pending-questions fetch may enqueue a debounced
- * pool-mining pass for that intent when no live pending pool_discovery
- * question exists. The trigger only adds a *when* — every existing mining
- * gate (POOL_QUESTIONS_MODE, k-anonymity floor, VoI threshold, per-intent
- * budgets, fingerprint freshness, push budgets) applies unchanged, so this
- * is a no-op unless {@link poolQuestionsMode} is also "on".
- */
-export declare function poolQuestionsVisitTrigger(): PoolQuestionsVisitTriggerMode;
-/**
- * Debounce window for visit-triggered pool mining, per intent (IND-439).
- * At most one visit-triggered mining run per intent per window, enforced via
- * BullMQ deduplication — no new tables.
- */
-export declare const POOL_VISIT_MINING_DEBOUNCE_MS: number;
-/** Newborn-opportunity stamping mode (IND-420 P4b). */
-export type PoolQuestionsStampNewbornMode = "off" | "on";
-/**
- * Current POOL_QUESTIONS_STAMP_NEWBORN mode (default off). Effective callers
- * additionally require {@link poolQuestionsMode} to be on.
- */
-export declare function poolQuestionsStampNewborn(): PoolQuestionsStampNewbornMode;
-/** Minimum VoI for a discriminator to become (or chain) a question. */
-export declare const POOL_QUESTION_MIN_VOI = 0.2;
-/** Minimum evidence-verification rate for a discriminator to become a question. */
-export declare const POOL_QUESTION_MIN_EVIDENCE_RATE = 0.6;
-/** Max eligible discriminators carried per mining pass (asked + alternates). */
-export declare const POOL_QUESTION_MAX_DISCRIMINATORS = 3;
-/** Unattended budget: max pending questions of ANY mode per intent. */
-export declare const POOL_QUESTION_MAX_PENDING_PER_INTENT = 3;
-/** Initial internal VoI threshold for proactive push delivery. */
-export declare const POOL_QUESTION_PUSH_BASE_VOI = 0.6;
-/** Multiplicative VoI threshold increase per consecutive dismissal. */
-export declare const POOL_QUESTION_PUSH_DISMISSAL_DECAY = 1.15;
-/** Minimum pool size for proactive delivery (stricter than mining). */
-export declare const POOL_QUESTION_PUSH_MIN_POOL_SIZE = 8;
-/** Maximum claimed proactive pool pushes per recipient per UTC day. */
-export declare const POOL_QUESTION_PUSH_DAILY_CAP = 2;
-/** Ranking mode for pool adjustments (IND-419). */
-export type PoolQuestionsRankingMode = "off" | "on";
-/**
- * Current POOL_QUESTIONS_RANKING (default off). When "on", the radar view
- * orders by adjusted confidence (confidence × Π poolAdjustments.factor,
- * floor {@link POOL_ADJUSTMENT_FLOOR}). Adjustments are WRITTEN regardless of
- * this flag — it only gates whether ordering reads them, so the apply path
- * can ship first.
- */
-export declare function poolQuestionsRanking(): PoolQuestionsRankingMode;
-/** Adjustment factor for candidates on the side the user did NOT choose. */
-export declare const POOL_ADJUSTMENT_FACTOR_OTHER = 0.6;
-/** Adjustment factor for candidates the miner could not assign (unknown). */
-export declare const POOL_ADJUSTMENT_FACTOR_UNKNOWN = 0.9;
-/** Floor for the cumulative adjustment multiplier — demoted, never hidden. */
-export declare const POOL_ADJUSTMENT_FLOOR = 0.3;
-/** Debounce window for answer-triggered re-discovery (Tier 1), per intent. */
-export declare const POOL_RERUN_DEBOUNCE_MS = 60000;
-/**
- * k-anonymity floor: axes are only mined when the pool has at least this many
- * candidates, so no axis (or later, question option) can be traced back to a
- * specific individual.
- */
-export declare const POOL_DISCRIMINATOR_MIN_POOL_SIZE = 5;
-/** Max candidates sent to the miner LLM (top-N by score). */
-export declare const POOL_DISCRIMINATOR_MAX_CANDIDATES = 24;
-/** Max chars of public context per candidate in the miner prompt. */
-export declare const POOL_DISCRIMINATOR_MAX_PUBLIC_CONTEXT_CHARS = 400;

package/dist/opportunities/discriminator/discriminator.env.js

@@ -1,103 +0,0 @@
-/**
- * Centralized accessors for pool-question environment variables (IND-416).
- *
- *   POOL_QUESTIONS_MINING   off | shadow — P1 shadow axis mining on
- *                           discovery-run completion. `shadow` mines and
- *                           scores axes and logs them; no questions are
- *                           generated and no user-facing behavior changes.
- *                           Any value other than "shadow" (including unset)
- *                           means off.
- *
- * 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.
- */
-/** Current POOL_QUESTIONS_MINING mode (default off). */
-export function poolQuestionsMiningMode() {
-    return process.env.POOL_QUESTIONS_MINING?.trim() === "shadow" ? "shadow" : "off";
-}
-/**
- * Current POOL_QUESTIONS_MODE (default off). When "on", the mining hook also
- * enqueues a pool_discovery question for the top eligible discriminator
- * (still subject to the QUESTIONER_ENABLED master gate and per-intent budget).
- * "on" implies mining runs even when POOL_QUESTIONS_MINING is off.
- */
-export function poolQuestionsMode() {
-    return process.env.POOL_QUESTIONS_MODE?.trim() === "on" ? "on" : "off";
-}
-/**
- * Current POOL_QUESTIONS_PUSH mode (default off). Callers must additionally
- * require pool-question mode and negotiator availability before delivery.
- */
-export function poolQuestionsPushMode() {
-    return process.env.POOL_QUESTIONS_PUSH?.trim() === "on" ? "on" : "off";
-}
-/**
- * Current POOL_QUESTIONS_VISIT_TRIGGER mode (default off). When "on", an
- * intent owner's intent-page pending-questions fetch may enqueue a debounced
- * pool-mining pass for that intent when no live pending pool_discovery
- * question exists. The trigger only adds a *when* — every existing mining
- * gate (POOL_QUESTIONS_MODE, k-anonymity floor, VoI threshold, per-intent
- * budgets, fingerprint freshness, push budgets) applies unchanged, so this
- * is a no-op unless {@link poolQuestionsMode} is also "on".
- */
-export function poolQuestionsVisitTrigger() {
-    return process.env.POOL_QUESTIONS_VISIT_TRIGGER?.trim() === "on" ? "on" : "off";
-}
-/**
- * Debounce window for visit-triggered pool mining, per intent (IND-439).
- * At most one visit-triggered mining run per intent per window, enforced via
- * BullMQ deduplication — no new tables.
- */
-export const POOL_VISIT_MINING_DEBOUNCE_MS = 6 * 60 * 60 * 1000;
-/**
- * Current POOL_QUESTIONS_STAMP_NEWBORN mode (default off). Effective callers
- * additionally require {@link poolQuestionsMode} to be on.
- */
-export function poolQuestionsStampNewborn() {
-    return process.env.POOL_QUESTIONS_STAMP_NEWBORN?.trim() === "on" ? "on" : "off";
-}
-/** Minimum VoI for a discriminator to become (or chain) a question. */
-export const POOL_QUESTION_MIN_VOI = 0.2;
-/** Minimum evidence-verification rate for a discriminator to become a question. */
-export const POOL_QUESTION_MIN_EVIDENCE_RATE = 0.6;
-/** Max eligible discriminators carried per mining pass (asked + alternates). */
-export const POOL_QUESTION_MAX_DISCRIMINATORS = 3;
-/** Unattended budget: max pending questions of ANY mode per intent. */
-export const POOL_QUESTION_MAX_PENDING_PER_INTENT = 3;
-/** Initial internal VoI threshold for proactive push delivery. */
-export const POOL_QUESTION_PUSH_BASE_VOI = 0.6;
-/** Multiplicative VoI threshold increase per consecutive dismissal. */
-export const POOL_QUESTION_PUSH_DISMISSAL_DECAY = 1.15;
-/** Minimum pool size for proactive delivery (stricter than mining). */
-export const POOL_QUESTION_PUSH_MIN_POOL_SIZE = 8;
-/** Maximum claimed proactive pool pushes per recipient per UTC day. */
-export const POOL_QUESTION_PUSH_DAILY_CAP = 2;
-/**
- * Current POOL_QUESTIONS_RANKING (default off). When "on", the radar view
- * orders by adjusted confidence (confidence × Π poolAdjustments.factor,
- * floor {@link POOL_ADJUSTMENT_FLOOR}). Adjustments are WRITTEN regardless of
- * this flag — it only gates whether ordering reads them, so the apply path
- * can ship first.
- */
-export function poolQuestionsRanking() {
-    return process.env.POOL_QUESTIONS_RANKING?.trim() === "on" ? "on" : "off";
-}
-/** Adjustment factor for candidates on the side the user did NOT choose. */
-export const POOL_ADJUSTMENT_FACTOR_OTHER = 0.6;
-/** Adjustment factor for candidates the miner could not assign (unknown). */
-export const POOL_ADJUSTMENT_FACTOR_UNKNOWN = 0.9;
-/** Floor for the cumulative adjustment multiplier — demoted, never hidden. */
-export const POOL_ADJUSTMENT_FLOOR = 0.3;
-/** Debounce window for answer-triggered re-discovery (Tier 1), per intent. */
-export const POOL_RERUN_DEBOUNCE_MS = 60000;
-/**
- * k-anonymity floor: axes are only mined when the pool has at least this many
- * candidates, so no axis (or later, question option) can be traced back to a
- * specific individual.
- */
-export const POOL_DISCRIMINATOR_MIN_POOL_SIZE = 5;
-/** Max candidates sent to the miner LLM (top-N by score). */
-export const POOL_DISCRIMINATOR_MAX_CANDIDATES = 24;
-/** Max chars of public context per candidate in the miner prompt. */
-export const POOL_DISCRIMINATOR_MAX_PUBLIC_CONTEXT_CHARS = 400;

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

@@ -1,114 +0,0 @@
-import { z } from "zod";
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-import type { MinedDiscriminator, DiscriminatorMiningInput } from "./discriminator.types.js";
-declare const AxisMiningResponseSchema: z.ZodObject<{
-    axes: z.ZodArray<z.ZodObject<{
-        axis: z.ZodString;
-        questionSeed: z.ZodString;
-        sides: z.ZodArray<z.ZodString, "many">;
-        assignments: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            side: z.ZodNullable<z.ZodString>;
-            evidence: z.ZodNullable<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            id: string;
-            evidence: string | null;
-            side: string | null;
-        }, {
-            id: string;
-            evidence: string | null;
-            side: string | null;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        questionSeed: string;
-        sides: string[];
-        assignments: {
-            id: string;
-            evidence: string | null;
-            side: string | null;
-        }[];
-        axis: string;
-    }, {
-        questionSeed: string;
-        sides: string[];
-        assignments: {
-            id: string;
-            evidence: string | null;
-            side: string | null;
-        }[];
-        axis: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    axes: {
-        questionSeed: string;
-        sides: string[];
-        assignments: {
-            id: string;
-            evidence: string | null;
-            side: string | null;
-        }[];
-        axis: string;
-    }[];
-}, {
-    axes: {
-        questionSeed: string;
-        sides: string[];
-        assignments: {
-            id: string;
-            evidence: string | null;
-            side: string | null;
-        }[];
-        axis: string;
-    }[];
-}>;
-type AxisMiningResponse = z.infer<typeof AxisMiningResponseSchema>;
-/** Config for PoolDiscriminatorMiner construction. */
-export interface PoolDiscriminatorMinerConfig {
-    /** Optional model config override (API key / base URL / model). */
-    modelConfig?: Parameters<typeof createStructuredModel>[3];
-}
-/**
- * Collapse whitespace, lowercase, and fold typographic punctuation to ASCII
- * (curly quotes/apostrophes, en/em dashes, ellipsis), so evidence matching
- * tolerates formatting drift without weakening the verbatim requirement.
- */
-export declare function normalizePoolEvidenceForMatch(s: string): string;
-/**
- * Strips wrapping quotes and edge punctuation from an evidence span before
- * matching. LLMs habitually sentence-ize copied spans (append a trailing
- * period, wrap in quotes); the meaningful content must still match verbatim.
- */
-export declare function stripPoolEvidenceEdgePunctuation(s: string): string;
-/** Evidence verifier shared by mining and newborn assignment. */
-export declare function poolEvidenceMatches(publicContext: string, evidence: string | null): boolean;
-/**
- * Stateless axis-mining agent. One `mine()` call = one structured LLM pass +
- * deterministic evidence verification.
- */
-export declare class PoolDiscriminatorMiner {
-    private model;
-    constructor(config?: PoolDiscriminatorMinerConfig);
-    /**
-     * Mine discriminating axes for one pool.
-     *
-     * @returns Verified axes (may be empty). Throws on LLM failure — callers
-     *   run this fire-and-forget and must catch.
-     */
-    mine(input: DiscriminatorMiningInput, options?: {
-        signal?: AbortSignal;
-    }): Promise<MinedDiscriminator[]>;
-}
-/** Builds the human message: intent text + one numbered block per candidate. */
-export declare function buildMiningPrompt(input: DiscriminatorMiningInput): string;
-/**
- * Deterministic post-pass over one LLM axis:
- * - drops assignments for ids not in the pool,
- * - demotes to unknown: sides not in the axis's side list, missing evidence,
- *   and evidence that does not substring-match the candidate's publicContext,
- * - collapses duplicate proposals to the same trim-normalized side,
- * - demotes a candidate proposed for different sides to unknown (zero support),
- * - guarantees exactly one assignment per pool candidate (missing → unknown),
- * - computes evidenceRate = verified / distinct candidate-side proposals.
- */
-export declare function verifyAxis(axis: AxisMiningResponse["axes"][number], candidates: DiscriminatorMiningInput["candidates"]): MinedDiscriminator;
-export {};

package/dist/opportunities/discriminator/discriminator.miner.js

@@ -1,228 +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);
-};
-/**
- * PoolDiscriminatorMiner — one structured LLM pass that proposes discriminating axes
- * over a discovery-run candidate pool, with code-side evidence verification
- * (IND-417).
- *
- * Anti-hallucination contract: every side assignment must quote a short
- * evidence span from that candidate's supplied publicContext. Verification is
- * done in code (substring match, case/whitespace-insensitive), NOT trusted
- * from the prompt. Failed verifications are demoted to `unknown`, which
- * lowers coverage → lowers VoI → buries the axis. The failure mode
- * self-punishes.
- *
- * Follows the QuestionerAgent pattern: constructor binds the structured
- * model once; 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("PoolDiscriminatorMiner");
-/** Max axes requested from (and accepted out of) one mining pass. */
-const MAX_AXES = 6;
-const AxisMiningResponseSchema = z.object({
-    axes: z
-        .array(z.object({
-        axis: z
-            .string()
-            .describe("Short discriminating-axis label, e.g. 'Hands-on builders vs strategic advisors'"),
-        questionSeed: z
-            .string()
-            .describe("A direct question the intent owner could answer to resolve this axis"),
-        sides: z
-            .array(z.string())
-            .min(2)
-            .max(3)
-            .describe("2-3 mutually exclusive side labels (2-5 words each)"),
-        assignments: z
-            .array(z.object({
-            id: z.string().describe("Candidate id exactly as given"),
-            side: z
-                .string()
-                .nullable()
-                .describe("One of this axis's side labels, or null when the context is insufficient"),
-            evidence: z
-                .string()
-                .max(200)
-                .nullable()
-                .describe("VERBATIM span (≤80 chars) copied from this candidate's context that justifies the side. null when side is null"),
-        }))
-            .describe("One entry per candidate"),
-    }))
-        .max(MAX_AXES),
-});
-const SYSTEM_PROMPT = `You analyze a pool of candidate matches for one user intent and propose the preference axes that best SPLIT the pool into meaningfully different groups.
-
-Rules for every axis:
-- Sides must be mutually exclusive readings of one dimension (a candidate belongs to at most one side).
-- The axis must NOT already be determined by the intent text itself — only propose axes the intent leaves genuinely open.
-- The axis must be phrased as a preference the intent OWNER could hold and answer (the questionSeed asks them directly).
-- Side labels are terse (2-5 words), concrete, and derived from patterns across MULTIPLE candidates — never from a single person and never naming anyone.
-- BANNED axis families: protected attributes (race, ethnicity, religion, gender, age, nationality, disability, politics, sexual orientation), and vanity/noise splits (profile completeness, bio length, has photo, name alphabet).
-
-Rules for assignments:
-- Assign EVERY candidate: pick a side only when the candidate's context contains clear support; otherwise use side null.
-- When you pick a side you MUST quote a short (≤80 chars) VERBATIM substring of that candidate's context as evidence. Copy it exactly — it is checked mechanically, and paraphrased evidence is discarded. Do NOT add punctuation that is not in the source (no trailing period); cutting off mid-sentence is fine.
-- Never invent context. If unsure, use side null with evidence null.
-
-Prefer axes that split the pool close to evenly and that cover many candidates with verifiable evidence. Propose at most ${MAX_AXES} axes; fewer strong axes beat many weak ones.`;
-/**
- * Collapse whitespace, lowercase, and fold typographic punctuation to ASCII
- * (curly quotes/apostrophes, en/em dashes, ellipsis), so evidence matching
- * tolerates formatting drift without weakening the verbatim requirement.
- */
-export function normalizePoolEvidenceForMatch(s) {
-    return s
-        .toLowerCase()
-        .replace(/[\u2018\u2019\u02bc]/g, "'")
-        .replace(/[\u201c\u201d]/g, '"')
-        .replace(/[\u2013\u2014]/g, "-")
-        .replace(/\u2026/g, "...")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-/**
- * Strips wrapping quotes and edge punctuation from an evidence span before
- * matching. LLMs habitually sentence-ize copied spans (append a trailing
- * period, wrap in quotes); the meaningful content must still match verbatim.
- */
-export function stripPoolEvidenceEdgePunctuation(s) {
-    return s.replace(/^[\s"'.,;:!?()\u2018\u2019\u201c\u201d]+/, "").replace(/[\s"'.,;:!?()\u2018\u2019\u201c\u201d]+$/, "");
-}
-/** Minimum normalized span that counts as meaningful verbatim evidence. */
-const MIN_POOL_EVIDENCE_CHARS = 8;
-/** Evidence verifier shared by mining and newborn assignment. */
-export function poolEvidenceMatches(publicContext, evidence) {
-    if (evidence === null)
-        return false;
-    const context = normalizePoolEvidenceForMatch(publicContext);
-    const evidenceCore = normalizePoolEvidenceForMatch(stripPoolEvidenceEdgePunctuation(evidence));
-    return evidenceCore.length >= MIN_POOL_EVIDENCE_CHARS && context.includes(evidenceCore);
-}
-/**
- * Stateless axis-mining agent. One `mine()` call = one structured LLM pass +
- * deterministic evidence verification.
- */
-export class PoolDiscriminatorMiner {
-    constructor(config) {
-        this.model = createStructuredModel("poolDiscriminatorMiner", AxisMiningResponseSchema, { name: "pool_axes" }, config?.modelConfig);
-    }
-    /**
-     * Mine discriminating axes for one pool.
-     *
-     * @returns Verified axes (may be empty). Throws on LLM failure — callers
-     *   run this fire-and-forget and must catch.
-     */
-    async mine(input, options) {
-        const prompt = buildMiningPrompt(input);
-        const raw = await invokeWithAbortSignal(this.model, [new SystemMessage(SYSTEM_PROMPT), new HumanMessage(prompt)], options?.signal);
-        const parsed = AxisMiningResponseSchema.safeParse(raw);
-        if (!parsed.success) {
-            logger.warn("Mining response failed schema validation", { issues: parsed.error.issues.length });
-            return [];
-        }
-        return parsed.data.axes.slice(0, MAX_AXES).map((axis) => verifyAxis(axis, input.candidates));
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], PoolDiscriminatorMiner.prototype, "mine", null);
-/** Builds the human message: intent text + one numbered block per candidate. */
-export function buildMiningPrompt(input) {
-    const candidateBlocks = input.candidates
-        .map((c) => `[${c.id}]\n${c.publicContext}`)
-        .join("\n\n");
-    return [
-        `Intent:\n${input.intentText}`,
-        `Candidate pool (${input.candidates.length} candidates, id in brackets):\n\n${candidateBlocks}`,
-    ].join("\n\n");
-}
-/**
- * Deterministic post-pass over one LLM axis:
- * - drops assignments for ids not in the pool,
- * - demotes to unknown: sides not in the axis's side list, missing evidence,
- *   and evidence that does not substring-match the candidate's publicContext,
- * - collapses duplicate proposals to the same trim-normalized side,
- * - demotes a candidate proposed for different sides to unknown (zero support),
- * - guarantees exactly one assignment per pool candidate (missing → unknown),
- * - computes evidenceRate = verified / distinct candidate-side proposals.
- */
-export function verifyAxis(axis, candidates) {
-    const contextById = new Map(candidates.map((c) => [c.id, c.publicContext]));
-    const normalizedAxisSides = axis.sides.map((side) => side.trim());
-    const axisSidesAreValid = normalizedAxisSides.every(Boolean)
-        && new Set(normalizedAxisSides).size === normalizedAxisSides.length;
-    const canonicalSideByNormalized = new Map(axis.sides.map((side) => [side.trim(), side]));
-    const proposalsById = new Map();
-    for (const assignment of axis.assignments) {
-        if (!contextById.has(assignment.id) || assignment.side === null)
-            continue;
-        const normalizedSide = assignment.side.trim();
-        let sides = proposalsById.get(assignment.id);
-        if (!sides) {
-            sides = new Map();
-            proposalsById.set(assignment.id, sides);
-        }
-        const sameSide = sides.get(normalizedSide) ?? [];
-        sameSide.push(assignment);
-        sides.set(normalizedSide, sameSide);
-    }
-    const byId = new Map();
-    let proposed = 0;
-    let verified = 0;
-    for (const [id, sides] of proposalsById) {
-        proposed += sides.size;
-        // Conflicting classifier output is permanently ambiguous regardless of
-        // proposal order or evidence quality. It must contribute zero support.
-        if (sides.size !== 1 || !axisSidesAreValid) {
-            byId.set(id, { id, side: null, evidence: null, verified: false });
-            continue;
-        }
-        const [[normalizedSide, sameSideProposals]] = [...sides];
-        const canonicalSide = canonicalSideByNormalized.get(normalizedSide);
-        const context = contextById.get(id);
-        const evidenceValid = canonicalSide
-            ? sameSideProposals.find((proposal) => poolEvidenceMatches(context, proposal.evidence))
-            : undefined;
-        if (canonicalSide && evidenceValid) {
-            verified++;
-            byId.set(id, {
-                id,
-                side: canonicalSide,
-                evidence: evidenceValid.evidence,
-                verified: true,
-            });
-        }
-        else {
-            byId.set(id, {
-                id,
-                side: null,
-                evidence: sameSideProposals[0]?.evidence ?? null,
-                verified: false,
-            });
-        }
-    }
-    const assignments = candidates.map((candidate) => byId.get(candidate.id)
-        ?? { id: candidate.id, side: null, evidence: null, verified: false });
-    return {
-        label: axis.axis,
-        questionSeed: axis.questionSeed,
-        sides: axis.sides,
-        assignments,
-        evidenceRate: proposed > 0 ? verified / proposed : 0,
-    };
-}

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

@@ -1,13 +0,0 @@
-import type { QuestionPoolSnapshot } from "../../questions/question.module.js";
-/** Maximum raw intent-title characters included in a proactive DM line. */
-export declare const POOL_QUESTION_PUSH_TITLE_MAX_CHARS = 80;
-/** Stable identity for one pool refresh cycle. Chained alternates retain it. */
-export declare function poolQuestionCycleKey(pool: Pick<QuestionPoolSnapshot, "runId" | "minedAt">): string;
-/** Escape plain text so it cannot alter the deterministic Markdown template. */
-export declare function escapePoolPushMarkdown(text: string): string;
-/** Build the sole proactive user-facing DM line for a pushed pool question. */
-export declare function buildPoolQuestionPushMessage(input: {
-    intentId: string;
-    intentTitle: string;
-    questionPrompt: string;
-}): string;

package/dist/opportunities/discriminator/discriminator.push.js

@@ -1,19 +0,0 @@
-/** Maximum raw intent-title characters included in a proactive DM line. */
-export const POOL_QUESTION_PUSH_TITLE_MAX_CHARS = 80;
-/** Stable identity for one pool refresh cycle. Chained alternates retain it. */
-export function poolQuestionCycleKey(pool) {
-    const runId = pool.runId?.trim();
-    return runId ? `run:${runId}` : `mined:${pool.minedAt}`;
-}
-/** Escape plain text so it cannot alter the deterministic Markdown template. */
-export function escapePoolPushMarkdown(text) {
-    return text.replace(/([\\`*_[\]{}()<>#+\-.!|])/g, "\\$1");
-}
-/** Build the sole proactive user-facing DM line for a pushed pool question. */
-export function buildPoolQuestionPushMessage(input) {
-    const normalizedTitle = input.intentTitle.replace(/\s+/g, " ").trim() || "your intent";
-    const boundedTitle = normalizedTitle.length > POOL_QUESTION_PUSH_TITLE_MAX_CHARS
-        ? `${normalizedTitle.slice(0, POOL_QUESTION_PUSH_TITLE_MAX_CHARS - 1)}…`
-        : normalizedTitle;
-    return `Quick one about [${escapePoolPushMarkdown(boundedTitle)}](/i/${input.intentId}): ${escapePoolPushMarkdown(input.questionPrompt)}`;
-}

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

@@ -1,58 +0,0 @@
-/**
- * Deterministic pool_discovery question synthesis (IND-418).
- *
- * A mined discriminator already carries everything a question needs: a label,
- * a question seed, 2–3 sides, and verified per-candidate assignments. This
- * module turns the top discriminator into a `Question` payload + server-side
- * pool snapshot with ZERO generation-time LLM calls — the phrasing was
- * produced (and evidence-verified) at mining time, so synthesis is pure,
- * auditable, and cheap to re-run for interview-mode chaining.
- */
-import type { Question, QuestionPoolDiscriminator, QuestionPoolSnapshot } from "../../questions/question.module.js";
-import type { ScoredDiscriminator } from "./discriminator.types.js";
-/** Fixed option appended to every pool question — the no-preference escape. */
-export declare const BOTH_MATTER_LABEL = "Both matter";
-/**
- * Converts a scored discriminator into the compact snapshot form stored on
- * the question row (verified assignments only; unknowns dropped).
- */
-export declare function toQuestionDiscriminator(d: ScoredDiscriminator): QuestionPoolDiscriminator;
-/**
- * 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 declare function selectQuestionDiscriminators(discriminators: ScoredDiscriminator[]): ScoredDiscriminator[];
-/** Input for one question synthesis. */
-export interface SynthesizePoolQuestionInput {
-    /** The discriminator to ask about (already eligibility-filtered). */
-    discriminator: QuestionPoolDiscriminator;
-    /** Remaining ranked eligible discriminators (interview-mode chain stash). */
-    alternates: QuestionPoolDiscriminator[];
-    poolSize: number;
-    /** Exact bounded candidate opportunity IDs supplied to this synthesis pass. */
-    opportunityIds: string[];
-    /** ISO-8601 timestamp of the mining pass. */
-    minedAt: string;
-    /** Discovery run id, when known. */
-    runId?: string;
-    /**
-     * Intent payload snippet — folded into the evidence chip so the question
-     * self-identifies on any surface ("based on 16 people matching ‘…’").
-     */
-    intentText?: string;
-    /** Stable hash of the full normalized intent payload + summary. */
-    intentFingerprint?: string;
-}
-/** Synthesized question: client payload + server-side snapshot. */
-export interface SynthesizedPoolQuestion {
-    payload: Question;
-    pool: QuestionPoolSnapshot;
-}
-/**
- * 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 declare function synthesizePoolQuestion(input: SynthesizePoolQuestionInput): SynthesizedPoolQuestion | null;