@inflexa-ai/harness 0.35.8 → 0.36.0

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

@@ -1,419 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-/**
- * Approval-precedent grounding for Phase-5 synthesis.
- *
- * Synthesis runs single-shot forced-`submit` LLM calls and can therefore call
- * no tool. This module does the openFDA / Drugs@FDA lookup deterministically
- * 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 { 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;
-    modality?: PrecedentModality;
-    mechanism?: string;
-}
-export interface Precedent {
-    /** 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;
-    safety_sections: LabelSafetyText[];
-}
-/**
- * Query openFDA for prior approvals in a given indication. Returns
- * NDA/BLA application numbers, generic and brand names, approval dates
- * (label effective time), and label-section excerpts.
- *
- * openFDA answers a zero-match search with 404 — an expected "no precedents"
- * outcome, returned uncached so a later, more specific query is not masked.
- * Any other non-ok status (5xx, 429) is an unexpected failure and throws; the
- * caller wraps the throw.
- */
-export declare function fetchApprovalPrecedents(input: FetchApprovalPrecedentsInput): Promise<{
-    precedents: Precedent[];
-}>;
-/** 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: 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[];
-} | null): string;

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

@@ -1,185 +0,0 @@
-/**
- * Approval-precedent grounding for Phase-5 synthesis.
- *
- * Synthesis runs single-shot forced-`submit` LLM calls and can therefore call
- * no tool. This module does the openFDA / Drugs@FDA lookup deterministically
- * 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 { 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
- * (label effective time), and label-section excerpts.
- *
- * openFDA answers a zero-match search with 404 — an expected "no precedents"
- * outcome, returned uncached so a later, more specific query is not masked.
- * Any other non-ok status (5xx, 429) is an unexpected failure and throws; the
- * caller wraps the throw.
- */
-export async function fetchApprovalPrecedents(input) {
-    const { indication, modality, mechanism } = input;
-    const key = JSON.stringify({
-        indication: indication.toLowerCase(),
-        modality,
-        mechanism,
-    });
-    const cached = cache.get(key);
-    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}"`);
-    url.searchParams.set("limit", "10");
-    const res = await fetch(url);
-    if (res.status === 404)
-        return { precedents: [] };
-    if (!res.ok) {
-        throw new Error(`openFDA label query failed: HTTP ${res.status}`);
-    }
-    const json = (await res.json());
-    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, value, TTL_MS);
-    return value;
-}
-/** Test-only — drops the in-memory cache to avoid cross-test bleed. */
-export function __resetApprovalPrecedentCacheForTest() {
-    cache = new BoundedTtlCache(CACHE_MAXIMUM);
-}
-/**
- * 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 function pickIndicationForPrecedents(dossier) {
-    const indications = dossier.indications;
-    if (indications.coverage === "available" && indications.data.rows.length > 0) {
-        const top = indications.data.rows.reduce((best, row) => (row.composite_score > best.composite_score ? row : best));
-        if (top.disease_name)
-            return top.disease_name;
-    }
-    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";
-    if (indication === null) {
-        return [header, "", "No indication could be resolved from the dossier, so no FDA approval precedents were queried."].join("\n");
-    }
-    const precedents = result?.precedents ?? [];
-    if (precedents.length === 0) {
-        return [
-            header,
-            "",
-            `No FDA approval precedents were found for "${indication}". Do not assert class precedents that are not present in the dossier.`,
-        ].join("\n");
-    }
-    const lines = [
-        header,
-        "",
-        `Prior FDA approvals retrieved for "${indication}". Ground class-precedent and disposition claims in these records; do not invent precedents beyond this list and the dossier.`,
-        "",
-    ];
-    for (const p of precedents) {
-        const generic = p.generic_name ?? "unknown generic";
-        const brand = p.brand_name ?? "unknown brand";
-        const date = p.approval_date ?? "unknown date";
-        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");
-}