@defai.digital/contracts 13.0.3

package/dist/orchestration/v1/schema.d.ts

@@ -0,0 +1,1384 @@
+/**
+ * Orchestration Domain Contracts v1
+ *
+ * Schemas for task orchestration, scheduling, and multi-agent coordination.
+ */
+import { z } from 'zod';
+/**
+ * Orchestration task status
+ */
+export declare const OrchTaskStatusSchema: z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>;
+export type OrchTaskStatus = z.infer<typeof OrchTaskStatusSchema>;
+/**
+ * Orchestration task priority
+ */
+export declare const OrchTaskPrioritySchema: z.ZodEnum<["critical", "high", "medium", "low", "background"]>;
+export type OrchTaskPriority = z.infer<typeof OrchTaskPrioritySchema>;
+/**
+ * Orchestration task type
+ */
+export declare const OrchTaskTypeSchema: z.ZodEnum<["sequential", "parallel", "conditional", "loop", "retry", "timeout", "wait", "callback", "other"]>;
+export type OrchTaskType = z.infer<typeof OrchTaskTypeSchema>;
+/**
+ * Task dependency
+ */
+export declare const TaskDependencySchema: z.ZodObject<{
+    taskId: z.ZodString;
+    condition: z.ZodDefault<z.ZodEnum<["completed", "failed", "any", "all"]>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    condition: "completed" | "failed" | "all" | "any";
+    timeout?: number | undefined;
+}, {
+    taskId: string;
+    timeout?: number | undefined;
+    condition?: "completed" | "failed" | "all" | "any" | undefined;
+}>;
+export type TaskDependency = z.infer<typeof TaskDependencySchema>;
+/**
+ * Orchestration retry policy
+ */
+export declare const OrchRetryPolicySchema: z.ZodObject<{
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    initialDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxDelayMs: z.ZodDefault<z.ZodNumber>;
+    backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+    retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    maxAttempts: number;
+    backoffMultiplier: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    retryableErrors?: string[] | undefined;
+}, {
+    maxAttempts?: number | undefined;
+    backoffMultiplier?: number | undefined;
+    initialDelayMs?: number | undefined;
+    maxDelayMs?: number | undefined;
+    retryableErrors?: string[] | undefined;
+}>;
+export type OrchRetryPolicy = z.infer<typeof OrchRetryPolicySchema>;
+/**
+ * Task timeout policy
+ */
+export declare const TimeoutPolicySchema: z.ZodObject<{
+    executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    executionTimeoutMs: number;
+    gracefulShutdownMs: number;
+    queueTimeoutMs?: number | undefined;
+}, {
+    executionTimeoutMs?: number | undefined;
+    queueTimeoutMs?: number | undefined;
+    gracefulShutdownMs?: number | undefined;
+}>;
+export type TimeoutPolicy = z.infer<typeof TimeoutPolicySchema>;
+/**
+ * Task definition
+ */
+export declare const TaskDefinitionSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["sequential", "parallel", "conditional", "loop", "retry", "timeout", "wait", "callback", "other"]>>;
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "medium", "low", "background"]>>;
+    agentId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        condition: z.ZodDefault<z.ZodEnum<["completed", "failed", "any", "all"]>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        taskId: string;
+        condition: "completed" | "failed" | "all" | "any";
+        timeout?: number | undefined;
+    }, {
+        taskId: string;
+        timeout?: number | undefined;
+        condition?: "completed" | "failed" | "all" | "any" | undefined;
+    }>, "many">>;
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    }>>;
+    timeoutPolicy: z.ZodOptional<z.ZodObject<{
+        executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    }, {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    }>>;
+    scheduledAt: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+    name: string;
+    priority: "critical" | "high" | "medium" | "low" | "background";
+    taskId: string;
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    agentId?: string | undefined;
+    sessionId?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    tags?: string[] | undefined;
+    dependencies?: {
+        taskId: string;
+        condition: "completed" | "failed" | "all" | "any";
+        timeout?: number | undefined;
+    }[] | undefined;
+    timeoutPolicy?: {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    } | undefined;
+    scheduledAt?: string | undefined;
+}, {
+    name: string;
+    taskId: string;
+    type?: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback" | undefined;
+    retryPolicy?: {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    priority?: "critical" | "high" | "medium" | "low" | "background" | undefined;
+    agentId?: string | undefined;
+    sessionId?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    tags?: string[] | undefined;
+    dependencies?: {
+        taskId: string;
+        timeout?: number | undefined;
+        condition?: "completed" | "failed" | "all" | "any" | undefined;
+    }[] | undefined;
+    timeoutPolicy?: {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    } | undefined;
+    scheduledAt?: string | undefined;
+}>;
+export type TaskDefinition = z.infer<typeof TaskDefinitionSchema>;
+/**
+ * Task execution state
+ */
+export declare const TaskExecutionSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    status: z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>;
+    attempt: z.ZodDefault<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    error: z.ZodOptional<z.ZodString>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    lastHeartbeat: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+    taskId: string;
+    attempt: number;
+    error?: string | undefined;
+    progress?: number | undefined;
+    output?: Record<string, unknown> | undefined;
+    completedAt?: string | undefined;
+    startedAt?: string | undefined;
+    lastHeartbeat?: string | undefined;
+}, {
+    status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+    taskId: string;
+    error?: string | undefined;
+    progress?: number | undefined;
+    output?: Record<string, unknown> | undefined;
+    completedAt?: string | undefined;
+    startedAt?: string | undefined;
+    attempt?: number | undefined;
+    lastHeartbeat?: string | undefined;
+}>;
+export type TaskExecution = z.infer<typeof TaskExecutionSchema>;
+/**
+ * Queue create request
+ */
+export declare const QueueCreateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    maxConcurrency: z.ZodDefault<z.ZodNumber>;
+    defaultPriority: z.ZodDefault<z.ZodEnum<["critical", "high", "medium", "low", "background"]>>;
+    defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    }>>;
+    defaultTimeoutPolicy: z.ZodOptional<z.ZodObject<{
+        executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    }, {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    maxConcurrency: number;
+    defaultPriority: "critical" | "high" | "medium" | "low" | "background";
+    description?: string | undefined;
+    defaultRetryPolicy?: {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    defaultTimeoutPolicy?: {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    } | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    maxConcurrency?: number | undefined;
+    defaultPriority?: "critical" | "high" | "medium" | "low" | "background" | undefined;
+    defaultRetryPolicy?: {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    defaultTimeoutPolicy?: {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    } | undefined;
+}>;
+export type QueueCreateRequest = z.infer<typeof QueueCreateRequestSchema>;
+/**
+ * Queue state
+ */
+export declare const QueueStateSchema: z.ZodObject<{
+    queueId: z.ZodString;
+    name: z.ZodString;
+    pending: z.ZodNumber;
+    running: z.ZodNumber;
+    completed: z.ZodNumber;
+    failed: z.ZodNumber;
+    maxConcurrency: z.ZodNumber;
+    isPaused: z.ZodDefault<z.ZodBoolean>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    pending: number;
+    completed: number;
+    failed: number;
+    createdAt: string;
+    updatedAt: string;
+    running: number;
+    maxConcurrency: number;
+    queueId: string;
+    isPaused: boolean;
+}, {
+    name: string;
+    pending: number;
+    completed: number;
+    failed: number;
+    createdAt: string;
+    updatedAt: string;
+    running: number;
+    maxConcurrency: number;
+    queueId: string;
+    isPaused?: boolean | undefined;
+}>;
+export type QueueState = z.infer<typeof QueueStateSchema>;
+/**
+ * Task submit request
+ */
+export declare const TaskSubmitRequestSchema: z.ZodObject<{
+    queueId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["sequential", "parallel", "conditional", "loop", "retry", "timeout", "wait", "callback", "other"]>>;
+    priority: z.ZodDefault<z.ZodEnum<["critical", "high", "medium", "low", "background"]>>;
+    agentId: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    }>>;
+    timeoutPolicy: z.ZodOptional<z.ZodObject<{
+        executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    }, {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    }>>;
+    scheduledAt: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+    name: string;
+    priority: "critical" | "high" | "medium" | "low" | "background";
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    agentId?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    tags?: string[] | undefined;
+    dependencies?: string[] | undefined;
+    timeoutPolicy?: {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    } | undefined;
+    scheduledAt?: string | undefined;
+    queueId?: string | undefined;
+}, {
+    name: string;
+    type?: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback" | undefined;
+    retryPolicy?: {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    description?: string | undefined;
+    priority?: "critical" | "high" | "medium" | "low" | "background" | undefined;
+    agentId?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    tags?: string[] | undefined;
+    dependencies?: string[] | undefined;
+    timeoutPolicy?: {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    } | undefined;
+    scheduledAt?: string | undefined;
+    queueId?: string | undefined;
+}>;
+export type TaskSubmitRequest = z.infer<typeof TaskSubmitRequestSchema>;
+/**
+ * Task submit result
+ */
+export declare const TaskSubmitResultSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    queueId: z.ZodString;
+    status: z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>;
+    position: z.ZodOptional<z.ZodNumber>;
+    estimatedStartTime: z.ZodOptional<z.ZodString>;
+    submittedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+    taskId: string;
+    queueId: string;
+    submittedAt: string;
+    position?: number | undefined;
+    estimatedStartTime?: string | undefined;
+}, {
+    status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+    taskId: string;
+    queueId: string;
+    submittedAt: string;
+    position?: number | undefined;
+    estimatedStartTime?: string | undefined;
+}>;
+export type TaskSubmitResult = z.infer<typeof TaskSubmitResultSchema>;
+/**
+ * Task query request
+ */
+export declare const TaskQueryRequestSchema: z.ZodObject<{
+    queueId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodArray<z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>, "many">>;
+    priority: z.ZodOptional<z.ZodArray<z.ZodEnum<["critical", "high", "medium", "low", "background"]>, "many">>;
+    agentId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    createdAfter: z.ZodOptional<z.ZodString>;
+    createdBefore: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    orderBy: z.ZodDefault<z.ZodEnum<["createdAt", "priority", "scheduledAt", "status"]>>;
+    orderDir: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    orderBy: "status" | "priority" | "createdAt" | "scheduledAt";
+    orderDir: "asc" | "desc";
+    status?: ("timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused")[] | undefined;
+    priority?: ("critical" | "high" | "medium" | "low" | "background")[] | undefined;
+    agentId?: string | undefined;
+    tags?: string[] | undefined;
+    createdAfter?: string | undefined;
+    createdBefore?: string | undefined;
+    queueId?: string | undefined;
+}, {
+    status?: ("timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused")[] | undefined;
+    priority?: ("critical" | "high" | "medium" | "low" | "background")[] | undefined;
+    agentId?: string | undefined;
+    limit?: number | undefined;
+    tags?: string[] | undefined;
+    offset?: number | undefined;
+    createdAfter?: string | undefined;
+    createdBefore?: string | undefined;
+    queueId?: string | undefined;
+    orderBy?: "status" | "priority" | "createdAt" | "scheduledAt" | undefined;
+    orderDir?: "asc" | "desc" | undefined;
+}>;
+export type TaskQueryRequest = z.infer<typeof TaskQueryRequestSchema>;
+/**
+ * Task query result
+ */
+export declare const TaskQueryResultSchema: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodDefault<z.ZodEnum<["sequential", "parallel", "conditional", "loop", "retry", "timeout", "wait", "callback", "other"]>>;
+        priority: z.ZodDefault<z.ZodEnum<["critical", "high", "medium", "low", "background"]>>;
+        agentId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            condition: z.ZodDefault<z.ZodEnum<["completed", "failed", "any", "all"]>>;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            taskId: string;
+            condition: "completed" | "failed" | "all" | "any";
+            timeout?: number | undefined;
+        }, {
+            taskId: string;
+            timeout?: number | undefined;
+            condition?: "completed" | "failed" | "all" | "any" | undefined;
+        }>, "many">>;
+        retryPolicy: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            initialDelayMs: z.ZodDefault<z.ZodNumber>;
+            maxDelayMs: z.ZodDefault<z.ZodNumber>;
+            backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+            retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            backoffMultiplier: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+            retryableErrors?: string[] | undefined;
+        }, {
+            maxAttempts?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+            retryableErrors?: string[] | undefined;
+        }>>;
+        timeoutPolicy: z.ZodOptional<z.ZodObject<{
+            executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            executionTimeoutMs: number;
+            gracefulShutdownMs: number;
+            queueTimeoutMs?: number | undefined;
+        }, {
+            executionTimeoutMs?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            gracefulShutdownMs?: number | undefined;
+        }>>;
+        scheduledAt: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    } & {
+        taskId: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>>;
+        attempt: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        startedAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        completedAt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        output: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        error: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        progress: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        lastHeartbeat: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+        name: string;
+        priority: "critical" | "high" | "medium" | "low" | "background";
+        status?: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused" | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMultiplier: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        agentId?: string | undefined;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        progress?: number | undefined;
+        input?: Record<string, unknown> | undefined;
+        output?: Record<string, unknown> | undefined;
+        tags?: string[] | undefined;
+        completedAt?: string | undefined;
+        taskId?: string | undefined;
+        dependencies?: {
+            taskId: string;
+            condition: "completed" | "failed" | "all" | "any";
+            timeout?: number | undefined;
+        }[] | undefined;
+        startedAt?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs: number;
+            gracefulShutdownMs: number;
+            queueTimeoutMs?: number | undefined;
+        } | undefined;
+        scheduledAt?: string | undefined;
+        attempt?: number | undefined;
+        lastHeartbeat?: string | undefined;
+    }, {
+        name: string;
+        type?: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback" | undefined;
+        status?: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused" | undefined;
+        retryPolicy?: {
+            maxAttempts?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        priority?: "critical" | "high" | "medium" | "low" | "background" | undefined;
+        agentId?: string | undefined;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        progress?: number | undefined;
+        input?: Record<string, unknown> | undefined;
+        output?: Record<string, unknown> | undefined;
+        tags?: string[] | undefined;
+        completedAt?: string | undefined;
+        taskId?: string | undefined;
+        dependencies?: {
+            taskId: string;
+            timeout?: number | undefined;
+            condition?: "completed" | "failed" | "all" | "any" | undefined;
+        }[] | undefined;
+        startedAt?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            gracefulShutdownMs?: number | undefined;
+        } | undefined;
+        scheduledAt?: string | undefined;
+        attempt?: number | undefined;
+        lastHeartbeat?: string | undefined;
+    }>, "many">;
+    total: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    hasMore: boolean;
+    tasks: {
+        type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+        name: string;
+        priority: "critical" | "high" | "medium" | "low" | "background";
+        status?: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused" | undefined;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMultiplier: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        agentId?: string | undefined;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        progress?: number | undefined;
+        input?: Record<string, unknown> | undefined;
+        output?: Record<string, unknown> | undefined;
+        tags?: string[] | undefined;
+        completedAt?: string | undefined;
+        taskId?: string | undefined;
+        dependencies?: {
+            taskId: string;
+            condition: "completed" | "failed" | "all" | "any";
+            timeout?: number | undefined;
+        }[] | undefined;
+        startedAt?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs: number;
+            gracefulShutdownMs: number;
+            queueTimeoutMs?: number | undefined;
+        } | undefined;
+        scheduledAt?: string | undefined;
+        attempt?: number | undefined;
+        lastHeartbeat?: string | undefined;
+    }[];
+}, {
+    total: number;
+    hasMore: boolean;
+    tasks: {
+        name: string;
+        type?: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback" | undefined;
+        status?: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused" | undefined;
+        retryPolicy?: {
+            maxAttempts?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        description?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        priority?: "critical" | "high" | "medium" | "low" | "background" | undefined;
+        agentId?: string | undefined;
+        sessionId?: string | undefined;
+        error?: string | undefined;
+        progress?: number | undefined;
+        input?: Record<string, unknown> | undefined;
+        output?: Record<string, unknown> | undefined;
+        tags?: string[] | undefined;
+        completedAt?: string | undefined;
+        taskId?: string | undefined;
+        dependencies?: {
+            taskId: string;
+            timeout?: number | undefined;
+            condition?: "completed" | "failed" | "all" | "any" | undefined;
+        }[] | undefined;
+        startedAt?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            gracefulShutdownMs?: number | undefined;
+        } | undefined;
+        scheduledAt?: string | undefined;
+        attempt?: number | undefined;
+        lastHeartbeat?: string | undefined;
+    }[];
+}>;
+export type TaskQueryResult = z.infer<typeof TaskQueryResultSchema>;
+/**
+ * Task cancel request
+ */
+export declare const TaskCancelRequestSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    force: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    force: boolean;
+    reason?: string | undefined;
+}, {
+    taskId: string;
+    reason?: string | undefined;
+    force?: boolean | undefined;
+}>;
+export type TaskCancelRequest = z.infer<typeof TaskCancelRequestSchema>;
+/**
+ * Task pause request
+ */
+export declare const TaskPauseRequestSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    reason?: string | undefined;
+}, {
+    taskId: string;
+    reason?: string | undefined;
+}>;
+export type TaskPauseRequest = z.infer<typeof TaskPauseRequestSchema>;
+/**
+ * Task resume request
+ */
+export declare const TaskResumeRequestSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+export type TaskResumeRequest = z.infer<typeof TaskResumeRequestSchema>;
+/**
+ * Task retry request
+ */
+export declare const TaskRetryRequestSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    resetAttempts: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    resetAttempts: boolean;
+}, {
+    taskId: string;
+    resetAttempts?: boolean | undefined;
+}>;
+export type TaskRetryRequest = z.infer<typeof TaskRetryRequestSchema>;
+/**
+ * Flow step
+ */
+export declare const FlowStepSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<["sequential", "parallel", "conditional", "loop", "retry", "timeout", "wait", "callback", "other"]>;
+    agentId: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    condition: z.ZodOptional<z.ZodString>;
+    onSuccess: z.ZodOptional<z.ZodString>;
+    onFailure: z.ZodOptional<z.ZodString>;
+    retryPolicy: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    }>>;
+    timeoutPolicy: z.ZodOptional<z.ZodObject<{
+        executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    }, {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+    stepId: string;
+    name: string;
+    retryPolicy?: {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    agentId?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    condition?: string | undefined;
+    timeoutPolicy?: {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    } | undefined;
+    onSuccess?: string | undefined;
+    onFailure?: string | undefined;
+}, {
+    type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+    stepId: string;
+    name: string;
+    retryPolicy?: {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    agentId?: string | undefined;
+    input?: Record<string, unknown> | undefined;
+    condition?: string | undefined;
+    timeoutPolicy?: {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    } | undefined;
+    onSuccess?: string | undefined;
+    onFailure?: string | undefined;
+}>;
+export type FlowStep = z.infer<typeof FlowStepSchema>;
+/**
+ * Orchestration flow definition
+ */
+export declare const FlowDefinitionSchema: z.ZodObject<{
+    flowId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodDefault<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<["sequential", "parallel", "conditional", "loop", "retry", "timeout", "wait", "callback", "other"]>;
+        agentId: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        condition: z.ZodOptional<z.ZodString>;
+        onSuccess: z.ZodOptional<z.ZodString>;
+        onFailure: z.ZodOptional<z.ZodString>;
+        retryPolicy: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            initialDelayMs: z.ZodDefault<z.ZodNumber>;
+            maxDelayMs: z.ZodDefault<z.ZodNumber>;
+            backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+            retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            maxAttempts: number;
+            backoffMultiplier: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+            retryableErrors?: string[] | undefined;
+        }, {
+            maxAttempts?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+            retryableErrors?: string[] | undefined;
+        }>>;
+        timeoutPolicy: z.ZodOptional<z.ZodObject<{
+            executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            executionTimeoutMs: number;
+            gracefulShutdownMs: number;
+            queueTimeoutMs?: number | undefined;
+        }, {
+            executionTimeoutMs?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            gracefulShutdownMs?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+        stepId: string;
+        name: string;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMultiplier: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        agentId?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        condition?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs: number;
+            gracefulShutdownMs: number;
+            queueTimeoutMs?: number | undefined;
+        } | undefined;
+        onSuccess?: string | undefined;
+        onFailure?: string | undefined;
+    }, {
+        type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+        stepId: string;
+        name: string;
+        retryPolicy?: {
+            maxAttempts?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        agentId?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        condition?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            gracefulShutdownMs?: number | undefined;
+        } | undefined;
+        onSuccess?: string | undefined;
+        onFailure?: string | undefined;
+    }>, "many">;
+    startStep: z.ZodString;
+    endSteps: z.ZodArray<z.ZodString, "many">;
+    defaultRetryPolicy: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        initialDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxDelayMs: z.ZodDefault<z.ZodNumber>;
+        backoffMultiplier: z.ZodDefault<z.ZodNumber>;
+        retryableErrors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    }, {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    }>>;
+    defaultTimeoutPolicy: z.ZodOptional<z.ZodObject<{
+        executionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        queueTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        gracefulShutdownMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    }, {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    steps: {
+        type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+        stepId: string;
+        name: string;
+        retryPolicy?: {
+            maxAttempts: number;
+            backoffMultiplier: number;
+            initialDelayMs: number;
+            maxDelayMs: number;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        agentId?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        condition?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs: number;
+            gracefulShutdownMs: number;
+            queueTimeoutMs?: number | undefined;
+        } | undefined;
+        onSuccess?: string | undefined;
+        onFailure?: string | undefined;
+    }[];
+    flowId: string;
+    startStep: string;
+    endSteps: string[];
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultRetryPolicy?: {
+        maxAttempts: number;
+        backoffMultiplier: number;
+        initialDelayMs: number;
+        maxDelayMs: number;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    defaultTimeoutPolicy?: {
+        executionTimeoutMs: number;
+        gracefulShutdownMs: number;
+        queueTimeoutMs?: number | undefined;
+    } | undefined;
+}, {
+    name: string;
+    steps: {
+        type: "timeout" | "conditional" | "loop" | "parallel" | "other" | "sequential" | "retry" | "wait" | "callback";
+        stepId: string;
+        name: string;
+        retryPolicy?: {
+            maxAttempts?: number | undefined;
+            backoffMultiplier?: number | undefined;
+            initialDelayMs?: number | undefined;
+            maxDelayMs?: number | undefined;
+            retryableErrors?: string[] | undefined;
+        } | undefined;
+        agentId?: string | undefined;
+        input?: Record<string, unknown> | undefined;
+        condition?: string | undefined;
+        timeoutPolicy?: {
+            executionTimeoutMs?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            gracefulShutdownMs?: number | undefined;
+        } | undefined;
+        onSuccess?: string | undefined;
+        onFailure?: string | undefined;
+    }[];
+    flowId: string;
+    startStep: string;
+    endSteps: string[];
+    version?: string | undefined;
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    defaultRetryPolicy?: {
+        maxAttempts?: number | undefined;
+        backoffMultiplier?: number | undefined;
+        initialDelayMs?: number | undefined;
+        maxDelayMs?: number | undefined;
+        retryableErrors?: string[] | undefined;
+    } | undefined;
+    defaultTimeoutPolicy?: {
+        executionTimeoutMs?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        gracefulShutdownMs?: number | undefined;
+    } | undefined;
+}>;
+export type FlowDefinition = z.infer<typeof FlowDefinitionSchema>;
+/**
+ * Flow execution state
+ */
+export declare const FlowExecutionSchema: z.ZodObject<{
+    executionId: z.ZodString;
+    flowId: z.ZodString;
+    status: z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>;
+    currentStep: z.ZodOptional<z.ZodString>;
+    stepHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        status: z.ZodEnum<["pending", "queued", "running", "paused", "completed", "failed", "cancelled", "timeout"]>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+        stepId: string;
+        startedAt: string;
+        error?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        completedAt?: string | undefined;
+    }, {
+        status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+        stepId: string;
+        startedAt: string;
+        error?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        completedAt?: string | undefined;
+    }>, "many">>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+    executionId: string;
+    startedAt: string;
+    flowId: string;
+    input?: Record<string, unknown> | undefined;
+    output?: Record<string, unknown> | undefined;
+    completedAt?: string | undefined;
+    currentStep?: string | undefined;
+    stepHistory?: {
+        status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+        stepId: string;
+        startedAt: string;
+        error?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        completedAt?: string | undefined;
+    }[] | undefined;
+}, {
+    status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+    executionId: string;
+    startedAt: string;
+    flowId: string;
+    input?: Record<string, unknown> | undefined;
+    output?: Record<string, unknown> | undefined;
+    completedAt?: string | undefined;
+    currentStep?: string | undefined;
+    stepHistory?: {
+        status: "timeout" | "pending" | "completed" | "failed" | "running" | "cancelled" | "queued" | "paused";
+        stepId: string;
+        startedAt: string;
+        error?: string | undefined;
+        output?: Record<string, unknown> | undefined;
+        completedAt?: string | undefined;
+    }[] | undefined;
+}>;
+export type FlowExecution = z.infer<typeof FlowExecutionSchema>;
+export declare const OrchestrationErrorCode: {
+    readonly TASK_NOT_FOUND: "TASK_NOT_FOUND";
+    readonly QUEUE_NOT_FOUND: "QUEUE_NOT_FOUND";
+    readonly FLOW_NOT_FOUND: "FLOW_NOT_FOUND";
+    readonly INVALID_STATE: "INVALID_STATE";
+    readonly DEPENDENCY_FAILED: "DEPENDENCY_FAILED";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly CANCELLED: "CANCELLED";
+    readonly MAX_RETRIES: "MAX_RETRIES";
+    readonly QUEUE_FULL: "QUEUE_FULL";
+    readonly AGENT_UNAVAILABLE: "AGENT_UNAVAILABLE";
+};
+export type OrchestrationErrorCode = (typeof OrchestrationErrorCode)[keyof typeof OrchestrationErrorCode];
+export declare function validateTaskSubmitRequest(data: unknown): TaskSubmitRequest;
+export declare function validateTaskQueryRequest(data: unknown): TaskQueryRequest;
+export declare function validateFlowDefinition(data: unknown): FlowDefinition;
+export declare function validateQueueCreateRequest(data: unknown): QueueCreateRequest;
+export declare function safeValidateTaskSubmitRequest(data: unknown): {
+    success: true;
+    data: TaskSubmitRequest;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Storage mode for application initialization
+ * Note: This is specific to app bootstrap - see storage/v1 for the canonical StorageMode
+ */
+export declare const AppStorageModeSchema: z.ZodEnum<["sqlite", "memory"]>;
+export type AppStorageMode = z.infer<typeof AppStorageModeSchema>;
+/**
+ * Application initialization configuration
+ */
+export declare const AppInitConfigSchema: z.ZodObject<{
+    /** Storage backend mode */
+    storageMode: z.ZodDefault<z.ZodEnum<["sqlite", "memory"]>>;
+    /** Custom storage path (optional, defaults to ~/.automatosx/data.db) */
+    storagePath: z.ZodOptional<z.ZodString>;
+    /** Enable agent registry initialization */
+    enableAgents: z.ZodDefault<z.ZodBoolean>;
+    /** Enable ability registry initialization */
+    enableAbilities: z.ZodDefault<z.ZodBoolean>;
+    /** Enable provider registry initialization */
+    enableProviders: z.ZodDefault<z.ZodBoolean>;
+    /** Enable trace store initialization */
+    enableTracing: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enableTracing: boolean;
+    storageMode: "sqlite" | "memory";
+    enableAgents: boolean;
+    enableAbilities: boolean;
+    enableProviders: boolean;
+    storagePath?: string | undefined;
+}, {
+    enableTracing?: boolean | undefined;
+    storageMode?: "sqlite" | "memory" | undefined;
+    storagePath?: string | undefined;
+    enableAgents?: boolean | undefined;
+    enableAbilities?: boolean | undefined;
+    enableProviders?: boolean | undefined;
+}>;
+export type AppInitConfig = z.infer<typeof AppInitConfigSchema>;
+/**
+ * Dependency container for initialized application
+ */
+export declare const DependencyContainerSchema: z.ZodObject<{
+    /** Whether SQLite is actually being used (may fall back to memory) */
+    usingSqlite: z.ZodBoolean;
+    /** Storage mode that was requested */
+    requestedMode: z.ZodEnum<["sqlite", "memory"]>;
+    /** Initialization timestamp */
+    initializedAt: z.ZodString;
+    /** Features that were enabled */
+    enabledFeatures: z.ZodObject<{
+        agents: z.ZodBoolean;
+        abilities: z.ZodBoolean;
+        providers: z.ZodBoolean;
+        tracing: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        agents: boolean;
+        abilities: boolean;
+        providers: boolean;
+        tracing: boolean;
+    }, {
+        agents: boolean;
+        abilities: boolean;
+        providers: boolean;
+        tracing: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    usingSqlite: boolean;
+    requestedMode: "sqlite" | "memory";
+    initializedAt: string;
+    enabledFeatures: {
+        agents: boolean;
+        abilities: boolean;
+        providers: boolean;
+        tracing: boolean;
+    };
+}, {
+    usingSqlite: boolean;
+    requestedMode: "sqlite" | "memory";
+    initializedAt: string;
+    enabledFeatures: {
+        agents: boolean;
+        abilities: boolean;
+        providers: boolean;
+        tracing: boolean;
+    };
+}>;
+export type DependencyContainer = z.infer<typeof DependencyContainerSchema>;
+/**
+ * Bootstrap result
+ */
+export declare const BootstrapResultSchema: z.ZodObject<{
+    /** Whether bootstrap succeeded */
+    success: z.ZodBoolean;
+    /** Container if successful */
+    container: z.ZodOptional<z.ZodObject<{
+        /** Whether SQLite is actually being used (may fall back to memory) */
+        usingSqlite: z.ZodBoolean;
+        /** Storage mode that was requested */
+        requestedMode: z.ZodEnum<["sqlite", "memory"]>;
+        /** Initialization timestamp */
+        initializedAt: z.ZodString;
+        /** Features that were enabled */
+        enabledFeatures: z.ZodObject<{
+            agents: z.ZodBoolean;
+            abilities: z.ZodBoolean;
+            providers: z.ZodBoolean;
+            tracing: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            agents: boolean;
+            abilities: boolean;
+            providers: boolean;
+            tracing: boolean;
+        }, {
+            agents: boolean;
+            abilities: boolean;
+            providers: boolean;
+            tracing: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        usingSqlite: boolean;
+        requestedMode: "sqlite" | "memory";
+        initializedAt: string;
+        enabledFeatures: {
+            agents: boolean;
+            abilities: boolean;
+            providers: boolean;
+            tracing: boolean;
+        };
+    }, {
+        usingSqlite: boolean;
+        requestedMode: "sqlite" | "memory";
+        initializedAt: string;
+        enabledFeatures: {
+            agents: boolean;
+            abilities: boolean;
+            providers: boolean;
+            tracing: boolean;
+        };
+    }>>;
+    /** Error message if failed */
+    error: z.ZodOptional<z.ZodString>;
+    /** Warnings during initialization */
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    warnings: string[];
+    error?: string | undefined;
+    container?: {
+        usingSqlite: boolean;
+        requestedMode: "sqlite" | "memory";
+        initializedAt: string;
+        enabledFeatures: {
+            agents: boolean;
+            abilities: boolean;
+            providers: boolean;
+            tracing: boolean;
+        };
+    } | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    container?: {
+        usingSqlite: boolean;
+        requestedMode: "sqlite" | "memory";
+        initializedAt: string;
+        enabledFeatures: {
+            agents: boolean;
+            abilities: boolean;
+            providers: boolean;
+            tracing: boolean;
+        };
+    } | undefined;
+    warnings?: string[] | undefined;
+}>;
+export type BootstrapResult = z.infer<typeof BootstrapResultSchema>;
+export declare const AppInitErrorCode: {
+    readonly SQLITE_UNAVAILABLE: "APP_INIT_SQLITE_UNAVAILABLE";
+    readonly STORAGE_INIT_FAILED: "APP_INIT_STORAGE_FAILED";
+    readonly PROVIDER_INIT_FAILED: "APP_INIT_PROVIDER_FAILED";
+    readonly AGENT_INIT_FAILED: "APP_INIT_AGENT_FAILED";
+    readonly ABILITY_INIT_FAILED: "APP_INIT_ABILITY_FAILED";
+    readonly ALREADY_INITIALIZED: "APP_INIT_ALREADY_INITIALIZED";
+};
+export type AppInitErrorCode = (typeof AppInitErrorCode)[keyof typeof AppInitErrorCode];
+export declare function validateAppInitConfig(data: unknown): AppInitConfig;
+export declare function safeValidateAppInitConfig(data: unknown): {
+    success: true;
+    data: AppInitConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+export declare function createDefaultAppInitConfig(): AppInitConfig;
+//# sourceMappingURL=schema.d.ts.map