@inflexa-ai/harness 0.17.0 → 0.18.0

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

@@ -18,7 +18,7 @@
 import { z } from "zod";
 import type { Pool } from "pg";
 import type { AgentSession } from "../../../auth/types.js";
-import type { ChatProvider } from "../../../providers/types.js";
+import type { AgentChat } from "../../../providers/types.js";
 import type { UsageRecorder } from "../../../billing/usage-recorder.js";
 export declare const OffTargetAnnotationSchema: z.ZodObject<{
     clinical_consequence: z.ZodString;
@@ -26,7 +26,7 @@ export declare const OffTargetAnnotationSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type OffTargetAnnotation = z.infer<typeof OffTargetAnnotationSchema>;
 export interface ClinicalConsequenceAnnotatorDeps {
-    readonly provider: ChatProvider;
+    readonly provider: AgentChat;
     readonly session: AgentSession;
     readonly model: string;
     /** LLM usage-accounting seam for the annotator loop; omitted falls back to the no-op recorder. */

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

@@ -1,4 +1,4 @@
-import type { ClinicalTrialAttributionV5, ClinicalTrialRowV5 } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { ClinicalTrialAttribution } from "@inflexa-ai/harness/contracts/target-dossier.js";
 type TrialLike = {
     nctId: string;
     title: string;
@@ -37,9 +37,8 @@ export type ClinicalEvidenceAttributionContext = {
     therapeuticPrograms: TherapeuticProgram[];
 };
 export type ClinicalEvidenceAttributionResult = {
-    attribution: ClinicalTrialAttributionV5;
+    attribution: ClinicalTrialAttribution;
     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

@@ -150,7 +150,3 @@ export function classifyClinicalEvidenceTrial(trial, ctx) {
     }
     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

@@ -1,4 +1,5 @@
-import type { DerivedV4 } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { Derived } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import { type OrganSystem } from "../../../contracts/organ-system.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
@@ -8,12 +9,12 @@ import type { DerivedV4 } from "@inflexa-ai/harness/contracts/target-dossier.js"
  * 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[];
+export declare function expectedOrgansFromBody(bodyInput: unknown): OrganSystem[];
 /**
- * Build the v4 derived sub-tree from a raw dossier body.
+ * Build the 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.
+ * Schema validation happens at the persist boundary, not here.
  */
-export declare function computeDerivedFields(bodyInput: unknown): DerivedV4;
+export declare function computeDerivedFields(bodyInput: unknown): Derived;

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

@@ -1,6 +1,15 @@
+import { ORGAN_SYSTEMS } from "../../../contracts/organ-system.js";
 import { classifyOrgan, classifyTrialAe } from "./meddra-organ-map.js";
 import { HIGH_EXPRESSION_TPM_THRESHOLD } from "./expression-constants.js";
 const FAERS_TOP_SIGNAL_THRESHOLD = 1000;
+const ORGAN_SYSTEM_SET = new Set(ORGAN_SYSTEMS);
+/**
+ * The body arrives here unvalidated, so an organ token is checked against the
+ * vocabulary before it is carried into the derived sub-tree.
+ */
+function isOrganSystem(value) {
+    return typeof value === "string" && ORGAN_SYSTEM_SET.has(value);
+}
 /**
  * Derive the set of organs that should appear in the organ rollup based on
  * available safety signals (FAERS top signals, serious trial AEs, and
@@ -29,7 +38,7 @@ export function expectedOrgansFromBody(bodyInput) {
     }
     const offTargets = body?.safety_profile?.off_target_panel?.data?.rows ?? [];
     for (const r of offTargets) {
-        if (r.organ_system && typeof r.organ_system === "string")
+        if (r.organ_system && isOrganSystem(r.organ_system))
             expected.add(r.organ_system);
     }
     return [...expected].sort();
@@ -38,7 +47,7 @@ function presentOrgans(body) {
     const rows = body?.safety_profile?.organ_rollup?.data?.rows ?? [];
     return rows
         .map((r) => r.organ)
-        .filter((o) => typeof o === "string")
+        .filter(isOrganSystem)
         .sort();
 }
 function countDistinctPapers(body) {
@@ -51,7 +60,7 @@ function countDistinctPapers(body) {
 }
 function countDistinctTrials(body) {
     const set = new Set();
-    // V5 partitions ineligible trials into `excluded_rows`, so the distinct
+    // Ineligible trials are partitioned 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.
@@ -189,11 +198,11 @@ function countHighExpressionTissues(body) {
     return set.size;
 }
 /**
- * Build the v4 derived sub-tree from a raw dossier body.
+ * Build the 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.
+ * Schema validation happens at the persist boundary, not here.
  */
 export function computeDerivedFields(bodyInput) {
     const body = bodyInput;

package/dist/workflows/target-assessment/lib/family-complex-supplement.d.ts

@@ -1,8 +1,7 @@
 /**
  * Build the obligate-cofactor supplement rows shown in
- * OffTargetPanelV4.excluded_rows from the IUPHAR family-complexes collector
- * bundle. Replaces the hand-curated calcitonin-only supplement that
- * previously lived next to it.
+ * OffTargetPanel.excluded_rows from the IUPHAR family-complexes collector
+ * bundle.
  *
  * pchembl is set to 0 because IUPHAR exposes complex structure, not
  * ligand affinity for the complex; the row is marked selectivity_unknown
@@ -11,11 +10,11 @@
  * clinical_consequence annotator populates `clinical_consequence` once
  * the per-row annotation step runs.
  */
-import type { ExcludedOffTargetRowV4Schema } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { ExcludedOffTargetRowSchema } from "@inflexa-ai/harness/contracts/target-dossier.js";
 import type { z } from "zod";
 import type { FamilyComplexesBundle } from "../schemas.js";
-type ExcludedOffTargetRowV4 = z.infer<typeof ExcludedOffTargetRowV4Schema>;
-export declare function buildFamilyComplexSupplement(bundle: FamilyComplexesBundle): (Omit<ExcludedOffTargetRowV4, "evidence"> & {
+type ExcludedOffTargetRow = z.infer<typeof ExcludedOffTargetRowSchema>;
+export declare function buildFamilyComplexSupplement(bundle: FamilyComplexesBundle): (Omit<ExcludedOffTargetRow, "evidence"> & {
     evidence: [];
 })[];
 export {};

package/dist/workflows/target-assessment/lib/family-complex-supplement.js

@@ -1,8 +1,7 @@
 /**
  * Build the obligate-cofactor supplement rows shown in
- * OffTargetPanelV4.excluded_rows from the IUPHAR family-complexes collector
- * bundle. Replaces the hand-curated calcitonin-only supplement that
- * previously lived next to it.
+ * OffTargetPanel.excluded_rows from the IUPHAR family-complexes collector
+ * bundle.
  *
  * pchembl is set to 0 because IUPHAR exposes complex structure, not
  * ligand affinity for the complex; the row is marked selectivity_unknown

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

@@ -0,0 +1,72 @@
+/**
+ * The typed form of an FDA Structured Product Label's safety prose, and the
+ * per-organ projection over it.
+ *
+ * A label arrives as prose in a handful of named sections. Ingesting it once
+ * into this shape is what lets the same warning reach two places without being
+ * fetched twice: the synthesis markdown renders the sections, and the dossier's
+ * per-organ regulatory signals are segmented out of them. Everything a reader
+ * needs to find a signal again — the application number and the label section —
+ * rides on the signal, so it satisfies the claim-evidence locator requirement.
+ */
+import type { OrganSystem } from "../../../contracts/organ-system.js";
+import type { EvidenceItem } from "../../../contracts/target-dossier.js";
+/** The label sections whose prose carries a safety finding. */
+export declare const LABEL_SAFETY_SECTIONS: readonly ["boxed_warning", "warnings_and_precautions", "warnings", "contraindications"];
+export type LabelSafetySection = (typeof LABEL_SAFETY_SECTIONS)[number];
+/** One block of prose, keyed to the label section it was published under. */
+export interface LabelSafetyText {
+    readonly section: LabelSafetySection;
+    readonly text: string;
+}
+/**
+ * One label's identity plus its safety prose.
+ *
+ * `application_number` is required rather than nullable because it is half of
+ * what makes a signal resolvable; a producer holding a label without one has
+ * nothing to cite and does not construct this shape.
+ */
+export interface FdaLabelSafety {
+    readonly application_number: string;
+    readonly drug_name: string;
+    readonly effective_time?: string;
+    readonly source_url?: string;
+    readonly sections: readonly LabelSafetyText[];
+}
+/** A warning fragment attributed to one canonical organ, with its locator. */
+export interface RegulatoryOrganSignal {
+    readonly organ: OrganSystem;
+    readonly drug_name: string;
+    readonly application_number: string;
+    /** The label section the prose was published under. */
+    readonly source_section: LabelSafetySection;
+    /** What a reader opens to find the excerpt: a numbered marker when the prose carried one. */
+    readonly label_section: string;
+    readonly excerpt: string;
+    readonly evidence: EvidenceItem;
+}
+export interface OrganSignalProjection {
+    readonly signals: readonly RegulatoryOrganSignal[];
+    /** Fragments whose organ did not resolve and were therefore not emitted. */
+    readonly dropped_count: number;
+}
+/** What the section reports as having emptied it when nothing resolved. */
+export declare const ORGAN_RESOLUTION_FILTER = "label warning fragments with no resolvable organ";
+interface WarningFragment {
+    readonly marker: string | null;
+    readonly text: string;
+}
+/**
+ * Split one section's prose into the fragments an organ can be attributed to:
+ * numbered label-section markers first, then bullets inside each marked block.
+ */
+export declare function splitWarningProse(text: string): WarningFragment[];
+/**
+ * Project a set of ingested labels onto per-organ regulatory signals.
+ *
+ * A fragment that resolves to no canonical organ is dropped and counted rather
+ * than filed under a neighbouring organ. A fragment the highlights section
+ * repeats from the full section is emitted once.
+ */
+export declare function segmentLabelSafety(labels: readonly FdaLabelSafety[]): OrganSignalProjection;
+export {};

package/dist/workflows/target-assessment/lib/fda-label-safety.js

@@ -0,0 +1,166 @@
+/**
+ * The typed form of an FDA Structured Product Label's safety prose, and the
+ * per-organ projection over it.
+ *
+ * A label arrives as prose in a handful of named sections. Ingesting it once
+ * into this shape is what lets the same warning reach two places without being
+ * fetched twice: the synthesis markdown renders the sections, and the dossier's
+ * per-organ regulatory signals are segmented out of them. Everything a reader
+ * needs to find a signal again — the application number and the label section —
+ * rides on the signal, so it satisfies the claim-evidence locator requirement.
+ */
+import { classifyOrgan } from "./meddra-organ-map.js";
+/** The label sections whose prose carries a safety finding. */
+export const LABEL_SAFETY_SECTIONS = ["boxed_warning", "warnings_and_precautions", "warnings", "contraindications"];
+/** What the section reports as having emptied it when nothing resolved. */
+export const ORGAN_RESOLUTION_FILTER = "label warning fragments with no resolvable organ";
+/**
+ * Numbered label-section markers ("5.1 Hepatotoxicity"). Split as a lookahead
+ * so the marker stays with the prose it heads. The trailing uppercase-or-paren
+ * requirement is what keeps a dose ("2.5 mg") from reading as a marker.
+ */
+const SECTION_MARKER_SPLIT = /(?=\b\d{1,2}\.\d{1,2}\s+[A-Z(])/;
+const SECTION_MARKER_HEAD = /^(\d{1,2}\.\d{1,2})\s+/;
+/**
+ * Bullet boundaries. Single newlines are NOT boundaries — labels wrap prose
+ * mid-sentence, and splitting on the wrap would sever a finding from the organ
+ * named in its own heading.
+ */
+const FRAGMENT_SPLIT = /[•·▪‣]+|\r?\n\s*\r?\n+|\r?\n[ \t]*[-*]\s+/;
+/** Below this a fragment is a stray heading remnant, not a finding. */
+const MIN_FRAGMENT_CHARS = 16;
+/** Excerpt budget per signal — enough to read the finding, bounded for storage. */
+const MAX_EXCERPT_CHARS = 400;
+function clipExcerpt(text) {
+    if (text.length <= MAX_EXCERPT_CHARS)
+        return text;
+    return `${text.slice(0, MAX_EXCERPT_CHARS - 1).trimEnd()}…`;
+}
+/**
+ * Split one section's prose into the fragments an organ can be attributed to:
+ * numbered label-section markers first, then bullets inside each marked block.
+ */
+export function splitWarningProse(text) {
+    const fragments = [];
+    for (const block of text.split(SECTION_MARKER_SPLIT)) {
+        const head = SECTION_MARKER_HEAD.exec(block);
+        const marker = head?.[1] ?? null;
+        const body = head ? block.slice(head[0].length) : block;
+        for (const piece of body.split(FRAGMENT_SPLIT)) {
+            const collapsed = piece.replace(/\s+/g, " ").trim();
+            if (collapsed.length < MIN_FRAGMENT_CHARS)
+                continue;
+            fragments.push({ marker, text: collapsed });
+        }
+    }
+    return fragments;
+}
+/**
+ * Resolve a fragment onto the canonical organ vocabulary at its own boundary.
+ * The heading — the prose up to its first colon — is tried first, because a
+ * label states the organ there and then discusses it; scanning the whole
+ * fragment first would let an incidental mention outrank the heading.
+ */
+function resolveFragmentOrgan(fragment) {
+    const colon = fragment.indexOf(":");
+    const heading = colon > 0 ? fragment.slice(0, colon) : "";
+    return (heading ? classifyOrgan(heading) : null) ?? classifyOrgan(fragment);
+}
+function buildEvidence(label, labelSection, excerpt, organ) {
+    return {
+        source: "openfda:label",
+        predicate: "label_warning",
+        excerpt,
+        regulatory_reference: {
+            document: `FDA prescribing information — ${label.drug_name}`,
+            section: labelSection,
+            doc_id: label.application_number,
+            ...(label.source_url ? { doc_url: label.source_url } : {}),
+        },
+        metadata: {
+            organ,
+            drug_name: label.drug_name,
+            ...(label.effective_time ? { effective_time: label.effective_time } : {}),
+        },
+    };
+}
+/**
+ * A short fragment can be a substring of a longer unrelated one, so containment
+ * only settles a repeat once the contained text is long enough to be prose
+ * rather than a phrase.
+ */
+const MIN_CONTAINMENT_CHARS = 60;
+function isRepeatOf(seen, candidate) {
+    if (seen === candidate)
+        return true;
+    if (seen.includes(candidate))
+        return candidate.length >= MIN_CONTAINMENT_CHARS;
+    if (candidate.includes(seen))
+        return seen.length >= MIN_CONTAINMENT_CHARS;
+    return false;
+}
+/**
+ * Order a label's sections for segmentation: published section order, then
+ * longest prose first within a section. openFDA returns the highlights summary
+ * and the full section under the same key, so reading the longer one first is
+ * what makes the shorter repeat recognisable as a repeat rather than the other
+ * way round.
+ */
+function segmentationOrder(sections) {
+    const firstSeenAt = new Map();
+    for (const [index, s] of sections.entries()) {
+        if (!firstSeenAt.has(s.section))
+            firstSeenAt.set(s.section, index);
+    }
+    return [...sections].sort((a, b) => firstSeenAt.get(a.section) - firstSeenAt.get(b.section) || b.text.length - a.text.length);
+}
+/**
+ * Project a set of ingested labels onto per-organ regulatory signals.
+ *
+ * A fragment that resolves to no canonical organ is dropped and counted rather
+ * than filed under a neighbouring organ. A fragment the highlights section
+ * repeats from the full section is emitted once.
+ */
+export function segmentLabelSafety(labels) {
+    const signals = [];
+    let droppedCount = 0;
+    for (const label of labels) {
+        const seenMarkers = new Set();
+        const seenText = [];
+        for (const section of segmentationOrder(label.sections)) {
+            // A numbered marker settles a repeat only across blocks: one block
+            // legitimately carries several fragments under its own `5.1`, while
+            // a second block reprising `5.1` is the highlights summary of it.
+            const blockMarkers = new Set();
+            for (const fragment of splitWarningProse(section.text)) {
+                const normalized = fragment.text.toLowerCase();
+                const markerKey = fragment.marker ? `${section.section}:${fragment.marker}` : null;
+                const repeated = (markerKey !== null && seenMarkers.has(markerKey)) || seenText.some((seen) => isRepeatOf(seen, normalized));
+                if (repeated)
+                    continue;
+                if (markerKey !== null)
+                    blockMarkers.add(markerKey);
+                seenText.push(normalized);
+                const organ = resolveFragmentOrgan(fragment.text);
+                if (organ === null) {
+                    droppedCount += 1;
+                    continue;
+                }
+                const labelSection = fragment.marker ?? section.section;
+                const excerpt = clipExcerpt(fragment.text);
+                signals.push({
+                    organ,
+                    drug_name: label.drug_name,
+                    application_number: label.application_number,
+                    source_section: section.section,
+                    label_section: labelSection,
+                    excerpt,
+                    evidence: buildEvidence(label, labelSection, excerpt, organ),
+                });
+            }
+            for (const marker of blockMarkers)
+                seenMarkers.add(marker);
+        }
+    }
+    return { signals, dropped_count: droppedCount };
+}

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

@@ -28,12 +28,3 @@ export interface HeterodimerFilterInput {
  *   "<primary>-<accessory>"  (some sources use a hyphen)
  */
 export declare function makeHeterodimerOfAssessmentFilter(input: HeterodimerFilterInput): (offTargetName: string) => boolean;
-/**
- * One-shot helper for callers that already have an accessory list in hand.
- * Equivalent to `makeHeterodimerOfAssessmentFilter(input)(offTargetName)`.
- */
-export declare function isHeterodimerOfAssessment(input: {
-    assessmentGeneSymbol: string;
-    accessoryProteinNames: string[];
-    offTargetName: string;
-}): boolean;

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

@@ -42,13 +42,3 @@ export function makeHeterodimerOfAssessmentFilter(input) {
         return m[1].toUpperCase() === target;
     };
 }
-/**
- * One-shot helper for callers that already have an accessory list in hand.
- * Equivalent to `makeHeterodimerOfAssessmentFilter(input)(offTargetName)`.
- */
-export function isHeterodimerOfAssessment(input) {
-    return makeHeterodimerOfAssessmentFilter({
-        assessmentGeneSymbol: input.assessmentGeneSymbol,
-        accessoryProteinNames: input.accessoryProteinNames,
-    })(input.offTargetName);
-}

package/dist/workflows/target-assessment/lib/hpo-organ-map.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Human Phenotype Ontology terms onto the canonical organ vocabulary.
+ *
+ * HPO organises every phenotypic abnormality under organ-system roots, and a
+ * phenotype association carries its full ancestor closure. Resolution is
+ * therefore membership of an ancestor id in this table — equality on
+ * identifiers, not matching on prose, so a renamed term keeps resolving and an
+ * incidental word in a label never decides an organ.
+ *
+ * The table is ordered most specific first, because a term sits under several
+ * roots at once: a liver phenotype's closure also contains the digestive-system
+ * root, and reading the broad root first would file every hepatic finding under
+ * `gi`. Roots with no canonical organ to land in (ear, head and neck, growth,
+ * prenatal) are absent — a phenotype is reported under the organ it affects or
+ * not at all.
+ *
+ * A root broader than any single token is absent for that same reason, even
+ * where a token's name is close to it: the endocrine-system root spans every
+ * endocrine organ while the only endocrine token names the thyroid, so an
+ * adrenal phenotype resolves through no root and is dropped. The neoplasm root
+ * says a phenotype is malignant, not where it sits, so a neoplasm resolves
+ * through the organ root it also carries — a lung neoplasm is respiratory, and
+ * a neoplasm with no organ root at all resolves to nothing.
+ *
+ * The values are the canonical tokens, so this module declares no organ
+ * enumeration of its own.
+ */
+import type { OrganSystem } from "../../../contracts/organ-system.js";
+/**
+ * Resolve an HPO term onto a canonical organ from its own id plus its ancestor
+ * closure. Returns null when nothing in the ancestry denotes a canonical organ
+ * system — the caller drops the phenotype and counts it.
+ */
+export declare function resolveHpoOrgan(termId: string, ancestorIds: readonly string[]): OrganSystem | null;

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

@@ -0,0 +1,63 @@
+/**
+ * Human Phenotype Ontology terms onto the canonical organ vocabulary.
+ *
+ * HPO organises every phenotypic abnormality under organ-system roots, and a
+ * phenotype association carries its full ancestor closure. Resolution is
+ * therefore membership of an ancestor id in this table — equality on
+ * identifiers, not matching on prose, so a renamed term keeps resolving and an
+ * incidental word in a label never decides an organ.
+ *
+ * The table is ordered most specific first, because a term sits under several
+ * roots at once: a liver phenotype's closure also contains the digestive-system
+ * root, and reading the broad root first would file every hepatic finding under
+ * `gi`. Roots with no canonical organ to land in (ear, head and neck, growth,
+ * prenatal) are absent — a phenotype is reported under the organ it affects or
+ * not at all.
+ *
+ * A root broader than any single token is absent for that same reason, even
+ * where a token's name is close to it: the endocrine-system root spans every
+ * endocrine organ while the only endocrine token names the thyroid, so an
+ * adrenal phenotype resolves through no root and is dropped. The neoplasm root
+ * says a phenotype is malignant, not where it sits, so a neoplasm resolves
+ * through the organ root it also carries — a lung neoplasm is respiratory, and
+ * a neoplasm with no organ root at all resolves to nothing.
+ *
+ * The values are the canonical tokens, so this module declares no organ
+ * enumeration of its own.
+ */
+/** HPO ancestor id → canonical organ, most specific ancestor first. */
+const HPO_ORGAN_ANCESTORS = [
+    ["HP:0001392", "hepatic"], // Abnormality of the liver
+    ["HP:0001733", "pancreas"], // Abnormality of the pancreas
+    ["HP:0000820", "endocrine_thyroid"], // Abnormality of the thyroid gland
+    ["HP:0000079", "renal"], // Abnormality of the urinary system
+    ["HP:0000078", "reproductive"], // Abnormality of the genital system
+    ["HP:0002597", "vascular"], // Abnormality of the vasculature
+    ["HP:0001627", "cardiac"], // Abnormal heart morphology
+    ["HP:0001626", "cardiac"], // Abnormality of the cardiovascular system
+    ["HP:0000759", "pns"], // Abnormal peripheral nervous system morphology
+    ["HP:0012639", "cns"], // Abnormal nervous system morphology
+    ["HP:0000707", "cns"], // Abnormality of the nervous system
+    ["HP:0002715", "immune"], // Abnormality of the immune system
+    ["HP:0001871", "hematologic"], // Abnormality of blood and blood-forming tissues
+    ["HP:0001939", "metabolic"], // Abnormality of metabolism/homeostasis
+    ["HP:0002086", "respiratory"], // Abnormality of the respiratory system
+    ["HP:0025031", "gi"], // Abnormality of the digestive system
+    ["HP:0000478", "ocular"], // Abnormality of the eye
+    ["HP:0001574", "dermatologic"], // Abnormality of the integument
+    ["HP:0003011", "musculoskeletal"], // Abnormality of the musculature
+    ["HP:0000924", "musculoskeletal"], // Abnormality of the skeletal system
+];
+/**
+ * Resolve an HPO term onto a canonical organ from its own id plus its ancestor
+ * closure. Returns null when nothing in the ancestry denotes a canonical organ
+ * system — the caller drops the phenotype and counts it.
+ */
+export function resolveHpoOrgan(termId, ancestorIds) {
+    const ancestry = new Set([termId, ...ancestorIds]);
+    for (const [id, organ] of HPO_ORGAN_ANCESTORS) {
+        if (ancestry.has(id))
+            return organ;
+    }
+    return null;
+}

package/dist/workflows/target-assessment/lib/impc-organ-map.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The IMPC top-level-phenotype vocabulary onto the canonical organ vocabulary.
+ *
+ * Buckets with no organ system to land in (hearing, growth, mortality,
+ * craniofacial) are absent: a phenotype is reported under the organ it affects
+ * or not at all, never under an approximate neighbour. The map's values are the
+ * canonical tokens, so it declares no enumeration of its own.
+ *
+ * The endocrine bucket is absent for the same reason: IMPC's
+ * "endocrine/exocrine gland phenotype" spans every endocrine organ and the
+ * exocrine glands besides, while the only endocrine token names the thyroid.
+ * A knockout in that bucket names no canonical organ, so it is dropped and
+ * counted rather than read as a thyroid finding.
+ */
+import type { OrganSystem } from "../../../contracts/organ-system.js";
+/** Resolve one IMPC bucket, or null when it denotes no canonical organ. */
+export declare function resolveImpcOrgan(bucket: string): OrganSystem | null;
+/** Resolve a set of IMPC buckets, dropping those with no canonical organ. */
+export declare function toOrganSystems(impcOrganSystems: readonly string[]): OrganSystem[];

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

@@ -0,0 +1,39 @@
+/**
+ * The IMPC top-level-phenotype vocabulary onto the canonical organ vocabulary.
+ *
+ * Buckets with no organ system to land in (hearing, growth, mortality,
+ * craniofacial) are absent: a phenotype is reported under the organ it affects
+ * or not at all, never under an approximate neighbour. The map's values are the
+ * canonical tokens, so it declares no enumeration of its own.
+ *
+ * The endocrine bucket is absent for the same reason: IMPC's
+ * "endocrine/exocrine gland phenotype" spans every endocrine organ and the
+ * exocrine glands besides, while the only endocrine token names the thyroid.
+ * A knockout in that bucket names no canonical organ, so it is dropped and
+ * counted rather than read as a thyroid finding.
+ */
+const IMPC_ORGAN_SYSTEMS = {
+    cardiovascular: "cardiac",
+    gastrointestinal: "gi",
+    hematologic: "hematologic",
+    metabolic: "metabolic",
+    immune: "immune",
+    skin: "dermatologic",
+    hepatic: "hepatic",
+    musculoskeletal: "musculoskeletal",
+    skeleton: "musculoskeletal",
+    cns: "cns",
+    renal: "renal",
+    reproductive: "reproductive",
+    respiratory: "respiratory",
+    vision: "ocular",
+};
+/** Resolve one IMPC bucket, or null when it denotes no canonical organ. */
+export function resolveImpcOrgan(bucket) {
+    return IMPC_ORGAN_SYSTEMS[bucket] ?? null;
+}
+/** Resolve a set of IMPC buckets, dropping those with no canonical organ. */
+export function toOrganSystems(impcOrganSystems) {
+    const resolved = impcOrganSystems.map((o) => resolveImpcOrgan(o)).filter((o) => o !== null);
+    return [...new Set(resolved)];
+}

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

@@ -1,13 +1,33 @@
-export type CanonicalOrgan = "cardiac" | "hepatic" | "cns" | "renal" | "gi" | "pancreas" | "endocrine_thyroid" | "metabolic" | "hematologic" | "immune" | "respiratory" | "reproductive" | "dermatologic" | "musculoskeletal" | "oncology";
-export declare function classifyOrgan(meddraTerm: string): CanonicalOrgan | null;
+/**
+ * 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.
+ */
+import type { OrganSystem } from "../../../contracts/organ-system.js";
+export declare function classifyOrgan(meddraTerm: string): OrganSystem | null;
 /**
  * MedDRA SOC (System Organ Class) names as they appear in CT.gov structured
  * AE tables → canonical organ. SOC strings (e.g. "Gastrointestinal disorders")
  * 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 declare const TRIAL_AE_ORGAN_MAP: Record<string, CanonicalOrgan>;
+export declare const TRIAL_AE_ORGAN_MAP: Record<string, OrganSystem>;
 /**
  * Classify a trial AE row by its SOC (preferred) or its individual MedDRA
  * preferred term (fallback). Shared between the Phase-4 assembler's
@@ -17,14 +37,4 @@ export declare const TRIAL_AE_ORGAN_MAP: Record<string, CanonicalOrgan>;
 export declare function classifyTrialAe(ae: {
     term?: string | null;
     organ?: string | null;
-}): CanonicalOrgan | null;
-/**
- * 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 declare function classifyPolypharmOrgan(organSystem: string | null | undefined): CanonicalOrgan | null;
+}): OrganSystem | null;