@atom-workflow-agent/contracts 0.1.0

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

@@ -0,0 +1,576 @@
+import { z } from "zod";
+/** A semantic role mapped to one exact top-level Atom field. Schema remains Runtime-owned. */
+export declare const CapabilityPortReferenceSchema: z.ZodObject<{
+    role: z.ZodString;
+    field: z.ZodString;
+}, z.core.$strict>;
+export type CapabilityPortReference = z.infer<typeof CapabilityPortReferenceSchema>;
+export declare const CapabilityAtomUseSchema: z.ZodObject<{
+    atom: z.ZodString;
+    inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strict>>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        field: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CapabilityAtomUse = z.infer<typeof CapabilityAtomUseSchema>;
+/** Coarse business shape used only to report a genuinely missing Atom contract. */
+export declare const CapabilityDesiredPortSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    acceptedTypes: z.ZodArray<z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        null: "null";
+        array: "array";
+        integer: "integer";
+    }>>;
+}, z.core.$strict>;
+export type CapabilityDesiredPort = z.infer<typeof CapabilityDesiredPortSchema>;
+export declare const CapabilityResolutionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"covered">;
+    uses: z.ZodArray<z.ZodObject<{
+        atom: z.ZodString;
+        inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strict>>>;
+        outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            field: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+    desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        acceptedTypes: z.ZodArray<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            null: "null";
+            array: "array";
+            integer: "integer";
+        }>>;
+    }, z.core.$strict>>>;
+    desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        acceptedTypes: z.ZodArray<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            null: "null";
+            array: "array";
+            integer: "integer";
+        }>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>], "kind">;
+export type CapabilityResolution = z.infer<typeof CapabilityResolutionSchema>;
+export declare const CapabilityRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"covered">;
+        uses: z.ZodArray<z.ZodObject<{
+            atom: z.ZodString;
+            inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                role: z.ZodString;
+                field: z.ZodString;
+            }, z.core.$strict>>>;
+            outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                role: z.ZodString;
+                field: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"missing">;
+        desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            acceptedTypes: z.ZodArray<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+                integer: "integer";
+            }>>;
+        }, z.core.$strict>>>;
+        desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            acceptedTypes: z.ZodArray<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+                integer: "integer";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type CapabilityRequirement = z.infer<typeof CapabilityRequirementSchema>;
+export declare const PlannerCapabilityPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.1">;
+    kind: z.ZodLiteral<"capability-plan">;
+    requirements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"covered">;
+            uses: z.ZodArray<z.ZodObject<{
+                atom: z.ZodString;
+                inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    role: z.ZodString;
+                    field: z.ZodString;
+                }, z.core.$strict>>>;
+                outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    role: z.ZodString;
+                    field: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+            desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                acceptedTypes: z.ZodArray<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>>;
+            }, z.core.$strict>>>;
+            desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                acceptedTypes: z.ZodArray<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PlannerCapabilityPlan = z.infer<typeof PlannerCapabilityPlanSchema>;
+export declare const CapabilityNearMatchSchema: z.ZodObject<{
+    atomKey: z.ZodString;
+    title: z.ZodString;
+    purpose: z.ZodString;
+    score: z.ZodNumber;
+    rejectedBecause: z.ZodString;
+}, z.core.$strict>;
+export declare const SuggestedAtomContractSchema: z.ZodObject<{
+    suggestedId: z.ZodString;
+    description: z.ZodString;
+    inputFields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        acceptedTypes: z.ZodArray<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            null: "null";
+            array: "array";
+            integer: "integer";
+        }>>;
+    }, z.core.$strict>>;
+    outputFields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        acceptedTypes: z.ZodArray<z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            null: "null";
+            array: "array";
+            integer: "integer";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SuggestedAtomContract = z.infer<typeof SuggestedAtomContractSchema>;
+export declare const CapabilityFieldIssueSchema: z.ZodObject<{
+    atomKey: z.ZodString;
+    direction: z.ZodEnum<{
+        input: "input";
+        output: "output";
+    }>;
+    field: z.ZodString;
+    reason: z.ZodEnum<{
+        "field-not-found": "field-not-found";
+        "required-input-not-declared": "required-input-not-declared";
+    }>;
+    availableFields: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type CapabilityFieldIssue = z.infer<typeof CapabilityFieldIssueSchema>;
+export declare const CapabilityGapSchema: z.ZodObject<{
+    requirement: z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"covered">;
+            uses: z.ZodArray<z.ZodObject<{
+                atom: z.ZodString;
+                inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    role: z.ZodString;
+                    field: z.ZodString;
+                }, z.core.$strict>>>;
+                outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    role: z.ZodString;
+                    field: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+            desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                acceptedTypes: z.ZodArray<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>>;
+            }, z.core.$strict>>>;
+            desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                acceptedTypes: z.ZodArray<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>;
+    code: z.ZodEnum<{
+        PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+        PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+        PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+    }>;
+    message: z.ZodString;
+    nearMatches: z.ZodArray<z.ZodObject<{
+        atomKey: z.ZodString;
+        title: z.ZodString;
+        purpose: z.ZodString;
+        score: z.ZodNumber;
+        rejectedBecause: z.ZodString;
+    }, z.core.$strict>>;
+    suggestedAtomContract: z.ZodObject<{
+        suggestedId: z.ZodString;
+        description: z.ZodString;
+        inputFields: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            acceptedTypes: z.ZodArray<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+                integer: "integer";
+            }>>;
+        }, z.core.$strict>>;
+        outputFields: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            acceptedTypes: z.ZodArray<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+                integer: "integer";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    fieldIssues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        atomKey: z.ZodString;
+        direction: z.ZodEnum<{
+            input: "input";
+            output: "output";
+        }>;
+        field: z.ZodString;
+        reason: z.ZodEnum<{
+            "field-not-found": "field-not-found";
+            "required-input-not-declared": "required-input-not-declared";
+        }>;
+        availableFields: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CapabilityGap = z.infer<typeof CapabilityGapSchema>;
+export declare const CapabilityCoverageResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.1">;
+    status: z.ZodLiteral<"covered">;
+    catalogHash: z.ZodString;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.1">;
+        kind: z.ZodLiteral<"capability-plan">;
+        requirements: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"covered">;
+                uses: z.ZodArray<z.ZodObject<{
+                    atom: z.ZodString;
+                    inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        role: z.ZodString;
+                        field: z.ZodString;
+                    }, z.core.$strict>>>;
+                    outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        role: z.ZodString;
+                        field: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+                desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>>;
+                desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    selectedAtomKeys: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.1">;
+    status: z.ZodLiteral<"blocked_missing_atom">;
+    catalogHash: z.ZodString;
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.1">;
+        kind: z.ZodLiteral<"capability-plan">;
+        requirements: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"covered">;
+                uses: z.ZodArray<z.ZodObject<{
+                    atom: z.ZodString;
+                    inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        role: z.ZodString;
+                        field: z.ZodString;
+                    }, z.core.$strict>>>;
+                    outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        role: z.ZodString;
+                        field: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+                desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>>;
+                desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    searchedAtomCount: z.ZodNumber;
+    gaps: z.ZodArray<z.ZodObject<{
+        requirement: z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            resolution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"covered">;
+                uses: z.ZodArray<z.ZodObject<{
+                    atom: z.ZodString;
+                    inputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        role: z.ZodString;
+                        field: z.ZodString;
+                    }, z.core.$strict>>>;
+                    outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        role: z.ZodString;
+                        field: z.ZodString;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"missing">;
+                desiredInputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>>;
+                desiredOutputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodString;
+                    required: z.ZodDefault<z.ZodBoolean>;
+                    acceptedTypes: z.ZodArray<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        null: "null";
+                        array: "array";
+                        integer: "integer";
+                    }>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>;
+        code: z.ZodEnum<{
+            PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+            PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+            PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+        }>;
+        message: z.ZodString;
+        nearMatches: z.ZodArray<z.ZodObject<{
+            atomKey: z.ZodString;
+            title: z.ZodString;
+            purpose: z.ZodString;
+            score: z.ZodNumber;
+            rejectedBecause: z.ZodString;
+        }, z.core.$strict>>;
+        suggestedAtomContract: z.ZodObject<{
+            suggestedId: z.ZodString;
+            description: z.ZodString;
+            inputFields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                acceptedTypes: z.ZodArray<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>>;
+            }, z.core.$strict>>;
+            outputFields: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                required: z.ZodDefault<z.ZodBoolean>;
+                acceptedTypes: z.ZodArray<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        fieldIssues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            atomKey: z.ZodString;
+            direction: z.ZodEnum<{
+                input: "input";
+                output: "output";
+            }>;
+            field: z.ZodString;
+            reason: z.ZodEnum<{
+                "field-not-found": "field-not-found";
+                "required-input-not-declared": "required-input-not-declared";
+            }>;
+            availableFields: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "status">;
+export type CapabilityCoverageResult = z.infer<typeof CapabilityCoverageResultSchema>;
+//# sourceMappingURL=planning-capability.d.ts.map

package/dist/planner/planning-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planning-capability.d.ts","sourceRoot":"","sources":["../../src/planner/planning-capability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,8FAA8F;AAC9F,eAAO,MAAM,6BAA6B;;;kBAG/B,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,uBAAuB;;;;;;;;;;kBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,mFAAmF;AACnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;kBAStC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7B,CAAC;AACZ,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAStC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,yBAAyB;;;;;;kBAM3B,CAAC;AAEZ,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7B,CAAC;AACZ,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;kBAM5B,CAAC;AACZ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOrB,CAAC;AACZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAgBzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}

package/dist/planner/planning-capability.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { PlannerCatalogFieldTypeSchema } from "../atoms/descriptors.js";
+import { WorkflowAtomReferenceSchema } from "../workflows/spec.js";
+const HashSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+/** A semantic role mapped to one exact top-level Atom field. Schema remains Runtime-owned. */
+export const CapabilityPortReferenceSchema = z.object({
+    role: z.string().trim().min(1),
+    field: z.string().trim().min(1),
+}).strict();
+export const CapabilityAtomUseSchema = z.object({
+    atom: WorkflowAtomReferenceSchema,
+    inputs: z.array(CapabilityPortReferenceSchema).default([]),
+    outputs: z.array(CapabilityPortReferenceSchema).default([]),
+}).strict().superRefine((use, context) => {
+    for (const [direction, ports] of [["inputs", use.inputs], ["outputs", use.outputs]]) {
+        const fields = ports.map(({ field }) => field);
+        if (new Set(fields).size !== fields.length) {
+            context.addIssue({ code: "custom", path: [direction], message: `Capability ${direction} must reference unique Atom fields` });
+        }
+    }
+});
+/** Coarse business shape used only to report a genuinely missing Atom contract. */
+export const CapabilityDesiredPortSchema = z.object({
+    name: z.string().trim().min(1),
+    description: z.string().trim().min(1),
+    required: z.boolean().default(true),
+    acceptedTypes: z.array(PlannerCatalogFieldTypeSchema).min(1).max(7),
+}).strict().superRefine((port, context) => {
+    if (new Set(port.acceptedTypes).size !== port.acceptedTypes.length) {
+        context.addIssue({ code: "custom", path: ["acceptedTypes"], message: "Desired port types must be unique" });
+    }
+});
+export const CapabilityResolutionSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("covered"),
+        uses: z.array(CapabilityAtomUseSchema).min(1).max(128),
+    }).strict(),
+    z.object({
+        kind: z.literal("missing"),
+        desiredInputs: z.array(CapabilityDesiredPortSchema).default([]),
+        desiredOutputs: z.array(CapabilityDesiredPortSchema).default([]),
+    }).strict(),
+]);
+export const CapabilityRequirementSchema = z.object({
+    id: z.string().regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/),
+    description: z.string().trim().min(1),
+    required: z.boolean().default(true),
+    resolution: CapabilityResolutionSchema,
+}).strict();
+export const PlannerCapabilityPlanSchema = z.object({
+    schemaVersion: z.literal("1.1"),
+    kind: z.literal("capability-plan"),
+    requirements: z.array(CapabilityRequirementSchema).min(1).max(128),
+}).strict().superRefine((plan, context) => {
+    const ids = plan.requirements.map(({ id }) => id);
+    if (new Set(ids).size !== ids.length) {
+        context.addIssue({ code: "custom", path: ["requirements"], message: "Capability requirement ids must be unique" });
+    }
+});
+export const CapabilityNearMatchSchema = z.object({
+    atomKey: WorkflowAtomReferenceSchema,
+    title: z.string().trim().min(1),
+    purpose: z.string().trim().min(1),
+    score: z.number().min(0).max(1),
+    rejectedBecause: z.string().trim().min(1),
+}).strict();
+export const SuggestedAtomContractSchema = z.object({
+    suggestedId: z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/),
+    description: z.string().trim().min(1),
+    inputFields: z.array(CapabilityDesiredPortSchema),
+    outputFields: z.array(CapabilityDesiredPortSchema),
+}).strict();
+export const CapabilityFieldIssueSchema = z.object({
+    atomKey: WorkflowAtomReferenceSchema,
+    direction: z.enum(["input", "output"]),
+    field: z.string().trim().min(1),
+    reason: z.enum(["field-not-found", "required-input-not-declared"]),
+    availableFields: z.array(z.string().trim().min(1)),
+}).strict();
+export const CapabilityGapSchema = z.object({
+    requirement: CapabilityRequirementSchema,
+    code: z.enum(["PLANNING_CAPABILITY_UNAVAILABLE", "PLANNING_CAPABILITY_ATOM_UNKNOWN", "PLANNING_CAPABILITY_SCHEMA_MISMATCH"]),
+    message: z.string().trim().min(1),
+    nearMatches: z.array(CapabilityNearMatchSchema).max(5),
+    suggestedAtomContract: SuggestedAtomContractSchema,
+    fieldIssues: z.array(CapabilityFieldIssueSchema).optional(),
+}).strict();
+export const CapabilityCoverageResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        schemaVersion: z.literal("1.1"),
+        status: z.literal("covered"),
+        catalogHash: HashSchema,
+        plan: PlannerCapabilityPlanSchema,
+        selectedAtomKeys: z.array(WorkflowAtomReferenceSchema).min(1).max(128),
+    }).strict(),
+    z.object({
+        schemaVersion: z.literal("1.1"),
+        status: z.literal("blocked_missing_atom"),
+        catalogHash: HashSchema,
+        plan: PlannerCapabilityPlanSchema,
+        searchedAtomCount: z.number().int().nonnegative(),
+        gaps: z.array(CapabilityGapSchema).min(1),
+    }).strict(),
+]);
+//# sourceMappingURL=planning-capability.js.map