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

package/dist/opportunities/delivery-card.cache.js

@@ -1,43 +0,0 @@
-import { gatherPresenterContext } from "./opportunity.presentation.js";
-import { buildDeliveryCardPresentationCacheKey } from "./opportunity.presentation.js";
-export const DELIVERY_CARD_CACHE_TTL = 24 * 60 * 60; // 24 hours
-export async function getOrCreateDeliveryCardBatch(cache, presenter, presenterDb, opportunities, viewerId, options) {
-    if (opportunities.length === 0) {
-        return new Map();
-    }
-    const ttl = options?.ttl ?? DELIVERY_CARD_CACHE_TTL;
-    const keys = opportunities.map((opp) => buildDeliveryCardPresentationCacheKey(opp.id, opp.status, viewerId));
-    const cached = await cache.mget(keys);
-    const result = new Map();
-    const misses = [];
-    for (let i = 0; i < opportunities.length; i++) {
-        const item = cached[i];
-        if (item) {
-            result.set(opportunities[i].id, item);
-        }
-        else {
-            misses.push({ opp: opportunities[i], index: i });
-        }
-    }
-    // Generate cards for cache misses
-    await Promise.all(misses.map(async ({ opp, index }) => {
-        const presenterInput = await gatherPresenterContext(presenterDb, opp, viewerId);
-        presenterInput.opportunityStatus = opp.status;
-        const presented = await presenter.presentCard(presenterInput);
-        const card = {
-            opportunityId: opp.id,
-            headline: presented.headline,
-            personalizedSummary: presented.personalizedSummary,
-            suggestedAction: presented.suggestedAction,
-            narratorRemark: presented.narratorRemark,
-            greeting: presented.greeting ?? '',
-        };
-        result.set(opp.id, card);
-        // Presenter fallbacks are safe for this request but are deliberately not
-        // persisted for 24 hours; a later request should retry genuine copy.
-        if (!presented.isFallback) {
-            await cache.set(keys[index], card, { ttl });
-        }
-    }));
-    return result;
-}

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

@@ -1,20 +0,0 @@
-export declare const DISCOVERY_MIN_SIMILARITY_DEFAULT = 0.3;
-export declare const DISCOVERY_EVALUATOR_MIN_SCORE_DEFAULT = 50;
-export declare function validateDiscoveryMinSimilarity(value: number): number;
-export declare function validateDiscoveryEvaluatorMinScore(value: number): number;
-export declare function discoveryMinSimilarity(): number;
-export declare function discoveryEvaluatorMinScore(): number;
-/** Data types allowed to participate in opportunity matching. */
-export type DiscoveryMatchType = 'intent' | 'profile';
-/** Test hook: clear warn-once state so each test observes warnings. */
-export declare function resetDiscoveryEnvWarningsForTests(): void;
-/** Current DISCOVERY_ALLOWED_TYPES set (default: intent + profile). */
-export declare function discoveryAllowedTypes(): ReadonlySet<DiscoveryMatchType>;
-/** True when intents may participate in matching (source or candidate). */
-export declare function discoveryIntentMatchingEnabled(): boolean;
-/** True when profile data (premises or user_contexts) may participate. */
-export declare function discoveryProfileMatchingEnabled(): boolean;
-/** What "profile" means in matching: heavyweight premises or lightweight user_contexts. */
-export type DiscoveryProfileSource = 'premise' | 'user_context';
-/** Current DISCOVERY_PROFILE_SOURCE (default: premise). */
-export declare function discoveryProfileSource(): DiscoveryProfileSource;

package/dist/opportunities/discovery.env.js

@@ -1,109 +0,0 @@
-/**
- * Centralized accessors for discovery match-type environment variables.
- *
- *   DISCOVERY_ALLOWED_TYPES   CSV of `intent`, `profile` (default: both).
- *                             Master gate for which data types may participate
- *                             in opportunity matching. `profile` is an umbrella
- *                             whose representation is selected by
- *                             DISCOVERY_PROFILE_SOURCE. Unknown tokens warn once
- *                             and are ignored; if no valid tokens remain, falls
- *                             back to both-allowed with a warning (a typo must
- *                             never disable all discovery).
- *   DISCOVERY_PROFILE_SOURCE  `premise` (default, heavyweight: atomic premises
- *                             as profile corpus + premise-to-premise) or
- *                             `user_context` (lightweight: synthesized context
- *                             paragraphs as profile corpus + context-to-context).
- *                             Unknown values warn once and fall back to `premise`.
- *
- * 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.
- */
-import { protocolLogger } from '../shared/observability/protocol.logger.js';
-const envLog = protocolLogger('Discovery:env');
-export const DISCOVERY_MIN_SIMILARITY_DEFAULT = 0.30;
-export const DISCOVERY_EVALUATOR_MIN_SCORE_DEFAULT = 50;
-const DECIMAL_VALUE = /^[+]?(?:\d+(?:\.\d*)?|\.\d+)$/;
-function validateThreshold(name, value, max) {
-    if (!Number.isFinite(value) || value < 0 || value > max) {
-        throw new Error(`${name} must be a finite decimal between 0 and ${max} (inclusive)`);
-    }
-    return value;
-}
-function readThreshold(raw, name, fallback, max) {
-    if (raw === undefined || raw.trim() === '')
-        return fallback;
-    const normalized = raw.trim();
-    if (!DECIMAL_VALUE.test(normalized)) {
-        throw new Error(`${name} must be a finite decimal between 0 and ${max} (inclusive)`);
-    }
-    return validateThreshold(name, Number(normalized), max);
-}
-export function validateDiscoveryMinSimilarity(value) {
-    return validateThreshold('DISCOVERY_MIN_SIMILARITY', value, 1);
-}
-export function validateDiscoveryEvaluatorMinScore(value) {
-    return validateThreshold('DISCOVERY_EVALUATOR_MIN_SCORE', value, 100);
-}
-export function discoveryMinSimilarity() {
-    return readThreshold(process.env.DISCOVERY_MIN_SIMILARITY, 'DISCOVERY_MIN_SIMILARITY', DISCOVERY_MIN_SIMILARITY_DEFAULT, 1);
-}
-export function discoveryEvaluatorMinScore() {
-    return readThreshold(process.env.DISCOVERY_EVALUATOR_MIN_SCORE, 'DISCOVERY_EVALUATOR_MIN_SCORE', DISCOVERY_EVALUATOR_MIN_SCORE_DEFAULT, 100);
-}
-const VALID_TOKENS = new Set(['intent', 'profile']);
-const BOTH = new Set(['intent', 'profile']);
-/** Tokens/values already warned about (warn-once per process). */
-const warned = new Set();
-/** Test hook: clear warn-once state so each test observes warnings. */
-export function resetDiscoveryEnvWarningsForTests() {
-    warned.clear();
-}
-function warnOnce(key, message) {
-    if (warned.has(key))
-        return;
-    warned.add(key);
-    envLog.warn(message);
-}
-/** Current DISCOVERY_ALLOWED_TYPES set (default: intent + profile). */
-export function discoveryAllowedTypes() {
-    const raw = process.env.DISCOVERY_ALLOWED_TYPES;
-    if (raw === undefined || raw.trim() === '')
-        return BOTH;
-    const parsed = new Set();
-    for (const token of raw.split(',')) {
-        const t = token.trim().toLowerCase();
-        if (!t)
-            continue;
-        if (VALID_TOKENS.has(t)) {
-            parsed.add(t);
-        }
-        else {
-            warnOnce(`token:${t}`, `DISCOVERY_ALLOWED_TYPES: ignoring unknown token "${t}" (valid: intent, profile)`);
-        }
-    }
-    if (parsed.size === 0) {
-        warnOnce('fallback', `DISCOVERY_ALLOWED_TYPES="${raw}" has no valid tokens; falling back to intent,profile`);
-        return BOTH;
-    }
-    return parsed;
-}
-/** True when intents may participate in matching (source or candidate). */
-export function discoveryIntentMatchingEnabled() {
-    return discoveryAllowedTypes().has('intent');
-}
-/** True when profile data (premises or user_contexts) may participate. */
-export function discoveryProfileMatchingEnabled() {
-    return discoveryAllowedTypes().has('profile');
-}
-/** Current DISCOVERY_PROFILE_SOURCE (default: premise). */
-export function discoveryProfileSource() {
-    const raw = process.env.DISCOVERY_PROFILE_SOURCE;
-    if (raw === undefined || raw.trim() === '')
-        return 'premise';
-    const v = raw.trim().toLowerCase();
-    if (v === 'premise' || v === 'user_context')
-        return v;
-    warnOnce(`source:${v}`, `DISCOVERY_PROFILE_SOURCE: unknown value "${raw}"; falling back to "premise" (valid: premise, user_context)`);
-    return 'premise';
-}

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

@@ -1,90 +0,0 @@
-import type { QuestionPoolDiscriminator } from "../../questions/question.module.js";
-/** Recipient and intent provenance that scopes one pool preference. */
-export interface PoolAdjustmentProvenance {
-    recipientUserId: string;
-    intentId: string;
-}
-/** One applied adjustment on an opportunity (stored in metadata.poolAdjustments). */
-export interface PoolAdjustment extends PoolAdjustmentProvenance {
-    /** The answered question that produced this adjustment (reversal key). */
-    questionId: string;
-    /** Discriminator label, e.g. "Hands-on builders vs advisors". */
-    label: string;
-    /** Side this candidate was assigned to (or "unknown"). */
-    side: string;
-    /** Multiplicative factor: chosen 1.0, other 0.6, unknown 0.9. */
-    factor: number;
-    /** Template chip text from the user's own answer. Set on demotions only. */
-    detail?: string;
-    /** ISO-8601 apply timestamp. */
-    appliedAt: string;
-    /** Full intent fingerprint authoritative when this adjustment was created. */
-    intentFingerprint?: string;
-    /** Audit-only marker: stale adjustments remain stored but have no ranking effect. */
-    stale?: true;
-}
-/** Reads valid adjustments, optionally narrowed to one recipient + intent. */
-export declare function readPoolAdjustments(metadata: Record<string, unknown> | null | undefined, provenance?: PoolAdjustmentProvenance): PoolAdjustment[];
-/** Reads valid, non-stale adjustments for ranking and presentation behavior. */
-export declare function readActivePoolAdjustments(metadata: Record<string, unknown> | null | undefined, provenance?: PoolAdjustmentProvenance): PoolAdjustment[];
-/**
- * Cumulative adjustment multiplier for an opportunity, floored at
- * {@link POOL_ADJUSTMENT_FLOOR}. 1 when no scoped adjustments exist.
- */
-export declare function poolAdjustmentMultiplier(metadata: Record<string, unknown> | null | undefined, provenance: PoolAdjustmentProvenance): number;
-/** Adjusted confidence: `confidence × Π factor`, floored. */
-export declare function adjustedConfidence(confidence: number, metadata: Record<string, unknown> | null | undefined, provenance: PoolAdjustmentProvenance): number;
-/** Deterministic provenance signal stored alongside one adjustment. */
-export interface PoolAdjustmentSignal extends PoolAdjustmentProvenance {
-    type: "pool_discriminator";
-    weight: 1 | -1 | 0;
-    detail: string;
-    questionId: string;
-}
-/** Pure helper input shared by Tier-0 answers and newborn stamping. */
-export interface BuildPoolAdjustmentInput extends PoolAdjustmentProvenance {
-    questionId: string;
-    label: string;
-    /** Verified side assignment, or null when the candidate is unassigned. */
-    assignedSide: string | null;
-    chosenSide: string;
-    appliedAt: string;
-    /** Full intent fingerprint authoritative when this adjustment was created. */
-    intentFingerprint?: string;
-}
-/**
- * Build one P3-compatible adjustment and signal. This is the only place that
- * defines chosen/other/unknown factors, weights, and safe template details.
- */
-export declare function buildPoolAdjustment(input: BuildPoolAdjustmentInput): {
-    adjustment: PoolAdjustment;
-    signal: PoolAdjustmentSignal;
-};
-/** Plan entry: what to write on one opportunity for one answer. */
-export interface PoolAdjustmentPlanEntry {
-    opportunityId: string;
-    adjustment: PoolAdjustment;
-    signal: PoolAdjustmentSignal;
-}
-/**
- * Computes the write plan for one answered discriminator. Pure: the caller
- * loads/patches rows. "Both matter" (or any label not in `sides`) yields an
- * empty plan — no preference, no adjustments.
- *
- * @param discriminator  The asked discriminator (from detection.pool).
- * @param chosenSide     The selected option label (chip label = side label).
- * @param questionId     Reversal key.
- * @param recipientUserId User whose answer produced the preference.
- * @param intentId       Intent whose candidate pool was ranked.
- * @param now            ISO-8601 timestamp.
- * @param intentFingerprint Full intent fingerprint authoritative at apply time.
- */
-export declare function planPoolAdjustments(discriminator: QuestionPoolDiscriminator, chosenSide: string, questionId: string, recipientUserId: string, intentId: string, now: string, intentFingerprint?: string): PoolAdjustmentPlanEntry[];
-/**
- * Merges one adjustment into an opportunity's existing metadata, replacing
- * only the entry for the same question + recipient + intent provenance.
- * Returns the NEW metadata object (caller persists it wholesale).
- */
-export declare function mergePoolAdjustment(metadata: Record<string, unknown> | null | undefined, adjustment: PoolAdjustment): Record<string, unknown>;
-/** Latest scoped user-explainable demotion detail for card presentation. */
-export declare function latestPoolDemotionDetail(metadata: Record<string, unknown> | null | undefined, provenance: PoolAdjustmentProvenance): string | undefined;

package/dist/opportunities/discriminator/discriminator.adjustments.js

@@ -1,141 +0,0 @@
-/**
- * Pool-adjustment domain logic (IND-419) — pure functions, no I/O.
- *
- * When a user answers a pool_discovery question, every candidate the mining
- * pass assigned to a side gets a multiplicative adjustment written to
- * `opportunities.metadata.poolAdjustments`. The radar view (flag-gated) orders
- * by `confidence × Π factor`, floored so demoted candidates stay visible.
- *
- * Invariants:
- * - Deterministic and O(pool): no LLM at answer time — the applyPlan was
- *   computed (and evidence-verified) at mining time.
- * - Reversible: entries are keyed by questionId; re-answering replaces them,
- *   dismissal-driven reversal removes them.
- * - `detail` carries the template chip text built from the user's OWN answer
- *   ("Hands-on builders vs advisors: you chose Advisor") — never LLM
- *   reasoning (see `packages/protocol/src/opportunity/AGENTS.md`).
- */
-import { POOL_ADJUSTMENT_FACTOR_OTHER, POOL_ADJUSTMENT_FACTOR_UNKNOWN, POOL_ADJUSTMENT_FLOOR } from "./discriminator.env.js";
-/** Reads valid adjustments, optionally narrowed to one recipient + intent. */
-export function readPoolAdjustments(metadata, provenance) {
-    const raw = metadata?.poolAdjustments;
-    if (!Array.isArray(raw))
-        return [];
-    return raw.filter((a) => {
-        if (typeof a !== "object" || a === null ||
-            typeof a.questionId !== "string" ||
-            typeof a.recipientUserId !== "string" ||
-            typeof a.intentId !== "string" ||
-            typeof a.factor !== "number" ||
-            (a.stale !== undefined && a.stale !== true))
-            return false;
-        return provenance === undefined || (a.recipientUserId === provenance.recipientUserId &&
-            a.intentId === provenance.intentId);
-    });
-}
-/** Reads valid, non-stale adjustments for ranking and presentation behavior. */
-export function readActivePoolAdjustments(metadata, provenance) {
-    return readPoolAdjustments(metadata, provenance).filter((adjustment) => adjustment.stale !== true);
-}
-/**
- * Cumulative adjustment multiplier for an opportunity, floored at
- * {@link POOL_ADJUSTMENT_FLOOR}. 1 when no scoped adjustments exist.
- */
-export function poolAdjustmentMultiplier(metadata, provenance) {
-    const adjustments = readActivePoolAdjustments(metadata, provenance);
-    if (adjustments.length === 0)
-        return 1;
-    const product = adjustments.reduce((acc, a) => acc * (Number.isFinite(a.factor) && a.factor > 0 ? a.factor : 1), 1);
-    return Math.max(POOL_ADJUSTMENT_FLOOR, product);
-}
-/** Adjusted confidence: `confidence × Π factor`, floored. */
-export function adjustedConfidence(confidence, metadata, provenance) {
-    return confidence * poolAdjustmentMultiplier(metadata, provenance);
-}
-/**
- * Build one P3-compatible adjustment and signal. This is the only place that
- * defines chosen/other/unknown factors, weights, and safe template details.
- */
-export function buildPoolAdjustment(input) {
-    const isUnknown = input.assignedSide === null;
-    const isChosen = !isUnknown && input.assignedSide === input.chosenSide;
-    const factor = isUnknown ? POOL_ADJUSTMENT_FACTOR_UNKNOWN : isChosen ? 1 : POOL_ADJUSTMENT_FACTOR_OTHER;
-    const weight = isUnknown ? 0 : isChosen ? 1 : -1;
-    const side = input.assignedSide ?? "unknown";
-    return {
-        adjustment: {
-            questionId: input.questionId,
-            recipientUserId: input.recipientUserId,
-            intentId: input.intentId,
-            label: input.label,
-            side,
-            factor,
-            ...(!isChosen && !isUnknown ? { detail: `${input.label}: you chose ${input.chosenSide}` } : {}),
-            appliedAt: input.appliedAt,
-            ...(input.intentFingerprint !== undefined ? { intentFingerprint: input.intentFingerprint } : {}),
-        },
-        signal: {
-            type: "pool_discriminator",
-            weight,
-            recipientUserId: input.recipientUserId,
-            intentId: input.intentId,
-            detail: isUnknown ? `${input.label}: unassigned` : `${input.label}: ${input.chosenSide}`,
-            questionId: input.questionId,
-        },
-    };
-}
-/**
- * Computes the write plan for one answered discriminator. Pure: the caller
- * loads/patches rows. "Both matter" (or any label not in `sides`) yields an
- * empty plan — no preference, no adjustments.
- *
- * @param discriminator  The asked discriminator (from detection.pool).
- * @param chosenSide     The selected option label (chip label = side label).
- * @param questionId     Reversal key.
- * @param recipientUserId User whose answer produced the preference.
- * @param intentId       Intent whose candidate pool was ranked.
- * @param now            ISO-8601 timestamp.
- * @param intentFingerprint Full intent fingerprint authoritative at apply time.
- */
-export function planPoolAdjustments(discriminator, chosenSide, questionId, recipientUserId, intentId, now, intentFingerprint) {
-    // Chip labels are word-capped side labels; match on the capped prefix too.
-    const matchesSide = (side) => side === chosenSide || side.startsWith(chosenSide) || chosenSide.startsWith(side);
-    const chosen = discriminator.sides.find(matchesSide);
-    if (!chosen)
-        return []; // "Both matter" or unrecognized option → no adjustments.
-    const plan = [];
-    for (const a of discriminator.assignments) {
-        plan.push({
-            opportunityId: a.opportunityId,
-            ...buildPoolAdjustment({
-                questionId,
-                recipientUserId,
-                intentId,
-                label: discriminator.label,
-                assignedSide: a.side,
-                chosenSide: chosen,
-                appliedAt: now,
-                ...(intentFingerprint !== undefined ? { intentFingerprint } : {}),
-            }),
-        });
-    }
-    return plan;
-}
-/**
- * Merges one adjustment into an opportunity's existing metadata, replacing
- * only the entry for the same question + recipient + intent provenance.
- * Returns the NEW metadata object (caller persists it wholesale).
- */
-export function mergePoolAdjustment(metadata, adjustment) {
-    const existing = readPoolAdjustments(metadata).filter((a) => !(a.questionId === adjustment.questionId &&
-        a.recipientUserId === adjustment.recipientUserId &&
-        a.intentId === adjustment.intentId));
-    return { ...(metadata ?? {}), poolAdjustments: [...existing, adjustment] };
-}
-/** Latest scoped user-explainable demotion detail for card presentation. */
-export function latestPoolDemotionDetail(metadata, provenance) {
-    return [...readActivePoolAdjustments(metadata, provenance)]
-        .reverse()
-        .find((adjustment) => adjustment.factor < 1 && typeof adjustment.detail === 'string' && adjustment.detail.length > 0)
-        ?.detail;
-}

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

@@ -1,78 +0,0 @@
-import { z } from "zod";
-import { createStructuredModel } from "../../shared/agent/model.config.js";
-import type { PoolCandidate } from "./discriminator.types.js";
-declare const AxisSchema: z.ZodObject<{
-    questionId: z.ZodString;
-    assignments: z.ZodArray<z.ZodObject<{
-        candidateId: z.ZodString;
-        side: z.ZodNullable<z.ZodString>;
-        evidence: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        evidence: string | null;
-        side: string | null;
-        candidateId: string;
-    }, {
-        evidence: string | null;
-        side: string | null;
-        candidateId: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    assignments: {
-        evidence: string | null;
-        side: string | null;
-        candidateId: string;
-    }[];
-    questionId: string;
-}, {
-    assignments: {
-        evidence: string | null;
-        side: string | null;
-        candidateId: string;
-    }[];
-    questionId: string;
-}>;
-type RawAxis = z.infer<typeof AxisSchema>;
-/** Fixed answered axis; deliberately excludes the owner's chosen side. */
-export interface PoolDiscriminatorAssignmentAxis {
-    questionId: string;
-    label: string;
-    sides: string[];
-}
-/** One batched assignment call. */
-export interface PoolDiscriminatorAssignmentInput {
-    axes: PoolDiscriminatorAssignmentAxis[];
-    candidates: PoolCandidate[];
-}
-/** Verified assignment. Invalid or explicit unknown classifications use null. */
-export interface PoolDiscriminatorCandidateAssignment {
-    candidateId: string;
-    side: string | null;
-    evidence: string | null;
-}
-/** One valid returned axis. Missing or malformed axes are omitted entirely. */
-export interface PoolDiscriminatorAssignedAxis {
-    questionId: string;
-    assignments: PoolDiscriminatorCandidateAssignment[];
-}
-/** Construction options for {@link PoolDiscriminatorAssigner}. */
-export interface PoolDiscriminatorAssignerConfig {
-    modelConfig?: Parameters<typeof createStructuredModel>[3];
-}
-/** Build the classifier prompt without any chosen-side preference. */
-export declare function buildAssignmentPrompt(input: PoolDiscriminatorAssignmentInput): string;
-/** Verify one model-returned axis against fixed IDs, sides, and contexts. */
-export declare function verifyAssignedAxis(raw: RawAxis, input: PoolDiscriminatorAssignmentInput): PoolDiscriminatorAssignedAxis | null;
-/** Stateless one-call newborn candidate classifier. */
-export declare class PoolDiscriminatorAssigner {
-    private model;
-    constructor(config?: PoolDiscriminatorAssignerConfig);
-    /**
-     * Classify every candidate against every fixed axis in one provider call.
-     * Provider failures propagate so the host graph's fail-open seam can retain
-     * the original un-stamped create items.
-     */
-    assign(input: PoolDiscriminatorAssignmentInput, options?: {
-        signal?: AbortSignal;
-    }): Promise<PoolDiscriminatorAssignedAxis[]>;
-}
-export {};

package/dist/opportunities/discriminator/discriminator.assigner.js

@@ -1,153 +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);
-};
-/**
- * Evidence-verified assignment of call-local newborn candidates to already
- * answered pool-discriminator axes (IND-420 P4b).
- *
- * One structured model call batches every fixed axis and candidate. The model
- * never receives the owner's chosen side; it only classifies public candidate
- * context. Code owns all identifiers, allowed sides, and evidence verification.
- */
-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";
-import { POOL_DISCRIMINATOR_MAX_CANDIDATES } from "./discriminator.env.js";
-import { poolEvidenceMatches } from "./discriminator.miner.js";
-/** QuestionerAdapter caps fresh answered preferences at this count. */
-const MAX_ASSIGNMENT_AXES = 10;
-const logger = protocolLogger("PoolDiscriminatorAssigner");
-const AssignmentSchema = z.object({
-    candidateId: z.string(),
-    side: z.string().nullable(),
-    evidence: z.string().max(200).nullable(),
-});
-const AxisSchema = z.object({
-    questionId: z.string(),
-    assignments: z.array(AssignmentSchema).max(POOL_DISCRIMINATOR_MAX_CANDIDATES),
-});
-// Keep fields optional at the outer response layer so one malformed/missing
-// axis can be skipped independently, while still bounding and describing the
-// nested assignment payload sent through structured output.
-const ResponseAxisSchema = z.object({
-    questionId: z.string().optional(),
-    assignments: z.array(AssignmentSchema).max(POOL_DISCRIMINATOR_MAX_CANDIDATES).optional(),
-}).passthrough();
-const ResponseSchema = z.object({ axes: z.array(ResponseAxisSchema).max(MAX_ASSIGNMENT_AXES) });
-const SYSTEM_PROMPT = `Classify candidate matches against FIXED preference axes.
-
-Rules:
-- Use only the supplied questionId, candidateId, and side labels. Never invent or rename them.
-- Return one axis object per supplied question and one assignment per candidate.
-- Pick a side only when the candidate context clearly supports it; otherwise use side null and evidence null.
-- Every non-null side requires a short VERBATIM substring copied from that candidate's context. It is checked mechanically.
-- Do not infer the user's preference. You are classifying candidates, not choosing which side is better.
-- Return only questionId, candidateId, side, and evidence fields.`;
-/** Build the classifier prompt without any chosen-side preference. */
-export function buildAssignmentPrompt(input) {
-    const axes = input.axes.map((axis) => ({
-        questionId: axis.questionId,
-        label: axis.label,
-        sides: axis.sides,
-    }));
-    const candidates = input.candidates.map((candidate) => ({
-        candidateId: candidate.id,
-        publicContext: candidate.publicContext,
-    }));
-    return JSON.stringify({ axes, candidates }, null, 2);
-}
-/** Verify one model-returned axis against fixed IDs, sides, and contexts. */
-export function verifyAssignedAxis(raw, input) {
-    const fixedAxis = input.axes.find((axis) => axis.questionId === raw.questionId);
-    if (!fixedAxis)
-        return null;
-    const contextById = new Map(input.candidates.map((candidate) => [candidate.id, candidate.publicContext]));
-    const firstById = new Map();
-    for (const assignment of raw.assignments) {
-        const context = contextById.get(assignment.candidateId);
-        if (context === undefined || firstById.has(assignment.candidateId))
-            continue;
-        if (assignment.side === null) {
-            firstById.set(assignment.candidateId, {
-                candidateId: assignment.candidateId,
-                side: null,
-                evidence: null,
-            });
-            continue;
-        }
-        if (!fixedAxis.sides.includes(assignment.side) || !poolEvidenceMatches(context, assignment.evidence)) {
-            firstById.set(assignment.candidateId, {
-                candidateId: assignment.candidateId,
-                side: null,
-                evidence: null,
-            });
-            continue;
-        }
-        firstById.set(assignment.candidateId, {
-            candidateId: assignment.candidateId,
-            side: assignment.side,
-            evidence: assignment.evidence,
-        });
-    }
-    return {
-        questionId: fixedAxis.questionId,
-        assignments: input.candidates.map((candidate) => firstById.get(candidate.id) ?? {
-            candidateId: candidate.id,
-            side: null,
-            evidence: null,
-        }),
-    };
-}
-/** Stateless one-call newborn candidate classifier. */
-export class PoolDiscriminatorAssigner {
-    constructor(config) {
-        this.model = createStructuredModel("poolDiscriminatorAssigner", ResponseSchema, { name: "pool_newborn_assignments" }, config?.modelConfig);
-    }
-    /**
-     * Classify every candidate against every fixed axis in one provider call.
-     * Provider failures propagate so the host graph's fail-open seam can retain
-     * the original un-stamped create items.
-     */
-    async assign(input, options) {
-        if (input.axes.length === 0 || input.candidates.length === 0)
-            return [];
-        const boundedInput = {
-            axes: input.axes.slice(0, MAX_ASSIGNMENT_AXES),
-            candidates: input.candidates.slice(0, POOL_DISCRIMINATOR_MAX_CANDIDATES),
-        };
-        const raw = await invokeWithAbortSignal(this.model, [new SystemMessage(SYSTEM_PROMPT), new HumanMessage(buildAssignmentPrompt(boundedInput))], options?.signal);
-        const parsed = ResponseSchema.safeParse(raw);
-        if (!parsed.success) {
-            logger.warn("Assignment response failed schema validation", { issues: parsed.error.issues.length });
-            return [];
-        }
-        const seen = new Set();
-        const verified = [];
-        for (const rawAxis of parsed.data.axes) {
-            const axis = AxisSchema.safeParse(rawAxis);
-            if (!axis.success || seen.has(axis.data.questionId))
-                continue;
-            const result = verifyAssignedAxis(axis.data, boundedInput);
-            if (!result)
-                continue;
-            seen.add(result.questionId);
-            verified.push(result);
-        }
-        return verified;
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], PoolDiscriminatorAssigner.prototype, "assign", null);