@inflexa-ai/harness 0.35.8 → 0.36.0

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

@@ -1,631 +0,0 @@
-/**
- * `executeTargetAssessment` — the parent DBOS workflow.
- *
- * Shape (every external interaction is a `DBOS.runStep` so a crashed
- * workflow replays from the cache instead of repeating side effects):
- *
- *  Phase 0   `phase0Resolve`               — only step allowed to throw
- *                                            (terminates → `target-unresolved`)
- *  Phase 1   15 collectors in parallel     — coverage-envelope failures
- *  Progress  `emitProgress("deciding")`
- *  Phase 2   2 decisions in parallel       — LLM calls, attempt-numbered
- *  Progress  `emitProgress("fanning_out")`
- *  Phase 3   4 fan-out blocks in parallel  — per-item HTTP, withHost semaphore
- *  Progress  `emitProgress("assembling")`
- *  Phase 4   `phase4Assemble`              — aggregation + cached annotator
- *  Phase 4a  `ta-approval-precedents`      — one openFDA lookup, two projections
- *  Phase 4b  `assembleSafetyCorroboration` — pure fold, no step of its own
- *  Phase 4c  `investigateClaims`           — propose / critique / re-verify / converge
- *  Progress  `emitProgress("synthesizing")`
- *  Phase 5a  3 per-section syntheses in parallel
- *  Phase 5b  `dossierRecommendation` sequential
- *  Phase 5c  `phase5Persist` (pure)
- *  Terminal  outermost try/finally:
- *             - normal:           setDossier         → status="completed"
- *             - phase0 throw:     markFailed         → "target-unresolved"
- *             - schema violation: markFailed         → "schema-violation"
- *             - other throw:      markFailed         → "unexpected-throw"
- *             - 402 self-cancel:  markAssessmentSuspended → "suspended_insufficient_funds"
- *             - operator cancel:  markFailed         → "operator-cancelled"
- *             - soft-deleted row: no-op
- *
- * Workflow ID convention: `workflowID === assessmentId`. TA is one-shot
- * (re-runs create new rows), so the workflowID equals the assessmentId
- * directly. No `:runId` suffix.
- */
-import { DBOS } from "@dbos-inc/dbos-sdk";
-import { z } from "zod";
-import { forSubAgent } from "../auth/types.js";
-import { createNoopLogger } from "../lib/console-logger.js";
-import { ATTR_INFLEXA_FANOUT_KEY, stableSpan } from "../lib/otel-spans.js";
-import { unwrapOrThrow } from "../lib/result.js";
-import { durableStep } from "../loop/run-step.js";
-import { createPubMedTool } from "../tools/bio/pubmed.js";
-import { resolveTarget } from "../tools/lib/identifier-resolver.js";
-import { TargetAssessmentInputSchema } from "./target-assessment/schemas.js";
-import { getAssessment, markAssessmentSuspended, markFailed, setDossier } from "../state/target-assessments.js";
-import { COLLECTOR_MANIFEST } from "./target-assessment/collectors/index.js";
-import { drugsInClass, modulatorTriage } from "./target-assessment/decisions/index.js";
-import { aesForOneClassDrug, aesForOneTrial, faersForOneModulator, polypharmForOneModulator, } from "./target-assessment/fanout/index.js";
-import { fetchApprovalPrecedents, pickIndicationForPrecedents, precedentLabelSafety, renderApprovalPrecedents, } from "./target-assessment/lib/approval-precedents.js";
-import { segmentLabelSafety } from "./target-assessment/lib/fda-label-safety.js";
-import { readBudgetExceededMarker } from "./target-assessment/lib/llm-step.js";
-import { assembleSafetyCorroboration } from "./target-assessment/lib/safety-corroboration.js";
-import { investigateClaims, isClaimInvestigationBudgetExceeded } from "./target-assessment/investigation/index.js";
-import { recordTerminalReason } from "./target-assessment/metrics.js";
-import { elapsedSinceIso, recordRunCompleted } from "../lib/metrics.js";
-import { phase4Assemble } from "./target-assessment/phase4-assemble.js";
-import { DossierDerivedInvariantError, DossierSchemaViolationError, phase5Persist } from "./target-assessment/phase5-persist.js";
-import { emitProgress } from "./target-assessment/progress.js";
-import { dossierRecommendation, liabilityBullets, safetyFlagsTrail, translationalCommentary, } from "./target-assessment/synthesis/index.js";
-// ── Workflow input ───────────────────────────────────────────────────
-export const ExecuteTargetAssessmentInputSchema = z.object({
-    assessmentId: z.string(),
-    target: z.string(),
-    goal: z.string().nullable().optional(),
-    organizationId: z.string(),
-    requestedBy: z.string(),
-    billingContextId: z.string(),
-});
-// ── Helpers ──────────────────────────────────────────────────────────
-/**
- * Derive a sub-agent session from the durable `RunSession`. Identity, scope,
- * and the opaque `auth` capability come from the parent session — no synthetic
- * envelopes.
- */
-function buildSession(input, agentId) {
-    return {
-        ...input.runSession,
-        provenance: { agentId, callPath: [agentId] },
-    };
-}
-/**
- * Type guard: any phase result carrying `{kind: "budget-exceeded"}` means
- * the LLM step wrapper has already self-cancelled the workflow. The body
- * should propagate the sentinel up the call chain so no downstream
- * coverage envelope is fabricated for it.
- */
-function isBudgetCancel(value) {
-    return typeof value === "object" && value !== null && "kind" in value && value.kind === "budget-exceeded";
-}
-function wrapCollectorThrow(err) {
-    return {
-        coverage: "queried_no_data",
-        error: { message: err instanceof Error ? err.message : String(err) },
-    };
-}
-/**
- * Internal sentinel thrown by the workflow body when a 402 marker has
- * been observed at a phase boundary — short-circuits the remaining
- * phases and lands in the outermost catch, which sets `budgetExceeded`
- * for the terminal dispatch.
- */
-class BudgetExceededSkip extends Error {
-    constructor() {
-        super("budget exceeded — skipping remaining phases");
-        this.name = "BudgetExceededSkip";
-    }
-}
-// ── Workflow registration ────────────────────────────────────────────
-/**
- * Register the executeTargetAssessment workflow with DBOS. Caller is
- * responsible for setting `workflowID = assessmentId` via
- * `DBOS.startWorkflow(_, { workflowID })`.
- */
-export function registerExecuteTargetAssessment(deps) {
-    return DBOS.registerWorkflow(async (input) => {
-        return runExecuteTargetAssessmentBody(input, deps);
-    }, { name: "executeTargetAssessment" });
-}
-/**
- * Body extracted so tests can drive it without registering a workflow
- * (the DBOS calls inside still rely on a workflow context being present).
- */
-export async function runExecuteTargetAssessmentBody(input, deps) {
-    const logger = (deps.logger ?? createNoopLogger()).with({ assessmentId: input.assessmentId });
-    // (§6.1) Outermost try/finally — every termination path dispatches the
-    // matching terminal handler. Phase 0 throws are caught here; every
-    // other phase wraps its body in coverage envelopes and does not throw.
-    // Budget-exceeded (billing-gateway 402) reaches here via `budgetExceeded` set
-    // when any LLM step returns the sentinel. The terminal block writes
-    // `status = "suspended_insufficient_funds"` via DBOS.runStep BEFORE
-    // materialising the cancel — the trailing `DBOS.cancelWorkflow` +
-    // `DBOS.runStep("self-cancel-budget-exceeded")` puts the workflow into
-    // CANCELLED status (the only state `DBOS.resumeWorkflow` replays).
-    // Ownership defaults to true for inputs persisted before the field existed
-    // (a workflow recovered across this deploy) — those were always Cortex-owned.
-    const authorization = {
-        runSession: input.runSession,
-        ownsMandate: input.ownsMandate ?? true, // oss-core-managed-ok
-    };
-    let phase0Error;
-    let schemaViolation;
-    let derivedViolation;
-    let unexpectedError;
-    let budgetExceeded = false;
-    let dossierForPersist;
-    let bytesForPersist = 0;
-    try {
-        // (§5.3, §6.3) Phase 0 — target resolution. The only legitimate throw
-        // site. On throw, the catch below records `phase0Error` and the
-        // terminal block dispatches `markFailed({kind: "target-unresolved"})`.
-        await emitProgress(deps.pool, logger, input.assessmentId, "resolving");
-        const resolved = await DBOS.runStep(async () => {
-            const r = await resolveTarget(input.target, logger);
-            return {
-                assessmentId: input.assessmentId,
-                goal: input.goal ?? null,
-                ...r,
-            };
-        }, { name: "ta-phase0-resolve" }).catch((err) => {
-            phase0Error = err;
-            throw err;
-        });
-        // (§5.4) Phase 1 — 15 collectors in parallel. Each is its own DBOS
-        // step; coverage failures cache as `queried_no_data` and replay
-        // returns the cached envelope. The per-collector run functions emit
-        // different bundle shapes; the union is widened to `unknown` here
-        // and `Phase1Bundle` is reconstructed by manifest key below.
-        await emitProgress(deps.pool, logger, input.assessmentId, "collecting");
-        const manifest = COLLECTOR_MANIFEST;
-        const collectorCtx = { ncbiApiKey: deps.ncbiApiKey, logger };
-        const collectorPairs = await Promise.all(manifest.map((entry) => DBOS.runStep(() => entry.run(resolved, collectorCtx), {
-            name: `ta-collector:${entry.id}`,
-        })
-            .catch((err) => wrapCollectorThrow(err))
-            .then((result) => [entry.id, result])));
-        const collectorById = Object.fromEntries(collectorPairs);
-        const phase1 = {
-            resolved,
-            collectors: {
-                opentargets: collectorById["opentargets"],
-                chemblModulators: collectorById["chembl-modulators"],
-                ctgov: collectorById["ctgov"],
-                faersByTarget: collectorById["faers-by-target"],
-                expressionHuman: collectorById["expression-human"],
-                expressionMultiSpecies: collectorById["expression-multi-species"],
-                clinvar: collectorById["clinvar"],
-                cbioportal: collectorById["cbioportal"],
-                impc: collectorById["impc"],
-                monarch: collectorById["monarch"],
-                pubmedIndex: collectorById["pubmed-index"],
-                pathways: collectorById["pathways"],
-                stringPpi: collectorById["string-ppi"],
-                familyComplexes: collectorById["family-complexes"],
-                therapeuticPrograms: collectorById["therapeutic-programs"],
-            },
-        };
-        // (§5.5, §5.11) Phase 2 — decisions. Lazy billing resolution happens
-        // inside the chat provider's closure (TA-aware provider in §12). The
-        // session carries the `billingContextId` the provider reads from.
-        await emitProgress(deps.pool, logger, input.assessmentId, "deciding");
-        const decisionSession = buildSession(input, "ta-decisions");
-        const [modulatorRes, drugsRes] = await Promise.all([
-            modulatorTriage(phase1, {
-                chatProvider: deps.chatProvider,
-                session: forSubAgent(decisionSession, "modulator-triage"),
-                model: deps.decisionModel,
-                attempt: 0,
-            }),
-            drugsInClass(phase1, {
-                chatProvider: deps.chatProvider,
-                session: forSubAgent(decisionSession, "drugs-in-class"),
-                model: deps.decisionModel,
-                attempt: 0,
-            }),
-        ]);
-        if (isBudgetCancel(modulatorRes) || isBudgetCancel(drugsRes)) {
-            // An LLM step already sent the budget-exceeded marker. Skip the
-            // remaining phases and fall through to the terminal block, which
-            // dispatches `markAssessmentSuspended` and materialises the cancel.
-            budgetExceeded = true;
-            throw new BudgetExceededSkip();
-        }
-        const phase2 = {
-            phase1,
-            decisions: {
-                modulatorTriage: modulatorRes,
-                failedTrialClassifier: {
-                    coverage: "not_loaded",
-                    reason: "deterministic in Phase 4 (classifyFailureReason)",
-                },
-                offTargetCurator: {
-                    coverage: "not_loaded",
-                    reason: "deterministic in Phase 4 (aggregateOffTargetPanel)",
-                },
-                drugsInClass: drugsRes,
-            },
-        };
-        // (§5.6) Phase 3 — fan-out blocks. Each block iterates items via
-        // Promise.all over DBOS.runStep; `withHost` semaphores inside each
-        // item function cap concurrency to 4 per host.
-        await emitProgress(deps.pool, logger, input.assessmentId, "fanning_out");
-        const triage = phase2.decisions.modulatorTriage;
-        const triageShortlist = triage.coverage === "available"
-            ? triage.data.shortlist.map((m) => ({
-                moleculeChemblId: m.moleculeChemblId,
-                preferredName: m.preferredName,
-                maxPhase: m.maxPhase,
-                firstApproval: m.firstApproval,
-                rationale: m.rationale ?? "",
-            }))
-            : [];
-        const chembl = phase1.collectors.chemblModulators;
-        const primaryTargetChemblId = chembl.coverage === "available" ? chembl.data.targetChemblId : null;
-        const polypharmItems = triageShortlist.map((m) => ({
-            moleculeChemblId: m.moleculeChemblId,
-            preferredName: m.preferredName,
-            primaryTargetChemblId,
-        }));
-        const ctgov = phase1.collectors.ctgov;
-        const trialItems = [];
-        if (ctgov.coverage === "available") {
-            const seen = new Set();
-            for (const t of [...ctgov.data.failed, ...ctgov.data.active]) {
-                if (!t.nctId || seen.has(t.nctId))
-                    continue;
-                seen.add(t.nctId);
-                trialItems.push({ nctId: t.nctId, title: t.title });
-                if (trialItems.length >= 30)
-                    break;
-            }
-        }
-        const dic = phase2.decisions.drugsInClass;
-        const classDrugItems = dic.coverage === "available"
-            ? dic.data.drugs.map((d) => ({
-                moleculeChemblId: d.moleculeChemblId,
-                preferredName: d.preferredName,
-                maxPhase: d.maxPhase,
-                firstApproval: d.firstApproval,
-            }))
-            : [];
-        async function runFanoutBlock(items, stepKindForName, keyOf, fn) {
-            return Promise.all(items.map((item) => {
-                const key = keyOf(item);
-                const stepName = `ta-fanout:${stepKindForName}:${key}`;
-                return DBOS.runStep(() => {
-                    stableSpan(stepName, `ta-fanout:${stepKindForName}`, { [ATTR_INFLEXA_FANOUT_KEY]: key });
-                    return fn(item);
-                }, { name: stepName }).catch((err) => wrapCollectorThrow(err));
-            }));
-        }
-        const [perModulatorFaersResults, perTrialAesResults, perModulatorPolypharmResults, perClassDrugAesResults] = await Promise.all([
-            runFanoutBlock(triageShortlist, "modulator-faers", (item) => item.moleculeChemblId, faersForOneModulator),
-            runFanoutBlock(trialItems, "trial-aes", (item) => item.nctId, aesForOneTrial),
-            runFanoutBlock(polypharmItems, "modulator-polypharm", (item) => item.moleculeChemblId, (item) => polypharmForOneModulator(item, logger)),
-            runFanoutBlock(classDrugItems, "class-drug-aes", (item) => item.moleculeChemblId, aesForOneClassDrug),
-        ]);
-        const phase3 = {
-            phase2,
-            fanout: {
-                perModulatorFaers: { results: perModulatorFaersResults },
-                perTrialAes: { results: perTrialAesResults },
-                perModulatorPolypharm: { results: perModulatorPolypharmResults },
-                perClassDrugAes: { results: perClassDrugAesResults },
-            },
-        };
-        // (§5.7) Phase 4 — assembly. Single DBOS step. The annotator seam lets
-        // the off-target panel's clinical-consequence pass reach its LLM on a
-        // cache miss; per-row failures leave the row's fallback in place.
-        await emitProgress(deps.pool, logger, input.assessmentId, "assembling");
-        const annotatorDeps = {
-            provider: deps.chatProvider,
-            session: buildSession(input, "off-target-annotator"),
-            model: deps.decisionModel,
-            ...(deps.usageRecorder ? { usageRecorder: deps.usageRecorder } : {}),
-        };
-        const phase4 = await DBOS.runStep(() => phase4Assemble(deps.pool, phase3, annotatorDeps, logger), {
-            name: "ta-phase4-assemble",
-        });
-        // (§5.8-pre) Approval-precedent grounding — one deterministic openFDA
-        // lookup feeding two projections of the same typed labels: the markdown
-        // block every synthesis prompt receives, and the per-organ regulatory
-        // signals the dossier carries. A precedent-lookup failure must NOT fail
-        // the whole assessment: a fetch throw degrades to a "no precedents" block.
-        const precedentGrounding = await DBOS.runStep(async () => {
-            const indication = pickIndicationForPrecedents(phase4.dossier);
-            let result = null;
-            if (indication !== null) {
-                try {
-                    result = await fetchApprovalPrecedents({ indication });
-                }
-                catch (err) {
-                    logger.named("ta-approval-precedents").warn("openFDA lookup failed", { indication, ...logger.errorFields(err) });
-                    result = null;
-                }
-            }
-            return {
-                block: renderApprovalPrecedents(indication, result),
-                // A resolved indication was queried even when the lookup
-                // degraded to nothing; only an unresolved one was not.
-                organSignals: indication === null ? null : segmentLabelSafety(precedentLabelSafety(result?.precedents ?? [])),
-            };
-        }, { name: "ta-approval-precedents" });
-        const approvalPrecedents = precedentGrounding.block;
-        // (§5.8-pre) The corroboration fold. It reads the label signals segmented
-        // above, so it runs here rather than at assembly — and here rather than at
-        // persist, because the claim investigation below is its consumer. The fold
-        // is pure over two cached step outputs, so it needs no step of its own: a
-        // replay recomputes the same record without a durable write.
-        const corroboration = assembleSafetyCorroboration({
-            phase1,
-            regulatoryOrganSignals: precedentGrounding.organSignals,
-        });
-        // (§5.8-pre) The claim investigation — propose a mechanism, argue
-        // against it, re-verify, converge. Runs before synthesis so the
-        // synthesis prompts read verdicts rather than bare agreement.
-        const investigation = await investigateClaims({ corroboration, dossier: phase4.dossier }, {
-            logger,
-            chatProvider: deps.chatProvider,
-            session: buildSession(input, "ta-claim-investigation"),
-            model: deps.synthesisModel,
-            attempt: 0,
-            runStep: durableStep,
-            critiqueTools: [createPubMedTool({ ...(deps.ncbiApiKey ? { ncbiApiKey: deps.ncbiApiKey } : {}) })],
-            ...(deps.claimInvestigation ? { config: deps.claimInvestigation } : {}),
-            ...(deps.usageRecorder ? { usageRecorder: deps.usageRecorder } : {}),
-        });
-        if (isClaimInvestigationBudgetExceeded(investigation)) {
-            budgetExceeded = true;
-            throw new BudgetExceededSkip();
-        }
-        const phase4Investigated = {
-            ...phase4,
-            dossier: {
-                ...phase4.dossier,
-                safety_corroboration: corroboration,
-                claim_investigation: investigation,
-            },
-        };
-        // (§5.8) Phase 5 — three per-section syntheses in parallel.
-        await emitProgress(deps.pool, logger, input.assessmentId, "synthesizing");
-        const synthesisDeps = (agentId) => ({
-            chatProvider: deps.chatProvider,
-            session: { ...buildSession(input, agentId) },
-            model: deps.synthesisModel,
-            attempt: 0,
-            approvalPrecedents,
-        });
-        const [bulletsRes, flagsRes, commentaryRes] = await Promise.all([
-            liabilityBullets(phase4Investigated, synthesisDeps("liability-bullets")),
-            safetyFlagsTrail(phase4Investigated, synthesisDeps("safety-flags-trail")),
-            translationalCommentary(phase4Investigated, synthesisDeps("translational-commentary")),
-        ]);
-        if (isBudgetCancel(bulletsRes) || isBudgetCancel(flagsRes) || isBudgetCancel(commentaryRes)) {
-            budgetExceeded = true;
-            throw new BudgetExceededSkip();
-        }
-        // (§5.9) Phase 5b — sequential dossier-recommendation step.
-        const recommendationRes = await dossierRecommendation({
-            phase4: phase4Investigated,
-            perSection: {
-                liabilityBullets: bulletsRes,
-                safetyFlagsTrail: flagsRes,
-                translationalCommentary: commentaryRes,
-            },
-        }, synthesisDeps("dossier-recommendation"));
-        if (isBudgetCancel(recommendationRes)) {
-            budgetExceeded = true;
-            throw new BudgetExceededSkip();
-        }
-        // (§5.10) Phase 5c — pure persist function. The DB write moves to
-        // the terminal handler below; this step validates the v5 dossier
-        // and returns the persisted-shape bundle. Schema/derived violations
-        // throw and the terminal handler dispatches to `markFailed`.
-        const persisted = await DBOS.runStep(() => phase5Persist({
-            logger,
-            assessmentId: input.assessmentId,
-            phase4Dossier: phase4Investigated.dossier,
-            phase2,
-            regulatoryOrganSignals: precedentGrounding.organSignals,
-            synthesis: {
-                bullets: bulletsRes,
-                flags: flagsRes,
-                commentary: commentaryRes,
-                recommendation: recommendationRes,
-            },
-        }), { name: "ta-phase5-persist" });
-        dossierForPersist = persisted.dossier;
-        bytesForPersist = persisted.bytes;
-    }
-    catch (err) {
-        if (err instanceof BudgetExceededSkip) {
-            // Already classified; the terminal block reads `budgetExceeded`.
-        }
-        else if (err instanceof DossierSchemaViolationError) {
-            schemaViolation = err;
-        }
-        else if (err instanceof DossierDerivedInvariantError) {
-            derivedViolation = err;
-        }
-        else if (phase0Error === undefined) {
-            unexpectedError = err;
-        }
-        // phase0Error is already set if it came from the Phase-0 catch above.
-    }
-    // (§6.1, §6.8) Terminal block. Read the row first; if soft-deleted,
-    // no-op (the user's delete during the run wins).
-    //
-    // Each terminal path records its `cortex.run.completed` outcome INSIDE the
-    // DBOS step that persists it, so a recovery replay reads the cached step
-    // and records nothing again. The duration runs from the row's `created_at`.
-    // The deleted path writes no row, so its record rides the read step itself.
-    const row = await DBOS.runStep(async () => {
-        const read = unwrapOrThrow(await getAssessment(deps.pool, input.assessmentId, input.organizationId));
-        if (read?.status === "deleted") {
-            recordRunCompleted({ workflow: "target_assessment", status: "canceled", durationMs: elapsedSinceIso(read.createdAt) });
-        }
-        return read;
-    }, { name: "ta-terminal-read-row" });
-    const recordTerminal = (status) => recordRunCompleted({ workflow: "target_assessment", status, durationMs: elapsedSinceIso(row?.createdAt) });
-    if (row?.status === "deleted") {
-        recordTerminalReason("deleted");
-        return {
-            assessmentId: input.assessmentId,
-            status: "deleted",
-            bytes: 0,
-        };
-    }
-    // (§6.2) Normal completion — happy path wrote `dossierForPersist`.
-    if (!phase0Error && !schemaViolation && !derivedViolation && !unexpectedError && !budgetExceeded && dossierForPersist) {
-        try {
-            await DBOS.runStep(async () => {
-                unwrapOrThrow(await setDossier(deps.pool, input.assessmentId, dossierForPersist));
-                recordTerminal("completed");
-            }, { name: "ta-terminal-completed" });
-            await emitProgress(deps.pool, logger, input.assessmentId, "completed");
-        }
-        catch (err) {
-            logger.named("ta-terminal").error("setDossier failed", logger.errorFields(err));
-        }
-        await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-completed");
-        recordTerminalReason("completed");
-        return {
-            assessmentId: input.assessmentId,
-            status: "completed",
-            bytes: bytesForPersist,
-        };
-    }
-    // (§6.3) Phase 0 throw — target unresolved.
-    if (phase0Error) {
-        await DBOS.runStep(async () => {
-            unwrapOrThrow(await markFailed(deps.pool, input.assessmentId, {
-                kind: "target-unresolved",
-                message: phase0Error instanceof Error ? phase0Error.message : String(phase0Error),
-            }));
-            recordTerminal("failed");
-        }, { name: "ta-terminal-failed-resolve" });
-        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
-        await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
-        recordTerminalReason("target-unresolved");
-        return {
-            assessmentId: input.assessmentId,
-            status: "failed",
-            bytes: 0,
-        };
-    }
-    // (§6.4) Schema violation.
-    if (schemaViolation) {
-        await DBOS.runStep(async () => {
-            unwrapOrThrow(await markFailed(deps.pool, input.assessmentId, {
-                kind: "schema-invariant-violation",
-                message: schemaViolation.message,
-                details: schemaViolation.issues,
-            }));
-            recordTerminal("failed");
-        }, { name: "ta-terminal-failed-schema" });
-        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
-        await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
-        recordTerminalReason("schema-violation");
-        return {
-            assessmentId: input.assessmentId,
-            status: "failed",
-            bytes: bytesForPersist,
-        };
-    }
-    // (§6.4 — derived invariant variant — same terminal class, different kind.)
-    if (derivedViolation) {
-        await DBOS.runStep(async () => {
-            unwrapOrThrow(await markFailed(deps.pool, input.assessmentId, {
-                kind: "derived-invariant-violation",
-                message: derivedViolation.message,
-            }));
-            recordTerminal("failed");
-        }, { name: "ta-terminal-failed-derived" });
-        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
-        await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
-        recordTerminalReason("derived-invariant-violation");
-        return {
-            assessmentId: input.assessmentId,
-            status: "failed",
-            bytes: bytesForPersist,
-        };
-    }
-    // (§6.6) Budget exceeded — drain the marker for telemetry, flip the
-    // row to `suspended_insufficient_funds`, then materialise the cancel.
-    // The trailing `DBOS.cancelWorkflow` + `DBOS.runStep` puts the
-    // workflow into CANCELLED status (the only state `DBOS.resumeWorkflow`
-    // will replay; SUCCESS / ERROR are terminal).
-    if (budgetExceeded) {
-        await DBOS.runStep(() => readBudgetExceededMarker(), {
-            name: "ta-terminal-drain-marker",
-        }).catch(() => null);
-        await DBOS.runStep(async () => {
-            unwrapOrThrow(await markAssessmentSuspended(deps.pool, input.assessmentId));
-            // A budget pause records as `canceled`, the same status the analysis run ledger gives it.
-            recordTerminal("canceled");
-        }, { name: "ta-terminal-suspended" });
-        await emitProgress(deps.pool, logger, input.assessmentId, "suspended");
-        await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-canceled");
-        const workflowId = DBOS.workflowID;
-        if (workflowId) {
-            await DBOS.cancelWorkflow(workflowId);
-            // Force one more durable hop so the cancel materialises before the
-            // body returns — without this trailing runStep the workflow would
-            // land SUCCESS in some DBOS versions because the body completed
-            // without re-entering the SDK after the cancel call.
-            await DBOS.runStep(async () => undefined, {
-                name: "ta-self-cancel-budget-exceeded",
-            });
-        }
-        recordTerminalReason("suspended-on-402");
-        return {
-            assessmentId: input.assessmentId,
-            status: "suspended_insufficient_funds",
-            bytes: 0,
-        };
-    }
-    // (§6.5) Unexpected throw — bug somewhere, coverage envelope failed.
-    if (unexpectedError) {
-        await DBOS.runStep(async () => {
-            unwrapOrThrow(await markFailed(deps.pool, input.assessmentId, {
-                kind: "unexpected-throw",
-                message: unexpectedError instanceof Error ? unexpectedError.message : String(unexpectedError),
-            }));
-            recordTerminal("failed");
-        }, { name: "ta-terminal-failed-unexpected" });
-        await emitProgress(deps.pool, logger, input.assessmentId, "failed");
-        await revokeRunAuthorizationSafe(deps, authorization, "target-assessment-failed");
-        recordTerminalReason("unexpected-throw");
-        return {
-            assessmentId: input.assessmentId,
-            status: "failed",
-            bytes: 0,
-        };
-    }
-    // Defensive: this branch is unreachable in practice (one of the
-    // categories above must have fired). Fall through to a generic failed
-    // status so a buggy refactor surfaces visibly.
-    await DBOS.runStep(async () => {
-        unwrapOrThrow(await markFailed(deps.pool, input.assessmentId, {
-            kind: "unexpected-throw",
-            message: "terminal block reached without classified outcome",
-        }));
-        recordTerminal("failed");
-    }, { name: "ta-terminal-failed-uncategorized" });
-    recordTerminalReason("unexpected-throw");
-    return {
-        assessmentId: input.assessmentId,
-        status: "failed",
-        bytes: 0,
-    };
-}
-/**
- * Best-effort revoke wrapped in a durableStep for replay idempotency. This
- * wrapper swallows any runStep-level error so a terminal path is never
- * aborted by a transient revoke failure.
- */
-async function revokeRunAuthorizationSafe(deps, authorization, reason) {
-    const logger = (deps.logger ?? createNoopLogger()).named("execute-target-assessment");
-    try {
-        await DBOS.runStep(() => deps.runAuthorizer.revoke(authorization, reason), {
-            name: `ta-revoke-run-auth:${reason}`,
-        });
-    }
-    catch (err) {
-        logger.warn("revokeRunAuthorization failed", { reason, ...logger.errorFields(err) });
-    }
-}
-// Re-export the canonical TA input schema (consumers and the managed root
-// validate against this shape on the trigger route).
-export { TargetAssessmentInputSchema };

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

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

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

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