@inflexa-ai/harness 0.1.1 → 0.3.0

package/dist/tools/bio/search-pubmed.js

@@ -1,31 +0,0 @@
-/**
- * searchPubMed — search PubMed via NCBI E-utilities.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchPubmed } from "../lib/pubmed-client.js";
-export function createSearchPubMedTool(deps) {
-    return defineTool({
-        id: "search_pubmed",
-        description: "Search PubMed for scientific articles using NCBI E-utilities. " +
-            "The query uses PubMed search syntax — use MeSH terms (e.g., " +
-            '"breast neoplasms"[MeSH]), field tags ([Title/Abstract], [Author], [Gene]), ' +
-            "and Boolean operators (AND, OR, NOT). " +
-            'Example: "BRCA1"[Gene] AND "breast neoplasms"[MeSH] AND "drug resistance"[Title/Abstract]. ' +
-            "Returns PMIDs, titles, journal names, publication years, and author summaries.",
-        inputSchema: z.object({
-            query: z.string().describe("PubMed search query. Supports MeSH terms, field tags, and Boolean operators."),
-            maxResults: z.number().int().min(1).max(50).default(10).describe("Maximum number of results to return (1–50, default 10)"),
-            sort: z.enum(["relevance", "date"]).default("relevance").describe('Sort order: "relevance" or "date" (default "relevance")'),
-            dateRange: z
-                .object({
-                from: z.string().describe("Start date in YYYY/MM/DD format"),
-                to: z.string().describe("End date in YYYY/MM/DD format"),
-            })
-                .optional()
-                .describe("Optional date range filter"),
-        }),
-        execute: async ({ query, maxResults, sort, dateRange }) => ok(await searchPubmed(deps.ncbiApiKey, query, { maxResults, sort, dateRange })),
-    });
-}

package/dist/tools/bio/search-targets.d.ts

@@ -1,9 +0,0 @@
-/**
- * searchTargets tool — search ChEMBL for biological targets.
- */
-export declare const searchTargetsTool: import("../define-tool.js").Tool<{
-    query: string;
-    limit: number;
-}, {
-    targets: import("../lib/chembl-client.js").ChemblTarget[];
-}>;

package/dist/tools/bio/search-targets.js

@@ -1,20 +0,0 @@
-/**
- * searchTargets tool — search ChEMBL for biological targets.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchTargets } from "../lib/chembl-client.js";
-export const searchTargetsTool = defineTool({
-    id: "search_targets",
-    description: "Search ChEMBL for biological targets by gene symbol, protein name, or ChEMBL ID. " +
-        "Returns target metadata including ChEMBL IDs, target type, organism, and gene names.",
-    inputSchema: z.object({
-        query: z.string().min(1).describe("Search term: gene symbol (e.g. 'EGFR'), protein name, or ChEMBL target ID"),
-        limit: z.number().int().min(1).max(25).default(25).describe("Maximum number of targets to return"),
-    }),
-    execute: async ({ query, limit }) => {
-        const targets = await searchTargets(query, limit);
-        return ok({ targets });
-    },
-});

package/dist/tools/bio/search-toxcast.d.ts

@@ -1,36 +0,0 @@
-/**
- * searchToxcast — search EPA ToxCast/Tox21 high-throughput screening data
- * for a chemical via the CTX Bioactivity API.
- */
-interface ToxcastAssayResult {
-    aeid: number;
-    assayEndpoint: string;
-    ac50: number | null;
-    hitCall: number;
-    maxMean: number | null;
-    model: string;
-    flags: string[];
-}
-type ToxcastOutput = {
-    found: false;
-    query: string;
-} | {
-    found: true;
-    chemical: {
-        dtxsid: string;
-        preferredName: string;
-        casrn: string | null;
-        totalAssays: number;
-        activeAssays: number;
-        activeHitRate: number;
-        results: ToxcastAssayResult[];
-    };
-};
-export declare function createSearchToxcastTool(deps: {
-    apiKey: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    activeOnly: boolean;
-    limit: number;
-}, ToxcastOutput>;
-export {};

package/dist/tools/bio/search-toxcast.js

@@ -1,141 +0,0 @@
-/**
- * searchToxcast — search EPA ToxCast/Tox21 high-throughput screening data
- * for a chemical via the CTX Bioactivity API.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { EPA_CCTE_BASE, getEpaCcteHeaders } from "../lib/toxcast-config.js";
-// Raw CTX Bioactivity API wire shapes, validated at the fetch boundary. Fields
-// are optional because the API omits absent values; `dtxsid` stays required
-// because `resolveDtxsid` reads it without a guard, so a row missing it is a
-// contract break surfaced as `invalid_response` rather than a runtime error.
-// The row-shaping/filtering logic in `execute` stays put — it depends on the
-// resolved chemical, the assay-name map, and the `activeOnly`/`limit` inputs.
-const CtxChemicalSearchRowSchema = z.object({
-    dtxsid: z.string(),
-    preferredName: z.string().optional(),
-    casrn: z.string().nullable().optional(),
-});
-const ToxcastMc5ParamSchema = z.object({
-    ac50: z.number().optional(),
-    acc: z.number().optional(),
-});
-const ToxcastMc6ParamSchema = z.object({
-    flag: z.unknown().optional(),
-});
-const ToxcastBioactivityRowSchema = z.object({
-    aeid: z.number().optional(),
-    hitc: z.number().optional(),
-    maxMean: z.number().nullable().optional(),
-    modl: z.string().optional(),
-    mc5Param: ToxcastMc5ParamSchema.nullable().optional(),
-    mc6Param: ToxcastMc6ParamSchema.nullable().optional(),
-});
-const ToxcastAssaySummaryRowSchema = z.object({
-    aeid: z.number().optional(),
-    aenm: z.string().optional(),
-});
-export function createSearchToxcastTool(deps) {
-    return defineTool({
-        id: "search_toxcast",
-        description: "Search EPA ToxCast/Tox21 high-throughput screening data for a chemical via the CTX Bioactivity API. " +
-            "Returns in-vitro bioactivity results across hundreds of assay endpoints " +
-            "(nuclear receptors, stress response, mitochondrial toxicity, etc.). " +
-            "Use to assess toxicological liability of compounds or drug targets. " +
-            "Requires EPA_CCTE_API_KEY environment variable.",
-        inputSchema: z.object({
-            query: z.string().describe("Chemical identifier: DTXSID (e.g. DTXSID7020182), CASRN (e.g. 80-05-7), " + "or chemical name (e.g. bisphenol A)"),
-            activeOnly: z.boolean().default(true).describe("Return only active (hit) assays. Set false for all tested assays."),
-            limit: z.number().int().min(1).max(200).default(50).describe("Max assay results to return (sorted by AC50 ascending for actives)"),
-        }),
-        execute: async ({ query, activeOnly = true, limit = 50 }) => {
-            const headers = getEpaCcteHeaders(deps.apiKey);
-            const resolved = await resolveDtxsid(query, headers);
-            // "No chemical found" is an expected outcome — a data variant, not an error.
-            if (!resolved)
-                return ok({ found: false, query });
-            const { dtxsid, preferredName, casrn } = resolved;
-            const aeidMap = await fetchAssayNames(dtxsid, headers);
-            const bioUrl = `${EPA_CCTE_BASE}/bioactivity/data/search/by-dtxsid/${dtxsid}`;
-            const bioRes = await apiFetchValidated(bioUrl, z.array(ToxcastBioactivityRowSchema), { headers });
-            if (bioRes.isErr())
-                throw new Error(describeApiError(bioRes.error));
-            const allResults = bioRes.value ?? [];
-            const totalAssays = allResults.length;
-            const activeAssays = allResults.filter((r) => r.hitc === 1).length;
-            const filtered = activeOnly ? allResults.filter((r) => r.hitc === 1) : allResults;
-            filtered.sort((a, b) => extractAc50(a) - extractAc50(b));
-            const results = filtered.slice(0, limit).map((r) => {
-                const aeid = r.aeid ?? 0;
-                const mc6 = r.mc6Param ?? {};
-                const flags = Array.isArray(mc6.flag) ? mc6.flag : [];
-                return {
-                    aeid,
-                    assayEndpoint: aeidMap.get(aeid) ?? `aeid:${aeid}`,
-                    ac50: extractAc50Raw(r),
-                    hitCall: r.hitc ?? 0,
-                    maxMean: r.maxMean ?? null,
-                    model: r.modl ?? "",
-                    flags,
-                };
-            });
-            return ok({
-                found: true,
-                chemical: {
-                    dtxsid,
-                    preferredName,
-                    casrn,
-                    totalAssays,
-                    activeAssays,
-                    activeHitRate: totalAssays > 0 ? Math.round((activeAssays / totalAssays) * 1000) / 1000 : 0,
-                    results,
-                },
-            });
-        },
-    });
-}
-function extractAc50(r) {
-    return extractAc50Raw(r) ?? Infinity;
-}
-function extractAc50Raw(r) {
-    const mc5 = r.mc5Param;
-    if (mc5 && typeof mc5 === "object") {
-        if (typeof mc5.ac50 === "number")
-            return mc5.ac50;
-        if (typeof mc5.acc === "number")
-            return mc5.acc;
-    }
-    return null;
-}
-async function resolveDtxsid(query, headers) {
-    if (query.startsWith("DTXSID")) {
-        return { dtxsid: query, preferredName: query, casrn: null };
-    }
-    const searchUrl = `${EPA_CCTE_BASE}/chemical/search/equal/${encodeURIComponent(query)}`;
-    const searchRes = await apiFetchValidated(searchUrl, z.array(CtxChemicalSearchRowSchema), { headers });
-    if (searchRes.isErr())
-        throw new Error(describeApiError(searchRes.error));
-    if (!searchRes.value?.length)
-        return null;
-    const chem = searchRes.value[0];
-    return {
-        dtxsid: chem.dtxsid,
-        preferredName: chem.preferredName ?? query,
-        casrn: chem.casrn ?? null,
-    };
-}
-async function fetchAssayNames(dtxsid, headers) {
-    const map = new Map();
-    const url = `${EPA_CCTE_BASE}/bioactivity/data/summary/search/by-dtxsid/${dtxsid}`;
-    const res = await apiFetchValidated(url, z.array(ToxcastAssaySummaryRowSchema), { headers });
-    if (res.isOk() && Array.isArray(res.value)) {
-        for (const s of res.value) {
-            if (s.aeid != null && s.aenm) {
-                map.set(s.aeid, s.aenm);
-            }
-        }
-    }
-    return map;
-}

package/dist/workflows/register-workflows.d.ts

@@ -1,51 +0,0 @@
-/**
- * Single registration call site for the analysis-side DBOS workflows.
- *
- * This module is the **one place** that calls `registerExecuteAnalysis` and
- * `registerSandboxStep`, binding the parent + child workflow bodies to the
- * running DBOS engine. Keeping both registrations in one file holds a single
- * invariant: both workflows land under the same `applicationVersion` stamp
- * that `launchDbos` writes onto the engine (`harness/runtime/dbos.ts`).
- * Blue/green drains gate on `dbos.application_versions`, so registering the
- * parent and child together under one stamp guarantees a drain treats them
- * as one cohort.
- *
- * Deps are supplied by the composition root: `registerAnalysisWorkflows`
- * takes a fully-formed deps bundle and passes each half straight through to
- * the per-workflow register functions. This module constructs nothing —
- * it only wires.
- */
-import { type ExecuteAnalysisDeps, type ExecuteAnalysisInput, type ExecuteAnalysisResult } from "./execute-analysis.js";
-import { type SandboxStepDeps, type SandboxStepInput, type SandboxStepResult } from "./sandbox-step.js";
-export interface AnalysisWorkflowDeps {
-    readonly executeAnalysis: ExecuteAnalysisDeps;
-    readonly sandboxStep: SandboxStepDeps;
-}
-export interface RegisteredAnalysisWorkflows {
-    readonly executeAnalysis: (input: ExecuteAnalysisInput) => Promise<ExecuteAnalysisResult>;
-    readonly sandboxStep: (input: SandboxStepInput) => Promise<SandboxStepResult>;
-}
-/**
- * Register the parent + child workflows with the running DBOS engine.
- *
- * Call this BEFORE `launchDbos`: `DBOS.launch()` runs recovery synchronously and
- * resolves in-flight workflows by their registered name, so a workflow that is
- * not registered at launch cannot be reclaimed. `runtime/assemble.ts` — the
- * declared source of truth for wiring order — registers every workflow before
- * launch for exactly this reason, and the embedded runtime does the same.
- * Idempotency is owned by the SDK — calling twice with the same name is a
- * `DBOS.registerWorkflow` invariant violation, not something this module
- * guards against.
- *
- * Scope: this helper takes a fully-formed `AnalysisWorkflowDeps`, so it fits
- * only a caller that already holds a registered sandbox-step callable —
- * `ExecuteAnalysisDeps.sandboxStepCallable` (inside `deps.executeAnalysis`)
- * exists only after `registerSandboxStep` has run. A caller that still needs
- * that child callable must instead register the two workflows directly in
- * assemble-order — register the child first, then feed its callable into the
- * parent's deps — the way `runtime/assemble.ts` does; registering the child
- * here as well would make its `registerSandboxStep` a second registration under
- * the same name, which the SDK rejects. No in-tree caller holds a
- * pre-registered child callable, so this helper is currently uncalled.
- */
-export declare function registerAnalysisWorkflows(deps: AnalysisWorkflowDeps): RegisteredAnalysisWorkflows;

package/dist/workflows/register-workflows.js

@@ -1,48 +0,0 @@
-/**
- * Single registration call site for the analysis-side DBOS workflows.
- *
- * This module is the **one place** that calls `registerExecuteAnalysis` and
- * `registerSandboxStep`, binding the parent + child workflow bodies to the
- * running DBOS engine. Keeping both registrations in one file holds a single
- * invariant: both workflows land under the same `applicationVersion` stamp
- * that `launchDbos` writes onto the engine (`harness/runtime/dbos.ts`).
- * Blue/green drains gate on `dbos.application_versions`, so registering the
- * parent and child together under one stamp guarantees a drain treats them
- * as one cohort.
- *
- * Deps are supplied by the composition root: `registerAnalysisWorkflows`
- * takes a fully-formed deps bundle and passes each half straight through to
- * the per-workflow register functions. This module constructs nothing —
- * it only wires.
- */
-import { registerExecuteAnalysis } from "./execute-analysis.js";
-import { registerSandboxStep } from "./sandbox-step.js";
-/**
- * Register the parent + child workflows with the running DBOS engine.
- *
- * Call this BEFORE `launchDbos`: `DBOS.launch()` runs recovery synchronously and
- * resolves in-flight workflows by their registered name, so a workflow that is
- * not registered at launch cannot be reclaimed. `runtime/assemble.ts` — the
- * declared source of truth for wiring order — registers every workflow before
- * launch for exactly this reason, and the embedded runtime does the same.
- * Idempotency is owned by the SDK — calling twice with the same name is a
- * `DBOS.registerWorkflow` invariant violation, not something this module
- * guards against.
- *
- * Scope: this helper takes a fully-formed `AnalysisWorkflowDeps`, so it fits
- * only a caller that already holds a registered sandbox-step callable —
- * `ExecuteAnalysisDeps.sandboxStepCallable` (inside `deps.executeAnalysis`)
- * exists only after `registerSandboxStep` has run. A caller that still needs
- * that child callable must instead register the two workflows directly in
- * assemble-order — register the child first, then feed its callable into the
- * parent's deps — the way `runtime/assemble.ts` does; registering the child
- * here as well would make its `registerSandboxStep` a second registration under
- * the same name, which the SDK rejects. No in-tree caller holds a
- * pre-registered child callable, so this helper is currently uncalled.
- */
-export function registerAnalysisWorkflows(deps) {
-    return {
-        executeAnalysis: registerExecuteAnalysis(deps.executeAnalysis),
-        sandboxStep: registerSandboxStep(deps.sandboxStep),
-    };
-}

package/dist/workflows/resume-execute-analysis.d.ts

@@ -1,70 +0,0 @@
-/**
- * Resume helper for the `executeAnalysis` parent workflow.
- *
- * The actual resume *entry-point* (the HTTP route, the operator CLI hook,
- * the analytics-tier replay) is owned by change 9 — that change exposes
- * resume to the world. This module owns the **internal contract** every
- * resume call site MUST satisfy so the parent body re-opens the running
- * charge correctly after a 402 pause.
- *
- * Contract:
- *
- *   1. Call `prepareExecuteAnalysisResume(pool, parentWorkflowId)` BEFORE
- *      `DBOS.resumeWorkflow(parentWorkflowId)`.
- *   2. The helper finds the cortex_runs row by `workflow_id`, atomically
- *      bumps `attempt_count`, and returns the new attempt + the runId.
- *      Children that are still CANCELLED need an explicit
- *      `DBOS.resumeWorkflow(childWorkflowId)` from the caller; completed
- *      children's `getResult` returns from the DBOS cache.
- *   3. On resume the parent body reads the bumped attempt_count and uses
- *      it in `open-running-charge:${attempt}` / `close-running-charge:${attempt}`
- *      / `revoke-run-auth:${attempt}` so each step name has never been
- *      cached. A fresh managed-root charge is opened to replace the one that
- *      closed with `budget_exceeded` on the pause.
- *   4. The same attempt is passed through to children via
- *      `SandboxStepInput.attempt`, where it drives
- *      `attemptStepNameFormatter` and so the resumed LLM calls miss the
- *      prior cached 402 and fire fresh (NOTES #3).
- *   5. The workflow id and run id MUST NOT change across resume:
- *      `cortex_runs.workflow_id` is rewritten by nothing in this code
- *      path. The whole point of the bumped attempt counter is that the
- *      same workflow id can survive multiple resumes without cache
- *      collisions.
- *
- * Failure modes:
- *
- *   - The row does not exist → `MissingRunError`. Caller MUST surface a 404
- *     to the originating operator; do NOT call `DBOS.resumeWorkflow` on a
- *     missing run.
- *   - The row's status is terminal (`completed`/`partial`/`failed`/`canceled`
- *     without `suspended_insufficient_funds` on the analysis): the helper
- *     still bumps the counter so a defensive retry is harmless, but the
- *     caller SHOULD skip the resume — the workflow already ran to
- *     completion. Change 9's entry point owns this guard.
- */
-import type { Pool } from "pg";
-import type { CortexRunRow } from "../state/schema.js";
-export declare class MissingRunError extends Error {
-    readonly workflowId: string;
-    constructor(workflowId: string);
-}
-export interface PrepareResumeResult {
-    readonly runId: string;
-    readonly workflowId: string;
-    readonly attempt: number;
-    readonly previousStatus: CortexRunRow["status"];
-}
-/**
- * Bump the parent-workflow resume attempt counter and return the new
- * value. The caller invokes `DBOS.resumeWorkflow(workflowId)` immediately
- * after; the resumed parent body reads the bumped counter and re-opens
- * the running charge with a step name that has never been cached.
- *
- * `workflowId` and `runId` are the same bare UUID — `cortex_runs.run_id`
- * IS the DBOS workflowID.
- *
- * Idempotency: each call bumps once. A double-call before
- * `DBOS.resumeWorkflow` is harmless — both step names are misses and the
- * close on the just-opened charge will still cleanly land.
- */
-export declare function prepareExecuteAnalysisResume(pool: Pool, workflowId: string): Promise<PrepareResumeResult>;

package/dist/workflows/resume-execute-analysis.js

@@ -1,80 +0,0 @@
-/**
- * Resume helper for the `executeAnalysis` parent workflow.
- *
- * The actual resume *entry-point* (the HTTP route, the operator CLI hook,
- * the analytics-tier replay) is owned by change 9 — that change exposes
- * resume to the world. This module owns the **internal contract** every
- * resume call site MUST satisfy so the parent body re-opens the running
- * charge correctly after a 402 pause.
- *
- * Contract:
- *
- *   1. Call `prepareExecuteAnalysisResume(pool, parentWorkflowId)` BEFORE
- *      `DBOS.resumeWorkflow(parentWorkflowId)`.
- *   2. The helper finds the cortex_runs row by `workflow_id`, atomically
- *      bumps `attempt_count`, and returns the new attempt + the runId.
- *      Children that are still CANCELLED need an explicit
- *      `DBOS.resumeWorkflow(childWorkflowId)` from the caller; completed
- *      children's `getResult` returns from the DBOS cache.
- *   3. On resume the parent body reads the bumped attempt_count and uses
- *      it in `open-running-charge:${attempt}` / `close-running-charge:${attempt}`
- *      / `revoke-run-auth:${attempt}` so each step name has never been
- *      cached. A fresh managed-root charge is opened to replace the one that
- *      closed with `budget_exceeded` on the pause.
- *   4. The same attempt is passed through to children via
- *      `SandboxStepInput.attempt`, where it drives
- *      `attemptStepNameFormatter` and so the resumed LLM calls miss the
- *      prior cached 402 and fire fresh (NOTES #3).
- *   5. The workflow id and run id MUST NOT change across resume:
- *      `cortex_runs.workflow_id` is rewritten by nothing in this code
- *      path. The whole point of the bumped attempt counter is that the
- *      same workflow id can survive multiple resumes without cache
- *      collisions.
- *
- * Failure modes:
- *
- *   - The row does not exist → `MissingRunError`. Caller MUST surface a 404
- *     to the originating operator; do NOT call `DBOS.resumeWorkflow` on a
- *     missing run.
- *   - The row's status is terminal (`completed`/`partial`/`failed`/`canceled`
- *     without `suspended_insufficient_funds` on the analysis): the helper
- *     still bumps the counter so a defensive retry is harmless, but the
- *     caller SHOULD skip the resume — the workflow already ran to
- *     completion. Change 9's entry point owns this guard.
- */
-import { unwrapOrThrow } from "../lib/result.js";
-import { bumpRunAttemptCount, queryRun } from "../state/index.js";
-export class MissingRunError extends Error {
-    workflowId;
-    constructor(workflowId) {
-        super(`No cortex_runs row found for run_id=${workflowId}`);
-        this.workflowId = workflowId;
-        this.name = "MissingRunError";
-    }
-}
-/**
- * Bump the parent-workflow resume attempt counter and return the new
- * value. The caller invokes `DBOS.resumeWorkflow(workflowId)` immediately
- * after; the resumed parent body reads the bumped counter and re-opens
- * the running charge with a step name that has never been cached.
- *
- * `workflowId` and `runId` are the same bare UUID — `cortex_runs.run_id`
- * IS the DBOS workflowID.
- *
- * Idempotency: each call bumps once. A double-call before
- * `DBOS.resumeWorkflow` is harmless — both step names are misses and the
- * close on the just-opened charge will still cleanly land.
- */
-export async function prepareExecuteAnalysisResume(pool, workflowId) {
-    const row = unwrapOrThrow(await queryRun(pool, workflowId));
-    if (!row) {
-        throw new MissingRunError(workflowId);
-    }
-    const attempt = unwrapOrThrow(await bumpRunAttemptCount(pool, row.runId));
-    return {
-        runId: row.runId,
-        workflowId,
-        attempt,
-        previousStatus: row.status,
-    };
-}

package/dist/workflows/target-assessment/correction-loop.d.ts

@@ -1,45 +0,0 @@
-/**
- * Correction loop for Phase-3 fan-out branches that returned empty
- * without an error.
- *
- * Contract:
- *   1. If `coverage` is `available` (non-empty data), pass through.
- *   2. If `coverage` is `queried_no_data` and we have a deterministic
- *      alt-name retry available, run ONE retry. If it succeeds, return
- *      the new payload tagged `available`.
- *   3. If still empty after the alt-name retry, escalate ONCE to the
- *      responsible Phase-2 agent (via the supplied `escalate` callback)
- *      with the failure bundle. If the agent returns a usable payload,
- *      return it. Otherwise return `coverage: "queried_no_data"`.
- *
- * The escalation callback is optional — callers without an agent fall
- * back to a final coverage tag without escalation.
- */
-import type { Coverage, SerializedError } from "./coverage.js";
-type CoverageEnvelope<T> = {
-    coverage: "available";
-    data: T;
-} | {
-    coverage: "queried_no_data";
-    error?: SerializedError;
-} | {
-    coverage: "not_loaded";
-    reason?: string;
-};
-export interface CorrectionInput<T> {
-    initial: CoverageEnvelope<T>;
-    altRetry?: () => Promise<CoverageEnvelope<T>>;
-    escalate?: () => Promise<CoverageEnvelope<T>>;
-}
-export interface CorrectionTrace {
-    altRetryAttempted: boolean;
-    altRetrySucceeded: boolean;
-    escalationAttempted: boolean;
-    escalationSucceeded: boolean;
-    finalCoverage: Coverage;
-}
-export declare function runCorrectionLoop<T>(input: CorrectionInput<T>): Promise<{
-    result: CoverageEnvelope<T>;
-    trace: CorrectionTrace;
-}>;
-export {};

package/dist/workflows/target-assessment/correction-loop.js

@@ -1,62 +0,0 @@
-/**
- * Correction loop for Phase-3 fan-out branches that returned empty
- * without an error.
- *
- * Contract:
- *   1. If `coverage` is `available` (non-empty data), pass through.
- *   2. If `coverage` is `queried_no_data` and we have a deterministic
- *      alt-name retry available, run ONE retry. If it succeeds, return
- *      the new payload tagged `available`.
- *   3. If still empty after the alt-name retry, escalate ONCE to the
- *      responsible Phase-2 agent (via the supplied `escalate` callback)
- *      with the failure bundle. If the agent returns a usable payload,
- *      return it. Otherwise return `coverage: "queried_no_data"`.
- *
- * The escalation callback is optional — callers without an agent fall
- * back to a final coverage tag without escalation.
- */
-export async function runCorrectionLoop(input) {
-    const trace = {
-        altRetryAttempted: false,
-        altRetrySucceeded: false,
-        escalationAttempted: false,
-        escalationSucceeded: false,
-        finalCoverage: input.initial.coverage,
-    };
-    if (input.initial.coverage === "available") {
-        return { result: input.initial, trace };
-    }
-    if (input.initial.coverage === "not_loaded") {
-        return { result: input.initial, trace };
-    }
-    if (input.altRetry) {
-        trace.altRetryAttempted = true;
-        try {
-            const retried = await input.altRetry();
-            if (retried.coverage === "available") {
-                trace.altRetrySucceeded = true;
-                trace.finalCoverage = "available";
-                return { result: retried, trace };
-            }
-        }
-        catch {
-            // alt retry failed; proceed to escalation
-        }
-    }
-    if (input.escalate) {
-        trace.escalationAttempted = true;
-        try {
-            const esc = await input.escalate();
-            if (esc.coverage === "available") {
-                trace.escalationSucceeded = true;
-                trace.finalCoverage = "available";
-                return { result: esc, trace };
-            }
-        }
-        catch {
-            // escalation failed; fall through
-        }
-    }
-    trace.finalCoverage = "queried_no_data";
-    return { result: input.initial, trace };
-}

package/dist/workflows/target-assessment/steps/phase0-resolve.d.ts

@@ -1,71 +0,0 @@
-/**
- * Phase 0 — target resolution.
- *
- * The single step in the workflow allowed to throw. A hard resolution
- * failure aborts the assessment with `error.kind: "target-unresolved"`.
- *
- * The DBOS workflow body re-implements Phase 0 inline; this module is kept
- * for its schemas (input/output) so dependent modules continue to compile.
- */
-export declare const phase0InputSchema: import("zod").ZodObject<{
-    assessmentId: import("zod").ZodString;
-    target: import("zod").ZodString;
-    goal: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-    organizationId: import("zod").ZodString;
-    requestedBy: import("zod").ZodString;
-}, import("zod/v4/core").$strip>;
-export declare const phase0OutputSchema: import("zod").ZodObject<{
-    assessmentId: import("zod").ZodString;
-    goal: import("zod").ZodNullable<import("zod").ZodString>;
-    canonicalId: import("zod").ZodString;
-    canonicalOntology: import("zod").ZodEnum<{
-        ensembl: "ensembl";
-        hgnc: "hgnc";
-    }>;
-    geneSymbol: import("zod").ZodString;
-    approvedName: import("zod").ZodString;
-    ids: import("zod").ZodObject<{
-        hgnc: import("zod").ZodNullable<import("zod").ZodString>;
-        ensembl: import("zod").ZodNullable<import("zod").ZodString>;
-        uniprot: import("zod").ZodNullable<import("zod").ZodString>;
-        chembl: import("zod").ZodNullable<import("zod").ZodString>;
-        entrez: import("zod").ZodNullable<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>;
-    synonyms: import("zod").ZodArray<import("zod").ZodString>;
-    proteinSynonyms: import("zod").ZodArray<import("zod").ZodString>;
-    proteinFamily: import("zod").ZodNullable<import("zod").ZodString>;
-    resolutionCoverage: import("zod").ZodObject<{
-        hgnc: import("zod").ZodBoolean;
-        uniprot: import("zod").ZodBoolean;
-        ensembl: import("zod").ZodBoolean;
-        chembl: import("zod").ZodBoolean;
-    }, import("zod/v4/core").$strip>;
-}, import("zod/v4/core").$strip>;
-export declare function phase0Execute(inputData: {
-    assessmentId: string;
-    goal?: string | null;
-    target: string;
-}): Promise<{
-    canonicalId: string;
-    canonicalOntology: "hgnc" | "ensembl";
-    geneSymbol: string;
-    approvedName: string;
-    ids: {
-        hgnc: string | null;
-        ensembl: string | null;
-        uniprot: string | null;
-        chembl: string | null;
-        entrez: string | null;
-    };
-    synonyms: string[];
-    proteinSynonyms: string[];
-    proteinFamily: string | null;
-    resolutionCoverage: {
-        hgnc: boolean;
-        uniprot: boolean;
-        ensembl: boolean;
-        chembl: boolean;
-    };
-    assessmentId: string;
-    goal: string | null;
-}>;