prompt-language-shell 0.6.2 → 0.6.6

package/README.md

@@ -2,8 +2,8 @@
 
 Your personal command-line concierge. Ask politely, and it gets things done.
 
-> **Note:** This project is in early preview. Features and APIs may change as
-> development continues.
+> **Note:** This project is in early preview. Features and APIs will change.
+> See [roadmap](#roadmap).
 
 ## Installation
 
@@ -13,14 +13,14 @@ npm install -g prompt-language-shell
 
 ## Setup
 
-On first run, `pls` walks you through a quick setup. Your settings will be saved to `~/.plsrc`.
+On first run, `pls` walks you through a quick setup.
+Your settings will be saved to `~/.plsrc`.
 
 ## Usage
 
 Type `pls` followed by your request in natural language.
 
-To see what `pls` can
-do, start by listing available capabilities:
+To see what `pls` can do, start by listing available capabilities:
 
 ```
 $ pls list skills
@@ -98,6 +98,8 @@ Skills let you teach `pls` about your project-specific workflows. Create
 markdown files in `~/.pls/skills/` to define custom operations that `pls` can
 understand and execute.
 
+For complete documentation, see [docs/SKILLS.md](./docs/SKILLS.md).
+
 ### Structure
 
 Each skill file uses a simple markdown format:
@@ -155,6 +157,13 @@ $ pls build dev
 $ pls build test
 ```
 
+## Roadmap
+
+- **0.7** - Comprehend skill, simplified prompts, better debugging
+- **0.8** - Sequential and interlaced skill execution
+- **0.9** - Learn skill, codebase refinement, complex dependency handling
+- **1.0** - Production release
+
 ## Development
 
 See [CLAUDE.md](./CLAUDE.md) for development guidelines and architecture.

package/dist/config/INTROSPECT.md

@@ -88,6 +88,8 @@ These MUST appear AFTER Execute and BEFORE user skills:
 If skills are provided in the "Available Skills" section below, include them
 in the response. For each skill:
 - Extract the skill name from the first heading (# Skill Name)
+- If the skill name contains "(INCOMPLETE)", preserve it exactly in the task
+  action
 - Extract a brief description from the Description or Overview section
 - Keep descriptions concise (1-2 lines maximum)
 - If the user specified a filter (e.g., "skills for deployment"), only include

package/dist/services/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration.js';
-import { formatSkillsForPrompt, loadSkills } from './skills.js';
+import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
 import { toolRegistry } from './tool-registry.js';
 /**
  * Wraps text to ensure no line exceeds the specified width.
@@ -62,7 +62,7 @@ export class AnthropicService {
             toolName === 'introspect' ||
             toolName === 'execute' ||
             toolName === 'validate') {
-            const skills = loadSkills();
+            const skills = loadSkillsWithValidation();
             const skillsSection = formatSkillsForPrompt(skills);
             systemPrompt += skillsSection;
         }

package/dist/services/components.js

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { ComponentName } from '../types/types.js';
+import { ComponentStatus, } from '../types/components.js';
 import { parse as parseYaml } from 'yaml';
-import { getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
+import { ConfigDefinitionType, getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function createWelcomeDefinition(app) {
@@ -39,15 +40,15 @@ function getConfigValue(config, key) {
  */
 function getValidator(definition) {
     switch (definition.type) {
-        case 'regexp':
+        case ConfigDefinitionType.RegExp:
             return (value) => definition.pattern.test(value);
-        case 'string':
+        case ConfigDefinitionType.String:
             return () => true; // Strings are always valid
-        case 'enum':
+        case ConfigDefinitionType.Enum:
             return (value) => definition.values.includes(value);
-        case 'number':
+        case ConfigDefinitionType.Number:
             return (value) => !isNaN(Number(value));
-        case 'boolean':
+        case ConfigDefinitionType.Boolean:
             return (value) => value === 'true' || value === 'false';
     }
 }
@@ -103,11 +104,11 @@ export function createConfigStepsFromSchema(keys) {
         const shortKey = keyParts[keyParts.length - 1];
         // Map definition to ConfigStep based on type
         switch (definition.type) {
-            case 'regexp':
-            case 'string': {
+            case ConfigDefinitionType.RegExp:
+            case ConfigDefinitionType.String: {
                 const value = currentValue !== undefined && typeof currentValue === 'string'
                     ? currentValue
-                    : definition.type === 'string'
+                    : definition.type === ConfigDefinitionType.String
                         ? (definition.default ?? '')
                         : null;
                 return {
@@ -119,7 +120,7 @@ export function createConfigStepsFromSchema(keys) {
                     validate: getValidator(definition),
                 };
             }
-            case 'number': {
+            case ConfigDefinitionType.Number: {
                 const value = currentValue !== undefined && typeof currentValue === 'number'
                     ? String(currentValue)
                     : definition.default !== undefined
@@ -134,7 +135,7 @@ export function createConfigStepsFromSchema(keys) {
                     validate: getValidator(definition),
                 };
             }
-            case 'enum': {
+            case ConfigDefinitionType.Enum: {
                 const currentStr = currentValue !== undefined && typeof currentValue === 'string'
                     ? currentValue
                     : definition.default;
@@ -154,7 +155,7 @@ export function createConfigStepsFromSchema(keys) {
                     validate: getValidator(definition),
                 };
             }
-            case 'boolean': {
+            case ConfigDefinitionType.Boolean: {
                 const currentBool = currentValue !== undefined && typeof currentValue === 'boolean'
                     ? currentValue
                     : undefined;
@@ -178,6 +179,7 @@ export function createConfigDefinition(onFinished, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Config,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             steps: createConfigSteps(),
@@ -193,6 +195,7 @@ export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Config,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             steps: createConfigStepsFromSchema(keys),
@@ -205,6 +208,7 @@ export function createCommandDefinition(command, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Command,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             command,
@@ -216,6 +220,7 @@ export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
     return {
         id: randomUUID(),
         name: ComponentName.Plan,
+        status: ComponentStatus.Awaiting,
         state: {
             highlightedIndex: null,
             currentDefineGroupIndex: 0,
@@ -251,6 +256,7 @@ export function createRefinement(text, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Refinement,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             text,
@@ -262,6 +268,7 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
     return {
         id: randomUUID(),
         name: ComponentName.Confirm,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             message: getConfirmationMessage(),
@@ -274,6 +281,7 @@ export function createIntrospectDefinition(tasks, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Introspect,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             tasks,
@@ -295,6 +303,7 @@ export function createAnswerDefinition(question, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Answer,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             question,
@@ -308,16 +317,16 @@ export function isStateless(component) {
 /**
  * Mark a component as done. Returns the component to be added to timeline.
  * Components use handlers.updateState to save their state before completion,
- * so this function simply returns the component as-is.
+ * so this function sets the status to Done and returns the updated component.
  */
 export function markAsDone(component) {
-    // State already updated via handlers.updateState
-    return component;
+    return { ...component, status: ComponentStatus.Done };
 }
 export function createExecuteDefinition(tasks, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Execute,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             tasks,
@@ -329,6 +338,7 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
     return {
         id: randomUUID(),
         name: ComponentName.Validate,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             missingConfig,

package/dist/services/configuration.js

@@ -9,6 +9,14 @@ export var AnthropicModel;
     AnthropicModel["Opus"] = "claude-opus-4-1";
 })(AnthropicModel || (AnthropicModel = {}));
 export const SUPPORTED_MODELS = Object.values(AnthropicModel);
+export var ConfigDefinitionType;
+(function (ConfigDefinitionType) {
+    ConfigDefinitionType["RegExp"] = "regexp";
+    ConfigDefinitionType["String"] = "string";
+    ConfigDefinitionType["Enum"] = "enum";
+    ConfigDefinitionType["Number"] = "number";
+    ConfigDefinitionType["Boolean"] = "boolean";
+})(ConfigDefinitionType || (ConfigDefinitionType = {}));
 export class ConfigError extends Error {
     origin;
     constructor(message, origin) {
@@ -172,20 +180,20 @@ export function getConfigurationRequiredMessage(forFutureUse = false) {
  */
 const coreConfigSchema = {
     'anthropic.key': {
-        type: 'regexp',
+        type: ConfigDefinitionType.RegExp,
         required: true,
         pattern: /^sk-ant-api03-[A-Za-z0-9_-]{95}$/,
         description: 'Anthropic API key',
     },
     'anthropic.model': {
-        type: 'enum',
+        type: ConfigDefinitionType.Enum,
         required: true,
         values: SUPPORTED_MODELS,
         default: AnthropicModel.Haiku,
         description: 'Anthropic model',
     },
     'settings.debug': {
-        type: 'boolean',
+        type: ConfigDefinitionType.Boolean,
         required: false,
         description: 'Debug mode',
     },
@@ -239,20 +247,20 @@ export function getMissingConfigKeys() {
         // Validate based on type
         let isValid = false;
         switch (definition.type) {
-            case 'regexp':
+            case ConfigDefinitionType.RegExp:
                 isValid = typeof value === 'string' && definition.pattern.test(value);
                 break;
-            case 'string':
+            case ConfigDefinitionType.String:
                 isValid = typeof value === 'string';
                 break;
-            case 'enum':
+            case ConfigDefinitionType.Enum:
                 isValid =
                     typeof value === 'string' && definition.values.includes(value);
                 break;
-            case 'number':
+            case ConfigDefinitionType.Number:
                 isValid = typeof value === 'number';
                 break;
-            case 'boolean':
+            case ConfigDefinitionType.Boolean:
                 isValid = typeof value === 'boolean';
                 break;
         }
@@ -357,13 +365,13 @@ function parseConfigValue(key, stringValue, schema) {
     if (key in schema) {
         const definition = schema[key];
         switch (definition.type) {
-            case 'boolean':
+            case ConfigDefinitionType.Boolean:
                 return stringValue === 'true';
-            case 'number':
+            case ConfigDefinitionType.Number:
                 return Number(stringValue);
-            case 'string':
-            case 'regexp':
-            case 'enum':
+            case ConfigDefinitionType.String:
+            case ConfigDefinitionType.RegExp:
+            case ConfigDefinitionType.Enum:
                 return stringValue;
         }
     }

package/dist/services/execution-validator.js

@@ -5,25 +5,47 @@ import { expandSkillReferences } from './skill-expander.js';
 import { getConfigType, parseSkillMarkdown } from './skill-parser.js';
 /**
  * Validate config requirements for execute tasks
- * Returns missing config requirements
+ * Returns validation result with missing config and validation errors
  */
 export function validateExecuteTasks(tasks) {
     const userConfig = loadUserConfig();
     const missing = [];
     const seenPaths = new Set();
-    // Load and parse all skills for validation
+    const validationErrors = [];
+    const seenSkills = new Set();
+    // Load all skills (including invalid ones for validation)
     const skillContents = loadSkills();
-    const parsedSkills = skillContents
-        .map((content) => parseSkillMarkdown(content))
-        .filter((s) => s !== null);
+    const parsedSkills = skillContents.map((content) => parseSkillMarkdown(content));
     const skillLookup = (name) => parsedSkills.find((s) => s.name === name) || null;
+    // Check for invalid skills being used in tasks
+    for (const task of tasks) {
+        const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;
+        if (skillName && !seenSkills.has(skillName)) {
+            seenSkills.add(skillName);
+            // Check if this skill is invalid
+            const skill = skillLookup(skillName);
+            if (skill && !skill.isValid) {
+                validationErrors.push({
+                    skill: skill.name,
+                    issues: [skill.validationError || 'Unknown validation error'],
+                });
+            }
+        }
+    }
+    // If there are validation errors, return early
+    if (validationErrors.length > 0) {
+        return {
+            missingConfig: [],
+            validationErrors,
+        };
+    }
     for (const task of tasks) {
         // Check if task originates from a skill
         const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;
         if (skillName) {
             // Task comes from a skill - check skill's Execution section
             const skill = skillLookup(skillName);
-            if (!skill || !skill.execution) {
+            if (!skill) {
                 continue;
             }
             // Get variant from task params (if any)
@@ -106,5 +128,8 @@ export function validateExecuteTasks(tasks) {
             }
         }
     }
-    return missing;
+    return {
+        missingConfig: missing,
+        validationErrors: [],
+    };
 }

package/dist/services/refinement.js

@@ -25,8 +25,7 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         // Complete the Refinement component
         handlers.completeActive();
         // Route refined tasks to appropriate components
-        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false, // No DEFINE tasks in refined result
-        undefined // No commandComponent - use normal flow
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
         );
     }
     catch (err) {

package/dist/services/skill-expander.js

@@ -37,10 +37,6 @@ export function expandSkillReferences(execution, skillLookup, visited = new Set(
             expanded.push(line);
             continue;
         }
-        if (!skill.execution || skill.execution.length === 0) {
-            // Referenced skill has no execution, skip
-            continue;
-        }
         // Recursively expand referenced skill's execution
         const newVisited = new Set(visited);
         newVisited.add(skillName);
@@ -62,7 +58,7 @@ export function getReferencedSkills(execution, skillLookup, visited = new Set())
         }
         referenced.add(skillName);
         const skill = skillLookup(skillName);
-        if (skill && skill.execution) {
+        if (skill) {
             const newVisited = new Set(visited);
             newVisited.add(skillName);
             const nested = getReferencedSkills(skill.execution, skillLookup, newVisited);

package/dist/services/skill-parser.js

@@ -1,40 +1,85 @@
 import YAML from 'yaml';
 /**
- * Parse a skill markdown file into structured definition
+ * Validate a skill without parsing it fully
+ * Returns validation error if skill is invalid, null if valid
  */
-export function parseSkillMarkdown(content) {
+export function validateSkill(content) {
     const sections = extractSections(content);
-    // Name is required
+    // Name is required for error reporting
+    const skillName = sections.name || 'Unknown skill';
+    // Check required sections
     if (!sections.name) {
-        return null;
+        return {
+            skillName,
+            error: 'The skill file is missing a Name section',
+        };
     }
-    // Description is required
     if (!sections.description) {
-        return null;
+        return {
+            skillName,
+            error: 'The skill file is missing a Description section',
+        };
     }
-    // Steps are required
     if (!sections.steps || sections.steps.length === 0) {
-        return null;
-    }
-    // Validate execution and steps have same count (if execution exists)
-    if (sections.execution &&
-        sections.execution.length !== sections.steps.length) {
-        return null;
-    }
+        return {
+            skillName,
+            error: 'The skill file is missing a Steps section',
+        };
+    }
+    if (!sections.execution || sections.execution.length === 0) {
+        return {
+            skillName,
+            error: 'The skill file is missing an Execution section',
+        };
+    }
+    // Execution and steps must have same count
+    if (sections.execution.length !== sections.steps.length) {
+        return {
+            skillName,
+            error: `The skill has ${String(sections.steps.length)} steps but ${String(sections.execution.length)} execution lines`,
+        };
+    }
+    return null;
+}
+/**
+ * Parse a skill markdown file into structured definition
+ */
+export function parseSkillMarkdown(content) {
+    const sections = extractSections(content);
+    // Validate the skill
+    const validationError = validateSkill(content);
+    // For invalid skills, return minimal definition with error
+    if (validationError) {
+        return {
+            name: sections.name || 'Unknown skill',
+            description: sections.description || '',
+            steps: sections.steps || [],
+            execution: sections.execution || [],
+            isValid: false,
+            validationError: validationError.error,
+            isIncomplete: true,
+        };
+    }
+    // Valid skill - all required fields are present (validation passed)
+    const description = sections.description;
     const skill = {
         name: sections.name,
-        description: sections.description,
+        description,
         steps: sections.steps,
+        execution: sections.execution,
+        isValid: true,
     };
+    // Check if skill is incomplete (valid but needs more documentation)
+    const MIN_DESCRIPTION_LENGTH = 20;
+    if (description.trim().length < MIN_DESCRIPTION_LENGTH) {
+        skill.isIncomplete = true;
+    }
     if (sections.aliases && sections.aliases.length > 0) {
         skill.aliases = sections.aliases;
     }
     if (sections.config) {
         skill.config = sections.config;
     }
-    if (sections.execution && sections.execution.length > 0) {
-        skill.execution = sections.execution;
-    }
     return skill;
 }
 /**
@@ -46,8 +91,8 @@ function extractSections(content) {
     let currentSection = null;
     let sectionLines = [];
     for (const line of lines) {
-        // Check for section headers (### SectionName)
-        const headerMatch = line.match(/^###\s+(.+)$/);
+        // Check for section headers (any valid markdown header: #, ##, ###, etc.)
+        const headerMatch = line.match(/^#{1,6}\s+(.+)$/);
         if (headerMatch) {
             // Process previous section
             if (currentSection) {

package/dist/services/skills.js

@@ -35,18 +35,26 @@ export function loadSkills() {
 }
 /**
  * Load and parse all skill definitions
- * Returns structured skill definitions
+ * Returns structured skill definitions (including invalid skills)
  */
 export function loadSkillDefinitions() {
     const skillContents = loadSkills();
-    const definitions = [];
-    for (const content of skillContents) {
+    return skillContents.map((content) => parseSkillMarkdown(content));
+}
+/**
+ * Load skills and mark incomplete ones in their markdown
+ * Returns array of skill markdown with status markers
+ */
+export function loadSkillsWithValidation() {
+    const skillContents = loadSkills();
+    return skillContents.map((content) => {
         const parsed = parseSkillMarkdown(content);
-        if (parsed) {
-            definitions.push(parsed);
+        // If skill is incomplete (either validation failed or needs more documentation), append (INCOMPLETE) to the name
+        if (parsed.isIncomplete) {
+            return content.replace(/^(#{1,6}\s+Name\s*\n+)(.+?)(\n|$)/im, `$1$2 (INCOMPLETE)$3`);
         }
-    }
-    return definitions;
+        return content;
+    });
 }
 /**
  * Create skill lookup function from definitions
@@ -72,6 +80,10 @@ export function formatSkillsForPrompt(skills) {
 The following skills define domain-specific workflows. When the user's
 query matches a skill, incorporate the skill's steps into your plan.
 
+Skills marked with (INCOMPLETE) have validation errors or need more
+documentation, and cannot be executed. These should be listed in
+introspection with their markers.
+
 **IMPORTANT**: When creating options from skill descriptions, do NOT use
 brackets for additional information. Use commas instead. For example:
 - CORRECT: "Build project Alpha, the legacy version"

package/dist/services/task-router.js

@@ -3,7 +3,7 @@ import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDe
 import { saveConfig, unflattenConfig } from './configuration.js';
 import { FeedbackType } from '../types/types.js';
 import { validateExecuteTasks } from './execution-validator.js';
-import { getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 /**
  * Determine the operation name based on task types
  */
@@ -20,7 +20,7 @@ export function getOperationName(tasks) {
  * Route tasks to appropriate components with Confirm flow
  * Handles the complete flow: Plan → Confirm → Execute/Answer/Introspect
  */
-export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false, commandComponent) {
+export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false) {
     if (tasks.length === 0)
         return;
     // Filter out ignore and discard tasks early
@@ -32,31 +32,32 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
         return;
     }
     const operation = getOperationName(validTasks);
-    // Create plan definition with valid tasks only
-    const planDefinition = createPlanDefinition(message, validTasks);
     if (hasDefineTask) {
         // Has DEFINE tasks - add Plan to queue for user selection
         // Refinement flow will call this function again with refined tasks
+        const planDefinition = createPlanDefinition(message, validTasks);
         handlers.addToQueue(planDefinition);
     }
     else {
-        // No DEFINE tasks - add Plan to timeline, create Confirm
-        const confirmDefinition = createConfirmDefinition(() => {
-            // User confirmed - route to appropriate component
-            handlers.completeActive();
-            executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
-        }, () => {
-            // User cancelled
-            handlers.onAborted(operation);
+        // No DEFINE tasks - Plan auto-completes and adds Confirm to queue
+        // When Plan activates, Command moves to timeline
+        // When Plan completes, it moves to pending
+        // When Confirm activates, Plan stays pending (visible for context)
+        const planDefinition = createPlanDefinition(message, validTasks, () => {
+            // Plan completed - add Confirm to queue
+            const confirmDefinition = createConfirmDefinition(() => {
+                // User confirmed - complete both Confirm and Plan, then route to appropriate component
+                handlers.completeActiveAndPending();
+                executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
+            }, () => {
+                // User cancelled - complete both Confirm and Plan, then show cancellation
+                handlers.completeActiveAndPending();
+                const message = getCancellationMessage(operation);
+                handlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
+            });
+            handlers.addToQueue(confirmDefinition);
         });
-        // Use atomic update if commandComponent provided, else normal flow
-        if (commandComponent) {
-            handlers.completeActive(planDefinition);
-        }
-        else {
-            handlers.addToTimeline(planDefinition);
-        }
-        handlers.addToQueue(confirmDefinition);
+        handlers.addToQueue(planDefinition);
     }
 }
 /**
@@ -124,9 +125,19 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
     }
     else {
         // Execute tasks with validation
-        const missingConfig = validateExecuteTasks(tasks);
-        if (missingConfig.length > 0) {
-            handlers.addToQueue(createValidateDefinition(missingConfig, userRequest, service, (error) => {
+        const validation = validateExecuteTasks(tasks);
+        if (validation.validationErrors.length > 0) {
+            // Show error feedback for invalid skills
+            const errorMessages = validation.validationErrors.map((error) => {
+                const issuesList = error.issues
+                    .map((issue) => `  - ${issue}`)
+                    .join('\n');
+                return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
+            });
+            handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+        }
+        else if (validation.missingConfig.length > 0) {
+            handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
                 handlers.onError(error);
             }, () => {
                 handlers.addToQueue(createExecuteDefinition(tasks, service));