prompt-language-shell 0.8.6 → 0.8.8

package/dist/execution/processing.js

@@ -30,6 +30,7 @@ export async function processTasks(tasks, service) {
         message: result.message,
         summary: result.summary || '',
         commands: resolvedCommands,
+        error: result.error,
         debug: result.debug,
     };
 }

package/dist/services/anthropic.js

@@ -167,6 +167,7 @@ export class AnthropicService {
                 summary: input.summary,
                 tasks: [],
                 commands: input.commands,
+                error: input.error,
                 debug,
             });
             if (!validation.success) {

package/dist/services/colors.js

@@ -1,13 +1,16 @@
 import { DebugLevel } from '../configuration/types.js';
 import { FeedbackType, Origin, TaskType } from '../types/types.js';
 import { ExecutionStatus } from './shell.js';
+import { ComponentStatus } from '../types/components.js';
 /**
  * Base color palette - raw color values with descriptive names.
  * All colors used in the interface are defined here.
  */
 export const Palette = {
     White: '#ffffff',
+    SoftWhite: '#fafafa',
     AshGray: '#d0d0d0',
+    LightGray: '#aaaaaa',
     Gray: '#888888',
     DarkGray: '#666666',
     CharcoalGray: '#282828',
@@ -32,6 +35,7 @@ export const Palette = {
 export const Colors = {
     Text: {
         Active: Palette.White,
+        Pending: Palette.SoftWhite,
         Inactive: Palette.AshGray,
         UserQuery: Palette.White,
     },
@@ -148,12 +152,18 @@ const originColors = {
  * - Colors.Text.Active for current items
  * - Colors.Text.Inactive (undefined) for historical items
  */
-function processColor(color, isCurrent) {
-    return color === null
-        ? isCurrent
-            ? Colors.Text.Active
-            : Colors.Text.Inactive
-        : color;
+function processColor(color, status) {
+    const getColor = () => {
+        switch (status) {
+            case ComponentStatus.Active:
+                return Colors.Text.Active;
+            case ComponentStatus.Pending:
+                return Colors.Text.Pending;
+            default:
+                return Colors.Text.Inactive;
+        }
+    };
+    return color || getColor();
 }
 /**
  * Get task colors with current/historical state handling.
@@ -162,11 +172,11 @@ function processColor(color, isCurrent) {
  * - Colors.Text.Inactive (undefined) for historical items
  * - Colors.Text.Active for current items
  */
-export function getTaskColors(type, isCurrent) {
+export function getTaskColors(type, status) {
     const colors = taskColors[type];
     return {
-        description: processColor(colors.description, isCurrent),
-        type: processColor(colors.type, isCurrent),
+        description: processColor(colors.description, status),
+        type: processColor(colors.type, status),
     };
 }
 /**
@@ -176,8 +186,8 @@ export function getTaskColors(type, isCurrent) {
  * - Colors.Text.Inactive (undefined) for historical items
  * - Colors.Text.Active for current items
  */
-export function getFeedbackColor(type, isCurrent) {
-    return processColor(feedbackColors[type], isCurrent);
+export function getFeedbackColor(type, status = ComponentStatus.Done) {
+    return processColor(feedbackColors[type], status);
 }
 /**
  * Get color for capability origin.

package/dist/services/messages.js

@@ -147,3 +147,24 @@ export function formatErrorMessage(error) {
     }
     return rawMessage;
 }
+/**
+ * Returns an execution error message with varied phrasing.
+ * Randomly selects from variations to sound natural, like a concierge.
+ * Format: "[Cannot execute phrase]. [Error details]."
+ */
+export function getExecutionErrorMessage(error) {
+    const prefixes = [
+        "I can't execute this",
+        "I'm unable to execute this",
+        "I can't proceed with this",
+        "I'm unable to proceed with this",
+        'This cannot be executed',
+    ];
+    const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
+    // Capitalize first letter of error
+    const capitalizedError = error.charAt(0).toUpperCase() + error.slice(1);
+    const errorWithPeriod = capitalizedError.endsWith('.')
+        ? capitalizedError
+        : `${capitalizedError}.`;
+    return `${prefix}. ${errorWithPeriod}`;
+}

package/dist/services/refinement.js

@@ -1,3 +1,4 @@
+import { TaskType } from '../types/types.js';
 import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
@@ -17,6 +18,10 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
             .map((task) => {
             const action = task.action.toLowerCase().replace(/,/g, ' -');
             const type = task.type;
+            // For execute/group tasks, use generic hint - let LLM decide based on skill
+            if (type === TaskType.Execute || type === TaskType.Group) {
+                return `${action} (shell execution)`;
+            }
             return `${action} (type: ${type})`;
         })
             .join(', ');

package/dist/services/router.js

@@ -101,6 +101,60 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
         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 = [];
@@ -197,37 +251,7 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, workflowHan
         }));
     }
     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}`;
-                });
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
-            }
-            else if (validation.missingConfig.length > 0) {
-                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    requestHandlers.onError(error);
-                }, () => {
-                    workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
-                }, (operation) => {
-                    requestHandlers.onAborted(operation);
-                }));
-            }
-            else {
-                workflowHandlers.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);
-            workflowHandlers.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(),
 });
 /**

package/dist/ui/Config.js

@@ -201,11 +201,15 @@ export function Config(props) {
                 selectedIndex,
             };
             requestHandlers.onCompleted(finalState);
+            // Abort configuration
             if (onAborted) {
+                // Let Workflow handler complete and add feedback
                 onAborted('configuration');
             }
-            // Complete with abort feedback
-            lifecycleHandlers.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            else {
+                // Fallback: complete with abort feedback directly
+                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            }
             return;
         }
         // Handle selection step navigation

package/dist/ui/Execute.js

@@ -4,13 +4,14 @@ import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.js';
+import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { buildAbortedState, handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
 import { processTasks } from '../execution/processing.js';
 import { executeReducer, initialState } from '../execution/reducer.js';
 import { ExecuteActionType } from '../execution/types.js';
+import { createMessage, markAsDone } from '../services/components.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
 import { Task } from './Task.js';
@@ -101,6 +102,26 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
                     workflowHandlers.addToTimeline(...result.debug);
                 }
                 if (result.commands.length === 0) {
+                    // Check if this is an error response (has error field)
+                    if (result.error) {
+                        // Add error message to timeline
+                        const errorMessage = getExecutionErrorMessage(result.error);
+                        workflowHandlers.addToTimeline(markAsDone(createMessage(errorMessage)));
+                        // Complete without error in state (message already in timeline)
+                        const finalState = {
+                            message: result.message,
+                            summary: '',
+                            taskInfos: [],
+                            completed: 0,
+                            taskExecutionTimes: [],
+                            completionMessage: null,
+                            error: null,
+                        };
+                        requestHandlers.onCompleted(finalState);
+                        lifecycleHandlers.completeActive();
+                        return;
+                    }
+                    // No commands and no error - just complete
                     dispatch({
                         type: ExecuteActionType.ProcessingComplete,
                         payload: { message: result.message },

package/dist/ui/Feedback.js

@@ -1,5 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { ComponentStatus } from '../types/components.js';
 import { FeedbackType } from '../types/types.js';
 import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
@@ -12,7 +13,7 @@ function getSymbol(type) {
     }[type];
 }
 export function Feedback({ type, message }) {
-    const color = getFeedbackColor(type, false);
+    const color = getFeedbackColor(type, ComponentStatus.Done);
     const symbol = getSymbol(type);
     return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
 }

package/dist/ui/Label.js

@@ -3,7 +3,8 @@ import { Box, Text } from 'ink';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
 import { DebugLevel } from '../configuration/types.js';
 import { Separator } from './Separator.js';
-export function Label({ description, taskType, showType = false, isCurrent = false, debug = DebugLevel.None, }) {
-    const colors = getTaskColors(taskType, isCurrent);
+import { ComponentStatus } from '../types/components.js';
+export function Label({ description, taskType, showType = false, status = ComponentStatus.Done, debug = DebugLevel.None, }) {
+    const colors = getTaskColors(taskType, status);
     return (_jsxs(Box, { children: [_jsx(Text, { color: colors.description, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: colors.type, children: getTaskTypeLabel(taskType, debug) })] }))] }));
 }

package/dist/ui/List.js

@@ -4,7 +4,8 @@ import { Palette } from '../services/colors.js';
 import { Separator } from './Separator.js';
 export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
     const marginLeft = level > 0 ? 2 : 0;
-    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
+    const gap = level === 0 ? 1 : 0;
+    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, gap: gap, children: items.map((item, index) => {
             // At level 0, track which parent is active for child highlighting
             // At level > 0, only highlight if this parent is the active one
             const shouldHighlightChildren = level === 0 ? highlightedParentIndex === index : false;
@@ -23,6 +24,6 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
                 (isHighlighted && item.type.highlightedColor
                     ? item.type.highlightedColor
                     : Palette.White);
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Text, { color: descriptionColor, children: item.description.text }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: item.type.text })] }))] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Text, { color: descriptionColor, children: item.description.text }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: item.type.text })] }))] }), item.children && item.children.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }) }))] }, index));
         }) }));
 };

package/dist/ui/Schedule.js

@@ -3,17 +3,22 @@ import { useEffect, useState } from 'react';
 import { Box } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
-import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
+import { getTaskColors, getTaskTypeLabel, Palette, } from '../services/colors.js';
 import { DebugLevel } from '../configuration/types.js';
 import { useInput } from '../services/keyboard.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
-function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, isCurrent = false, debug = DebugLevel.None) {
-    const taskColors = getTaskColors(task.type, isCurrent);
+export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, status = ComponentStatus.Done, debug = DebugLevel.None) {
+    const taskColors = getTaskColors(task.type, status);
+    // Determine description color based on status
+    let descriptionColor = taskColors.description;
+    if (status === ComponentStatus.Pending) {
+        descriptionColor = Palette.SoftWhite;
+    }
     const item = {
         description: {
             text: task.action,
-            color: taskColors.description,
+            color: descriptionColor,
         },
         type: { text: getTaskTypeLabel(task.type, debug), color: taskColors.type },
         children: [],
@@ -21,7 +26,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     // Mark define tasks with right arrow when no selection has been made
     if (isDefineTaskWithoutSelection) {
         item.marker = '  → ';
-        item.markerColor = getTaskColors(TaskType.Schedule, isCurrent).type;
+        item.markerColor = getTaskColors(TaskType.Schedule, status).type;
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
@@ -33,8 +38,8 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
                 childType =
                     index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
             }
-            const colors = getTaskColors(childType, isCurrent);
-            const planColors = getTaskColors(TaskType.Schedule, isCurrent);
+            const colors = getTaskColors(childType, status);
+            const planColors = getTaskColors(TaskType.Schedule, status);
             return {
                 description: {
                     text: option,
@@ -56,11 +61,11 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
         Array.isArray(scheduledTask.subtasks) &&
         scheduledTask.subtasks.length > 0) {
         item.children = scheduledTask.subtasks.map((subtask) => {
-            const subtaskColors = getTaskColors(subtask.type, isCurrent);
+            const subtaskColors = getTaskColors(subtask.type, status);
             return {
                 description: {
                     text: subtask.action,
-                    color: subtaskColors.description,
+                    color: Palette.AshGray,
                 },
                 type: {
                     text: getTaskTypeLabel(subtask.type, debug),
@@ -107,9 +112,9 @@ export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel
             defineGroupIndex === currentDefineGroupIndex &&
             highlightedIndex === null &&
             isActive;
-        return taskToListItem(task, childIndex, isDefineWithoutSelection, isActive, debug);
+        return taskToListItem(task, childIndex, isDefineWithoutSelection, status, debug);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, isCurrent: isActive, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
 };
 /**
  * Schedule controller: Manages task selection and navigation

package/dist/ui/Workflow.js

@@ -47,12 +47,9 @@ export const Workflow = ({ initialQueue, debug }) => {
         },
         onAborted: (operation) => {
             moveActiveToTimeline();
-            // Add feedback to queue
+            // Clear queue and add only feedback to prevent subsequent components from executing
             const message = getCancellationMessage(operation);
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Aborted, message),
-            ]);
+            setQueue([createFeedback(FeedbackType.Aborted, message)]);
         },
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
         onCompleted: (finalState) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",