prompt-language-shell 0.9.2 → 0.9.6

package/dist/services/parser.js

@@ -1,12 +1,11 @@
 import YAML from 'yaml';
 import { displayWarning } from './logger.js';
 /**
- * Validate a skill without parsing it fully
+ * Validate extracted sections from a skill
  * Returns validation error if skill is invalid, null if valid
  * Note: Name section is optional - key from filename is used as fallback
  */
-export function validateSkillStructure(content, key) {
-    const sections = extractSections(content);
+function validateSections(sections, key) {
     // Use key for error reporting if name not present
     const skillName = sections.name || key;
     // Check required sections (Name is now optional)
@@ -37,6 +36,15 @@ export function validateSkillStructure(content, key) {
     }
     return null;
 }
+/**
+ * Validate a skill without parsing it fully
+ * Returns validation error if skill is invalid, null if valid
+ * Note: Name section is optional - key from filename is used as fallback
+ */
+export function validateSkillStructure(content, key) {
+    const sections = extractSections(content);
+    return validateSections(sections, key);
+}
 /**
  * Convert kebab-case key to Title Case display name
  * Examples: "deploy-app" -> "Deploy App", "build-project-2" -> "Build Project 2"
@@ -64,8 +72,8 @@ export function parseSkillMarkdown(key, content) {
     const sections = extractSections(content);
     // Determine display name: prefer Name section, otherwise derive from key
     const displayName = sections.name || keyToDisplayName(key);
-    // Validate the skill (Name is no longer required since we have key)
-    const validationError = validateSkillStructure(content, key);
+    // Validate using already-extracted sections (avoids re-parsing)
+    const validationError = validateSections(sections, key);
     // For invalid skills, return minimal definition with error
     if (validationError) {
         return {

package/dist/services/refinement.js

@@ -1,5 +1,6 @@
+import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
-import { createRefinement } from './components.js';
+import { createCommand, createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
 /**
@@ -7,6 +8,11 @@ import { routeTasksWithConfirm } from './router.js';
  * Called when user selects options from a plan with DEFINE tasks
  */
 export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
+    // Display the resolved command (from user's selection)
+    // The first task's action contains the full resolved command
+    const resolvedCommand = selectedTasks[0]?.action || originalCommand;
+    const commandDisplay = createCommand({ command: resolvedCommand, service, onAborted: requestHandlers.onAborted }, ComponentStatus.Done);
+    workflowHandlers.addToTimeline(commandDisplay);
     // Create and add refinement component to queue
     const refinementDef = createRefinement({
         text: getRefiningMessage(),
@@ -19,7 +25,7 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         // Build refined command from selected tasks
         const refinedCommand = selectedTasks
             .map((task) => {
-            const action = task.action.toLowerCase().replace(/,/g, ' -');
+            const action = task.action.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) {

package/dist/services/router.js

@@ -5,9 +5,74 @@ import { getConfigSchema } from '../configuration/schema.js';
 import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
 import { saveConfigLabels } from '../configuration/labels.js';
-import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createMessage, createSchedule, createValidate, } from './components.js';
-import { getCancellationMessage, getConfirmationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createSchedule, createValidate, } from './components.js';
+import { getCancellationMessage, getConfirmationMessage, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
+/**
+ * Flatten inner task structure completely - removes all nested groups.
+ * Used internally to flatten subtasks within a top-level group.
+ */
+function flattenInnerTasks(tasks) {
+    const result = [];
+    for (const task of tasks) {
+        if (task.type === TaskType.Group &&
+            task.subtasks &&
+            task.subtasks.length > 0) {
+            // Recursively flatten inner group
+            result.push(...flattenInnerTasks(task.subtasks));
+        }
+        else if (task.type !== TaskType.Group) {
+            // Leaf task - add as-is
+            const leafTask = {
+                action: task.action,
+                type: task.type,
+            };
+            if (task.params)
+                leafTask.params = task.params;
+            if (task.config)
+                leafTask.config = task.config;
+            result.push(leafTask);
+        }
+        // Skip empty groups
+    }
+    return result;
+}
+/**
+ * Flatten hierarchical task structure, preserving top-level groups.
+ * Top-level groups are kept with their subtasks flattened.
+ * Inner nested groups are removed and their subtasks extracted recursively.
+ */
+export function flattenTasks(tasks) {
+    const result = [];
+    for (const task of tasks) {
+        if (task.type === TaskType.Group &&
+            task.subtasks &&
+            task.subtasks.length > 0) {
+            // Preserve top-level group but flatten its subtasks
+            const flattenedSubtasks = flattenInnerTasks(task.subtasks);
+            const groupTask = {
+                action: task.action,
+                type: task.type,
+                subtasks: flattenedSubtasks,
+            };
+            result.push(groupTask);
+        }
+        else if (task.type !== TaskType.Group) {
+            // Non-group task - add as-is
+            const leafTask = {
+                action: task.action,
+                type: task.type,
+            };
+            if (task.params)
+                leafTask.params = task.params;
+            if (task.config)
+                leafTask.config = task.config;
+            result.push(leafTask);
+        }
+        // Skip empty groups (group with no subtasks)
+    }
+    return result;
+}
 /**
  * Determine the operation name based on task types
  */
@@ -31,8 +96,12 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     const validTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
-        const msg = createMessage({ text: getUnknownRequestMessage() });
-        workflowHandlers.addToQueue(msg);
+        // Use action from first ignore task if available, otherwise generic message
+        const ignoreTask = tasks.find((task) => task.type === TaskType.Ignore);
+        const message = ignoreTask?.action
+            ? `${ignoreTask.action}.`
+            : getUnknownRequestMessage();
+        workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Warning, message }));
         return;
     }
     const operation = getOperationName(validTasks);
@@ -80,61 +149,44 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     }
 }
 /**
- * Validate task types - allows mixed types at top level with Groups,
- * but each Group must have uniform subtask types
+ * Validate task structure after flattening.
+ * Currently no-op since flattening removes Groups and mixed types are allowed.
  */
-function validateTaskTypes(tasks) {
-    if (tasks.length === 0)
-        return;
-    // Convert to ScheduledTask to access subtasks property
-    const scheduledTasks = asScheduledTasks(tasks);
-    // Check each Group task's subtasks for uniform types
-    for (const task of scheduledTasks) {
-        if (task.type === TaskType.Group &&
-            task.subtasks &&
-            task.subtasks.length > 0) {
-            const subtaskTypes = new Set(task.subtasks.map((t) => t.type));
-            if (subtaskTypes.size > 1) {
-                throw new Error(getMixedTaskTypesError(Array.from(subtaskTypes)));
-            }
-            // Recursively validate nested groups
-            validateTaskTypes(task.subtasks);
-        }
-    }
+function validateTaskTypes(_tasks) {
+    // After flattening, Groups are removed and mixed leaf types are allowed.
+    // The router handles different task types by routing each to its handler.
 }
 /**
  * Execute tasks after confirmation (internal helper)
- * Validates task types and routes each type appropriately
- * Supports mixed types at top level with Groups
+ * Flattens hierarchical structure, validates task types, and routes appropriately
  */
 function executeTasksAfterConfirm(tasks, context) {
     const { service, userRequest, workflowHandlers, requestHandlers } = context;
-    // Validate task types (Groups must have uniform subtasks)
+    // Flatten hierarchical structure into flat list of leaf tasks
+    const scheduledTasks = asScheduledTasks(tasks);
+    const flatTasks = flattenTasks(scheduledTasks);
+    // Validate that all tasks have uniform type
     try {
-        validateTaskTypes(tasks);
+        validateTaskTypes(flatTasks);
     }
     catch (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) {
+    // Collect all Execute tasks for validation (including those inside groups)
+    const executeTasks = [];
+    for (const task of flatTasks) {
         if (task.type === TaskType.Execute) {
-            allExecuteTasks.push(task);
+            executeTasks.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);
-            }
+            executeTasks.push(...task.subtasks.filter((t) => t.type === TaskType.Execute));
         }
     }
-    // Validate ALL Execute tasks together to collect ALL missing config upfront
-    if (allExecuteTasks.length > 0) {
+    // Validate Execute tasks to collect missing config upfront
+    if (executeTasks.length > 0) {
         try {
-            const validation = validateExecuteTasks(allExecuteTasks);
+            const validation = validateExecuteTasks(executeTasks);
             if (validation.validationErrors.length > 0) {
                 // Show error feedback for invalid skills
                 const errorMessages = validation.validationErrors.map((error) => {
@@ -150,7 +202,7 @@ function executeTasksAfterConfirm(tasks, context) {
                 return;
             }
             else if (validation.missingConfig.length > 0) {
-                // Missing config detected - create ONE Validate component for ALL missing config
+                // Missing config detected - create Validate component for all missing config
                 workflowHandlers.addToQueue(createValidate({
                     missingConfig: validation.missingConfig,
                     userRequest,
@@ -160,7 +212,7 @@ function executeTasksAfterConfirm(tasks, context) {
                     },
                     onValidationComplete: () => {
                         // After config is complete, resume task routing
-                        routeTasksAfterConfig(scheduledTasks, context);
+                        routeTasksAfterConfig(flatTasks, context);
                     },
                     onAborted: (operation) => {
                         requestHandlers.onAborted(operation);
@@ -175,74 +227,117 @@ function executeTasksAfterConfirm(tasks, context) {
         }
     }
     // No missing config - proceed with normal routing
-    routeTasksAfterConfig(scheduledTasks, context);
+    routeTasksAfterConfig(flatTasks, context);
+}
+/**
+ * Task types that should appear in the upcoming display
+ */
+const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer, TaskType.Group];
+/**
+ * Collect action names for tasks that appear in upcoming display.
+ * Groups are included with their group name (not individual subtask names).
+ */
+function collectUpcomingNames(tasks) {
+    return tasks
+        .filter((t) => UPCOMING_TASK_TYPES.includes(t.type))
+        .map((t) => t.action);
 }
 /**
  * Route tasks after config is complete (or when no config is needed)
- * Processes tasks in order, grouping by type
+ * Processes task list, routing each task type to its handler.
+ * Top-level groups are preserved: their subtasks are routed with the group name.
+ * Config tasks are grouped together; Execute/Answer are routed individually.
  */
-function routeTasksAfterConfig(scheduledTasks, context) {
-    // Process tasks in order, preserving Group boundaries
-    // Track consecutive standalone tasks to group them by type
-    let consecutiveStandaloneTasks = [];
-    const processStandaloneTasks = () => {
-        if (consecutiveStandaloneTasks.length === 0)
-            return;
-        // Group consecutive standalone tasks by type
-        const tasksByType = {};
-        for (const type of Object.values(TaskType)) {
-            tasksByType[type] = [];
-        }
-        for (const task of consecutiveStandaloneTasks) {
-            tasksByType[task.type].push(task);
+function routeTasksAfterConfig(tasks, context) {
+    if (tasks.length === 0)
+        return;
+    // Collect all upcoming names for display (Execute, Answer, and Group tasks)
+    const allUpcomingNames = collectUpcomingNames(tasks);
+    let upcomingIndex = 0;
+    // Task types that should be grouped together (one component for all tasks)
+    const groupedTypes = [TaskType.Config, TaskType.Introspect];
+    // Route grouped task types together (collect from all tasks including subtasks)
+    for (const groupedType of groupedTypes) {
+        const typeTasks = [];
+        for (const task of tasks) {
+            if (task.type === groupedType) {
+                typeTasks.push(task);
+            }
+            else if (task.type === TaskType.Group && task.subtasks) {
+                typeTasks.push(...task.subtasks.filter((t) => t.type === groupedType));
+            }
         }
-        // Route each type group
-        for (const [type, typeTasks] of Object.entries(tasksByType)) {
-            const taskType = type;
-            if (typeTasks.length === 0)
-                continue;
-            routeTasksByType(taskType, typeTasks, context);
+        if (typeTasks.length > 0) {
+            routeTasksByType(groupedType, typeTasks, context, []);
         }
-        consecutiveStandaloneTasks = [];
-    };
-    // Process tasks in original order
-    for (const task of scheduledTasks) {
-        if (task.type === TaskType.Group && task.subtasks) {
-            // Process any accumulated standalone tasks first
-            processStandaloneTasks();
-            // Process Group as separate component
-            if (task.subtasks.length > 0) {
-                const subtasks = task.subtasks;
-                const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, context);
+    }
+    // Process Execute, Answer, and Group tasks individually (with upcoming support)
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        const taskType = task.type;
+        // Skip grouped task types (already routed above)
+        if (groupedTypes.includes(taskType))
+            continue;
+        if (taskType === TaskType.Group && task.subtasks) {
+            // Route group's subtasks - Execute tasks get group label, others routed normally
+            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
+            upcomingIndex++;
+            // Separate subtasks by type
+            const executeSubtasks = task.subtasks.filter((t) => t.type === TaskType.Execute);
+            const answerSubtasks = task.subtasks.filter((t) => t.type === TaskType.Answer);
+            // Route Execute subtasks with group name as label
+            if (executeSubtasks.length > 0) {
+                routeExecuteTasks(executeSubtasks, context, upcoming, task.action);
+            }
+            // Route Answer subtasks individually
+            if (answerSubtasks.length > 0) {
+                routeAnswerTasks(answerSubtasks, context, upcoming);
             }
         }
+        else if (taskType === TaskType.Execute) {
+            // Calculate upcoming for this Execute task
+            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
+            upcomingIndex++;
+            routeExecuteTasks([task], context, upcoming);
+        }
+        else if (taskType === TaskType.Answer) {
+            // Calculate upcoming for this Answer task
+            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
+            upcomingIndex++;
+            routeTasksByType(taskType, [task], context, upcoming);
+        }
         else {
-            // Accumulate standalone task
-            consecutiveStandaloneTasks.push(task);
+            // For other types (Report, etc.), route without upcoming
+            routeTasksByType(taskType, [task], context, []);
         }
     }
-    // Process any remaining standalone tasks
-    processStandaloneTasks();
 }
 /**
  * Route Answer tasks - creates separate Answer component for each question
  */
-function routeAnswerTasks(tasks, context) {
-    for (const task of tasks) {
-        context.workflowHandlers.addToQueue(createAnswer({ question: task.action, service: context.service }));
+function routeAnswerTasks(tasks, context, upcoming) {
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        // Calculate upcoming: remaining answer tasks + original upcoming
+        const remainingAnswers = tasks.slice(i + 1).map((t) => t.action);
+        const taskUpcoming = [...remainingAnswers, ...upcoming];
+        context.workflowHandlers.addToQueue(createAnswer({
+            question: task.action,
+            service: context.service,
+            upcoming: taskUpcoming,
+        }));
     }
 }
 /**
  * Route Introspect tasks - creates single Introspect component for all tasks
  */
-function routeIntrospectTasks(tasks, context) {
+function routeIntrospectTasks(tasks, context, _upcoming) {
     context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
 }
 /**
  * Route Config tasks - extracts keys, caches labels, creates Config component
  */
-function routeConfigTasks(tasks, context) {
+function routeConfigTasks(tasks, context, _upcoming) {
     const configKeys = tasks
         .map((task) => task.params?.key)
         .filter((key) => key !== undefined);
@@ -286,8 +381,8 @@ function routeConfigTasks(tasks, context) {
 /**
  * Route Execute tasks - creates Execute component (validation already done)
  */
-function routeExecuteTasks(tasks, context) {
-    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service }));
+function routeExecuteTasks(tasks, context, upcoming, label) {
+    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service, upcoming, label }));
 }
 /**
  * Registry mapping task types to their route handlers
@@ -302,9 +397,9 @@ const taskRouteHandlers = {
  * Route tasks by type to appropriate components
  * Uses registry pattern for extensibility
  */
-function routeTasksByType(taskType, tasks, context) {
+function routeTasksByType(taskType, tasks, context, upcoming) {
     const handler = taskRouteHandlers[taskType];
     if (handler) {
-        handler(tasks, context);
+        handler(tasks, context, upcoming);
     }
 }

package/dist/services/shell.js

@@ -61,6 +61,14 @@ export class DummyExecutor {
 }
 // Marker for extracting pwd from command output
 const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
+const MAX_OUTPUT_LINES = 128;
+/**
+ * Limit output to last MAX_OUTPUT_LINES lines.
+ */
+function limitLines(output) {
+    const lines = output.split('\n');
+    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
+}
 /**
  * Parse stdout to extract workdir and clean output.
  * Returns the cleaned output and the extracted workdir.
@@ -93,6 +101,12 @@ class OutputStreamer {
      */
     pushStdout(data) {
         this.chunks.push(data);
+        // Collapse when we have too many chunks to prevent memory growth
+        if (this.chunks.length > 16) {
+            const accumulated = this.chunks.join('');
+            this.chunks = [limitLines(accumulated)];
+            this.emittedLength = 0;
+        }
         if (!this.callback)
             return;
         const accumulated = this.chunks.join('');
@@ -123,7 +137,7 @@ class OutputStreamer {
      * Get the accumulated raw output.
      */
     getAccumulated() {
-        return this.chunks.join('');
+        return limitLines(this.chunks.join(''));
     }
 }
 /**
@@ -189,6 +203,13 @@ export class RealExecutor {
             child.stderr.on('data', (data) => {
                 const text = data.toString();
                 stderr.push(text);
+                // Collapse when we have too many chunks to prevent memory growth
+                if (stderr.length > 16) {
+                    const accumulated = stderr.join('');
+                    const limited = limitLines(accumulated);
+                    stderr.length = 0;
+                    stderr.push(limited);
+                }
                 this.outputCallback?.(text, 'stderr');
             });
             child.on('error', (error) => {
@@ -200,7 +221,7 @@ export class RealExecutor {
                     description: cmd.description,
                     command: cmd.command,
                     output: stdoutStreamer.getAccumulated(),
-                    errors: error.message,
+                    errors: limitLines(stderr.join('')) || error.message,
                     result: ExecutionResult.Error,
                     error: error.message,
                 };
@@ -218,7 +239,7 @@ export class RealExecutor {
                     description: cmd.description,
                     command: cmd.command,
                     output,
-                    errors: stderr.join(''),
+                    errors: limitLines(stderr.join('')),
                     result: success ? ExecutionResult.Success : ExecutionResult.Error,
                     error: success ? undefined : `Exit code: ${code}`,
                     workdir,
@@ -278,9 +299,8 @@ export async function executeCommands(commands, onProgress) {
                 : ExecutionStatus.Failed,
             output,
         });
-        // Stop if critical command failed
-        const isCritical = cmd.critical !== false;
-        if (output.result !== ExecutionResult.Success && isCritical) {
+        // Stop on failure
+        if (output.result !== ExecutionResult.Success) {
             break;
         }
     }

package/dist/services/skills.js

@@ -94,17 +94,47 @@ export function loadSkillDefinitions(fs = defaultFileSystem) {
     const skills = loadSkills(fs);
     return skills.map(({ key, content }) => parseSkillMarkdown(key, content));
 }
+/**
+ * Mark incomplete skill in markdown by appending (INCOMPLETE) to name
+ */
+function markIncompleteSkill(content) {
+    return content.replace(/^(#{1,6}\s+Name\s*\n+)(.+?)(\n|$)/im, `$1$2 (INCOMPLETE)$3`);
+}
+/**
+ * Load skills with both formatted prompt section and parsed definitions
+ * Single source of truth for both LLM prompts and debug display
+ * Parses each skill only once for efficiency
+ */
+export function loadSkillsForPrompt(fs = defaultFileSystem) {
+    const skills = loadSkills(fs);
+    // Parse each skill once and build both outputs
+    const definitions = [];
+    const markedContent = [];
+    for (const { key, content } of skills) {
+        const parsed = parseSkillMarkdown(key, content);
+        definitions.push(parsed);
+        // Mark incomplete skills in markdown for LLM
+        if (parsed.isIncomplete) {
+            markedContent.push(markIncompleteSkill(content));
+        }
+        else {
+            markedContent.push(content);
+        }
+    }
+    const formatted = formatSkillsForPrompt(markedContent);
+    return { formatted, definitions };
+}
 /**
  * Load skills and mark incomplete ones in their markdown
  * Returns array of skill markdown with status markers
+ * Uses loadSkillsForPrompt internally to avoid duplicating logic
  */
 export function loadSkillsWithValidation(fs = defaultFileSystem) {
     const skills = loadSkills(fs);
     return skills.map(({ key, content }) => {
         const parsed = parseSkillMarkdown(key, content);
-        // 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 markIncompleteSkill(content);
         }
         return content;
     });
@@ -127,6 +157,7 @@ export function createSkillLookup(definitions) {
 }
 /**
  * Format skills for inclusion in the planning prompt
+ * Skills are joined with double newlines (skill headers provide separation)
  */
 export function formatSkillsForPrompt(skills) {
     if (skills.length === 0) {
@@ -148,11 +179,8 @@ brackets for additional information. Use commas instead. For example:
 - WRONG: "Build project Alpha (the legacy version)"
 
 `;
-    const separator = '-'.repeat(64);
-    const skillsContent = skills
-        .map((s) => s.trim())
-        .join('\n\n' + separator + '\n\n');
-    return header + separator + '\n\n' + skillsContent;
+    const skillsContent = skills.map((s) => s.trim()).join('\n\n');
+    return header + skillsContent;
 }
 /**
  * Parse skill reference from execution line

package/dist/services/timing.js

@@ -1,6 +1,7 @@
 /**
  * Timing utilities for UI components
  */
+export const ELAPSED_UPDATE_INTERVAL = 250;
 /**
  * Waits for at least the minimum processing time.
  * Ensures async operations don't complete too quickly for good UX.

package/dist/skills/execute.md

@@ -139,6 +139,18 @@ Given tasks from this skill:
 Do NOT invent different commands - use exactly what the skill specifies,
 with parameter placeholders replaced by actual values.
 
+### Handling Skipped Steps
+
+**CRITICAL - STEP ORDER PRESERVATION**: When some steps from a skill are
+omitted during scheduling, you MUST maintain alignment with the
+original step positions in both the Steps and Execution sections. Each
+task corresponds to a specific line number in the skill definition, NOT
+to its sequential position in the task list. If you receive tasks for
+steps 1 and 3 (with step 2 skipped), use Execution lines 1 and 3
+(NOT lines 1 and 2). The step numbers in the task actions indicate
+which Execution line to use - always match by original position, never
+by sequential task index.
+
 **CRITICAL - VERBATIM EXECUTION**: Run shell commands EXACTLY as written in
 the ### Execution section. Do NOT:
 - Modify the command string in any way
@@ -180,7 +192,6 @@ Return a structured response with commands to execute:
 - **workdir**: Optional working directory for the command (defaults to
   current)
 - **timeout**: Optional timeout in milliseconds (defaults to 30000)
-- **critical**: Whether failure should stop execution (defaults to true)
 
 ## Command Generation Guidelines
 
@@ -364,14 +375,12 @@ commands:
 
 For complex multi-step operations:
 
-1. **Sequential dependencies**: Mark early commands as critical so failure
-   stops the chain
+1. **Sequential dependencies**: Commands execute in order; any failure stops
+   the chain
 2. **Long-running processes**: Set appropriate timeouts (build processes
    may need 10+ minutes)
 3. **Working directories**: Use workdir to ensure commands run in the
    right location
-4. **Error handling**: For non-critical cleanup steps, set critical:
-   false
 
 ## Handling Config Placeholders
 
@@ -444,8 +453,7 @@ Before returning commands:
 7. Check that all task params are incorporated
 8. Ensure paths are properly quoted
 9. Confirm timeouts are reasonable for each operation
-10. Validate that critical flags are set appropriately
-11. Review for any safety concerns
+10. Review for any safety concerns
 
 ## Confirmed Schedule