@cbnventures/nova 0.13.1 → 0.15.0

package/build/src/cli/utility/initialize.js

@@ -1,40 +1,42 @@
-import { relative, sep } from 'path';
+import { promises as fs } from 'fs';
+import { join, relative, sep } from 'path';
 import chalk from 'chalk';
 import prompts from 'prompts';
-import { itemAllowedPoliciesByRole, itemAllowedSyncProperties } from '../../lib/item.js';
-import { NovaConfig } from '../../lib/nova-config.js';
-import { PATTERN_EMAIL_SIMPLE, PATTERN_SLUG_SCOPED, PATTERN_SLUG_SIMPLE } from '../../lib/regex.js';
-import { discoverPathsWithFile } from '../../lib/utility.js';
+import { libItemAllowedPoliciesByRole, libItemAllowedRecipes, libItemSyncRoles, libItemValidEntityRoles, } from '../../lib/item.js';
+import { LibNovaConfig } from '../../lib/nova-config.js';
+import { LIB_REGEX_PATTERN_EMAIL_SIMPLE, LIB_REGEX_PATTERN_SLUG_SCOPED, LIB_REGEX_PATTERN_SLUG_SIMPLE, LIB_REGEX_PATTERN_YML_EXTENSION, } from '../../lib/regex.js';
+import { discoverPathsWithFile, pathExists, resolveTemplatePath } from '../../lib/utility.js';
+import { libWorkflowTemplatesMetadata } from '../../lib/workflow-templates.js';
 import { Logger } from '../../toolkit/index.js';
-export class CLIUtilityInitialize {
+export class CliUtilityInitialize {
     static async run(options) {
         const currentDirectory = process.cwd();
-        const isProjectRoot = await CLIUtilityInitialize.checkPath(currentDirectory);
+        const isProjectRoot = await CliUtilityInitialize.checkPath(currentDirectory);
         if (isProjectRoot !== true) {
             process.exitCode = 1;
             return;
         }
-        const isDryRun = options.dryRun === true;
-        const isReplaceFile = options.replaceFile === true;
+        const isDryRun = options['dryRun'] === true;
+        const isReplaceFile = options['replaceFile'] === true;
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CLIUtilityInitialize.run',
+                name: 'CliUtilityInitialize.run',
                 purpose: 'options',
             }).warn('Dry run enabled. File changes will not be made in this session.');
         }
         if (isReplaceFile === true) {
-            const replaceFileNotice = (isDryRun) ? 'This option has no effect during a dry run session.' : 'Backup file will not be created.';
+            const replaceFileNotice = (isDryRun === true) ? 'This option has no effect during a dry run session.' : 'Backup file will not be created.';
             Logger.customize({
-                name: 'CLIUtilityInitialize.run',
+                name: 'CliUtilityInitialize.run',
                 purpose: 'options',
             }).warn(`Replace file enabled. ${replaceFileNotice}`);
         }
-        const novaConfig = new NovaConfig();
+        const novaConfig = new LibNovaConfig();
         const workingFile = await novaConfig.load();
-        const promptFlowResult = await CLIUtilityInitialize.promptFlow(workingFile);
+        const promptFlowResult = await CliUtilityInitialize.promptFlow(workingFile);
         if (promptFlowResult === 'cancel') {
             Logger.customize({
-                name: 'CLIUtilityInitialize.run',
+                name: 'CliUtilityInitialize.run',
                 purpose: 'promptFlow',
             }).debug('Prompt flow exited without saving.');
             return;
@@ -42,46 +44,52 @@ export class CLIUtilityInitialize {
         novaConfig.set(workingFile);
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CLIUtilityInitialize.run',
+                name: 'CliUtilityInitialize.run',
                 purpose: 'promptFlow',
             }).debug('Dry run enabled. Skipping save operation.');
             return;
         }
         await novaConfig.save(isReplaceFile);
+        return;
     }
     static async promptFlow(config) {
         const category = {
             project: {
                 label: 'Project',
                 description: 'Configure project metadata (name, description, keywords).',
-                handler: CLIUtilityInitialize.promptProject,
+                handler: CliUtilityInitialize['promptProject'],
             },
             entities: {
                 label: 'Entities',
                 description: 'Manage entities, their roles, and contact information.',
-                handler: CLIUtilityInitialize.promptEntities,
+                handler: CliUtilityInitialize['promptEntities'],
             },
             emails: {
                 label: 'Emails',
                 description: 'Configure project emails (bugs, etc.).',
-                handler: CLIUtilityInitialize.promptEmails,
+                handler: CliUtilityInitialize['promptEmails'],
+            },
+            workflows: {
+                label: 'Workflows',
+                description: 'Configure workflow templates and settings.',
+                handler: CliUtilityInitialize['promptWorkflows'],
             },
             urls: {
                 label: 'URLs',
                 description: 'Configure project URLs (homepage, repository, fund sources, etc.).',
-                handler: CLIUtilityInitialize.promptUrls,
+                handler: CliUtilityInitialize['promptUrls'],
             },
             workspaces: {
                 label: 'Workspaces',
                 description: 'Review workspace packages, assigning roles and policies.',
-                handler: CLIUtilityInitialize.promptWorkspaces,
+                handler: CliUtilityInitialize['promptWorkspaces'],
             },
         };
         while (true) {
             const categoryKeys = Object.keys(category);
             const choices = categoryKeys.map((categoryKey) => ({
-                title: category[categoryKey].label,
-                description: category[categoryKey].description,
+                title: category[categoryKey]['label'],
+                description: category[categoryKey]['description'],
                 value: categoryKey,
             }));
             choices.push({
@@ -94,16 +102,16 @@ export class CLIUtilityInitialize {
                 description: 'Exit without persisting any changes.',
                 value: 'cancel',
             });
-            const menuOutput = await CLIUtilityInitialize.promptWithCancel({
+            const menuOutput = await CliUtilityInitialize.promptWithCancel({
                 type: 'select',
                 name: 'action',
                 message: 'Select a Nova configuration category to edit.',
                 choices,
             });
-            if (menuOutput.cancelled) {
+            if (menuOutput['cancelled'] === true) {
                 return 'cancel';
             }
-            const menuOutputResult = menuOutput.result;
+            const menuOutputResult = menuOutput['result'];
             if (menuOutputResult.action === undefined
                 || menuOutputResult.action === 'cancel') {
                 return 'cancel';
@@ -112,65 +120,70 @@ export class CLIUtilityInitialize {
                 return 'save';
             }
             const categoryKey = menuOutputResult.action;
-            const categoryHandler = category[categoryKey].handler;
+            const categoryHandler = category[categoryKey]['handler'];
             await categoryHandler(config);
         }
     }
     static async promptProject(config) {
-        const existingProject = config.project;
-        const existingProjectName = (existingProject !== undefined) ? existingProject.name : undefined;
-        const existingProjectDescription = (existingProject !== undefined) ? existingProject.description : undefined;
-        const existingProjectKeywords = (existingProject !== undefined) ? existingProject.keywords : undefined;
+        const existingProject = config['project'];
+        const existingProjectName = (existingProject !== undefined) ? existingProject['name'] : undefined;
+        const existingProjectDescription = (existingProject !== undefined) ? existingProject['description'] : undefined;
+        const existingProjectKeywords = (existingProject !== undefined) ? existingProject['keywords'] : undefined;
+        const existingProjectLegalName = (existingProject !== undefined) ? existingProject['legalName'] : undefined;
+        const existingProjectPronouns = (existingProject !== undefined) ? existingProject['pronouns'] : undefined;
+        const existingProjectPlatforms = (existingProject !== undefined) ? existingProject['platforms'] : undefined;
+        const existingProjectStartingYear = (existingProject !== undefined) ? existingProject['startingYear'] : undefined;
+        const existingProjectLicense = (existingProject !== undefined) ? existingProject['license'] : undefined;
         const project = (existingProject !== undefined) ? { ...existingProject } : {};
         const projectName = (existingProjectName !== undefined) ? { ...existingProjectName } : {};
         const projectDescription = (existingProjectDescription !== undefined) ? { ...existingProjectDescription } : {};
         const projectKeywords = (existingProjectKeywords !== undefined) ? [...existingProjectKeywords] : [];
-        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
+        const questionsOutput = await CliUtilityInitialize.promptWithCancel([
             {
                 type: 'text',
                 name: 'projectNameTitle',
                 message: 'Project title (display name)',
-                initial: projectName.title ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
+                initial: projectName['title'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
             },
             {
                 type: 'text',
                 name: 'projectNameSlug',
                 message: 'Project slug (package name)',
-                initial: projectName.slug ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeProjectSlug(value).result,
+                initial: projectName['slug'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeProjectSlug(value)['result'],
             },
             {
                 type: 'text',
                 name: 'projectDescriptionShort',
                 message: 'Short description',
-                initial: projectDescription.short ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
+                initial: projectDescription['short'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
             },
             {
                 type: 'text',
                 name: 'projectDescriptionLong',
                 message: 'Long description',
-                initial: projectDescription.long ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
+                initial: projectDescription['long'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
             },
             {
                 type: 'text',
                 name: 'projectKeywords',
                 message: 'Keywords (comma separated)',
                 initial: (projectKeywords.length > 0) ? projectKeywords.join(', ') : '',
-                validate: (value) => CLIUtilityInitialize.normalizeTextArray(value, 50).result,
+                validate: (value) => CliUtilityInitialize.normalizeTextArray(value, 50)['result'],
             },
         ]);
-        if (questionsOutput.cancelled) {
+        if (questionsOutput['cancelled'] === true) {
             return 'back';
         }
-        const questionsOutputResult = questionsOutput.result;
-        const projectNameTitleInput = CLIUtilityInitialize.normalizeText(questionsOutputResult.projectNameTitle, Infinity).sanitized;
-        const projectNameSlugInput = CLIUtilityInitialize.normalizeProjectSlug(questionsOutputResult.projectNameSlug).sanitized;
-        const projectDescriptionShortInput = CLIUtilityInitialize.normalizeText(questionsOutputResult.projectDescriptionShort, Infinity).sanitized;
-        const projectDescriptionLongInput = CLIUtilityInitialize.normalizeText(questionsOutputResult.projectDescriptionLong, Infinity).sanitized;
-        const projectKeywordsInput = CLIUtilityInitialize.normalizeTextArray(questionsOutputResult.projectKeywords, 50).sanitized;
+        const questionsOutputResult = questionsOutput['result'];
+        const projectNameTitleInput = CliUtilityInitialize.normalizeText(questionsOutputResult.projectNameTitle, Infinity)['sanitized'];
+        const projectNameSlugInput = CliUtilityInitialize.normalizeProjectSlug(questionsOutputResult.projectNameSlug)['sanitized'];
+        const projectDescriptionShortInput = CliUtilityInitialize.normalizeText(questionsOutputResult.projectDescriptionShort, Infinity)['sanitized'];
+        const projectDescriptionLongInput = CliUtilityInitialize.normalizeText(questionsOutputResult.projectDescriptionLong, Infinity)['sanitized'];
+        const projectKeywordsInput = CliUtilityInitialize.normalizeTextArray(questionsOutputResult.projectKeywords, 50)['sanitized'];
         if (projectNameTitleInput !== undefined) {
             projectName.title = projectNameTitleInput;
         }
@@ -213,28 +226,253 @@ export class CLIUtilityInitialize {
         else {
             Reflect.deleteProperty(project, 'keywords');
         }
+        const legalNameOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'text',
+            name: 'projectLegalName',
+            message: 'Legal name (for licenses and copyright notices)',
+            initial: (typeof existingProjectLegalName === 'string') ? existingProjectLegalName : '',
+        });
+        if (legalNameOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const projectLegalNameInput = CliUtilityInitialize.normalizeText(legalNameOutput['result'].projectLegalName, Infinity)['sanitized'];
+        if (projectLegalNameInput !== undefined) {
+            project.legalName = projectLegalNameInput;
+        }
+        else {
+            Reflect.deleteProperty(project, 'legalName');
+        }
+        const pronounsOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'select',
+            name: 'projectPronouns',
+            message: 'Pronouns',
+            choices: [
+                {
+                    title: 'Business (we/us/our)',
+                    value: 'business',
+                },
+                {
+                    title: 'Personal (I/me/my)',
+                    value: 'personal',
+                },
+            ],
+            initial: (existingProjectPronouns === 'personal') ? 1 : 0,
+        });
+        if (pronounsOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const projectPronounsInput = pronounsOutput['result'].projectPronouns;
+        if (projectPronounsInput !== undefined) {
+            project.pronouns = projectPronounsInput;
+        }
+        else {
+            Reflect.deleteProperty(project, 'pronouns');
+        }
+        const platformChoices = [
+            {
+                title: 'Node.js',
+                value: 'nodejs',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('nodejs') === true,
+            },
+            {
+                title: 'Swift',
+                value: 'swift',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('swift') === true,
+            },
+            {
+                title: 'Android',
+                value: 'android',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('android') === true,
+            },
+            {
+                title: 'Java',
+                value: 'java',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('java') === true,
+            },
+            {
+                title: 'Kotlin',
+                value: 'kotlin',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('kotlin') === true,
+            },
+            {
+                title: 'C#',
+                value: 'csharp',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('csharp') === true,
+            },
+            {
+                title: 'PHP',
+                value: 'php',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('php') === true,
+            },
+            {
+                title: 'Python',
+                value: 'python',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('python') === true,
+            },
+            {
+                title: 'macOS',
+                value: 'macos',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('macos') === true,
+            },
+            {
+                title: 'Linux',
+                value: 'linux',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('linux') === true,
+            },
+            {
+                title: 'Windows',
+                value: 'windows',
+                selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('windows') === true,
+            },
+        ];
+        const platformsOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'multiselect',
+            name: 'projectPlatforms',
+            message: 'Supported platforms',
+            choices: platformChoices,
+        });
+        if (platformsOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const projectPlatformsInput = platformsOutput['result'].projectPlatforms;
+        if (Array.isArray(projectPlatformsInput) === true && projectPlatformsInput.length > 0) {
+            project.platforms = projectPlatformsInput;
+        }
+        else {
+            Reflect.deleteProperty(project, 'platforms');
+        }
+        const startingYearOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'text',
+            name: 'projectStartingYear',
+            message: 'Starting year (e.g. 2025)',
+            initial: (existingProjectStartingYear !== undefined) ? String(existingProjectStartingYear) : '',
+            validate: (value) => {
+                const trimmed = String(value ?? '').trim();
+                if (trimmed === '') {
+                    return true;
+                }
+                const parsed = Number(trimmed);
+                if (Number.isNaN(parsed) === true
+                    || Number.isInteger(parsed) === false
+                    || parsed < 1970) {
+                    return 'Must be an integer >= 1970';
+                }
+                return true;
+            },
+        });
+        if (startingYearOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const startingYearRaw = String(startingYearOutput['result'].projectStartingYear ?? '').trim();
+        const startingYearParsed = (startingYearRaw !== '') ? Number(startingYearRaw) : undefined;
+        if (startingYearParsed !== undefined
+            && Number.isInteger(startingYearParsed) === true
+            && startingYearParsed >= 1970) {
+            project.startingYear = startingYearParsed;
+        }
+        else {
+            Reflect.deleteProperty(project, 'startingYear');
+        }
+        const licenseChoices = [
+            {
+                title: 'MIT License',
+                value: 'MIT',
+            },
+            {
+                title: 'Apache License 2.0',
+                value: 'Apache-2.0',
+            },
+            {
+                title: 'GNU General Public License v3.0',
+                value: 'GPL-3.0',
+            },
+            {
+                title: 'GNU General Public License v2.0',
+                value: 'GPL-2.0',
+            },
+            {
+                title: 'GNU Affero General Public License v3.0',
+                value: 'AGPL-3.0',
+            },
+            {
+                title: 'GNU Lesser General Public License v2.1',
+                value: 'LGPL-2.1',
+            },
+            {
+                title: 'BSD 2-Clause "Simplified" License',
+                value: 'BSD-2-Clause',
+            },
+            {
+                title: 'BSD 3-Clause "New" or "Revised" License',
+                value: 'BSD-3-Clause',
+            },
+            {
+                title: 'Boost Software License 1.0',
+                value: 'BSL-1.0',
+            },
+            {
+                title: 'Creative Commons Zero v1.0 Universal',
+                value: 'CC0-1.0',
+            },
+            {
+                title: 'Eclipse Public License 2.0',
+                value: 'EPL-2.0',
+            },
+            {
+                title: 'Mozilla Public License 2.0',
+                value: 'MPL-2.0',
+            },
+            {
+                title: 'Proprietary (All Rights Reserved)',
+                value: 'Proprietary',
+            },
+            {
+                title: 'The Unlicense',
+                value: 'Unlicense',
+            },
+        ];
+        const licenseInitialIndex = licenseChoices.findIndex((choice) => choice['value'] === existingProjectLicense);
+        const licenseOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'select',
+            name: 'projectLicense',
+            message: 'License',
+            choices: licenseChoices,
+            initial: (licenseInitialIndex !== -1) ? licenseInitialIndex : 0,
+        });
+        if (licenseOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const projectLicenseInput = licenseOutput['result'].projectLicense;
+        if (projectLicenseInput !== undefined) {
+            project.license = projectLicenseInput;
+        }
+        else {
+            Reflect.deleteProperty(project, 'license');
+        }
         if (Object.keys(project).length > 0) {
             Object.assign(config, { project });
         }
         else {
             Reflect.deleteProperty(config, 'project');
         }
-        const previousSlug = (existingProjectName !== undefined) ? existingProjectName.slug ?? '' : '';
-        const currentSlug = (config.project !== undefined && config.project.name !== undefined) ? config.project.name.slug ?? '' : '';
+        const previousSlug = (existingProjectName !== undefined) ? existingProjectName['slug'] ?? '' : '';
+        const currentSlug = (config['project'] !== undefined && config['project']['name'] !== undefined) ? config['project']['name']['slug'] ?? '' : '';
         const slugChanged = previousSlug !== currentSlug;
-        if (slugChanged && config.workspaces !== undefined) {
-            const rolesToSync = ['project', 'docs', 'config', 'app', 'tool'];
+        if (slugChanged === true && config['workspaces'] !== undefined) {
+            const rolesToSync = [...libItemSyncRoles];
             const slugPrefix = new RegExp(`^${previousSlug}-`);
+            const previousLabel = (previousSlug !== '') ? previousSlug : '(unset)';
+            const currentLabel = (currentSlug !== '') ? currentSlug : '(unset)';
             Logger.customize({
-                name: 'CLIUtilityInitialize.promptProject',
+                name: 'CliUtilityInitialize.promptProject',
                 purpose: 'updated',
                 padTop: 1,
-            }).info(`Project slug updated from "${previousSlug || '(unset)'}" to "${currentSlug || '(unset)'}".`);
-            for (const workspace of Object.values(config.workspaces)) {
-                if (!rolesToSync.includes(workspace.role)) {
+            }).info(`Project slug updated from "${previousLabel}" to "${currentLabel}".`);
+            for (const workspace of Object.values(config['workspaces'])) {
+                if (rolesToSync.includes(workspace['role']) === false) {
                     continue;
                 }
-                const { name } = workspace;
+                const name = workspace['name'];
                 if (previousSlug === '' && currentSlug !== '') {
                     workspace.name = `${currentSlug}-${name}`;
                 }
@@ -245,26 +483,26 @@ export class CLIUtilityInitialize {
                     workspace.name = name.replace(slugPrefix, `${currentSlug}-`);
                 }
                 Logger.customize({
-                    name: 'CLIUtilityInitialize.promptProject',
+                    name: 'CliUtilityInitialize.promptProject',
                     purpose: 'updated',
-                }).info(`Workspace name updated from "${name}" to "${workspace.name}".`);
+                }).info(`Workspace name updated from "${name}" to "${workspace['name']}".`);
             }
         }
         Logger.customize({
-            name: 'CLIUtilityInitialize.promptProject',
+            name: 'CliUtilityInitialize.promptProject',
             purpose: 'updated',
-            padTop: (slugChanged && config.workspaces !== undefined) ? 0 : 1,
+            padTop: (slugChanged === true && config['workspaces'] !== undefined) ? 0 : 1,
             padBottom: 1,
         }).info('Project details updated.');
         return 'back';
     }
     static async promptEntities(config) {
         const entities = [];
-        if (Array.isArray(config.entities)) {
-            for (const configEntity of config.entities) {
+        if (Array.isArray(config['entities']) === true) {
+            for (const configEntity of config['entities']) {
                 const clonedEntity = { ...configEntity };
-                if (Array.isArray(configEntity.roles)) {
-                    clonedEntity.roles = [...configEntity.roles];
+                if (Array.isArray(configEntity['roles']) === true) {
+                    clonedEntity.roles = [...configEntity['roles']];
                 }
                 else {
                     Reflect.deleteProperty(clonedEntity, 'roles');
@@ -276,8 +514,8 @@ export class CLIUtilityInitialize {
             if (entities.length > 0) {
                 const normalizedEntities = entities.map((entity) => {
                     const normalizedEntity = { ...entity };
-                    if (Array.isArray(entity.roles) && entity.roles.length > 0) {
-                        normalizedEntity.roles = [...entity.roles];
+                    if (Array.isArray(entity['roles']) === true && entity['roles'].length > 0) {
+                        normalizedEntity.roles = [...entity['roles']];
                     }
                     else {
                         Reflect.deleteProperty(normalizedEntity, 'roles');
@@ -289,14 +527,30 @@ export class CLIUtilityInitialize {
             else {
                 Reflect.deleteProperty(config, 'entities');
             }
+            return;
         };
         while (true) {
+            entities.sort((a, b) => {
+                const nameA = (a !== undefined && a['name'] !== undefined) ? a['name'] : '';
+                const nameB = (b !== undefined && b['name'] !== undefined) ? b['name'] : '';
+                return nameA.localeCompare(nameB);
+            });
             const choices = [];
-            entities.forEach((entity, index) => {
-                const entityName = (entity.name !== undefined) ? entity.name.trim() : '';
-                const entityEmail = (entity.email !== undefined) ? entity.email.trim() : '';
-                const entityRoles = (Array.isArray(entity.roles)) ? entity.roles.filter((role) => role.trim() !== '') : [];
-                const label = entityName || entityEmail || `Entity ${index + 1}`;
+            for (let i = 0; i < entities.length; i += 1) {
+                const entity = entities[i];
+                if (entity === undefined) {
+                    continue;
+                }
+                const entityName = (entity['name'] !== undefined) ? entity['name'].trim() : '';
+                const entityEmail = (entity['email'] !== undefined) ? entity['email'].trim() : '';
+                const entityRoles = (Array.isArray(entity['roles']) === true) ? entity['roles'].filter((role) => role.trim() !== '') : [];
+                let label = `Entity ${i + 1}`;
+                if (entityName !== '') {
+                    label = entityName;
+                }
+                else if (entityEmail !== '') {
+                    label = entityEmail;
+                }
                 const descriptionParts = [];
                 if (entityEmail !== '') {
                     descriptionParts.push(entityEmail);
@@ -306,13 +560,14 @@ export class CLIUtilityInitialize {
                         .map((entityRole) => entityRole.trim())
                         .filter((entityRole) => entityRole.length > 0)
                         .reduce((unique, entityRole) => {
-                        if (!unique.includes(entityRole)) {
+                        if (unique.includes(entityRole) === false) {
                             unique.push(entityRole);
                         }
                         return unique;
                     }, []);
                     if (normalizedRoles.length > 0) {
-                        descriptionParts.push(normalizedRoles.join(', '));
+                        const joinedRoles = normalizedRoles.join(', ');
+                        descriptionParts.push(joinedRoles);
                     }
                 }
                 const description = descriptionParts.join(' · ');
@@ -321,7 +576,7 @@ export class CLIUtilityInitialize {
                     description: (description !== '') ? description : 'Update this entity.',
                     value: {
                         kind: 'edit',
-                        index,
+                        index: i,
                     },
                 });
                 choices.push({
@@ -329,10 +584,10 @@ export class CLIUtilityInitialize {
                     description: 'Delete this entity.',
                     value: {
                         kind: 'remove',
-                        index,
+                        index: i,
                     },
                 });
-            });
+            }
             choices.push({
                 title: 'Add new entity',
                 description: 'Create a new entity.',
@@ -347,58 +602,58 @@ export class CLIUtilityInitialize {
                     kind: 'back',
                 },
             });
-            const menuOutput = await CLIUtilityInitialize.promptWithCancel({
+            const menuOutput = await CliUtilityInitialize.promptWithCancel({
                 type: 'select',
                 name: 'action',
                 message: (entities.length > 0) ? 'Select an entity to manage.' : 'No entities found. Choose an option.',
                 choices,
             });
-            if (menuOutput.cancelled) {
+            if (menuOutput['cancelled'] === true) {
                 return 'back';
             }
-            const menuOutputResult = menuOutput.result;
+            const menuOutputResult = menuOutput['result'];
             if (menuOutputResult.action === undefined
-                || menuOutputResult.action.kind === 'back') {
+                || menuOutputResult.action['kind'] === 'back') {
                 sync();
                 return 'back';
             }
-            if (menuOutputResult.action.kind === 'add') {
-                const result = await CLIUtilityInitialize.promptEntitiesForm(undefined, 'create');
-                if (result.action === 'back') {
+            if (menuOutputResult.action['kind'] === 'add') {
+                const result = await CliUtilityInitialize.promptEntitiesForm(undefined, 'create');
+                if (result['action'] === 'back') {
                     continue;
                 }
-                entities.push(result.entity);
+                entities.push(result['entity']);
                 sync();
                 Logger.customize({
-                    name: 'CLIUtilityInitialize.promptEntities',
+                    name: 'CliUtilityInitialize.promptEntities',
                     purpose: 'add',
                     padTop: 1,
                     padBottom: 1,
                 }).info('Added new entity.');
                 continue;
             }
-            if (menuOutputResult.action.kind === 'edit') {
-                const entityIndex = menuOutputResult.action.index;
+            if (menuOutputResult.action['kind'] === 'edit') {
+                const entityIndex = menuOutputResult.action['index'];
                 if (entityIndex < 0 || entityIndex >= entities.length) {
                     continue;
                 }
                 const entityToEdit = entities[entityIndex];
-                const entityResult = await CLIUtilityInitialize.promptEntitiesForm(entityToEdit, 'update');
-                if (entityResult.action === 'back') {
+                const entityResult = await CliUtilityInitialize.promptEntitiesForm(entityToEdit, 'update');
+                if (entityResult['action'] === 'back') {
                     continue;
                 }
-                entities[entityIndex] = entityResult.entity;
+                Reflect.set(entities, entityIndex, entityResult['entity']);
                 sync();
                 Logger.customize({
-                    name: 'CLIUtilityInitialize.promptEntities',
+                    name: 'CliUtilityInitialize.promptEntities',
                     purpose: 'edit',
                     padTop: 1,
                     padBottom: 1,
                 }).info('Updated entity.');
                 continue;
             }
-            if (menuOutputResult.action.kind === 'remove') {
-                const entityIndex = menuOutputResult.action.index;
+            if (menuOutputResult.action['kind'] === 'remove') {
+                const entityIndex = menuOutputResult.action['index'];
                 if (entityIndex < 0 || entityIndex >= entities.length) {
                     continue;
                 }
@@ -406,17 +661,23 @@ export class CLIUtilityInitialize {
                 if (entityToRemove === undefined) {
                     continue;
                 }
-                const entityName = (typeof entityToRemove.name === 'string') ? entityToRemove.name.trim() : '';
-                const entityEmail = (typeof entityToRemove.email === 'string') ? entityToRemove.email.trim() : '';
-                const entityLabel = entityName || entityEmail || `Entity ${entityIndex + 1}`;
-                const shouldRemove = await CLIUtilityInitialize.promptEntitiesDeleteForm(entityLabel);
+                const entityName = (typeof entityToRemove['name'] === 'string') ? entityToRemove['name'].trim() : '';
+                const entityEmail = (typeof entityToRemove['email'] === 'string') ? entityToRemove['email'].trim() : '';
+                let entityLabel = `Entity ${entityIndex + 1}`;
+                if (entityName !== '') {
+                    entityLabel = entityName;
+                }
+                else if (entityEmail !== '') {
+                    entityLabel = entityEmail;
+                }
+                const shouldRemove = await CliUtilityInitialize.promptEntitiesDeleteForm(entityLabel);
                 if (shouldRemove !== true) {
                     continue;
                 }
                 entities.splice(entityIndex, 1);
                 sync();
                 Logger.customize({
-                    name: 'CLIUtilityInitialize.promptEntities',
+                    name: 'CliUtilityInitialize.promptEntities',
                     purpose: 'remove',
                     padTop: 1,
                     padBottom: 1,
@@ -425,35 +686,35 @@ export class CLIUtilityInitialize {
         }
     }
     static async promptEntitiesForm(entity, mode) {
-        const validRoles = ['author', 'contributor', 'supporter'];
-        const existingName = (entity !== undefined && typeof entity.name === 'string') ? entity.name : '';
-        const existingEmail = (entity !== undefined && typeof entity.email === 'string') ? entity.email : '';
-        const existingUrl = (entity !== undefined && typeof entity.url === 'string') ? entity.url : '';
+        const validRoles = [...libItemValidEntityRoles];
+        const existingName = (entity !== undefined && typeof entity['name'] === 'string') ? entity['name'] : '';
+        const existingEmail = (entity !== undefined && typeof entity['email'] === 'string') ? entity['email'] : '';
+        const existingUrl = (entity !== undefined && typeof entity['url'] === 'string') ? entity['url'] : '';
         let existingRoles = [];
-        if (entity !== undefined && Array.isArray(entity.roles)) {
-            existingRoles = entity.roles.filter((role) => validRoles.includes(role));
+        if (entity !== undefined && Array.isArray(entity['roles']) === true) {
+            existingRoles = entity['roles'].filter((role) => validRoles.includes(role));
         }
-        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
+        const questionsOutput = await CliUtilityInitialize.promptWithCancel([
             {
                 type: 'text',
                 name: 'entityName',
                 message: 'Entity name',
                 initial: existingName,
-                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
+                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
             },
             {
                 type: 'text',
                 name: 'entityEmail',
                 message: 'Entity email address',
                 initial: existingEmail,
-                validate: (value) => CLIUtilityInitialize.normalizeEmail(value).result,
+                validate: (value) => CliUtilityInitialize.normalizeEmail(value)['result'],
             },
             {
                 type: 'text',
                 name: 'entityUrl',
                 message: 'Entity website',
                 initial: existingUrl,
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'multiselect',
@@ -466,16 +727,16 @@ export class CLIUtilityInitialize {
                 })),
             },
         ]);
-        if (questionsOutput.cancelled) {
+        if (questionsOutput['cancelled'] === true) {
             return {
                 action: 'back',
             };
         }
-        const questionsOutputResult = questionsOutput.result;
-        const entityNameInput = CLIUtilityInitialize.normalizeText(questionsOutputResult.entityName, Infinity).sanitized;
-        const entityEmailInput = CLIUtilityInitialize.normalizeEmail(questionsOutputResult.entityEmail).sanitized;
-        const entityUrlInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.entityUrl, 'generic').sanitized;
-        const entityRolesInput = Array.isArray(questionsOutputResult.entityRoles) ? [...questionsOutputResult.entityRoles] : [];
+        const questionsOutputResult = questionsOutput['result'];
+        const entityNameInput = CliUtilityInitialize.normalizeText(questionsOutputResult.entityName, Infinity)['sanitized'];
+        const entityEmailInput = CliUtilityInitialize.normalizeEmail(questionsOutputResult.entityEmail)['sanitized'];
+        const entityUrlInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.entityUrl, 'generic')['sanitized'];
+        const entityRolesInput = (Array.isArray(questionsOutputResult.entityRoles) === true) ? [...questionsOutputResult.entityRoles] : [];
         const resolvedEntity = {};
         if (entityNameInput !== undefined) {
             resolvedEntity.name = entityNameInput;
@@ -500,35 +761,33 @@ export class CLIUtilityInitialize {
         };
     }
     static async promptEntitiesDeleteForm(label) {
-        const confirmOutput = await CLIUtilityInitialize.promptWithCancel({
+        const confirmOutput = await CliUtilityInitialize.promptWithCancel({
             type: 'confirm',
             name: 'confirm',
             message: `Remove entity "${label}"?`,
             initial: false,
         });
-        if (confirmOutput.cancelled) {
+        if (confirmOutput['cancelled'] === true) {
             return false;
         }
-        const confirmOutputResult = confirmOutput.result;
+        const confirmOutputResult = confirmOutput['result'];
         return confirmOutputResult.confirm;
     }
     static async promptEmails(config) {
-        const existingEmails = config.emails;
+        const existingEmails = config['emails'];
         const emails = (existingEmails !== undefined) ? { ...existingEmails } : {};
-        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
-            {
+        const questionsOutput = await CliUtilityInitialize.promptWithCancel([{
                 type: 'text',
                 name: 'emailsBugs',
                 message: 'Issue tracker email',
-                initial: emails.bugs ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeEmail(value).result,
-            },
-        ]);
-        if (questionsOutput.cancelled) {
+                initial: emails['bugs'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeEmail(value)['result'],
+            }]);
+        if (questionsOutput['cancelled'] === true) {
             return 'back';
         }
-        const questionsOutputResult = questionsOutput.result;
-        const emailsBugsInput = CLIUtilityInitialize.normalizeEmail(questionsOutputResult.emailsBugs).sanitized;
+        const questionsOutputResult = questionsOutput['result'];
+        const emailsBugsInput = CliUtilityInitialize.normalizeEmail(questionsOutputResult.emailsBugs)['sanitized'];
         if (emailsBugsInput !== undefined) {
             emails.bugs = emailsBugsInput;
         }
@@ -542,7 +801,7 @@ export class CLIUtilityInitialize {
             Reflect.deleteProperty(config, 'emails');
         }
         Logger.customize({
-            name: 'CLIUtilityInitialize.promptEmails',
+            name: 'CliUtilityInitialize.promptEmails',
             purpose: 'updated',
             padTop: 1,
             padBottom: 1,
@@ -550,86 +809,110 @@ export class CLIUtilityInitialize {
         return 'back';
     }
     static async promptUrls(config) {
-        const existingUrls = config.urls;
+        const existingUrls = config['urls'];
         const urls = (existingUrls !== undefined) ? { ...existingUrls } : {};
-        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
+        const questionsOutput = await CliUtilityInitialize.promptWithCancel([
             {
                 type: 'text',
                 name: 'urlsHomepage',
                 message: 'Homepage URL',
-                initial: urls.homepage ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['homepage'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsRepository',
                 message: 'Repository URL',
-                initial: urls.repository ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'repository').result,
+                initial: urls['repository'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'repository')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsBugs',
                 message: 'Issue tracker URL',
-                initial: urls.bugs ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['bugs'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsLicense',
                 message: 'License URL',
-                initial: urls.license ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['license'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsLogo',
                 message: 'Logo URL',
-                initial: urls.logo ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['logo'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsDocumentation',
                 message: 'Documentation URL',
-                initial: urls.documentation ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['documentation'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsGithub',
                 message: 'GitHub URL',
-                initial: urls.github ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['github'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsNpm',
                 message: 'npm package URL',
-                initial: urls.npm ?? '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
+                initial: urls['npm'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+            },
+            {
+                type: 'text',
+                name: 'urlsDocker',
+                message: 'Docker Hub URL',
+                initial: urls['docker'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
             {
                 type: 'text',
                 name: 'urlsFundSources',
                 message: 'Funding URLs (comma separated)',
-                initial: (Array.isArray(urls.fundSources)) ? urls.fundSources.join(', ') : '',
-                validate: (value) => CLIUtilityInitialize.normalizeUrlArray(value, 'generic').result,
+                initial: (Array.isArray(urls['fundSources']) === true) ? urls['fundSources'].join(', ') : '',
+                validate: (value) => CliUtilityInitialize.normalizeUrlArray(value, 'generic')['result'],
+            },
+            {
+                type: 'text',
+                name: 'urlsPrivacyPolicy',
+                message: 'Privacy policy URL',
+                initial: urls['privacyPolicy'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+            },
+            {
+                type: 'text',
+                name: 'urlsTermsOfUse',
+                message: 'Terms of use URL',
+                initial: urls['termsOfUse'] ?? '',
+                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
             },
         ]);
-        if (questionsOutput.cancelled) {
+        if (questionsOutput['cancelled'] === true) {
             return 'back';
         }
-        const questionsOutputResult = questionsOutput.result;
-        const urlsHomepageInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsHomepage, 'generic').sanitized;
-        const urlsRepositoryInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsRepository, 'repository').sanitized;
-        const urlsBugsInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsBugs, 'generic').sanitized;
-        const urlsLicenseInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsLicense, 'generic').sanitized;
-        const urlsLogoInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsLogo, 'generic').sanitized;
-        const urlsDocumentationInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsDocumentation, 'generic').sanitized;
-        const urlsGithubInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsGithub, 'generic').sanitized;
-        const urlsNpmInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.urlsNpm, 'generic').sanitized;
-        const urlsFundSourcesInput = CLIUtilityInitialize.normalizeUrlArray(questionsOutputResult.urlsFundSources, 'generic').sanitized;
+        const questionsOutputResult = questionsOutput['result'];
+        const urlsHomepageInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsHomepage, 'generic')['sanitized'];
+        const urlsRepositoryInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsRepository, 'repository')['sanitized'];
+        const urlsBugsInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsBugs, 'generic')['sanitized'];
+        const urlsLicenseInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsLicense, 'generic')['sanitized'];
+        const urlsLogoInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsLogo, 'generic')['sanitized'];
+        const urlsDocumentationInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsDocumentation, 'generic')['sanitized'];
+        const urlsGithubInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsGithub, 'generic')['sanitized'];
+        const urlsNpmInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsNpm, 'generic')['sanitized'];
+        const urlsDockerInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsDocker, 'generic')['sanitized'];
+        const urlsFundSourcesInput = CliUtilityInitialize.normalizeUrlArray(questionsOutputResult.urlsFundSources, 'generic')['sanitized'];
+        const urlsPrivacyPolicyInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsPrivacyPolicy, 'generic')['sanitized'];
+        const urlsTermsOfUseInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsTermsOfUse, 'generic')['sanitized'];
         if (urlsHomepageInput !== undefined) {
             urls.homepage = urlsHomepageInput;
         }
@@ -678,12 +961,30 @@ export class CLIUtilityInitialize {
         else {
             Reflect.deleteProperty(urls, 'npm');
         }
+        if (urlsDockerInput !== undefined) {
+            urls.docker = urlsDockerInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'docker');
+        }
         if (urlsFundSourcesInput !== undefined) {
             urls.fundSources = urlsFundSourcesInput;
         }
         else {
             Reflect.deleteProperty(urls, 'fundSources');
         }
+        if (urlsPrivacyPolicyInput !== undefined) {
+            urls.privacyPolicy = urlsPrivacyPolicyInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'privacyPolicy');
+        }
+        if (urlsTermsOfUseInput !== undefined) {
+            urls.termsOfUse = urlsTermsOfUseInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'termsOfUse');
+        }
         if (Object.keys(urls).length > 0) {
             Object.assign(config, { urls });
         }
@@ -691,39 +992,437 @@ export class CLIUtilityInitialize {
             Reflect.deleteProperty(config, 'urls');
         }
         Logger.customize({
-            name: 'CLIUtilityInitialize.promptUrls',
+            name: 'CliUtilityInitialize.promptUrls',
             purpose: 'updated',
             padTop: 1,
             padBottom: 1,
         }).info('URL references updated.');
         return 'back';
     }
+    static async promptWorkflows(config) {
+        const workflows = [];
+        if (Array.isArray(config['workflows']) === true) {
+            for (const configWorkflow of config['workflows']) {
+                const clonedWorkflow = { ...configWorkflow };
+                if (Array.isArray(configWorkflow['triggers']) === true) {
+                    clonedWorkflow.triggers = [...configWorkflow['triggers']];
+                }
+                if (configWorkflow['settings'] !== undefined) {
+                    clonedWorkflow.settings = { ...configWorkflow['settings'] };
+                }
+                else {
+                    Reflect.deleteProperty(clonedWorkflow, 'settings');
+                }
+                workflows.push(clonedWorkflow);
+            }
+        }
+        const sync = () => {
+            if (workflows.length > 0) {
+                const normalizedWorkflows = workflows.map((workflow) => {
+                    const normalizedWorkflow = { ...workflow };
+                    if (Array.isArray(workflow['triggers']) === true && workflow['triggers'].length > 0) {
+                        normalizedWorkflow.triggers = [...workflow['triggers']];
+                    }
+                    if (Array.isArray(workflow['depends-on']) === true && workflow['depends-on'].length > 0) {
+                        Reflect.set(normalizedWorkflow, 'depends-on', [...workflow['depends-on']]);
+                    }
+                    else {
+                        Reflect.deleteProperty(normalizedWorkflow, 'depends-on');
+                    }
+                    if (workflow['settings'] !== undefined && Object.keys(workflow['settings']).length > 0) {
+                        normalizedWorkflow.settings = { ...workflow['settings'] };
+                    }
+                    else {
+                        Reflect.deleteProperty(normalizedWorkflow, 'settings');
+                    }
+                    return normalizedWorkflow;
+                });
+                Object.assign(config, { workflows: normalizedWorkflows });
+            }
+            else {
+                Reflect.deleteProperty(config, 'workflows');
+            }
+            return;
+        };
+        while (true) {
+            workflows.sort((a, b) => {
+                const templateA = (a !== undefined && typeof a['template'] === 'string') ? a['template'] : '';
+                const templateB = (b !== undefined && typeof b['template'] === 'string') ? b['template'] : '';
+                const templateCompare = templateA.localeCompare(templateB);
+                if (templateCompare !== 0) {
+                    return templateCompare;
+                }
+                const suffixA = (a !== undefined && typeof a['suffix'] === 'string') ? a['suffix'] : '';
+                const suffixB = (b !== undefined && typeof b['suffix'] === 'string') ? b['suffix'] : '';
+                return suffixA.localeCompare(suffixB);
+            });
+            const choices = [];
+            for (let i = 0; i < workflows.length; i += 1) {
+                const workflow = workflows[i];
+                if (workflow === undefined) {
+                    continue;
+                }
+                const template = (typeof workflow['template'] === 'string') ? workflow['template'].trim() : '';
+                const suffix = (typeof workflow['suffix'] === 'string') ? workflow['suffix'].trim() : '';
+                const triggers = (Array.isArray(workflow['triggers']) === true) ? workflow['triggers'] : [];
+                let label = `Workflow ${i + 1}`;
+                if (template !== '' && suffix !== '') {
+                    label = `${template}-${suffix}`;
+                }
+                else if (template !== '') {
+                    label = template;
+                }
+                const triggersLabel = (triggers.length > 0) ? ` [${triggers.join(', ')}]` : '';
+                const outputFileName = (suffix !== '') ? `nova-${template}-${suffix}.yml` : `nova-${template}.yml`;
+                const description = (template !== '') ? `${outputFileName}${triggersLabel}` : 'Update this workflow.';
+                choices.push({
+                    title: `${chalk.yellow.bold('[EDIT]')} ${label}`,
+                    description,
+                    value: {
+                        kind: 'edit',
+                        index: i,
+                    },
+                });
+                choices.push({
+                    title: `${chalk.red.bold('[REMOVE]')} ${label}`,
+                    description: 'Delete this workflow.',
+                    value: {
+                        kind: 'remove',
+                        index: i,
+                    },
+                });
+            }
+            choices.push({
+                title: 'Add new workflow',
+                description: 'Create a new workflow.',
+                value: {
+                    kind: 'add',
+                },
+            });
+            choices.push({
+                title: 'Back',
+                description: 'Return to the category selection.',
+                value: {
+                    kind: 'back',
+                },
+            });
+            const menuOutput = await CliUtilityInitialize.promptWithCancel({
+                type: 'select',
+                name: 'action',
+                message: (workflows.length > 0) ? 'Select a workflow to manage.' : 'No workflows found. Choose an option.',
+                choices,
+            });
+            if (menuOutput['cancelled'] === true) {
+                return 'back';
+            }
+            const menuOutputResult = menuOutput['result'];
+            if (menuOutputResult.action === undefined
+                || menuOutputResult.action['kind'] === 'back') {
+                sync();
+                return 'back';
+            }
+            if (menuOutputResult.action['kind'] === 'add') {
+                const result = await CliUtilityInitialize.promptWorkflowsForm(undefined, 'create', workflows);
+                if (result['action'] === 'back') {
+                    continue;
+                }
+                workflows.push(result['workflow']);
+                sync();
+                Logger.customize({
+                    name: 'CliUtilityInitialize.promptWorkflows',
+                    purpose: 'add',
+                    padTop: 1,
+                    padBottom: 1,
+                }).info('Added new workflow.');
+                continue;
+            }
+            if (menuOutputResult.action['kind'] === 'edit') {
+                const workflowIndex = menuOutputResult.action['index'];
+                if (workflowIndex < 0 || workflowIndex >= workflows.length) {
+                    continue;
+                }
+                const workflowToEdit = workflows[workflowIndex];
+                const workflowResult = await CliUtilityInitialize.promptWorkflowsForm(workflowToEdit, 'update', workflows);
+                if (workflowResult['action'] === 'back') {
+                    continue;
+                }
+                Reflect.set(workflows, workflowIndex, workflowResult['workflow']);
+                sync();
+                Logger.customize({
+                    name: 'CliUtilityInitialize.promptWorkflows',
+                    purpose: 'edit',
+                    padTop: 1,
+                    padBottom: 1,
+                }).info('Updated workflow.');
+                continue;
+            }
+            if (menuOutputResult.action['kind'] === 'remove') {
+                const workflowIndex = menuOutputResult.action['index'];
+                if (workflowIndex < 0 || workflowIndex >= workflows.length) {
+                    continue;
+                }
+                const workflowToRemove = workflows[workflowIndex];
+                if (workflowToRemove === undefined) {
+                    continue;
+                }
+                const template = (typeof workflowToRemove['template'] === 'string') ? workflowToRemove['template'].trim() : '';
+                const suffix = (typeof workflowToRemove['suffix'] === 'string') ? workflowToRemove['suffix'].trim() : '';
+                let workflowLabel = `Workflow ${workflowIndex + 1}`;
+                if (template !== '' && suffix !== '') {
+                    workflowLabel = `${template}-${suffix}`;
+                }
+                else if (template !== '') {
+                    workflowLabel = template;
+                }
+                const shouldRemove = await CliUtilityInitialize.promptWorkflowsDeleteForm(workflowLabel);
+                if (shouldRemove !== true) {
+                    continue;
+                }
+                workflows.splice(workflowIndex, 1);
+                sync();
+                Logger.customize({
+                    name: 'CliUtilityInitialize.promptWorkflows',
+                    purpose: 'remove',
+                    padTop: 1,
+                    padBottom: 1,
+                }).info('Removed workflow.');
+            }
+        }
+    }
+    static async promptWorkflowsForm(workflow, mode, workflows) {
+        const existingTemplate = (workflow !== undefined && typeof workflow['template'] === 'string') ? workflow['template'] : '';
+        const existingSuffix = (workflow !== undefined && typeof workflow['suffix'] === 'string') ? workflow['suffix'] : '';
+        const existingTriggers = (workflow !== undefined && Array.isArray(workflow['triggers']) === true) ? workflow['triggers'] : [];
+        const existingDependsOn = (workflow !== undefined && Array.isArray(workflow['depends-on']) === true) ? workflow['depends-on'] : [];
+        const templateChoices = libWorkflowTemplatesMetadata.map((entry) => ({
+            title: entry['name'],
+            description: entry['description'],
+            value: entry['name'],
+        }));
+        let templateInitialIndex = 0;
+        if (existingTemplate !== '') {
+            const foundIndex = templateChoices.findIndex((choice) => choice['value'] === existingTemplate);
+            if (foundIndex >= 0) {
+                templateInitialIndex = foundIndex;
+            }
+        }
+        const templateOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'select',
+            name: 'template',
+            message: 'Select a workflow template.',
+            choices: templateChoices,
+            initial: templateInitialIndex,
+        });
+        if (templateOutput['cancelled'] === true) {
+            return {
+                action: 'back',
+            };
+        }
+        const templateOutputResult = templateOutput['result'];
+        const selectedTemplate = templateOutputResult.template;
+        const suffixOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'text',
+            name: 'suffix',
+            message: 'Workflow suffix (used in filename and workflow name)',
+            initial: existingSuffix,
+            validate: (value) => {
+                const trimmed = (typeof value === 'string') ? value.trim() : '';
+                if (trimmed === '') {
+                    return 'Suffix is required.';
+                }
+                const compositeKey = `${selectedTemplate}-${trimmed}`;
+                const editIndex = (workflow !== undefined) ? workflows.indexOf(workflow) : -1;
+                const isDuplicate = workflows.some((w, i) => {
+                    if (i === editIndex) {
+                        return false;
+                    }
+                    const existingKey = `${w['template']}-${w['suffix'] ?? ''}`;
+                    return existingKey === compositeKey;
+                });
+                if (isDuplicate === true) {
+                    return 'A workflow with this template and suffix already exists.';
+                }
+                return true;
+            },
+        });
+        if (suffixOutput['cancelled'] === true) {
+            return {
+                action: 'back',
+            };
+        }
+        const suffixOutputResult = suffixOutput['result'];
+        const selectedSuffix = (typeof suffixOutputResult.suffix === 'string') ? suffixOutputResult.suffix.trim() : '';
+        const triggersDir = join(resolveTemplatePath(import.meta.url, 'generators/github/workflows'), selectedTemplate, 'triggers');
+        const triggersDirExists = await pathExists(triggersDir);
+        let selectedTriggers = [];
+        if (triggersDirExists === true) {
+            const triggersFiles = (await fs.readdir(triggersDir)).filter((file) => file.endsWith('.yml'));
+            const triggerChoices = triggersFiles.map((file) => {
+                const triggerName = file.replace(LIB_REGEX_PATTERN_YML_EXTENSION, '');
+                return {
+                    title: triggerName,
+                    value: triggerName,
+                    selected: existingTriggers.includes(triggerName),
+                };
+            });
+            const triggersOutput = await CliUtilityInitialize.promptWithCancel({
+                type: 'multiselect',
+                name: 'triggers',
+                message: 'Select triggers for this workflow.',
+                choices: triggerChoices,
+            });
+            if (triggersOutput['cancelled'] === true) {
+                return {
+                    action: 'back',
+                };
+            }
+            const triggersOutputResult = triggersOutput['result'];
+            selectedTriggers = (Array.isArray(triggersOutputResult.triggers) === true) ? triggersOutputResult.triggers : [];
+        }
+        let selectedDependsOn = undefined;
+        if (selectedTriggers.some((trigger) => trigger.startsWith('workflow-run')) === true) {
+            const dependsOnChoices = workflows
+                .filter((w) => w !== workflow
+                && typeof w['template'] === 'string'
+                && w['template'].trim() !== '')
+                .map((w) => {
+                const compositeKey = (typeof w['suffix'] === 'string' && w['suffix'].trim() !== '') ? `${w['template']}-${w['suffix']}` : w['template'];
+                return {
+                    title: compositeKey,
+                    value: compositeKey,
+                    selected: existingDependsOn.includes(compositeKey),
+                };
+            });
+            if (dependsOnChoices.length > 0) {
+                const dependsOnOutput = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'dependsOn',
+                    message: 'Select the workflows this depends on.',
+                    choices: dependsOnChoices,
+                });
+                if (dependsOnOutput['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const dependsOnOutputResult = dependsOnOutput['result'];
+                selectedDependsOn = (Array.isArray(dependsOnOutputResult.dependsOn) === true && dependsOnOutputResult.dependsOn.length > 0) ? dependsOnOutputResult.dependsOn : undefined;
+            }
+        }
+        const matchedMetadata = libWorkflowTemplatesMetadata.find((entry) => entry['name'] === selectedTemplate);
+        const settings = {};
+        if (matchedMetadata !== undefined) {
+            const variableEntries = Object.entries(matchedMetadata['variables']);
+            for (const variableEntry of variableEntries) {
+                const variableName = variableEntry[0];
+                const variableConfig = variableEntry[1];
+                if (variableConfig['auto'] === true) {
+                    continue;
+                }
+                let promptMessage = `Literal: ${variableName}`;
+                let initialValue = '';
+                if (variableConfig['format'] === 'secret') {
+                    promptMessage = `Secret: ${variableName}`;
+                    initialValue = (typeof variableConfig['default'] === 'string') ? variableConfig['default'] : '';
+                }
+                else if (variableConfig['format'] === 'var') {
+                    promptMessage = `Variable: ${variableName}`;
+                    initialValue = (typeof variableConfig['default'] === 'string') ? variableConfig['default'] : '';
+                }
+                const parts = [];
+                if (typeof variableConfig['description'] === 'string') {
+                    parts.push(variableConfig['description']);
+                }
+                if (typeof variableConfig['example'] === 'string') {
+                    parts.push(`e.g. ${variableConfig['example']}`);
+                }
+                if (parts.length > 0) {
+                    promptMessage = `${promptMessage} (${parts.join(', ')})`;
+                }
+                if (workflow !== undefined
+                    && workflow['settings'] !== undefined
+                    && typeof workflow['settings'][variableName] === 'string') {
+                    initialValue = workflow['settings'][variableName];
+                }
+                const settingsOutput = await CliUtilityInitialize.promptWithCancel({
+                    type: 'text',
+                    name: 'settingValue',
+                    message: promptMessage,
+                    initial: initialValue,
+                });
+                if (settingsOutput['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const settingsOutputResult = settingsOutput['result'];
+                const settingValue = (typeof settingsOutputResult.settingValue === 'string') ? settingsOutputResult.settingValue.trim().replaceAll('\\n', '\n') : '';
+                if (settingValue !== '') {
+                    Reflect.set(settings, variableName, settingValue);
+                }
+            }
+        }
+        const resolvedWorkflow = {
+            template: selectedTemplate,
+            suffix: selectedSuffix,
+            triggers: selectedTriggers,
+        };
+        if (selectedDependsOn !== undefined) {
+            Reflect.set(resolvedWorkflow, 'depends-on', selectedDependsOn);
+        }
+        if (Object.keys(settings).length > 0) {
+            resolvedWorkflow.settings = settings;
+        }
+        if (mode === 'create' && selectedTemplate.trim() === '') {
+            return {
+                action: 'back',
+            };
+        }
+        return {
+            action: 'apply',
+            workflow: resolvedWorkflow,
+        };
+    }
+    static async promptWorkflowsDeleteForm(label) {
+        const confirmOutput = await CliUtilityInitialize.promptWithCancel({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove workflow "${label}"?`,
+            initial: false,
+        });
+        if (confirmOutput['cancelled'] === true) {
+            return false;
+        }
+        const confirmOutputResult = confirmOutput['result'];
+        return confirmOutputResult.confirm;
+    }
     static async promptWorkspaces(config) {
-        const workspaces = (config.workspaces) ? { ...(config.workspaces) } : {};
+        const workspaces = (config['workspaces'] !== undefined) ? { ...(config['workspaces']) } : {};
         const rawWorkspacePaths = await discoverPathsWithFile('package.json', 'forward');
         const workspacePaths = rawWorkspacePaths.map((rawWorkspacePath) => {
-            const relativePath = relative(process.cwd(), rawWorkspacePath);
+            const currentWorkingDirectory = process.cwd();
+            const relativePath = relative(currentWorkingDirectory, rawWorkspacePath);
             if (relativePath === '') {
                 return './';
             }
             return `./${relativePath.split(sep).join('/')}`;
         });
         Logger.customize({
-            name: 'CLIUtilityInitialize.promptWorkspaces',
+            name: 'CliUtilityInitialize.promptWorkspaces',
             purpose: 'paths',
         }).debug(workspacePaths);
         while (true) {
             const choices = workspacePaths.map((workspacePath) => {
                 const workspace = workspaces[workspacePath];
                 const summaryParts = [];
-                if (workspace !== undefined && workspace.name !== undefined) {
-                    summaryParts.push(workspace.name);
+                if (workspace !== undefined && workspace['name'] !== undefined) {
+                    summaryParts.push(workspace['name']);
                 }
-                if (workspace !== undefined && workspace.role !== undefined) {
-                    summaryParts.push(workspace.role);
+                if (workspace !== undefined && workspace['role'] !== undefined) {
+                    summaryParts.push(workspace['role']);
                 }
-                if (workspace !== undefined && workspace.policy !== undefined) {
-                    summaryParts.push(workspace.policy);
+                if (workspace !== undefined && workspace['policy'] !== undefined) {
+                    summaryParts.push(workspace['policy']);
                 }
                 return {
                     title: workspacePath,
@@ -736,37 +1435,37 @@ export class CLIUtilityInitialize {
                 description: 'Return to the category selection.',
                 value: 'back',
             });
-            const menuOutput = await CLIUtilityInitialize.promptWithCancel({
+            const menuOutput = await CliUtilityInitialize.promptWithCancel({
                 type: 'select',
                 name: 'workspacePath',
                 message: 'Select a workspace to configure.',
                 choices,
             });
-            if (menuOutput.cancelled) {
+            if (menuOutput['cancelled'] === true) {
                 return 'back';
             }
-            const menuOutputResult = menuOutput.result;
+            const menuOutputResult = menuOutput['result'];
             if (menuOutputResult.workspacePath === undefined
                 || menuOutputResult.workspacePath === 'back') {
                 return 'back';
             }
             const workspacePath = menuOutputResult.workspacePath;
-            const formResult = await CLIUtilityInitialize.promptWorkspacesForm({
+            const formResult = await CliUtilityInitialize.promptWorkspacesForm({
                 workspacePath,
                 existingWorkspace: workspaces[workspacePath],
-                projectSlug: (config.project !== undefined && config.project.name !== undefined) ? config.project.name.slug : undefined,
+                projectSlug: (config['project'] !== undefined && config['project']['name'] !== undefined) ? config['project']['name']['slug'] : undefined,
             });
-            if (formResult.action === 'back') {
+            if (formResult['action'] === 'back') {
                 continue;
             }
-            Reflect.set(workspaces, workspacePath, formResult.workspace);
+            Reflect.set(workspaces, workspacePath, formResult['workspace']);
             Object.assign(config, { workspaces });
             Logger.customize({
-                name: 'CLIUtilityInitialize.promptWorkspaces',
+                name: 'CliUtilityInitialize.promptWorkspaces',
                 purpose: 'updated',
                 padTop: 1,
                 padBottom: 1,
-            }).info(`Updated workspace "${workspacePath}" → ${formResult.workspace.name} · ${formResult.workspace.role} · ${formResult.workspace.policy}`);
+            }).info(`Updated workspace "${workspacePath}" → ${formResult['workspace']['name']} · ${formResult['workspace']['role']} · ${formResult['workspace']['policy']}`);
         }
     }
     static async promptWorkspacesForm(options) {
@@ -823,132 +1522,326 @@ export class CLIUtilityInitialize {
         };
         const resolveName = async (role) => {
             if (role === 'project' || role === 'docs') {
-                if (options.projectSlug === undefined) {
+                if (options['projectSlug'] === undefined) {
                     return (role === 'project') ? 'project' : 'docs';
                 }
-                return `${options.projectSlug}-${role}`;
+                return `${options['projectSlug']}-${role}`;
             }
-            const base = (options.projectSlug !== undefined) ? `${options.projectSlug}-${role}` : role;
-            const namePrompt = await CLIUtilityInitialize.promptWithCancel({
+            const base = (options['projectSlug'] !== undefined) ? `${options['projectSlug']}-${role}` : role;
+            const namePrompt = await CliUtilityInitialize.promptWithCancel({
                 type: 'text',
                 name: 'workspaceName',
                 message: 'Workspace package name',
-                initial: (options.existingWorkspace !== undefined) ? options.existingWorkspace.name ?? '' : '',
-                validate: (value) => CLIUtilityInitialize.normalizeWorkspaceName(value, role, base).result,
+                initial: (options['existingWorkspace'] !== undefined) ? options['existingWorkspace']['name'] ?? '' : '',
+                validate: (value) => CliUtilityInitialize.normalizeWorkspaceName(value, role, base)['result'],
             });
-            if (namePrompt.cancelled) {
+            if (namePrompt['cancelled'] === true) {
                 return undefined;
             }
-            return CLIUtilityInitialize.normalizeWorkspaceName(namePrompt.result.workspaceName, role, base).sanitized;
+            return CliUtilityInitialize.normalizeWorkspaceName(namePrompt['result'].workspaceName, role, base)['sanitized'];
         };
-        const rolePrompt = await CLIUtilityInitialize.promptWithCancel({
+        const existingRoleIndex = allowedRoles.findIndex((allowedRole) => options['existingWorkspace'] !== undefined && allowedRole['value'] === options['existingWorkspace']['role']);
+        const rolePrompt = await CliUtilityInitialize.promptWithCancel({
             type: 'select',
             name: 'workspaceRole',
-            message: `Select a role for "${options.workspacePath}"`,
-            choices: allowedRoles.map((role) => ({
-                title: role.title,
-                description: role.description,
-                value: role.value,
-            })),
-            initial: Math.max(0, allowedRoles.findIndex((role) => options.existingWorkspace !== undefined && role.value === options.existingWorkspace.role)),
+            message: `Select a role for "${options['workspacePath']}"`,
+            choices: allowedRoles.map((allowedRole) => {
+                return {
+                    title: allowedRole['title'],
+                    description: allowedRole['description'],
+                    value: allowedRole['value'],
+                };
+            }),
+            initial: Math.max(0, existingRoleIndex),
         });
-        if (rolePrompt.cancelled) {
+        if (rolePrompt['cancelled'] === true) {
             return {
                 action: 'back',
             };
         }
-        const selectedRole = rolePrompt.result.workspaceRole;
-        const allowedPolicies = itemAllowedPoliciesByRole[selectedRole];
-        const policyPrompt = await CLIUtilityInitialize.promptWithCancel({
+        const selectedRole = rolePrompt['result'].workspaceRole;
+        const allowedPolicies = libItemAllowedPoliciesByRole[selectedRole];
+        const existingPolicyIndex = allowedPolicies.findIndex((allowedPolicy) => options['existingWorkspace'] !== undefined && allowedPolicy === options['existingWorkspace']['policy']);
+        const policyPrompt = await CliUtilityInitialize.promptWithCancel({
             type: 'select',
             name: 'workspacePolicy',
             message: 'Select a policy',
-            choices: allowedPolicies.map((allowedPolicy) => ({
-                title: policy[allowedPolicy].label,
-                description: policy[allowedPolicy].description,
-                value: allowedPolicy,
-            })),
-            initial: Math.max(0, allowedPolicies.findIndex((policy) => options.existingWorkspace !== undefined && policy === options.existingWorkspace.policy)),
+            choices: allowedPolicies.map((allowedPolicy) => {
+                const policyEntry = Reflect.get(policy, allowedPolicy);
+                return {
+                    title: policyEntry['label'],
+                    description: policyEntry['description'],
+                    value: allowedPolicy,
+                };
+            }),
+            initial: Math.max(0, existingPolicyIndex),
         });
-        if (policyPrompt.cancelled) {
+        if (policyPrompt['cancelled'] === true) {
             return {
                 action: 'back',
             };
         }
-        const selectedPolicy = policyPrompt.result.workspacePolicy;
+        const selectedPolicy = policyPrompt['result'].workspacePolicy;
         const resolvedName = await resolveName(selectedRole);
         if (resolvedName === undefined) {
             return {
                 action: 'back',
             };
         }
-        let syncProperties;
-        if (selectedPolicy === 'distributable') {
-            const syncPropertiesPrompt = await CLIUtilityInitialize.promptWithCancel({
-                type: 'multiselect',
-                name: 'workspaceSyncProperties',
-                message: 'Select metadata properties to sync',
-                choices: itemAllowedSyncProperties.map((property) => ({
-                    title: property,
-                    value: property,
-                    selected: (options.existingWorkspace !== undefined && options.existingWorkspace.syncProperties !== undefined) ? options.existingWorkspace.syncProperties.includes(property) : false,
-                })),
-            });
-            if (syncPropertiesPrompt.cancelled) {
+        const existingRecipes = (options['existingWorkspace'] !== undefined && options['existingWorkspace']['recipes'] !== undefined) ? options['existingWorkspace']['recipes'] : undefined;
+        const recipesPrompt = await CliUtilityInitialize.promptWithCancel({
+            type: 'multiselect',
+            name: 'workspaceRecipes',
+            message: 'Select recipes to enable',
+            choices: libItemAllowedRecipes.map((recipe) => {
+                const recipeTuple = (existingRecipes !== undefined) ? Reflect.get(existingRecipes, recipe) : undefined;
+                const recipeSelected = (Array.isArray(recipeTuple)
+                    && recipeTuple.length > 0
+                    && recipeTuple[0] === true);
                 return {
-                    action: 'back',
+                    title: recipe,
+                    value: recipe,
+                    selected: recipeSelected,
                 };
-            }
-            const selectedSyncProperties = syncPropertiesPrompt.result.workspaceSyncProperties;
-            if (selectedSyncProperties.length > 0) {
-                syncProperties = selectedSyncProperties;
-            }
-        }
-        const pinVersionsPrompt = await CLIUtilityInitialize.promptWithCancel({
-            type: 'confirm',
-            name: 'workspacePinVersions',
-            message: 'Pin dependency versions?',
-            initial: options.existingWorkspace !== undefined && options.existingWorkspace.pinVersions === true,
+            }),
         });
-        if (pinVersionsPrompt.cancelled) {
+        if (recipesPrompt['cancelled'] === true) {
             return {
                 action: 'back',
             };
         }
-        const selectedPinVersions = pinVersionsPrompt.result.workspacePinVersions;
-        const syncLtsEnginesPrompt = await CLIUtilityInitialize.promptWithCancel({
-            type: 'confirm',
-            name: 'workspaceSyncLtsEngines',
-            message: 'Sync Node.js LTS engine constraint?',
-            initial: options.existingWorkspace !== undefined && options.existingWorkspace.syncLtsEngines === true,
-        });
-        if (syncLtsEnginesPrompt.cancelled) {
-            return {
-                action: 'back',
-            };
+        const selectedRecipes = recipesPrompt['result'].workspaceRecipes;
+        const recipes = {};
+        for (const recipe of selectedRecipes) {
+            const existingTupleRaw = (existingRecipes !== undefined) ? Reflect.get(existingRecipes, recipe) : undefined;
+            const existingTuple = (Array.isArray(existingTupleRaw) === true) ? existingTupleRaw : undefined;
+            const existingSettings = (existingTuple !== undefined && existingTuple.length > 1) ? existingTuple[1] : undefined;
+            if (recipe === 'sync-identity' && selectedPolicy === 'distributable') {
+                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'workspaceRecipeSettings',
+                    message: 'sync-identity: Select properties to sync',
+                    choices: [
+                        {
+                            title: 'description',
+                            value: 'description',
+                            selected: existingSettings !== undefined && existingSettings['description'] === true,
+                        },
+                        {
+                            title: 'keywords',
+                            value: 'keywords',
+                            selected: existingSettings !== undefined && existingSettings['keywords'] === true,
+                        },
+                    ],
+                });
+                if (settingsPrompt['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
+                if (selectedSettings.length > 0) {
+                    const settings = {};
+                    for (const setting of selectedSettings) {
+                        Reflect.set(settings, setting, true);
+                    }
+                    Reflect.set(recipes, recipe, [
+                        true,
+                        settings,
+                    ]);
+                }
+                else {
+                    Reflect.set(recipes, recipe, [true]);
+                }
+            }
+            else if (recipe === 'sync-ownership' && selectedPolicy === 'distributable') {
+                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'workspaceRecipeSettings',
+                    message: 'sync-ownership: Select properties to sync',
+                    choices: [
+                        {
+                            title: 'homepage',
+                            value: 'homepage',
+                            selected: existingSettings !== undefined && existingSettings['homepage'] === true,
+                        },
+                        {
+                            title: 'bugs',
+                            value: 'bugs',
+                            selected: existingSettings !== undefined && existingSettings['bugs'] === true,
+                        },
+                        {
+                            title: 'author',
+                            value: 'author',
+                            selected: existingSettings !== undefined && existingSettings['author'] === true,
+                        },
+                        {
+                            title: 'contributors',
+                            value: 'contributors',
+                            selected: existingSettings !== undefined && existingSettings['contributors'] === true,
+                        },
+                        {
+                            title: 'funding',
+                            value: 'funding',
+                            selected: existingSettings !== undefined && existingSettings['funding'] === true,
+                        },
+                        {
+                            title: 'repository',
+                            value: 'repository',
+                            selected: existingSettings !== undefined && existingSettings['repository'] === true,
+                        },
+                    ],
+                });
+                if (settingsPrompt['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
+                if (selectedSettings.length > 0) {
+                    const settings = {};
+                    for (const setting of selectedSettings) {
+                        Reflect.set(settings, setting, true);
+                    }
+                    Reflect.set(recipes, recipe, [
+                        true,
+                        settings,
+                    ]);
+                }
+                else {
+                    Reflect.set(recipes, recipe, [true]);
+                }
+            }
+            else if (recipe === 'sync-environment') {
+                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'workspaceRecipeSettings',
+                    message: 'sync-environment: Select settings',
+                    choices: [{
+                            title: 'trackNodeLtsVersions',
+                            value: 'trackNodeLtsVersions',
+                            selected: existingSettings !== undefined && existingSettings['trackNodeLtsVersions'] === true,
+                        }],
+                });
+                if (settingsPrompt['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
+                if (selectedSettings.length > 0) {
+                    const settings = {};
+                    for (const setting of selectedSettings) {
+                        Reflect.set(settings, setting, true);
+                    }
+                    Reflect.set(recipes, recipe, [
+                        true,
+                        settings,
+                    ]);
+                }
+                else {
+                    Reflect.set(recipes, recipe, [true]);
+                }
+            }
+            else if (recipe === 'cleanup') {
+                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'workspaceRecipeSettings',
+                    message: 'cleanup: Select settings',
+                    choices: [
+                        {
+                            title: 'removeUnknownKeys',
+                            value: 'removeUnknownKeys',
+                            selected: existingSettings !== undefined && existingSettings['removeUnknownKeys'] === true,
+                        },
+                        {
+                            title: 'reorderKeys',
+                            value: 'reorderKeys',
+                            selected: existingSettings !== undefined && existingSettings['reorderKeys'] === true,
+                        },
+                    ],
+                });
+                if (settingsPrompt['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
+                if (selectedSettings.length > 0) {
+                    const settings = {};
+                    for (const setting of selectedSettings) {
+                        Reflect.set(settings, setting, true);
+                    }
+                    Reflect.set(recipes, recipe, [
+                        true,
+                        settings,
+                    ]);
+                }
+                else {
+                    Reflect.set(recipes, recipe, [true]);
+                }
+            }
+            else if (recipe === 'normalize-dependencies') {
+                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                    type: 'multiselect',
+                    name: 'workspaceRecipeSettings',
+                    message: 'normalize-dependencies: Select settings',
+                    choices: [
+                        {
+                            title: 'pinDependencyVersions',
+                            value: 'pinDependencyVersions',
+                            selected: existingSettings !== undefined && existingSettings['pinDependencyVersions'] === true,
+                        },
+                        {
+                            title: 'pinDevDependencyVersions',
+                            value: 'pinDevDependencyVersions',
+                            selected: existingSettings !== undefined && existingSettings['pinDevDependencyVersions'] === true,
+                        },
+                    ],
+                });
+                if (settingsPrompt['cancelled'] === true) {
+                    return {
+                        action: 'back',
+                    };
+                }
+                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
+                if (selectedSettings.length > 0) {
+                    const settings = {};
+                    for (const setting of selectedSettings) {
+                        Reflect.set(settings, setting, true);
+                    }
+                    Reflect.set(recipes, recipe, [
+                        true,
+                        settings,
+                    ]);
+                }
+                else {
+                    Reflect.set(recipes, recipe, [true]);
+                }
+            }
+            else {
+                Reflect.set(recipes, recipe, [true]);
+            }
         }
-        const selectedSyncLtsEngines = syncLtsEnginesPrompt.result.workspaceSyncLtsEngines;
         return {
             action: 'apply',
             workspace: {
                 name: resolvedName,
                 role: selectedRole,
                 policy: selectedPolicy,
-                ...(syncProperties !== undefined) ? { syncProperties } : {},
-                ...(selectedPinVersions === true) ? { pinVersions: selectedPinVersions } : {},
-                ...(selectedSyncLtsEngines === true) ? { syncLtsEngines: selectedSyncLtsEngines } : {},
+                ...(Object.keys(recipes).length > 0) ? { recipes } : {},
             },
         };
     }
     static async promptWithCancel(questions) {
         let cancelled = false;
         const result = await prompts(questions, {
-            onCancel: () => {
-                cancelled = true;
-                return false;
-            },
+            onCancel: () => false,
         });
-        if (cancelled) {
+        if (Object.keys(result).length === 0) {
+            cancelled = true;
+        }
+        if (cancelled === true) {
             return {
                 cancelled: true,
             };
@@ -961,37 +1854,40 @@ export class CLIUtilityInitialize {
     static async checkPath(currentDirectory) {
         const locations = await discoverPathsWithFile('package.json', 'backward');
         Logger.customize({
-            name: 'CLIUtilityInitialize.checkPath',
+            name: 'CliUtilityInitialize.checkPath',
             purpose: 'detectedLocations',
         }).debug(locations);
         if (locations.length < 1) {
-            Logger.customize({
-                name: 'CLIUtilityInitialize.checkPath',
-                purpose: 'lessThanOne',
-            }).error([
+            const lessThanOneMessage = [
                 'No "package.json" files were found. Re-run this command inside the project root directory.',
                 `Current directory is "${currentDirectory}"`,
-            ].join('\n'));
+            ].join('\n');
+            Logger.customize({
+                name: 'CliUtilityInitialize.checkPath',
+                purpose: 'lessThanOne',
+            }).error(lessThanOneMessage);
             return false;
         }
         if (locations.length > 1) {
-            Logger.customize({
-                name: 'CLIUtilityInitialize.checkPath',
-                purpose: 'greaterThanOne',
-            }).error([
+            const greaterThanOneMessage = [
                 'Multiple "package.json" files were found. Re-run this command inside the project root directory.',
                 `Current directory is "${currentDirectory}"`,
-            ].join('\n'));
+            ].join('\n');
+            Logger.customize({
+                name: 'CliUtilityInitialize.checkPath',
+                purpose: 'greaterThanOne',
+            }).error(greaterThanOneMessage);
             return false;
         }
         if (locations.length === 1 && locations[0] !== currentDirectory) {
-            Logger.customize({
-                name: 'CLIUtilityInitialize.checkPath',
-                purpose: 'notProjectRootDir',
-            }).error([
+            const notProjectRootDirectoryMessage = [
                 'Must be run inside the project root directory.',
                 `Current directory is "${currentDirectory}"`,
-            ].join('\n'));
+            ].join('\n');
+            Logger.customize({
+                name: 'CliUtilityInitialize.checkPath',
+                purpose: 'notProjectRootDirectory',
+            }).error(notProjectRootDirectoryMessage);
             return false;
         }
         return true;
@@ -1010,7 +1906,7 @@ export class CLIUtilityInitialize {
                 sanitized: undefined,
             };
         }
-        if (!PATTERN_EMAIL_SIMPLE.test(trimmedValue)) {
+        if (LIB_REGEX_PATTERN_EMAIL_SIMPLE.test(trimmedValue) === false) {
             return {
                 result: 'Enter a valid email address or leave blank.',
                 sanitized: undefined,
@@ -1036,7 +1932,7 @@ export class CLIUtilityInitialize {
             };
         }
         if (trimmedValue.length > 214
-            || !new RegExp(PATTERN_SLUG_SIMPLE, 'i').test(trimmedValue)) {
+            || new RegExp(LIB_REGEX_PATTERN_SLUG_SIMPLE, 'i').test(trimmedValue) === false) {
             return {
                 result: 'Use only letters, numbers, hyphens, or underscores, and keep it at 214 characters or fewer.',
                 sanitized: undefined,
@@ -1091,7 +1987,9 @@ export class CLIUtilityInitialize {
             .map((item) => item.trim())
             .filter((item) => item !== '');
         for (let i = 0; i < items.length; i += 1) {
-            const { result, sanitized } = CLIUtilityInitialize.normalizeText(items[i], maxLengthPerItem);
+            const normalizedText = CliUtilityInitialize.normalizeText(items[i], maxLengthPerItem);
+            const result = normalizedText['result'];
+            const sanitized = normalizedText['sanitized'];
             if (result !== true) {
                 return {
                     result: `Invalid entry "${items[i]}": Input a value under ${maxLengthPerItem} character(s) or remove entry.`,
@@ -1099,7 +1997,7 @@ export class CLIUtilityInitialize {
                 };
             }
             if (sanitized !== undefined) {
-                items[i] = sanitized;
+                Reflect.set(items, i, sanitized);
             }
         }
         return {
@@ -1123,19 +2021,29 @@ export class CLIUtilityInitialize {
         }
         const rules = {
             generic: {
-                allowed: ['http:', 'https:'],
+                allowed: [
+                    'http:',
+                    'https:',
+                ],
                 message: 'Enter a valid generic URL (e.g., https://) or leave blank.',
             },
             repository: {
-                allowed: ['git:', 'git+https:', 'git+ssh:', 'git+http:', 'http:', 'https:'],
+                allowed: [
+                    'git:',
+                    'git+https:',
+                    'git+ssh:',
+                    'git+http:',
+                    'http:',
+                    'https:',
+                ],
                 message: 'Enter a valid repository URL (e.g., git+https://) or leave blank.',
             },
         };
-        const allowed = (protocol === 'repository') ? rules.repository.allowed : rules.generic.allowed;
-        const errorMessage = (protocol === 'repository') ? rules.repository.message : rules.generic.message;
+        const allowed = (protocol === 'repository') ? rules['repository']['allowed'] : rules['generic']['allowed'];
+        const errorMessage = (protocol === 'repository') ? rules['repository']['message'] : rules['generic']['message'];
         try {
             const url = new URL(trimmedValue);
-            if (allowed.includes(url.protocol)) {
+            if (allowed.includes(url.protocol) === true) {
                 return {
                     result: true,
                     sanitized: url.toString(),
@@ -1168,20 +2076,22 @@ export class CLIUtilityInitialize {
             .map((item) => item.trim())
             .filter((item) => item !== '');
         for (let i = 0; i < items.length; i += 1) {
-            const { result, sanitized } = CLIUtilityInitialize.normalizeUrl(items[i], protocol);
+            const normalizedUrl = CliUtilityInitialize.normalizeUrl(items[i], protocol);
+            const result = normalizedUrl['result'];
+            const sanitized = normalizedUrl['sanitized'];
             if (result !== true) {
                 const errorMessages = {
                     generic: 'Enter a valid generic URL (e.g., https://) or remove entry.',
                     repository: 'Enter a valid repository URL (e.g., git+https://) or remove entry.',
                 };
-                const errorMessage = (protocol === 'repository') ? errorMessages.repository : errorMessages.generic;
+                const errorMessage = (protocol === 'repository') ? errorMessages['repository'] : errorMessages['generic'];
                 return {
                     result: `Invalid URL "${items[i]}": ${errorMessage}`,
                     sanitized: undefined,
                 };
             }
             if (sanitized !== undefined) {
-                items[i] = sanitized;
+                Reflect.set(items, i, sanitized);
             }
         }
         return {
@@ -1208,7 +2118,7 @@ export class CLIUtilityInitialize {
             case 'app':
             case 'tool': {
                 const expectedPrefix = `${base}-`;
-                if (!trimmedValue.startsWith(expectedPrefix)) {
+                if (trimmedValue.startsWith(expectedPrefix) === false) {
                     return {
                         result: `Begin with "${expectedPrefix}" and add a descriptor slug.`,
                         sanitized: undefined,
@@ -1221,7 +2131,7 @@ export class CLIUtilityInitialize {
                         sanitized: undefined,
                     };
                 }
-                if (!PATTERN_SLUG_SIMPLE.test(descriptor)) {
+                if (LIB_REGEX_PATTERN_SLUG_SIMPLE.test(descriptor) === false) {
                     return {
                         result: 'Descriptor must match the slug pattern (lowercase letters, numbers, hyphens, underscores).',
                         sanitized: undefined,
@@ -1235,7 +2145,7 @@ export class CLIUtilityInitialize {
             case 'template':
             case 'package':
             default: {
-                if (PATTERN_SLUG_SIMPLE.test(trimmedValue) || PATTERN_SLUG_SCOPED.test(trimmedValue)) {
+                if (LIB_REGEX_PATTERN_SLUG_SIMPLE.test(trimmedValue) === true || LIB_REGEX_PATTERN_SLUG_SCOPED.test(trimmedValue) === true) {
                     return {
                         result: true,
                         sanitized: trimmedValue,