@inflexa-ai/harness 0.16.0 → 0.18.0

package/dist/workflows/target-assessment/phase4-assemble.js

@@ -1,37 +1,37 @@
 /**
- * Phase 4 — deterministic dossier assembly.
+ * Phase 4 — dossier assembly.
  *
- * Pure function over a Phase-3 bundle. Calls `assembleDossier` (~3.5K LOC
- * of pure compute) and returns the assembled `DossierV4Body`. The Phase-5
- * synthesis sections (translational commentary, liability bullets, safety-
- * flags trail) are stamped by the Phase-5 persist step after this step
- * completes.
+ * Calls `assembleDossier` (~3.5K LOC of aggregation over the Phase-3 bundle)
+ * and returns the assembled `DossierBody`. The safety-corroboration and
+ * claim-investigation sections are stamped by the workflow body between this
+ * step and synthesis; the Phase-5 synthesis sections (translational commentary,
+ * liability bullets, safety-flags trail) are stamped by the Phase-5 persist
+ * step.
  *
  * The DBOS workflow body wraps this in `DBOS.runStep({name: "phase4-assemble"})`
  * so recovery on a fresh replica replays the cached output without re-running
- * the ~1-3 sec compute.
- *
- * `assembleDossier` accepts an optional `ClinicalConsequenceAnnotatorDeps`
- * bundle that is threaded through to `annotateOffTargetPanel`. For the
- * DBOS workflow the parameter is undefined — the annotator falls back to
- * its DB cache + no-LLM path. Threading a real deps bundle (provider +
- * session + model) through Phase-4 is a follow-up tracked in §17 cleanup.
+ * the compute. Replay caching earns its keep here because `annotatorDeps`
+ * carries the per-row clinical-consequence annotator's LLM seam: assembly makes
+ * bounded model calls for off-target rows that have no cached annotation. Those
+ * calls are per-row best-effort — a failure leaves the row's original fallback —
+ * and their results are cached in Postgres, so a repeat assessment of the same
+ * target reaches them without an LLM call at all.
  */
-import { DossierV4BodySchema } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import { DossierBodySchema } from "@inflexa-ai/harness/contracts/target-dossier.js";
 import { z } from "zod";
 import { assembleDossier } from "./assemblers/index.js";
 import { Phase3BundleSchema } from "./steps/phase3-aggregate.js";
 export const Phase4OutputSchema = z.object({
     assessmentId: z.string(),
-    dossier: DossierV4BodySchema,
+    dossier: DossierBodySchema,
 });
 export { Phase3BundleSchema };
 /**
- * Run Phase 4 — assemble the v4 dossier body from the Phase-3 bundle.
- * Deterministic over its inputs; safely cached on DBOS replay.
+ * Run Phase 4 — assemble the dossier body from the Phase-3 bundle.
+ * Safely cached on DBOS replay; the caller supplies the annotator seam.
  */
-export async function phase4Assemble(pool, phase3) {
-    const dossier = await assembleDossier(pool, phase3.phase2, phase3, undefined);
+export async function phase4Assemble(pool, phase3, annotatorDeps) {
+    const dossier = await assembleDossier(pool, phase3.phase2, phase3, annotatorDeps);
     return {
         assessmentId: phase3.phase2.phase1.resolved.assessmentId,
         dossier,

package/dist/workflows/target-assessment/phase5-persist.d.ts

@@ -2,21 +2,21 @@
  * Phase 5 — stamps the four Phase-5 synthesis outputs into the Phase-4 dossier,
  * runs the deterministic refinement passes (coverage-qualifier reconcile,
  * no-liabilities disclosure rewrite, recommendation citation validation +
- * demotion, recommendation quality gates), upgrades the v4 body to v5,
- * computes derived fields, and validates against `DossierV5Schema`.
+ * demotion, recommendation quality gates), computes derived fields, and
+ * validates against `DossierSchema`.
  *
- * The DB write (`setDossier` / `markFailed`) lives in the workflow's terminal
- * handler in §6. This module returns the validated dossier instead of writing it.
+ * The DB write (`setDossier` / `markFailed`) belongs to the workflow's terminal
+ * handler; this module returns the validated dossier instead of writing it.
  * Typed throws (`DossierSchemaViolationError`, `DossierDerivedInvariantError`)
- * let the terminal handler dispatch to `markFailed` with the matching `error.kind`.
+ * let that handler dispatch to `markFailed` with the matching `error.kind`.
  *
- * The direction-of-effect audit (`auditCitationDirections`) is NOT called here —
- * it requires an LLM and is not on the PR #4 critical path. Follow-up tracked
- * in §17 if a harness-native audit pipeline is wired.
+ * Every pass here is deterministic. The direction-of-effect audit
+ * (`auditCitationDirections`) is not among them because it needs an LLM call,
+ * and this module runs after synthesis has closed.
  */
-import { z } from "zod";
 import type { Logger } from "../../lib/logger.js";
-import { type DossierV4Body } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import { type DossierBody } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { OrganSignalProjection } from "./lib/fda-label-safety.js";
 import type { Phase2Bundle } from "./steps/phase2-aggregate.js";
 import type { DossierRecommendationStepOutput, LiabilityBulletsStepOutput, SafetyFlagsTrailStepOutput, TranslationalCommentaryStepOutput } from "./synthesis/index.js";
 export declare class DossierSchemaViolationError extends Error {
@@ -31,8 +31,13 @@ export interface Phase5PersistInput {
     /** Operational logging seam; omitted falls back to no-op. */
     readonly logger?: Logger;
     readonly assessmentId: string;
-    readonly phase4Dossier: DossierV4Body;
+    readonly phase4Dossier: DossierBody;
     readonly phase2: Phase2Bundle;
+    /**
+     * Per-organ signals segmented from the FDA labels the approval-precedent
+     * step fetched. Null when no indication resolved and no label was queried.
+     */
+    readonly regulatoryOrganSignals: OrganSignalProjection | null;
     readonly synthesis: {
         readonly bullets: LiabilityBulletsStepOutput;
         readonly flags: SafetyFlagsTrailStepOutput;
@@ -40,21 +45,15 @@ export interface Phase5PersistInput {
         readonly recommendation: DossierRecommendationStepOutput;
     };
 }
-export declare const Phase5PersistResultSchema: z.ZodObject<{
-    assessmentId: z.ZodString;
-    dossier: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    bytes: z.ZodNumber;
-}, z.core.$strip>;
 export interface Phase5PersistResult {
     readonly assessmentId: string;
     readonly dossier: Record<string, unknown>;
     readonly bytes: number;
 }
 /**
- * Run Phase-5 persist as a pure function. Returns the validated v5
- * dossier (and computed bytes) on success. Throws
- * `DossierDerivedInvariantError` when `computeDerivedFields` rejects the
- * dossier; throws `DossierSchemaViolationError` when the v5 schema
- * rejects the final dossier.
+ * Run Phase-5 persist as a pure function. Returns the validated dossier (and
+ * computed bytes) on success. Throws `DossierDerivedInvariantError` when
+ * `computeDerivedFields` rejects the dossier; throws
+ * `DossierSchemaViolationError` when the schema rejects the final dossier.
  */
 export declare function phase5Persist(input: Phase5PersistInput): Promise<Phase5PersistResult>;

package/dist/workflows/target-assessment/phase5-persist.js

@@ -2,30 +2,26 @@
  * Phase 5 — stamps the four Phase-5 synthesis outputs into the Phase-4 dossier,
  * runs the deterministic refinement passes (coverage-qualifier reconcile,
  * no-liabilities disclosure rewrite, recommendation citation validation +
- * demotion, recommendation quality gates), upgrades the v4 body to v5,
- * computes derived fields, and validates against `DossierV5Schema`.
+ * demotion, recommendation quality gates), computes derived fields, and
+ * validates against `DossierSchema`.
  *
- * The DB write (`setDossier` / `markFailed`) lives in the workflow's terminal
- * handler in §6. This module returns the validated dossier instead of writing it.
+ * The DB write (`setDossier` / `markFailed`) belongs to the workflow's terminal
+ * handler; this module returns the validated dossier instead of writing it.
  * Typed throws (`DossierSchemaViolationError`, `DossierDerivedInvariantError`)
- * let the terminal handler dispatch to `markFailed` with the matching `error.kind`.
+ * let that handler dispatch to `markFailed` with the matching `error.kind`.
  *
- * The direction-of-effect audit (`auditCitationDirections`) is NOT called here —
- * it requires an LLM and is not on the PR #4 critical path. Follow-up tracked
- * in §17 if a harness-native audit pipeline is wired.
+ * Every pass here is deterministic. The direction-of-effect audit
+ * (`auditCitationDirections`) is not among them because it needs an LLM call,
+ * and this module runs after synthesis has closed.
  */
-import { z } from "zod";
 import { createNoopLogger } from "../../lib/console-logger.js";
-import { DossierV5Schema, } from "@inflexa-ai/harness/contracts/target-dossier.js";
-import { getDrugPrimaryTargetUniprots } from "../../tools/lib/chembl-client.js";
-import { deterministicTranslationalCommentary } from "./assemblers/index.js";
+import { DossierSchema, } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import { assembleRegulatoryOrganSignals, deterministicTranslationalCommentary } from "./assemblers/index.js";
 import { validateRecommendationCitations } from "./lib/citation-validator.js";
-import { classifyClinicalEvidenceTrial } from "./lib/clinical-evidence-attribution.js";
 import { computeDerivedFields } from "./lib/compute-derived.js";
 import { detectStructuralEvidenceConflicts } from "./lib/evidence-conflict-detector.js";
 import { applyRecommendationQualityGates } from "./lib/recommendation-quality-gates.js";
 import { sanitizeRecommendation } from "./lib/recommendation-sanitizer.js";
-import { resolveFamilySiblingUniprots } from "./lib/target-identity-filter.js";
 const SOFT_CAP_BYTES = 16 * 1024 * 1024;
 // ── Typed throws — handled in §6 terminal handler ────────────────────
 export class DossierSchemaViolationError extends Error {
@@ -44,11 +40,6 @@ export class DossierDerivedInvariantError extends Error {
         this.name = "DossierDerivedInvariantError";
     }
 }
-export const Phase5PersistResultSchema = z.object({
-    assessmentId: z.string(),
-    dossier: z.record(z.string(), z.unknown()),
-    bytes: z.number(),
-});
 // ── Internal helpers ─────────────────────────────────────────────────
 function approximateSize(d) {
     return Buffer.byteLength(JSON.stringify(d), "utf-8");
@@ -85,13 +76,45 @@ function pickCommentarySeverity(row) {
     }
     return "ok";
 }
-function stampSynthesis(logger, phase4Dossier, syn, phase2) {
+const CITED_PMID_RE = /\bPMID[:\s]?(\d{6,9})\b/gi;
+/**
+ * A synthesised claim stands on the papers it cites. One that cites none says
+ * so — a section path is a pointer into this dossier, not a record a reader
+ * can independently check.
+ */
+function supportFromCitedPmids(text, reasonWhenUncited) {
+    const pmids = [...new Set([...text.matchAll(CITED_PMID_RE)].map((m) => m[1]))];
+    if (pmids.length === 0)
+        return { state: "unknown", reason: reasonWhenUncited };
+    return { state: "scored", evidence: pmids.map((pmid) => ({ pmid, source: "pubmed" })) };
+}
+function stampSynthesis(logger, phase4Dossier, syn, phase2, regulatoryOrganSignals) {
     const next = structuredClone(phase4Dossier);
+    next.safety_profile.regulatory_organ_signals = assembleRegulatoryOrganSignals(regulatoryOrganSignals);
     if (syn.bullets.coverage === "available") {
-        next.liability_summary.liability_bullets = syn.bullets.data.bullets.map((b) => ({ text: b.text, rationale: b.rationale, category: b.category }));
+        next.liability_summary.liability_bullets = syn.bullets.data.bullets.map((b) => ({
+            text: b.text,
+            rationale: b.rationale,
+            category: b.category,
+            support: supportFromCitedPmids(`${b.text} ${b.rationale} ${b.evidence_pointer}`, `bullet cites ${b.evidence_pointer} rather than a paper`),
+        }));
     }
     if (syn.flags.coverage === "available" && syn.flags.data.flags.length > 0) {
-        next.safety_profile.target_organ_liabilities = syn.flags.data.flags;
+        next.safety_profile.target_organ_liabilities = {
+            coverage: "available",
+            data: {
+                rows: syn.flags.data.flags.map((f) => ({
+                    organ: f.organ,
+                    severity: f.severity,
+                    trail: f.trail,
+                    mechanism_hypothesis: f.mechanism_hypothesis,
+                    support: supportFromCitedPmids(f.trail, "the audit trail is assembled from dossier sections and cites no paper"),
+                })),
+            },
+        };
+    }
+    else if (syn.flags.coverage === "queried_no_data") {
+        next.safety_profile.target_organ_liabilities = { coverage: "queried_no_data", error: syn.flags.error };
     }
     const deterministicAll = deterministicTranslationalCommentary(phase2);
     const deterministicSorted = [...deterministicAll].sort((a, b) => {
@@ -245,160 +268,21 @@ function reconcileCoverageQualifier(dossier) {
         return coverage !== "available";
     });
 }
-function makeUnknownAttribution(reason) {
-    return {
-        relationship: "unknown",
-        evidence_role: "excluded",
-        basis: [{ kind: "text_match", source: "legacy-v4-upgrade" }],
-        resolved_interventions: [],
-        exclusion_reason: reason,
-    };
-}
-async function buildAttributionContext(phase2, knownClassDrugsBase, therapeuticPrograms) {
-    const ctgov = phase2.phase1.collectors.ctgov.coverage === "available"
-        ? [...phase2.phase1.collectors.ctgov.data.active, ...phase2.phase1.collectors.ctgov.data.failed]
-        : [];
-    const assessmentUniprot = phase2.phase1.resolved.ids?.uniprot ?? "";
-    const geneSymbol = phase2.phase1.resolved.geneSymbol ?? "";
-    const [familyUniprots, resolvedDrugs] = await Promise.all([
-        assessmentUniprot || geneSymbol ? resolveFamilySiblingUniprots(assessmentUniprot || geneSymbol) : Promise.resolve([]),
-        Promise.all(knownClassDrugsBase.map(async (drug) => {
-            const resolved = drug.moleculeChemblId ? await getDrugPrimaryTargetUniprots(drug.moleculeChemblId).catch(() => []) : [];
-            const targetUniprots = resolved.length > 0 ? resolved : assessmentUniprot ? [assessmentUniprot] : [];
-            return { ...drug, targetUniprots };
-        })),
-    ]);
-    return {
-        byNct: new Map(ctgov.map((trial) => [trial.nctId, trial])),
-        classifyOpts: {
-            assessmentSymbol: geneSymbol,
-            assessmentUniprot,
-            familyUniprots,
-            knownClassDrugs: resolvedDrugs,
-            therapeuticPrograms,
-        },
-    };
-}
-function attachAttribution(row, ctx) {
-    const source = ctx.byNct.get(row.nct_id);
-    const classified = source
-        ? classifyClinicalEvidenceTrial(source, ctx.classifyOpts)
-        : {
-            attribution: makeUnknownAttribution("No normalized CT.gov source row was available for this legacy row."),
-            eligible_for_toxicology_aggregation: false,
-        };
-    return {
-        ...row,
-        attribution: classified.attribution,
-        eligible_for_toxicology_aggregation: classified.eligible_for_toxicology_aggregation,
-    };
-}
-function upgradeTrialRows(rows, ctx) {
-    const kept = [];
-    const excluded = [];
-    for (const row of rows) {
-        const upgraded = attachAttribution(row, ctx);
-        if (upgraded.eligible_for_toxicology_aggregation)
-            kept.push(upgraded);
-        else
-            excluded.push(upgraded);
-    }
-    return { rows: kept, excluded_rows: excluded };
-}
-function normalizeRegulatoryActionRows(rows) {
-    return rows.map((row) => {
-        if (row.source_kind)
-            return row;
-        const action_kind = row.action_kind;
-        const agency = row.agency;
-        const source_kind = action_kind === "black_box"
-            ? "boxed_warning"
-            : action_kind === "REMS"
-                ? "rems"
-                : action_kind === "withdrawal"
-                    ? "withdrawal"
-                    : agency === "EMA"
-                        ? "referral"
-                        : "label_warning";
-        return {
-            ...row,
-            source_kind,
-            action_kind: source_kind === "label_warning" && action_kind === "safety_communication" ? "label_warning" : action_kind,
-            source_date: row.action_date,
-        };
-    });
-}
-async function upgradeDossierToV5(body, phase2) {
-    const next = structuredClone(body);
-    next.schema_version = "5";
-    const drugInteractions = next.drug_interactions;
-    const knownClassDrugsBase = drugInteractions?.coverage === "available"
-        ? (drugInteractions.data?.rows ?? []).map((row) => ({
-            name: String(row.drug_name ?? ""),
-            moleculeChemblId: row.drug_id ?? null,
-        }))
-        : [];
-    const tpCollector = phase2.phase1.collectors.therapeuticPrograms;
-    const therapeuticPrograms = tpCollector?.coverage === "available"
-        ? tpCollector.data.programs.map((program) => ({
-            programId: program.programId,
-            name: program.name,
-            targetSymbol: program.targetSymbol,
-            targetUniprot: program.targetUniprot,
-            modality: program.modality,
-            nctIds: program.nctIds,
-        }))
-        : [];
-    const attributionCtx = await buildAttributionContext(phase2, knownClassDrugsBase, therapeuticPrograms);
-    const cd = next.clinical_development;
-    if (cd?.trials?.coverage === "available") {
-        const upgraded = upgradeTrialRows(cd.trials.data.rows, attributionCtx);
-        cd.trials.data.rows = upgraded.rows;
-        cd.trials.data.excluded_rows = [...(cd.trials.data.excluded_rows ?? []), ...upgraded.excluded_rows];
-    }
-    if (cd?.failed_trials?.coverage === "available") {
-        const upgraded = upgradeTrialRows(cd.failed_trials.data.rows, attributionCtx);
-        cd.failed_trials.data.rows = upgraded.rows;
-        cd.failed_trials.data.excluded_rows = [...(cd.failed_trials.data.excluded_rows ?? []), ...upgraded.excluded_rows];
-    }
-    if (cd?.outcomes?.coverage === "available") {
-        cd.outcomes.data.rows = cd.outcomes.data.rows.map((row) => attachAttribution(row, attributionCtx));
-    }
-    const analytics = next.analytics;
-    if (analytics?.discovery_trials?.coverage === "available") {
-        const upgraded = upgradeTrialRows(analytics.discovery_trials.data.rows, attributionCtx);
-        analytics.discovery_trials.data.rows = upgraded.rows;
-        analytics.discovery_trials.data.excluded_rows = [...(analytics.discovery_trials.data.excluded_rows ?? []), ...upgraded.excluded_rows];
-        delete analytics.discovery_trials.data.related_target_trials;
-        delete analytics.discovery_trials.data.related_receptor;
-    }
-    const sp = next.safety_profile;
-    const regulatory = sp?.regulatory_actions;
-    if (regulatory?.coverage === "available") {
-        regulatory.data.rows = normalizeRegulatoryActionRows(regulatory.data.rows ?? []);
-    }
-    next.analytics.quality_gates ??= {
-        coverage: "available",
-        data: { rows: [] },
-    };
-    return next;
-}
 // ── Pure-function entry point ────────────────────────────────────────
 /**
- * Run Phase-5 persist as a pure function. Returns the validated v5
- * dossier (and computed bytes) on success. Throws
- * `DossierDerivedInvariantError` when `computeDerivedFields` rejects the
- * dossier; throws `DossierSchemaViolationError` when the v5 schema
- * rejects the final dossier.
+ * Run Phase-5 persist as a pure function. Returns the validated dossier (and
+ * computed bytes) on success. Throws `DossierDerivedInvariantError` when
+ * `computeDerivedFields` rejects the dossier; throws
+ * `DossierSchemaViolationError` when the schema rejects the final dossier.
  */
 export async function phase5Persist(input) {
     const logger = (input.logger ?? createNoopLogger()).named("phase5-persist").with({ assessmentId: input.assessmentId });
     // The dossier rides through this function as an untyped working blob; the
-    // `as unknown as DossierV{4,5}Body` casts below are version-shim views that
-    // let the typed helpers operate on it. None of these casts is load-bearing
-    // for soundness: `DossierV5Schema.safeParse(fullDossier)` at the end is the
-    // single validation gate, and it throws before anything is returned.
-    let dossier = stampSynthesis(logger, input.phase4Dossier, input.synthesis, input.phase2);
+    // `as unknown as DossierBody` casts below let the typed helpers operate on
+    // it. None of these casts is load-bearing for soundness:
+    // `DossierSchema.safeParse(fullDossier)` at the end is the single
+    // validation gate, and it throws before anything is returned.
+    let dossier = stampSynthesis(logger, input.phase4Dossier, input.synthesis, input.phase2, input.regulatoryOrganSignals);
     // Demote organ-claim flagged bullets into coverage_qualifier.unverified_bullets.
     const exec = dossier.executive_recommendation;
     if (exec?.coverage === "available") {
@@ -409,7 +293,6 @@ export async function phase5Persist(input) {
     }
     reconcileCoverageQualifier(dossier);
     rewriteNoLiabilitiesDisclosure(dossier);
-    dossier = (await upgradeDossierToV5(dossier, input.phase2));
     const recommendationAudit = dossier.analytics.recommendation_audit?.data;
     const synthesisDiagnostics = dossier.analytics.synthesis_diagnostics?.coverage ===
         "available"
@@ -454,9 +337,9 @@ export async function phase5Persist(input) {
             data: { rows: [...existingRows, ...structuralConflicts] },
         };
     }
-    const parsed = DossierV5Schema.safeParse(fullDossier);
+    const parsed = DossierSchema.safeParse(fullDossier);
     if (!parsed.success) {
-        throw new DossierSchemaViolationError("Dossier failed v5 schema validation", parsed.error.issues);
+        throw new DossierSchemaViolationError("Dossier failed schema validation", parsed.error.issues);
     }
     return {
         assessmentId: input.assessmentId,

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

@@ -12,7 +12,6 @@ export declare const TargetAssessmentInputSchema: z.ZodObject<{
     organizationId: z.ZodString;
     requestedBy: z.ZodString;
 }, z.core.$strip>;
-export type TargetAssessmentInput = z.infer<typeof TargetAssessmentInputSchema>;
 export declare const ResolvedTargetSchema: z.ZodObject<{
     assessmentId: z.ZodString;
     goal: z.ZodNullable<z.ZodString>;
@@ -250,10 +249,10 @@ export declare const ExpressionMultiSpeciesBundleSchema: z.ZodObject<{
         tissues: z.ZodArray<z.ZodObject<{
             tissue: z.ZodString;
             rank: z.ZodEnum<{
+                absent: "absent";
                 high: "high";
                 medium: "medium";
                 low: "low";
-                absent: "absent";
             }>;
             expressionScore: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strip>>;
@@ -384,6 +383,7 @@ export declare const TherapeuticProgramsBundleSchema: z.ZodObject<{
         evidence: z.ZodArray<z.ZodObject<{
             pmid: z.ZodOptional<z.ZodString>;
             doi: z.ZodOptional<z.ZodString>;
+            accession: z.ZodOptional<z.ZodString>;
             source: z.ZodString;
             predicate: z.ZodOptional<z.ZodString>;
             score: z.ZodOptional<z.ZodNumber>;
@@ -407,6 +407,25 @@ export declare const TherapeuticProgramsBundleSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TherapeuticProgramsBundle = z.infer<typeof TherapeuticProgramsBundleSchema>;
+/**
+ * Curated human phenotype and causal-disease evidence from Monarch.
+ *
+ * `ancestorIds` is the HPO ancestor closure, carried through so the consumer
+ * resolves a phenotype onto an organ by identifier rather than by its label.
+ */
+export declare const MonarchBundleSchema: z.ZodObject<{
+    geneCurie: z.ZodString;
+    phenotypes: z.ZodArray<z.ZodObject<{
+        hpoId: z.ZodString;
+        label: z.ZodString;
+        ancestorIds: z.ZodArray<z.ZodString>;
+        publications: z.ZodArray<z.ZodString>;
+        diseaseContext: z.ZodNullable<z.ZodString>;
+        frequencyPercent: z.ZodNullable<z.ZodNumber>;
+        primaryKnowledgeSource: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MonarchBundle = z.infer<typeof MonarchBundleSchema>;
 export declare const Phase1BundleSchema: z.ZodObject<{
     resolved: z.ZodObject<{
         assessmentId: z.ZodString;
@@ -669,10 +688,10 @@ export declare const Phase1BundleSchema: z.ZodObject<{
                     tissues: z.ZodArray<z.ZodObject<{
                         tissue: z.ZodString;
                         rank: z.ZodEnum<{
+                            absent: "absent";
                             high: "high";
                             medium: "medium";
                             low: "low";
-                            absent: "absent";
                         }>;
                         expressionScore: z.ZodNullable<z.ZodNumber>;
                     }, z.core.$strip>>;
@@ -876,6 +895,31 @@ export declare const Phase1BundleSchema: z.ZodObject<{
             coverage: z.ZodLiteral<"not_loaded">;
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "coverage">;
+        monarch: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            coverage: z.ZodLiteral<"available">;
+            data: z.ZodObject<{
+                geneCurie: z.ZodString;
+                phenotypes: z.ZodArray<z.ZodObject<{
+                    hpoId: z.ZodString;
+                    label: z.ZodString;
+                    ancestorIds: z.ZodArray<z.ZodString>;
+                    publications: z.ZodArray<z.ZodString>;
+                    diseaseContext: z.ZodNullable<z.ZodString>;
+                    frequencyPercent: z.ZodNullable<z.ZodNumber>;
+                    primaryKnowledgeSource: z.ZodNullable<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            coverage: z.ZodLiteral<"queried_no_data">;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                stack: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            coverage: z.ZodLiteral<"not_loaded">;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "coverage">;
         therapeuticPrograms: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             coverage: z.ZodLiteral<"available">;
             data: z.ZodObject<{
@@ -893,6 +937,7 @@ export declare const Phase1BundleSchema: z.ZodObject<{
                     evidence: z.ZodArray<z.ZodObject<{
                         pmid: z.ZodOptional<z.ZodString>;
                         doi: z.ZodOptional<z.ZodString>;
+                        accession: z.ZodOptional<z.ZodString>;
                         source: z.ZodString;
                         predicate: z.ZodOptional<z.ZodString>;
                         score: z.ZodOptional<z.ZodNumber>;

package/dist/workflows/target-assessment/schemas.js

@@ -271,6 +271,24 @@ export const TherapeuticProgramsBundleSchema = z.object({
         confidence: z.enum(["high", "medium", "low"]),
     })),
 });
+/**
+ * Curated human phenotype and causal-disease evidence from Monarch.
+ *
+ * `ancestorIds` is the HPO ancestor closure, carried through so the consumer
+ * resolves a phenotype onto an organ by identifier rather than by its label.
+ */
+export const MonarchBundleSchema = z.object({
+    geneCurie: z.string(),
+    phenotypes: z.array(z.object({
+        hpoId: z.string(),
+        label: z.string(),
+        ancestorIds: z.array(z.string()),
+        publications: z.array(z.string()),
+        diseaseContext: z.string().nullable(),
+        frequencyPercent: z.number().nullable(),
+        primaryKnowledgeSource: z.string().nullable(),
+    })),
+});
 // ── Phase-1 keyed bundle (output of phase1Aggregate) ─────────────────
 export const Phase1BundleSchema = z.object({
     resolved: ResolvedTargetSchema,
@@ -288,6 +306,7 @@ export const Phase1BundleSchema = z.object({
         pathways: withCoverage(PathwaysBundleSchema),
         stringPpi: withCoverage(StringPpiBundleSchema),
         familyComplexes: withCoverage(FamilyComplexesBundleSchema),
+        monarch: withCoverage(MonarchBundleSchema),
         therapeuticPrograms: withCoverage(TherapeuticProgramsBundleSchema).optional(),
     }),
 });

package/dist/workflows/target-assessment/steps/fanout/polypharm-for-one-modulator-step.d.ts

@@ -19,6 +19,7 @@ export declare const PerModulatorPolypharmItemSchema: z.ZodObject<{
     hits: z.ZodArray<z.ZodObject<{
         targetChemblId: z.ZodString;
         targetName: z.ZodNullable<z.ZodString>;
+        assayChemblId: z.ZodNullable<z.ZodString>;
         pchemblValue: z.ZodNullable<z.ZodNumber>;
         standardType: z.ZodNullable<z.ZodString>;
         standardValue: z.ZodNullable<z.ZodNumber>;

package/dist/workflows/target-assessment/steps/fanout/polypharm-for-one-modulator-step.js

@@ -19,6 +19,8 @@ export const PerModulatorPolypharmItemSchema = z.object({
     hits: z.array(z.object({
         targetChemblId: z.string(),
         targetName: z.string().nullable(),
+        /** The ChEMBL assay record the binding was measured in, when there is one. */
+        assayChemblId: z.string().nullable(),
         pchemblValue: z.number().nullable(),
         standardType: z.string().nullable(),
         standardValue: z.number().nullable(),