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

package/dist/opportunities/outcome/outcome.env.js

@@ -1,63 +0,0 @@
-/**
- * Centralized accessors for Lens B outcome-question environment variables
- * (IND-434).
- *
- *   OUTCOME_QUESTIONS_MODE   off | shadow | on — Lens B "explicit opportunity
- *                            outcomes → grounded questions" pipeline.
- *
- *                            off (default): no outcome feedback events are
- *                              captured and no hypothesis mining runs. Zero
- *                              behavior change.
- *                            shadow: capture one idempotent append-only
- *                              feedback event per explicit owner action, mine
- *                              neutral trade-off hypotheses for the exact
- *                              recipient + intent + fingerprint, and emit
- *                              aggregate telemetry only. No question, ranking,
- *                              intent, premise, memory, newborn-stamp, or push
- *                              writes.
- *                            on: reserved for a later phase (IND-438) that
- *                              turns a grounded hypothesis into a user-facing
- *                              question. This slice treats "on" exactly like
- *                              "shadow" for capture + mining; it never emits
- *                              questions.
- *
- * All reads go through this module — do not read this variable via
- * `process.env` elsewhere. Values are read on every call (no caching) so tests
- * and long-lived processes observe changes.
- */
-/**
- * Current OUTCOME_QUESTIONS_MODE (default off). Only the exact trimmed literals
- * "shadow" and "on" activate; every other value (including unset/empty) is off.
- */
-export function outcomeQuestionsMode() {
-    const value = process.env.OUTCOME_QUESTIONS_MODE?.trim();
-    return value === "shadow" || value === "on" ? value : "off";
-}
-/**
- * True when Lens B capture + mining should run at all. Both "shadow" and "on"
- * activate the shadow pipeline; only the future question-emitting behavior is
- * gated on "on" (not part of this slice).
- */
-export function isOutcomeQuestionsActivated() {
-    return outcomeQuestionsMode() !== "off";
-}
-/**
- * Independent-support threshold (k). Every compared group (discriminator side)
- * must have at least this many INDEPENDENT (related-opportunity-deduplicated)
- * examples before the hypothesis is eligible. Enforced per side, so no side
- * can be traced back to a small handful of individuals.
- */
-export const OUTCOME_MIN_INDEPENDENT_SUPPORT = 5;
-/** Minimum number of qualified sides (each ≥ k) for a hypothesis to compare. */
-export const OUTCOME_MIN_COMPARED_SIDES = 2;
-/**
- * k-anonymity floor for attempting a mining pass at all: the number of
- * distinct independent examples (after related-opportunity dedup) required
- * before the miner is invoked. Set to k × minimum compared sides so a pass can
- * never produce an eligible hypothesis below the aggregate floor.
- */
-export const OUTCOME_MIN_INDEPENDENT_EXAMPLES = OUTCOME_MIN_INDEPENDENT_SUPPORT * OUTCOME_MIN_COMPARED_SIDES;
-/** Max independent examples sent to the miner LLM (most recent first). */
-export const OUTCOME_MAX_CANDIDATES = 48;
-/** Max chars of presentation-safe candidate snapshot stored/sent per example. */
-export const OUTCOME_MAX_PUBLIC_CONTEXT_CHARS = 400;

package/dist/opportunities/outcome/outcome.hypotheses.d.ts

@@ -1,29 +0,0 @@
-/**
- * Lens B outcome join + threshold — pure functions, no LLM, no I/O (IND-434).
- *
- * Given discriminators whose candidate → side assignments were produced BLIND
- * to outcome (the miner never saw which side the user chose), this module joins
- * the explicit owner-outcome labels and produces aggregate-only telemetry:
- *
- *   - Independence: capture admits only one unique counterpart per opportunity;
- *     the caller then deduplicates by that recipient-scoped counterpart hash.
- *     Every retained entry therefore represents one distinct counterpart.
- *   - Threshold: a discriminator side is "qualified" only when it holds at
- *     least `minIndependentSupport` (k) independent examples. A hypothesis is
- *     eligible only when at least `minComparedSides` sides qualify.
- *   - Small-cell suppression: only qualified sides (≥ k) are ever emitted, so
- *     no aggregate row can be traced to a small handful of individuals.
- *
- * The outcome label is joined here and ONLY here — the miner and the side
- * assignments upstream are independent of it, so association can never leak
- * into classification.
- */
-import type { JoinOutcomeHypothesesInput, OutcomeShadowResult } from "./outcome.types.js";
-/**
- * Join outcome labels onto blind side assignments and keep only hypotheses that
- * clear the independent-support threshold on at least `minComparedSides` sides.
- *
- * @returns Aggregate telemetry: eligible hypotheses sorted by (min support desc,
- *   label asc) for deterministic ordering, each carrying only qualified sides.
- */
-export declare function joinOutcomeHypotheses(input: JoinOutcomeHypothesesInput): OutcomeShadowResult;

package/dist/opportunities/outcome/outcome.hypotheses.js

@@ -1,117 +0,0 @@
-/**
- * Lens B outcome join + threshold — pure functions, no LLM, no I/O (IND-434).
- *
- * Given discriminators whose candidate → side assignments were produced BLIND
- * to outcome (the miner never saw which side the user chose), this module joins
- * the explicit owner-outcome labels and produces aggregate-only telemetry:
- *
- *   - Independence: capture admits only one unique counterpart per opportunity;
- *     the caller then deduplicates by that recipient-scoped counterpart hash.
- *     Every retained entry therefore represents one distinct counterpart.
- *   - Threshold: a discriminator side is "qualified" only when it holds at
- *     least `minIndependentSupport` (k) independent examples. A hypothesis is
- *     eligible only when at least `minComparedSides` sides qualify.
- *   - Small-cell suppression: only qualified sides (≥ k) are ever emitted, so
- *     no aggregate row can be traced to a small handful of individuals.
- *
- * The outcome label is joined here and ONLY here — the miner and the side
- * assignments upstream are independent of it, so association can never leak
- * into classification.
- */
-import { OUTCOME_MIN_COMPARED_SIDES, OUTCOME_MIN_INDEPENDENT_SUPPORT } from "./outcome.env.js";
-/** Round a rate to 0.01 for telemetry (never a raw count). */
-function roundRate(n) {
-    return Math.round(n * 100) / 100;
-}
-/**
- * Join outcome labels onto blind side assignments and keep only hypotheses that
- * clear the independent-support threshold on at least `minComparedSides` sides.
- *
- * @returns Aggregate telemetry: eligible hypotheses sorted by (min support desc,
- *   label asc) for deterministic ordering, each carrying only qualified sides.
- */
-export function joinOutcomeHypotheses(input) {
-    const minSupport = input.minIndependentSupport ?? OUTCOME_MIN_INDEPENDENT_SUPPORT;
-    const minSides = input.minComparedSides ?? OUTCOME_MIN_COMPARED_SIDES;
-    // Distinct independent examples with a joinable outcome label.
-    const poolSize = input.examples.size;
-    const hypotheses = [];
-    for (const discriminator of input.discriminators) {
-        // Normalize sides by trimming, then reject the ENTIRE discriminator if any
-        // side is empty or if labels are not unique after normalization. Silently
-        // deduplicating malformed model output would turn an ambiguous comparison
-        // into apparently valid evidence.
-        const normalizedSides = discriminator.sides.map((side) => side.trim());
-        if (normalizedSides.some((side) => side.length === 0))
-            continue;
-        if (new Set(normalizedSides).size !== normalizedSides.length)
-            continue;
-        if (normalizedSides.length < minSides)
-            continue;
-        const validSides = new Set(normalizedSides);
-        // First normalize VERIFIED, labelled assignments by candidate id. If the
-        // same independent example is assigned to different sides, mark it
-        // ambiguous and exclude it from every side; it must never support two cells.
-        const sideById = new Map();
-        const ambiguousIds = new Set();
-        for (const assignment of discriminator.assignments) {
-            if (assignment.side === null || !assignment.verified)
-                continue;
-            const side = assignment.side.trim();
-            if (!validSides.has(side) || !input.examples.has(assignment.id))
-                continue;
-            const previous = sideById.get(assignment.id);
-            if (previous !== undefined && previous !== side)
-                ambiguousIds.add(assignment.id);
-            else if (previous === undefined)
-                sideById.set(assignment.id, side);
-        }
-        // Tally DISTINCT independent example ids per unambiguous side. Repeating
-        // the same assignment never increases support.
-        const idsBySide = new Map();
-        const acceptedIdsBySide = new Map();
-        for (const [id, side] of sideById) {
-            if (ambiguousIds.has(id))
-                continue;
-            const label = input.examples.get(id);
-            if (label === undefined)
-                continue;
-            if (!idsBySide.has(side))
-                idsBySide.set(side, new Set());
-            idsBySide.get(side).add(id);
-            if (label === "accepted") {
-                if (!acceptedIdsBySide.has(side))
-                    acceptedIdsBySide.set(side, new Set());
-                acceptedIdsBySide.get(side).add(id);
-            }
-        }
-        // Keep only sides that clear the independent-support threshold (>= k
-        // genuinely distinct independent examples).
-        const qualifiedSides = [];
-        for (const side of normalizedSides) {
-            const support = idsBySide.get(side)?.size ?? 0;
-            if (support < minSupport)
-                continue; // small-cell: never emitted
-            const accepted = acceptedIdsBySide.get(side)?.size ?? 0;
-            qualifiedSides.push({
-                side,
-                independentSupport: support,
-                acceptRate: roundRate(accepted / support),
-            });
-        }
-        if (qualifiedSides.length < minSides)
-            continue; // not enough to compare
-        // Deterministic side ordering: support desc, then label asc.
-        qualifiedSides.sort((a, b) => b.independentSupport - a.independentSupport || a.side.localeCompare(b.side));
-        hypotheses.push({
-            label: discriminator.label,
-            questionSeed: discriminator.questionSeed,
-            sides: qualifiedSides,
-            evidenceRate: discriminator.evidenceRate,
-            minIndependentSupport: Math.min(...qualifiedSides.map((s) => s.independentSupport)),
-        });
-    }
-    // Deterministic hypothesis ordering: strongest support first, then label.
-    hypotheses.sort((a, b) => b.minIndependentSupport - a.minIndependentSupport || a.label.localeCompare(b.label));
-    return { poolSize, eligibleCount: hypotheses.length, hypotheses };
-}

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

@@ -1,56 +0,0 @@
-/**
- * Lens B shadow orchestrator (IND-434): deduplicate related opportunities,
- * mine neutral axes over the deduplicated historical pool BLIND to outcome,
- * then join the owner-outcome labels and threshold the result.
- *
- * No persistence, no questions, no UI. The output is consumed only by aggregate
- * telemetry for human review.
- *
- * Pipeline:
- *   1. Dedup related opportunities: collapse examples sharing a dedup key to a
- *      single representative (most recent), so a cluster of related opps can
- *      neither dominate the miner nor inflate a side's independent support.
- *   2. Cap to the most recent OUTCOME_MAX_CANDIDATES for a bounded LLM pass.
- *   3. Build the miner pool — PoolCandidate carries id + publicContext + score
- *      and, critically, NO outcome label. The miner is structurally blind.
- *   4. Mine neutral axes + assign candidates (evidence-verified).
- *   5. Join outcome labels (only now) and apply the k-support threshold.
- */
-import type { PoolDiscriminatorMiner } from "../discriminator/discriminator.miner.js";
-import type { OutcomeExample, OutcomeShadowResult } from "./outcome.types.js";
-/** Input for one Lens B shadow mining+join pass. */
-export interface OutcomeShadowInput {
-    /**
-     * Intent payload (+ summary) text that owns this scope. Used only as miner
-     * context; never mixed with outcome labels.
-     */
-    intentText: string;
-    /**
-     * Captured owner-outcome examples for exactly one recipient + intent +
-     * fingerprint scope. Each carries a presentation-safe snapshot and a dedup
-     * key; outcome labels live here but are withheld from the miner.
-     */
-    examples: OutcomeExample[];
-    miner: Pick<PoolDiscriminatorMiner, "mine">;
-    /** Override the independent-support threshold (defaults to k). */
-    minIndependentSupport?: number;
-    /** Override the minimum qualified sides. */
-    minComparedSides?: number;
-    /** Override the LLM candidate cap. */
-    maxCandidates?: number;
-    signal?: AbortSignal;
-}
-/**
- * Collapse related opportunities to independent examples: one representative
- * (most recent by occurredAt) per distinct dedup key. Deterministic — ties on
- * occurredAt fall back to opportunityId ordering.
- */
-export declare function deduplicateOutcomeExamples(examples: OutcomeExample[]): OutcomeExample[];
-/**
- * Run the Lens B shadow pipeline for one scope.
- *
- * Throws only when *mining* fails (callers are fire-and-forget and must catch).
- * A pool that is empty or below the compare floor after dedup returns an empty
- * result rather than throwing.
- */
-export declare function runOutcomeShadow(input: OutcomeShadowInput): Promise<OutcomeShadowResult>;

package/dist/opportunities/outcome/outcome.shadow.js

@@ -1,87 +0,0 @@
-/**
- * Lens B shadow orchestrator (IND-434): deduplicate related opportunities,
- * mine neutral axes over the deduplicated historical pool BLIND to outcome,
- * then join the owner-outcome labels and threshold the result.
- *
- * No persistence, no questions, no UI. The output is consumed only by aggregate
- * telemetry for human review.
- *
- * Pipeline:
- *   1. Dedup related opportunities: collapse examples sharing a dedup key to a
- *      single representative (most recent), so a cluster of related opps can
- *      neither dominate the miner nor inflate a side's independent support.
- *   2. Cap to the most recent OUTCOME_MAX_CANDIDATES for a bounded LLM pass.
- *   3. Build the miner pool — PoolCandidate carries id + publicContext + score
- *      and, critically, NO outcome label. The miner is structurally blind.
- *   4. Mine neutral axes + assign candidates (evidence-verified).
- *   5. Join outcome labels (only now) and apply the k-support threshold.
- */
-import { protocolLogger } from "../../shared/observability/protocol.logger.js";
-import { OUTCOME_MAX_CANDIDATES, OUTCOME_MIN_COMPARED_SIDES, OUTCOME_MIN_INDEPENDENT_SUPPORT } from "./outcome.env.js";
-import { joinOutcomeHypotheses } from "./outcome.hypotheses.js";
-const logger = protocolLogger("OutcomeQuestionShadow");
-/**
- * Collapse related opportunities to independent examples: one representative
- * (most recent by occurredAt) per distinct dedup key. Deterministic — ties on
- * occurredAt fall back to opportunityId ordering.
- */
-export function deduplicateOutcomeExamples(examples) {
-    const byKey = new Map();
-    for (const example of examples) {
-        const existing = byKey.get(example.dedupKey);
-        if (existing === undefined) {
-            byKey.set(example.dedupKey, example);
-            continue;
-        }
-        const newer = example.occurredAt > existing.occurredAt ||
-            (example.occurredAt === existing.occurredAt && example.opportunityId > existing.opportunityId);
-        if (newer)
-            byKey.set(example.dedupKey, example);
-    }
-    return [...byKey.values()].sort((a, b) => b.occurredAt.localeCompare(a.occurredAt) || a.opportunityId.localeCompare(b.opportunityId));
-}
-/**
- * Run the Lens B shadow pipeline for one scope.
- *
- * Throws only when *mining* fails (callers are fire-and-forget and must catch).
- * A pool that is empty or below the compare floor after dedup returns an empty
- * result rather than throwing.
- */
-export async function runOutcomeShadow(input) {
-    const minSupport = input.minIndependentSupport ?? OUTCOME_MIN_INDEPENDENT_SUPPORT;
-    const minSides = input.minComparedSides ?? OUTCOME_MIN_COMPARED_SIDES;
-    const maxCandidates = input.maxCandidates ?? OUTCOME_MAX_CANDIDATES;
-    // 1–2. Dedup related opportunities, then cap to a bounded, recent pool.
-    const independent = deduplicateOutcomeExamples(input.examples).slice(0, maxCandidates);
-    if (independent.length < minSupport * minSides) {
-        return { poolSize: independent.length, eligibleCount: 0, hypotheses: [] };
-    }
-    // 3. Build the miner pool with RUN-LOCAL aliases (c0, c1, …) as candidate ids
-    //    — raw opportunity ids are never sent to the LLM. The alias→outcome map is
-    //    kept internally for the join. PoolCandidate deliberately excludes the
-    //    outcome label, so the miner cannot condition on which side was chosen.
-    const aliased = independent.map((example, index) => ({ alias: `c${index}`, example }));
-    const candidates = aliased.map(({ alias, example }) => ({
-        id: alias,
-        publicContext: example.publicContext,
-        score: example.score ?? 1,
-    }));
-    // 4. Blind assignment (assignments come back keyed by the run-local alias).
-    const mined = await input.miner.mine({ intentText: input.intentText, candidates }, input.signal ? { signal: input.signal } : undefined);
-    if (mined.length === 0) {
-        return { poolSize: independent.length, eligibleCount: 0, hypotheses: [] };
-    }
-    // 5. Join outcome labels (only now) by alias, and threshold.
-    const examples = new Map(aliased.map(({ alias, example }) => [alias, example.label]));
-    const result = joinOutcomeHypotheses({
-        discriminators: mined,
-        examples,
-        minIndependentSupport: minSupport,
-        minComparedSides: minSides,
-    });
-    logger.debug("shadow join complete", {
-        poolSize: result.poolSize,
-        eligibleCount: result.eligibleCount,
-    });
-    return result;
-}

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

@@ -1,110 +0,0 @@
-/**
- * Lens B outcome-question mining — shared types (IND-434).
- *
- * Lens B learns whether a user's OWN past explicit opportunity decisions
- * (accept / reject) suggest a useful clarification question, WITHOUT treating
- * mutable statuses, counterparty actions, or system transitions as
- * preferences. It is the historical-outcome analogue of the live-pool Lens A
- * discriminator (see ../discriminator/*).
- *
- * The two lenses share the neutral-axis mining machinery (PoolDiscriminatorMiner
- * assigns candidates to axis sides from presentation-safe context only). Lens B
- * adds the crucial privacy/correctness discipline on top:
- *
- *   1. Candidates are assigned to sides BLIND to their outcome label — the
- *      classifier never sees which side the user chose (the miner input carries
- *      no outcome field at all).
- *   2. Outcome labels are joined only AFTER assignment.
- *   3. Related opportunities are deduplicated (one independent example per
- *      distinct counterpart) before support is counted.
- *   4. Every compared group (side) must clear the independent-support
- *      threshold k, so aggregate telemetry never exposes a small cell.
- *
- * P7 (shadow) uses these types for aggregate-telemetry output only: no
- * questions, ranking, intent, premise, memory, newborn-stamp, or push writes.
- */
-import type { MinedDiscriminator } from "../discriminator/discriminator.types.js";
-/**
- * The only two explicit owner actions Lens B treats as preference labels.
- * Non-action, delivery, expiry, timeout, merge, cascade, screening, and every
- * counterparty/agent/system transition are deliberately excluded upstream.
- */
-export type OutcomeLabel = "accepted" | "rejected";
-/**
- * One captured owner-outcome example, as consumed by the mining orchestrator.
- * Built from an append-only feedback event; carries only presentation-safe
- * text plus join/dedup keys — never raw ids, vectors, or model reasoning.
- */
-export interface OutcomeExample {
-    /**
-     * Opportunity id — the join key between blind assignment and outcome label.
-     * Never emitted in telemetry.
-     */
-    opportunityId: string;
-    /** Presentation-safe candidate snapshot the miner assigns sides from. */
-    publicContext: string;
-    /** Explicit owner action. Joined AFTER assignment, never seen by the miner. */
-    label: OutcomeLabel;
-    /**
-     * Related-opportunity dedup key: a stable, non-reversible identifier of the
-     * counterpart (or opportunity when no counterpart). Two examples with the
-     * same key count as ONE independent example.
-     */
-    dedupKey: string;
-    /** Sort key for recency-based capping/representative selection (ISO-8601). */
-    occurredAt: string;
-    /** Optional confidence mass for score-weighted assignment; defaults to 1. */
-    score?: number;
-}
-/** Aggregate support for one discriminator side, after dedup + threshold. */
-export interface OutcomeSideSupport {
-    /** Neutral side label carried verbatim from the miner. */
-    side: string;
-    /** Distinct independent (deduplicated) examples assigned to this side (≥ k). */
-    independentSupport: number;
-    /**
-     * Independent accepted examples ÷ independentSupport, rounded to 0.01. A
-     * rate, never a raw small-cell count.
-     */
-    acceptRate: number;
-}
-/** One eligible neutral hypothesis with aggregate-only stats. */
-export interface OutcomeHypothesis {
-    /** Discriminator label, e.g. "Hands-on builders vs strategic advisors". */
-    label: string;
-    /** A neutral question the intent owner could answer to resolve the axis. */
-    questionSeed: string;
-    /** Only the qualified sides (each ≥ k independent examples). */
-    sides: OutcomeSideSupport[];
-    /** Evidence-verification rate carried from the miner (hallucination health). */
-    evidenceRate: number;
-    /** Minimum independentSupport across the qualified sides (≥ k). */
-    minIndependentSupport: number;
-}
-/** Result of one shadow mining pass (the aggregate telemetry payload shape). */
-export interface OutcomeShadowResult {
-    /** Distinct independent examples considered after dedup + capping. */
-    poolSize: number;
-    /** Count of eligible hypotheses (meets k + ≥ minComparedSides qualified). */
-    eligibleCount: number;
-    /**
-     * Eligible hypotheses only, sorted deterministically. Aggregate stats only —
-     * no opportunity ids, no candidate text, no small-cell counts.
-     */
-    hypotheses: OutcomeHypothesis[];
-}
-/** Input to the pure outcome-join step (assignment already done, blind). */
-export interface JoinOutcomeHypothesesInput {
-    /** Mined discriminators with verified side assignments (blind to outcome). */
-    discriminators: MinedDiscriminator[];
-    /**
-     * Outcome labels keyed by opportunity id. Each example is already
-     * independent (deduplicated by the orchestrator), so one entry = one
-     * independent example.
-     */
-    examples: Map<string, OutcomeLabel>;
-    /** Independent-support threshold per side. Defaults to k. */
-    minIndependentSupport?: number;
-    /** Minimum qualified sides. Defaults to the module constant. */
-    minComparedSides?: number;
-}

package/dist/opportunities/outcome/outcome.types.js

@@ -1,26 +0,0 @@
-/**
- * Lens B outcome-question mining — shared types (IND-434).
- *
- * Lens B learns whether a user's OWN past explicit opportunity decisions
- * (accept / reject) suggest a useful clarification question, WITHOUT treating
- * mutable statuses, counterparty actions, or system transitions as
- * preferences. It is the historical-outcome analogue of the live-pool Lens A
- * discriminator (see ../discriminator/*).
- *
- * The two lenses share the neutral-axis mining machinery (PoolDiscriminatorMiner
- * assigns candidates to axis sides from presentation-safe context only). Lens B
- * adds the crucial privacy/correctness discipline on top:
- *
- *   1. Candidates are assigned to sides BLIND to their outcome label — the
- *      classifier never sees which side the user chose (the miner input carries
- *      no outcome field at all).
- *   2. Outcome labels are joined only AFTER assignment.
- *   3. Related opportunities are deduplicated (one independent example per
- *      distinct counterpart) before support is counted.
- *   4. Every compared group (side) must clear the independent-support
- *      threshold k, so aggregate telemetry never exposes a small cell.
- *
- * P7 (shadow) uses these types for aggregate-telemetry output only: no
- * questions, ranking, intent, premise, memory, newborn-stamp, or push writes.
- */
-export {};

package/dist/opportunities/radar/radar.health.d.ts

@@ -1,31 +0,0 @@
-/** Input for computing radar health score. */
-export interface RadarHealthInput {
-    connectionCount: number;
-    connectorFlowCount: number;
-    expiredCount: number;
-    totalActionable: number;
-    /** Unix ms timestamp of last rediscovery, or null if never. */
-    lastRediscoveryAt: number | null;
-    /** Window in ms over which freshness decays from 1 → 0 (e.g. 12h). */
-    freshnessWindowMs: number;
-    /** Score threshold below which shouldMaintain is true. Default 0.5. */
-    threshold?: number;
-}
-/** Output of radar health computation. */
-export interface RadarHealthResult {
-    score: number;
-    breakdown: {
-        composition: number;
-        freshness: number;
-        expirationRatio: number;
-    };
-    shouldMaintain: boolean;
-}
-/**
- * Compute radar health score (0–1) from current radar state.
- * Pure function, no side effects.
- *
- * @param input - Current radar composition and timing data
- * @returns Health score with breakdown and maintenance recommendation
- */
-export declare function computeRadarHealth(input: RadarHealthInput): RadarHealthResult;

package/dist/opportunities/radar/radar.health.js

@@ -1,75 +0,0 @@
-import { RADAR_SOFT_TARGETS } from '../opportunity.utils.js';
-const WEIGHT_COMPOSITION = 0.4;
-const WEIGHT_FRESHNESS = 0.3;
-const WEIGHT_EXPIRATION = 0.3;
-const DEFAULT_THRESHOLD = 0.5;
-/**
- * Compute composition sub-score: how close current counts are to soft targets.
- * Uses normalized distance: 1 - (|actual - target| / max(target, actual, 1)) per category,
- * then averages across categories.
- */
-function scoreComposition(connectionCount, connectorFlowCount, expiredCount) {
-    const categories = [
-        { actual: connectionCount, target: RADAR_SOFT_TARGETS.connection },
-        { actual: connectorFlowCount, target: RADAR_SOFT_TARGETS.connectorFlow },
-        { actual: expiredCount, target: RADAR_SOFT_TARGETS.expired },
-    ];
-    let totalScore = 0;
-    for (const { actual, target } of categories) {
-        const diff = Math.abs(actual - target);
-        const denom = Math.max(target, actual, 1);
-        totalScore += 1 - diff / denom;
-    }
-    return totalScore / categories.length;
-}
-/**
- * Compute freshness sub-score: linear decay from 1 → 0 over freshnessWindowMs.
- */
-function scoreFreshness(lastRediscoveryAt, freshnessWindowMs) {
-    if (lastRediscoveryAt == null)
-        return 0;
-    const elapsed = Date.now() - lastRediscoveryAt;
-    if (elapsed <= 0)
-        return 1;
-    if (elapsed >= freshnessWindowMs)
-        return 0;
-    return 1 - elapsed / freshnessWindowMs;
-}
-/**
- * Compute expiration ratio sub-score: 1 - (expired / total).
- */
-function scoreExpirationRatio(expiredCount, totalActionable) {
-    const total = totalActionable + expiredCount;
-    if (total === 0)
-        return 0;
-    return 1 - expiredCount / total;
-}
-/**
- * Compute radar health score (0–1) from current radar state.
- * Pure function, no side effects.
- *
- * @param input - Current radar composition and timing data
- * @returns Health score with breakdown and maintenance recommendation
- */
-export function computeRadarHealth(input) {
-    const { connectionCount, connectorFlowCount, expiredCount, totalActionable, lastRediscoveryAt, freshnessWindowMs, threshold = DEFAULT_THRESHOLD, } = input;
-    // Empty radar is always unhealthy
-    if (totalActionable === 0 && expiredCount === 0) {
-        return {
-            score: 0,
-            breakdown: { composition: 0, freshness: 0, expirationRatio: 0 },
-            shouldMaintain: true,
-        };
-    }
-    const composition = scoreComposition(connectionCount, connectorFlowCount, expiredCount);
-    const freshness = scoreFreshness(lastRediscoveryAt, freshnessWindowMs);
-    const expirationRatio = scoreExpirationRatio(expiredCount, totalActionable);
-    const score = WEIGHT_COMPOSITION * composition +
-        WEIGHT_FRESHNESS * freshness +
-        WEIGHT_EXPIRATION * expirationRatio;
-    return {
-        score,
-        breakdown: { composition, freshness, expirationRatio },
-        shouldMaintain: score < threshold,
-    };
-}

package/dist/premises/premise.analyzer.d.ts

@@ -1,35 +0,0 @@
-import { z } from "zod";
-declare const responseFormat: z.ZodObject<{
-    reasoning: z.ZodString;
-    speechActType: z.ZodEnum<["DECLARATIVE", "ASSERTIVE"]>;
-    felicityAuthority: z.ZodNumber;
-    felicitySincerity: z.ZodNumber;
-    felicityClarity: z.ZodNumber;
-    semanticEntropy: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    reasoning: string;
-    semanticEntropy: number;
-    felicityAuthority: number;
-    felicitySincerity: number;
-    felicityClarity: number;
-    speechActType: "DECLARATIVE" | "ASSERTIVE";
-}, {
-    reasoning: string;
-    semanticEntropy: number;
-    felicityAuthority: number;
-    felicitySincerity: number;
-    felicityClarity: number;
-    speechActType: "DECLARATIVE" | "ASSERTIVE";
-}>;
-export type PremiseAnalyzerOutput = z.infer<typeof responseFormat>;
-/**
- * Classifies a premise using adapted Speech Act Theory and scores felicity conditions.
- */
-export declare class PremiseAnalyzer {
-    private model;
-    constructor();
-    invoke(premiseText: string, profileContext?: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<PremiseAnalyzerOutput>;
-}
-export {};