@inflexa-ai/harness 0.1.1

package/dist/schemas/plan-schemas.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Planning schemas — used by the generatePlan tool and executeAnalysis
+ * workflow to produce and validate analysis plans.
+ */
+import { z } from "zod";
+import type { AnalysisPlan } from "./workflow-state.js";
+/** Step schema for planner output — omits fields populated at execution time
+ *  and the hardcoded sandbox turn budget. */
+export declare const PlanStepSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
+        cpu: z.ZodNumber;
+        memoryGb: z.ZodNumber;
+        gpu: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    track: z.ZodString;
+    step_type: z.ZodString;
+    question: z.ZodString;
+    acceptance_criteria: z.ZodArray<z.ZodString>;
+    caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    depends_on: z.ZodArray<z.ZodString>;
+    agent: z.ZodEnum<{
+        [x: string]: string;
+    }>;
+}, z.core.$strip>;
+export type PlanStep = z.infer<typeof PlanStepSchema>;
+/** Plan schema for planner output — uses PlanStepSchema for steps and requires
+ *  a concise title (optional on the persistence schema for historical plans). */
+export declare const PlannerPlanSchema: z.ZodObject<{
+    analytical_narrative: z.ZodString;
+    created_at: z.ZodString;
+    omicsType: z.ZodOptional<z.ZodString>;
+    omicsSubtype: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
+            cpu: z.ZodNumber;
+            memoryGb: z.ZodNumber;
+            gpu: z.ZodOptional<z.ZodObject<{
+                count: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        track: z.ZodString;
+        step_type: z.ZodString;
+        question: z.ZodString;
+        acceptance_criteria: z.ZodArray<z.ZodString>;
+        caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        depends_on: z.ZodArray<z.ZodString>;
+        agent: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlannerPlan = z.infer<typeof PlannerPlanSchema>;
+/** Hydrate slim planner output into a full AnalysisPlan with execution-time defaults. */
+export declare function hydratePlanSteps(plannerPlan: PlannerPlan): AnalysisPlan;
+/** Schema for the planning agent's structured output. */
+export declare const PlanningAgentOutputSchema: z.ZodObject<{
+    event: z.ZodEnum<{
+        error: "error";
+        plan_complete: "plan_complete";
+        clarification_needed: "clarification_needed";
+    }>;
+    planId: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodObject<{
+        analytical_narrative: z.ZodString;
+        created_at: z.ZodString;
+        omicsType: z.ZodOptional<z.ZodString>;
+        omicsSubtype: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        steps: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            id: z.ZodString;
+            context: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            resources: z.ZodNonOptional<z.ZodOptional<z.ZodObject<{
+                cpu: z.ZodNumber;
+                memoryGb: z.ZodNumber;
+                gpu: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            track: z.ZodString;
+            step_type: z.ZodString;
+            question: z.ZodString;
+            acceptance_criteria: z.ZodArray<z.ZodString>;
+            caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            depends_on: z.ZodArray<z.ZodString>;
+            agent: z.ZodEnum<{
+                [x: string]: string;
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    question: z.ZodOptional<z.ZodString>;
+    questionContext: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlanningAgentOutput = z.infer<typeof PlanningAgentOutputSchema>;

package/dist/schemas/plan-schemas.js

@@ -0,0 +1,50 @@
+/**
+ * Planning schemas — used by the generatePlan tool and executeAnalysis
+ * workflow to produce and validate analysis plans.
+ */
+import { z } from "zod";
+import { AnalysisStepSchema, AnalysisPlanSchema } from "./workflow-state.js";
+import { PLANNABLE_AGENT_IDS as plannableAgentIds } from "../agents/sandbox-catalog.js";
+import { DEFAULT_SANDBOX_MAX_STEPS } from "../config/resource-limits.js";
+// ── Slim planner schemas (no execution-time fields) ──────────────────
+/** Step schema for planner output — omits fields populated at execution time
+ *  and the hardcoded sandbox turn budget. */
+export const PlanStepSchema = AnalysisStepSchema.omit({
+    status: true,
+    timeout: true,
+    summary: true,
+    artifactIds: true,
+    error: true,
+    maxSteps: true,
+})
+    .required({ agent: true, resources: true })
+    .extend({
+    agent: z.enum(plannableAgentIds).describe("Sandbox agent ID from the available agents list"),
+});
+/** Plan schema for planner output — uses PlanStepSchema for steps and requires
+ *  a concise title (optional on the persistence schema for historical plans). */
+export const PlannerPlanSchema = AnalysisPlanSchema.extend({
+    title: z.string().min(1).max(80).describe("Concise human-readable plan name (3–8 words)"),
+    steps: z.array(PlanStepSchema),
+});
+/** Hydrate slim planner output into a full AnalysisPlan with execution-time defaults. */
+export function hydratePlanSteps(plannerPlan) {
+    return {
+        ...plannerPlan,
+        steps: plannerPlan.steps.map((s) => ({
+            ...s,
+            status: "pending",
+            maxSteps: DEFAULT_SANDBOX_MAX_STEPS,
+        })),
+    };
+}
+// ── Planning agent structured output ─────────────────────────────────
+/** Schema for the planning agent's structured output. */
+export const PlanningAgentOutputSchema = z.object({
+    event: z.enum(["plan_complete", "clarification_needed", "error"]),
+    planId: z.string().optional(),
+    plan: PlannerPlanSchema.optional(),
+    question: z.string().optional(),
+    questionContext: z.string().optional(),
+    error: z.string().optional(),
+});

package/dist/schemas/render-step-prompt.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Render an AnalysisStep into the user-content prompt the sandbox agent
+ * receives as its initial message.
+ *
+ * The planner writes the bulk of a step's instructions into structured
+ * fields (`constraints`, `acceptance_criteria`, `context`, `caveats`,
+ * `description`) alongside the one-line `question`. The execution path
+ * forwards a single `prompt` string to the sandbox agent, so every
+ * instruction-bearing field must be folded into that string here — otherwise
+ * the agent runs against the bare question and improvises the rest.
+ *
+ * `STEP_PROMPT_INSTRUCTION_FIELDS` / `STEP_PROMPT_NON_INSTRUCTION_FIELDS`
+ * partition every AnalysisStep field so the field-coverage guard test can
+ * fail when a new field is added to the schema without a deliberate decision
+ * about whether the agent needs to see it.
+ */
+import type { AnalysisStep } from "./workflow-state.js";
+/** Fields whose content is agent-facing and MUST appear in the rendered prompt. */
+export declare const STEP_PROMPT_INSTRUCTION_FIELDS: readonly ["name", "question", "description", "context", "constraints", "acceptance_criteria", "caveats"];
+/**
+ * Fields deliberately excluded from the prompt: identity/DAG structure
+ * threaded separately through the workflow input, execution knobs, and
+ * result fields populated after the step runs.
+ */
+export declare const STEP_PROMPT_NON_INSTRUCTION_FIELDS: readonly ["id", "track", "step_type", "depends_on", "status", "resources", "agent", "timeout", "maxSteps", "summary", "artifactIds", "error"];
+/**
+ * Compose the agent's initial prompt from a plan step. Only the `question`
+ * is guaranteed present; the remaining instruction fields are appended as
+ * dedicated sections when populated. Empty strings and empty arrays are
+ * skipped so a sparse step renders cleanly.
+ */
+export declare function renderStepPrompt(step: AnalysisStep): string;

package/dist/schemas/render-step-prompt.js

@@ -0,0 +1,76 @@
+/**
+ * Render an AnalysisStep into the user-content prompt the sandbox agent
+ * receives as its initial message.
+ *
+ * The planner writes the bulk of a step's instructions into structured
+ * fields (`constraints`, `acceptance_criteria`, `context`, `caveats`,
+ * `description`) alongside the one-line `question`. The execution path
+ * forwards a single `prompt` string to the sandbox agent, so every
+ * instruction-bearing field must be folded into that string here — otherwise
+ * the agent runs against the bare question and improvises the rest.
+ *
+ * `STEP_PROMPT_INSTRUCTION_FIELDS` / `STEP_PROMPT_NON_INSTRUCTION_FIELDS`
+ * partition every AnalysisStep field so the field-coverage guard test can
+ * fail when a new field is added to the schema without a deliberate decision
+ * about whether the agent needs to see it.
+ */
+/** Fields whose content is agent-facing and MUST appear in the rendered prompt. */
+export const STEP_PROMPT_INSTRUCTION_FIELDS = [
+    "name",
+    "question",
+    "description",
+    "context",
+    "constraints",
+    "acceptance_criteria",
+    "caveats",
+];
+/**
+ * Fields deliberately excluded from the prompt: identity/DAG structure
+ * threaded separately through the workflow input, execution knobs, and
+ * result fields populated after the step runs.
+ */
+export const STEP_PROMPT_NON_INSTRUCTION_FIELDS = [
+    "id",
+    "track",
+    "step_type",
+    "depends_on",
+    "status",
+    "resources",
+    "agent",
+    "timeout",
+    "maxSteps",
+    "summary",
+    "artifactIds",
+    "error",
+];
+function section(heading, body) {
+    return `## ${heading}\n${body}`;
+}
+function bullets(items) {
+    return items.map((i) => `- ${i}`).join("\n");
+}
+/**
+ * Compose the agent's initial prompt from a plan step. Only the `question`
+ * is guaranteed present; the remaining instruction fields are appended as
+ * dedicated sections when populated. Empty strings and empty arrays are
+ * skipped so a sparse step renders cleanly.
+ */
+export function renderStepPrompt(step) {
+    const parts = [`# ${step.name}`, section("Task", step.question)];
+    if (step.description?.trim()) {
+        parts.push(section("What this step produces", step.description.trim()));
+    }
+    if (step.context?.trim()) {
+        parts.push(section("Context", step.context.trim()));
+    }
+    if (step.constraints && step.constraints.length > 0) {
+        parts.push(section("Constraints (these are requirements, not suggestions — follow them exactly)", bullets(step.constraints)));
+    }
+    if (step.acceptance_criteria && step.acceptance_criteria.length > 0) {
+        parts.push(section("Acceptance criteria (the result must satisfy all of these)", bullets(step.acceptance_criteria)));
+    }
+    if (step.caveats && step.caveats.length > 0) {
+        parts.push(section("Caveats", bullets(step.caveats)));
+    }
+    return parts.join("\n\n");
+}

package/dist/schemas/run-synthesis.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Run synthesis schema — cross-step findings grounded in literature.
+ *
+ * Produced by the synthesis step after all sandbox steps complete.
+ * Combines computational findings from step summaries with literature
+ * evidence from the literature-reviewer agent.
+ */
+import { z } from "zod";
+export declare const LiteratureReferenceSchema: z.ZodObject<{
+    pmid: z.ZodString;
+    citation: z.ZodString;
+    relevance: z.ZodString;
+    concordance: z.ZodEnum<{
+        supports: "supports";
+        contradicts: "contradicts";
+        extends: "extends";
+        contextualizes: "contextualizes";
+    }>;
+}, z.core.$strip>;
+export declare const SynthesizedFindingSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    confidence: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    noveltyStatus: z.ZodEnum<{
+        expected: "expected";
+        novel: "novel";
+        confirmed: "confirmed";
+        partially_confirmed: "partially_confirmed";
+        contradicted: "contradicted";
+    }>;
+    literatureInterpretation: z.ZodString;
+    references: z.ZodArray<z.ZodObject<{
+        pmid: z.ZodString;
+        citation: z.ZodString;
+        relevance: z.ZodString;
+        concordance: z.ZodEnum<{
+            supports: "supports";
+            contradicts: "contradicts";
+            extends: "extends";
+            contextualizes: "contextualizes";
+        }>;
+    }, z.core.$strip>>;
+    translationalRelevance: z.ZodOptional<z.ZodObject<{
+        stage: z.ZodEnum<{
+            discovery: "discovery";
+            "preclinical-validation": "preclinical-validation";
+            "biomarker-candidate": "biomarker-candidate";
+            "clinical-evidence": "clinical-evidence";
+        }>;
+        actionType: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            "therapeutic-target": "therapeutic-target";
+            "predictive-biomarker": "predictive-biomarker";
+            "prognostic-biomarker": "prognostic-biomarker";
+            "pharmacodynamic-biomarker": "pharmacodynamic-biomarker";
+            "safety-signal": "safety-signal";
+            "resistance-mechanism": "resistance-mechanism";
+            "patient-stratification": "patient-stratification";
+            "mechanism-of-action": "mechanism-of-action";
+        }>>;
+        rationale: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const BiologicalThemeSchema: z.ZodObject<{
+    name: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    narrative: z.ZodString;
+}, z.core.$strip>;
+export declare const RunSynthesisSchema: z.ZodObject<{
+    runId: z.ZodString;
+    overview: z.ZodString;
+    conclusions: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        noveltyStatus: z.ZodEnum<{
+            expected: "expected";
+            novel: "novel";
+            confirmed: "confirmed";
+            partially_confirmed: "partially_confirmed";
+            contradicted: "contradicted";
+        }>;
+        literatureInterpretation: z.ZodString;
+        references: z.ZodArray<z.ZodObject<{
+            pmid: z.ZodString;
+            citation: z.ZodString;
+            relevance: z.ZodString;
+            concordance: z.ZodEnum<{
+                supports: "supports";
+                contradicts: "contradicts";
+                extends: "extends";
+                contextualizes: "contextualizes";
+            }>;
+        }, z.core.$strip>>;
+        translationalRelevance: z.ZodOptional<z.ZodObject<{
+            stage: z.ZodEnum<{
+                discovery: "discovery";
+                "preclinical-validation": "preclinical-validation";
+                "biomarker-candidate": "biomarker-candidate";
+                "clinical-evidence": "clinical-evidence";
+            }>;
+            actionType: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                "therapeutic-target": "therapeutic-target";
+                "predictive-biomarker": "predictive-biomarker";
+                "prognostic-biomarker": "prognostic-biomarker";
+                "pharmacodynamic-biomarker": "pharmacodynamic-biomarker";
+                "safety-signal": "safety-signal";
+                "resistance-mechanism": "resistance-mechanism";
+                "patient-stratification": "patient-stratification";
+                "mechanism-of-action": "mechanism-of-action";
+            }>>;
+            rationale: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    themes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        findings: z.ZodArray<z.ZodObject<{
+            stepId: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+        narrative: z.ZodString;
+    }, z.core.$strip>>;
+    limitations: z.ZodArray<z.ZodString>;
+    keyReferences: z.ZodArray<z.ZodObject<{
+        pmid: z.ZodString;
+        citation: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunSynthesis = z.infer<typeof RunSynthesisSchema>;
+export type SynthesizedFinding = z.infer<typeof SynthesizedFindingSchema>;
+export type BiologicalTheme = z.infer<typeof BiologicalThemeSchema>;
+export type LiteratureReference = z.infer<typeof LiteratureReferenceSchema>;

package/dist/schemas/run-synthesis.js

@@ -0,0 +1,87 @@
+/**
+ * Run synthesis schema — cross-step findings grounded in literature.
+ *
+ * Produced by the synthesis step after all sandbox steps complete.
+ * Combines computational findings from step summaries with literature
+ * evidence from the literature-reviewer agent.
+ */
+import { z } from "zod";
+export const LiteratureReferenceSchema = z.object({
+    pmid: z.string(),
+    citation: z.string(),
+    relevance: z.string(),
+    concordance: z.enum(["supports", "contradicts", "extends", "contextualizes"]),
+});
+export const SynthesizedFindingSchema = z.object({
+    /** Which step produced this finding. */
+    stepId: z.string(),
+    /** Finding title from the step summary. */
+    title: z.string(),
+    /** Finding description from the step summary. */
+    description: z.string(),
+    /** Confidence from the step summary. */
+    confidence: z.enum(["high", "medium", "low"]),
+    /** Novelty assessment based on literature review. */
+    noveltyStatus: z.enum(["novel", "confirmed", "partially_confirmed", "contradicted", "expected"]),
+    /** How this finding relates to existing literature. */
+    literatureInterpretation: z.string(),
+    /** Supporting or contradicting references. */
+    references: z.array(LiteratureReferenceSchema),
+    /** Translational proximity and actionability assessment. */
+    translationalRelevance: z
+        .object({
+        /** How close this finding is to clinical application. */
+        stage: z.enum(["discovery", "preclinical-validation", "biomarker-candidate", "clinical-evidence"]),
+        /** What type of translational action this finding supports. */
+        actionType: z
+            .enum([
+            "therapeutic-target",
+            "predictive-biomarker",
+            "prognostic-biomarker",
+            "pharmacodynamic-biomarker",
+            "safety-signal",
+            "resistance-mechanism",
+            "patient-stratification",
+            "mechanism-of-action",
+            "none",
+        ])
+            .optional(),
+        /** Brief rationale for the stage and action type. */
+        rationale: z.string(),
+    })
+        .optional(),
+});
+export const BiologicalThemeSchema = z.object({
+    /** Theme name, e.g. "Immune dysregulation", "Metabolic reprogramming". */
+    name: z.string(),
+    /** Findings that contribute to this theme (by stepId + title). */
+    findings: z.array(z.object({ stepId: z.string(), title: z.string() })),
+    /** How these findings connect into a coherent biological story. */
+    narrative: z.string(),
+});
+export const RunSynthesisSchema = z.object({
+    runId: z.string(),
+    /** Brief (2-4 sentence) summary of the run's scope and top-line result. */
+    overview: z.string(),
+    /**
+     * Integrated interpretation: what the run establishes, what is novel,
+     * what is actionable from a translational perspective. This is the
+     * primary interpretive section — the "so what" of the analysis.
+     */
+    conclusions: z.string(),
+    /**
+     * Selective findings — only novel, contradicted, or high-impact results
+     * that warrant individual attention. NOT a per-step catalog.
+     */
+    findings: z.array(SynthesizedFindingSchema),
+    /** Cross-step biological themes. */
+    themes: z.array(BiologicalThemeSchema),
+    /** Methodological and translational caveats. */
+    limitations: z.array(z.string()),
+    /** Key references across all findings. */
+    keyReferences: z.array(z.object({
+        pmid: z.string(),
+        citation: z.string(),
+        description: z.string(),
+    })),
+});

package/dist/schemas/step-summary.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Step summary schema — plain markdown.
+ *
+ * Each sandbox step produces a free-form markdown summary at the end of its
+ * execution. The schema intentionally carries no structured fields — the
+ * markdown body is the single source of truth, rendered verbatim by the UI
+ * and embedded verbatim into the vector search index with `type: "summary"`.
+ *
+ * Literature grounding is handled separately by the run synthesis step
+ * (see run-synthesis.ts).
+ */
+import { z } from "zod";
+export declare const StepSummarySchema: z.ZodObject<{
+    stepId: z.ZodString;
+    agentId: z.ZodString;
+    markdown: z.ZodString;
+}, z.core.$strip>;
+export type StepSummary = z.infer<typeof StepSummarySchema>;

package/dist/schemas/step-summary.js

@@ -0,0 +1,20 @@
+/**
+ * Step summary schema — plain markdown.
+ *
+ * Each sandbox step produces a free-form markdown summary at the end of its
+ * execution. The schema intentionally carries no structured fields — the
+ * markdown body is the single source of truth, rendered verbatim by the UI
+ * and embedded verbatim into the vector search index with `type: "summary"`.
+ *
+ * Literature grounding is handled separately by the run synthesis step
+ * (see run-synthesis.ts).
+ */
+import { z } from "zod";
+export const StepSummarySchema = z.object({
+    /** Step ID this summary belongs to. */
+    stepId: z.string(),
+    /** Agent that produced this summary. */
+    agentId: z.string(),
+    /** Free-form markdown body. Rendered directly by the UI. */
+    markdown: z.string(),
+});

package/dist/schemas/validate-plan.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Plan validation — pure structural checks on an AnalysisPlan.
+ *
+ * Depends only on the plan schema types, the topological sorter, and the
+ * agent id list. No framework dependencies. The `generatePlan` tool imports
+ * this directly.
+ *
+ * Checks:
+ * 1. Topological sort succeeds (no cycles, no missing deps)
+ * 2. Output prefix uniqueness
+ * 3. All agent assignments exist in the agent catalog
+ * 4. All steps have resources defined
+ */
+import type { ResourceLimits } from "../config/resource-limits.js";
+import type { AnalysisPlan } from "./workflow-state.js";
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface ValidatePlanOptions {
+    /**
+     * Host per-step resource ceilings. When present, a step whose declared
+     * `resources` exceed them is an error — the planner gets actionable
+     * feedback at plan time instead of a silent clamp at sandbox creation.
+     * The plan-generation path passes this; `execute_plan` deliberately does
+     * not, so stored plans that predate the policy keep running (the
+     * sandbox-creation clamp remains their backstop).
+     */
+    readonly perStepCeiling?: ResourceLimits;
+}
+/** Derive a filesystem-safe output prefix from a step ID. */
+export declare function deriveOutputPrefix(stepId: string): string;
+/**
+ * Validate an analysis plan for structural correctness.
+ *
+ * Returns `valid: true` if the plan passes all checks, or `valid: false`
+ * with a list of human-readable error strings.
+ */
+export declare function validatePlan(plan: AnalysisPlan, options?: ValidatePlanOptions): ValidationResult;