@atom-workflow-agent/contracts 0.1.0

package/dist/planner/planning-workspace.d.ts

@@ -0,0 +1,1791 @@
+import { z } from "zod";
+import { WorkflowNodePolicySchema } from "../workflows/spec.js";
+export declare const PlanningBindingEvidenceSchema: 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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    reason: z.ZodString;
+    confidence: z.ZodLiteral<"high">;
+}, z.core.$strict>;
+export type PlanningBindingEvidence = z.infer<typeof PlanningBindingEvidenceSchema>;
+export declare const PlanningFrontierValueSchema: z.ZodObject<{
+    ref: z.ZodString;
+    producerAlias: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    schema: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+    description: z.ZodString;
+    required: z.ZodBoolean;
+    guaranteed: z.ZodLiteral<true>;
+    controlEvidence: z.ZodString;
+}, z.core.$strict>;
+export type PlanningFrontierValue = z.infer<typeof PlanningFrontierValueSchema>;
+export declare const PlanningFrontierSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    workspaceId: z.ZodString;
+    revision: z.ZodNumber;
+    draftHash: z.ZodString;
+    blockIds: z.ZodArray<z.ZodString>;
+    guaranteedAliases: z.ZodArray<z.ZodString>;
+    availableValues: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        producerAlias: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        schema: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+        description: z.ZodString;
+        required: z.ZodBoolean;
+        guaranteed: z.ZodLiteral<true>;
+        controlEvidence: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PlanningFrontier = z.infer<typeof PlanningFrontierSchema>;
+export declare const PlanningWorkspaceStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    cancelled: "cancelled";
+    blocked_missing_atom: "blocked_missing_atom";
+    editing: "editing";
+    blocked_missing_input: "blocked_missing_input";
+    finalized: "finalized";
+}>;
+export type PlanningWorkspaceStatus = z.infer<typeof PlanningWorkspaceStatusSchema>;
+export declare const PlanningGapReportSchema: 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>;
+export type PlanningGapReport = z.infer<typeof PlanningGapReportSchema>;
+/** A semantic source selector. Runtime converts it into an exact Draft reference. */
+export declare const PlanningSourceSchema: 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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+}, z.core.$strict>], "source">;
+export type PlanningSource = z.infer<typeof PlanningSourceSchema>;
+export interface PlanningAtomStep {
+    readonly kind: "atom";
+    readonly id: string;
+    readonly atom: string;
+    readonly bindings?: Readonly<Record<string, PlanningSource>> | undefined;
+    readonly policy?: z.infer<typeof WorkflowNodePolicySchema> | undefined;
+}
+export interface PlanningSequenceStep {
+    readonly kind: "sequence";
+    readonly steps: readonly PlanningStep[];
+}
+export interface PlanningParallelStep {
+    readonly kind: "parallel";
+    readonly branches: readonly PlanningStep[];
+}
+export interface PlanningDecisionStep {
+    readonly kind: "decision";
+    readonly id: string;
+    readonly atom: string;
+    readonly select: string;
+    readonly bindings?: Readonly<Record<string, PlanningSource>> | undefined;
+    readonly branches: Readonly<Record<string, PlanningDecisionBranch>>;
+    readonly defaultBranch: string;
+    readonly policy?: z.infer<typeof WorkflowNodePolicySchema> | undefined;
+}
+export interface PlanningMapStep {
+    readonly kind: "map";
+    readonly id: string;
+    readonly items: PlanningSource;
+    readonly maxItems: number;
+    readonly maxConcurrency?: number | undefined;
+    readonly body: PlanningMapBodyStep;
+}
+export interface PlanningRepeatStep {
+    readonly kind: "repeat";
+    readonly maxIterations: number;
+    readonly body: PlanningStep;
+    readonly decision: Omit<PlanningDecisionStep, "kind" | "branches"> & {
+        readonly continueBranch: string;
+        readonly exitBranch: string;
+    };
+}
+export type PlanningDecisionBranch = {
+    readonly mode: "continue";
+    readonly flow?: PlanningStep | undefined;
+    /** Typed values exported by this mutually-exclusive path into the common continuation. */
+    readonly result?: Readonly<Record<string, PlanningSource>> | undefined;
+} | {
+    readonly mode: "revisit";
+    readonly maxIterations: number;
+    readonly flow: PlanningStep;
+} | {
+    readonly mode: "terminal";
+    readonly status: "success" | "failure";
+};
+export type PlanningStep = PlanningAtomStep | PlanningSequenceStep | PlanningParallelStep | PlanningDecisionStep | PlanningMapStep | PlanningRepeatStep;
+export type PlanningMapBodyStep = PlanningAtomStep | {
+    readonly kind: "sequence";
+    readonly steps: readonly PlanningMapBodyStep[];
+} | {
+    readonly kind: "parallel";
+    readonly branches: readonly PlanningMapBodyStep[];
+};
+export declare const PlanningStepSchema: z.ZodType<PlanningStep>;
+export declare const PlanningMapBodyStepSchema: z.ZodType<PlanningMapBodyStep>;
+export declare const PlanningStepJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>>;
+/** One semantic control region. It contains no Runtime references or graph edges. */
+export declare const PlanningPlanBlockSchema: z.ZodObject<{
+    blockId: z.ZodString;
+    plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>;
+}, z.core.$strict>;
+export type PlanningPlanBlock = z.infer<typeof PlanningPlanBlockSchema>;
+export declare const PlanningOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"add-region">;
+    block: z.ZodObject<{
+        blockId: z.ZodString;
+        plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    op: z.ZodLiteral<"replace-region">;
+    blockId: z.ZodString;
+    plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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">;
+export type PlanningOperation = z.infer<typeof PlanningOperationSchema>;
+/** Atomic change-set against exactly one immutable Draft Revision. */
+export declare const PlanningDraftTransactionSchema: 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<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        op: z.ZodLiteral<"replace-region">;
+        blockId: z.ZodString;
+        plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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>;
+export type PlanningDraftTransaction = z.infer<typeof PlanningDraftTransactionSchema>;
+/** The only documents an ACP Planner may return while editing a Workspace. */
+export declare const PlanningWorkspaceActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    kind: z.ZodLiteral<"workspace-plan">;
+    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<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"replace-region">;
+            blockId: z.ZodString;
+            plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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>;
+    finalize: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    kind: z.ZodLiteral<"workspace-finalize">;
+    revision: z.ZodNumber;
+    draftHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    kind: z.ZodLiteral<"workspace-report-gap">;
+    report: 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>], "kind">;
+export type PlanningWorkspaceAction = z.infer<typeof PlanningWorkspaceActionSchema>;
+export declare const PlanningDraftRevisionSchema: 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<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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>;
+export type PlanningDraftRevision = z.infer<typeof PlanningDraftRevisionSchema>;
+export declare const PlanningWorkspaceSchema: 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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    context: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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>;
+export type PlanningWorkspace = z.infer<typeof PlanningWorkspaceSchema>;
+export declare const PlanningTransactionCommittedResultSchema: 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<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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>;
+export declare const PlanningTransactionRejectedResultSchema: 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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        received: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const PlanningTransactionResultSchema: 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<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        received: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "status">;
+export type PlanningTransactionResult = z.infer<typeof PlanningTransactionResultSchema>;
+export declare const PlanningTransactionRecordSchema: 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<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            op: z.ZodLiteral<"replace-region">;
+            blockId: z.ZodString;
+            plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            received: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "status">;
+    recordedAt: z.ZodString;
+}, z.core.$strict>;
+export type PlanningTransactionRecord = z.infer<typeof PlanningTransactionRecordSchema>;
+/** Serializable state used by the future durable Workspace Store. */
+export declare const PlanningWorkspaceSnapshotSchema: 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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        context: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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<PlanningStep, unknown, z.core.$ZodTypeInternals<PlanningStep, unknown>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                op: z.ZodLiteral<"replace-region">;
+                blockId: z.ZodString;
+                plan: z.ZodType<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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<PlanningStep, unknown, z.core.$ZodTypeInternals<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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                    targetSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                received: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.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>;
+export type PlanningWorkspaceSnapshot = z.infer<typeof PlanningWorkspaceSnapshotSchema>;
+//# sourceMappingURL=planning-workspace.d.ts.map