@ai-dev-orchestrator/schemas 0.1.1

package/dist/specification/canonical-specification.d.ts

@@ -0,0 +1,475 @@
+import { z } from 'zod/v4';
+export declare const specificationIdSchema: z.core.$ZodBranded<z.ZodString, "SpecificationId", "out">;
+export type SpecificationId = z.infer<typeof specificationIdSchema>;
+export declare const stakeholderSchema: z.ZodObject<{
+    name: z.ZodString;
+    role: z.ZodString;
+    interest: z.ZodString;
+}, z.core.$strip>;
+export type Stakeholder = z.infer<typeof stakeholderSchema>;
+export declare const assumptionSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    impact: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    validated: z.ZodBoolean;
+}, z.core.$strip>;
+export type Assumption = z.infer<typeof assumptionSchema>;
+export declare const constraintSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<{
+        resource: "resource";
+        technical: "technical";
+        business: "business";
+        regulatory: "regulatory";
+        timeline: "timeline";
+    }>;
+    source: z.ZodString;
+}, z.core.$strip>;
+export type Constraint = z.infer<typeof constraintSchema>;
+export declare const requirementPrioritySchema: z.ZodEnum<{
+    must: "must";
+    should: "should";
+    could: "could";
+    wont: "wont";
+}>;
+export type RequirementPriority = z.infer<typeof requirementPrioritySchema>;
+export declare const functionalRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    priority: z.ZodEnum<{
+        must: "must";
+        should: "should";
+        could: "could";
+        wont: "wont";
+    }>;
+    acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type FunctionalRequirement = z.infer<typeof functionalRequirementSchema>;
+export declare const nfrCategorySchema: z.ZodEnum<{
+    security: "security";
+    performance: "performance";
+    maintainability: "maintainability";
+    other: "other";
+    reliability: "reliability";
+    scalability: "scalability";
+    usability: "usability";
+    compatibility: "compatibility";
+}>;
+export type NfrCategory = z.infer<typeof nfrCategorySchema>;
+export declare const nonFunctionalRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    category: z.ZodEnum<{
+        security: "security";
+        performance: "performance";
+        maintainability: "maintainability";
+        other: "other";
+        reliability: "reliability";
+        scalability: "scalability";
+        usability: "usability";
+        compatibility: "compatibility";
+    }>;
+    metric: z.ZodOptional<z.ZodString>;
+    threshold: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NonFunctionalRequirement = z.infer<typeof nonFunctionalRequirementSchema>;
+export declare const verificationMethodSchema: z.ZodEnum<{
+    review: "review";
+    test: "test";
+    demo: "demo";
+    analysis: "analysis";
+}>;
+export type VerificationMethod = z.infer<typeof verificationMethodSchema>;
+export declare const acceptanceCriterionSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    verificationMethod: z.ZodEnum<{
+        review: "review";
+        test: "test";
+        demo: "demo";
+        analysis: "analysis";
+    }>;
+    requirementIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type AcceptanceCriterion = z.infer<typeof acceptanceCriterionSchema>;
+export declare const riskSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    likelihood: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    impact: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    mitigation: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Risk = z.infer<typeof riskSchema>;
+export declare const dependencySchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    type: z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        available: "available";
+        blocked: "blocked";
+    }>;
+    owner: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Dependency = z.infer<typeof dependencySchema>;
+export declare const sourceProvenanceSchema: z.ZodObject<{
+    fetchedAt: z.ZodString;
+    checksum: z.ZodString;
+    fieldsMapped: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SourceProvenance = z.infer<typeof sourceProvenanceSchema>;
+export declare const specificationAnalysisSchema: z.ZodObject<{
+    completenessScore: z.ZodNumber;
+    ambiguityCount: z.ZodNumber;
+    riskCount: z.ZodNumber;
+    unvalidatedAssumptionCount: z.ZodNumber;
+    readinessVerdict: z.ZodEnum<{
+        Ready: "Ready";
+        NotReady: "NotReady";
+    }>;
+    analystNotes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SpecificationAnalysis = z.infer<typeof specificationAnalysisSchema>;
+export declare const canonicalSpecificationSchema: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodString, "SpecificationId", "out">;
+    version: z.ZodNumber;
+    previousVersion: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    businessGoal: z.ZodString;
+    stakeholders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodString;
+        interest: z.ZodString;
+    }, z.core.$strip>>>;
+    assumptions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        impact: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        validated: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            resource: "resource";
+            technical: "technical";
+            business: "business";
+            regulatory: "regulatory";
+            timeline: "timeline";
+        }>;
+        source: z.ZodString;
+    }, z.core.$strip>>>;
+    functionalRequirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        priority: z.ZodEnum<{
+            must: "must";
+            should: "should";
+            could: "could";
+            wont: "wont";
+        }>;
+        acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        dependencies: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    nonFunctionalRequirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        category: z.ZodEnum<{
+            security: "security";
+            performance: "performance";
+            maintainability: "maintainability";
+            other: "other";
+            reliability: "reliability";
+            scalability: "scalability";
+            usability: "usability";
+            compatibility: "compatibility";
+        }>;
+        metric: z.ZodOptional<z.ZodString>;
+        threshold: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        verificationMethod: z.ZodEnum<{
+            review: "review";
+            test: "test";
+            demo: "demo";
+            analysis: "analysis";
+        }>;
+        requirementIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    risks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        likelihood: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        impact: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    dependencies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            available: "available";
+            blocked: "blocked";
+        }>;
+        owner: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    definitionOfDone: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    sources: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        fetchedAt: z.ZodString;
+        checksum: z.ZodString;
+        fieldsMapped: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    analysis: z.ZodOptional<z.ZodObject<{
+        completenessScore: z.ZodNumber;
+        ambiguityCount: z.ZodNumber;
+        riskCount: z.ZodNumber;
+        unvalidatedAssumptionCount: z.ZodNumber;
+        readinessVerdict: z.ZodEnum<{
+            Ready: "Ready";
+            NotReady: "NotReady";
+        }>;
+        analystNotes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CanonicalSpecification = z.infer<typeof canonicalSpecificationSchema>;
+export declare const specificationValidationErrorSchema: z.ZodObject<{
+    field: z.ZodString;
+    message: z.ZodString;
+    rule: z.ZodString;
+}, z.core.$strip>;
+export type SpecificationValidationError = z.infer<typeof specificationValidationErrorSchema>;
+export declare const specificationValidationWarningSchema: z.ZodObject<{
+    field: z.ZodString;
+    message: z.ZodString;
+    suggestion: z.ZodString;
+}, z.core.$strip>;
+export type SpecificationValidationWarning = z.infer<typeof specificationValidationWarningSchema>;
+export declare const specificationValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        message: z.ZodString;
+        rule: z.ZodString;
+    }, z.core.$strip>>>;
+    warnings: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        message: z.ZodString;
+        suggestion: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SpecificationValidationResult = z.infer<typeof specificationValidationResultSchema>;
+export declare const completenessResultSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    missingFields: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    emptyFields: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    fieldScores: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type CompletenessResult = z.infer<typeof completenessResultSchema>;
+export declare const mergeStrategySchema: z.ZodObject<{
+    scalarConflict: z.ZodEnum<{
+        "last-wins": "last-wins";
+        "first-wins": "first-wins";
+        "flag-conflict": "flag-conflict";
+    }>;
+    arrayMerge: z.ZodEnum<{
+        union: "union";
+        concatenate: "concatenate";
+    }>;
+    deduplication: z.ZodBoolean;
+}, z.core.$strip>;
+export type MergeStrategy = z.infer<typeof mergeStrategySchema>;
+export declare const mergeConflictSchema: z.ZodObject<{
+    field: z.ZodString;
+    values: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>>;
+    resolution: z.ZodEnum<{
+        "auto-resolved": "auto-resolved";
+        flagged: "flagged";
+    }>;
+    resolvedValue: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MergeConflict = z.infer<typeof mergeConflictSchema>;
+export declare const mergeResultSchema: z.ZodObject<{
+    merged: z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "SpecificationId", "out">;
+        version: z.ZodNumber;
+        previousVersion: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        businessGoal: z.ZodString;
+        stakeholders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            role: z.ZodString;
+            interest: z.ZodString;
+        }, z.core.$strip>>>;
+        assumptions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            impact: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            validated: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                resource: "resource";
+                technical: "technical";
+                business: "business";
+                regulatory: "regulatory";
+                timeline: "timeline";
+            }>;
+            source: z.ZodString;
+        }, z.core.$strip>>>;
+        functionalRequirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            priority: z.ZodEnum<{
+                must: "must";
+                should: "should";
+                could: "could";
+                wont: "wont";
+            }>;
+            acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            dependencies: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>>;
+        nonFunctionalRequirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            category: z.ZodEnum<{
+                security: "security";
+                performance: "performance";
+                maintainability: "maintainability";
+                other: "other";
+                reliability: "reliability";
+                scalability: "scalability";
+                usability: "usability";
+                compatibility: "compatibility";
+            }>;
+            metric: z.ZodOptional<z.ZodString>;
+            threshold: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        acceptanceCriteria: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            verificationMethod: z.ZodEnum<{
+                review: "review";
+                test: "test";
+                demo: "demo";
+                analysis: "analysis";
+            }>;
+            requirementIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        risks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            likelihood: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            impact: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            mitigation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        dependencies: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            type: z.ZodEnum<{
+                external: "external";
+                internal: "internal";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                available: "available";
+                blocked: "blocked";
+            }>;
+            owner: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        definitionOfDone: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        sources: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            fetchedAt: z.ZodString;
+            checksum: z.ZodString;
+            fieldsMapped: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        analysis: z.ZodOptional<z.ZodObject<{
+            completenessScore: z.ZodNumber;
+            ambiguityCount: z.ZodNumber;
+            riskCount: z.ZodNumber;
+            unvalidatedAssumptionCount: z.ZodNumber;
+            readinessVerdict: z.ZodEnum<{
+                Ready: "Ready";
+                NotReady: "NotReady";
+            }>;
+            analystNotes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    conflicts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        values: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>;
+        resolution: z.ZodEnum<{
+            "auto-resolved": "auto-resolved";
+            flagged: "flagged";
+        }>;
+        resolvedValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MergeResult = z.infer<typeof mergeResultSchema>;
+export declare const COMPLETENESS_WEIGHTS: Record<string, number>;

package/dist/specification/canonical-specification.js

@@ -0,0 +1,151 @@
+import { z } from 'zod/v4';
+import { readinessVerdictSchema, threeTierSeveritySchema } from '../shared/string-enums';
+export const specificationIdSchema = z.string().brand('SpecificationId');
+export const stakeholderSchema = z.object({
+    name: z.string(),
+    role: z.string(),
+    interest: z.string(),
+});
+export const assumptionSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    impact: threeTierSeveritySchema,
+    validated: z.boolean(),
+});
+export const constraintSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    type: z.enum(['technical', 'business', 'regulatory', 'timeline', 'resource']),
+    source: z.string(),
+});
+export const requirementPrioritySchema = z.enum(['must', 'should', 'could', 'wont']);
+export const functionalRequirementSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    priority: requirementPrioritySchema,
+    acceptanceCriteria: z.array(z.string()).readonly(),
+    dependencies: z.array(z.string()).readonly().optional(),
+});
+export const nfrCategorySchema = z.enum([
+    'performance',
+    'security',
+    'reliability',
+    'scalability',
+    'usability',
+    'maintainability',
+    'compatibility',
+    'other',
+]);
+export const nonFunctionalRequirementSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    category: nfrCategorySchema,
+    metric: z.string().optional(),
+    threshold: z.string().optional(),
+});
+export const verificationMethodSchema = z.enum(['test', 'review', 'demo', 'analysis']);
+export const acceptanceCriterionSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    verificationMethod: verificationMethodSchema,
+    requirementIds: z.array(z.string()).readonly(),
+});
+export const riskSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    likelihood: threeTierSeveritySchema,
+    impact: threeTierSeveritySchema,
+    mitigation: z.string().optional(),
+});
+export const dependencySchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    type: z.enum(['internal', 'external']),
+    status: z.enum(['available', 'pending', 'blocked']),
+    owner: z.string().optional(),
+});
+export const sourceProvenanceSchema = z.object({
+    fetchedAt: z.string(),
+    checksum: z.string(),
+    fieldsMapped: z.array(z.string()).readonly(),
+});
+export const specificationAnalysisSchema = z.object({
+    completenessScore: z.number(),
+    ambiguityCount: z.number(),
+    riskCount: z.number(),
+    unvalidatedAssumptionCount: z.number(),
+    readinessVerdict: readinessVerdictSchema,
+    analystNotes: z.string().optional(),
+});
+export const canonicalSpecificationSchema = z.object({
+    id: specificationIdSchema,
+    version: z.number(),
+    previousVersion: z.string().optional(),
+    title: z.string(),
+    businessGoal: z.string(),
+    stakeholders: z.array(stakeholderSchema).readonly(),
+    assumptions: z.array(assumptionSchema).readonly(),
+    constraints: z.array(constraintSchema).readonly(),
+    functionalRequirements: z.array(functionalRequirementSchema).readonly(),
+    nonFunctionalRequirements: z.array(nonFunctionalRequirementSchema).readonly(),
+    acceptanceCriteria: z.array(acceptanceCriterionSchema).readonly(),
+    risks: z.array(riskSchema).readonly(),
+    dependencies: z.array(dependencySchema).readonly(),
+    definitionOfDone: z.array(z.string()).readonly(),
+    sources: z.array(sourceProvenanceSchema).readonly(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    extensions: z.record(z.string(), z.unknown()).optional(),
+    analysis: specificationAnalysisSchema.optional(),
+});
+export const specificationValidationErrorSchema = z.object({
+    field: z.string(),
+    message: z.string(),
+    rule: z.string(),
+});
+export const specificationValidationWarningSchema = z.object({
+    field: z.string(),
+    message: z.string(),
+    suggestion: z.string(),
+});
+export const specificationValidationResultSchema = z.object({
+    valid: z.boolean(),
+    errors: z.array(specificationValidationErrorSchema).readonly(),
+    warnings: z.array(specificationValidationWarningSchema).readonly(),
+});
+export const completenessResultSchema = z.object({
+    score: z.number(),
+    missingFields: z.array(z.string()).readonly(),
+    emptyFields: z.array(z.string()).readonly(),
+    fieldScores: z.record(z.string(), z.number()),
+});
+export const mergeStrategySchema = z.object({
+    scalarConflict: z.enum(['last-wins', 'first-wins', 'flag-conflict']),
+    arrayMerge: z.enum(['union', 'concatenate']),
+    deduplication: z.boolean(),
+});
+export const mergeConflictSchema = z.object({
+    field: z.string(),
+    values: z.array(z.object({ source: z.string(), value: z.string() })).readonly(),
+    resolution: z.enum(['auto-resolved', 'flagged']),
+    resolvedValue: z.string().optional(),
+});
+export const mergeResultSchema = z.object({
+    merged: canonicalSpecificationSchema,
+    conflicts: z.array(mergeConflictSchema).readonly(),
+});
+export const COMPLETENESS_WEIGHTS = {
+    title: 0.05,
+    businessGoal: 0.1,
+    stakeholders: 0.05,
+    assumptions: 0.1,
+    constraints: 0.05,
+    functionalRequirements: 0.25,
+    nonFunctionalRequirements: 0.1,
+    acceptanceCriteria: 0.15,
+    risks: 0.05,
+    dependencies: 0.05,
+    definitionOfDone: 0.05,
+};

package/dist/specification/index.d.ts

@@ -0,0 +1,3 @@
+export * from './canonical-specification';
+export * from './intake';
+export * from './iteration-contracts';

package/dist/specification/index.js

@@ -0,0 +1,3 @@
+export * from './canonical-specification';
+export * from './intake';
+export * from './iteration-contracts';