@inflexa-ai/harness 0.35.8 → 0.36.1

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

@@ -1,86 +0,0 @@
-/**
- * Shared coverage discriminator for target-assessment workflow steps.
- *
- * Per design §6, every collector / decision / fan-out / synthesis step
- * MUST wrap its body in try/catch and return a `{ coverage, ... }` shape
- * instead of throwing. Only Phase 0 (target resolution) is allowed to
- * throw — that legitimately aborts the workflow.
- *
- * `CoverageSchema` in `contracts/target-dossier.ts` is the one enumeration of
- * the coverage states, and the helpers below emit its members. A step envelope
- * carries the three states a step can reach on its own; `filtered` is a
- * judgement one of our own filters makes, so only the assembler helpers below
- * produce it.
- */
-import { z } from "zod";
-export const SerializedErrorSchema = z.object({
-    message: z.string(),
-    name: z.string().optional(),
-    stack: z.string().optional(),
-});
-/**
- * Build the schema for a `{ coverage, data, error? }` step output.
- *
- * Use as: `outputSchema: withCoverage(MyDataSchema)` where `MyDataSchema`
- * is the shape of the Phase-1 / Phase-2 / etc. payload for this step.
- */
-export function withCoverage(dataSchema) {
-    return z.discriminatedUnion("coverage", [
-        z.object({
-            coverage: z.literal("available"),
-            data: dataSchema,
-        }),
-        z.object({
-            coverage: z.literal("queried_no_data"),
-            error: SerializedErrorSchema.optional(),
-        }),
-        z.object({
-            coverage: z.literal("not_loaded"),
-            reason: z.string().optional(),
-        }),
-    ]);
-}
-/**
- * Convenience wrapper for `{ rows: T[] }` payloads. Maps an empty rows
- * array to `coverage: "queried_no_data"` so the dossier discriminator's
- * "available ≡ we have data" invariant holds without per-callsite
- * length checks. Use at any assembler callsite that emits a `rows`
- * shape from a query that may legitimately return zero items.
- */
-export function coverageFromRows(rows, opts) {
-    if (rows.length === 0) {
-        return {
-            coverage: "queried_no_data",
-            error: { message: opts?.reason ?? "no rows returned" },
-        };
-    }
-    return { coverage: "available", data: { rows } };
-}
-/**
- * Build a dossier-section envelope for a row list one of our own filters
- * narrowed.
- *
- * A filter is not the same as an empty upstream, and the difference is the
- * whole point of the four-state contract. Deciding coverage from the source
- * and then filtering the payload loses it: a section whose every row our
- * threshold discarded reports a clean `available` holding nothing, which reads
- * as "the source had nothing to say".
- *
- * So the decision is made once, from both counts:
- *   - nothing survived and something was dropped → `filtered`, naming the
- *     filter and the count it discarded, with no `data`;
- *   - some survived and some were dropped → `available` carrying
- *     `dropped_count`, so the section does not overstate its completeness;
- *   - nothing survived and nothing was dropped → `queried_no_data`: the list
- *     was empty before any filter of ours ran.
- */
-export function coverageFromFilteredRows(args) {
-    const { data, retainedCount, droppedCount, filter, emptyReason } = args;
-    if (retainedCount > 0) {
-        return droppedCount > 0 ? { coverage: "available", data, dropped_count: droppedCount } : { coverage: "available", data };
-    }
-    if (droppedCount > 0) {
-        return { coverage: "filtered", filter, dropped_count: droppedCount };
-    }
-    return { coverage: "queried_no_data", error: { message: emptyReason } };
-}

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

@@ -1,86 +0,0 @@
-/**
- * Phase-2 decision functions for the harness DBOS workflow.
- *
- * `modulatorTriage` selects up to 8 ChEMBL modulators for downstream
- * fan-out; `drugsInClass` identifies clinically-advanced drugs in the
- * class. Both are single-shot, structured-output LLM calls — no tools,
- * no multi-step reasoning. Each function is `(input, deps) => Promise<CoverageEnvelope<...>>`.
- *
- * Coverage envelope is the failure mode: an LLM throw (non-402) → the
- * function returns `coverage: "queried_no_data"`. A billing-gateway 402 reaches
- * here as a `RunLlmStepResult` with `kind: "budget-exceeded"`; the caller
- * stops scheduling because the workflow has self-cancelled.
- */
-import { z } from "zod";
-import type { AgentSession } from "../../../auth/types.js";
-import type { AgentChat } from "../../../providers/types.js";
-import type { Phase1Bundle } from "../schemas.js";
-import { BUDGET_EXCEEDED_SENTINEL } from "../lib/llm-step.js";
-export declare const ModulatorTriageOutputSchema: z.ZodObject<{
-    shortlist: z.ZodArray<z.ZodObject<{
-        moleculeChemblId: z.ZodString;
-        preferredName: z.ZodString;
-        maxPhase: z.ZodNullable<z.ZodNumber>;
-        firstApproval: z.ZodNullable<z.ZodNumber>;
-        rationale: z.ZodString;
-    }, z.core.$strip>>;
-    notes: z.ZodString;
-    dropped_synonyms: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        chemblId: z.ZodString;
-        reason: z.ZodEnum<{
-            same_active_substance: "same_active_substance";
-            ambiguous_name_synonym: "ambiguous_name_synonym";
-        }>;
-        keptId: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export type ModulatorTriageOutput = z.infer<typeof ModulatorTriageOutputSchema>;
-export declare const DrugsInClassOutputSchema: z.ZodObject<{
-    drugs: z.ZodArray<z.ZodObject<{
-        moleculeChemblId: z.ZodString;
-        preferredName: z.ZodString;
-        maxPhase: z.ZodNullable<z.ZodNumber>;
-        firstApproval: z.ZodNullable<z.ZodNumber>;
-        moleculeType: z.ZodNullable<z.ZodString>;
-        sources: z.ZodArray<z.ZodEnum<{
-            dgidb: "dgidb";
-            drugbank: "drugbank";
-            chembl: "chembl";
-        }>>;
-    }, z.core.$strip>>;
-    total: z.ZodNumber;
-    truncated: z.ZodBoolean;
-}, z.core.$strip>;
-export type DrugsInClassOutput = z.infer<typeof DrugsInClassOutputSchema>;
-interface CoverageAvailable<T> {
-    readonly coverage: "available";
-    readonly data: T;
-}
-interface CoverageQueriedNoData {
-    readonly coverage: "queried_no_data";
-    readonly error?: {
-        message: string;
-    };
-}
-type CoverageEnvelope<T> = CoverageAvailable<T> | CoverageQueriedNoData;
-export interface DecisionAgentDeps {
-    readonly chatProvider: AgentChat;
-    readonly session: AgentSession;
-    /** Billing-gateway model id — e.g. `env.TARGET_ASSESSMENT_DECISION_MODEL`. */
-    readonly model: string;
-    /** Attempt counter — bumped on resume so a 402-cancelled call lands a fresh DBOS step slot. */
-    readonly attempt: number;
-}
-export type ModulatorTriageResult = CoverageEnvelope<ModulatorTriageOutput & {
-    dropped_synonyms?: unknown;
-}> | {
-    readonly kind: "budget-exceeded";
-    readonly sentinel: typeof BUDGET_EXCEEDED_SENTINEL;
-};
-export declare function modulatorTriage(input: Phase1Bundle, deps: DecisionAgentDeps): Promise<ModulatorTriageResult>;
-export type DrugsInClassResult = CoverageEnvelope<DrugsInClassOutput> | {
-    readonly kind: "budget-exceeded";
-    readonly sentinel: typeof BUDGET_EXCEEDED_SENTINEL;
-};
-export declare function drugsInClass(input: Phase1Bundle, deps: DecisionAgentDeps): Promise<DrugsInClassResult>;
-export {};

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

@@ -1,127 +0,0 @@
-/**
- * Phase-2 decision functions for the harness DBOS workflow.
- *
- * `modulatorTriage` selects up to 8 ChEMBL modulators for downstream
- * fan-out; `drugsInClass` identifies clinically-advanced drugs in the
- * class. Both are single-shot, structured-output LLM calls — no tools,
- * no multi-step reasoning. Each function is `(input, deps) => Promise<CoverageEnvelope<...>>`.
- *
- * Coverage envelope is the failure mode: an LLM throw (non-402) → the
- * function returns `coverage: "queried_no_data"`. A billing-gateway 402 reaches
- * here as a `RunLlmStepResult` with `kind: "budget-exceeded"`; the caller
- * stops scheduling because the workflow has self-cancelled.
- */
-import { z } from "zod";
-import { drugsInClassPrompt } from "../../../prompts/target-assessment/drugs-in-class.js";
-import { modulatorTriagePrompt } from "../../../prompts/target-assessment/modulator-triage.js";
-import { dedupModulatorsByParent } from "../lib/dedup-modulators.js";
-import { structuredLlmCall } from "../lib/structured-llm.js";
-// ── Output schemas ────────────────────────────────────────────────────
-export const ModulatorTriageOutputSchema = z.object({
-    shortlist: z.array(z.object({
-        moleculeChemblId: z.string(),
-        preferredName: z.string(),
-        maxPhase: z.number().nullable(),
-        firstApproval: z.number().nullable(),
-        rationale: z.string(),
-    })),
-    notes: z.string(),
-    dropped_synonyms: z
-        .array(z.object({
-        chemblId: z.string(),
-        reason: z.enum(["same_active_substance", "ambiguous_name_synonym"]),
-        keptId: z.string().nullable(),
-    }))
-        .default([]),
-});
-export const DrugsInClassOutputSchema = z.object({
-    drugs: z.array(z.object({
-        moleculeChemblId: z.string(),
-        preferredName: z.string(),
-        maxPhase: z.number().nullable(),
-        firstApproval: z.number().nullable(),
-        moleculeType: z.string().nullable(),
-        sources: z.array(z.enum(["chembl", "dgidb", "drugbank"])),
-    })),
-    total: z.number(),
-    truncated: z.boolean(),
-});
-function fail(message) {
-    return { coverage: "queried_no_data", error: { message } };
-}
-function failFromErr(err) {
-    return fail(err instanceof Error ? err.message : String(err));
-}
-export async function modulatorTriage(input, deps) {
-    const modulators = input.collectors.chemblModulators;
-    if (modulators.coverage !== "available" || modulators.data.modulators.length === 0) {
-        return fail("no modulators to triage");
-    }
-    const { kept, dropped } = dedupModulatorsByParent(modulators.data.modulators);
-    if (kept.length === 0) {
-        return fail("no modulators after dedup");
-    }
-    const prompt = [
-        `Target: ${input.resolved.geneSymbol} (${input.resolved.canonicalId})`,
-        `ChEMBL target id: ${modulators.data.targetChemblId ?? "unknown"}`,
-        ``,
-        `Modulators (${kept.length}, deduped from ${modulators.data.modulators.length}):`,
-        JSON.stringify(kept, null, 2),
-    ].join("\n");
-    try {
-        const result = await structuredLlmCall({
-            stepName: `ta-decision:modulator-triage:${deps.attempt}`,
-            agentId: "modulator-triage",
-            provider: deps.chatProvider,
-            session: deps.session,
-            system: modulatorTriagePrompt,
-            prompt,
-            schema: ModulatorTriageOutputSchema,
-            model: deps.model,
-        });
-        if (result.kind === "budget-exceeded") {
-            return { kind: "budget-exceeded", sentinel: result.sentinel };
-        }
-        return {
-            coverage: "available",
-            data: { ...result.value, dropped_synonyms: dropped },
-        };
-    }
-    catch (err) {
-        return failFromErr(err);
-    }
-}
-export async function drugsInClass(input, deps) {
-    const modulators = input.collectors.chemblModulators;
-    if (modulators.coverage !== "available" || modulators.data.modulators.length === 0) {
-        return fail("no modulators in class");
-    }
-    const { kept } = dedupModulatorsByParent(modulators.data.modulators);
-    if (kept.length === 0) {
-        return fail("no modulators after dedup");
-    }
-    const prompt = [
-        `Target: ${input.resolved.geneSymbol}`,
-        `ChEMBL modulators (max_phase ≥ 2, deduped by active substance):`,
-        JSON.stringify(kept, null, 2),
-    ].join("\n");
-    try {
-        const result = await structuredLlmCall({
-            stepName: `ta-decision:drugs-in-class:${deps.attempt}`,
-            agentId: "drugs-in-class",
-            provider: deps.chatProvider,
-            session: deps.session,
-            system: drugsInClassPrompt,
-            prompt,
-            schema: DrugsInClassOutputSchema,
-            model: deps.model,
-        });
-        if (result.kind === "budget-exceeded") {
-            return { kind: "budget-exceeded", sentinel: result.sentinel };
-        }
-        return { coverage: "available", data: result.value };
-    }
-    catch (err) {
-        return failFromErr(err);
-    }
-}

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

@@ -1,32 +0,0 @@
-/**
- * Phase-3 fan-out item functions for the harness DBOS workflow.
- *
- * Each function operates on one item (one modulator, one trial, one class
- * drug) and returns a coverage envelope. The DBOS workflow body iterates
- * the item list and dispatches each via `DBOS.runStep` with a deterministic
- * step name `"ta-fanout:{kind}:{itemKey}"`. The `withHost` semaphore inside
- * each body caps openFDA / ChEMBL / ctgov in-flight at 4.
- *
- * No throws — coverage envelope is the failure mode. Recovery replays the
- * cached envelope from the DBOS step cache.
- */
-import type { Logger } from "../../../lib/logger.js";
-import type { SerializedError } from "../coverage.js";
-import type { ClassDrugItem, PerClassDrugAEsItem } from "../steps/fanout/aes-for-one-class-drug-step.js";
-import type { PerTrialAEsItem, TrialItem } from "../steps/fanout/aes-for-one-trial-step.js";
-import type { ModulatorItem, PerModulatorFaersItem } from "../steps/fanout/faers-for-one-modulator-step.js";
-import type { PerModulatorPolypharmItem, PolypharmInputItem } from "../steps/fanout/polypharm-for-one-modulator-step.js";
-export type { ClassDrugItem, ModulatorItem, PerClassDrugAEsItem, PerModulatorFaersItem, PerModulatorPolypharmItem, PerTrialAEsItem, PolypharmInputItem, TrialItem, };
-type CoverageAvailable<T> = {
-    coverage: "available";
-    data: T;
-};
-type CoverageQueriedNoData = {
-    coverage: "queried_no_data";
-    error?: SerializedError;
-};
-type CoverageEnvelope<T> = CoverageAvailable<T> | CoverageQueriedNoData;
-export declare function faersForOneModulator(item: ModulatorItem): Promise<CoverageEnvelope<PerModulatorFaersItem>>;
-export declare function polypharmForOneModulator(item: PolypharmInputItem, logger?: Logger): Promise<CoverageEnvelope<PerModulatorPolypharmItem>>;
-export declare function aesForOneTrial(item: TrialItem): Promise<CoverageEnvelope<PerTrialAEsItem>>;
-export declare function aesForOneClassDrug(item: ClassDrugItem): Promise<CoverageEnvelope<PerClassDrugAEsItem>>;

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

@@ -1,156 +0,0 @@
-/**
- * Phase-3 fan-out item functions for the harness DBOS workflow.
- *
- * Each function operates on one item (one modulator, one trial, one class
- * drug) and returns a coverage envelope. The DBOS workflow body iterates
- * the item list and dispatches each via `DBOS.runStep` with a deterministic
- * step name `"ta-fanout:{kind}:{itemKey}"`. The `withHost` semaphore inside
- * each body caps openFDA / ChEMBL / ctgov in-flight at 4.
- *
- * No throws — coverage envelope is the failure mode. Recovery replays the
- * cached envelope from the DBOS step cache.
- */
-import { withHost } from "../../../lib/host-concurrency.js";
-import { getModulatorOnTargetPchembl, getModulatorPolypharmacology } from "../../../tools/lib/chembl-client.js";
-import { getTrialDetails } from "../../../tools/lib/clinical-trials-client.js";
-import { getFaersByDrug, getFaersSeriousness } from "../../../tools/lib/openfda-client.js";
-function fail(message) {
-    return { coverage: "queried_no_data", error: { message } };
-}
-function failFromErr(err) {
-    return fail(err instanceof Error ? err.message : String(err));
-}
-// ── Per-modulator FAERS ──────────────────────────────────────────────
-export async function faersForOneModulator(item) {
-    const probe = item.preferredName;
-    if (!probe) {
-        return fail(`no preferred name for ${item.moleculeChemblId}`);
-    }
-    try {
-        const [byDrug, seriousness] = await Promise.all([
-            withHost("openfda", () => getFaersByDrug(probe, { limit: 10 })),
-            withHost("openfda", () => getFaersSeriousness(probe)),
-        ]);
-        const total = byDrug.totalReports ?? 0;
-        if (total === 0 && byDrug.adverseEvents.length === 0) {
-            return fail(`FAERS returned no reports for ${probe}`);
-        }
-        if (seriousness !== null &&
-            seriousness.totalReports >= 1000 &&
-            seriousness.fatalCount === 0 &&
-            seriousness.hospitalizationCount === 0 &&
-            seriousness.lifeThreateningCount === 0 &&
-            seriousness.disablingCount === 0 &&
-            seriousness.congenitalAnomalyCount === 0 &&
-            seriousness.otherSeriousCount === 0) {
-            return fail(`FAERS seriousness all-zero across ${seriousness.totalReports} reports for ${probe}; openFDA seriousness fields not reliably populated`);
-        }
-        return {
-            coverage: "available",
-            data: {
-                moleculeChemblId: item.moleculeChemblId,
-                preferredName: probe,
-                totalReports: byDrug.totalReports ?? null,
-                topReactions: byDrug.adverseEvents,
-                seriousness,
-            },
-        };
-    }
-    catch (err) {
-        return failFromErr(err);
-    }
-}
-// ── Per-modulator polypharmacology ──────────────────────────────────
-export async function polypharmForOneModulator(item, logger) {
-    try {
-        const [hits, primaryPchembl] = await Promise.all([
-            withHost("chembl", () => getModulatorPolypharmacology(item.moleculeChemblId, {
-                minPchembl: 5,
-                excludeTargetChemblId: item.primaryTargetChemblId ?? undefined,
-                limit: 200,
-            })),
-            item.primaryTargetChemblId
-                ? withHost("chembl", () => getModulatorOnTargetPchembl(item.moleculeChemblId, item.primaryTargetChemblId, logger))
-                : Promise.resolve(null),
-        ]);
-        if (hits.length === 0) {
-            return fail(`no polypharm hits for ${item.moleculeChemblId}`);
-        }
-        return {
-            coverage: "available",
-            data: {
-                moleculeChemblId: item.moleculeChemblId,
-                preferredName: item.preferredName,
-                primaryPchembl,
-                hits: hits.map((h) => ({
-                    targetChemblId: h.targetChemblId,
-                    targetName: h.targetName,
-                    assayChemblId: h.assayChemblId,
-                    pchemblValue: h.pchemblValue,
-                    standardType: h.standardType,
-                    standardValue: h.standardValue,
-                    standardUnits: h.standardUnits,
-                })),
-            },
-        };
-    }
-    catch (err) {
-        return failFromErr(err);
-    }
-}
-// ── Per-trial AEs ────────────────────────────────────────────────────
-export async function aesForOneTrial(item) {
-    try {
-        const details = await withHost("ctgov", () => getTrialDetails(item.nctId));
-        if (!details) {
-            return fail(`no details for ${item.nctId}`);
-        }
-        if (details.adverseEvents.length === 0 && details.outcomes.length === 0) {
-            return fail(`no AE/outcome rows for ${item.nctId}`);
-        }
-        return {
-            coverage: "available",
-            data: {
-                nctId: item.nctId,
-                title: item.title,
-                whyStopped: details.whyStopped,
-                outcomes: details.outcomes,
-                groups: details.adverseEventGroups,
-                events: details.adverseEvents,
-            },
-        };
-    }
-    catch (err) {
-        return failFromErr(err);
-    }
-}
-// ── Per-class-drug AEs ───────────────────────────────────────────────
-export async function aesForOneClassDrug(item) {
-    const probe = item.preferredName;
-    if (!probe) {
-        return fail(`no preferred name for ${item.moleculeChemblId}`);
-    }
-    try {
-        const [byDrug, seriousness] = await Promise.all([
-            withHost("openfda", () => getFaersByDrug(probe, { limit: 10 })),
-            withHost("openfda", () => getFaersSeriousness(probe)),
-        ]);
-        const total = byDrug.totalReports ?? 0;
-        if (total === 0 && byDrug.adverseEvents.length === 0) {
-            return fail(`FAERS returned no reports for ${probe}`);
-        }
-        return {
-            coverage: "available",
-            data: {
-                moleculeChemblId: item.moleculeChemblId,
-                preferredName: probe,
-                totalReports: byDrug.totalReports ?? null,
-                topReactions: byDrug.adverseEvents,
-                seriousness,
-            },
-        };
-    }
-    catch (err) {
-        return failFromErr(err);
-    }
-}

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

@@ -1,97 +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 type { ClaimInvestigation, DossierBody, SafetyCorroboration } from "@inflexa-ai/harness/contracts/target-dossier.js";
-import type { AgentSession } from "../../../auth/types.js";
-import type { UsageRecorder } from "../../../billing/usage-recorder.js";
-import type { Logger } from "../../../lib/logger.js";
-import type { RunStep } from "../../../loop/types.js";
-import type { AgentChat } from "../../../providers/types.js";
-import { type Tool } from "../../../tools/define-tool.js";
-import { BUDGET_EXCEEDED_SENTINEL } from "../lib/llm-step.js";
-/**
- * The bounds the phase runs under.
- *
- * These are configuration with stated defaults, not clinical constants: nothing
- * about biology says six claims or two rounds. They exist to bound cost and to
- * guarantee termination, the section reports the values in force, and an
- * embedder that wants a deeper pass sets its own.
- */
-export interface ClaimInvestigationConfig {
-    /** Corroborated organ claims investigated per run; the rest are reported as budget-cut. */
-    readonly claimBudget: number;
-    /** Propose → critique → re-verify rounds a single claim may run. */
-    readonly roundBound: number;
-    /** Iteration budget for the adversarial critic's tool-using loop. */
-    readonly criticMaxIterations: number;
-}
-export declare const DEFAULT_CLAIM_INVESTIGATION_CONFIG: ClaimInvestigationConfig;
-export interface ClaimInvestigationDeps {
-    /** Operational logging seam; omitted falls back to no-op. */
-    readonly logger?: Logger;
-    readonly chatProvider: AgentChat;
-    /** Session for the phase; each step derives its own sub-agent session from it. */
-    readonly session: AgentSession;
-    readonly model: string;
-    /** Attempt counter — bumped on resume so a cancelled call lands a fresh durable slot. */
-    readonly attempt: number;
-    /** Durability seam for the critic's agent loop. */
-    readonly runStep: RunStep;
-    /** Retrieval surface the adversarial critic searches for disconfirming records. */
-    readonly critiqueTools: readonly Tool[];
-    /** Overrides for {@link DEFAULT_CLAIM_INVESTIGATION_CONFIG}. */
-    readonly config?: Partial<ClaimInvestigationConfig>;
-    /** LLM usage-accounting seam for the critic loop; omitted falls back to the no-op recorder. */
-    readonly usageRecorder?: UsageRecorder;
-    readonly signal?: AbortSignal;
-}
-export interface ClaimInvestigationInput {
-    /** The run's corroboration record — the source of candidate claims. */
-    readonly corroboration: SafetyCorroboration;
-    /** The assembled dossier body, read for per-organ risk context and completeness. */
-    readonly dossier: DossierBody;
-}
-/** The sentinel an LLM step returns once it has self-cancelled the workflow on a 402. */
-export interface BudgetExceeded {
-    readonly kind: "budget-exceeded";
-    readonly sentinel: typeof BUDGET_EXCEEDED_SENTINEL;
-}
-export type ClaimInvestigationResult = ClaimInvestigation | BudgetExceeded;
-declare function isBudgetCancel<T>(value: T | BudgetExceeded): value is BudgetExceeded;
-/**
- * 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 declare function investigateClaims(input: ClaimInvestigationInput, deps: ClaimInvestigationDeps): Promise<ClaimInvestigationResult>;
-export { isBudgetCancel as isClaimInvestigationBudgetExceeded };