@inflexa-ai/harness 0.16.0 → 0.18.0

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

@@ -0,0 +1,419 @@
+/**
+ * The claim-investigation phase.
+ *
+ * Corroboration says which organs several sources agree on. Agreement is not
+ * adjudication: sources that all re-import one curation agree perfectly and are
+ * wrong together. This phase interrogates each corroborated organ claim —
+ * propose a mechanism, argue against it, re-verify, converge — and records what
+ * survived, plus every candidate it did not get to and why.
+ *
+ * Three LLM steps per round, chosen per step rather than uniformly:
+ *
+ *   - **propose** and **re-verify** are single-shot structured extractions
+ *     (`structuredLlmCall`). Everything they reason over is already in the
+ *     prompt; a retrieval surface would only let them ground an answer in
+ *     something the run never collected.
+ *   - **critique** is a real agent loop (`runToTerminal` over `runAgent`) with a
+ *     literature tool and a `defineTool` terminal recorder. Disconfirmation is a
+ *     search task: the dossier is assembled to state what the run found, not to
+ *     refute it, so a critic confined to it can only observe that the evidence
+ *     is thin — which is the rubber stamp this step exists to avoid.
+ *
+ * Nothing here scores a claim. The verdict is a four-word vocabulary the model
+ * states, no threshold decides survival, and no claim is removed from the
+ * dossier by anything this phase concludes.
+ *
+ * Durability arrives through the injected `runStep` seam and through
+ * `structuredLlmCall`'s own attempt-named steps; this module imports no
+ * durability engine.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { composeSystemPrompt } from "../../../agents/system-prompt.js";
+import { createNoopLogger } from "../../../lib/console-logger.js";
+import { runToTerminal } from "../../../loop/run-to-terminal.js";
+import { adversarialCritiquePrompt, claimReverificationBrief, mechanismProposalBrief } from "../../../prompts/target-assessment/investigation/index.js";
+import { defineTool } from "../../../tools/define-tool.js";
+import { forSubAgent } from "../../../auth/types.js";
+import { structuredLlmCall } from "../lib/structured-llm.js";
+export const DEFAULT_CLAIM_INVESTIGATION_CONFIG = {
+    claimBudget: 6,
+    roundBound: 2,
+    criticMaxIterations: 8,
+};
+function isBudgetCancel(value) {
+    return typeof value === "object" && value !== null && "kind" in value && value.kind === "budget-exceeded";
+}
+// ── The model-facing claim contract ──────────────────────────────────
+/**
+ * What a step is asked to return as support.
+ *
+ * Structurally the claim contract, minus the locator refinement — a refinement
+ * cannot be expressed in a tool input schema, so requiring it here would mean
+ * requiring it in prose and hoping. {@link resolveSupport} enforces it instead,
+ * at this producer's own boundary.
+ */
+const ModelEvidenceSchema = z.object({
+    source: z.string().min(1).describe("Which corpus or record set the evidence came from."),
+    pmid: z.string().optional().describe("PubMed identifier, digits only, of a record you actually read."),
+    doi: z.string().optional().describe("Digital object identifier of a record you actually read."),
+    accession: z.string().optional().describe("Database accession of a record you actually read."),
+    regulatory_reference: z
+        .object({
+        document: z.string().min(1).describe("The regulatory document, e.g. an NDA/BLA application number."),
+        section: z.string().optional().describe("The label section the statement came from."),
+    })
+        .optional()
+        .describe("Set only when the evidence is a regulatory document you were shown or retrieved."),
+    excerpt: z.string().optional().describe("Short quotation or paraphrase of what the record says."),
+});
+const ModelSupportSchema = z.discriminatedUnion("state", [
+    z.object({
+        state: z.literal("scored"),
+        evidence: z
+            .array(ModelEvidenceSchema)
+            .min(1)
+            .describe("Records supporting the claim. Each needs a pmid, doi, accession, or regulatory reference you retrieved."),
+    }),
+    z.object({
+        state: z.literal("unknown"),
+        reason: z.string().min(1).describe("One line saying why no record supports the claim. A complete, expected answer."),
+    }),
+]);
+/**
+ * Resolve model-supplied support onto the claim contract.
+ *
+ * Evidence naming only a source resolves to nothing a reader can check, so it is
+ * dropped; a scored claim left with no admissible evidence becomes `unknown`
+ * with a reason saying so. Degrading here rather than failing keeps a
+ * hallucinated citation from taking the whole assessment down at schema
+ * validation, and keeps the honest answer cheaper than the invented one.
+ */
+function resolveSupport(support) {
+    if (support.state === "unknown")
+        return { state: "unknown", reason: support.reason };
+    const admissible = support.evidence.filter((e) => Boolean(e.pmid ?? e.doi ?? e.accession ?? e.regulatory_reference));
+    if (admissible.length === 0) {
+        return { state: "unknown", reason: "the cited support named a source but carried no publication identifier, doi, accession, or regulatory reference" };
+    }
+    return { state: "scored", evidence: admissible };
+}
+// ── Step output schemas ──────────────────────────────────────────────
+const MechanismProposalOutputSchema = z.object({
+    mechanism: z.string().nullable().describe("How the target produces the liability in this organ. Null when the evidence supports none."),
+    support: ModelSupportSchema,
+});
+const CritiqueOutputSchema = z.object({
+    objection: z.string().min(1).describe("The concrete case against the claim. Not 'the evidence is limited'."),
+    support: ModelSupportSchema,
+});
+const ReverificationOutputSchema = z.object({
+    verdict: z.enum(["upheld", "weakened", "overturned", "undetermined"]).describe("What the record supports once the objection is weighed."),
+    support: ModelSupportSchema,
+});
+// ── Prompt payloads ──────────────────────────────────────────────────
+/**
+ * What a step is shown about the organ under investigation.
+ *
+ * The corroboration row already carries every contributing source, its signal,
+ * and the record it came from, so the claim's whole evidential basis travels as
+ * one value. The rollup row adds the assessment's own per-organ risk read.
+ */
+function claimContext(row, dossier) {
+    const rollup = dossier.safety_profile.organ_rollup;
+    const rollupRow = rollup.coverage === "available" ? rollup.data.rows.find((r) => r.organ === row.organ) : undefined;
+    return JSON.stringify({
+        target: dossier.entity.symbol,
+        organ: row.organ,
+        corroboration: {
+            corroborating_sources: row.corroborating_sources,
+            independent_source_count: row.independent_source_count,
+            contributions: row.contributions,
+        },
+        organ_rollup: rollupRow ?? null,
+    }, null, 2);
+}
+const PROPOSER_AGENT_ID = "claim-mechanism-proposer";
+const CRITIC_AGENT_ID = "claim-adversarial-critic";
+const VERIFIER_AGENT_ID = "claim-reverifier";
+async function proposeMechanism(row, dossier, round, priorObjection, { deps }) {
+    const prompt = [
+        `Propose a mechanism for the ${row.organ} liability of ${dossier.entity.symbol}.`,
+        "",
+        claimContext(row, dossier),
+        ...(priorObjection ? ["", "A previous round raised this objection. Answer it or revise the mechanism:", priorObjection] : []),
+    ].join("\n");
+    const result = await structuredLlmCall({
+        ...(deps.logger ? { logger: deps.logger } : {}),
+        stepName: `ta-investigate:propose:${row.organ}:${deps.attempt}:${round}`,
+        agentId: PROPOSER_AGENT_ID,
+        provider: deps.chatProvider,
+        session: forSubAgent(deps.session, PROPOSER_AGENT_ID),
+        system: composeSystemPrompt(mechanismProposalBrief),
+        prompt,
+        schema: MechanismProposalOutputSchema,
+        model: deps.model,
+        ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+    if (result.kind === "budget-exceeded")
+        return result;
+    const out = result.value;
+    if (out.mechanism === null || out.mechanism.trim().length === 0)
+        return { kind: "ok", value: null };
+    return { kind: "ok", value: { statement: out.mechanism, support: resolveSupport(out.support) } };
+}
+/**
+ * Namespace the critic loop's own step names.
+ *
+ * `runAgent` names its steps `llm-{i}` / `tool-{name}-{id}`, which are unique
+ * only within one run. Several claims are investigated concurrently and each
+ * runs several rounds, so without this every one of them would write into the
+ * same durable cache slots and replay another claim's answers.
+ */
+function criticStepNames(organ, attempt, round) {
+    const prefix = `ta-investigate:critique:${organ}:${attempt}:${round}`;
+    return {
+        llm: (i) => `${prefix}:llm-${i}`,
+        tool: (name, id) => `${prefix}:tool-${name}-${id}`,
+    };
+}
+async function critiqueClaim(row, dossier, mechanism, round, { deps, config }) {
+    // A mutable holder rather than a plain `let`: the cell is written from the
+    // tool's `execute` closure, which the compiler cannot see, so a bare local
+    // would still read as `null` at every use after the loop returns.
+    const cell = { recorded: null };
+    const recordCritique = defineTool({
+        id: "record_critique",
+        description: "Record your case against the claim and finish. Call exactly once, with the strongest objection you " +
+            "could build and the counter-evidence you actually retrieved. If you found no record that disconfirms " +
+            "the claim, record the objection with support state 'unknown' and a one-line reason — that is a " +
+            "complete answer, not a failure.",
+        inputSchema: CritiqueOutputSchema,
+        describeCall: ({ objection }) => objection,
+        executionMode: "inline",
+        execute: (input) => {
+            cell.recorded = input;
+            return Promise.resolve(ok({ recorded: true }));
+        },
+    });
+    const agent = {
+        id: CRITIC_AGENT_ID,
+        systemPrompt: composeSystemPrompt(adversarialCritiquePrompt),
+        model: deps.model,
+        tools: [...deps.critiqueTools, recordCritique],
+        maxIterations: config.criticMaxIterations,
+    };
+    const brief = [
+        `Argue that the ${row.organ} liability claim about ${dossier.entity.symbol} does not hold.`,
+        "",
+        "Proposed mechanism:",
+        mechanism.statement,
+        "",
+        "Evidence the assessment collected for this organ:",
+        claimContext(row, dossier),
+    ].join("\n");
+    const controller = new AbortController();
+    await runToTerminal(agent, [{ role: "user", content: brief }], forSubAgent(deps.session, CRITIC_AGENT_ID), {
+        provider: deps.chatProvider,
+        signal: deps.signal ?? controller.signal,
+        emit: () => { },
+        runStep: deps.runStep,
+        formatStepName: criticStepNames(row.organ, deps.attempt, round),
+        resolved: () => cell.recorded !== null,
+        ...(deps.logger ? { logger: deps.logger } : {}),
+        ...(deps.usageRecorder ? { usageRecorder: deps.usageRecorder } : {}),
+    }, {
+        tools: [recordCritique],
+        nudge: "You have not recorded a critique. Call `record_critique` now with the case you built; if you found no disconfirming record, use support state 'unknown' with a one-line reason.",
+    });
+    const outcome = cell.recorded;
+    if (outcome === null)
+        return null;
+    return { objection: outcome.objection, support: resolveSupport(outcome.support) };
+}
+async function reverifyClaim(row, dossier, mechanism, critique, round, { deps }) {
+    const prompt = [
+        `Re-verify the ${row.organ} liability claim about ${dossier.entity.symbol}.`,
+        "",
+        "Proposed mechanism:",
+        mechanism.statement,
+        "",
+        "Objection raised against it:",
+        critique.objection,
+        "",
+        "Counter-evidence offered with the objection:",
+        JSON.stringify(critique.support, null, 2),
+        "",
+        "Evidence the assessment collected for this organ:",
+        claimContext(row, dossier),
+    ].join("\n");
+    const result = await structuredLlmCall({
+        ...(deps.logger ? { logger: deps.logger } : {}),
+        stepName: `ta-investigate:reverify:${row.organ}:${deps.attempt}:${round}`,
+        agentId: VERIFIER_AGENT_ID,
+        provider: deps.chatProvider,
+        session: forSubAgent(deps.session, VERIFIER_AGENT_ID),
+        system: composeSystemPrompt(claimReverificationBrief),
+        prompt,
+        schema: ReverificationOutputSchema,
+        model: deps.model,
+        ...(deps.signal ? { signal: deps.signal } : {}),
+    });
+    if (result.kind === "budget-exceeded")
+        return result;
+    return { kind: "ok", value: { verdict: result.value.verdict, support: resolveSupport(result.value.support) } };
+}
+/**
+ * Investigate one organ claim to convergence.
+ *
+ * The loop stops on the first of three conditions: a terminal verdict, a verdict
+ * that repeats the previous round's, or the configured round bound. Critiques
+ * are keyed by organ, so a later round's objection replaces the earlier one it
+ * was written in answer to.
+ */
+async function investigateOneClaim(row, dossier, stepDeps) {
+    const logger = (stepDeps.deps.logger ?? createNoopLogger()).named("ta-claim-investigation").with({ organ: row.organ });
+    let mechanism = null;
+    let critique = null;
+    let verdict = null;
+    let previousVerdict = null;
+    let support = { state: "unknown", reason: "the investigation recorded no verdict support" };
+    let convergence = "round_bound_reached";
+    let roundsRun = 0;
+    for (let round = 1; round <= stepDeps.config.roundBound; round += 1) {
+        roundsRun = round;
+        let proposed;
+        try {
+            proposed = await proposeMechanism(row, dossier, round, critique?.objection ?? null, stepDeps);
+        }
+        catch (err) {
+            logger.warn("mechanism proposal failed", { round, ...logger.errorFields(err) });
+            return { kind: "unavailable", organ: row.organ, detail: `mechanism proposal failed: ${messageOf(err)}` };
+        }
+        if (proposed.kind === "budget-exceeded")
+            return proposed;
+        if (proposed.value === null) {
+            return { kind: "unavailable", organ: row.organ, detail: "no mechanism was proposable from the evidence collected for this organ" };
+        }
+        mechanism = proposed.value;
+        let rounded;
+        try {
+            rounded = await critiqueClaim(row, dossier, mechanism, round, stepDeps);
+        }
+        catch (err) {
+            logger.warn("adversarial critique failed", { round, ...logger.errorFields(err) });
+            return { kind: "unavailable", organ: row.organ, detail: `adversarial critique failed: ${messageOf(err)}` };
+        }
+        if (rounded === null) {
+            // A verdict reached without the adversarial step is the rubber stamp
+            // this phase exists to avoid, so the claim goes uninvestigated rather
+            // than acquiring an unchallenged verdict.
+            return { kind: "unavailable", organ: row.organ, detail: "the adversarial critic recorded no objection" };
+        }
+        critique = rounded;
+        let verified;
+        try {
+            verified = await reverifyClaim(row, dossier, mechanism, critique, round, stepDeps);
+        }
+        catch (err) {
+            logger.warn("re-verification failed", { round, ...logger.errorFields(err) });
+            return { kind: "unavailable", organ: row.organ, detail: `re-verification failed: ${messageOf(err)}` };
+        }
+        if (verified.kind === "budget-exceeded")
+            return verified;
+        verdict = verified.value.verdict;
+        support = verified.value.support;
+        if (verdict === "upheld" || verdict === "overturned") {
+            convergence = "verdict_terminal";
+            break;
+        }
+        if (verdict === previousVerdict) {
+            convergence = "verdict_settled";
+            break;
+        }
+        previousVerdict = verdict;
+    }
+    if (verdict === null || mechanism === null) {
+        return { kind: "unavailable", organ: row.organ, detail: "the investigation completed no round" };
+    }
+    return {
+        kind: "investigated",
+        row: {
+            organ: row.organ,
+            mechanism,
+            critique,
+            verdict,
+            rounds_run: roundsRun,
+            convergence,
+            support,
+        },
+    };
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+// ── The phase ────────────────────────────────────────────────────────
+/**
+ * Interrogate the run's corroborated organ claims.
+ *
+ * Coverage is the honest account of what happened: `not_loaded` when there was
+ * no corroboration record to work from, `queried_no_data` when the fold produced
+ * no corroborated organ, and `available` once at least one candidate reached the
+ * phase — including when every one of them ended up in `not_investigated`, since
+ * that list is what the section has to say in that case.
+ */
+export async function investigateClaims(input, deps) {
+    const config = { ...DEFAULT_CLAIM_INVESTIGATION_CONFIG, ...deps.config };
+    const bounds = { round_bound: config.roundBound, claim_budget: config.claimBudget };
+    if (input.corroboration.coverage === "not_loaded") {
+        return { coverage: "not_loaded", reason: "no corroboration record was assembled for this run" };
+    }
+    const candidates = input.corroboration.coverage === "available" ? input.corroboration.data.rows : [];
+    if (candidates.length === 0) {
+        return { coverage: "queried_no_data", error: { message: "no corroborated organ claim reached the investigation" } };
+    }
+    const admitted = candidates.slice(0, config.claimBudget);
+    const notInvestigated = candidates.slice(config.claimBudget).map((row) => ({
+        organ: row.organ,
+        reason: "exceeded_claim_budget",
+        detail: `the run investigates at most ${config.claimBudget} corroborated claims; this one ranked below that`,
+    }));
+    // Organs the assessment's own per-organ risk read carries, which the
+    // corroboration fold never admitted. They are candidates a reader would
+    // expect to see interrogated, so their absence is stated rather than left
+    // to be noticed.
+    const corroboratedOrgans = new Set(candidates.map((r) => r.organ));
+    const rollup = input.dossier.safety_profile.organ_rollup;
+    if (rollup.coverage === "available") {
+        for (const rollupRow of rollup.data.rows) {
+            if (corroboratedOrgans.has(rollupRow.organ))
+                continue;
+            notInvestigated.push({
+                organ: rollupRow.organ,
+                reason: "not_corroborated",
+                detail: "the per-organ risk rollup carries this organ, but fewer independent sources corroborated it than the fold requires",
+            });
+        }
+    }
+    const outcomes = await Promise.all(admitted.map((row) => investigateOneClaim(row, input.dossier, { deps, config })));
+    const cancelled = outcomes.find(isBudgetCancel);
+    if (cancelled)
+        return cancelled;
+    const rows = [];
+    for (const outcome of outcomes) {
+        if (outcome.kind === "investigated")
+            rows.push(outcome.row);
+        else if (outcome.kind === "unavailable") {
+            notInvestigated.push({ organ: outcome.organ, reason: "investigation_unavailable", detail: outcome.detail });
+        }
+    }
+    rows.sort((a, b) => a.organ.localeCompare(b.organ));
+    notInvestigated.sort((a, b) => a.organ.localeCompare(b.organ) || a.reason.localeCompare(b.reason));
+    const droppedByBudget = candidates.length - admitted.length;
+    return {
+        coverage: "available",
+        data: { rows, not_investigated: notInvestigated, ...bounds },
+        ...(droppedByBudget > 0 ? { dropped_count: droppedByBudget } : {}),
+    };
+}
+export { isBudgetCancel as isClaimInvestigationBudgetExceeded };

package/dist/workflows/target-assessment/lib/approval-precedents.d.ts

@@ -6,8 +6,18 @@
  * before synthesis so the fetched precedents can be injected into the synthesis
  * prompts as a static markdown block. The fetch, in-memory TTL cache, and
  * mapping mirror what a per-turn tool would have done, minus the tool wrapper.
+ *
+ * One fetch produces one typed form: each precedent keeps its label's safety
+ * sections as `LabelSafetyText`. The markdown block is a projection of that
+ * form, not a replacement for it — the same sections also project onto
+ * per-organ regulatory signals via `segmentLabelSafety`.
+ *
+ * The lookup is cached in-process through the shared `BoundedTtlCache`: two
+ * assessments in the same therapeutic area ask openFDA the same question, and
+ * the answer moves on the scale of a label revision, not a run.
  */
-import type { DossierV4Body } from "../../../contracts/target-dossier.js";
+import type { DossierBody } from "../../../contracts/target-dossier.js";
+import { type FdaLabelSafety, type LabelSafetyText } from "./fda-label-safety.js";
 export type PrecedentModality = "small_molecule" | "biologic" | "gene_therapy" | "cell_therapy";
 export interface FetchApprovalPrecedentsInput {
     indication: string;
@@ -15,11 +25,12 @@ export interface FetchApprovalPrecedentsInput {
     mechanism?: string;
 }
 export interface Precedent {
-    application_number: string;
+    /** Null when openFDA published the label without one; such a label cannot be cited. */
+    application_number: string | null;
     brand_name?: string;
     generic_name?: string;
     approval_date?: string;
-    label_section_excerpts?: Record<string, string>;
+    safety_sections: LabelSafetyText[];
 }
 /**
  * Query openFDA for prior approvals in a given indication. Returns
@@ -34,18 +45,28 @@ export interface Precedent {
 export declare function fetchApprovalPrecedents(input: FetchApprovalPrecedentsInput): Promise<{
     precedents: Precedent[];
 }>;
-/** Test-only — clears the in-memory cache to avoid cross-test bleed. */
+/** Test-only — drops the in-memory cache to avoid cross-test bleed. */
 export declare function __resetApprovalPrecedentCacheForTest(): void;
 /**
  * Pick the openFDA query term for a Phase-4 dossier: the top `indications`
  * row by `composite_score` (only when indications coverage is available and
  * has rows), falling back to the inferred therapeutic area, else null.
  */
-export declare function pickIndicationForPrecedents(dossier: DossierV4Body): string | null;
+export declare function pickIndicationForPrecedents(dossier: DossierBody): string | null;
+/**
+ * Project the fetched precedents onto the typed label form the per-organ
+ * segmentation reads. A label without an application number is skipped: its
+ * signals would carry no locator, and an unciteable signal is not evidence.
+ */
+export declare function precedentLabelSafety(precedents: readonly Precedent[]): FdaLabelSafety[];
 /**
  * Render the fetched precedents as a markdown block for injection into the
  * synthesis prompts. The block always begins with the `## FDA approval
  * precedents` header, which the synthesis briefs reference verbatim.
+ *
+ * Synthesis is a single-shot forced-`submit` call that can reach no tool, so
+ * this block is the whole of what the model gets: a plain string, no citation
+ * the model is expected to resolve itself.
  */
 export declare function renderApprovalPrecedents(indication: string | null, result: {
     precedents: Precedent[];

package/dist/workflows/target-assessment/lib/approval-precedents.js

@@ -6,9 +6,50 @@
  * before synthesis so the fetched precedents can be injected into the synthesis
  * prompts as a static markdown block. The fetch, in-memory TTL cache, and
  * mapping mirror what a per-turn tool would have done, minus the tool wrapper.
+ *
+ * One fetch produces one typed form: each precedent keeps its label's safety
+ * sections as `LabelSafetyText`. The markdown block is a projection of that
+ * form, not a replacement for it — the same sections also project onto
+ * per-organ regulatory signals via `segmentLabelSafety`.
+ *
+ * The lookup is cached in-process through the shared `BoundedTtlCache`: two
+ * assessments in the same therapeutic area ask openFDA the same question, and
+ * the answer moves on the scale of a label revision, not a run.
  */
-const cache = new Map();
+import { BoundedTtlCache } from "../../../lib/cache.js";
+import { LABEL_SAFETY_SECTIONS } from "./fda-label-safety.js";
+/** Per-block ingest budget — enough prose to segment, bounded for the step cache. */
+const SECTION_INGEST_CHARS = 4000;
+/** Per-section budget in the rendered markdown, which rides in every synthesis prompt. */
+const SECTION_RENDER_CHARS = 1000;
+function ingestSafetySections(r) {
+    const sections = [];
+    const push = (section, blocks) => {
+        for (const block of blocks ?? []) {
+            const text = block.trim();
+            if (text.length === 0)
+                continue;
+            sections.push({ section, text: text.slice(0, SECTION_INGEST_CHARS) });
+        }
+    };
+    push("boxed_warning", r.boxed_warning);
+    // Current labels publish Section 5 as `warnings_and_precautions`; older ones
+    // publish the same prose as `warnings`. Ingesting both files it twice.
+    if (r.warnings_and_precautions?.length)
+        push("warnings_and_precautions", r.warnings_and_precautions);
+    else
+        push("warnings", r.warnings);
+    push("contraindications", r.contraindications);
+    return sections;
+}
 const TTL_MS = 60 * 60 * 1000;
+/**
+ * One entry per (indication, modality, mechanism) an assessment resolves, and a
+ * host serves many assessments from one process — hence a bound, not a Map that
+ * only ever grows.
+ */
+const CACHE_MAXIMUM = 64;
+let cache = new BoundedTtlCache(CACHE_MAXIMUM);
 /**
  * Query openFDA for prior approvals in a given indication. Returns
  * NDA/BLA application numbers, generic and brand names, approval dates
@@ -27,8 +68,8 @@ export async function fetchApprovalPrecedents(input) {
         mechanism,
     });
     const cached = cache.get(key);
-    if (cached && Date.now() - cached.ts < TTL_MS)
-        return cached.value;
+    if (cached)
+        return cached;
     const term = indication.replace(/"/g, "");
     const url = new URL("https://api.fda.gov/drug/label.json");
     url.searchParams.set("search", `indications_and_usage:"${term}"`);
@@ -40,31 +81,20 @@ export async function fetchApprovalPrecedents(input) {
         throw new Error(`openFDA label query failed: HTTP ${res.status}`);
     }
     const json = (await res.json());
-    const precedents = (json.results ?? []).slice(0, 10).map((r) => {
-        const excerpts = {};
-        if (r.boxed_warning?.[0])
-            excerpts.boxed_warning = r.boxed_warning[0].slice(0, 1000);
-        if (r.warnings_and_precautions?.[0])
-            excerpts.warnings_and_precautions = r.warnings_and_precautions[0].slice(0, 1000);
-        else if (r.warnings?.[0])
-            excerpts.warnings = r.warnings[0].slice(0, 1000);
-        if (r.contraindications?.[0])
-            excerpts.contraindications = r.contraindications[0].slice(0, 1000);
-        return {
-            application_number: r.openfda?.application_number?.[0] ?? "(unknown)",
-            brand_name: r.openfda?.brand_name?.[0],
-            generic_name: r.openfda?.generic_name?.[0],
-            approval_date: r.effective_time,
-            label_section_excerpts: Object.keys(excerpts).length > 0 ? excerpts : undefined,
-        };
-    });
+    const precedents = (json.results ?? []).slice(0, 10).map((r) => ({
+        application_number: r.openfda?.application_number?.[0] ?? null,
+        brand_name: r.openfda?.brand_name?.[0],
+        generic_name: r.openfda?.generic_name?.[0],
+        approval_date: r.effective_time,
+        safety_sections: ingestSafetySections(r),
+    }));
     const value = { precedents };
-    cache.set(key, { ts: Date.now(), value });
+    cache.set(key, value, TTL_MS);
     return value;
 }
-/** Test-only — clears the in-memory cache to avoid cross-test bleed. */
+/** Test-only — drops the in-memory cache to avoid cross-test bleed. */
 export function __resetApprovalPrecedentCacheForTest() {
-    cache.clear();
+    cache = new BoundedTtlCache(CACHE_MAXIMUM);
 }
 /**
  * Pick the openFDA query term for a Phase-4 dossier: the top `indications`
@@ -80,10 +110,47 @@ export function pickIndicationForPrecedents(dossier) {
     }
     return dossier.liability_summary.inferred_therapeutic_area ?? null;
 }
+/**
+ * Project the fetched precedents onto the typed label form the per-organ
+ * segmentation reads. A label without an application number is skipped: its
+ * signals would carry no locator, and an unciteable signal is not evidence.
+ */
+export function precedentLabelSafety(precedents) {
+    const labels = [];
+    for (const p of precedents) {
+        if (p.application_number === null || p.safety_sections.length === 0)
+            continue;
+        labels.push({
+            application_number: p.application_number,
+            drug_name: p.generic_name ?? p.brand_name ?? p.application_number,
+            effective_time: p.approval_date,
+            sections: p.safety_sections,
+        });
+    }
+    return labels;
+}
+/**
+ * The prose a reader meets for one section: the longest block published under
+ * it. openFDA returns both the highlights summary and the full section under
+ * the same key, and the full section is the one worth grounding on.
+ */
+function renderableSections(precedent) {
+    const longest = new Map();
+    for (const { section, text } of precedent.safety_sections) {
+        const current = longest.get(section);
+        if (current === undefined || text.length > current.length)
+            longest.set(section, text);
+    }
+    return LABEL_SAFETY_SECTIONS.filter((section) => longest.has(section)).map((section) => [section, longest.get(section).slice(0, SECTION_RENDER_CHARS)]);
+}
 /**
  * Render the fetched precedents as a markdown block for injection into the
  * synthesis prompts. The block always begins with the `## FDA approval
  * precedents` header, which the synthesis briefs reference verbatim.
+ *
+ * Synthesis is a single-shot forced-`submit` call that can reach no tool, so
+ * this block is the whole of what the model gets: a plain string, no citation
+ * the model is expected to resolve itself.
  */
 export function renderApprovalPrecedents(indication, result) {
     const header = "## FDA approval precedents";
@@ -108,11 +175,10 @@ export function renderApprovalPrecedents(indication, result) {
         const generic = p.generic_name ?? "unknown generic";
         const brand = p.brand_name ?? "unknown brand";
         const date = p.approval_date ?? "unknown date";
-        lines.push(`- ${generic} (${brand}), ${p.application_number}, approved ${date}`);
-        if (p.label_section_excerpts) {
-            for (const [section, excerpt] of Object.entries(p.label_section_excerpts)) {
-                lines.push(`  - ${section}: ${excerpt}`);
-            }
+        const application = p.application_number ?? "unknown application number";
+        lines.push(`- ${generic} (${brand}), ${application}, approved ${date}`);
+        for (const [section, excerpt] of renderableSections(p)) {
+            lines.push(`  - ${section}: ${excerpt}`);
         }
     }
     return lines.join("\n");

package/dist/workflows/target-assessment/lib/citation-validator.js

@@ -280,7 +280,7 @@ export function validateRecommendationCitations(rec, dossier) {
             }
         }
     }
-    const organLiabilities = dossierView?.safety_profile?.target_organ_liabilities ?? [];
+    const organLiabilities = dossierView?.safety_profile?.target_organ_liabilities?.data?.rows ?? [];
     const tolOrgans = new Set(organLiabilities
         .map((t) => String(t?.organ ?? "")
         .toLowerCase()