@inflexa-ai/harness 0.1.1 → 0.2.0

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;
-}>;

package/dist/workflows/target-assessment/steps/phase0-resolve.js

@@ -1,21 +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.
- */
-import { TargetAssessmentInputSchema, ResolvedTargetSchema } from "../schemas.js";
-import { resolveTarget } from "../../../tools/lib/identifier-resolver.js";
-export const phase0InputSchema = TargetAssessmentInputSchema;
-export const phase0OutputSchema = ResolvedTargetSchema;
-export async function phase0Execute(inputData) {
-    const resolved = await resolveTarget(inputData.target);
-    return {
-        assessmentId: inputData.assessmentId,
-        goal: inputData.goal ?? null,
-        ...resolved,
-    };
-}