@db-lyon/flowkit 0.17.2 → 0.18.0

package/dist/config/schema.d.ts

@@ -1,5 +1,179 @@
 import { z } from 'zod';
 export declare const TaskOptionsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/**
+ * One declared task option. JSON-Schema-like: the constraint keywords are the
+ * JSON Schema ones (`enum`, `minimum`, `maxLength`, `items`, ...) and are
+ * checked with flowkit's built-in validator; `required` and `default` are
+ * per-option here rather than on a parent object.
+ */
+export declare const OptionSpecSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+    description: z.ZodOptional<z.ZodString>;
+    /** The option must be present (after defaults and every override layer). */
+    required: z.ZodOptional<z.ZodBoolean>;
+    /** Used when no layer supplies the option. Lowest precedence of all. */
+    default: z.ZodOptional<z.ZodUnknown>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    const: z.ZodOptional<z.ZodUnknown>;
+    minimum: z.ZodOptional<z.ZodNumber>;
+    maximum: z.ZodOptional<z.ZodNumber>;
+    exclusiveMinimum: z.ZodOptional<z.ZodNumber>;
+    exclusiveMaximum: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+    minItems: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    /** JSON Schema for array elements. */
+    items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** JSON Schema properties for an object-valued option. */
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    additionalProperties: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    minimum?: number | undefined;
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    maximum?: number | undefined;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    default?: unknown;
+    enum?: unknown[] | undefined;
+    const?: unknown;
+    exclusiveMinimum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+    additionalProperties?: boolean | Record<string, unknown> | undefined;
+    nullable?: boolean | undefined;
+}, {
+    minimum?: number | undefined;
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    maximum?: number | undefined;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    default?: unknown;
+    enum?: unknown[] | undefined;
+    const?: unknown;
+    exclusiveMinimum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+    additionalProperties?: boolean | Record<string, unknown> | undefined;
+    nullable?: boolean | undefined;
+}>;
+/** A task's declared options, keyed by option name. */
+export declare const OptionSpecsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+    description: z.ZodOptional<z.ZodString>;
+    /** The option must be present (after defaults and every override layer). */
+    required: z.ZodOptional<z.ZodBoolean>;
+    /** Used when no layer supplies the option. Lowest precedence of all. */
+    default: z.ZodOptional<z.ZodUnknown>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    const: z.ZodOptional<z.ZodUnknown>;
+    minimum: z.ZodOptional<z.ZodNumber>;
+    maximum: z.ZodOptional<z.ZodNumber>;
+    exclusiveMinimum: z.ZodOptional<z.ZodNumber>;
+    exclusiveMaximum: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+    minItems: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+    /** JSON Schema for array elements. */
+    items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** JSON Schema properties for an object-valued option. */
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    additionalProperties: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    nullable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    minimum?: number | undefined;
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    maximum?: number | undefined;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    default?: unknown;
+    enum?: unknown[] | undefined;
+    const?: unknown;
+    exclusiveMinimum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+    additionalProperties?: boolean | Record<string, unknown> | undefined;
+    nullable?: boolean | undefined;
+}, {
+    minimum?: number | undefined;
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    maximum?: number | undefined;
+    description?: string | undefined;
+    required?: boolean | undefined;
+    default?: unknown;
+    enum?: unknown[] | undefined;
+    const?: unknown;
+    exclusiveMinimum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minLength?: number | undefined;
+    maxLength?: number | undefined;
+    pattern?: string | undefined;
+    minItems?: number | undefined;
+    maxItems?: number | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+    additionalProperties?: boolean | Record<string, unknown> | undefined;
+    nullable?: boolean | undefined;
+}>>;
+/**
+ * One declared output: a key the task puts on `TaskResult.data`. Descriptive
+ * only; the runner does not check outputs.
+ */
+export declare const OutputSpecSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+    description: z.ZodOptional<z.ZodString>;
+    items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    description?: string | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+}, {
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    description?: string | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+}>;
+/** A task's declared outputs, keyed by `data` key. */
+export declare const OutputSpecsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+    description: z.ZodOptional<z.ZodString>;
+    items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    description?: string | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+}, {
+    type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+    description?: string | undefined;
+    items?: Record<string, unknown> | undefined;
+    properties?: Record<string, unknown> | undefined;
+}>>;
 export declare const TaskDefinitionSchema: z.ZodObject<{
     /**
      * The task's implementation. Optional: an option-only entry (no class_path)
@@ -14,22 +188,202 @@ export declare const TaskDefinitionSchema: z.ZodObject<{
     /** Declarative hints surfaced in listings; not used by the runner. */
     idempotent: z.ZodOptional<z.ZodBoolean>;
     reversible: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Declared options. Refines (per option, field by field) any static
+     * `optionsSchema` on the task class, and step options are validated against
+     * the result before the task runs.
+     */
+    options_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+        description: z.ZodOptional<z.ZodString>;
+        /** The option must be present (after defaults and every override layer). */
+        required: z.ZodOptional<z.ZodBoolean>;
+        /** Used when no layer supplies the option. Lowest precedence of all. */
+        default: z.ZodOptional<z.ZodUnknown>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        const: z.ZodOptional<z.ZodUnknown>;
+        minimum: z.ZodOptional<z.ZodNumber>;
+        maximum: z.ZodOptional<z.ZodNumber>;
+        exclusiveMinimum: z.ZodOptional<z.ZodNumber>;
+        exclusiveMaximum: z.ZodOptional<z.ZodNumber>;
+        minLength: z.ZodOptional<z.ZodNumber>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+        minItems: z.ZodOptional<z.ZodNumber>;
+        maxItems: z.ZodOptional<z.ZodNumber>;
+        /** JSON Schema for array elements. */
+        items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** JSON Schema properties for an object-valued option. */
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        additionalProperties: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        nullable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        minimum?: number | undefined;
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        maximum?: number | undefined;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        default?: unknown;
+        enum?: unknown[] | undefined;
+        const?: unknown;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        minItems?: number | undefined;
+        maxItems?: number | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+        additionalProperties?: boolean | Record<string, unknown> | undefined;
+        nullable?: boolean | undefined;
+    }, {
+        minimum?: number | undefined;
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        maximum?: number | undefined;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        default?: unknown;
+        enum?: unknown[] | undefined;
+        const?: unknown;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        minItems?: number | undefined;
+        maxItems?: number | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+        additionalProperties?: boolean | Record<string, unknown> | undefined;
+        nullable?: boolean | undefined;
+    }>>>;
+    /** Declared outputs, for `describe` and docs. Not enforced. */
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+        description: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        description?: string | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+    }, {
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        description?: string | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+    }>>>;
+    /**
+     * Mark the task deprecated: `true`, or a string saying why. Running or
+     * planning it adds a `deprecated` warning to the result; it still runs.
+     */
+    deprecated: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    /** The task to use instead, named in the deprecation warning. */
+    replaced_by: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     options: Record<string, unknown>;
-    class_path?: string | undefined;
     description?: string | undefined;
+    class_path?: string | undefined;
     group?: string | undefined;
     idempotent?: boolean | undefined;
     reversible?: boolean | undefined;
+    options_schema?: Record<string, {
+        minimum?: number | undefined;
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        maximum?: number | undefined;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        default?: unknown;
+        enum?: unknown[] | undefined;
+        const?: unknown;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        minItems?: number | undefined;
+        maxItems?: number | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+        additionalProperties?: boolean | Record<string, unknown> | undefined;
+        nullable?: boolean | undefined;
+    }> | undefined;
+    outputs?: Record<string, {
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        description?: string | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+    }> | undefined;
+    deprecated?: string | boolean | undefined;
+    replaced_by?: string | undefined;
 }, {
     options?: Record<string, unknown> | undefined;
-    class_path?: string | undefined;
     description?: string | undefined;
+    class_path?: string | undefined;
     group?: string | undefined;
     idempotent?: boolean | undefined;
     reversible?: boolean | undefined;
+    options_schema?: Record<string, {
+        minimum?: number | undefined;
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        maximum?: number | undefined;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        default?: unknown;
+        enum?: unknown[] | undefined;
+        const?: unknown;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minLength?: number | undefined;
+        maxLength?: number | undefined;
+        pattern?: string | undefined;
+        minItems?: number | undefined;
+        maxItems?: number | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+        additionalProperties?: boolean | Record<string, unknown> | undefined;
+        nullable?: boolean | undefined;
+    }> | undefined;
+    outputs?: Record<string, {
+        type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+        description?: string | undefined;
+        items?: Record<string, unknown> | undefined;
+        properties?: Record<string, unknown> | undefined;
+    }> | undefined;
+    deprecated?: string | boolean | undefined;
+    replaced_by?: string | undefined;
 }>;
-export declare const FlowStepSchema: z.ZodEffects<z.ZodObject<{
+/**
+ * A declared preflight check. `when` is evaluated by the runner's
+ * `conditionEvaluator` (or the built-in `${...}` truthiness fallback); when it
+ * is truthy the check fires and `action` applies: `error` fails before the
+ * step (or flow) starts, `skip` skips it, `warn` records a warning and runs it.
+ */
+export declare const StepCheckSchema: z.ZodObject<{
+    when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+    action: z.ZodEnum<["error", "warn", "skip"]>;
+    /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+    message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    when: string | boolean;
+    action: "error" | "warn" | "skip";
+    message?: string | undefined;
+}, {
+    when: string | boolean;
+    action: "error" | "warn" | "skip";
+    message?: string | undefined;
+}>;
+/**
+ * The fields of one flow step, as a plain object schema.
+ *
+ * Exported unrefined so a host can `.extend()` it for its own manifests (a
+ * plugin manifest, a code-declared flow) and stay in step with every field the
+ * runner understands. Pass the extended schema through `refineFlowStep` to get
+ * the same target rule `FlowStepSchema` enforces.
+ */
+export declare const FlowStepObjectSchema: z.ZodObject<{
     task: z.ZodOptional<z.ZodString>;
     flow: z.ZodOptional<z.ZodString>;
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -48,43 +402,251 @@ export declare const FlowStepSchema: z.ZodEffects<z.ZodObject<{
     when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     /** If true, a failure of this step is recorded but does not abort the flow. */
     ignore_failure: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Preflight checks, evaluated in order just before the step would run (after
+     * `when`), and reported without running anything by `FlowRunner.preflight`.
+     */
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+        action: z.ZodEnum<["error", "warn", "skip"]>;
+        /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
     task?: string | undefined;
     flow?: string | undefined;
     retries?: number | undefined;
     retryDelay?: number | undefined;
     retryOn?: string | undefined;
-    when?: string | boolean | undefined;
     ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
 }, {
     options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
     task?: string | undefined;
     flow?: string | undefined;
     retries?: number | undefined;
     retryDelay?: number | undefined;
     retryOn?: string | undefined;
+    ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}>;
+/**
+ * Apply the step target rule to a step object schema, typically one a host
+ * built with `FlowStepObjectSchema.extend({ ... })`.
+ */
+export declare function refineFlowStep<T extends z.ZodType<{
+    task?: string;
+    flow?: string;
+}>>(schema: T): z.ZodEffects<T>;
+/** One flow step: `FlowStepObjectSchema` with the target rule applied. */
+export declare const FlowStepSchema: z.ZodEffects<z.ZodObject<{
+    task: z.ZodOptional<z.ZodString>;
+    flow: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Retry the step up to N additional times on failure. */
+    retries: z.ZodOptional<z.ZodNumber>;
+    /** Delay between retries, in milliseconds. */
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    /** Only retry when the error message contains this substring. */
+    retryOn: z.ZodOptional<z.ZodString>;
+    /**
+     * Conditional execution. A boolean runs/skips the step directly; a string is
+     * an expression evaluated at runtime by the runner's `conditionEvaluator`
+     * (or the built-in `${...}`-reference truthiness check if none is set). A
+     * falsy result skips the step without failing the flow.
+     */
+    when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    /** If true, a failure of this step is recorded but does not abort the flow. */
+    ignore_failure: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Preflight checks, evaluated in order just before the step would run (after
+     * `when`), and reported without running anything by `FlowRunner.preflight`.
+     */
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+        action: z.ZodEnum<["error", "warn", "skip"]>;
+        /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, unknown> | undefined;
     when?: string | boolean | undefined;
+    task?: string | undefined;
+    flow?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    retryOn?: string | undefined;
     ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}, {
+    options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
+    task?: string | undefined;
+    flow?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    retryOn?: string | undefined;
+    ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
 }>, {
     options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
+    task?: string | undefined;
+    flow?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    retryOn?: string | undefined;
+    ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}, {
+    options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
     task?: string | undefined;
     flow?: string | undefined;
     retries?: number | undefined;
     retryDelay?: number | undefined;
     retryOn?: string | undefined;
+    ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}>;
+/** A flow's `steps:` map, keyed by step number. */
+export declare const FlowStepsSchema: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
+    task: z.ZodOptional<z.ZodString>;
+    flow: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Retry the step up to N additional times on failure. */
+    retries: z.ZodOptional<z.ZodNumber>;
+    /** Delay between retries, in milliseconds. */
+    retryDelay: z.ZodOptional<z.ZodNumber>;
+    /** Only retry when the error message contains this substring. */
+    retryOn: z.ZodOptional<z.ZodString>;
+    /**
+     * Conditional execution. A boolean runs/skips the step directly; a string is
+     * an expression evaluated at runtime by the runner's `conditionEvaluator`
+     * (or the built-in `${...}`-reference truthiness check if none is set). A
+     * falsy result skips the step without failing the flow.
+     */
+    when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    /** If true, a failure of this step is recorded but does not abort the flow. */
+    ignore_failure: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Preflight checks, evaluated in order just before the step would run (after
+     * `when`), and reported without running anything by `FlowRunner.preflight`.
+     */
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+        action: z.ZodEnum<["error", "warn", "skip"]>;
+        /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, unknown> | undefined;
     when?: string | boolean | undefined;
+    task?: string | undefined;
+    flow?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    retryOn?: string | undefined;
     ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
 }, {
     options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
     task?: string | undefined;
     flow?: string | undefined;
     retries?: number | undefined;
     retryDelay?: number | undefined;
     retryOn?: string | undefined;
+    ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}>, {
+    options?: Record<string, unknown> | undefined;
     when?: string | boolean | undefined;
+    task?: string | undefined;
+    flow?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    retryOn?: string | undefined;
     ignore_failure?: boolean | undefined;
-}>;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}, {
+    options?: Record<string, unknown> | undefined;
+    when?: string | boolean | undefined;
+    task?: string | undefined;
+    flow?: string | undefined;
+    retries?: number | undefined;
+    retryDelay?: number | undefined;
+    retryOn?: string | undefined;
+    ignore_failure?: boolean | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
+}>>;
 export declare const FlowDefinitionSchema: z.ZodObject<{
     /**
      * Optional: a flow override (one that layers steps/hooks onto a same-named
@@ -111,42 +673,80 @@ export declare const FlowDefinitionSchema: z.ZodObject<{
         when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
         /** If true, a failure of this step is recorded but does not abort the flow. */
         ignore_failure: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Preflight checks, evaluated in order just before the step would run (after
+         * `when`), and reported without running anything by `FlowRunner.preflight`.
+         */
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+            action: z.ZodEnum<["error", "warn", "skip"]>;
+            /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>>>;
     /** Runs before the first step. Failure fails the flow before steps execute. */
     on_start: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -168,42 +768,80 @@ export declare const FlowDefinitionSchema: z.ZodObject<{
         when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
         /** If true, a failure of this step is recorded but does not abort the flow. */
         ignore_failure: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Preflight checks, evaluated in order just before the step would run (after
+         * `when`), and reported without running anything by `FlowRunner.preflight`.
+         */
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+            action: z.ZodEnum<["error", "warn", "skip"]>;
+            /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, "many">>;
     /** Runs after all steps succeed. */
     on_success: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -225,42 +863,80 @@ export declare const FlowDefinitionSchema: z.ZodObject<{
         when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
         /** If true, a failure of this step is recorded but does not abort the flow. */
         ignore_failure: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Preflight checks, evaluated in order just before the step would run (after
+         * `when`), and reported without running anything by `FlowRunner.preflight`.
+         */
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+            action: z.ZodEnum<["error", "warn", "skip"]>;
+            /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, "many">>;
     /** Runs on any step failure. */
     on_failure: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -282,42 +958,80 @@ export declare const FlowDefinitionSchema: z.ZodObject<{
         when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
         /** If true, a failure of this step is recorded but does not abort the flow. */
         ignore_failure: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Preflight checks, evaluated in order just before the step would run (after
+         * `when`), and reported without running anything by `FlowRunner.preflight`.
+         */
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+            action: z.ZodEnum<["error", "warn", "skip"]>;
+            /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, "many">>;
     /** Runs after success or failure, after on_success/on_failure. */
     finally: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -339,151 +1053,281 @@ export declare const FlowDefinitionSchema: z.ZodObject<{
         when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
         /** If true, a failure of this step is recorded but does not abort the flow. */
         ignore_failure: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Preflight checks, evaluated in order just before the step would run (after
+         * `when`), and reported without running anything by `FlowRunner.preflight`.
+         */
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+            action: z.ZodEnum<["error", "warn", "skip"]>;
+            /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>, "many">>;
     /** If true, invoke rollback records from completed steps in reverse order on failure. */
     rollback_on_failure: z.ZodOptional<z.ZodBoolean>;
+    /** Preflight checks for the whole flow, evaluated before any of its steps or hooks. */
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+        action: z.ZodEnum<["error", "warn", "skip"]>;
+        /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+        message: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }, {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }>, "many">>;
+    /**
+     * How runtime `params` reach the steps of a run started on this flow.
+     * `flat` (the default): every key goes to every step. `step`: each key is a
+     * step selector (a task name or a step path such as `2` or `2/1`) whose value
+     * is the options for the matching steps only.
+     */
+    options_scope: z.ZodOptional<z.ZodEnum<["flat", "step"]>>;
+    /** Mark the flow deprecated: `true`, or a string saying why. It still runs. */
+    deprecated: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    /** The flow to use instead, named in the deprecation warning. */
+    replaced_by: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     steps: Record<string, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }>;
     description?: string | null | undefined;
+    deprecated?: string | boolean | undefined;
+    replaced_by?: string | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
     on_start?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     on_success?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     on_failure?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     finally?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     rollback_on_failure?: boolean | undefined;
+    options_scope?: "flat" | "step" | undefined;
 }, {
     description?: string | null | undefined;
+    deprecated?: string | boolean | undefined;
+    replaced_by?: string | undefined;
+    checks?: {
+        when: string | boolean;
+        action: "error" | "warn" | "skip";
+        message?: string | undefined;
+    }[] | undefined;
     steps?: Record<string, {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }> | undefined;
     on_start?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     on_success?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     on_failure?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     finally?: {
         options?: Record<string, unknown> | undefined;
+        when?: string | boolean | undefined;
         task?: string | undefined;
         flow?: string | undefined;
         retries?: number | undefined;
         retryDelay?: number | undefined;
         retryOn?: string | undefined;
-        when?: string | boolean | undefined;
         ignore_failure?: boolean | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
     }[] | undefined;
     rollback_on_failure?: boolean | undefined;
+    options_scope?: "flat" | "step" | undefined;
 }>;
 /**
  * A tool an agent may call. References an existing flowkit primitive — a `task`,
@@ -708,20 +1552,172 @@ export declare const EngineConfigSchema: z.ZodObject<{
         /** Declarative hints surfaced in listings; not used by the runner. */
         idempotent: z.ZodOptional<z.ZodBoolean>;
         reversible: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * Declared options. Refines (per option, field by field) any static
+         * `optionsSchema` on the task class, and step options are validated against
+         * the result before the task runs.
+         */
+        options_schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+            description: z.ZodOptional<z.ZodString>;
+            /** The option must be present (after defaults and every override layer). */
+            required: z.ZodOptional<z.ZodBoolean>;
+            /** Used when no layer supplies the option. Lowest precedence of all. */
+            default: z.ZodOptional<z.ZodUnknown>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+            const: z.ZodOptional<z.ZodUnknown>;
+            minimum: z.ZodOptional<z.ZodNumber>;
+            maximum: z.ZodOptional<z.ZodNumber>;
+            exclusiveMinimum: z.ZodOptional<z.ZodNumber>;
+            exclusiveMaximum: z.ZodOptional<z.ZodNumber>;
+            minLength: z.ZodOptional<z.ZodNumber>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            pattern: z.ZodOptional<z.ZodString>;
+            minItems: z.ZodOptional<z.ZodNumber>;
+            maxItems: z.ZodOptional<z.ZodNumber>;
+            /** JSON Schema for array elements. */
+            items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            /** JSON Schema properties for an object-valued option. */
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            additionalProperties: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+            nullable: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            minimum?: number | undefined;
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            maximum?: number | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            default?: unknown;
+            enum?: unknown[] | undefined;
+            const?: unknown;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            pattern?: string | undefined;
+            minItems?: number | undefined;
+            maxItems?: number | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+            additionalProperties?: boolean | Record<string, unknown> | undefined;
+            nullable?: boolean | undefined;
+        }, {
+            minimum?: number | undefined;
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            maximum?: number | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            default?: unknown;
+            enum?: unknown[] | undefined;
+            const?: unknown;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            pattern?: string | undefined;
+            minItems?: number | undefined;
+            maxItems?: number | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+            additionalProperties?: boolean | Record<string, unknown> | undefined;
+            nullable?: boolean | undefined;
+        }>>>;
+        /** Declared outputs, for `describe` and docs. Not enforced. */
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, z.ZodArray<z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>, "many">]>>;
+            description: z.ZodOptional<z.ZodString>;
+            items: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            description?: string | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+        }, {
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            description?: string | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+        }>>>;
+        /**
+         * Mark the task deprecated: `true`, or a string saying why. Running or
+         * planning it adds a `deprecated` warning to the result; it still runs.
+         */
+        deprecated: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        /** The task to use instead, named in the deprecation warning. */
+        replaced_by: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         options: Record<string, unknown>;
-        class_path?: string | undefined;
         description?: string | undefined;
+        class_path?: string | undefined;
         group?: string | undefined;
         idempotent?: boolean | undefined;
         reversible?: boolean | undefined;
+        options_schema?: Record<string, {
+            minimum?: number | undefined;
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            maximum?: number | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            default?: unknown;
+            enum?: unknown[] | undefined;
+            const?: unknown;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            pattern?: string | undefined;
+            minItems?: number | undefined;
+            maxItems?: number | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+            additionalProperties?: boolean | Record<string, unknown> | undefined;
+            nullable?: boolean | undefined;
+        }> | undefined;
+        outputs?: Record<string, {
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            description?: string | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+        }> | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
     }, {
         options?: Record<string, unknown> | undefined;
-        class_path?: string | undefined;
         description?: string | undefined;
+        class_path?: string | undefined;
         group?: string | undefined;
         idempotent?: boolean | undefined;
         reversible?: boolean | undefined;
+        options_schema?: Record<string, {
+            minimum?: number | undefined;
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            maximum?: number | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            default?: unknown;
+            enum?: unknown[] | undefined;
+            const?: unknown;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            pattern?: string | undefined;
+            minItems?: number | undefined;
+            maxItems?: number | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+            additionalProperties?: boolean | Record<string, unknown> | undefined;
+            nullable?: boolean | undefined;
+        }> | undefined;
+        outputs?: Record<string, {
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            description?: string | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+        }> | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
     }>>>;
     flows: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         /**
@@ -749,42 +1745,80 @@ export declare const EngineConfigSchema: z.ZodObject<{
             when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
             /** If true, a failure of this step is recorded but does not abort the flow. */
             ignore_failure: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Preflight checks, evaluated in order just before the step would run (after
+             * `when`), and reported without running anything by `FlowRunner.preflight`.
+             */
+            checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+                action: z.ZodEnum<["error", "warn", "skip"]>;
+                /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+                message: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>>>;
         /** Runs before the first step. Failure fails the flow before steps execute. */
         on_start: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -806,42 +1840,80 @@ export declare const EngineConfigSchema: z.ZodObject<{
             when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
             /** If true, a failure of this step is recorded but does not abort the flow. */
             ignore_failure: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Preflight checks, evaluated in order just before the step would run (after
+             * `when`), and reported without running anything by `FlowRunner.preflight`.
+             */
+            checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+                action: z.ZodEnum<["error", "warn", "skip"]>;
+                /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+                message: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, "many">>;
         /** Runs after all steps succeed. */
         on_success: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -863,42 +1935,80 @@ export declare const EngineConfigSchema: z.ZodObject<{
             when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
             /** If true, a failure of this step is recorded but does not abort the flow. */
             ignore_failure: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Preflight checks, evaluated in order just before the step would run (after
+             * `when`), and reported without running anything by `FlowRunner.preflight`.
+             */
+            checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+                action: z.ZodEnum<["error", "warn", "skip"]>;
+                /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+                message: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, "many">>;
         /** Runs on any step failure. */
         on_failure: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -920,42 +2030,80 @@ export declare const EngineConfigSchema: z.ZodObject<{
             when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
             /** If true, a failure of this step is recorded but does not abort the flow. */
             ignore_failure: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Preflight checks, evaluated in order just before the step would run (after
+             * `when`), and reported without running anything by `FlowRunner.preflight`.
+             */
+            checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+                action: z.ZodEnum<["error", "warn", "skip"]>;
+                /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+                message: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, "many">>;
         /** Runs after success or failure, after on_success/on_failure. */
         finally: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
@@ -977,151 +2125,281 @@ export declare const EngineConfigSchema: z.ZodObject<{
             when: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
             /** If true, a failure of this step is recorded but does not abort the flow. */
             ignore_failure: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * Preflight checks, evaluated in order just before the step would run (after
+             * `when`), and reported without running anything by `FlowRunner.preflight`.
+             */
+            checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+                action: z.ZodEnum<["error", "warn", "skip"]>;
+                /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+                message: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }, {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>, "many">>;
         /** If true, invoke rollback records from completed steps in reverse order on failure. */
         rollback_on_failure: z.ZodOptional<z.ZodBoolean>;
+        /** Preflight checks for the whole flow, evaluated before any of its steps or hooks. */
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodUnion<[z.ZodString, z.ZodBoolean]>;
+            action: z.ZodEnum<["error", "warn", "skip"]>;
+            /** Shown in the error, skip reason or warning. Defaults to one naming the condition. */
+            message: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }, {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }>, "many">>;
+        /**
+         * How runtime `params` reach the steps of a run started on this flow.
+         * `flat` (the default): every key goes to every step. `step`: each key is a
+         * step selector (a task name or a step path such as `2` or `2/1`) whose value
+         * is the options for the matching steps only.
+         */
+        options_scope: z.ZodOptional<z.ZodEnum<["flat", "step"]>>;
+        /** Mark the flow deprecated: `true`, or a string saying why. It still runs. */
+        deprecated: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        /** The flow to use instead, named in the deprecation warning. */
+        replaced_by: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         steps: Record<string, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>;
         description?: string | null | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
         on_start?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_success?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_failure?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         finally?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         rollback_on_failure?: boolean | undefined;
+        options_scope?: "flat" | "step" | undefined;
     }, {
         description?: string | null | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
         steps?: Record<string, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }> | undefined;
         on_start?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_success?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_failure?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         finally?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         rollback_on_failure?: boolean | undefined;
+        options_scope?: "flat" | "step" | undefined;
     }>>>;
     agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -1259,65 +2537,127 @@ export declare const EngineConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     tasks: Record<string, {
         options: Record<string, unknown>;
-        class_path?: string | undefined;
         description?: string | undefined;
+        class_path?: string | undefined;
         group?: string | undefined;
         idempotent?: boolean | undefined;
         reversible?: boolean | undefined;
+        options_schema?: Record<string, {
+            minimum?: number | undefined;
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            maximum?: number | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            default?: unknown;
+            enum?: unknown[] | undefined;
+            const?: unknown;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            pattern?: string | undefined;
+            minItems?: number | undefined;
+            maxItems?: number | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+            additionalProperties?: boolean | Record<string, unknown> | undefined;
+            nullable?: boolean | undefined;
+        }> | undefined;
+        outputs?: Record<string, {
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            description?: string | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+        }> | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
     }>;
     flows: Record<string, {
         steps: Record<string, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }>;
         description?: string | null | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
         on_start?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_success?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_failure?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         finally?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         rollback_on_failure?: boolean | undefined;
+        options_scope?: "flat" | "step" | undefined;
     }>;
     agents: Record<string, {
         tools: {
@@ -1348,65 +2688,127 @@ export declare const EngineConfigSchema: z.ZodObject<{
 }, {
     tasks?: Record<string, {
         options?: Record<string, unknown> | undefined;
-        class_path?: string | undefined;
         description?: string | undefined;
+        class_path?: string | undefined;
         group?: string | undefined;
         idempotent?: boolean | undefined;
         reversible?: boolean | undefined;
+        options_schema?: Record<string, {
+            minimum?: number | undefined;
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            maximum?: number | undefined;
+            description?: string | undefined;
+            required?: boolean | undefined;
+            default?: unknown;
+            enum?: unknown[] | undefined;
+            const?: unknown;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            minLength?: number | undefined;
+            maxLength?: number | undefined;
+            pattern?: string | undefined;
+            minItems?: number | undefined;
+            maxItems?: number | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+            additionalProperties?: boolean | Record<string, unknown> | undefined;
+            nullable?: boolean | undefined;
+        }> | undefined;
+        outputs?: Record<string, {
+            type?: "string" | "number" | "boolean" | "object" | "integer" | "array" | "null" | ("string" | "number" | "boolean" | "object" | "integer" | "array" | "null")[] | undefined;
+            description?: string | undefined;
+            items?: Record<string, unknown> | undefined;
+            properties?: Record<string, unknown> | undefined;
+        }> | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
     }> | undefined;
     flows?: Record<string, {
         description?: string | null | undefined;
+        deprecated?: string | boolean | undefined;
+        replaced_by?: string | undefined;
+        checks?: {
+            when: string | boolean;
+            action: "error" | "warn" | "skip";
+            message?: string | undefined;
+        }[] | undefined;
         steps?: Record<string, {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }> | undefined;
         on_start?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_success?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         on_failure?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         finally?: {
             options?: Record<string, unknown> | undefined;
+            when?: string | boolean | undefined;
             task?: string | undefined;
             flow?: string | undefined;
             retries?: number | undefined;
             retryDelay?: number | undefined;
             retryOn?: string | undefined;
-            when?: string | boolean | undefined;
             ignore_failure?: boolean | undefined;
+            checks?: {
+                when: string | boolean;
+                action: "error" | "warn" | "skip";
+                message?: string | undefined;
+            }[] | undefined;
         }[] | undefined;
         rollback_on_failure?: boolean | undefined;
+        options_scope?: "flat" | "step" | undefined;
     }> | undefined;
     agents?: Record<string, {
         description?: string | undefined;
@@ -1436,8 +2838,13 @@ export declare const EngineConfigSchema: z.ZodObject<{
     }> | undefined;
 }>;
 export type TaskOptions = z.infer<typeof TaskOptionsSchema>;
+export type OptionSpec = z.infer<typeof OptionSpecSchema>;
+export type OptionSpecs = z.infer<typeof OptionSpecsSchema>;
+export type OutputSpec = z.infer<typeof OutputSpecSchema>;
+export type OutputSpecs = z.infer<typeof OutputSpecsSchema>;
 export type TaskDefinition = z.infer<typeof TaskDefinitionSchema>;
 export type FlowStep = z.infer<typeof FlowStepSchema>;
+export type StepCheck = z.infer<typeof StepCheckSchema>;
 export type FlowDefinition = z.infer<typeof FlowDefinitionSchema>;
 export type AgentTool = z.infer<typeof AgentToolSchema>;
 export type AgentBudget = z.infer<typeof AgentBudgetSchema>;