@inflexa-ai/harness 0.1.1

package/dist/workflows/target-assessment/lib/clinical-consequence-annotator.js

@@ -0,0 +1,172 @@
+/**
+ * Per-row LLM clinical-consequence annotator with Postgres caching.
+ *
+ * Any off-target row missing a `clinical_consequence` gets annotated by a
+ * focused tool-less LLM specialist that returns ONE sentence + provenance.
+ * Results are cached in `cortex_off_target_annotations` keyed by
+ * (primary_target_gene, off_target_key) so repeat assessments reuse prior
+ * work.
+ *
+ * Cache miss path: when a `deps` bundle is supplied, build a compact JSON
+ * prompt, run a single-shot harness agent loop (no tools, max 2 iterations),
+ * parse JSON out of the final assistant text, INSERT on success, return the
+ * consequence. With no `deps`, the function returns null on cache miss
+ * (no LLM call). Cache hit path: a single primary-key lookup, no LLM call.
+ * Per-row failures (LLM, schema validation, DB) are swallowed — annotation
+ * is supplementary; the dossier renders fine with null.
+ */
+import { z } from "zod";
+import { withHost } from "../../../lib/host-concurrency.js";
+import { tryQuery, tryMutation } from "../../../lib/db-result.js";
+import { offTargetAnnotatorPrompt } from "../../../prompts/target-assessment/off-target-annotator.js";
+import { forSubAgent } from "../../../auth/types.js";
+import { finalText, runAgent } from "../../../loop/run-agent.js";
+import { passthroughStep } from "../../../loop/run-step.js";
+export const OffTargetAnnotationSchema = z.object({
+    clinical_consequence: z.string().min(10),
+    provenance: z.string().min(3),
+});
+function cacheKey(input) {
+    const id = input.offTargetId?.trim();
+    if (id)
+        return id;
+    const name = input.offTargetName.trim().toLowerCase();
+    return name ? `name:${name}` : null;
+}
+async function readCache(pool, primaryTargetGene, key) {
+    // Annotation is supplementary — a cache-read failure must NOT surface. The
+    // `DbError` is collapsed to `null` (treated as a cache miss) via `.unwrapOr`.
+    return tryQuery("offTargetAnnotations.readCache", async () => {
+        const res = await pool.query(`SELECT clinical_consequence, provenance
+       FROM cortex_off_target_annotations
+       WHERE primary_target_gene = $1 AND off_target_key = $2
+       LIMIT 1`, [primaryTargetGene, key]);
+        if (res.rows.length === 0)
+            return null;
+        const row = res.rows[0];
+        return {
+            clinical_consequence: row.clinical_consequence,
+            provenance: row.provenance ?? "",
+        };
+    }).unwrapOr(null);
+}
+async function writeCache(pool, primaryTargetGene, key, offTargetName, annotation, model) {
+    // Cache-write failures must not affect the assembly result — the `DbError`
+    // is swallowed (both branches no-op) so annotation never surfaces a DB fault.
+    await tryMutation("offTargetAnnotations.writeCache", async () => {
+        await pool.query(`INSERT INTO cortex_off_target_annotations
+         (primary_target_gene, off_target_key, off_target_name, clinical_consequence, provenance, model)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (primary_target_gene, off_target_key) DO NOTHING`, [primaryTargetGene, key, offTargetName, annotation.clinical_consequence, annotation.provenance, model]);
+    }).match(() => { }, () => { });
+}
+function buildPrompt(input) {
+    return JSON.stringify({
+        primary_target_gene: input.primaryTargetGene,
+        off_target_id: input.offTargetId,
+        off_target_name: input.offTargetName,
+        off_target_accession: input.offTargetAccession,
+        pchembl: input.pchembl,
+        context: input.context ?? null,
+    }, null, 2);
+}
+/**
+ * Best-effort JSON extraction from an LLM text response. Strips fenced
+ * code blocks and surrounding prose so a slightly-out-of-spec reply still
+ * parses.
+ */
+function extractJsonObject(text) {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const candidate = fenced ? fenced[1] : text;
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    if (start === -1 || end === -1 || end < start)
+        return null;
+    try {
+        return JSON.parse(candidate.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+}
+const ANNOTATOR_AGENT_ID = "off-target-annotator";
+function buildAnnotatorAgent(model) {
+    return {
+        id: ANNOTATOR_AGENT_ID,
+        systemPrompt: offTargetAnnotatorPrompt,
+        model,
+        tools: [],
+        maxIterations: 2,
+    };
+}
+/**
+ * Annotate a single off-target row. Returns null on any failure (cache
+ * miss + no deps, cache miss + LLM unavailable, schema validation failure,
+ * DB unreachable, etc.) — callers must treat null as "no annotation" and
+ * leave `clinical_consequence` as their original fallback.
+ */
+export async function annotateClinicalConsequence(pool, input, deps) {
+    if (!input.primaryTargetGene)
+        return null;
+    const key = cacheKey(input);
+    if (!key)
+        return null;
+    const cached = await readCache(pool, input.primaryTargetGene, key);
+    if (cached)
+        return cached;
+    if (!deps)
+        return null;
+    try {
+        const agent = buildAnnotatorAgent(deps.model);
+        const session = forSubAgent(deps.session, ANNOTATOR_AGENT_ID);
+        const controller = new AbortController();
+        const { messages } = await runAgent(agent, [{ role: "user", content: buildPrompt(input) }], session, {
+            provider: deps.provider,
+            signal: controller.signal,
+            emit: () => { },
+            runStep: passthroughStep,
+        });
+        const raw = extractJsonObject(finalText(messages));
+        if (raw === null)
+            return null;
+        const parsed = OffTargetAnnotationSchema.safeParse(raw);
+        if (!parsed.success)
+            return null;
+        await writeCache(pool, input.primaryTargetGene, key, input.offTargetName, parsed.data, deps.model);
+        return parsed.data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Annotate every row in an off-target panel whose `clinical_consequence`
+ * is currently null. Mutates the supplied arrays in-place. Pure assembly-
+ * time helper — no return value.
+ *
+ * Per-row LLM calls are bounded by the "annotation-llm" host budget (4 in
+ * flight). Cache hits skip the LLM entirely and consume only a cheap
+ * Postgres lookup, so the budget gate is held briefly for those rows.
+ * Without `deps`, the panel is annotated cache-only — rows missing a
+ * cached entry remain with their original fallback.
+ */
+export async function annotateOffTargetPanel(pool, panel, primaryTargetGene, deps) {
+    if (!primaryTargetGene)
+        return;
+    const allRows = [...panel.rows, ...panel.excluded_rows];
+    const needsAnnotation = allRows.filter((r) => r && (r.clinical_consequence == null || r.clinical_consequence === ""));
+    if (needsAnnotation.length === 0)
+        return;
+    await Promise.all(needsAnnotation.map((r) => withHost("annotation-llm", async () => {
+        const annotation = await annotateClinicalConsequence(pool, {
+            primaryTargetGene,
+            offTargetId: typeof r.off_target_id === "string" ? r.off_target_id : null,
+            offTargetName: typeof r.off_target_name === "string" ? r.off_target_name : "",
+            offTargetAccession: typeof r.accession === "string" ? r.accession : null,
+            pchembl: typeof r.pchembl === "number" ? r.pchembl : 0,
+            context: r.relationship === "obligate_cofactor" ? "obligate cofactor with the primary protein" : undefined,
+        }, deps);
+        if (annotation)
+            r.clinical_consequence = annotation.clinical_consequence;
+    })));
+}

package/dist/workflows/target-assessment/lib/clinical-evidence-attribution.d.ts

@@ -0,0 +1,45 @@
+import type { ClinicalTrialAttributionV5, ClinicalTrialRowV5 } from "@inflexa-ai/harness/contracts/target-dossier.js";
+type TrialLike = {
+    nctId: string;
+    title: string;
+    officialTitle?: string | null;
+    conditions?: string[];
+    interventions?: string[];
+    interventionDetails?: Array<{
+        name: string;
+        type?: string | null;
+        description?: string | null;
+        otherNames?: string[];
+    }>;
+    studyType?: string | null;
+    primaryPurpose?: string | null;
+    briefSummary?: string | null;
+    detailedDescription?: string | null;
+};
+export type KnownClassDrug = {
+    name: string;
+    moleculeChemblId?: string | null;
+    targetUniprots?: string[];
+};
+export type TherapeuticProgram = {
+    programId: string;
+    name: string;
+    targetSymbol: string;
+    targetUniprot?: string | null;
+    modality?: string | null;
+    nctIds?: string[];
+};
+export type ClinicalEvidenceAttributionContext = {
+    assessmentSymbol: string;
+    assessmentUniprot: string;
+    familyUniprots: string[];
+    knownClassDrugs: KnownClassDrug[];
+    therapeuticPrograms: TherapeuticProgram[];
+};
+export type ClinicalEvidenceAttributionResult = {
+    attribution: ClinicalTrialAttributionV5;
+    eligible_for_toxicology_aggregation: boolean;
+};
+export declare function classifyClinicalEvidenceTrial(trial: TrialLike, ctx: ClinicalEvidenceAttributionContext): ClinicalEvidenceAttributionResult;
+export declare function attachClinicalEvidenceAttribution<T extends TrialLike>(trial: T, ctx: ClinicalEvidenceAttributionContext): T & Pick<ClinicalTrialRowV5, "attribution" | "eligible_for_toxicology_aggregation">;
+export {};

package/dist/workflows/target-assessment/lib/clinical-evidence-attribution.js

@@ -0,0 +1,156 @@
+function normalize(text) {
+    return text
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, " ")
+        .trim();
+}
+function tokenMatch(haystack, needle) {
+    const h = ` ${normalize(haystack)} `;
+    const n = normalize(needle);
+    if (!n)
+        return false;
+    return h.includes(` ${n} `);
+}
+function trialText(trial) {
+    return [
+        trial.title,
+        trial.officialTitle,
+        ...(trial.conditions ?? []),
+        ...(trial.interventions ?? []),
+        ...(trial.interventionDetails ?? []).flatMap((i) => [i.name, i.description, ...(i.otherNames ?? [])]),
+        trial.briefSummary,
+        trial.detailedDescription,
+    ]
+        .filter((v) => typeof v === "string" && v.length > 0)
+        .join(" ");
+}
+function interventionDetails(trial) {
+    if (trial.interventionDetails && trial.interventionDetails.length > 0) {
+        return trial.interventionDetails;
+    }
+    return (trial.interventions ?? []).map((name) => ({
+        name,
+        type: null,
+        description: null,
+        otherNames: [],
+    }));
+}
+function toResolvedIntervention(intervention, source, extras = {}) {
+    return {
+        name: intervention.name,
+        intervention_type: intervention.type ?? null,
+        target_uniprots: extras.target_uniprots ?? [],
+        resolver_source: source,
+        ...extras,
+    };
+}
+function isDiagnosticOrBiomarkerOnly(trial) {
+    const details = interventionDetails(trial);
+    const hasOnlyDiagnostic = details.length > 0 && details.every((i) => ["DIAGNOSTIC_TEST", "OTHER", "PROCEDURE"].includes(String(i.type ?? "").toUpperCase()));
+    const design = `${trial.studyType ?? ""} ${trial.primaryPurpose ?? ""}`.toUpperCase();
+    return hasOnlyDiagnostic || /\bOBSERVATIONAL\b|\bBASIC_SCIENCE\b/.test(design);
+}
+function targetBiomarkerMention(trial, symbol) {
+    const text = normalize(trialText(trial));
+    const sym = normalize(symbol);
+    if (!sym)
+        return false;
+    const wrapped = ` ${text} `;
+    return wrapped.includes(` ${sym} `) || wrapped.includes(`S ${sym} `) || wrapped.includes(` ${sym} LEVEL`) || wrapped.includes(` ${sym} CONCENTRATION`);
+}
+function excluded(relationship, reason, basisKind, source, resolved_interventions) {
+    return {
+        eligible_for_toxicology_aggregation: false,
+        attribution: {
+            relationship,
+            evidence_role: relationship === "target_biomarker" || relationship === "pathway_biomarker" ? "contextual" : "excluded",
+            basis: [{ kind: basisKind, source }],
+            resolved_interventions,
+            exclusion_reason: reason,
+        },
+    };
+}
+export function classifyClinicalEvidenceTrial(trial, ctx) {
+    const details = interventionDetails(trial);
+    for (const program of ctx.therapeuticPrograms) {
+        const matchesProgram = (program.nctIds ?? []).includes(trial.nctId) ||
+            details.some((i) => tokenMatch(i.name, program.name) || (i.otherNames ?? []).some((alias) => tokenMatch(alias, program.name))) ||
+            tokenMatch(trial.title, program.name);
+        const hitsTarget = normalize(program.targetSymbol) === normalize(ctx.assessmentSymbol) || program.targetUniprot === ctx.assessmentUniprot;
+        if (matchesProgram && hitsTarget) {
+            const matched = details.find((i) => tokenMatch(i.name, program.name)) ??
+                details[0] ?? {
+                name: program.name,
+                type: null,
+                description: null,
+                otherNames: [],
+            };
+            return {
+                eligible_for_toxicology_aggregation: true,
+                attribution: {
+                    relationship: "direct_modulator",
+                    evidence_role: "supports_target",
+                    basis: [
+                        {
+                            kind: "therapeutic_program_match",
+                            source: "therapeutic_programs",
+                            excerpt: `${program.name} targets ${program.targetSymbol}`,
+                        },
+                    ],
+                    resolved_interventions: [
+                        toResolvedIntervention(matched, "therapeutic_programs", {
+                            therapeutic_program_id: program.programId,
+                            target_uniprots: program.targetUniprot ? [program.targetUniprot] : [],
+                        }),
+                    ],
+                },
+            };
+        }
+    }
+    for (const intervention of details) {
+        const candidates = [intervention.name, ...(intervention.otherNames ?? [])];
+        const matchedDrug = ctx.knownClassDrugs.find((drug) => candidates.some((candidate) => tokenMatch(candidate, drug.name)));
+        if (!matchedDrug)
+            continue;
+        const targetUniprots = matchedDrug.targetUniprots ?? [];
+        if (targetUniprots.includes(ctx.assessmentUniprot)) {
+            return {
+                eligible_for_toxicology_aggregation: true,
+                attribution: {
+                    relationship: "class_modulator",
+                    evidence_role: "supports_target",
+                    basis: [{ kind: "known_class_drug", source: "chembl" }],
+                    resolved_interventions: [
+                        toResolvedIntervention(intervention, "chembl", {
+                            chembl_id: matchedDrug.moleculeChemblId ?? null,
+                            target_uniprots: targetUniprots,
+                        }),
+                    ],
+                },
+            };
+        }
+        if (targetUniprots.some((u) => ctx.familyUniprots.includes(u))) {
+            return excluded("related_family_target", "Intervention targets a related family receptor, not the assessed target.", "related_family_target", "chembl", [
+                toResolvedIntervention(intervention, "chembl", {
+                    chembl_id: matchedDrug.moleculeChemblId ?? null,
+                    target_uniprots: targetUniprots,
+                }),
+            ]);
+        }
+    }
+    if (targetBiomarkerMention(trial, ctx.assessmentSymbol)) {
+        const resolved = details.map((i) => toResolvedIntervention(i, "ctgov"));
+        return excluded("target_biomarker", isDiagnosticOrBiomarkerOnly(trial)
+            ? "Target is used as a biomarker or diagnostic endpoint, not as a therapeutic intervention."
+            : "Target is mentioned in biomarker/outcome context without target-modulating intervention evidence.", "biomarker_endpoint", "ctgov", resolved);
+    }
+    const conditionOnly = (trial.conditions ?? []).some((c) => tokenMatch(c, ctx.assessmentSymbol));
+    if (conditionOnly) {
+        return excluded("condition_only", "Trial matched only by condition text and has no target-modulating intervention evidence.", "condition_only", "ctgov", details.map((i) => toResolvedIntervention(i, "ctgov")));
+    }
+    return excluded("unrelated", "No intervention or mechanism evidence links this trial to the assessed target.", "text_match", "ctgov", details.map((i) => toResolvedIntervention(i, "ctgov")));
+}
+export function attachClinicalEvidenceAttribution(trial, ctx) {
+    const result = classifyClinicalEvidenceTrial(trial, ctx);
+    return { ...trial, ...result };
+}

package/dist/workflows/target-assessment/lib/compute-derived.d.ts

@@ -0,0 +1,19 @@
+import type { DerivedV4 } from "@inflexa-ai/harness/contracts/target-dossier.js";
+/**
+ * Derive the set of organs that should appear in the organ rollup based on
+ * available safety signals (FAERS top signals, serious trial AEs, and
+ * off-target panel entries).
+ *
+ * Exported so the Phase-4 assembler can call the same logic when building
+ * organ_rollup rows — ensuring the set of "expected" organs is identical at
+ * assembly time and at derived-validation time.
+ */
+export declare function expectedOrgansFromBody(bodyInput: unknown): string[];
+/**
+ * Build the v4 derived sub-tree from a raw dossier body.
+ *
+ * Pure function: no I/O, no LLM calls, no side effects. Defensive against
+ * missing/partial bodies — always returns a best-effort result and never throws.
+ * Schema validation happens at the persist boundary (Task 11), not here.
+ */
+export declare function computeDerivedFields(bodyInput: unknown): DerivedV4;

package/dist/workflows/target-assessment/lib/compute-derived.js

@@ -0,0 +1,252 @@
+import { classifyOrgan, classifyTrialAe } from "./meddra-organ-map.js";
+import { HIGH_EXPRESSION_TPM_THRESHOLD } from "./expression-constants.js";
+const FAERS_TOP_SIGNAL_THRESHOLD = 1000;
+/**
+ * Derive the set of organs that should appear in the organ rollup based on
+ * available safety signals (FAERS top signals, serious trial AEs, and
+ * off-target panel entries).
+ *
+ * Exported so the Phase-4 assembler can call the same logic when building
+ * organ_rollup rows — ensuring the set of "expected" organs is identical at
+ * assembly time and at derived-validation time.
+ */
+export function expectedOrgansFromBody(bodyInput) {
+    const body = bodyInput;
+    const expected = new Set();
+    const top = body?.safety_profile?.faers?.data?.top_signals ?? [];
+    for (const sig of top) {
+        if (sig.report_count >= FAERS_TOP_SIGNAL_THRESHOLD) {
+            const organ = classifyOrgan(sig.meddra_term);
+            if (organ)
+                expected.add(organ);
+        }
+    }
+    const serious = body?.safety_profile?.trial_aes?.data?.serious ?? [];
+    for (const ae of serious) {
+        const organ = classifyTrialAe(ae);
+        if (organ)
+            expected.add(organ);
+    }
+    const offTargets = body?.safety_profile?.off_target_panel?.data?.rows ?? [];
+    for (const r of offTargets) {
+        if (r.organ_system && typeof r.organ_system === "string")
+            expected.add(r.organ_system);
+    }
+    return [...expected].sort();
+}
+function presentOrgans(body) {
+    const rows = body?.safety_profile?.organ_rollup?.data?.rows ?? [];
+    return rows
+        .map((r) => r.organ)
+        .filter((o) => typeof o === "string")
+        .sort();
+}
+function countDistinctPapers(body) {
+    const set = new Set();
+    const keyPapers = body?.reference_biology?.key_papers?.data?.rows ?? [];
+    for (const p of keyPapers)
+        if (p.pmid)
+            set.add(String(p.pmid));
+    return set.size;
+}
+function countDistinctTrials(body) {
+    const set = new Set();
+    // V5 partitions ineligible trials into `excluded_rows`, so the distinct
+    // count must union both buckets for trials, failed_trials, and
+    // discovery_trials. Outcomes preserves every row in `rows` and has no
+    // `excluded_rows` bucket.
+    const partitioned = [body?.clinical_development?.trials?.data, body?.clinical_development?.failed_trials?.data, body?.analytics?.discovery_trials?.data];
+    for (const data of partitioned) {
+        for (const bucket of ["rows", "excluded_rows"]) {
+            for (const r of data?.[bucket] ?? []) {
+                if (r.nct_id)
+                    set.add(String(r.nct_id));
+            }
+        }
+    }
+    for (const r of body?.clinical_development?.outcomes?.data?.rows ?? []) {
+        if (r.nct_id)
+            set.add(String(r.nct_id));
+    }
+    return set.size;
+}
+// Walk the entire body tree counting all `evidence` array entries to produce
+// a total evidence item count. This is intentionally recursive and treats every
+// nested `evidence` array as contributing to the total.
+function countTotalEvidenceItems(body) {
+    let total = 0;
+    const walk = (v) => {
+        if (Array.isArray(v)) {
+            for (const item of v)
+                walk(item);
+        }
+        else if (v && typeof v === "object") {
+            const node = v;
+            if (Array.isArray(node.evidence))
+                total += node.evidence.length;
+            for (const k of Object.keys(v))
+                walk(node[k]);
+        }
+    };
+    walk(body);
+    return total;
+}
+function hasHumanEvidence(body) {
+    let found = false;
+    const walk = (v) => {
+        if (found)
+            return;
+        if (Array.isArray(v)) {
+            for (const item of v)
+                walk(item);
+        }
+        else if (v && typeof v === "object") {
+            const node = v;
+            if (node.has_human_evidence === true || node.is_human === true) {
+                found = true;
+                return;
+            }
+            for (const k of Object.keys(v))
+                walk(node[k]);
+        }
+    };
+    walk(body);
+    return found;
+}
+function hasClinicalEvidence(body) {
+    let found = false;
+    const walk = (v) => {
+        if (found)
+            return;
+        if (Array.isArray(v)) {
+            for (const item of v)
+                walk(item);
+        }
+        else if (v && typeof v === "object") {
+            const node = v;
+            if (node.has_clinical_evidence === true || node.is_clinical === true) {
+                found = true;
+                return;
+            }
+            for (const k of Object.keys(v))
+                walk(node[k]);
+        }
+    };
+    walk(body);
+    return found;
+}
+function highestRiskOrgan(body) {
+    const rows = body?.safety_profile?.organ_rollup?.data?.rows ?? [];
+    const high = rows.find((r) => r.risk_level === "high");
+    if (high)
+        return high.organ;
+    const med = rows.find((r) => r.risk_level === "medium");
+    if (med)
+        return med.organ;
+    return null;
+}
+function topIndicationSummary(body) {
+    const rows = body?.indications?.coverage === "available" ? (body.indications?.data?.rows ?? []) : [];
+    if (rows.length === 0) {
+        return { highest_score: null, strongest_strength_label: null, highest_score_is_conflicted: false };
+    }
+    let top = null;
+    for (const r of rows) {
+        if (typeof r.composite_score !== "number")
+            continue;
+        if (!top || r.composite_score > top.composite_score)
+            top = r;
+    }
+    if (!top) {
+        return { highest_score: null, strongest_strength_label: null, highest_score_is_conflicted: false };
+    }
+    const conflicted = Array.isArray(top.evidence) ? top.evidence.some((e) => e?.predicate === "direction_mismatch") : false;
+    return {
+        highest_score: top.composite_score ?? null,
+        strongest_strength_label: top.disease_name ?? null,
+        highest_score_is_conflicted: conflicted,
+    };
+}
+// Count distinct high-expression tissues across the human protein atlas consensus
+// (normal_tissue_expression, keyed as "human") and the cross-species expression
+// heatmap. Deduplication uses `${tissue}::${species}` pairs so the same tissue
+// in different species counts as separate entries.
+function countHighExpressionTissues(body) {
+    const set = new Set();
+    const consensusRows = body?.reference_biology?.normal_tissue_expression?.data?.rows ?? [];
+    for (const r of consensusRows) {
+        if ((r.value ?? 0) >= HIGH_EXPRESSION_TPM_THRESHOLD && r.tissue) {
+            set.add(`${r.tissue}::human`);
+        }
+    }
+    const heatmapCells = body?.reference_biology?.preclinical?.expression_heatmap?.data?.cells ?? [];
+    for (const c of heatmapCells) {
+        if (c.rank === "high" && c.tissue) {
+            const species = c.species ?? "unknown";
+            set.add(`${c.tissue}::${species}`);
+        }
+    }
+    return set.size;
+}
+/**
+ * Build the v4 derived sub-tree from a raw dossier body.
+ *
+ * Pure function: no I/O, no LLM calls, no side effects. Defensive against
+ * missing/partial bodies — always returns a best-effort result and never throws.
+ * Schema validation happens at the persist boundary (Task 11), not here.
+ */
+export function computeDerivedFields(bodyInput) {
+    const body = bodyInput;
+    const classLiabilityRows = body?.safety_profile?.class_precedent?.coverage === "available"
+        ? (body.safety_profile?.class_precedent?.data?.per_organ ?? []).filter((o) => o.is_class_liability)
+        : [];
+    const classLiabilityCount = classLiabilityRows.length;
+    const sameClassDrugCount = body?.safety_profile?.class_precedent?.coverage === "available" ? (body.safety_profile?.class_precedent?.data?.drugs_in_class ?? []).length : 0;
+    const offTargetRows = body?.safety_profile?.off_target_panel?.data?.rows ?? [];
+    const safetyHits = offTargetRows.filter((r) => r.is_safety_panel_target === true).length;
+    const offTissueRows = body?.off_tissue_risk?.data?.rows ?? [];
+    const offTissueOrganCount = new Set(offTissueRows.map((r) => r.organ).filter(Boolean)).size;
+    const expected = expectedOrgansFromBody(body);
+    const present = presentOrgans(body);
+    const missing = expected.filter((o) => !present.includes(o));
+    const seriousness = body?.safety_profile?.faers?.data?.seriousness;
+    const fatalBullet = (body?.liability_summary?.liability_bullets ?? []).some((b) => b?.category === "fatal_post_market");
+    const anyFatal = seriousness?.coverage === "available" ? (seriousness.by_seriousness?.death ?? 0) > 0 || fatalBullet : fatalBullet ? true : "unknown";
+    const tissueRows = body?.reference_biology?.normal_tissue_expression?.data?.rows ?? [];
+    const highTissues = countHighExpressionTissues(body);
+    const safetySources = ["organ_rollup", "faers", "trial_aes", "off_target_panel", "failed_trials_safety_lens", "class_precedent"].filter((k) => body?.safety_profile?.[k]?.coverage === "available").length;
+    return {
+        summary: {
+            has_human_evidence: hasHumanEvidence(body),
+            has_clinical_evidence: hasClinicalEvidence(body),
+            total_evidence_items: countTotalEvidenceItems(body),
+            total_distinct_papers: countDistinctPapers(body),
+            total_distinct_clinical_trials: countDistinctTrials(body),
+            ...topIndicationSummary(body),
+        },
+        risk_summary: {
+            any_fatal_signal: anyFatal,
+            highest_risk_organ: highestRiskOrgan(body),
+            off_target_safety_target_hits: safetyHits,
+            class_liability_count: classLiabilityCount,
+        },
+        liability_summary: {
+            counts: {
+                class_liability_count: classLiabilityCount,
+                safety_target_off_target_count: safetyHits,
+                off_tissue_risk_organ_count: offTissueOrganCount,
+            },
+            expression_breadth: {
+                total_assessed_tissues: tissueRows.length,
+                high_expression_tissue_count: highTissues,
+            },
+            same_class_drug_count: sameClassDrugCount,
+            safety_data_sources_checked: safetySources,
+        },
+        organ_rollup_completeness: {
+            expected_organs: expected,
+            present_organs: present,
+            missing_organs: missing,
+        },
+    };
+}

package/dist/workflows/target-assessment/lib/compute-selectivity.d.ts

@@ -0,0 +1,15 @@
+export declare function computeSelectivity(input: {
+    primary_pchembl: number | null;
+    off_target_pchembl: number | null;
+    primary_source?: "chembl_target_drug_indication" | "literature_curated";
+}): {
+    vs_primary_potency: {
+        primary_pchembl_used: number;
+        primary_source: "chembl_target_drug_indication" | "literature_curated";
+        fold: number;
+        log_units: number;
+    };
+} | {
+    selectivity_unknown: true;
+    reason: string;
+};

package/dist/workflows/target-assessment/lib/compute-selectivity.js

@@ -0,0 +1,18 @@
+export function computeSelectivity(input) {
+    if (input.primary_pchembl == null) {
+        return { selectivity_unknown: true, reason: "no primary pChEMBL available for this modulator in ChEMBL target-drug-indication table" };
+    }
+    if (input.off_target_pchembl == null) {
+        return { selectivity_unknown: true, reason: "no off-target pChEMBL recorded" };
+    }
+    const logUnits = input.primary_pchembl - input.off_target_pchembl;
+    const fold = Math.pow(10, logUnits);
+    return {
+        vs_primary_potency: {
+            primary_pchembl_used: input.primary_pchembl,
+            primary_source: input.primary_source ?? "chembl_target_drug_indication",
+            fold,
+            log_units: logUnits,
+        },
+    };
+}