prompt-language-shell 0.8.4 → 0.8.8

package/dist/services/router.js

@@ -1,7 +1,10 @@
 import { asScheduledTasks } from '../types/guards.js';
 import { FeedbackType, TaskType } from '../types/types.js';
+import { saveConfig } from '../configuration/io.js';
+import { getConfigSchema } from '../configuration/schema.js';
+import { unflattenConfig } from '../configuration/transformation.js';
+import { saveConfigLabels } from './config-labels.js';
 import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
-import { saveConfig, unflattenConfig } from './configuration.js';
 import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
 /**
@@ -20,7 +23,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, queueHandlers, workflowHandlers, errorHandlers, hasDefineTask = false) {
+export function routeTasksWithConfirm(tasks, message, service, userRequest, lifecycleHandlers, workflowHandlers, requestHandlers, hasDefineTask = false) {
     if (tasks.length === 0)
         return;
     // Filter out ignore and discard tasks early
@@ -28,7 +31,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, queu
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
         const message = createMessage(getUnknownRequestMessage());
-        queueHandlers.addToQueue(message);
+        workflowHandlers.addToQueue(message);
         return;
     }
     const operation = getOperationName(validTasks);
@@ -36,7 +39,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, queu
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
         const scheduleDefinition = createScheduleDefinition(message, validTasks);
-        queueHandlers.addToQueue(scheduleDefinition);
+        workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
         // No DEFINE tasks - Schedule auto-completes and adds Confirm to queue
@@ -47,17 +50,17 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, queu
             // Schedule completed - add Confirm to queue
             const confirmDefinition = createConfirmDefinition(() => {
                 // User confirmed - complete both Confirm and Schedule, then route to appropriate component
-                workflowHandlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, service, userRequest, queueHandlers, errorHandlers);
+                lifecycleHandlers.completeActiveAndPending();
+                executeTasksAfterConfirm(validTasks, service, userRequest, workflowHandlers, requestHandlers);
             }, () => {
                 // User cancelled - complete both Confirm and Schedule, then show cancellation
-                workflowHandlers.completeActiveAndPending();
+                lifecycleHandlers.completeActiveAndPending();
                 const message = getCancellationMessage(operation);
-                queueHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
+                workflowHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
             });
-            queueHandlers.addToQueue(confirmDefinition);
+            workflowHandlers.addToQueue(confirmDefinition);
         });
-        queueHandlers.addToQueue(scheduleDefinition);
+        workflowHandlers.addToQueue(scheduleDefinition);
     }
 }
 /**
@@ -88,16 +91,70 @@ function validateTaskTypes(tasks) {
  * Validates task types and routes each type appropriately
  * Supports mixed types at top level with Groups
  */
-function executeTasksAfterConfirm(tasks, service, userRequest, queueHandlers, errorHandlers) {
+function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers, requestHandlers) {
     // Validate task types (Groups must have uniform subtasks)
     try {
         validateTaskTypes(tasks);
     }
     catch (error) {
-        errorHandlers.onError(error instanceof Error ? error.message : String(error));
+        requestHandlers.onError(error instanceof Error ? error.message : String(error));
         return;
     }
     const scheduledTasks = asScheduledTasks(tasks);
+    // Collect ALL Execute tasks (standalone and from groups) for upfront validation
+    const allExecuteTasks = [];
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Execute) {
+            allExecuteTasks.push(task);
+        }
+        else if (task.type === TaskType.Group && task.subtasks) {
+            const subtasks = task.subtasks;
+            if (subtasks.length > 0 && subtasks[0].type === TaskType.Execute) {
+                allExecuteTasks.push(...subtasks);
+            }
+        }
+    }
+    // Validate ALL Execute tasks together to collect ALL missing config upfront
+    if (allExecuteTasks.length > 0) {
+        try {
+            const validation = validateExecuteTasks(allExecuteTasks);
+            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}`;
+                });
+                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                return;
+            }
+            else if (validation.missingConfig.length > 0) {
+                // Missing config detected - create ONE Validate component for ALL missing config
+                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
+                    requestHandlers.onError(error);
+                }, () => {
+                    // After config is complete, resume task routing
+                    routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers);
+                }, (operation) => {
+                    requestHandlers.onAborted(operation);
+                }));
+                return;
+            }
+        }
+        catch (error) {
+            requestHandlers.onError(error instanceof Error ? error.message : String(error));
+            return;
+        }
+    }
+    // No missing config - proceed with normal routing
+    routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers);
+}
+/**
+ * Route tasks after config is complete (or when no config is needed)
+ * Processes tasks in order, grouping by type
+ */
+function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers) {
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -117,7 +174,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, queueHandlers, er
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, service, userRequest, queueHandlers, errorHandlers);
+            routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers);
         }
         consecutiveStandaloneTasks = [];
     };
@@ -130,7 +187,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, queueHandlers, er
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, service, userRequest, queueHandlers, errorHandlers);
+                routeTasksByType(taskType, subtasks, service, userRequest, workflowHandlers, requestHandlers);
             }
         }
         else {
@@ -145,22 +202,35 @@ function executeTasksAfterConfirm(tasks, service, userRequest, queueHandlers, er
  * Route tasks by type to appropriate components
  * Extracted to allow reuse for both Groups and standalone tasks
  */
-function routeTasksByType(taskType, typeTasks, service, userRequest, queueHandlers, errorHandlers) {
+function routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers) {
     if (taskType === TaskType.Answer) {
         // Create separate Answer component for each question
         for (const task of typeTasks) {
-            queueHandlers.addToQueue(createAnswerDefinition(task.action, service));
+            workflowHandlers.addToQueue(createAnswerDefinition(task.action, service));
         }
     }
     else if (taskType === TaskType.Introspect) {
-        queueHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
+        workflowHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
     }
     else if (taskType === TaskType.Config) {
-        // Route to Config flow - extract keys from task params
+        // Route to Config flow - extract keys and descriptions from task params
         const configKeys = typeTasks
             .map((task) => task.params?.key)
             .filter((key) => key !== undefined);
-        queueHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
+        // Extract and cache labels from task descriptions
+        // Only cache labels for dynamically discovered keys (not in schema)
+        const schema = getConfigSchema();
+        const labels = {};
+        for (const task of typeTasks) {
+            const key = task.params?.key;
+            if (key && task.action && !(key in schema)) {
+                labels[key] = task.action;
+            }
+        }
+        if (Object.keys(labels).length > 0) {
+            saveConfigLabels(labels);
+        }
+        workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
             // Save config - Config component will handle completion and feedback
             try {
                 // Convert flat dotted keys to nested structure grouped by section
@@ -177,41 +247,11 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, queueHandle
                 throw new Error(errorMessage);
             }
         }, (operation) => {
-            errorHandlers.onAborted(operation);
+            requestHandlers.onAborted(operation);
         }));
     }
     else if (taskType === TaskType.Execute) {
-        // Execute tasks with validation
-        try {
-            const validation = validateExecuteTasks(typeTasks);
-            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}`;
-                });
-                queueHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
-            }
-            else if (validation.missingConfig.length > 0) {
-                queueHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    errorHandlers.onError(error);
-                }, () => {
-                    queueHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
-                }, (operation) => {
-                    errorHandlers.onAborted(operation);
-                }));
-            }
-            else {
-                queueHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
-            }
-        }
-        catch (error) {
-            // Handle skill reference errors (e.g., unknown skills)
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const message = createMessage(errorMessage);
-            queueHandlers.addToQueue(message);
-        }
+        // Execute tasks (validation already happened upfront in executeTasksAfterConfirm)
+        workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
     }
 }

package/dist/skills/execute.md

@@ -26,9 +26,63 @@ You will receive:
 
 ## Skill-Based Command Generation
 
+**CRITICAL**: The "Available Skills" section in the prompt defines the ONLY
+skills you can execute. This is an EXHAUSTIVE and COMPLETE list. Do NOT
+assume skills exist based on examples in these instructions.
+
 **CRITICAL**: When tasks originate from a user-defined skill, you MUST use
 the skill's **Execution** section to generate commands, NOT invent your own.
 
+**CRITICAL VALIDATION**: Before generating ANY commands for skill-based
+tasks, perform these checks in order:
+
+1. **Verify "Available Skills" section exists**: If there is no
+   "Available Skills" section in the prompt, STOP immediately and return
+   an error response.
+
+2. **Verify skill exists**: Check if the skill named in params.skill
+   actually exists in the "Available Skills" section below.
+
+3. **Verify skill has Steps section**: Check if the skill definition
+   includes a "### Steps" section with step descriptions.
+
+4. **Verify skill has Execution section**: Check if the skill definition
+   includes a "### Execution" section with actual commands.
+
+5. **If ANY check fails**: STOP immediately and return an error response.
+   DO NOT generate commands. DO NOT invent commands. DO NOT make
+   assumptions about what commands should be run.
+
+**Error Response Formats** (keep error messages concise):
+
+No Available Skills section:
+```
+message: "Cannot execute:"
+summary: "No skills available"
+commands: []
+error: "No skills available"
+```
+
+Skill not found:
+```
+message: "Cannot execute:"
+summary: "Skill not found"
+commands: []
+error: "Skill '[skill name]' not found"
+```
+
+Skill missing Steps or Execution:
+```
+message: "Cannot execute:"
+summary: "Incomplete skill"
+commands: []
+error: "Skill '[skill name]' is incomplete"
+```
+
+**IMPORTANT**: Error messages must be concise (under 50 characters). Avoid
+technical jargon or detailed explanations. The error will be shown to the
+user in a natural, conversational format.
+
 ### Understanding Skill Structure
 
 User-defined skills have two key sections:
@@ -42,7 +96,7 @@ position.
 
 1. **Identify skill tasks**: Check if tasks have params.skill
 2. **Find the skill**: Look up the skill in "Available Skills" section
-   below
+   below (REQUIRED - must exist)
 3. **Match tasks to Execution**: Each task action came from a Steps line;
    use the corresponding Execution line for the command
 4. **Substitute parameters**: Replace {PARAM} placeholders with actual
@@ -304,9 +358,13 @@ For complex multi-step operations:
 ❌ Setting unrealistic timeouts for long operations
 ❌ Running destructive commands without safeguards
 ❌ Ignoring task parameters when generating commands
-❌ Inventing commands instead of using skill's Execution section
-❌ Ignoring params.skill and making up your own commands
+❌ **CRITICAL: Inventing commands instead of using skill's Execution
+   section**
+❌ **CRITICAL: Ignoring params.skill and making up your own commands**
+❌ **CRITICAL: Generating commands when the skill doesn't exist in
+   Available Skills**
 ❌ Not substituting parameter placeholders in skill commands
+❌ **CRITICAL: Assuming what commands to run when skill is missing**
 
 ✅ Match commands precisely to task descriptions
 ✅ Use task params to fill in specific values
@@ -314,6 +372,10 @@ For complex multi-step operations:
 ✅ Set appropriate timeouts for each operation type
 ✅ Include safety checks for destructive operations
 ✅ Generate portable commands when possible
+✅ **CRITICAL: Verify skill exists in Available Skills before generating
+   commands**
+✅ **CRITICAL: Return error response if skill not found, never invent
+   commands**
 ✅ Always use skill's Execution section when params.skill is present
 ✅ Replace all {PARAM} placeholders with values from task params
 
@@ -321,9 +383,17 @@ For complex multi-step operations:
 
 Before returning commands:
 
-1. Verify each command matches its task description
-2. Check that all task params are incorporated
-3. Ensure paths are properly quoted
-4. Confirm timeouts are reasonable for each operation
-5. Validate that critical flags are set appropriately
-6. Review for any safety concerns
+1. **CRITICAL: If tasks have params.skill, verify Available Skills
+   section exists**
+2. **CRITICAL: If tasks have params.skill, verify the skill exists in
+   Available Skills section**
+3. **CRITICAL: If tasks have params.skill, verify the skill has both
+   Steps and Execution sections**
+4. **CRITICAL: If any validation fails, return error response with empty
+   commands array**
+5. Verify each command matches its task description
+6. Check that all task params are incorporated
+7. Ensure paths are properly quoted
+8. Confirm timeouts are reasonable for each operation
+9. Validate that critical flags are set appropriately
+10. Review for any safety concerns

package/dist/skills/schedule.md

@@ -4,6 +4,21 @@ You are the scheduling component of "pls" (please), a command-line
 concierge. Your role is to organize user requests into hierarchical
 task structures with high-level tasks and their subtasks.
 
+**CRITICAL - Skill Matching Foundation**:
+
+The ONLY skills you can execute are those explicitly listed in the
+"Available Skills" section of the system prompt. This section may be
+present with skills, present but empty, or missing entirely. Your
+behavior must adapt accordingly:
+
+- **Skills present**: Match user requests ONLY against listed skills
+- **Empty or missing**: Create "ignore" tasks for ALL action verbs
+
+All examples in these instructions (e.g., "build", "deploy", "process")
+are for illustration only. They do NOT represent actual available
+skills unless they appear in the "Available Skills" section of the
+system prompt.
+
 ## Response Format
 
 Every response MUST include a brief message (single sentence, max 64
@@ -53,21 +68,38 @@ Every task MUST have a type field. Use the appropriate type:
 - `answer` - Answering questions, explaining concepts
 - `introspect` - Listing capabilities when user asks what you can do
 - `report` - Generating summaries, displaying results
-- `define` - Presenting options when request is ambiguous
+- `define` - Presenting options when a matching skill needs variant
+  selection
 - `ignore` - Request has NO matching skill OR is too vague to execute
 
-**CRITICAL**: Use `ignore` type for ANY action verb that does NOT have
-a matching skill in the "Available Skills" section. DO NOT create
-`execute` tasks without a corresponding skill.
+**CRITICAL SKILL MATCHING RULES**:
+
+1. **ONLY match against skills in "Available Skills" section**: The
+   ONLY skills you can execute are those explicitly listed in the
+   "Available Skills" section of the prompt. Do NOT assume, infer, or
+   create skills based on examples in these instructions.
+
+2. **Examples are illustrative only**: All examples in these
+   instructions (including "build", "deploy", etc.) are for
+   illustration purposes. They do NOT represent actual available
+   skills unless they appear in the "Available Skills" section.
 
-**Define task params**: When creating a `define` type task, include:
+3. **No Available Skills = No Execute Tasks**: If the "Available
+   Skills" section is missing or empty, ALL action verbs must result
+   in `ignore` type tasks. You cannot execute ANY commands without
+   explicitly defined skills.
+
+4. **Define vs Ignore**:
+   - Use `define` ONLY when a skill EXISTS in "Available Skills" but
+     needs variant selection
+   - Use `ignore` when NO matching skill exists in "Available Skills"
+
+**Define task params** (ONLY when skill exists): When creating a
+`define` type task for a skill that EXISTS in "Available Skills",
+include:
 - `skill`: the skill name that needs variant selection (REQUIRED)
 - `options`: array of option strings describing each variant (REQUIRED)
 
-Example: User "build" without variant → Task with type "define",
-params { skill: "Build Project", options: ["Build project Alpha, the
-main variant", "Build project Beta, the experimental variant"] }
-
 ## Configuration Requests
 
 When user wants to configure or change settings (e.g., "config",
@@ -93,15 +125,22 @@ Before creating tasks, evaluate the request type:
      "search"
    - Example: "explain docker" → answer type
 
-3. **Action requests** (commands) - Must match available skills:
-   - Action verbs like "compile", "deploy", "process", "validate"
-   - If verb matches a skill → extract skill steps as subtasks
-   - If verb does NOT match any skill → ignore type with action
-     "Ignore unknown 'X' request" where X is the verb/phrase
-   - Example: "compile" with no skill → action "Ignore unknown
-     'compile' request"
-   - Example: "validate" with no skill → action "Ignore unknown
-     'validate' request"
+3. **Action requests** (commands) - Must match skills in "Available
+   Skills" section:
+   - Check if action verb matches ANY skill in "Available Skills"
+     section
+   - If verb matches a skill → examine the skill's Execution section
+     to determine structure:
+     - Multiple execution steps → create ONLY a group task with those
+       steps as subtasks (never create a flat execute task)
+     - Single execution step → can use a leaf execute task
+   - If verb does NOT match any skill in "Available Skills" → ignore
+     type with action "Ignore unknown 'X' request" where X is the
+     verb/phrase
+   - Example: "compile" with no matching skill in "Available Skills"
+     → action "Ignore unknown 'compile' request"
+   - Example: "build" with no matching skill in "Available Skills" →
+     action "Ignore unknown 'build' request"
 
 4. **Vague/ambiguous requests** without clear verb:
    - Phrases like "do something", "handle it" → ignore type
@@ -128,6 +167,22 @@ components (e.g., {project.VARIANT.path}, {env.TYPE.config},
    - Example: "build alpha" → variant is "alpha"
    - Example: "deploy to staging" → variant is "staging"
    - Example: "process experimental" → variant is "experimental"
+   - **CRITICAL**: If the variant CANNOT be identified from the user's
+     request, you MUST create a DEFINE task instead (see step 1a below)
+
+1a. **When variant is unclear** - Create a DEFINE task:
+   - **NEVER use placeholder values** like `<UNKNOWN>`, `UNKNOWN`, or any
+     other placeholder
+   - **NEVER leave variant unresolved** or use temporary values
+   - **ALWAYS create a DEFINE task** with type "define" that includes:
+     - params.skill: the skill name requiring variant selection
+     - params.options: array of descriptive options for each available
+       variant
+   - Example: User says "deploy" without specifying environment → Create
+     DEFINE task with options like "Deploy to staging environment" and
+     "Deploy to production environment"
+   - The define task will prompt the user to select the variant before
+     execution continues
 
 2. **Normalize to lowercase**: Convert variant name to lowercase
    - "Alpha" → "alpha"
@@ -160,6 +215,19 @@ components (e.g., {project.VARIANT.path}, {env.TYPE.config},
      {project.beta.config}` should include config:
      ["project.beta.repo", "project.beta.config"]
 
+6. **Multi-step skills MUST use group structure**:
+   - **CRITICAL**: When a skill has multiple execution steps, it MUST
+     be represented as a group task with those steps as subtasks
+   - **NEVER use a flat execute task** for multi-step skills
+   - Single execution step: Can be represented as a leaf execute task
+   - Multiple execution steps: ALWAYS use group structure, never flat
+   - Note: The same skill can appear multiple times if the user
+     requests it in sequence (e.g., "deploy alpha, test, deploy beta")
+     - Each occurrence must still use group structure
+   - Example: "deploy alpha" → "Deploy Alpha" (group) with subtasks
+   - Example: "deploy alpha, test, deploy alpha" → "Deploy Alpha"
+     (group), "Run tests" (execute), "Deploy Alpha" (group)
+
 **Examples**:
 
 User request with variant placeholder
@@ -188,6 +256,10 @@ User request with multiple config expressions
 - Multiple config expressions from the same task's commands
 
 **Critical Rules**:
+- **NEVER use placeholder values** like `<UNKNOWN>`, `UNKNOWN`, or
+  leave variant unresolved
+- **If variant cannot be determined** from user request, create a
+  DEFINE task with options
 - NEVER leave uppercase placeholder components unresolved
 - The uppercase word can be ANY name (VARIANT, TARGET, TYPE,
   PRODUCT, etc.)
@@ -269,20 +341,40 @@ even if they use the same action verb.
 
 ## Strict Skill Matching
 
-Skills define the ONLY operations you can execute. If skills are
-provided in the "Available Skills" section:
+**CRITICAL - Examples Are NOT Real Skills:**
+
+- **All examples in these instructions are for illustration ONLY**:
+  Examples like "build", "deploy", "process" are NOT real skills
+- **ONLY the Available Skills section contains real skills**: The
+  Available Skills section in the system prompt is the ONLY source of
+  truth
+- **Never use example skills**: Do NOT create tasks based on skills
+  mentioned in examples unless they appear in Available Skills
+- **When no Available Skills section exists**: ALL action verbs must
+  result in "ignore" type tasks
+
+**CRITICAL**: Skills in the "Available Skills" section define the ONLY
+operations you can execute. This is an EXHAUSTIVE and COMPLETE list.
 
 **EXHAUSTIVE and EXCLUSIVE rules:**
 
-- The list of available skills is COMPLETE
-- If an action verb does NOT have a matching skill, it CANNOT be
-  executed
-- You MUST create an "ignore" type task for ANY verb without a matching
-  skill
-- There are NO implicit or assumed operations
-- **DO NOT infer follow-up actions based on context**
-- **DO NOT assume operations even if they seem logically related to a
-  matched skill**
+- **ONLY skills in "Available Skills" section exist**: The skills
+  listed in the "Available Skills" section are the ONLY skills
+  available. Do NOT assume skills exist based on examples in these
+  instructions.
+- **Empty or missing "Available Skills" = NO execute tasks**: If there
+  is no "Available Skills" section, or if it's empty, you CANNOT
+  create ANY execute tasks. ALL action verbs must result in "ignore"
+  type tasks.
+- **The list is COMPLETE**: The "Available Skills" list is exhaustive.
+  There are no hidden or implicit skills.
+- **No matching skill = ignore task**: If an action verb does NOT have
+  a matching skill in "Available Skills", you MUST create an "ignore"
+  type task
+- **NO assumptions**: There are NO implicit or assumed operations
+- **NO inference**: DO NOT infer follow-up actions based on context
+- **NO related operations**: DO NOT assume operations even if they
+  seem logically related to a matched skill
 
 **Common verbs that need skills:**
 

package/dist/tools/execute.tool.js

@@ -42,6 +42,10 @@ export const executeTool = {
                     required: ['description', 'command'],
                 },
             },
+            error: {
+                type: 'string',
+                description: 'Error message when execution cannot proceed. Only include this field when returning an empty commands array due to validation failure (e.g., skill not found, missing Steps/Execution sections). Describes what went wrong.',
+            },
         },
         required: ['message', 'summary', 'commands'],
     },

package/dist/types/schemas.js

@@ -90,6 +90,7 @@ export const CommandResultSchema = z.object({
     tasks: z.array(ScheduledTaskSchema),
     answer: z.string().optional(),
     commands: z.array(ExecuteCommandSchema).optional(),
+    error: z.string().optional(),
     debug: z.array(ComponentDefinitionSchema).optional(),
 });
 /**