@inflexa-ai/harness 0.17.0 → 0.18.0

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

@@ -6,13 +6,16 @@
  *
  *  Phase 0   `phase0Resolve`               — only step allowed to throw
  *                                            (terminates → `target-unresolved`)
- *  Phase 1   14 collectors in parallel     — coverage-envelope failures
+ *  Phase 1   15 collectors in parallel     — coverage-envelope failures
  *  Progress  `emitProgress("deciding")`
  *  Phase 2   2 decisions in parallel       — LLM calls, attempt-numbered
  *  Progress  `emitProgress("fanning_out")`
  *  Phase 3   4 fan-out blocks in parallel  — per-item HTTP, withHost semaphore
  *  Progress  `emitProgress("assembling")`
- *  Phase 4   `phase4Assemble`              — deterministic
+ *  Phase 4   `phase4Assemble`              — aggregation + cached annotator
+ *  Phase 4a  `ta-approval-precedents`      — one openFDA lookup, two projections
+ *  Phase 4b  `assembleSafetyCorroboration` — pure fold, no step of its own
+ *  Phase 4c  `investigateClaims`           — propose / critique / re-verify / converge
  *  Progress  `emitProgress("synthesizing")`
  *  Phase 5a  3 per-section syntheses in parallel
  *  Phase 5b  `dossierRecommendation` sequential
@@ -38,6 +41,7 @@ import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { AgentChat } from "../providers/types.js";
 import { TargetAssessmentInputSchema } from "./target-assessment/schemas.js";
+import { type ClaimInvestigationConfig } from "./target-assessment/investigation/index.js";
 import { type ProgressPhase } from "./target-assessment/progress.js";
 export declare const ExecuteTargetAssessmentInputSchema: z.ZodObject<{
     assessmentId: z.ZodString;
@@ -91,6 +95,13 @@ export interface ExecuteTargetAssessmentDeps {
     readonly synthesisModel: string;
     /** LLM usage-accounting seam for the assessment's agent loops; omitted falls back to the no-op recorder. */
     readonly usageRecorder?: UsageRecorder;
+    /**
+     * Bounds the claim-investigation phase runs under. Omitted falls back to
+     * `DEFAULT_CLAIM_INVESTIGATION_CONFIG` — the values are cost and termination
+     * bounds, not domain constants, so an embedder wanting a deeper pass sets
+     * its own and the dossier reports what was in force.
+     */
+    readonly claimInvestigation?: Partial<ClaimInvestigationConfig>;
 }
 /**
  * Register the executeTargetAssessment workflow with DBOS. Caller is

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

@@ -6,13 +6,16 @@
  *
  *  Phase 0   `phase0Resolve`               — only step allowed to throw
  *                                            (terminates → `target-unresolved`)
- *  Phase 1   14 collectors in parallel     — coverage-envelope failures
+ *  Phase 1   15 collectors in parallel     — coverage-envelope failures
  *  Progress  `emitProgress("deciding")`
  *  Phase 2   2 decisions in parallel       — LLM calls, attempt-numbered
  *  Progress  `emitProgress("fanning_out")`
  *  Phase 3   4 fan-out blocks in parallel  — per-item HTTP, withHost semaphore
  *  Progress  `emitProgress("assembling")`
- *  Phase 4   `phase4Assemble`              — deterministic
+ *  Phase 4   `phase4Assemble`              — aggregation + cached annotator
+ *  Phase 4a  `ta-approval-precedents`      — one openFDA lookup, two projections
+ *  Phase 4b  `assembleSafetyCorroboration` — pure fold, no step of its own
+ *  Phase 4c  `investigateClaims`           — propose / critique / re-verify / converge
  *  Progress  `emitProgress("synthesizing")`
  *  Phase 5a  3 per-section syntheses in parallel
  *  Phase 5b  `dossierRecommendation` sequential
@@ -35,14 +38,19 @@ import { z } from "zod";
 import { forSubAgent } from "../auth/types.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
+import { durableStep } from "../loop/run-step.js";
+import { createPubMedTool } from "../tools/bio/pubmed.js";
 import { resolveTarget } from "../tools/lib/identifier-resolver.js";
 import { TargetAssessmentInputSchema } from "./target-assessment/schemas.js";
 import { getAssessment, markAssessmentSuspended, markFailed, setDossier } from "../state/target-assessments.js";
 import { COLLECTOR_MANIFEST } from "./target-assessment/collectors/index.js";
 import { drugsInClass, modulatorTriage } from "./target-assessment/decisions/index.js";
 import { aesForOneClassDrug, aesForOneTrial, faersForOneModulator, polypharmForOneModulator, } from "./target-assessment/fanout/index.js";
-import { fetchApprovalPrecedents, pickIndicationForPrecedents, renderApprovalPrecedents } from "./target-assessment/lib/approval-precedents.js";
+import { fetchApprovalPrecedents, pickIndicationForPrecedents, precedentLabelSafety, renderApprovalPrecedents, } from "./target-assessment/lib/approval-precedents.js";
+import { segmentLabelSafety } from "./target-assessment/lib/fda-label-safety.js";
 import { readBudgetExceededMarker } from "./target-assessment/lib/llm-step.js";
+import { assembleSafetyCorroboration } from "./target-assessment/lib/safety-corroboration.js";
+import { investigateClaims, isClaimInvestigationBudgetExceeded } from "./target-assessment/investigation/index.js";
 import { recordTerminalReason } from "./target-assessment/metrics.js";
 import { phase4Assemble } from "./target-assessment/phase4-assemble.js";
 import { DossierDerivedInvariantError, DossierSchemaViolationError, phase5Persist } from "./target-assessment/phase5-persist.js";
@@ -151,7 +159,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             phase0Error = err;
             throw err;
         });
-        // (§5.4) Phase 1 — 14 collectors in parallel. Each is its own DBOS
+        // (§5.4) Phase 1 — 15 collectors in parallel. Each is its own DBOS
         // step; coverage failures cache as `queried_no_data` and replay
         // returns the cached envelope. The per-collector run functions emit
         // different bundle shapes; the union is widened to `unknown` here
@@ -177,6 +185,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
                 clinvar: collectorById["clinvar"],
                 cbioportal: collectorById["cbioportal"],
                 impc: collectorById["impc"],
+                monarch: collectorById["monarch"],
                 pubmedIndex: collectorById["pubmed-index"],
                 pathways: collectorById["pathways"],
                 stringPpi: collectorById["string-ppi"],
@@ -288,14 +297,25 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
                 perClassDrugAes: { results: perClassDrugAesResults },
             },
         };
-        // (§5.7) Phase 4 — deterministic assembly. Single DBOS step.
+        // (§5.7) Phase 4 — assembly. Single DBOS step. The annotator seam lets
+        // the off-target panel's clinical-consequence pass reach its LLM on a
+        // cache miss; per-row failures leave the row's fallback in place.
         await emitProgress(deps.pool, logger, input.assessmentId, "assembling");
-        const phase4 = await DBOS.runStep(() => phase4Assemble(deps.pool, phase3), { name: "ta-phase4-assemble" });
+        const annotatorDeps = {
+            provider: deps.chatProvider,
+            session: buildSession(input, "off-target-annotator"),
+            model: deps.decisionModel,
+            ...(deps.usageRecorder ? { usageRecorder: deps.usageRecorder } : {}),
+        };
+        const phase4 = await DBOS.runStep(() => phase4Assemble(deps.pool, phase3, annotatorDeps), {
+            name: "ta-phase4-assemble",
+        });
         // (§5.8-pre) Approval-precedent grounding — one deterministic openFDA
-        // lookup, rendered to markdown and injected into every synthesis prompt.
-        // A precedent-lookup failure must NOT fail the whole assessment: a fetch
-        // throw degrades to a "no precedents" block.
-        const approvalPrecedents = await DBOS.runStep(async () => {
+        // lookup feeding two projections of the same typed labels: the markdown
+        // block every synthesis prompt receives, and the per-organ regulatory
+        // signals the dossier carries. A precedent-lookup failure must NOT fail
+        // the whole assessment: a fetch throw degrades to a "no precedents" block.
+        const precedentGrounding = await DBOS.runStep(async () => {
             const indication = pickIndicationForPrecedents(phase4.dossier);
             let result = null;
             if (indication !== null) {
@@ -307,8 +327,49 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
                     result = null;
                 }
             }
-            return renderApprovalPrecedents(indication, result);
+            return {
+                block: renderApprovalPrecedents(indication, result),
+                // A resolved indication was queried even when the lookup
+                // degraded to nothing; only an unresolved one was not.
+                organSignals: indication === null ? null : segmentLabelSafety(precedentLabelSafety(result?.precedents ?? [])),
+            };
         }, { name: "ta-approval-precedents" });
+        const approvalPrecedents = precedentGrounding.block;
+        // (§5.8-pre) The corroboration fold. It reads the label signals segmented
+        // above, so it runs here rather than at assembly — and here rather than at
+        // persist, because the claim investigation below is its consumer. The fold
+        // is pure over two cached step outputs, so it needs no step of its own: a
+        // replay recomputes the same record without a durable write.
+        const corroboration = assembleSafetyCorroboration({
+            phase1,
+            regulatoryOrganSignals: precedentGrounding.organSignals,
+        });
+        // (§5.8-pre) The claim investigation — propose a mechanism, argue
+        // against it, re-verify, converge. Runs before synthesis so the
+        // synthesis prompts read verdicts rather than bare agreement.
+        const investigation = await investigateClaims({ corroboration, dossier: phase4.dossier }, {
+            logger,
+            chatProvider: deps.chatProvider,
+            session: buildSession(input, "ta-claim-investigation"),
+            model: deps.synthesisModel,
+            attempt: 0,
+            runStep: durableStep,
+            critiqueTools: [createPubMedTool({ ...(deps.ncbiApiKey ? { ncbiApiKey: deps.ncbiApiKey } : {}) })],
+            ...(deps.claimInvestigation ? { config: deps.claimInvestigation } : {}),
+            ...(deps.usageRecorder ? { usageRecorder: deps.usageRecorder } : {}),
+        });
+        if (isClaimInvestigationBudgetExceeded(investigation)) {
+            budgetExceeded = true;
+            throw new BudgetExceededSkip();
+        }
+        const phase4Investigated = {
+            ...phase4,
+            dossier: {
+                ...phase4.dossier,
+                safety_corroboration: corroboration,
+                claim_investigation: investigation,
+            },
+        };
         // (§5.8) Phase 5 — three per-section syntheses in parallel.
         await emitProgress(deps.pool, logger, input.assessmentId, "synthesizing");
         const synthesisDeps = (agentId) => ({
@@ -319,9 +380,9 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
             approvalPrecedents,
         });
         const [bulletsRes, flagsRes, commentaryRes] = await Promise.all([
-            liabilityBullets(phase4, synthesisDeps("liability-bullets")),
-            safetyFlagsTrail(phase4, synthesisDeps("safety-flags-trail")),
-            translationalCommentary(phase4, synthesisDeps("translational-commentary")),
+            liabilityBullets(phase4Investigated, synthesisDeps("liability-bullets")),
+            safetyFlagsTrail(phase4Investigated, synthesisDeps("safety-flags-trail")),
+            translationalCommentary(phase4Investigated, synthesisDeps("translational-commentary")),
         ]);
         if (isBudgetCancel(bulletsRes) || isBudgetCancel(flagsRes) || isBudgetCancel(commentaryRes)) {
             budgetExceeded = true;
@@ -329,7 +390,7 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         }
         // (§5.9) Phase 5b — sequential dossier-recommendation step.
         const recommendationRes = await dossierRecommendation({
-            phase4,
+            phase4: phase4Investigated,
             perSection: {
                 liabilityBullets: bulletsRes,
                 safetyFlagsTrail: flagsRes,
@@ -347,8 +408,9 @@ export async function runExecuteTargetAssessmentBody(input, deps) {
         const persisted = await DBOS.runStep(() => phase5Persist({
             logger,
             assessmentId: input.assessmentId,
-            phase4Dossier: phase4.dossier,
+            phase4Dossier: phase4Investigated.dossier,
             phase2,
+            regulatoryOrganSignals: precedentGrounding.organSignals,
             synthesis: {
                 bullets: bulletsRes,
                 flags: flagsRes,

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

@@ -1,5 +1,5 @@
 export { assembleEntity, assembleTractability, enrichTractabilityModalitiesWithApprovals, type DrugForTractability, reconcileFaersCoverage, assembleDossier, } from "./orchestrator.js";
 export type { TrialOutcomeFilter } from "./trials.js";
-export { assembleLiabilitySummary, isSafetyRelevant, meetsTpmFloor, SAFETY_RELEVANT_ORGANS, REPRODUCTIVE_TOX_TISSUES, REPRODUCTIVE_TOX_TPM_FLOOR, DEFAULT_TPM_FLOOR, aggregateFaersAcrossModulators, aggregateTrialAes, aggregateOffTargetPanel, aggregateClassPrecedent, buildOrganRollup, } from "./safety.js";
+export { assembleLiabilitySummary, isSafetyRelevant, meetsTpmFloor, SAFETY_RELEVANT_ORGANS, REPRODUCTIVE_TOX_TISSUES, REPRODUCTIVE_TOX_TPM_FLOOR, DEFAULT_TPM_FLOOR, aggregateFaersAcrossModulators, aggregateTrialAes, aggregateOffTargetPanel, aggregateClassPrecedent, assembleRegulatoryOrganSignals, buildOrganRollup, } from "./safety.js";
 export { deterministicTranslationalCommentary, isClinicalMeasurement, isSelfReference } from "./literature.js";
 export { aggregateTrialOutcomes } from "./trials.js";

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

@@ -1,4 +1,4 @@
 export { assembleEntity, assembleTractability, enrichTractabilityModalitiesWithApprovals, reconcileFaersCoverage, assembleDossier, } from "./orchestrator.js";
-export { assembleLiabilitySummary, isSafetyRelevant, meetsTpmFloor, SAFETY_RELEVANT_ORGANS, REPRODUCTIVE_TOX_TISSUES, REPRODUCTIVE_TOX_TPM_FLOOR, DEFAULT_TPM_FLOOR, aggregateFaersAcrossModulators, aggregateTrialAes, aggregateOffTargetPanel, aggregateClassPrecedent, buildOrganRollup, } from "./safety.js";
+export { assembleLiabilitySummary, isSafetyRelevant, meetsTpmFloor, SAFETY_RELEVANT_ORGANS, REPRODUCTIVE_TOX_TISSUES, REPRODUCTIVE_TOX_TPM_FLOOR, DEFAULT_TPM_FLOOR, aggregateFaersAcrossModulators, aggregateTrialAes, aggregateOffTargetPanel, aggregateClassPrecedent, assembleRegulatoryOrganSignals, buildOrganRollup, } from "./safety.js";
 export { deterministicTranslationalCommentary, isClinicalMeasurement, isSelfReference } from "./literature.js";
 export { aggregateTrialOutcomes } from "./trials.js";

package/dist/workflows/target-assessment/assemblers/literature.d.ts

@@ -1,4 +1,4 @@
-import type { EvidenceItem } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { ClinicalTrialAttribution, DiscoveryTrials, EvidenceItem } from "@inflexa-ai/harness/contracts/target-dossier.js";
 import type { Phase2Bundle } from "../steps/phase2-aggregate.js";
 import type { Phase3Bundle } from "../steps/phase3-aggregate.js";
 import { HIGH_EXPRESSION_TPM_THRESHOLD } from "../lib/expression-constants.js";
@@ -102,6 +102,7 @@ export declare function assembleAdditionalEvidence(phase2: Phase2Bundle): {
             source: string;
             pmid?: string | undefined;
             doi?: string | undefined;
+            accession?: string | undefined;
             predicate?: string | undefined;
             score?: number | undefined;
             strength?: string | undefined;
@@ -131,7 +132,7 @@ export declare function dedupePpiPartners(partners: PpiInputPartner[]): {
 }[];
 export declare function isClinicalMeasurement(name: string): boolean;
 /**
- * Produce a v4 discriminated `failure_category` block. The "safety" branch
+ * Produce a discriminated `failure_category` block. The "safety" branch
  * uses `safety_evidence_excerpt`; all other branches use
  * `category_evidence_excerpt`.
  */
@@ -197,7 +198,6 @@ export declare function partitionTrialsByAttribution<T extends {
     related: Array<T & {
         match_confidence: "off_target";
     }>;
-    related_receptor: string | undefined;
 }>;
 type RelevanceBasis = {
     kind: "drug_in_class_match";
@@ -246,30 +246,12 @@ export declare function classifyClinicalTrialConfidence(trial: {
     conditions?: string[];
     title: string;
 }, geneSymbol: string, knownClassDrugNames: Set<string>): "high" | "medium" | "low";
-export declare function assembleDiscoveryTrials(phase2: Phase2Bundle, symbol: string, attrCtx: AttributionContext, knownClassDrugNames: Set<string>): Promise<{
-    related_target_trials?: {
-        nct_id: string;
-        title: string;
-        phase: string | null;
-        status: string;
-        conditions: string[];
-        start_date: string | null;
-        completion_date: string | null;
-        match_confidence: "off_target";
-    }[] | undefined;
-    related_receptor?: string | undefined;
-    rows: {
-        nct_id: string;
-        title: string;
-        phase: string | null;
-        status: string;
-        conditions: string[];
-        start_date: string | undefined;
-        completion_date: string | undefined;
-        match_confidence: "high" | "medium" | "low";
-        relevance_basis: RelevanceBasis;
-    }[];
-} | null>;
+export declare function assembleDiscoveryTrials(phase2: Phase2Bundle, symbol: string, attrCtx: AttributionContext, knownClassDrugNames: Set<string>, attachAttribution: <T extends {
+    nct_id: string;
+}>(row: T) => T & {
+    attribution: ClinicalTrialAttribution;
+    eligible_for_toxicology_aggregation: boolean;
+}): Promise<DiscoveryTrials>;
 export declare function assembleEvidenceTimeline(phase2: Phase2Bundle): {
     histogram: Record<string, number>;
     first_reported_year: number | null;

package/dist/workflows/target-assessment/assemblers/literature.js

@@ -1,3 +1,4 @@
+import { coverageFromFilteredRows } from "../coverage.js";
 import { classifyTrialAttribution } from "../lib/target-identity-filter.js";
 import { HIGH_EXPRESSION_TPM_THRESHOLD } from "../lib/expression-constants.js";
 export { HIGH_EXPRESSION_TPM_THRESHOLD };
@@ -525,7 +526,7 @@ const CATEGORY_PATTERNS = [
  * Match the first known failure-cause pattern against `whyStopped` and return
  * the category plus the matched substring (truncated to 200 chars). When no
  * pattern matches, falls back to "operational" with the first 200 chars of
- * `whyStopped` itself — the v4 schema requires the evidence excerpt to be a
+ * `whyStopped` itself — the schema requires the evidence excerpt to be a
  * literal substring of `why_stopped`, which holds by construction.
  */
 function classifyFailureCategory(whyStopped) {
@@ -541,7 +542,7 @@ function classifyFailureCategory(whyStopped) {
     };
 }
 /**
- * Produce a v4 discriminated `failure_category` block. The "safety" branch
+ * Produce a discriminated `failure_category` block. The "safety" branch
  * uses `safety_evidence_excerpt`; all other branches use
  * `category_evidence_excerpt`.
  */
@@ -690,14 +691,6 @@ export function deterministicTranslationalCommentary(phase2) {
     }
     return out.slice(0, 6);
 }
-/**
- * Map from UniProt accession to HGNC gene symbol for related-receptor labeling.
- * Extend as new receptor families gain assessment support.
- */
-const UNIPROT_TO_SYMBOL = {
-    P30988: "CALCR",
-    P32241: "CALCRL",
-};
 /**
  * Partition a list of trials into primary (on-target or unresolved) and
  * related (off-target via a related family receptor). Each trial's
@@ -709,7 +702,6 @@ const UNIPROT_TO_SYMBOL = {
 export async function partitionTrialsByAttribution(trials, ctx) {
     const primary = [];
     const related = [];
-    const relatedAccs = new Set();
     for (const trial of trials) {
         // Normalize interventions: ctgov bundle has string[], typed input may use objects.
         const interventions = Array.isArray(trial.interventions)
@@ -724,20 +716,12 @@ export async function partitionTrialsByAttribution(trials, ctx) {
         });
         if (result.match_confidence === "off_target") {
             related.push({ ...trial, match_confidence: "off_target" });
-            for (const a of result.related_target_uniprots)
-                relatedAccs.add(a);
         }
         else {
             primary.push({ ...trial, match_confidence: result.match_confidence });
         }
     }
-    const related_receptor = relatedAccs.size > 0
-        ? [...relatedAccs]
-            .map((a) => UNIPROT_TO_SYMBOL[a] ?? a)
-            .sort()
-            .join("/")
-        : undefined;
-    return { primary, related, related_receptor };
+    return { primary, related };
 }
 /**
  * Classify why a candidate trial is considered relevant to the assessment.
@@ -804,10 +788,14 @@ export function classifyClinicalTrialConfidence(trial, geneSymbol, knownClassDru
         return "medium";
     return "low";
 }
-export async function assembleDiscoveryTrials(phase2, symbol, attrCtx, knownClassDrugNames) {
+/** Rows the section carries; a candidate set beyond it is reported as truncated. */
+const DISCOVERY_TRIAL_CAP = 100;
+/** What emptied the discovery-trials section when nothing survived. */
+const DISCOVERY_TRIALS_FILTER = "trial already carried by clinical_development.trials, attributed to a related family receptor, matched only by a generic condition string at low confidence, or attribution not eligible for toxicology aggregation";
+export async function assembleDiscoveryTrials(phase2, symbol, attrCtx, knownClassDrugNames, attachAttribution) {
     const ctgov = phase2.phase1.collectors.ctgov;
     if (ctgov.coverage !== "available")
-        return null;
+        return { coverage: "queried_no_data", error: { message: "ClinicalTrials.gov unavailable" } };
     const symU = symbol.toUpperCase();
     // Build a case-insensitive title-keyword regex from the target symbol and
     // common synonyms embedded in the assessment symbol name. For most targets
@@ -821,9 +809,7 @@ export async function assembleDiscoveryTrials(phase2, symbol, attrCtx, knownClas
         const inTitle = t.title.toUpperCase().includes(symU);
         return !(inInterventions || inTitle);
     });
-    if (candidates.length === 0)
-        return null;
-    const partitioned = await partitionTrialsByAttribution(candidates, attrCtx);
+    const partitioned = candidates.length > 0 ? await partitionTrialsByAttribution(candidates, attrCtx) : { primary: [], related: [] };
     // Classify each primary candidate's relevance basis and drop low-confidence
     // condition-only matches — these are wrong-class contaminants (e.g., an
     // SGLT2 trial picked up because it studies T2D while assessing GLP1R).
@@ -836,7 +822,7 @@ export async function assembleDiscoveryTrials(phase2, symbol, attrCtx, knownClas
             phase: t.phase,
             status: t.status,
             conditions: t.conditions,
-            // Convert null → undefined to match DiscoveryTrialRowV4Schema optional fields.
+            // Convert null → undefined to match DiscoveryTrialRowSchema optional fields.
             start_date: t.startDate ?? undefined,
             completion_date: t.primaryCompletionDate ?? undefined,
             match_confidence: t.match_confidence,
@@ -845,31 +831,29 @@ export async function assembleDiscoveryTrials(phase2, symbol, attrCtx, knownClas
     })
         .filter((row) => {
         // Drop low-confidence rows whose only basis is a generic condition string.
-        // These fail the DiscoveryTrialRowV4Schema superRefine invariant and must
+        // These fail the DiscoveryTrialRowSchema superRefine invariant and must
         // not reach the dossier.
         return !(row.match_confidence === "low" && row.relevance_basis.kind === "condition_match");
     });
-    const relatedRows = partitioned.related.map((t) => ({
-        nct_id: t.nctId,
-        title: t.title,
-        phase: t.phase,
-        status: t.status,
-        conditions: t.conditions,
-        start_date: t.startDate,
-        completion_date: t.primaryCompletionDate,
-        match_confidence: t.match_confidence,
-    }));
-    if (primaryRows.length === 0 && relatedRows.length === 0)
-        return null;
-    return {
-        rows: primaryRows.slice(0, 100),
-        ...(relatedRows.length > 0
-            ? {
-                related_target_trials: relatedRows,
-                related_receptor: partitioned.related_receptor,
-            }
-            : {}),
-    };
+    // Trials attributed to a related receptor rather than the assessed target
+    // are not discovery candidates at all, so they are not carried here.
+    const carried = primaryRows.slice(0, DISCOVERY_TRIAL_CAP);
+    const truncatedAway = primaryRows.length - carried.length;
+    const attributed = carried.map(attachAttribution);
+    const rows = attributed.filter((r) => r.eligible_for_toxicology_aggregation);
+    const section = coverageFromFilteredRows({
+        data: {
+            rows,
+            excluded_rows: attributed.filter((r) => !r.eligible_for_toxicology_aggregation),
+        },
+        retainedCount: rows.length,
+        // The cap is a carrying limit, not a judgement about a row, so it is
+        // reported as truncation rather than counted as a drop.
+        droppedCount: candidates.length - rows.length - truncatedAway,
+        filter: DISCOVERY_TRIALS_FILTER,
+        emptyReason: "every ClinicalTrials.gov record for the target is already carried by clinical_development.trials",
+    });
+    return truncatedAway > 0 && section.coverage === "available" ? { ...section, truncated: true } : section;
 }
 export function assembleEvidenceTimeline(phase2) {
     const pubmed = phase2.phase1.collectors.pubmedIndex;

package/dist/workflows/target-assessment/assemblers/orchestrator.d.ts

@@ -2,13 +2,21 @@
  * Phase-4 deterministic assemblers.
  *
  * Each assembler maps Phase-1 / Phase-2 / Phase-3 outputs onto the
- * corresponding dossier section schema. Coverage is honored end-to-end:
- * when an upstream came back `queried_no_data` or the derived row set is
- * empty, the section is marked `queried_no_data` / `not_loaded` rather
- * than fabricated. Aggregate rows preserve their contributing evidence
- * under `evidence: [...]` arrays.
+ * corresponding dossier section schema. Coverage is honored end-to-end: an
+ * upstream that came back empty or was never consulted yields
+ * `queried_no_data` / `not_loaded` rather than a fabricated section.
+ *
+ * Where a section applies a threshold of its own, the decision runs through
+ * `coverageFromFilteredRows` over both counts — what survived and what the
+ * threshold discarded — so a section our own filter emptied reports
+ * `filtered` rather than an `available` section holding nothing. Deciding
+ * coverage first and filtering the payload afterwards is the shape that loses
+ * that distinction.
+ *
+ * Aggregate rows preserve their contributing evidence under `evidence: [...]`
+ * arrays.
  */
-import type { DossierV4Body, Entity, TractabilityV4Section } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { DossierBody, Entity, TractabilitySection } from "@inflexa-ai/harness/contracts/target-dossier.js";
 import type { Phase2Bundle } from "../steps/phase2-aggregate.js";
 import type { Phase3Bundle } from "../steps/phase3-aggregate.js";
 import type { ResolvedTarget } from "../schemas.js";
@@ -36,7 +44,7 @@ export declare function enrichTractabilityModalitiesWithApprovals<M extends {
 }>(modalities: M[], drugs: DrugForTractability[]): (M & {
     approved_drug_ids?: string[];
 })[];
-export declare function assembleTractability(resolved: ResolvedTarget, ot: OpenTargetsCoverageResult, drugs: DrugForTractability[]): TractabilityV4Section;
+export declare function assembleTractability(resolved: ResolvedTarget, ot: OpenTargetsCoverageResult, drugs: DrugForTractability[]): TractabilitySection;
 /**
  * Build a body-only dossier from Phase-2 (and optionally Phase-3)
  * outputs. Synthesis-dependent fields stay `not_loaded` until Phase 5
@@ -44,7 +52,7 @@ export declare function assembleTractability(resolved: ResolvedTarget, ot: OpenT
  * attached here — phase5-persist computes it after synthesis is stamped
  * so the final derived values reflect liability bullets and safety flags.
  */
-export declare function assembleDossier(pool: Pool, phase2: Phase2Bundle, phase3?: Phase3Bundle, annotatorDeps?: ClinicalConsequenceAnnotatorDeps): Promise<DossierV4Body>;
+export declare function assembleDossier(pool: Pool, phase2: Phase2Bundle, phase3?: Phase3Bundle, annotatorDeps?: ClinicalConsequenceAnnotatorDeps): Promise<DossierBody>;
 type ReconcileFaersClassPrecedent = {
     coverage?: "available" | "queried_no_data" | "not_loaded";
     data?: {
@@ -91,7 +99,7 @@ type ReconcileFaersOutput = {
  *
  * When target-level FAERS has data (coverage: "available"), pass through
  * unchanged. When class_precedent has FAERS-derived reports in per_organ,
- * fold them into a class-scoped FaersSummaryV4 payload with
+ * fold them into a class-scoped FAERS summary payload with
  * coverage: "available" and inference_path tagged — rather than leaving
  * the section as queried_no_data, which creates an evidence conflict
  * that the conflict-detector flags. When neither has data, return