@atom-workflow-agent/contracts 0.1.0

package/dist/planner/planner-validation.d.ts

@@ -0,0 +1,830 @@
+import { z } from "zod";
+/** Durable state for capability preflight followed by transactional Workspace editing. */
+export declare const PlanningCheckpointSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    phase: z.ZodEnum<{
+        "capability-coverage": "capability-coverage";
+        workspace: "workspace";
+        blocked_missing_atom: "blocked_missing_atom";
+        blocked_missing_input: "blocked_missing_input";
+        completed: "completed";
+    }>;
+    catalogIndexHash: z.ZodString;
+    selectedAtomKeys: z.ZodArray<z.ZodString>;
+    planningCatalogHash: z.ZodOptional<z.ZodString>;
+    capabilityCoverage: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.1">;
+        status: z.ZodLiteral<"covered">;
+        catalogHash: z.ZodString;
+        plan: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.1">;
+            kind: z.ZodLiteral<"capability-plan">;
+            requirements: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"covered">;
+                    uses: z.ZodArray<z.ZodObject<{
+                        atom: z.ZodString;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            role: z.ZodString;
+                            field: z.ZodString;
+                        }, z.core.$strict>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            role: z.ZodString;
+                            field: z.ZodString;
+                        }, z.core.$strict>>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"missing">;
+                    desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        acceptedTypes: z.ZodArray<z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            object: "object";
+                            null: "null";
+                            array: "array";
+                            integer: "integer";
+                        }>>;
+                    }, z.core.$strict>>>;
+                    desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        acceptedTypes: z.ZodArray<z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            object: "object";
+                            null: "null";
+                            array: "array";
+                            integer: "integer";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        selectedAtomKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.1">;
+        status: z.ZodLiteral<"blocked_missing_atom">;
+        catalogHash: z.ZodString;
+        plan: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.1">;
+            kind: z.ZodLiteral<"capability-plan">;
+            requirements: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"covered">;
+                    uses: z.ZodArray<z.ZodObject<{
+                        atom: z.ZodString;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            role: z.ZodString;
+                            field: z.ZodString;
+                        }, z.core.$strict>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            role: z.ZodString;
+                            field: z.ZodString;
+                        }, z.core.$strict>>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"missing">;
+                    desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        acceptedTypes: z.ZodArray<z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            object: "object";
+                            null: "null";
+                            array: "array";
+                            integer: "integer";
+                        }>>;
+                    }, z.core.$strict>>>;
+                    desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        acceptedTypes: z.ZodArray<z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            object: "object";
+                            null: "null";
+                            array: "array";
+                            integer: "integer";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        searchedAtomCount: z.ZodNumber;
+        gaps: z.ZodArray<z.ZodObject<{
+            requirement: z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"covered">;
+                    uses: z.ZodArray<z.ZodObject<{
+                        atom: z.ZodString;
+                        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            role: z.ZodString;
+                            field: z.ZodString;
+                        }, z.core.$strict>>>;
+                        outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            role: z.ZodString;
+                            field: z.ZodString;
+                        }, z.core.$strict>>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"missing">;
+                    desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        acceptedTypes: z.ZodArray<z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            object: "object";
+                            null: "null";
+                            array: "array";
+                            integer: "integer";
+                        }>>;
+                    }, z.core.$strict>>>;
+                    desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        description: z.ZodString;
+                        required: z.ZodDefault<z.ZodBoolean>;
+                        acceptedTypes: z.ZodArray<z.ZodEnum<{
+                            string: "string";
+                            number: "number";
+                            boolean: "boolean";
+                            object: "object";
+                            null: "null";
+                            array: "array";
+                            integer: "integer";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>;
+            code: z.ZodEnum<{
+                PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+                PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+                PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+            }>;
+            message: z.ZodString;
+            nearMatches: z.ZodArray<z.ZodObject<{
+                atomKey: z.ZodString;
+                title: z.ZodString;
+                purpose: z.ZodString;
+                score: z.ZodNumber;
+                rejectedBecause: z.ZodString;
+            }, z.core.$strict>>;
+            suggestedAtomContract: z.ZodObject<{
+                suggestedId: z.ZodString;
+                description: z.ZodString;
+                inputFields: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>;
+                outputFields: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            fieldIssues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                atomKey: z.ZodString;
+                direction: z.ZodEnum<{
+                    input: "input";
+                    output: "output";
+                }>;
+                field: z.ZodString;
+                reason: z.ZodEnum<{
+                    "field-not-found": "field-not-found";
+                    "required-input-not-declared": "required-input-not-declared";
+                }>;
+                availableFields: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "status">>;
+    workspaceSnapshot: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0">;
+        workspace: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0">;
+            workspaceId: z.ZodString;
+            requestId: z.ZodString;
+            goal: z.ZodString;
+            workflowName: z.ZodString;
+            workflowInputs: z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+            context: z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>;
+            runtimePolicy: z.ZodObject<{
+                schemaVersion: z.ZodDefault<z.ZodLiteral<"1.1">>;
+                maxNodes: z.ZodDefault<z.ZodNumber>;
+                maxDependenciesPerNode: z.ZodDefault<z.ZodNumber>;
+                maxMapItems: z.ZodDefault<z.ZodNumber>;
+                maxEdgeTraversals: z.ZodDefault<z.ZodNumber>;
+                maxWorkflowTransitions: z.ZodDefault<z.ZodNumber>;
+                maxNodeActivations: z.ZodDefault<z.ZodNumber>;
+                maxLifecycleTicks: z.ZodDefault<z.ZodNumber>;
+                maxLifecycleTickTimeoutMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                maxAttemptDurationMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                maxRetryAttempts: z.ZodDefault<z.ZodNumber>;
+                maxRetryDelayMs: z.ZodDefault<z.ZodNumber>;
+                maxCacheTtlMs: z.ZodDefault<z.ZodNumber>;
+                allowDeprecatedAtoms: z.ZodDefault<z.ZodBoolean>;
+                allowCacheEnableOverride: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>;
+            catalogHash: z.ZodString;
+            selectedAtomKeys: z.ZodArray<z.ZodString>;
+            requiredAtomKeys: z.ZodArray<z.ZodString>;
+            descriptorHashes: z.ZodRecord<z.ZodString, z.ZodString>;
+            status: z.ZodEnum<{
+                failed: "failed";
+                cancelled: "cancelled";
+                blocked_missing_atom: "blocked_missing_atom";
+                editing: "editing";
+                blocked_missing_input: "blocked_missing_input";
+                finalized: "finalized";
+            }>;
+            currentRevision: z.ZodNumber;
+            currentDraftHash: z.ZodString;
+            finalizedRevision: z.ZodOptional<z.ZodNumber>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strict>;
+        revisions: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0">;
+            revision: z.ZodNumber;
+            parentRevision: z.ZodNumber;
+            operationId: z.ZodString;
+            draftHash: z.ZodString;
+            blocks: z.ZodArray<z.ZodObject<{
+                blockId: z.ZodString;
+                plan: z.ZodType<import("./planning-workspace.js").PlanningStep, unknown, z.core.$ZodTypeInternals<import("./planning-workspace.js").PlanningStep, unknown>>;
+            }, z.core.$strict>>;
+            outputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodLiteral<"workflow">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"node">;
+                nodeId: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"item">;
+                path: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                source: z.ZodLiteral<"value">;
+                value: z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>;
+            }, z.core.$strict>], "source">>;
+            bindingEvidence: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"1.0">;
+                consumerAlias: z.ZodString;
+                targetPath: z.ZodString;
+                sourceRef: z.ZodString;
+                sourceDescription: z.ZodString;
+                targetDescription: z.ZodString;
+                sourceSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+                targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+                reason: z.ZodString;
+                confidence: z.ZodLiteral<"high">;
+            }, z.core.$strict>>;
+            plannerDraft: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"1.0">;
+                kind: z.ZodLiteral<"workflow-draft">;
+                name: z.ZodString;
+                flow: z.ZodType<import("./planner-draft.js").PlannerDraftStep, unknown, z.core.$ZodTypeInternals<import("./planner-draft.js").PlannerDraftStep, unknown>>;
+                outputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>>;
+            }, z.core.$strict>;
+            validation: z.ZodObject<{
+                workflowName: z.ZodString;
+                workflowNodeCount: z.ZodNumber;
+                workflowIrHash: z.ZodString;
+            }, z.core.$strict>;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
+        transactions: z.ZodArray<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0">;
+            transaction: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"1.0">;
+                operationId: z.ZodString;
+                baseRevision: z.ZodNumber;
+                baseDraftHash: z.ZodString;
+                operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    op: z.ZodLiteral<"add-region">;
+                    block: z.ZodObject<{
+                        blockId: z.ZodString;
+                        plan: z.ZodType<import("./planning-workspace.js").PlanningStep, unknown, z.core.$ZodTypeInternals<import("./planning-workspace.js").PlanningStep, unknown>>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"replace-region">;
+                    blockId: z.ZodString;
+                    plan: z.ZodType<import("./planning-workspace.js").PlanningStep, unknown, z.core.$ZodTypeInternals<import("./planning-workspace.js").PlanningStep, unknown>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"remove-region">;
+                    blockId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"set-workflow-output">;
+                    name: z.ZodString;
+                    value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        source: z.ZodLiteral<"workflow">;
+                        path: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        source: z.ZodLiteral<"node">;
+                        nodeId: z.ZodString;
+                        path: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        source: z.ZodLiteral<"item">;
+                        path: z.ZodDefault<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        source: z.ZodLiteral<"value">;
+                        value: z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>;
+                    }, z.core.$strict>], "source">;
+                }, z.core.$strict>, z.ZodObject<{
+                    op: z.ZodLiteral<"remove-workflow-output">;
+                    name: z.ZodString;
+                }, z.core.$strict>], "op">>;
+            }, z.core.$strict>;
+            transactionHash: z.ZodString;
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"1.0">;
+                status: z.ZodLiteral<"committed">;
+                operationId: z.ZodString;
+                transactionHash: z.ZodString;
+                replayed: z.ZodBoolean;
+                revision: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"1.0">;
+                    revision: z.ZodNumber;
+                    parentRevision: z.ZodNumber;
+                    operationId: z.ZodString;
+                    draftHash: z.ZodString;
+                    blocks: z.ZodArray<z.ZodObject<{
+                        blockId: z.ZodString;
+                        plan: z.ZodType<import("./planning-workspace.js").PlanningStep, unknown, z.core.$ZodTypeInternals<import("./planning-workspace.js").PlanningStep, unknown>>;
+                    }, z.core.$strict>>;
+                    outputs: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        source: z.ZodLiteral<"workflow">;
+                        path: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        source: z.ZodLiteral<"node">;
+                        nodeId: z.ZodString;
+                        path: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        source: z.ZodLiteral<"item">;
+                        path: z.ZodDefault<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        source: z.ZodLiteral<"value">;
+                        value: z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>;
+                    }, z.core.$strict>], "source">>;
+                    bindingEvidence: z.ZodArray<z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"1.0">;
+                        consumerAlias: z.ZodString;
+                        targetPath: z.ZodString;
+                        sourceRef: z.ZodString;
+                        sourceDescription: z.ZodString;
+                        targetDescription: z.ZodString;
+                        sourceSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+                        targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+                        reason: z.ZodString;
+                        confidence: z.ZodLiteral<"high">;
+                    }, z.core.$strict>>;
+                    plannerDraft: z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"1.0">;
+                        kind: z.ZodLiteral<"workflow-draft">;
+                        name: z.ZodString;
+                        flow: z.ZodType<import("./planner-draft.js").PlannerDraftStep, unknown, z.core.$ZodTypeInternals<import("./planner-draft.js").PlannerDraftStep, unknown>>;
+                        outputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>>;
+                    }, z.core.$strict>;
+                    validation: z.ZodObject<{
+                        workflowName: z.ZodString;
+                        workflowNodeCount: z.ZodNumber;
+                        workflowIrHash: z.ZodString;
+                    }, z.core.$strict>;
+                    createdAt: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"1.0">;
+                status: z.ZodLiteral<"rejected">;
+                operationId: z.ZodString;
+                transactionHash: z.ZodString;
+                code: z.ZodEnum<{
+                    WORKFLOW_JSON_INVALID: "WORKFLOW_JSON_INVALID";
+                    WORKFLOW_SCHEMA_INVALID: "WORKFLOW_SCHEMA_INVALID";
+                    RUNTIME_POLICY_INVALID: "RUNTIME_POLICY_INVALID";
+                    ATOM_CATALOG_INVALID: "ATOM_CATALOG_INVALID";
+                    ATOM_CATALOG_DUPLICATE: "ATOM_CATALOG_DUPLICATE";
+                    NODE_LIMIT_EXCEEDED: "NODE_LIMIT_EXCEEDED";
+                    DEPENDENCY_LIMIT_EXCEEDED: "DEPENDENCY_LIMIT_EXCEEDED";
+                    ATOM_NOT_FOUND: "ATOM_NOT_FOUND";
+                    ATOM_UNAVAILABLE: "ATOM_UNAVAILABLE";
+                    DEPRECATED_ATOM_FORBIDDEN: "DEPRECATED_ATOM_FORBIDDEN";
+                    ATTEMPT_TIMEOUT_LIMIT_EXCEEDED: "ATTEMPT_TIMEOUT_LIMIT_EXCEEDED";
+                    LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED: "LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED";
+                    LIFECYCLE_TICK_LIMIT_EXCEEDED: "LIFECYCLE_TICK_LIMIT_EXCEEDED";
+                    RETRY_LIMIT_EXCEEDED: "RETRY_LIMIT_EXCEEDED";
+                    RETRY_DELAY_LIMIT_EXCEEDED: "RETRY_DELAY_LIMIT_EXCEEDED";
+                    RETRY_POLICY_INVALID: "RETRY_POLICY_INVALID";
+                    NON_IDEMPOTENT_RETRY_FORBIDDEN: "NON_IDEMPOTENT_RETRY_FORBIDDEN";
+                    CACHE_TTL_LIMIT_EXCEEDED: "CACHE_TTL_LIMIT_EXCEEDED";
+                    CACHE_ENABLE_OVERRIDE_FORBIDDEN: "CACHE_ENABLE_OVERRIDE_FORBIDDEN";
+                    MAP_LIMIT_EXCEEDED: "MAP_LIMIT_EXCEEDED";
+                    MAP_GROUP_CONFIG_MISMATCH: "MAP_GROUP_CONFIG_MISMATCH";
+                    MAP_COMPLETION_CONFLICT: "MAP_COMPLETION_CONFLICT";
+                    AGENT_PROVIDER_FORBIDDEN: "AGENT_PROVIDER_FORBIDDEN";
+                    AGENT_MODEL_FORBIDDEN: "AGENT_MODEL_FORBIDDEN";
+                    AGENT_FALLBACK_LIMIT_EXCEEDED: "AGENT_FALLBACK_LIMIT_EXCEEDED";
+                    AGENT_FALLBACK_DUPLICATE: "AGENT_FALLBACK_DUPLICATE";
+                    AGENT_CWD_FORBIDDEN: "AGENT_CWD_FORBIDDEN";
+                    DUPLICATE_NODE_ID: "DUPLICATE_NODE_ID";
+                    DUPLICATE_DEPENDENCY: "DUPLICATE_DEPENDENCY";
+                    SELF_DEPENDENCY: "SELF_DEPENDENCY";
+                    DEPENDENCY_NOT_FOUND: "DEPENDENCY_NOT_FOUND";
+                    DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE";
+                    ENTRY_NODE_NOT_FOUND: "ENTRY_NODE_NOT_FOUND";
+                    ENTRY_NODE_DUPLICATE: "ENTRY_NODE_DUPLICATE";
+                    ENTRY_DEPENDENCY_INVALID: "ENTRY_DEPENDENCY_INVALID";
+                    EDGE_TARGET_NOT_FOUND: "EDGE_TARGET_NOT_FOUND";
+                    EDGE_TARGET_DUPLICATE: "EDGE_TARGET_DUPLICATE";
+                    EDGE_TERMINAL_WITH_INPUT_FORBIDDEN: "EDGE_TERMINAL_WITH_INPUT_FORBIDDEN";
+                    EDGE_BACK_EDGE_UNBOUNDED: "EDGE_BACK_EDGE_UNBOUNDED";
+                    EDGE_TRAVERSAL_LIMIT_EXCEEDED: "EDGE_TRAVERSAL_LIMIT_EXCEEDED";
+                    DECISION_SELECT_REFERENCE_INVALID: "DECISION_SELECT_REFERENCE_INVALID";
+                    DECISION_SELECT_TYPE_MISMATCH: "DECISION_SELECT_TYPE_MISMATCH";
+                    DECISION_BRANCH_ENUM_MISMATCH: "DECISION_BRANCH_ENUM_MISMATCH";
+                    CONTROL_NODE_UNREACHABLE: "CONTROL_NODE_UNREACHABLE";
+                    CONTROL_DEAD_END: "CONTROL_DEAD_END";
+                    CONTROL_TERMINAL_UNREACHABLE: "CONTROL_TERMINAL_UNREACHABLE";
+                    JOIN_CONTROL_PREDECESSOR_MISSING: "JOIN_CONTROL_PREDECESSOR_MISSING";
+                    PARALLEL_FANOUT_NOT_JOINED: "PARALLEL_FANOUT_NOT_JOINED";
+                    BRANCH_MERGE_INPUT_MISSING: "BRANCH_MERGE_INPUT_MISSING";
+                    BRANCH_MERGE_SOURCE_INVALID: "BRANCH_MERGE_SOURCE_INVALID";
+                    REFERENCE_NOT_FOUND: "REFERENCE_NOT_FOUND";
+                    REFERENCE_SOURCE_OPTIONAL: "REFERENCE_SOURCE_OPTIONAL";
+                    REFERENCE_NOT_DEPENDENCY: "REFERENCE_NOT_DEPENDENCY";
+                    MAP_REFERENCE_OUTSIDE_MAP: "MAP_REFERENCE_OUTSIDE_MAP";
+                    EDGE_REFERENCE_OUTSIDE_EDGE: "EDGE_REFERENCE_OUTSIDE_EDGE";
+                    WORKFLOW_OUTPUT_REFERENCE_INVALID: "WORKFLOW_OUTPUT_REFERENCE_INVALID";
+                    REFERENCE_INVALID: "REFERENCE_INVALID";
+                    REFERENCE_TYPE_MISMATCH: "REFERENCE_TYPE_MISMATCH";
+                    INPUT_SCHEMA_MISMATCH: "INPUT_SCHEMA_MISMATCH";
+                    INPUT_REQUIRED_PROPERTY_MISSING: "INPUT_REQUIRED_PROPERTY_MISSING";
+                    INPUT_ADDITIONAL_PROPERTY_FORBIDDEN: "INPUT_ADDITIONAL_PROPERTY_FORBIDDEN";
+                    MAP_ITEMS_NOT_ARRAY: "MAP_ITEMS_NOT_ARRAY";
+                    EDGE_INPUT_SCHEMA_MISMATCH: "EDGE_INPUT_SCHEMA_MISMATCH";
+                    AGENT_CWD_TYPE_MISMATCH: "AGENT_CWD_TYPE_MISMATCH";
+                    PLANNER_DRAFT_SCHEMA_INVALID: "PLANNER_DRAFT_SCHEMA_INVALID";
+                    PLANNER_DRAFT_ATOM_NOT_SELECTED: "PLANNER_DRAFT_ATOM_NOT_SELECTED";
+                    PLANNER_DRAFT_ALIAS_DUPLICATE: "PLANNER_DRAFT_ALIAS_DUPLICATE";
+                    PLANNER_DRAFT_REFERENCE_INVALID: "PLANNER_DRAFT_REFERENCE_INVALID";
+                    PLANNER_DRAFT_REFERENCE_AMBIGUOUS: "PLANNER_DRAFT_REFERENCE_AMBIGUOUS";
+                    PLANNER_DRAFT_CONTROL_INVALID: "PLANNER_DRAFT_CONTROL_INVALID";
+                    PLANNER_DRAFT_NORMALIZATION_FAILED: "PLANNER_DRAFT_NORMALIZATION_FAILED";
+                    PLANNER_TURN_LIMIT_EXCEEDED: "PLANNER_TURN_LIMIT_EXCEEDED";
+                    PLANNER_CAPABILITY_SCHEMA_INVALID: "PLANNER_CAPABILITY_SCHEMA_INVALID";
+                    PLANNING_WORKSPACE_ACTION_INVALID: "PLANNING_WORKSPACE_ACTION_INVALID";
+                    PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+                    PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+                    PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+                    PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED: "PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED";
+                    PLANNING_REQUIRED_INPUT_UNAVAILABLE: "PLANNING_REQUIRED_INPUT_UNAVAILABLE";
+                    PLANNING_BINDING_SOURCE_OPTIONAL: "PLANNING_BINDING_SOURCE_OPTIONAL";
+                    PLANNING_BINDING_AMBIGUOUS: "PLANNING_BINDING_AMBIGUOUS";
+                    PLANNING_BRANCH_RESULT_REQUIRED: "PLANNING_BRANCH_RESULT_REQUIRED";
+                    PLANNING_BRANCH_RESULT_MISMATCH: "PLANNING_BRANCH_RESULT_MISMATCH";
+                    PLANNING_DECISION_NO_EFFECT: "PLANNING_DECISION_NO_EFFECT";
+                    PLANNING_DRAFT_EMPTY: "PLANNING_DRAFT_EMPTY";
+                    PLANNING_TRANSACTION_INVALID: "PLANNING_TRANSACTION_INVALID";
+                    PLANNING_TRANSACTION_LIMIT_EXCEEDED: "PLANNING_TRANSACTION_LIMIT_EXCEEDED";
+                    PLANNING_TRANSACTION_VALIDATION_FAILED: "PLANNING_TRANSACTION_VALIDATION_FAILED";
+                    PLANNING_REVISION_CONFLICT: "PLANNING_REVISION_CONFLICT";
+                    PLANNING_REVISION_LIMIT_EXCEEDED: "PLANNING_REVISION_LIMIT_EXCEEDED";
+                    PLANNING_NODE_LIMIT_EXCEEDED: "PLANNING_NODE_LIMIT_EXCEEDED";
+                    PLANNING_OPERATION_CONFLICT: "PLANNING_OPERATION_CONFLICT";
+                    PLANNING_BLOCK_DUPLICATE: "PLANNING_BLOCK_DUPLICATE";
+                    PLANNING_BLOCK_NOT_FOUND: "PLANNING_BLOCK_NOT_FOUND";
+                    PLANNING_FINALIZE_CONFLICT: "PLANNING_FINALIZE_CONFLICT";
+                    PLANNING_WORKSPACE_NOT_EDITABLE: "PLANNING_WORKSPACE_NOT_EDITABLE";
+                    PLANNING_WORKSPACE_NOT_FINALIZABLE: "PLANNING_WORKSPACE_NOT_FINALIZABLE";
+                    PLANNING_ATOM_UNAVAILABLE: "PLANNING_ATOM_UNAVAILABLE";
+                    PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED: "PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED";
+                    PLANNING_FINAL_VALIDATION_FAILED: "PLANNING_FINAL_VALIDATION_FAILED";
+                    PLANNING_WORKFLOW_OUTPUT_REQUIRED: "PLANNING_WORKFLOW_OUTPUT_REQUIRED";
+                    PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED: "PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED";
+                    PLANNING_FINALIZED_REVISION_MISSING: "PLANNING_FINALIZED_REVISION_MISSING";
+                }>;
+                message: z.ZodString;
+                retryable: z.ZodBoolean;
+                currentRevision: z.ZodNumber;
+                currentDraftHash: z.ZodString;
+                errors: z.ZodArray<z.ZodObject<{
+                    code: z.ZodEnum<{
+                        WORKFLOW_JSON_INVALID: "WORKFLOW_JSON_INVALID";
+                        WORKFLOW_SCHEMA_INVALID: "WORKFLOW_SCHEMA_INVALID";
+                        RUNTIME_POLICY_INVALID: "RUNTIME_POLICY_INVALID";
+                        ATOM_CATALOG_INVALID: "ATOM_CATALOG_INVALID";
+                        ATOM_CATALOG_DUPLICATE: "ATOM_CATALOG_DUPLICATE";
+                        NODE_LIMIT_EXCEEDED: "NODE_LIMIT_EXCEEDED";
+                        DEPENDENCY_LIMIT_EXCEEDED: "DEPENDENCY_LIMIT_EXCEEDED";
+                        ATOM_NOT_FOUND: "ATOM_NOT_FOUND";
+                        ATOM_UNAVAILABLE: "ATOM_UNAVAILABLE";
+                        DEPRECATED_ATOM_FORBIDDEN: "DEPRECATED_ATOM_FORBIDDEN";
+                        ATTEMPT_TIMEOUT_LIMIT_EXCEEDED: "ATTEMPT_TIMEOUT_LIMIT_EXCEEDED";
+                        LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED: "LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED";
+                        LIFECYCLE_TICK_LIMIT_EXCEEDED: "LIFECYCLE_TICK_LIMIT_EXCEEDED";
+                        RETRY_LIMIT_EXCEEDED: "RETRY_LIMIT_EXCEEDED";
+                        RETRY_DELAY_LIMIT_EXCEEDED: "RETRY_DELAY_LIMIT_EXCEEDED";
+                        RETRY_POLICY_INVALID: "RETRY_POLICY_INVALID";
+                        NON_IDEMPOTENT_RETRY_FORBIDDEN: "NON_IDEMPOTENT_RETRY_FORBIDDEN";
+                        CACHE_TTL_LIMIT_EXCEEDED: "CACHE_TTL_LIMIT_EXCEEDED";
+                        CACHE_ENABLE_OVERRIDE_FORBIDDEN: "CACHE_ENABLE_OVERRIDE_FORBIDDEN";
+                        MAP_LIMIT_EXCEEDED: "MAP_LIMIT_EXCEEDED";
+                        MAP_GROUP_CONFIG_MISMATCH: "MAP_GROUP_CONFIG_MISMATCH";
+                        MAP_COMPLETION_CONFLICT: "MAP_COMPLETION_CONFLICT";
+                        AGENT_PROVIDER_FORBIDDEN: "AGENT_PROVIDER_FORBIDDEN";
+                        AGENT_MODEL_FORBIDDEN: "AGENT_MODEL_FORBIDDEN";
+                        AGENT_FALLBACK_LIMIT_EXCEEDED: "AGENT_FALLBACK_LIMIT_EXCEEDED";
+                        AGENT_FALLBACK_DUPLICATE: "AGENT_FALLBACK_DUPLICATE";
+                        AGENT_CWD_FORBIDDEN: "AGENT_CWD_FORBIDDEN";
+                        DUPLICATE_NODE_ID: "DUPLICATE_NODE_ID";
+                        DUPLICATE_DEPENDENCY: "DUPLICATE_DEPENDENCY";
+                        SELF_DEPENDENCY: "SELF_DEPENDENCY";
+                        DEPENDENCY_NOT_FOUND: "DEPENDENCY_NOT_FOUND";
+                        DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE";
+                        ENTRY_NODE_NOT_FOUND: "ENTRY_NODE_NOT_FOUND";
+                        ENTRY_NODE_DUPLICATE: "ENTRY_NODE_DUPLICATE";
+                        ENTRY_DEPENDENCY_INVALID: "ENTRY_DEPENDENCY_INVALID";
+                        EDGE_TARGET_NOT_FOUND: "EDGE_TARGET_NOT_FOUND";
+                        EDGE_TARGET_DUPLICATE: "EDGE_TARGET_DUPLICATE";
+                        EDGE_TERMINAL_WITH_INPUT_FORBIDDEN: "EDGE_TERMINAL_WITH_INPUT_FORBIDDEN";
+                        EDGE_BACK_EDGE_UNBOUNDED: "EDGE_BACK_EDGE_UNBOUNDED";
+                        EDGE_TRAVERSAL_LIMIT_EXCEEDED: "EDGE_TRAVERSAL_LIMIT_EXCEEDED";
+                        DECISION_SELECT_REFERENCE_INVALID: "DECISION_SELECT_REFERENCE_INVALID";
+                        DECISION_SELECT_TYPE_MISMATCH: "DECISION_SELECT_TYPE_MISMATCH";
+                        DECISION_BRANCH_ENUM_MISMATCH: "DECISION_BRANCH_ENUM_MISMATCH";
+                        CONTROL_NODE_UNREACHABLE: "CONTROL_NODE_UNREACHABLE";
+                        CONTROL_DEAD_END: "CONTROL_DEAD_END";
+                        CONTROL_TERMINAL_UNREACHABLE: "CONTROL_TERMINAL_UNREACHABLE";
+                        JOIN_CONTROL_PREDECESSOR_MISSING: "JOIN_CONTROL_PREDECESSOR_MISSING";
+                        PARALLEL_FANOUT_NOT_JOINED: "PARALLEL_FANOUT_NOT_JOINED";
+                        BRANCH_MERGE_INPUT_MISSING: "BRANCH_MERGE_INPUT_MISSING";
+                        BRANCH_MERGE_SOURCE_INVALID: "BRANCH_MERGE_SOURCE_INVALID";
+                        REFERENCE_NOT_FOUND: "REFERENCE_NOT_FOUND";
+                        REFERENCE_SOURCE_OPTIONAL: "REFERENCE_SOURCE_OPTIONAL";
+                        REFERENCE_NOT_DEPENDENCY: "REFERENCE_NOT_DEPENDENCY";
+                        MAP_REFERENCE_OUTSIDE_MAP: "MAP_REFERENCE_OUTSIDE_MAP";
+                        EDGE_REFERENCE_OUTSIDE_EDGE: "EDGE_REFERENCE_OUTSIDE_EDGE";
+                        WORKFLOW_OUTPUT_REFERENCE_INVALID: "WORKFLOW_OUTPUT_REFERENCE_INVALID";
+                        REFERENCE_INVALID: "REFERENCE_INVALID";
+                        REFERENCE_TYPE_MISMATCH: "REFERENCE_TYPE_MISMATCH";
+                        INPUT_SCHEMA_MISMATCH: "INPUT_SCHEMA_MISMATCH";
+                        INPUT_REQUIRED_PROPERTY_MISSING: "INPUT_REQUIRED_PROPERTY_MISSING";
+                        INPUT_ADDITIONAL_PROPERTY_FORBIDDEN: "INPUT_ADDITIONAL_PROPERTY_FORBIDDEN";
+                        MAP_ITEMS_NOT_ARRAY: "MAP_ITEMS_NOT_ARRAY";
+                        EDGE_INPUT_SCHEMA_MISMATCH: "EDGE_INPUT_SCHEMA_MISMATCH";
+                        AGENT_CWD_TYPE_MISMATCH: "AGENT_CWD_TYPE_MISMATCH";
+                        PLANNER_DRAFT_SCHEMA_INVALID: "PLANNER_DRAFT_SCHEMA_INVALID";
+                        PLANNER_DRAFT_ATOM_NOT_SELECTED: "PLANNER_DRAFT_ATOM_NOT_SELECTED";
+                        PLANNER_DRAFT_ALIAS_DUPLICATE: "PLANNER_DRAFT_ALIAS_DUPLICATE";
+                        PLANNER_DRAFT_REFERENCE_INVALID: "PLANNER_DRAFT_REFERENCE_INVALID";
+                        PLANNER_DRAFT_REFERENCE_AMBIGUOUS: "PLANNER_DRAFT_REFERENCE_AMBIGUOUS";
+                        PLANNER_DRAFT_CONTROL_INVALID: "PLANNER_DRAFT_CONTROL_INVALID";
+                        PLANNER_DRAFT_NORMALIZATION_FAILED: "PLANNER_DRAFT_NORMALIZATION_FAILED";
+                        PLANNER_TURN_LIMIT_EXCEEDED: "PLANNER_TURN_LIMIT_EXCEEDED";
+                        PLANNER_CAPABILITY_SCHEMA_INVALID: "PLANNER_CAPABILITY_SCHEMA_INVALID";
+                        PLANNING_WORKSPACE_ACTION_INVALID: "PLANNING_WORKSPACE_ACTION_INVALID";
+                        PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+                        PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+                        PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+                        PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED: "PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED";
+                        PLANNING_REQUIRED_INPUT_UNAVAILABLE: "PLANNING_REQUIRED_INPUT_UNAVAILABLE";
+                        PLANNING_BINDING_SOURCE_OPTIONAL: "PLANNING_BINDING_SOURCE_OPTIONAL";
+                        PLANNING_BINDING_AMBIGUOUS: "PLANNING_BINDING_AMBIGUOUS";
+                        PLANNING_BRANCH_RESULT_REQUIRED: "PLANNING_BRANCH_RESULT_REQUIRED";
+                        PLANNING_BRANCH_RESULT_MISMATCH: "PLANNING_BRANCH_RESULT_MISMATCH";
+                        PLANNING_DECISION_NO_EFFECT: "PLANNING_DECISION_NO_EFFECT";
+                        PLANNING_DRAFT_EMPTY: "PLANNING_DRAFT_EMPTY";
+                        PLANNING_TRANSACTION_INVALID: "PLANNING_TRANSACTION_INVALID";
+                        PLANNING_TRANSACTION_LIMIT_EXCEEDED: "PLANNING_TRANSACTION_LIMIT_EXCEEDED";
+                        PLANNING_TRANSACTION_VALIDATION_FAILED: "PLANNING_TRANSACTION_VALIDATION_FAILED";
+                        PLANNING_REVISION_CONFLICT: "PLANNING_REVISION_CONFLICT";
+                        PLANNING_REVISION_LIMIT_EXCEEDED: "PLANNING_REVISION_LIMIT_EXCEEDED";
+                        PLANNING_NODE_LIMIT_EXCEEDED: "PLANNING_NODE_LIMIT_EXCEEDED";
+                        PLANNING_OPERATION_CONFLICT: "PLANNING_OPERATION_CONFLICT";
+                        PLANNING_BLOCK_DUPLICATE: "PLANNING_BLOCK_DUPLICATE";
+                        PLANNING_BLOCK_NOT_FOUND: "PLANNING_BLOCK_NOT_FOUND";
+                        PLANNING_FINALIZE_CONFLICT: "PLANNING_FINALIZE_CONFLICT";
+                        PLANNING_WORKSPACE_NOT_EDITABLE: "PLANNING_WORKSPACE_NOT_EDITABLE";
+                        PLANNING_WORKSPACE_NOT_FINALIZABLE: "PLANNING_WORKSPACE_NOT_FINALIZABLE";
+                        PLANNING_ATOM_UNAVAILABLE: "PLANNING_ATOM_UNAVAILABLE";
+                        PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED: "PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED";
+                        PLANNING_FINAL_VALIDATION_FAILED: "PLANNING_FINAL_VALIDATION_FAILED";
+                        PLANNING_WORKFLOW_OUTPUT_REQUIRED: "PLANNING_WORKFLOW_OUTPUT_REQUIRED";
+                        PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED: "PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED";
+                        PLANNING_FINALIZED_REVISION_MISSING: "PLANNING_FINALIZED_REVISION_MISSING";
+                    }>;
+                    stage: z.ZodOptional<z.ZodEnum<{
+                        "json-extract": "json-extract";
+                        "capability-schema": "capability-schema";
+                        "capability-resolution": "capability-resolution";
+                        "draft-schema": "draft-schema";
+                        "atom-resolution": "atom-resolution";
+                        "draft-normalization": "draft-normalization";
+                        "workflow-schema": "workflow-schema";
+                        "data-link": "data-link";
+                        "control-graph": "control-graph";
+                        "runtime-policy": "runtime-policy";
+                    }>>;
+                    path: z.ZodString;
+                    message: z.ZodString;
+                    hint: z.ZodOptional<z.ZodString>;
+                    atomId: z.ZodOptional<z.ZodString>;
+                    expected: z.ZodOptional<z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+                    received: z.ZodOptional<z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>], "status">;
+            recordedAt: z.ZodString;
+        }, z.core.$strict>>;
+        gapReport: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0">;
+            kind: z.ZodEnum<{
+                "missing-atom": "missing-atom";
+                "missing-input": "missing-input";
+            }>;
+            code: z.ZodEnum<{
+                PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+                PLANNING_REQUIRED_INPUT_UNAVAILABLE: "PLANNING_REQUIRED_INPUT_UNAVAILABLE";
+            }>;
+            message: z.ZodString;
+            requirementId: z.ZodOptional<z.ZodString>;
+            paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            resolution: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    planningTurnsConsumed: z.ZodNumber;
+    maxPlanningTurns: z.ZodNumber;
+    lastValidationErrors: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            WORKFLOW_JSON_INVALID: "WORKFLOW_JSON_INVALID";
+            WORKFLOW_SCHEMA_INVALID: "WORKFLOW_SCHEMA_INVALID";
+            RUNTIME_POLICY_INVALID: "RUNTIME_POLICY_INVALID";
+            ATOM_CATALOG_INVALID: "ATOM_CATALOG_INVALID";
+            ATOM_CATALOG_DUPLICATE: "ATOM_CATALOG_DUPLICATE";
+            NODE_LIMIT_EXCEEDED: "NODE_LIMIT_EXCEEDED";
+            DEPENDENCY_LIMIT_EXCEEDED: "DEPENDENCY_LIMIT_EXCEEDED";
+            ATOM_NOT_FOUND: "ATOM_NOT_FOUND";
+            ATOM_UNAVAILABLE: "ATOM_UNAVAILABLE";
+            DEPRECATED_ATOM_FORBIDDEN: "DEPRECATED_ATOM_FORBIDDEN";
+            ATTEMPT_TIMEOUT_LIMIT_EXCEEDED: "ATTEMPT_TIMEOUT_LIMIT_EXCEEDED";
+            LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED: "LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED";
+            LIFECYCLE_TICK_LIMIT_EXCEEDED: "LIFECYCLE_TICK_LIMIT_EXCEEDED";
+            RETRY_LIMIT_EXCEEDED: "RETRY_LIMIT_EXCEEDED";
+            RETRY_DELAY_LIMIT_EXCEEDED: "RETRY_DELAY_LIMIT_EXCEEDED";
+            RETRY_POLICY_INVALID: "RETRY_POLICY_INVALID";
+            NON_IDEMPOTENT_RETRY_FORBIDDEN: "NON_IDEMPOTENT_RETRY_FORBIDDEN";
+            CACHE_TTL_LIMIT_EXCEEDED: "CACHE_TTL_LIMIT_EXCEEDED";
+            CACHE_ENABLE_OVERRIDE_FORBIDDEN: "CACHE_ENABLE_OVERRIDE_FORBIDDEN";
+            MAP_LIMIT_EXCEEDED: "MAP_LIMIT_EXCEEDED";
+            MAP_GROUP_CONFIG_MISMATCH: "MAP_GROUP_CONFIG_MISMATCH";
+            MAP_COMPLETION_CONFLICT: "MAP_COMPLETION_CONFLICT";
+            AGENT_PROVIDER_FORBIDDEN: "AGENT_PROVIDER_FORBIDDEN";
+            AGENT_MODEL_FORBIDDEN: "AGENT_MODEL_FORBIDDEN";
+            AGENT_FALLBACK_LIMIT_EXCEEDED: "AGENT_FALLBACK_LIMIT_EXCEEDED";
+            AGENT_FALLBACK_DUPLICATE: "AGENT_FALLBACK_DUPLICATE";
+            AGENT_CWD_FORBIDDEN: "AGENT_CWD_FORBIDDEN";
+            DUPLICATE_NODE_ID: "DUPLICATE_NODE_ID";
+            DUPLICATE_DEPENDENCY: "DUPLICATE_DEPENDENCY";
+            SELF_DEPENDENCY: "SELF_DEPENDENCY";
+            DEPENDENCY_NOT_FOUND: "DEPENDENCY_NOT_FOUND";
+            DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE";
+            ENTRY_NODE_NOT_FOUND: "ENTRY_NODE_NOT_FOUND";
+            ENTRY_NODE_DUPLICATE: "ENTRY_NODE_DUPLICATE";
+            ENTRY_DEPENDENCY_INVALID: "ENTRY_DEPENDENCY_INVALID";
+            EDGE_TARGET_NOT_FOUND: "EDGE_TARGET_NOT_FOUND";
+            EDGE_TARGET_DUPLICATE: "EDGE_TARGET_DUPLICATE";
+            EDGE_TERMINAL_WITH_INPUT_FORBIDDEN: "EDGE_TERMINAL_WITH_INPUT_FORBIDDEN";
+            EDGE_BACK_EDGE_UNBOUNDED: "EDGE_BACK_EDGE_UNBOUNDED";
+            EDGE_TRAVERSAL_LIMIT_EXCEEDED: "EDGE_TRAVERSAL_LIMIT_EXCEEDED";
+            DECISION_SELECT_REFERENCE_INVALID: "DECISION_SELECT_REFERENCE_INVALID";
+            DECISION_SELECT_TYPE_MISMATCH: "DECISION_SELECT_TYPE_MISMATCH";
+            DECISION_BRANCH_ENUM_MISMATCH: "DECISION_BRANCH_ENUM_MISMATCH";
+            CONTROL_NODE_UNREACHABLE: "CONTROL_NODE_UNREACHABLE";
+            CONTROL_DEAD_END: "CONTROL_DEAD_END";
+            CONTROL_TERMINAL_UNREACHABLE: "CONTROL_TERMINAL_UNREACHABLE";
+            JOIN_CONTROL_PREDECESSOR_MISSING: "JOIN_CONTROL_PREDECESSOR_MISSING";
+            PARALLEL_FANOUT_NOT_JOINED: "PARALLEL_FANOUT_NOT_JOINED";
+            BRANCH_MERGE_INPUT_MISSING: "BRANCH_MERGE_INPUT_MISSING";
+            BRANCH_MERGE_SOURCE_INVALID: "BRANCH_MERGE_SOURCE_INVALID";
+            REFERENCE_NOT_FOUND: "REFERENCE_NOT_FOUND";
+            REFERENCE_SOURCE_OPTIONAL: "REFERENCE_SOURCE_OPTIONAL";
+            REFERENCE_NOT_DEPENDENCY: "REFERENCE_NOT_DEPENDENCY";
+            MAP_REFERENCE_OUTSIDE_MAP: "MAP_REFERENCE_OUTSIDE_MAP";
+            EDGE_REFERENCE_OUTSIDE_EDGE: "EDGE_REFERENCE_OUTSIDE_EDGE";
+            WORKFLOW_OUTPUT_REFERENCE_INVALID: "WORKFLOW_OUTPUT_REFERENCE_INVALID";
+            REFERENCE_INVALID: "REFERENCE_INVALID";
+            REFERENCE_TYPE_MISMATCH: "REFERENCE_TYPE_MISMATCH";
+            INPUT_SCHEMA_MISMATCH: "INPUT_SCHEMA_MISMATCH";
+            INPUT_REQUIRED_PROPERTY_MISSING: "INPUT_REQUIRED_PROPERTY_MISSING";
+            INPUT_ADDITIONAL_PROPERTY_FORBIDDEN: "INPUT_ADDITIONAL_PROPERTY_FORBIDDEN";
+            MAP_ITEMS_NOT_ARRAY: "MAP_ITEMS_NOT_ARRAY";
+            EDGE_INPUT_SCHEMA_MISMATCH: "EDGE_INPUT_SCHEMA_MISMATCH";
+            AGENT_CWD_TYPE_MISMATCH: "AGENT_CWD_TYPE_MISMATCH";
+            PLANNER_DRAFT_SCHEMA_INVALID: "PLANNER_DRAFT_SCHEMA_INVALID";
+            PLANNER_DRAFT_ATOM_NOT_SELECTED: "PLANNER_DRAFT_ATOM_NOT_SELECTED";
+            PLANNER_DRAFT_ALIAS_DUPLICATE: "PLANNER_DRAFT_ALIAS_DUPLICATE";
+            PLANNER_DRAFT_REFERENCE_INVALID: "PLANNER_DRAFT_REFERENCE_INVALID";
+            PLANNER_DRAFT_REFERENCE_AMBIGUOUS: "PLANNER_DRAFT_REFERENCE_AMBIGUOUS";
+            PLANNER_DRAFT_CONTROL_INVALID: "PLANNER_DRAFT_CONTROL_INVALID";
+            PLANNER_DRAFT_NORMALIZATION_FAILED: "PLANNER_DRAFT_NORMALIZATION_FAILED";
+            PLANNER_TURN_LIMIT_EXCEEDED: "PLANNER_TURN_LIMIT_EXCEEDED";
+            PLANNER_CAPABILITY_SCHEMA_INVALID: "PLANNER_CAPABILITY_SCHEMA_INVALID";
+            PLANNING_WORKSPACE_ACTION_INVALID: "PLANNING_WORKSPACE_ACTION_INVALID";
+            PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+            PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+            PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+            PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED: "PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED";
+            PLANNING_REQUIRED_INPUT_UNAVAILABLE: "PLANNING_REQUIRED_INPUT_UNAVAILABLE";
+            PLANNING_BINDING_SOURCE_OPTIONAL: "PLANNING_BINDING_SOURCE_OPTIONAL";
+            PLANNING_BINDING_AMBIGUOUS: "PLANNING_BINDING_AMBIGUOUS";
+            PLANNING_BRANCH_RESULT_REQUIRED: "PLANNING_BRANCH_RESULT_REQUIRED";
+            PLANNING_BRANCH_RESULT_MISMATCH: "PLANNING_BRANCH_RESULT_MISMATCH";
+            PLANNING_DECISION_NO_EFFECT: "PLANNING_DECISION_NO_EFFECT";
+            PLANNING_DRAFT_EMPTY: "PLANNING_DRAFT_EMPTY";
+            PLANNING_TRANSACTION_INVALID: "PLANNING_TRANSACTION_INVALID";
+            PLANNING_TRANSACTION_LIMIT_EXCEEDED: "PLANNING_TRANSACTION_LIMIT_EXCEEDED";
+            PLANNING_TRANSACTION_VALIDATION_FAILED: "PLANNING_TRANSACTION_VALIDATION_FAILED";
+            PLANNING_REVISION_CONFLICT: "PLANNING_REVISION_CONFLICT";
+            PLANNING_REVISION_LIMIT_EXCEEDED: "PLANNING_REVISION_LIMIT_EXCEEDED";
+            PLANNING_NODE_LIMIT_EXCEEDED: "PLANNING_NODE_LIMIT_EXCEEDED";
+            PLANNING_OPERATION_CONFLICT: "PLANNING_OPERATION_CONFLICT";
+            PLANNING_BLOCK_DUPLICATE: "PLANNING_BLOCK_DUPLICATE";
+            PLANNING_BLOCK_NOT_FOUND: "PLANNING_BLOCK_NOT_FOUND";
+            PLANNING_FINALIZE_CONFLICT: "PLANNING_FINALIZE_CONFLICT";
+            PLANNING_WORKSPACE_NOT_EDITABLE: "PLANNING_WORKSPACE_NOT_EDITABLE";
+            PLANNING_WORKSPACE_NOT_FINALIZABLE: "PLANNING_WORKSPACE_NOT_FINALIZABLE";
+            PLANNING_ATOM_UNAVAILABLE: "PLANNING_ATOM_UNAVAILABLE";
+            PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED: "PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED";
+            PLANNING_FINAL_VALIDATION_FAILED: "PLANNING_FINAL_VALIDATION_FAILED";
+            PLANNING_WORKFLOW_OUTPUT_REQUIRED: "PLANNING_WORKFLOW_OUTPUT_REQUIRED";
+            PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED: "PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED";
+            PLANNING_FINALIZED_REVISION_MISSING: "PLANNING_FINALIZED_REVISION_MISSING";
+        }>;
+        stage: z.ZodOptional<z.ZodEnum<{
+            "json-extract": "json-extract";
+            "capability-schema": "capability-schema";
+            "capability-resolution": "capability-resolution";
+            "draft-schema": "draft-schema";
+            "atom-resolution": "atom-resolution";
+            "draft-normalization": "draft-normalization";
+            "workflow-schema": "workflow-schema";
+            "data-link": "data-link";
+            "control-graph": "control-graph";
+            "runtime-policy": "runtime-policy";
+        }>>;
+        path: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+        atomId: z.ZodOptional<z.ZodString>;
+        expected: z.ZodOptional<z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+        received: z.ZodOptional<z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>;
+    }, z.core.$strict>>;
+    lastSubmittedRequestId: z.ZodOptional<z.ZodString>;
+    acceptedPlannerDraft: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0">;
+        kind: z.ZodLiteral<"workflow-draft">;
+        name: z.ZodString;
+        flow: z.ZodType<import("./planner-draft.js").PlannerDraftStep, unknown, z.core.$ZodTypeInternals<import("./planner-draft.js").PlannerDraftStep, unknown>>;
+        outputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PlanningCheckpoint = z.infer<typeof PlanningCheckpointSchema>;
+//# sourceMappingURL=planner-validation.d.ts.map