@inflexa-ai/harness 0.16.0 → 0.18.0

package/dist/workflows/target-assessment/lib/meddra-organ-map.js

@@ -1,3 +1,18 @@
+/**
+ * MedDRA terms and CT.gov system-organ classes onto the canonical organ
+ * vocabulary.
+ *
+ * The values are the canonical tokens, so this module declares no organ
+ * enumeration of its own. Every token in the vocabulary is reachable through
+ * the rules below, so nothing a producer may legitimately attribute is
+ * unreachable by accident.
+ *
+ * A term resolves onto the organ it names, or onto nothing. A term whose
+ * compartment is genuinely ambiguous — "Paraesthesia" and the other nervous
+ * system terms that name no compartment, "Adrenal insufficiency" and the other
+ * endocrine terms outside the thyroid — matches no rule, so the caller drops
+ * and counts it rather than filing it under a neighbour.
+ */
 /**
  * Order matters: more-specific patterns first. GI is matched before
  * "metabolic" because terms like "blood glucose" should land in
@@ -11,8 +26,9 @@
 const RULES = [
     // pancreas (specific) — must come before generic GI
     { rx: /\bpancreatit|\bamylase|\blipase/i, organ: "pancreas" },
-    // thyroid / C-cell
-    { rx: /\b(thyroid|c[-\s]?cell|calcitonin|goit[re]+|medullar[a-z]*\s*(?:thyroid|carcinoma))/i, organ: "endocrine_thyroid" },
+    // thyroid / C-cell. The token names the thyroid, not the endocrine system,
+    // so a non-thyroid endocrine term deliberately matches nothing here.
+    { rx: /thyroid|\b(c[-\s]?cell|calcitonin|goit[re]+|medullar[a-z]*\s*carcinoma)/i, organ: "endocrine_thyroid" },
     // gastrointestinal
     { rx: /\b(nause|vomit|diarrhoe|diarrhea|constipat|ileus|gastropares|abdominal\s*pain|cholecystit|cholelithias|gallbladder|colit|heartburn)/i, organ: "gi" },
     // hepatic — liver/alt/ast forms added; alt/ast pinned to "increased" to avoid
@@ -27,23 +43,48 @@ const RULES = [
     // cardiac — cardi(ac|al|o) covers CARDIOMYOPATHY/CARDIOVASCULAR/CARDIOTOXICITY;
     // bare heart covers HEART FAILURE, HEART RATE INCREASED, etc.
     { rx: /\b(cardi(?:ac|al|o)|heart|myocard|tachycard|brady\w*card|arrhythm|atrial\s+fibrillat|qt\s+prolong|torsade)/i, organ: "cardiac" },
+    // vascular — placed after cardiac so a myocardial event stays cardiac.
+    // `thrombos` rather than the `thrombo` stem, which would swallow
+    // THROMBOCYTOPENIA; `\bvascul` never matches inside CEREBROVASCULAR.
+    { rx: /\b(hypertens|hypotens|vasculit|vascular|thrombos|thromboemboli|thrombophleb|embolism|aneurysm|varicose|phlebit)/i, organ: "vascular" },
     // metabolic (glucose, weight, lipid)
     // triglyc has no leading \b because it appears mid-word in HYPERTRIGLYCERIDAEMIA
     { rx: /\b(glucose|glycaemi|hba1c|insulin|weight\s+(?:decreased|increased)|lipid|cholester|dehydration)|triglyc/i, organ: "metabolic" },
-    // cns
-    { rx: /\b(headache|dizz|seizure|suici|depression|anxiet|paraesthes|neuropath|encephalo|migrain)/i, organ: "cns" },
-    // hematologic
-    { rx: /\b(haemoglobin|hemoglobin|haematocrit|leuko|neutro|thrombocyt|anaemi|haemat|platelet)/i, organ: "hematologic" },
-    // respiratory
-    { rx: /\b(nasopharyng|pharyng|bronch|pneumon|dyspnoe|dyspnea|cough|respiratory|sinusit)/i, organ: "respiratory" },
+    // respiratory — above the neurological rules so RESPIRATORY DEPRESSION is
+    // read as a respiratory event rather than by the bare "depression" stem
+    { rx: /\b(nasopharyng|pharyng|bronch|pneumon|dyspnoe|dyspnea|cough|respiratory|sinusit|pulmonary)/i, organ: "respiratory" },
+    // hematologic — above the neurological rules for the same reason, so
+    // BONE MARROW DEPRESSION is read as haematologic
+    { rx: /\b(haemoglobin|hemoglobin|haematocrit|leuko|neutro|thrombocyt|anaemi|haemat|platelet|marrow)/i, organ: "hematologic" },
+    // ocular — above the nerve rules so OPTIC NEUROPATHY stays ocular.
+    // `macular` is pinned to its ocular compounds so it never matches
+    // MACULOPAPULAR RASH.
+    {
+        rx: /\b(ocular|ophthalm|retinopath|retinal|glaucoma|cataract|uveit|conjunctivit|blindness|vision|visual|keratit|scleriti|blephariti|eye\s|macular\s+(?:oedema|edema|degenerat)|optic\s+(?:neuropath|neurit|atroph))/i,
+        organ: "ocular",
+    },
+    // peripheral nervous system — a neuropathy is a disease of the peripheral
+    // nerves; a central lesion is named by the terms in the cns rule below
+    // `neuropath` carries no leading \b so POLYNEUROPATHY and MONONEUROPATHY
+    // resolve as well as NEUROPATHY PERIPHERAL
+    { rx: /neuropath|neurit|\b(radiculopath|neuralg|carpal\s+tunnel|guillain|plexopath|peripheral\s+(?:motor|sensory))/i, organ: "pns" },
+    // central nervous system
+    {
+        rx: /\b(headache|dizz|seizure|convuls|suici|depression|anxiet|encephalo|migrain|myelopath|meningit|cerebr|intracranial|somnolen|ataxi|tremor|stroke)/i,
+        organ: "cns",
+    },
     // dermatologic
     { rx: /\b(rash|eczem|prurit|urticari|injection\s+site\s+(?:pain|haemorrhag|erythem))/i, organ: "dermatologic" },
-    // musculoskeletal
-    { rx: /\b(arthralg|myalg|musculoskel|fracture|bone\s+pain)/i, organ: "musculoskeletal" },
+    // musculoskeletal — malignant hyperthermia is a skeletal-muscle crisis and
+    // is matched here so the malignancy stem below never claims it
+    { rx: /\b(arthralg|myalg|musculoskel|fracture|bone\s+pain|rhabdomyol|malignant\s+hyperthermi)/i, organ: "musculoskeletal" },
     // immune
     { rx: /\b(hypersensitiv|anaphyl|autoimmune|cytokine\s+release)/i, organ: "immune" },
     // reproductive
     { rx: /\b(menstrual|menorrhag|ovari|endometr|prostat|erectile)/i, organ: "reproductive" },
+    // oncology — last, so a malignancy that names its site is filed under that
+    // site and only a term whose content is the malignancy itself lands here
+    { rx: /\b(neoplasm|malignan|carcinoma|sarcoma|lymphoma|leukaemi|leukemi|myeloma|myelodysplas|melanoma|metastas|tumour|tumor|cancer)/i, organ: "oncology" },
 ];
 const UNINFORMATIVE_RE = /\b(incorrect\s+dose|off\s+label|drug\s+ineffective|product\s+(?:use|storage|administration)|accidental\s+exposure|inappropriate\s+schedule|exposure\s+via\s+skin|extra\s+dose|wrong\s+technique)\b/i;
 export function classifyOrgan(meddraTerm) {
@@ -61,14 +102,18 @@ export function classifyOrgan(meddraTerm) {
  * do not contain MedDRA PT stems, so `classifyOrgan` returns null for them —
  * the SOC map is the primary path; `classifyOrgan(term)` is the fallback when
  * the SOC string isn't in the map.
+ *
+ * A SOC that spans more than one canonical organ is absent: "Nervous system
+ * disorders" covers both nervous-system tokens and "Endocrine disorders" is
+ * broader than the thyroid, so a row under either resolves by its preferred
+ * term or not at all.
  */
 export const TRIAL_AE_ORGAN_MAP = {
     "Gastrointestinal disorders": "gi",
     "Cardiac disorders": "cardiac",
-    "Nervous system disorders": "cns",
+    "Vascular disorders": "vascular",
     "Hepatobiliary disorders": "hepatic",
     "Renal and urinary disorders": "renal",
-    "Endocrine disorders": "endocrine_thyroid",
     "Respiratory, thoracic and mediastinal disorders": "respiratory",
     "Skin and subcutaneous tissue disorders": "dermatologic",
     "Musculoskeletal and connective tissue disorders": "musculoskeletal",
@@ -76,6 +121,8 @@ export const TRIAL_AE_ORGAN_MAP = {
     "Blood and lymphatic system disorders": "hematologic",
     "Reproductive system and breast disorders": "reproductive",
     "Immune system disorders": "immune",
+    "Eye disorders": "ocular",
+    "Neoplasms benign, malignant and unspecified (incl cysts and polyps)": "oncology",
 };
 /**
  * Classify a trial AE row by its SOC (preferred) or its individual MedDRA
@@ -89,38 +136,3 @@ export function classifyTrialAe(ae) {
         return fromSoc;
     return classifyOrgan(ae.term ?? "");
 }
-/**
- * Classify a polypharm off-target panel row by its canonical `organ_system`
- * string (set by the curated safety panel — `cardiac` | `hepatic` | `cns` |
- * `renal` | `gi` | `hematologic` | `immune` | `metabolic` | `respiratory`).
- *
- * Falls back to `classifyOrgan` if the upstream string is non-canonical;
- * this preserves coverage if a future collector emits MedDRA terms instead
- * of canonical organ names.
- */
-export function classifyPolypharmOrgan(organSystem) {
-    const sys = (organSystem ?? "").toLowerCase().trim();
-    if (!sys)
-        return null;
-    // Canonical names from the safety panel enum match by direct string equality.
-    if (CANONICAL_ORGAN_NAMES.has(sys))
-        return sys;
-    return classifyOrgan(sys);
-}
-const CANONICAL_ORGAN_NAMES = new Set([
-    "cardiac",
-    "hepatic",
-    "cns",
-    "renal",
-    "gi",
-    "pancreas",
-    "endocrine_thyroid",
-    "metabolic",
-    "hematologic",
-    "immune",
-    "respiratory",
-    "reproductive",
-    "dermatologic",
-    "musculoskeletal",
-    "oncology",
-]);

package/dist/workflows/target-assessment/lib/recommendation-sanitizer.js

@@ -13,7 +13,7 @@
  */
 const SCAFFOLD_TOKEN_RE = /per_section_synthesis\.[A-Za-z_][\w.]*(?:\[[\d–-]+\])?(?:\s+row\s+\d+)?/g;
 // Citations to dossier.per_section_synthesis.* — this namespace doesn't exist
-// in the v4 schema. The synthesis prompt occasionally emits these paths;
+// in the dossier schema. The synthesis prompt occasionally emits these paths;
 // strip them to prevent non-resolvable citations in recommendation prose.
 const INVALID_PATH_RE = /\(?dossier\.per_section_synthesis\.[a-z_.[\]0-9]*\)?/gi;
 // Dangling "dossier." with no path suffix is leftover templating; strip it.

package/dist/workflows/target-assessment/lib/regulatory-actions.d.ts

@@ -5,14 +5,13 @@
  * for each drug, then maps both into the dossier's RegulatoryActionRow
  * shape.
  *
- * This is the data-source replacement for the hand-curated calcitonin seed
- * that previously lived next to it. Coverage that legitimately has no
+ * Coverage that legitimately has no
  * machine-readable source (e.g., EMA assessment-report procedure codes like
  * EMEA/H/A-31/1291) is omitted rather than backfilled with curation — the
  * source_url points at the canonical document where the human reader can
  * extract the additional context.
  */
-import type { RegulatoryActionRowV5 as RegulatoryActionRow } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { RegulatoryActionRow } from "@inflexa-ai/harness/contracts/target-dossier.js";
 export interface DrugForRegulatoryActions {
     chemblId: string;
     name: string;

package/dist/workflows/target-assessment/lib/regulatory-actions.js

@@ -5,8 +5,7 @@
  * for each drug, then maps both into the dossier's RegulatoryActionRow
  * shape.
  *
- * This is the data-source replacement for the hand-curated calcitonin seed
- * that previously lived next to it. Coverage that legitimately has no
+ * Coverage that legitimately has no
  * machine-readable source (e.g., EMA assessment-report procedure codes like
  * EMEA/H/A-31/1291) is omitted rather than backfilled with curation — the
  * source_url points at the canonical document where the human reader can
@@ -15,6 +14,7 @@
 import { withHost } from "../../../lib/host-concurrency.js";
 import { getReferralsByDrug } from "../../../tools/lib/ema-client.js";
 import { getDrugLabelActions } from "../../../tools/lib/openfda-client.js";
+import { segmentLabelSafety } from "./fda-label-safety.js";
 function formatEffectiveTime(yyyymmdd) {
     if (!yyyymmdd || yyyymmdd.length < 6)
         return "";
@@ -35,6 +35,29 @@ function clipFinding(text) {
         return cleaned;
     return `${cleaned.slice(0, FINDING_CHAR_LIMIT - 1).trimEnd()}…`;
 }
+/**
+ * Project a fetched label onto the shared typed safety form. Returns null when
+ * the label carries no application number: its warnings could not then be cited
+ * back to a document, and an uncitable warning is not evidence.
+ */
+function labelSafetyOf(drug, label) {
+    if (!label.applicationNumber)
+        return null;
+    const sections = [];
+    if (label.boxedWarning)
+        sections.push({ section: "boxed_warning", text: label.boxedWarning });
+    if (label.warningsAndCautions)
+        sections.push({ section: "warnings_and_precautions", text: label.warningsAndCautions });
+    if (sections.length === 0)
+        return null;
+    return {
+        application_number: label.applicationNumber,
+        drug_name: label.genericName ?? label.brandName ?? drug.name,
+        effective_time: label.effectiveTime ?? undefined,
+        source_url: label.sourceUrl || undefined,
+        sections,
+    };
+}
 function fdaRowsFor(drug, labels) {
     if (labels.length === 0)
         return [];
@@ -42,6 +65,12 @@ function fdaRowsFor(drug, labels) {
     const latest = sorted[0];
     const rows = [];
     const actionDate = formatEffectiveTime(latest.effectiveTime);
+    // The label's own prose, segmented once and attributed to organs, is what
+    // lets each row cite the section a reader can open rather than only the
+    // agency and the date.
+    const labelSafety = labelSafetyOf(drug, latest);
+    const signals = labelSafety ? segmentLabelSafety([labelSafety]).signals : [];
+    const evidenceFrom = (section) => signals.filter((s) => s.source_section === section).map((s) => s.evidence);
     if (latest.boxedWarning) {
         rows.push({
             drug_chembl_id: drug.chemblId,
@@ -54,7 +83,7 @@ function fdaRowsFor(drug, labels) {
             application_number: latest.applicationNumber ?? undefined,
             finding: clipFinding(latest.boxedWarning),
             source_url: latest.sourceUrl || undefined,
-            evidence: [],
+            evidence: evidenceFrom("boxed_warning"),
         });
     }
     if (latest.warningsAndCautions) {
@@ -70,7 +99,7 @@ function fdaRowsFor(drug, labels) {
             label_section: "5",
             finding: clipFinding(latest.warningsAndCautions),
             source_url: latest.sourceUrl || undefined,
-            evidence: [],
+            evidence: evidenceFrom("warnings_and_precautions"),
         });
     }
     if (latest.hasRems) {

package/dist/workflows/target-assessment/lib/safety-corroboration.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The safety-evidence corroboration spine.
+ *
+ * A run queries a dozen-plus independent sources and files each one's output in
+ * its own dossier section. This fold asks the question none of those sections
+ * can: for a given organ, do the sources agree? Agreement across independent
+ * sources is itself evidence, and it is what separates a real organ liability
+ * from a single-source artefact.
+ *
+ * The fold re-fetches nothing. Every signal it reads is already in hand when it
+ * runs, and a source that also populates a section of its own is referenced
+ * here as a contribution rather than restated — there is one evidence path, not
+ * two.
+ *
+ * **The source list is open.** A source is one entry in `SIGNAL_SOURCES`
+ * declaring its id and how to read its signals out of the run's inputs.
+ * Everything downstream — grouping, counting, thresholding, evidence assembly —
+ * is written against the id-bearing record, so a fifteenth collector joins the
+ * spine by adding an entry and changes neither the fold nor the schema.
+ */
+import type { SafetyCorroboration } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { Phase1Bundle } from "../schemas.js";
+import type { OrganSignalProjection } from "./fda-label-safety.js";
+/** Distinct sources an organ needs before the spine calls it corroborated. */
+export declare const MIN_INDEPENDENT_SOURCES = 2;
+/** What the section reports as having emptied it. */
+export declare const CORROBORATION_FILTER: string;
+/** Everything the fold reads. Already collected — nothing here is fetched. */
+export interface CorroborationInput {
+    readonly phase1: Phase1Bundle;
+    /** Per-organ FDA label warnings segmented at the approval-precedent step. */
+    readonly regulatoryOrganSignals: OrganSignalProjection | null;
+}
+/**
+ * Fold the run's per-organ safety signals into one corroboration record per
+ * organ.
+ *
+ * `dropped_count` counts signals — the fold's input unit — discarded because
+ * their organ did not resolve, because their source produced no locator, or
+ * because their organ drew fewer than `MIN_INDEPENDENT_SOURCES` distinct
+ * sources. A fold that ends with no record reports `filtered` with that count
+ * rather than an empty `available`.
+ */
+export declare function assembleSafetyCorroboration(input: CorroborationInput): SafetyCorroboration;

package/dist/workflows/target-assessment/lib/safety-corroboration.js

@@ -0,0 +1,273 @@
+/**
+ * The safety-evidence corroboration spine.
+ *
+ * A run queries a dozen-plus independent sources and files each one's output in
+ * its own dossier section. This fold asks the question none of those sections
+ * can: for a given organ, do the sources agree? Agreement across independent
+ * sources is itself evidence, and it is what separates a real organ liability
+ * from a single-source artefact.
+ *
+ * The fold re-fetches nothing. Every signal it reads is already in hand when it
+ * runs, and a source that also populates a section of its own is referenced
+ * here as a contribution rather than restated — there is one evidence path, not
+ * two.
+ *
+ * **The source list is open.** A source is one entry in `SIGNAL_SOURCES`
+ * declaring its id and how to read its signals out of the run's inputs.
+ * Everything downstream — grouping, counting, thresholding, evidence assembly —
+ * is written against the id-bearing record, so a fifteenth collector joins the
+ * spine by adding an entry and changes neither the fold nor the schema.
+ */
+import { isSafetyRelevant, meetsTpmFloor, resolveTissueOrganSystem } from "../assemblers/safety.js";
+import { resolveHpoOrgan } from "./hpo-organ-map.js";
+import { resolveImpcOrgan } from "./impc-organ-map.js";
+import { classifyOrgan } from "./meddra-organ-map.js";
+/** Distinct sources an organ needs before the spine calls it corroborated. */
+export const MIN_INDEPENDENT_SOURCES = 2;
+/** What the section reports as having emptied it. */
+export const CORROBORATION_FILTER = `organ signals with no resolvable organ or locator, or whose organ drew fewer than ` + `${MIN_INDEPENDENT_SOURCES} independent sources`;
+/**
+ * Curated human phenotypes ranked per organ. A well-annotated gene carries
+ * hundreds of HPO terms under one organ system; beyond the ranked head they
+ * restate the same organ-level signal, so the source raises it once at the
+ * granularity a reader can act on.
+ */
+const PHENOTYPES_PER_ORGAN = 3;
+// ── Source extractors ────────────────────────────────────────────────
+/** Warning fragments from FDA prescribing information, already organ-keyed. */
+function extractRegulatoryLabels(input) {
+    const projection = input.regulatoryOrganSignals;
+    if (!projection)
+        return [];
+    return projection.signals.map((s) => ({
+        organ: s.organ,
+        signal: `${s.drug_name} label §${s.label_section}: ${s.excerpt}`,
+        evidence: s.evidence.regulatory_reference ? s.evidence : null,
+    }));
+}
+/** Mouse knockout phenotype systems, keyed by the MGI accession for the gene. */
+function extractKnockoutPhenotypes(input) {
+    const impc = input.phase1.collectors.impc;
+    if (impc.coverage !== "available")
+        return [];
+    const accession = impc.data.mgiAccessionId;
+    return impc.data.organSystems.map((bucket) => ({
+        organ: resolveImpcOrgan(bucket),
+        signal: `mouse knockout phenotype in the ${bucket} system`,
+        evidence: accession
+            ? {
+                source: "impc",
+                accession,
+                predicate: "knockout_phenotype",
+                excerpt: `${impc.data.mouseMarkerSymbol ?? ""} knockout phenotypes in the ${bucket} system`.trim(),
+                metadata: { bucket, phenotype_count: impc.data.phenotypeCount },
+            }
+            : null,
+    }));
+}
+/** Curated human phenotypes, resolved by HPO ancestry rather than by label. */
+function extractHumanPhenotypes(input) {
+    const monarch = input.phase1.collectors.monarch;
+    if (monarch.coverage !== "available")
+        return [];
+    const ranked = [...monarch.data.phenotypes].sort((a, b) => b.publications.length - a.publications.length || (b.frequencyPercent ?? 0) - (a.frequencyPercent ?? 0) || a.label.localeCompare(b.label));
+    const perOrgan = new Map();
+    const out = [];
+    for (const p of ranked) {
+        const organ = resolveHpoOrgan(p.hpoId, p.ancestorIds);
+        if (organ === null) {
+            out.push({ organ: null, signal: p.label, evidence: null });
+            continue;
+        }
+        const seen = perOrgan.get(organ) ?? 0;
+        if (seen >= PHENOTYPES_PER_ORGAN)
+            continue;
+        perOrgan.set(organ, seen + 1);
+        const pmid = p.publications.find((pub) => pub.startsWith("PMID:"))?.slice("PMID:".length);
+        out.push({
+            organ,
+            signal: `curated human phenotype: ${p.label}`,
+            evidence: {
+                source: "monarch",
+                accession: p.hpoId,
+                ...(pmid ? { pmid } : {}),
+                predicate: "human_phenotype",
+                is_human: true,
+                excerpt: p.label,
+                metadata: {
+                    ...(p.diseaseContext ? { disease_context: p.diseaseContext } : {}),
+                    ...(p.frequencyPercent != null ? { frequency_percent: p.frequencyPercent } : {}),
+                    ...(p.primaryKnowledgeSource ? { knowledge_source: p.primaryKnowledgeSource } : {}),
+                },
+            },
+        });
+    }
+    return out;
+}
+/** Open Targets' curated safety liabilities, keyed by the Ensembl accession. */
+function extractCuratedSafetyLiabilities(input) {
+    const ot = input.phase1.collectors.opentargets;
+    if (ot.coverage !== "available")
+        return [];
+    return ot.data.safetyLiabilities.map((liability) => ({
+        organ: classifyOrgan(liability.event) ?? classifyOrgan(liability.biosamples.join(" ")),
+        signal: `curated safety liability: ${liability.event}`,
+        evidence: {
+            source: "opentargets:safety",
+            accession: ot.data.ensemblId,
+            predicate: "known_safety_liability",
+            excerpt: liability.effects ? `${liability.event} — ${liability.effects}` : liability.event,
+            metadata: { biosamples: liability.biosamples, curator: liability.source },
+        },
+    }));
+}
+/**
+ * Baseline expression in safety-relevant tissues.
+ *
+ * The atlas reaches the dossier through Open Targets' consensus expression,
+ * which is Human Protein Atlas data — the same path
+ * `reference_biology.normal_tissue_expression` and the off-tissue risk rows
+ * read, with the same safety-relevance and floor rules applied. Only the
+ * highest-expressing tissue per organ is raised: several tissues mapping to one
+ * organ are one expression signal about that organ.
+ */
+function extractExpressionAtlas(input) {
+    const expression = input.phase1.collectors.expressionHuman;
+    if (expression.coverage !== "available")
+        return [];
+    const accession = input.phase1.resolved.ids.ensembl;
+    const best = new Map();
+    const unresolved = [];
+    for (const t of expression.data.tissues) {
+        const value = t.value ?? 0;
+        if (!isSafetyRelevant(t.tissueLabel, t.organSystem) || !meetsTpmFloor(t.tissueLabel, value))
+            continue;
+        const organ = resolveTissueOrganSystem(t.tissueLabel, t.organSystem);
+        if (organ === null) {
+            unresolved.push({ organ: null, signal: `${t.tissueLabel} expression`, evidence: null });
+            continue;
+        }
+        const current = best.get(organ);
+        if (!current || value > current.value)
+            best.set(organ, { tissue: t.tissueLabel, value });
+    }
+    const resolved = [...best.entries()].map(([organ, hit]) => {
+        const signal = `${expression.data.unit} expression ${hit.value} in ${hit.tissue}`;
+        return {
+            organ,
+            signal,
+            evidence: accession
+                ? {
+                    source: `expression:${expression.data.source}`,
+                    accession,
+                    predicate: "expressed_in_safety_tissue",
+                    score: hit.value,
+                    excerpt: `${hit.tissue}: ${hit.value} (${expression.data.unit})`,
+                    metadata: {
+                        tissue: hit.tissue,
+                        unit: expression.data.unit,
+                        normalization_notes: expression.data.normalization_notes,
+                    },
+                }
+                : null,
+        };
+    });
+    return [...resolved, ...unresolved];
+}
+/**
+ * The registered sources.
+ *
+ * This array is the whole integration surface: an id, and how to read that
+ * source's organ-bearing signals out of what the run already collected.
+ */
+const SIGNAL_SOURCES = [
+    { id: "fda_label", extract: extractRegulatoryLabels },
+    { id: "impc", extract: extractKnockoutPhenotypes },
+    { id: "monarch", extract: extractHumanPhenotypes },
+    { id: "opentargets_safety", extract: extractCuratedSafetyLiabilities },
+    { id: "expression_atlas", extract: extractExpressionAtlas },
+];
+/**
+ * Fold the run's per-organ safety signals into one corroboration record per
+ * organ.
+ *
+ * `dropped_count` counts signals — the fold's input unit — discarded because
+ * their organ did not resolve, because their source produced no locator, or
+ * because their organ drew fewer than `MIN_INDEPENDENT_SOURCES` distinct
+ * sources. A fold that ends with no record reports `filtered` with that count
+ * rather than an empty `available`.
+ */
+export function assembleSafetyCorroboration(input) {
+    const sourcesConsidered = [];
+    const admitted = [];
+    let dropped = 0;
+    for (const source of SIGNAL_SOURCES) {
+        const signals = source.extract(input);
+        if (signals.length === 0)
+            continue;
+        sourcesConsidered.push(source.id);
+        const seen = new Set();
+        for (const raw of signals) {
+            if (raw.organ === null || raw.evidence === null) {
+                dropped += 1;
+                continue;
+            }
+            const key = `${raw.organ}\u0000${raw.signal}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            admitted.push({
+                source: source.id,
+                organ: raw.organ,
+                contribution: { source: source.id, signal: raw.signal, evidence: raw.evidence },
+            });
+        }
+    }
+    if (sourcesConsidered.length === 0) {
+        return {
+            coverage: "queried_no_data",
+            error: { message: "no source produced an organ-bearing safety signal" },
+        };
+    }
+    const byOrgan = new Map();
+    for (const item of admitted) {
+        const bucket = byOrgan.get(item.organ);
+        if (bucket)
+            bucket.push(item);
+        else
+            byOrgan.set(item.organ, [item]);
+    }
+    const rows = [];
+    for (const [organ, items] of byOrgan) {
+        const corroborating = [...new Set(items.map((i) => i.source))].sort();
+        if (corroborating.length < MIN_INDEPENDENT_SOURCES) {
+            dropped += items.length;
+            continue;
+        }
+        const contributions = items.map((i) => i.contribution);
+        rows.push({
+            organ,
+            contributions,
+            corroborating_sources: corroborating,
+            independent_source_count: corroborating.length,
+            support: { state: "scored", evidence: contributions.map((c) => c.evidence) },
+        });
+    }
+    rows.sort((a, b) => b.independent_source_count - a.independent_source_count || a.organ.localeCompare(b.organ));
+    // Reaching here means at least one source emitted a signal — that is what put
+    // it in `sourcesConsidered` — and every emitted signal was either admitted or
+    // counted as dropped. So no record left standing means the fold's own
+    // thresholds took them all, and `dropped` is necessarily positive.
+    if (rows.length === 0) {
+        return { coverage: "filtered", filter: CORROBORATION_FILTER, dropped_count: dropped };
+    }
+    return {
+        coverage: "available",
+        data: {
+            rows,
+            sources_considered: [...sourcesConsidered].sort(),
+            min_independent_sources: MIN_INDEPENDENT_SOURCES,
+        },
+        ...(dropped > 0 ? { dropped_count: dropped } : {}),
+    };
+}

package/dist/workflows/target-assessment/lib/target-identity-filter.d.ts

@@ -1,12 +1,10 @@
 /**
  * Trial-attribution classifier + UniProt-backed identity resolvers.
  *
- * `resolveOnTargetChemblIds` and `resolveFamilySiblingUniprots` replace the
- * hand-curated ALTERNATE_CHEMBL_IDS and RELATED_FAMILY_UNIPROTS maps that
- * previously lived here. Both fetch from authoritative sources at assembly
- * time (UniProt for ChEMBL cross-references; IUPHAR Guide to Pharmacology
- * for receptor-family siblings) so no per-target editing is needed when a
- * new HGNC target is assessed.
+ * `resolveOnTargetChemblIds` and `resolveFamilySiblingUniprots` fetch from
+ * authoritative sources at assembly time — UniProt for ChEMBL cross-references,
+ * IUPHAR Guide to Pharmacology for receptor-family siblings — so assessing a
+ * new HGNC target needs no per-target curation here.
  *
  * The actual loop-level checks (`isOnTargetChemblId` etc.) take the
  * resolved arrays as plain inputs so the per-row assembly path stays
@@ -48,7 +46,7 @@ export declare function resolveOnTargetChemblIds(assessmentUniprot: string): Pro
  * Resolve UniProt accessions of sibling receptors in the same IUPHAR family
  * as the assessment target. Used by `classifyTrialAttribution` so a trial
  * whose intervention hits a paralog (e.g., CALCRL when CALCR is the
- * assessment target) lands in `related_target_trials[]` rather than the
+ * assessment target) lands in the related bucket rather than the
  * primary trials list.
  */
 export declare function resolveFamilySiblingUniprots(uniprotOrGeneSymbol: string): Promise<string[]>;

package/dist/workflows/target-assessment/lib/target-identity-filter.js

@@ -1,12 +1,10 @@
 /**
  * Trial-attribution classifier + UniProt-backed identity resolvers.
  *
- * `resolveOnTargetChemblIds` and `resolveFamilySiblingUniprots` replace the
- * hand-curated ALTERNATE_CHEMBL_IDS and RELATED_FAMILY_UNIPROTS maps that
- * previously lived here. Both fetch from authoritative sources at assembly
- * time (UniProt for ChEMBL cross-references; IUPHAR Guide to Pharmacology
- * for receptor-family siblings) so no per-target editing is needed when a
- * new HGNC target is assessed.
+ * `resolveOnTargetChemblIds` and `resolveFamilySiblingUniprots` fetch from
+ * authoritative sources at assembly time — UniProt for ChEMBL cross-references,
+ * IUPHAR Guide to Pharmacology for receptor-family siblings — so assessing a
+ * new HGNC target needs no per-target curation here.
  *
  * The actual loop-level checks (`isOnTargetChemblId` etc.) take the
  * resolved arrays as plain inputs so the per-row assembly path stays
@@ -63,7 +61,7 @@ export async function resolveOnTargetChemblIds(assessmentUniprot) {
  * Resolve UniProt accessions of sibling receptors in the same IUPHAR family
  * as the assessment target. Used by `classifyTrialAttribution` so a trial
  * whose intervention hits a paralog (e.g., CALCRL when CALCR is the
- * assessment target) lands in `related_target_trials[]` rather than the
+ * assessment target) lands in the related bucket rather than the
  * primary trials list.
  */
 export async function resolveFamilySiblingUniprots(uniprotOrGeneSymbol) {

package/dist/workflows/target-assessment/metrics.d.ts

@@ -1,13 +1,11 @@
 /**
  * OpenTelemetry counters for the target-assessment DBOS workflow.
  *
- * Surfaces three signals:
+ * Surfaces two signals:
  *  - `cortex.harness.ta.workflow.terminal_reason` — per terminal path; the
  *    alert in §16.5/§16.6 reads this. `reason` ∈ {completed,
  *    target-unresolved, schema-violation, derived-invariant-violation,
  *    unexpected-throw, suspended-on-402, operator-cancelled}.
- *  - `cortex.harness.ta.llm.attempts` — histogram per LLM step (caller
- *    samples on entry to detect probe-retry loops).
  *  - billing cache_hit/_miss live in `harness/billing/target-assessment-resolver.ts`.
  *
  * Memoised meter so a re-imported module in tests doesn't recreate the
@@ -15,7 +13,4 @@
  * "duplicate instrument" warnings).
  */
 export type TaTerminalReason = "completed" | "target-unresolved" | "schema-violation" | "derived-invariant-violation" | "unexpected-throw" | "suspended-on-402" | "operator-cancelled" | "deleted";
-/** Test hook — drop memoised instruments to rebind a fresh MeterProvider. */
-export declare function __resetTaWorkflowMetricsForTest(): void;
 export declare function recordTerminalReason(reason: TaTerminalReason): void;
-export declare function recordLlmAttempt(agentId: string, attempt: number): void;