@inflexa-ai/harness 0.1.1

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

@@ -0,0 +1,94 @@
+/**
+ * Dependency-gated scheduler for `executeAnalysis`.
+ *
+ * Three pure functions over a plan DAG, unit-testable in isolation:
+ *
+ *  - `validatePlanDag` — cycle + missing-dependency detection, typed errors.
+ *  - `scheduleReady`   — given the completed set, return every step whose
+ *                        dependencies are now satisfied and that has not
+ *                        already been started.
+ *  - `computeTopologicalLevels` — UI-only depth per step (level 0 = no deps,
+ *                                 level N = max(level(deps)) + 1). Persisted
+ *                                 on `cortex_step_executions.wave` and emitted
+ *                                 on `data-dag-state`; does NOT gate execution.
+ *
+ * The parent workflow drives the scheduler — it owns the in-flight handle
+ * map and reacts to child completions / failures. Keeping the scheduler
+ * pure means parent recovery replays the same dispatch sequence given the
+ * same persisted child outcomes.
+ */
+import type { MachineBudget, ResourceSpec } from "../config/resource-limits.js";
+/**
+ * The minimum shape the scheduler needs from a plan step. Larger workflow-state
+ * schemas are a superset of this, keeping the scheduler decoupled.
+ */
+export interface PlanStep {
+    readonly id: string;
+    readonly depends_on: readonly string[];
+}
+/** Budget-admission inputs — the snapshotted machine budget from the workflow
+ *  input plus each step's plan-declared resources. */
+export interface BudgetAdmission {
+    readonly budget: MachineBudget;
+    readonly resourcesByStepId: Readonly<Record<string, ResourceSpec>>;
+}
+/** Partition of the dependency-satisfied steps under budget admission. */
+export interface ScheduledSteps {
+    /** Steps to start now — they fit the remaining budget capacity. */
+    readonly admit: readonly string[];
+    /** Dependency-satisfied steps held until in-flight steps free capacity. */
+    readonly heldForCapacity: readonly string[];
+    /** Steps whose declared resources exceed the budget outright — they could
+     *  never be admitted even against an empty budget. */
+    readonly neverFits: readonly string[];
+}
+/** Thrown when the plan DAG contains a dependency cycle. */
+export declare class CycleError extends Error {
+    readonly involvedSteps: readonly string[];
+    constructor(involvedSteps: readonly string[]);
+}
+/** Thrown when a step references a `depends_on` id that does not exist. */
+export declare class MissingDependencyError extends Error {
+    readonly stepId: string;
+    readonly missingDependency: string;
+    constructor(stepId: string, missingDependency: string);
+}
+/** Thrown when two steps share the same `id`. */
+export declare class DuplicateStepIdError extends Error {
+    readonly stepId: string;
+    constructor(stepId: string);
+}
+/**
+ * Validate a plan DAG. Throws on duplicate ids, missing dependencies, or
+ * cycles. Returns the validated step map for convenient downstream use.
+ */
+export declare function validatePlanDag<S extends PlanStep>(steps: readonly S[]): Map<string, S>;
+/**
+ * Return every step that is now eligible to start: all of its `depends_on`
+ * are in `completedSet`, and the step itself is not yet in `startedSet`.
+ *
+ * Pure function — the parent workflow recomputes this after every child
+ * completion (or on parent recovery) and dispatches each returned id via
+ * `DBOS.startWorkflow`. Order in the returned array follows the plan's
+ * declared order for deterministic dispatch.
+ *
+ * With `admission`, the dependency-satisfied steps are additionally gated on
+ * the machine budget and partitioned instead of returned flat: a step is
+ * admitted only while the declared resources of the in-flight steps
+ * (`startedSet`) plus every step admitted earlier in the round leave room for
+ * it. Admission is greedy in plan order with skip-over — a candidate that does
+ * not fit never blocks a later, smaller one. Determinism holds because every
+ * input derives from the workflow input and checkpointed completion state.
+ */
+export declare function scheduleReady<S extends PlanStep>(steps: readonly S[], completedSet: ReadonlySet<string>, startedSet?: ReadonlySet<string>): string[];
+export declare function scheduleReady<S extends PlanStep>(steps: readonly S[], completedSet: ReadonlySet<string>, startedSet: ReadonlySet<string>, admission: BudgetAdmission): ScheduledSteps;
+/**
+ * Compute a depth per step. A step with no dependencies is level 0; a step
+ * with deps is `max(level(dep)) + 1`. Used by the UI for column layout in
+ * the DAG view and persisted as `cortex_step_executions.wave` for legacy
+ * compatibility — it does NOT gate execution.
+ *
+ * Pre-condition: `validatePlanDag` has been called (no cycles, no missing
+ * deps). Behaviour is undefined on an invalid DAG.
+ */
+export declare function computeTopologicalLevels<S extends PlanStep>(steps: readonly S[]): Map<string, number>;

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

@@ -0,0 +1,186 @@
+/**
+ * Dependency-gated scheduler for `executeAnalysis`.
+ *
+ * Three pure functions over a plan DAG, unit-testable in isolation:
+ *
+ *  - `validatePlanDag` — cycle + missing-dependency detection, typed errors.
+ *  - `scheduleReady`   — given the completed set, return every step whose
+ *                        dependencies are now satisfied and that has not
+ *                        already been started.
+ *  - `computeTopologicalLevels` — UI-only depth per step (level 0 = no deps,
+ *                                 level N = max(level(deps)) + 1). Persisted
+ *                                 on `cortex_step_executions.wave` and emitted
+ *                                 on `data-dag-state`; does NOT gate execution.
+ *
+ * The parent workflow drives the scheduler — it owns the in-flight handle
+ * map and reacts to child completions / failures. Keeping the scheduler
+ * pure means parent recovery replays the same dispatch sequence given the
+ * same persisted child outcomes.
+ */
+// ── Errors ───────────────────────────────────────────────────────────
+/** Thrown when the plan DAG contains a dependency cycle. */
+export class CycleError extends Error {
+    involvedSteps;
+    constructor(involvedSteps) {
+        super(`dependency cycle detected involving steps: ${involvedSteps.join(", ")}`);
+        this.involvedSteps = involvedSteps;
+        this.name = "CycleError";
+    }
+}
+/** Thrown when a step references a `depends_on` id that does not exist. */
+export class MissingDependencyError extends Error {
+    stepId;
+    missingDependency;
+    constructor(stepId, missingDependency) {
+        super(`step "${stepId}" depends on "${missingDependency}" which is not in the plan`);
+        this.stepId = stepId;
+        this.missingDependency = missingDependency;
+        this.name = "MissingDependencyError";
+    }
+}
+/** Thrown when two steps share the same `id`. */
+export class DuplicateStepIdError extends Error {
+    stepId;
+    constructor(stepId) {
+        super(`plan contains duplicate step id "${stepId}"`);
+        this.stepId = stepId;
+        this.name = "DuplicateStepIdError";
+    }
+}
+// ── Validation ───────────────────────────────────────────────────────
+/**
+ * Validate a plan DAG. Throws on duplicate ids, missing dependencies, or
+ * cycles. Returns the validated step map for convenient downstream use.
+ */
+export function validatePlanDag(steps) {
+    const stepById = new Map();
+    for (const step of steps) {
+        if (stepById.has(step.id)) {
+            throw new DuplicateStepIdError(step.id);
+        }
+        stepById.set(step.id, step);
+    }
+    for (const step of steps) {
+        for (const dep of step.depends_on) {
+            if (!stepById.has(dep)) {
+                throw new MissingDependencyError(step.id, dep);
+            }
+        }
+    }
+    detectCycle(steps);
+    return stepById;
+}
+/**
+ * Iterative DFS cycle detection — Kahn-style would also work, but DFS lets
+ * us surface the participating step ids directly when a cycle is found.
+ */
+function detectCycle(steps) {
+    const VISITING = 1;
+    const DONE = 2;
+    const state = new Map();
+    const stepById = new Map(steps.map((s) => [s.id, s]));
+    for (const start of steps) {
+        if (state.get(start.id) === DONE)
+            continue;
+        // Iterative DFS — preserves the in-progress chain so we can report it.
+        const stack = [{ id: start.id, iter: stepById.get(start.id).depends_on[Symbol.iterator]() }];
+        state.set(start.id, VISITING);
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            const next = frame.iter.next();
+            if (next.done) {
+                state.set(frame.id, DONE);
+                stack.pop();
+                continue;
+            }
+            const childId = next.value;
+            const childState = state.get(childId);
+            if (childState === VISITING) {
+                const cycle = stack.map((f) => f.id);
+                cycle.push(childId);
+                throw new CycleError(cycle);
+            }
+            if (childState === DONE)
+                continue;
+            state.set(childId, VISITING);
+            stack.push({
+                id: childId,
+                iter: stepById.get(childId).depends_on[Symbol.iterator](),
+            });
+        }
+    }
+}
+export function scheduleReady(steps, completedSet, startedSet = new Set(), admission) {
+    const ready = [];
+    for (const step of steps) {
+        if (startedSet.has(step.id) || completedSet.has(step.id))
+            continue;
+        if (step.depends_on.every((d) => completedSet.has(d))) {
+            ready.push(step.id);
+        }
+    }
+    if (!admission)
+        return ready;
+    const { budget, resourcesByStepId } = admission;
+    // A step with no declared resources weighs nothing — it is never throttled,
+    // matching the unbudgeted legacy behavior for that step.
+    const weightOf = (id) => resourcesByStepId[id] ?? { cpu: 0, memoryGb: 0 };
+    let usedCpu = 0;
+    let usedMemoryGb = 0;
+    for (const id of startedSet) {
+        const w = weightOf(id);
+        usedCpu += w.cpu;
+        usedMemoryGb += w.memoryGb;
+    }
+    const admit = [];
+    const heldForCapacity = [];
+    const neverFits = [];
+    for (const id of ready) {
+        const w = weightOf(id);
+        if (w.cpu > budget.cpu || w.memoryGb > budget.memoryGb) {
+            neverFits.push(id);
+        }
+        else if (usedCpu + w.cpu <= budget.cpu && usedMemoryGb + w.memoryGb <= budget.memoryGb) {
+            admit.push(id);
+            usedCpu += w.cpu;
+            usedMemoryGb += w.memoryGb;
+        }
+        else {
+            heldForCapacity.push(id);
+        }
+    }
+    return { admit, heldForCapacity, neverFits };
+}
+// ── Topological levels (UI layout) ───────────────────────────────────
+/**
+ * Compute a depth per step. A step with no dependencies is level 0; a step
+ * with deps is `max(level(dep)) + 1`. Used by the UI for column layout in
+ * the DAG view and persisted as `cortex_step_executions.wave` for legacy
+ * compatibility — it does NOT gate execution.
+ *
+ * Pre-condition: `validatePlanDag` has been called (no cycles, no missing
+ * deps). Behaviour is undefined on an invalid DAG.
+ */
+export function computeTopologicalLevels(steps) {
+    const stepById = new Map(steps.map((s) => [s.id, s]));
+    const levels = new Map();
+    function levelOf(id) {
+        const cached = levels.get(id);
+        if (cached !== undefined)
+            return cached;
+        const step = stepById.get(id);
+        if (step === undefined) {
+            throw new MissingDependencyError("(internal)", id);
+        }
+        let level = 0;
+        for (const dep of step.depends_on) {
+            level = Math.max(level, levelOf(dep) + 1);
+        }
+        levels.set(id, level);
+        return level;
+    }
+    for (const step of steps) {
+        levelOf(step.id);
+    }
+    return levels;
+}

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

@@ -0,0 +1,271 @@
+/**
+ * `executeAnalysis` — the parent DBOS workflow.
+ *
+ * Shape (every external interaction is a `DBOS.runStep` so a crashed parent
+ * replays from the cache instead of repeating side effects):
+ *
+ *  1. `validateAndInit`
+ *     - validate the plan DAG (cycle / missing-dep / dup-id)
+ *     - create the run dir
+ *     - open the running charge
+ *     - emit `data-run-started`
+ *     Inputs are NOT materialized here: the workspace tree's `data/` inputs must
+ *     already be populated by the embedder before the run is triggered — the
+ *     workflow neither downloads nor stages input data.
+ *     The run authorization is minted at the async edge (`executePlan` / TA
+ *     trigger / `runDataProfile`) and rides in `input.runSession` — the
+ *     workflow body never mints, never reads the JWT back from `cortex_runs`.
+ *  2. Scheduler loop
+ *     - maintain `completedSet` + `inFlightHandles`
+ *     - dispatch every `scheduleReady(plan, completedSet, startedSet)` via
+ *       `DBOS.startWorkflow` with deterministic child id
+ *       `"${parent.workflowID}-${N}"` (N is the step's stable index)
+ *     - each child input is `forStep(input.runSession, stepId)` for the
+ *       session field
+ *     - emit `data-dag-state` (reconciling by id) on every dispatch +
+ *       completion
+ *     - await child results via `getResult` (these are themselves cached
+ *       in DBOS, so parent recovery does NOT re-run completed children)
+ *  3. Fail-fast cascade
+ *     - on the first non-resumable child failure (or on external parent
+ *       cancel): stop scheduling, then
+ *       `Promise.allSettled(handles.map(h => DBOS.cancelWorkflow(h.workflowID)))`
+ *     - each cancelled child tears down its sandbox in its own terminal path
+ *  4. Pause cascade (402)
+ *     - on a child cancelling itself with `budget_exceeded`: cancel siblings
+ *       then self-cancel the parent to `CANCELLED` (NOT `ERROR` — ERROR
+ *       isn't resumable; NOTES #3)
+ *     - the analysis flips to `suspended_insufficient_funds` in
+ *       `collectAndComplete`. The paused parent lands in `CANCELLED`, a
+ *       durably reschedulable state; re-driving it after a top-up is a
+ *       future enhancement, not yet wired here.
+ *  5. `synthesizeFindings` (single sequential block, no sandbox)
+ *  6. `collectAndComplete` (terminal — runs on ALL paths)
+ *     - determine final status from completed/cancelled/failed counts
+ *     - update `cortex_runs.status` + `error`
+ *     - close running charge with matching reason
+ *     - revoke run authorization via the injected `runAuthorizer` seam
+ *     - emit terminal stream part
+ *     - WRITES NOTHING to the conversation thread (results are pull-only
+ *       via `inspectRun`)
+ */
+import type { Pool } from "pg";
+import type { MachineBudget, ResourceSpec } from "../config/resource-limits.js";
+import type { RunSession } from "../auth/types.js";
+import type { RunAuthorizer } from "../execution/run-authorizer.js";
+import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
+import type { BioToolKeys } from "../tools/bio/keys.js";
+import type { RunCharge } from "../billing/run-charge.js";
+import { type ResolveWorkspaceRoot } from "../workspace/paths.js";
+import { type PlanStep } from "./execute-analysis-scheduler.js";
+import { type SandboxStepInput, type SandboxStepResult } from "./sandbox-step.js";
+/** Registered child sandbox-step callable the parent's child-dispatch closes over. */
+type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxStepResult>;
+/** Quick-display finding on the run-completed card. Mirrors the wire schema's RunCompletedFinding. */
+export interface RunFinding {
+    readonly title: string;
+    readonly confidence: "high" | "medium" | "low";
+}
+export interface ExecuteAnalysisInput {
+    readonly analysisId: string;
+    /** Plan id — the dedup key for the partial-unique index on cortex_runs. */
+    readonly planId: string;
+    /** Human-readable plan summary for the run-started card (title or narrative). */
+    readonly planSummary: string;
+    /** Plan steps with `id` and `depends_on`. Validated before any side effect. */
+    readonly steps: readonly PlanStep[];
+    /** Optional thread id for cortex_runs.thread_id (UI breadcrumb only). */
+    readonly threadId?: string | null;
+    /** Per-step prompt body the child workflow forwards to its agent. */
+    readonly promptByStepId: Readonly<Record<string, string>>;
+    /** Per-step agent id (sandbox catalog entry). */
+    readonly agentByStepId: Readonly<Record<string, string>>;
+    /** Per-step planner-estimated sandbox resource request. */
+    readonly resourcesByStepId: Readonly<Record<string, ResourceSpec>>;
+    /**
+     * Per-step execution timeout in seconds, from the plan's `step.timeout`.
+     * Only present for steps that declared one; the child falls back to
+     * `DEFAULT_STEP_TIMEOUT_SECONDS` when a step is absent here.
+     */
+    readonly timeoutByStepId?: Readonly<Record<string, number>>;
+    /**
+     * Machine resource budget snapshotted by `executePlan` at the async edge.
+     * The scheduler admits dependency-satisfied steps only while the declared
+     * resources of concurrently running steps fit within it. Absent (no policy
+     * configured, or a workflow persisted before this field existed), every
+     * dependency-satisfied step starts immediately — the legacy fan-out.
+     */
+    readonly budget?: MachineBudget;
+    /**
+     * Durable `RunSession` minted at the async edge by `executePlan`.
+     * Carries the run-authorization credential, identity, scope, and `runFrame.runId`.
+     * DBOS replay reconstructs it from the serialized workflow input on
+     * resume — no DB read, no in-process cache.
+     */
+    readonly runSession: RunSession;
+    /**
+     * True when Cortex owns the run-authorization lifecycle and therefore must
+     * revoke it on the terminal path. The ownership decision is made by the
+     * `RunAuthorizer` seam at the async edge (`executePlan`).
+     *
+     * Optional because a workflow persisted before this field existed (recovered
+     * across the deploy that added it) deserializes without it; the body defaults
+     * absent → true, matching the prior Cortex-owned behavior.
+     */
+    readonly ownsMandate?: boolean;
+}
+/**
+ * Outcome of the trigger. `running` is what the dedup-collision recovery
+ * path returns — the caller joined an in-flight run, no new workflow was
+ * started. Every other variant is a terminal status the parent reached.
+ */
+export type ExecuteAnalysisFinalStatus = "running" | "completed" | "partial" | "failed" | "canceled";
+export interface ExecuteAnalysisResult {
+    readonly runId: string;
+    readonly workflowId: string;
+    readonly status: ExecuteAnalysisFinalStatus;
+    readonly completedSteps: readonly string[];
+    readonly failedSteps: readonly string[];
+    readonly canceledSteps: readonly string[];
+}
+/**
+ * A run-lifecycle provenance observation handed to an optional host observer.
+ * Harness-owned plain union — the harness stays tsprov-free and bus-free; the
+ * host maps these execution facts onto its own ledger vocabulary.
+ *
+ * Every `atMs` is epoch milliseconds read via `await DBOS.now()`, a checkpointed
+ * step: a body re-executed by DBOS recovery reads the recorded value, so a
+ * re-emitted event carries the identical timestamp and merges on the host's
+ * ledger without a value conflict. Never source these from a wall clock
+ * (`Date.now()`) — that would diverge across replays and defeat the merge.
+ *
+ * `run_completed.durationMs` is the terminal `atMs` minus the `run_started`
+ * `atMs` (both `DBOS.now()` reads) — the true workflow-observed run span.
+ *
+ * `step_completed` fires once at EVERY scheduler-loop settlement — the only site
+ * that observes every executed step (registration sees only artifact-producing
+ * steps, and a child cannot observe its own parent-driven cancel). Steps that
+ * were never dispatched (dependents of a failed sibling) emit nothing by design;
+ * the run's terminal status carries that outcome. `status` maps the settlement
+ * outcome: `complete` → `"completed"`, `canceled` → `"canceled"`,
+ * `failed`/`blocked`/child-error → `"failed"`.
+ *
+ * `run_completed` fires at BOTH terminal boundaries (success and failure); the
+ * `status` field distinguishes them.
+ */
+export type RunProvenanceEvent = {
+    type: "run_started";
+    analysisId: string;
+    runId: string;
+    planSummary: string;
+    stepCount: number;
+    atMs: number;
+} | {
+    type: "step_completed";
+    analysisId: string;
+    runId: string;
+    stepId: string;
+    /** Settlement outcome mapped to a terminal step status. */
+    status: "completed" | "failed" | "canceled";
+    /** The child's durable execution duration; absent when the child settled by throwing. */
+    durationMs?: number;
+    atMs: number;
+} | {
+    type: "run_completed";
+    analysisId: string;
+    runId: string;
+    /**
+     * The body's terminal status. Both boundary sites resolve it through `deriveFinalStatus`,
+     * which records a budget pause as `"canceled"` — so `"suspended_insufficient_funds"` (a
+     * `RunStatus` member) is never emitted here and is deliberately absent from this narrower
+     * `ExecuteAnalysisFinalStatus`-minus-`"running"` set.
+     */
+    status: Exclude<ExecuteAnalysisFinalStatus, "running">;
+    atMs: number;
+    /** `atMs − run_started.atMs`: the workflow-observed run span in ms. */
+    durationMs: number;
+};
+/**
+ * Construction-time deps for the parent workflow. The order-of-operations is
+ * the body's own: it brackets the run, dispatches children, and synthesizes
+ * directly via `DBOS.*` + the harness's helpers. Only the genuinely host-specific seams
+ * stay injected — the run-charge bracket, run-authorization revoke, and the
+ * registered sandbox-step callable — plus the construction inputs (provider,
+ * embedder, model, keys, roots) the in-body synthesis needs.
+ */
+export interface ExecuteAnalysisDeps {
+    readonly pool: Pool;
+    /** Chat provider for the in-body literature-grounded synthesis. */
+    readonly provider: ChatProvider;
+    /** Write-side embedder for indexing the run synthesis. */
+    readonly embedding: EmbeddingProvider;
+    /** Registered child sandbox-step callable the body dispatches per step. */
+    readonly sandboxStepCallable: SandboxStepCallable;
+    /** Workspace-root resolution seam — run dir creation + synthesis disk reads. */
+    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    /** Model id for the synthesizer agent loop. */
+    readonly synthesisModel: string;
+    /** API keys for the bio/chem tools the embedded literature reviewer uses. */
+    readonly bioKeys: BioToolKeys;
+    /** Run-level billing-bracket seam (managed: external bracket; OSS: no-op). */
+    readonly runCharge: RunCharge;
+    /**
+     * When false, skip run-level synthesis entirely (findings stay empty).
+     * Config, not a seam. Defaults to true.
+     */
+    readonly synthesisEnabled?: boolean;
+    /** Run-authorization seam — the terminal path revokes through `revoke`. */
+    readonly runAuthorizer: RunAuthorizer;
+    /**
+     * Optional, fire-and-forget provenance observation of the run lifecycle.
+     * Deliberately invoked directly in the workflow body (NOT wrapped in
+     * `DBOS.runStep`) so that body re-execution on DBOS recovery re-fires it —
+     * a cached step would suppress the recovery re-emission, defeating the
+     * point. Idempotency is the consumer's job, achieved via the deterministic
+     * identifiers the events carry, not via step caching. Every call site is
+     * guarded so a throwing observer never fails the run.
+     */
+    readonly emitProvenance?: (event: RunProvenanceEvent) => void;
+}
+/**
+ * Project the sandbox-step input handed to each child. The parent owns the
+ * level computation; the rest comes from `ExecuteAnalysisInput`. The body
+ * fills in `runSession` via `forStep` after this returns. Exported for the
+ * projection/timeout-propagation tests.
+ */
+export declare function buildChildInput(args: {
+    input: ExecuteAnalysisInput;
+    stepId: string;
+    level: number;
+    runId: string;
+    workflowId: string;
+}): Omit<SandboxStepInput, "runSession">;
+/**
+ * Run-level literature-grounded synthesis (no sandbox). Returns the
+ * quick-display findings for the run-completed card; empty when synthesis is
+ * skipped or produced no synthesizable content. A genuine failure re-throws
+ * inside the caller's `DBOS.runStep`, failing the run (D10). Exported so
+ * integration tests can drive the wired synthesis without a full parent body.
+ */
+export declare function synthesizeFindings(args: {
+    analysisId: string;
+    runId: string;
+    completedSteps: readonly string[];
+    session: RunSession;
+    deps: ExecuteAnalysisDeps;
+}): Promise<{
+    findings: readonly RunFinding[];
+}>;
+/**
+ * Register the executeAnalysis parent workflow with DBOS. Caller is
+ * responsible for setting `workflowID = runId` via
+ * `DBOS.startWorkflow(_, { workflowID })` — the body assumes that contract
+ * and uses `DBOS.workflowID` as the source of truth.
+ */
+export declare function registerExecuteAnalysis(deps: ExecuteAnalysisDeps): (input: ExecuteAnalysisInput) => Promise<ExecuteAnalysisResult>;
+/**
+ * Body extracted so tests can drive it without registering a workflow
+ * (the DBOS calls inside still rely on a workflow context being present).
+ */
+export declare function runExecuteAnalysisBody(input: ExecuteAnalysisInput, deps: ExecuteAnalysisDeps): Promise<ExecuteAnalysisResult>;
+export {};