@inflexa-ai/harness 0.30.3 → 0.31.1

package/dist/workflows/target-assessment/collectors/index.d.ts

@@ -19,9 +19,15 @@
  * `withHost(...)` semaphore. The function signature reserves the future
  * `deps` slot for test injection without churning callers.
  */
+import type { Logger } from "../../../lib/logger.js";
 /** Per-run context threaded to collectors that hit keyed external APIs. */
 export interface CollectorCtx {
     readonly ncbiApiKey?: string;
+    /**
+     * The diagnostics seam of the run. A collector degrades to a coverage
+     * envelope, thus an unexpected cause is invisible without a record here.
+     */
+    readonly logger?: Logger;
 }
 import type { SerializedError } from "../coverage.js";
 import type { CbioportalBundle, ChemblModulatorsBundle, ClinvarBundle, CtgovBundle, ExpressionHumanBundle, ExpressionMultiSpeciesBundle, FaersByTargetBundle, FamilyComplexesBundle, ImpcBundle, MonarchBundle, OpenTargetsBundle, PathwaysBundle, PubmedIndexBundle, ResolvedTarget, StringPpiBundle, TherapeuticProgramsBundle } from "../schemas.js";
@@ -39,13 +45,13 @@ type CoverageNotLoaded = {
 };
 type CoverageEnvelope<T> = CoverageAvailable<T> | CoverageQueriedNoData | CoverageNotLoaded;
 export declare function collectCbioportal(input: ResolvedTarget): Promise<CoverageEnvelope<CbioportalBundle>>;
-export declare function collectChemblModulators(input: ResolvedTarget): Promise<CoverageEnvelope<ChemblModulatorsBundle>>;
+export declare function collectChemblModulators(input: ResolvedTarget, ctx: CollectorCtx): Promise<CoverageEnvelope<ChemblModulatorsBundle>>;
 export declare function collectClinvar(input: ResolvedTarget, ctx: CollectorCtx): Promise<CoverageEnvelope<ClinvarBundle>>;
 export declare function collectCtgov(input: ResolvedTarget): Promise<CoverageEnvelope<CtgovBundle>>;
 export declare function collectExpressionHuman(input: ResolvedTarget): Promise<CoverageEnvelope<ExpressionHumanBundle>>;
 export declare function collectExpressionMultiSpecies(input: ResolvedTarget): Promise<CoverageEnvelope<ExpressionMultiSpeciesBundle>>;
 export declare function collectFaersByTarget(input: ResolvedTarget): Promise<CoverageEnvelope<FaersByTargetBundle>>;
-export declare function collectFamilyComplexes(input: ResolvedTarget): Promise<CoverageEnvelope<FamilyComplexesBundle>>;
+export declare function collectFamilyComplexes(input: ResolvedTarget, ctx: CollectorCtx): Promise<CoverageEnvelope<FamilyComplexesBundle>>;
 export declare function collectImpc(input: ResolvedTarget): Promise<CoverageEnvelope<ImpcBundle>>;
 export declare function collectMonarch(input: ResolvedTarget): Promise<CoverageEnvelope<MonarchBundle>>;
 export declare function collectOpenTargets(input: ResolvedTarget): Promise<CoverageEnvelope<OpenTargetsBundle>>;

package/dist/workflows/target-assessment/collectors/index.js

@@ -19,6 +19,7 @@
  * `withHost(...)` semaphore. The function signature reserves the future
  * `deps` slot for test injection without churning callers.
  */
+import { createNoopLogger } from "../../../lib/console-logger.js";
 import { withHost } from "../../../lib/host-concurrency.js";
 import { getMultiSpeciesExpression } from "../../../tools/lib/bgee-client.js";
 import { getSomaticMutationFrequencies } from "../../../tools/lib/cbioportal-client.js";
@@ -60,18 +61,18 @@ export async function collectCbioportal(input) {
     }
 }
 // ── 2. ChEMBL modulators ─────────────────────────────────────────────
-export async function collectChemblModulators(input) {
+export async function collectChemblModulators(input, ctx) {
     const chemblId = input.ids.chembl;
     if (!chemblId) {
         return { coverage: "not_loaded", reason: "no ChEMBL target id resolved" };
     }
     try {
-        const primaryRows = await withHost("chembl", () => getTargetModulators(chemblId, { minPhase: 2, limit: 200 }));
+        const primaryRows = await withHost("chembl", () => getTargetModulators(chemblId, { minPhase: 2, limit: 200 }, ctx.logger));
         const activityRows = await withHost("chembl", () => getModulatorsViaActivity({
             target_chembl_id: chemblId,
             max_phase_min: 2,
             molecule_type: "Small molecule",
-        }));
+        }, ctx.logger));
         const primaryIds = new Set(primaryRows.map((m) => m.moleculeChemblId));
         const novelActivityRows = activityRows
             .filter((m) => !primaryIds.has(m.moleculeChemblId))
@@ -153,18 +154,32 @@ export async function collectExpressionHuman(input) {
                 },
             };
         }
-        const tissues = expressions.map((e) => ({
+        // `baselineExpression` mixes datasources under one row type, and each one
+        // carries its own unit: GTEx gives bulk-tissue TPM, Tabula Sapiens gives
+        // single-cell CPM pseudobulk, and DICE gives immune-cell TPM. The bundle
+        // declares one source and one unit, thus it can hold rows of one datasource
+        // only. Tabula Sapiens also outnumbers GTEx about 20 to 1, thus an unfiltered
+        // list drowns the tissue table in cell types.
+        const gtex = expressions.filter((e) => e.datasourceId === "gtex");
+        if (gtex.length === 0) {
+            return {
+                coverage: "queried_no_data",
+                error: {
+                    message: `Open Targets carries no GTEx baseline expression for ${ensemblId} (${expressions.length} rows of other datasources dropped)`,
+                },
+            };
+        }
+        const tissues = gtex.map((e) => ({
             tissueLabel: e.tissueLabel,
             organSystem: e.organSystem,
             value: e.rna?.value ?? null,
-            protein: e.protein?.level ?? null,
         }));
         return {
             coverage: "available",
             data: {
-                source: "hpa_consensus",
-                unit: "consensus_normalized",
-                normalization_notes: "Open Targets consensus expression (HPA RNA tissue, TMM-normalized nTPM across samples)",
+                source: "gtex",
+                unit: "tpm",
+                normalization_notes: "Open Targets baseline expression, GTEx bulk-tissue rows only, as the median TPM of each tissue",
                 tissues,
             },
         };
@@ -241,7 +256,7 @@ export async function collectFaersByTarget(input) {
     }
 }
 // ── 8. Family complexes (IUPHAR) ─────────────────────────────────────
-export async function collectFamilyComplexes(input) {
+export async function collectFamilyComplexes(input, ctx) {
     const geneSymbol = input.geneSymbol;
     const uniprot = input.ids.uniprot;
     const lookup = uniprot ?? geneSymbol;
@@ -284,6 +299,12 @@ export async function collectFamilyComplexes(input) {
         };
     }
     catch (err) {
+        // `getFamilyHeterodimers` answers an unknown target with an empty list, thus
+        // a throw here is always an unexpected cause. The IUPHAR outage of 2026 hid
+        // behind this envelope for months, because `queried_no_data` reads as a
+        // clean miss to every consumer of the dossier.
+        const log = (ctx.logger ?? createNoopLogger()).named("ta-collector.family-complexes");
+        log.error("IUPHAR family-complex lookup failed", { lookup, ...log.errorFields(err) });
         return fail(err);
     }
 }
@@ -385,7 +406,13 @@ export async function collectOpenTargets(input) {
                 tractability: info.tractability,
                 associations: info.associations,
                 safetyLiabilities: safety?.safetyLiabilities ?? [],
-                baselineExpression: expression,
+                baselineExpression: expression.map((e) => ({
+                    tissueId: e.tissueId,
+                    tissueLabel: e.tissueLabel,
+                    organSystem: e.organSystem,
+                    datasourceId: e.datasourceId,
+                    rna: e.rna,
+                })),
             },
         };
     }

package/dist/workflows/target-assessment/fanout/index.d.ts

@@ -10,6 +10,7 @@
  * No throws — coverage envelope is the failure mode. Recovery replays the
  * cached envelope from the DBOS step cache.
  */
+import type { Logger } from "../../../lib/logger.js";
 import type { SerializedError } from "../coverage.js";
 import type { ClassDrugItem, PerClassDrugAEsItem } from "../steps/fanout/aes-for-one-class-drug-step.js";
 import type { PerTrialAEsItem, TrialItem } from "../steps/fanout/aes-for-one-trial-step.js";
@@ -26,6 +27,6 @@ type CoverageQueriedNoData = {
 };
 type CoverageEnvelope<T> = CoverageAvailable<T> | CoverageQueriedNoData;
 export declare function faersForOneModulator(item: ModulatorItem): Promise<CoverageEnvelope<PerModulatorFaersItem>>;
-export declare function polypharmForOneModulator(item: PolypharmInputItem): Promise<CoverageEnvelope<PerModulatorPolypharmItem>>;
+export declare function polypharmForOneModulator(item: PolypharmInputItem, logger?: Logger): Promise<CoverageEnvelope<PerModulatorPolypharmItem>>;
 export declare function aesForOneTrial(item: TrialItem): Promise<CoverageEnvelope<PerTrialAEsItem>>;
 export declare function aesForOneClassDrug(item: ClassDrugItem): Promise<CoverageEnvelope<PerClassDrugAEsItem>>;

package/dist/workflows/target-assessment/fanout/index.js

@@ -61,7 +61,7 @@ export async function faersForOneModulator(item) {
     }
 }
 // ── Per-modulator polypharmacology ──────────────────────────────────
-export async function polypharmForOneModulator(item) {
+export async function polypharmForOneModulator(item, logger) {
     try {
         const [hits, primaryPchembl] = await Promise.all([
             withHost("chembl", () => getModulatorPolypharmacology(item.moleculeChemblId, {
@@ -70,7 +70,7 @@ export async function polypharmForOneModulator(item) {
                 limit: 200,
             })),
             item.primaryTargetChemblId
-                ? withHost("chembl", () => getModulatorOnTargetPchembl(item.moleculeChemblId, item.primaryTargetChemblId))
+                ? withHost("chembl", () => getModulatorOnTargetPchembl(item.moleculeChemblId, item.primaryTargetChemblId, logger))
                 : Promise.resolve(null),
         ]);
         if (hits.length === 0) {

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

@@ -124,8 +124,8 @@ function extractCuratedSafetyLiabilities(input) {
 /**
  * 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
+ * The atlas reaches the dossier through the Open Targets `baselineExpression`
+ * surface, narrowed to the GTEx bulk-tissue rows — 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

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

@@ -10,6 +10,7 @@
  * resolved arrays as plain inputs so the per-row assembly path stays
  * synchronous after a single upfront await.
  */
+import type { Logger } from "../../../lib/logger.js";
 export type TrialAttributionInput = {
     assessmentUniprot: string;
     /** UniProts of related family receptors (resolved from IUPHAR family siblings). */
@@ -41,7 +42,7 @@ export declare function classifyTrialAttribution(input: TrialAttributionInput):
  * Network failures are surfaced as an empty list so the assembler degrades
  * to "no alternate-id filtering" rather than blocking the run.
  */
-export declare function resolveOnTargetChemblIds(assessmentUniprot: string): Promise<string[]>;
+export declare function resolveOnTargetChemblIds(assessmentUniprot: string, logger?: Logger): Promise<string[]>;
 /**
  * Resolve UniProt accessions of sibling receptors in the same IUPHAR family
  * as the assessment target. Used by `classifyTrialAttribution` so a trial
@@ -49,7 +50,7 @@ export declare function resolveOnTargetChemblIds(assessmentUniprot: string): Pro
  * assessment target) lands in the related bucket rather than the
  * primary trials list.
  */
-export declare function resolveFamilySiblingUniprots(uniprotOrGeneSymbol: string): Promise<string[]>;
+export declare function resolveFamilySiblingUniprots(uniprotOrGeneSymbol: string, logger?: Logger): Promise<string[]>;
 /**
  * Returns true if `chemblId` is among the supplied list of on-target ChEMBL
  * ids for the assessment protein. Caller is responsible for resolving the

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

@@ -10,6 +10,7 @@
  * resolved arrays as plain inputs so the per-row assembly path stays
  * synchronous after a single upfront await.
  */
+import { createNoopLogger } from "../../../lib/console-logger.js";
 import { withHost } from "../../../lib/host-concurrency.js";
 import { getFamilySiblingUniprots } from "../../../tools/lib/iuphar-client.js";
 import { getChemblIdsByUniProt } from "../../../tools/lib/uniprot-client.js";
@@ -47,13 +48,18 @@ export async function classifyTrialAttribution(input) {
  * Network failures are surfaced as an empty list so the assembler degrades
  * to "no alternate-id filtering" rather than blocking the run.
  */
-export async function resolveOnTargetChemblIds(assessmentUniprot) {
+export async function resolveOnTargetChemblIds(assessmentUniprot, logger) {
     if (!assessmentUniprot)
         return [];
     try {
         return await withHost("uniprot", () => getChemblIdsByUniProt(assessmentUniprot));
     }
-    catch {
+    catch (err) {
+        // UniProt answers an unknown accession with a 404, and the client maps that
+        // to an empty record. Thus a throw here is always an unexpected cause, and
+        // the empty list silently turns off the self-hit filter of the panel.
+        const log = (logger ?? createNoopLogger()).named("ta-identity.on-target-chembl");
+        log.error("UniProt ChEMBL cross-reference lookup failed", { uniprot: assessmentUniprot, ...log.errorFields(err) });
         return [];
     }
 }
@@ -64,13 +70,18 @@ export async function resolveOnTargetChemblIds(assessmentUniprot) {
  * assessment target) lands in the related bucket rather than the
  * primary trials list.
  */
-export async function resolveFamilySiblingUniprots(uniprotOrGeneSymbol) {
+export async function resolveFamilySiblingUniprots(uniprotOrGeneSymbol, logger) {
     if (!uniprotOrGeneSymbol)
         return [];
+    const log = (logger ?? createNoopLogger()).named("ta-identity.family-siblings");
     try {
-        return await withHost("iuphar", () => getFamilySiblingUniprots(uniprotOrGeneSymbol));
+        return await withHost("iuphar", () => getFamilySiblingUniprots(uniprotOrGeneSymbol, log));
     }
-    catch {
+    catch (err) {
+        // IUPHAR answers an unknown target with an empty list, thus a throw here is
+        // always an unexpected cause. The empty list then routes a paralog trial into
+        // the primary trials list, which is the defect that this resolver prevents.
+        log.error("IUPHAR family-sibling lookup failed", { query: uniprotOrGeneSymbol, ...log.errorFields(err) });
         return [];
     }
 }

package/dist/workflows/target-assessment/phase4-assemble.d.ts

@@ -19,70 +19,13 @@
  */
 import type { Pool } from "pg";
 import { z } from "zod";
+import type { Logger } from "../../lib/logger.js";
 import type { ClinicalConsequenceAnnotatorDeps } from "./lib/clinical-consequence-annotator.js";
 import type { Phase3Bundle } from "./steps/phase3-aggregate.js";
 import { Phase3BundleSchema } from "./steps/phase3-aggregate.js";
 export declare const Phase4OutputSchema: z.ZodObject<{
     assessmentId: z.ZodString;
     dossier: z.ZodObject<{
-        drug_interactions: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            coverage: z.ZodLiteral<"available">;
-            data: z.ZodObject<{
-                rows: z.ZodArray<z.ZodObject<{
-                    drug_id: z.ZodNullable<z.ZodString>;
-                    drug_name: z.ZodString;
-                    best_score: z.ZodNumber;
-                    predicates: z.ZodArray<z.ZodString>;
-                    sources: z.ZodArray<z.ZodString>;
-                    paper_count: z.ZodNumber;
-                    dominant_direction: z.ZodEnum<{
-                        unknown: "unknown";
-                        positive: "positive";
-                        negative: "negative";
-                        mixed: "mixed";
-                    }>;
-                    has_human_evidence: z.ZodBoolean;
-                    has_clinical_evidence: z.ZodBoolean;
-                    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>;
-                        strength: z.ZodOptional<z.ZodString>;
-                        is_human: z.ZodOptional<z.ZodBoolean>;
-                        is_clinical: z.ZodOptional<z.ZodBoolean>;
-                        excerpt: z.ZodOptional<z.ZodString>;
-                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                        regulatory_reference: z.ZodOptional<z.ZodObject<{
-                            document: z.ZodString;
-                            section: z.ZodOptional<z.ZodString>;
-                            doc_id: z.ZodOptional<z.ZodString>;
-                            doc_url: z.ZodOptional<z.ZodString>;
-                        }, z.core.$strip>>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>;
-            dropped_count: z.ZodOptional<z.ZodNumber>;
-            inference_path: z.ZodOptional<z.ZodString>;
-            truncated: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>, z.ZodObject<{
-            coverage: z.ZodLiteral<"queried_no_data">;
-            error: z.ZodOptional<z.ZodObject<{
-                message: z.ZodString;
-                source: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            inference_path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            coverage: z.ZodLiteral<"filtered">;
-            filter: z.ZodString;
-            dropped_count: z.ZodNumber;
-            inference_path: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            coverage: z.ZodLiteral<"not_loaded">;
-            reason: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>], "coverage">;
         tractability: z.ZodDiscriminatedUnion<[z.ZodObject<{
             coverage: z.ZodLiteral<"available">;
             data: z.ZodObject<{
@@ -130,8 +73,8 @@ export declare const Phase4OutputSchema: z.ZodObject<{
             displayName: z.ZodString;
             entityType: z.ZodEnum<{
                 gene: "gene";
-                rna: "rna";
                 protein: "protein";
+                rna: "rna";
                 complex: "complex";
             }>;
             ontology: z.ZodString;
@@ -429,6 +372,64 @@ export declare const Phase4OutputSchema: z.ZodObject<{
             coverage: z.ZodLiteral<"not_loaded">;
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "coverage">;
+        drug_interactions: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            coverage: z.ZodLiteral<"available">;
+            data: z.ZodObject<{
+                rows: z.ZodArray<z.ZodObject<{
+                    drug_id: z.ZodNullable<z.ZodString>;
+                    drug_name: z.ZodString;
+                    best_score: z.ZodNumber;
+                    predicates: z.ZodArray<z.ZodString>;
+                    sources: z.ZodArray<z.ZodString>;
+                    paper_count: z.ZodNumber;
+                    dominant_direction: z.ZodEnum<{
+                        unknown: "unknown";
+                        positive: "positive";
+                        negative: "negative";
+                        mixed: "mixed";
+                    }>;
+                    has_human_evidence: z.ZodBoolean;
+                    has_clinical_evidence: z.ZodBoolean;
+                    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>;
+                        strength: z.ZodOptional<z.ZodString>;
+                        is_human: z.ZodOptional<z.ZodBoolean>;
+                        is_clinical: z.ZodOptional<z.ZodBoolean>;
+                        excerpt: z.ZodOptional<z.ZodString>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        regulatory_reference: z.ZodOptional<z.ZodObject<{
+                            document: z.ZodString;
+                            section: z.ZodOptional<z.ZodString>;
+                            doc_id: z.ZodOptional<z.ZodString>;
+                            doc_url: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            dropped_count: z.ZodOptional<z.ZodNumber>;
+            inference_path: z.ZodOptional<z.ZodString>;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            coverage: z.ZodLiteral<"queried_no_data">;
+            error: z.ZodOptional<z.ZodObject<{
+                message: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            inference_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            coverage: z.ZodLiteral<"filtered">;
+            filter: z.ZodString;
+            dropped_count: z.ZodNumber;
+            inference_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            coverage: z.ZodLiteral<"not_loaded">;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "coverage">;
         clinical_development: z.ZodObject<{
             trials: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 coverage: z.ZodLiteral<"available">;
@@ -3178,4 +3179,4 @@ export type { Phase3Bundle };
  * Run Phase 4 — assemble the dossier body from the Phase-3 bundle.
  * Safely cached on DBOS replay; the caller supplies the annotator seam.
  */
-export declare function phase4Assemble(pool: Pool, phase3: Phase3Bundle, annotatorDeps?: ClinicalConsequenceAnnotatorDeps): Promise<Phase4Output>;
+export declare function phase4Assemble(pool: Pool, phase3: Phase3Bundle, annotatorDeps?: ClinicalConsequenceAnnotatorDeps, logger?: Logger): Promise<Phase4Output>;

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

@@ -30,8 +30,8 @@ export { Phase3BundleSchema };
  * 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, annotatorDeps) {
-    const dossier = await assembleDossier(pool, phase3.phase2, phase3, annotatorDeps);
+export async function phase4Assemble(pool, phase3, annotatorDeps, logger) {
+    const dossier = await assembleDossier(pool, phase3.phase2, phase3, annotatorDeps, logger);
     return {
         assessmentId: phase3.phase2.phase1.resolved.assessmentId,
         dossier,

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

@@ -70,13 +70,11 @@ export declare const OpenTargetsBundleSchema: z.ZodObject<{
         tissueId: z.ZodString;
         tissueLabel: z.ZodString;
         organSystem: z.ZodNullable<z.ZodString>;
+        datasourceId: z.ZodString;
         rna: z.ZodNullable<z.ZodObject<{
             value: z.ZodNumber;
             unit: z.ZodString;
         }, z.core.$strip>>;
-        protein: z.ZodNullable<z.ZodObject<{
-            level: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type OpenTargetsBundle = z.infer<typeof OpenTargetsBundleSchema>;
@@ -232,7 +230,6 @@ export declare const ExpressionHumanBundleSchema: z.ZodObject<{
         tissueLabel: z.ZodString;
         organSystem: z.ZodNullable<z.ZodString>;
         value: z.ZodNullable<z.ZodNumber>;
-        protein: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type ExpressionHumanBundle = z.infer<typeof ExpressionHumanBundleSchema>;
@@ -487,13 +484,11 @@ export declare const Phase1BundleSchema: z.ZodObject<{
                     tissueId: z.ZodString;
                     tissueLabel: z.ZodString;
                     organSystem: z.ZodNullable<z.ZodString>;
+                    datasourceId: z.ZodString;
                     rna: z.ZodNullable<z.ZodObject<{
                         value: z.ZodNumber;
                         unit: z.ZodString;
                     }, z.core.$strip>>;
-                    protein: z.ZodNullable<z.ZodObject<{
-                        level: z.ZodNullable<z.ZodNumber>;
-                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{
@@ -659,7 +654,6 @@ export declare const Phase1BundleSchema: z.ZodObject<{
                     tissueLabel: z.ZodString;
                     organSystem: z.ZodNullable<z.ZodString>;
                     value: z.ZodNullable<z.ZodNumber>;
-                    protein: z.ZodNullable<z.ZodNumber>;
                 }, z.core.$strip>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodObject<{

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

@@ -73,12 +73,17 @@ export const OpenTargetsBundleSchema = z.object({
         effects: z.string().nullable(),
         source: z.string(),
     })),
+    // One target carries rows of more than one datasource, and each datasource has
+    // its own unit. Thus `datasourceId` rides with the row, because a reader that
+    // compares two rows without it compares a TPM against a CPM. The
+    // `baselineExpression` surface carries no protein measurement, thus the bundle
+    // makes no protein claim.
     baselineExpression: z.array(z.object({
         tissueId: z.string(),
         tissueLabel: z.string(),
         organSystem: z.string().nullable(),
+        datasourceId: z.string(),
         rna: z.object({ value: z.number(), unit: z.string() }).nullable(),
-        protein: z.object({ level: z.number().nullable() }).nullable(),
     })),
 });
 export const ChemblModulatorsBundleSchema = z.object({
@@ -141,6 +146,8 @@ export const FaersByTargetBundleSchema = z.object({
     })
         .nullable(),
 });
+// The rows come from the Open Targets `baselineExpression` surface, which carries
+// no protein measurement. Thus a row states an RNA value only.
 export const ExpressionHumanBundleSchema = z.object({
     source: z.enum(["gtex", "hpa_consensus", "hpa_rna_tissue"]),
     unit: z.enum(["tpm", "ntpm", "consensus_normalized"]),
@@ -149,7 +156,6 @@ export const ExpressionHumanBundleSchema = z.object({
         tissueLabel: z.string(),
         organSystem: z.string().nullable(),
         value: z.number().nullable(),
-        protein: z.number().nullable(),
     })),
 });
 export const ExpressionMultiSpeciesBundleSchema = z.object({

package/dist/workflows/target-assessment/steps/phase2-aggregate.d.ts

@@ -73,13 +73,11 @@ export declare const Phase2BundleSchema: z.ZodObject<{
                         tissueId: z.ZodString;
                         tissueLabel: z.ZodString;
                         organSystem: z.ZodNullable<z.ZodString>;
+                        datasourceId: z.ZodString;
                         rna: z.ZodNullable<z.ZodObject<{
                             value: z.ZodNumber;
                             unit: z.ZodString;
                         }, z.core.$strip>>;
-                        protein: z.ZodNullable<z.ZodObject<{
-                            level: z.ZodNullable<z.ZodNumber>;
-                        }, z.core.$strip>>;
                     }, z.core.$strip>>;
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{
@@ -245,7 +243,6 @@ export declare const Phase2BundleSchema: z.ZodObject<{
                         tissueLabel: z.ZodString;
                         organSystem: z.ZodNullable<z.ZodString>;
                         value: z.ZodNullable<z.ZodNumber>;
-                        protein: z.ZodNullable<z.ZodNumber>;
                     }, z.core.$strip>>;
                 }, z.core.$strip>;
             }, z.core.$strip>, z.ZodObject<{

package/dist/workflows/target-assessment/steps/phase3-aggregate.d.ts

@@ -66,13 +66,11 @@ export declare const Phase3BundleSchema: z.ZodObject<{
                             tissueId: z.ZodString;
                             tissueLabel: z.ZodString;
                             organSystem: z.ZodNullable<z.ZodString>;
+                            datasourceId: z.ZodString;
                             rna: z.ZodNullable<z.ZodObject<{
                                 value: z.ZodNumber;
                                 unit: z.ZodString;
                             }, z.core.$strip>>;
-                            protein: z.ZodNullable<z.ZodObject<{
-                                level: z.ZodNullable<z.ZodNumber>;
-                            }, z.core.$strip>>;
                         }, z.core.$strip>>;
                     }, z.core.$strip>;
                 }, z.core.$strip>, z.ZodObject<{
@@ -238,7 +236,6 @@ export declare const Phase3BundleSchema: z.ZodObject<{
                             tissueLabel: z.ZodString;
                             organSystem: z.ZodNullable<z.ZodString>;
                             value: z.ZodNullable<z.ZodNumber>;
-                            protein: z.ZodNullable<z.ZodNumber>;
                         }, z.core.$strip>>;
                     }, z.core.$strip>;
                 }, z.core.$strip>, z.ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.30.3",
+    "version": "0.31.1",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",

package/dist/agents/sandbox/__fixtures__/deps.d.ts

@@ -1,23 +0,0 @@
-/**
- * Test-only `SandboxAgentDeps` builder. Hands every dependency a stub so
- * `createSandboxAgent` builds without touching Postgres, the network, or
- * a real sandbox.
- */
-import type { Pool } from "pg";
-import type { ChatProvider } from "../../../providers/types.js";
-import type { SandboxClient } from "../../../sandbox/client.js";
-import type { WorkspaceFilesystem } from "../../../workspace/filesystem.js";
-import type { SandboxAgentDeps } from "../shared.js";
-export declare function makeFakeSandboxClient(): SandboxClient;
-export declare function makeFakeWorkspaceFs(): WorkspaceFilesystem;
-export declare function makeFakeChatProvider(): ChatProvider;
-export declare function makeFakePool(): Pool;
-export interface MakeDepsOverrides {
-    readonly model?: string;
-    readonly analysisId?: string;
-    readonly runId?: string;
-    readonly stepId?: string;
-    readonly workflowId?: string;
-    readonly allowedWritePrefix?: string;
-}
-export declare function makeFakeSandboxAgentDeps(over?: MakeDepsOverrides): SandboxAgentDeps;