prompt-language-shell 0.8.8 → 0.9.0

package/dist/services/router.js

@@ -30,11 +30,18 @@ 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 message = createMessage(getUnknownRequestMessage());
-        workflowHandlers.addToQueue(message);
+        const msg = createMessage(getUnknownRequestMessage());
+        workflowHandlers.addToQueue(msg);
         return;
     }
     const operation = getOperationName(validTasks);
+    // Create routing context for downstream functions
+    const context = {
+        service,
+        userRequest,
+        workflowHandlers,
+        requestHandlers: requestHandlers,
+    };
     if (hasDefineTask) {
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
@@ -49,9 +56,9 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         const scheduleDefinition = createScheduleDefinition(message, validTasks, () => {
             // Schedule completed - add Confirm to queue
             const confirmDefinition = createConfirmDefinition(() => {
-                // User confirmed - complete both Confirm and Schedule, then route to appropriate component
+                // User confirmed - complete both Confirm and Schedule, then route
                 lifecycleHandlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, service, userRequest, workflowHandlers, requestHandlers);
+                executeTasksAfterConfirm(validTasks, context);
             }, () => {
                 // User cancelled - complete both Confirm and Schedule, then show cancellation
                 lifecycleHandlers.completeActiveAndPending();
@@ -91,7 +98,8 @@ function validateTaskTypes(tasks) {
  * Validates task types and routes each type appropriately
  * Supports mixed types at top level with Groups
  */
-function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers, requestHandlers) {
+function executeTasksAfterConfirm(tasks, context) {
+    const { service, userRequest, workflowHandlers, requestHandlers } = context;
     // Validate task types (Groups must have uniform subtasks)
     try {
         validateTaskTypes(tasks);
@@ -135,7 +143,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
                     requestHandlers.onError(error);
                 }, () => {
                     // After config is complete, resume task routing
-                    routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers);
+                    routeTasksAfterConfig(scheduledTasks, context);
                 }, (operation) => {
                     requestHandlers.onAborted(operation);
                 }));
@@ -148,13 +156,13 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
         }
     }
     // No missing config - proceed with normal routing
-    routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers);
+    routeTasksAfterConfig(scheduledTasks, context);
 }
 /**
  * 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) {
+function routeTasksAfterConfig(scheduledTasks, context) {
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -174,7 +182,7 @@ function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHan
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers);
+            routeTasksByType(taskType, typeTasks, context);
         }
         consecutiveStandaloneTasks = [];
     };
@@ -187,7 +195,7 @@ function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHan
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, service, userRequest, workflowHandlers, requestHandlers);
+                routeTasksByType(taskType, subtasks, context);
             }
         }
         else {
@@ -199,59 +207,81 @@ function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHan
     processStandaloneTasks();
 }
 /**
- * Route tasks by type to appropriate components
- * Extracted to allow reuse for both Groups and standalone tasks
+ * Route Answer tasks - creates separate Answer component for each question
+ */
+function routeAnswerTasks(tasks, context) {
+    for (const task of tasks) {
+        context.workflowHandlers.addToQueue(createAnswerDefinition(task.action, context.service));
+    }
+}
+/**
+ * Route Introspect tasks - creates single Introspect component for all tasks
  */
-function routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers) {
-    if (taskType === TaskType.Answer) {
-        // Create separate Answer component for each question
-        for (const task of typeTasks) {
-            workflowHandlers.addToQueue(createAnswerDefinition(task.action, service));
+function routeIntrospectTasks(tasks, context) {
+    context.workflowHandlers.addToQueue(createIntrospectDefinition(tasks, context.service));
+}
+/**
+ * Route Config tasks - extracts keys, caches labels, creates Config component
+ */
+function routeConfigTasks(tasks, context) {
+    const configKeys = tasks
+        .map((task) => task.params?.key)
+        .filter((key) => key !== undefined);
+    // 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 tasks) {
+        const key = task.params?.key;
+        if (key && task.action && !(key in schema)) {
+            labels[key] = task.action;
         }
     }
-    else if (taskType === TaskType.Introspect) {
-        workflowHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
+    if (Object.keys(labels).length > 0) {
+        saveConfigLabels(labels);
     }
-    else if (taskType === TaskType.Config) {
-        // Route to Config flow - extract keys and descriptions from task params
-        const configKeys = typeTasks
-            .map((task) => task.params?.key)
-            .filter((key) => key !== undefined);
-        // 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;
+    context.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
+            const configBySection = unflattenConfig(config);
+            // Save each section
+            for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                saveConfig(section, sectionConfig);
             }
         }
-        if (Object.keys(labels).length > 0) {
-            saveConfigLabels(labels);
+        catch (error) {
+            const errorMessage = error instanceof Error
+                ? error.message
+                : 'Failed to save configuration';
+            throw new Error(errorMessage);
         }
-        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
-                const configBySection = unflattenConfig(config);
-                // Save each section
-                for (const [section, sectionConfig] of Object.entries(configBySection)) {
-                    saveConfig(section, sectionConfig);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error
-                    ? error.message
-                    : 'Failed to save configuration';
-                throw new Error(errorMessage);
-            }
-        }, (operation) => {
-            requestHandlers.onAborted(operation);
-        }));
-    }
-    else if (taskType === TaskType.Execute) {
-        // Execute tasks (validation already happened upfront in executeTasksAfterConfirm)
-        workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
+    }, (operation) => {
+        context.requestHandlers.onAborted(operation);
+    }));
+}
+/**
+ * Route Execute tasks - creates Execute component (validation already done)
+ */
+function routeExecuteTasks(tasks, context) {
+    context.workflowHandlers.addToQueue(createExecuteDefinition(tasks, context.service));
+}
+/**
+ * Registry mapping task types to their route handlers
+ */
+const taskRouteHandlers = {
+    [TaskType.Answer]: routeAnswerTasks,
+    [TaskType.Introspect]: routeIntrospectTasks,
+    [TaskType.Config]: routeConfigTasks,
+    [TaskType.Execute]: routeExecuteTasks,
+};
+/**
+ * Route tasks by type to appropriate components
+ * Uses registry pattern for extensibility
+ */
+function routeTasksByType(taskType, tasks, context) {
+    const handler = taskRouteHandlers[taskType];
+    if (handler) {
+        handler(tasks, context);
     }
 }

package/dist/services/shell.js

@@ -1,3 +1,4 @@
+import { spawn } from 'child_process';
 export var ExecutionStatus;
 (function (ExecutionStatus) {
     ExecutionStatus["Pending"] = "pending";
@@ -58,18 +59,186 @@ export class DummyExecutor {
         });
     }
 }
+// Marker for extracting pwd from command output
+const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
 /**
- * Default executor uses DummyExecutor for development and testing.
- * To implement real shell execution, create a RealExecutor class that:
- * - Spawns process with cmd.command in shell mode using child_process.spawn()
- * - Sets working directory from cmd.workdir
- * - Handles cmd.timeout for command timeout
- * - Captures stdout and stderr streams
- * - Calls onProgress with Running/Success/Failed status
- * - Returns CommandOutput with actual stdout, stderr, exitCode
- * - Handles errors (spawn failures, timeouts, non-zero exit codes)
+ * Parse stdout to extract workdir and clean output.
+ * Returns the cleaned output and the extracted workdir.
  */
-const executor = new DummyExecutor();
+function parseWorkdir(rawOutput) {
+    const markerIndex = rawOutput.lastIndexOf(PWD_MARKER);
+    if (markerIndex === -1) {
+        return { output: rawOutput };
+    }
+    const output = rawOutput.slice(0, markerIndex).trimEnd();
+    const pwdPart = rawOutput.slice(markerIndex + PWD_MARKER.length).trim();
+    const lines = pwdPart.split('\n').filter((l) => l.trim());
+    const workdir = lines[0];
+    return { output, workdir };
+}
+/**
+ * Manages streaming output while filtering out the PWD marker.
+ * Buffers output to avoid emitting partial markers to the callback.
+ */
+class OutputStreamer {
+    chunks = [];
+    emittedLength = 0;
+    callback;
+    constructor(callback) {
+        this.callback = callback;
+    }
+    /**
+     * Add new stdout data and emit safe content to callback.
+     * Buffers data to avoid emitting partial PWD markers.
+     */
+    pushStdout(data) {
+        this.chunks.push(data);
+        if (!this.callback)
+            return;
+        const accumulated = this.chunks.join('');
+        const markerIndex = accumulated.indexOf(PWD_MARKER);
+        if (markerIndex !== -1) {
+            // Marker found - emit everything before it (trimmed)
+            this.emitUpTo(accumulated.slice(0, markerIndex).trimEnd().length);
+        }
+        else {
+            // No marker yet - emit all but buffer for potential partial marker
+            const bufferSize = PWD_MARKER.length + 5;
+            const safeLength = Math.max(this.emittedLength, accumulated.length - bufferSize);
+            this.emitUpTo(safeLength);
+        }
+    }
+    /**
+     * Emit content up to the specified length if there's new content.
+     */
+    emitUpTo(length) {
+        if (length > this.emittedLength && this.callback) {
+            const accumulated = this.chunks.join('');
+            const newContent = accumulated.slice(this.emittedLength, length);
+            this.callback(newContent, 'stdout');
+            this.emittedLength = length;
+        }
+    }
+    /**
+     * Get the accumulated raw output.
+     */
+    getAccumulated() {
+        return this.chunks.join('');
+    }
+}
+/**
+ * Real executor that spawns shell processes and captures output.
+ */
+export class RealExecutor {
+    outputCallback;
+    constructor(outputCallback) {
+        this.outputCallback = outputCallback;
+    }
+    /**
+     * Set or update the output callback
+     */
+    setOutputCallback(callback) {
+        this.outputCallback = callback;
+    }
+    execute(cmd, onProgress, _ = 0) {
+        return new Promise((resolve) => {
+            onProgress?.(ExecutionStatus.Running);
+            const stderr = [];
+            // Wrap command to capture final working directory
+            const wrappedCommand = `${cmd.command}; __exit=$?; echo ""; echo "${PWD_MARKER}"; pwd; exit $__exit`;
+            // Wrap spawn in try/catch to handle synchronous errors
+            let child;
+            try {
+                child = spawn(wrappedCommand, {
+                    shell: true,
+                    cwd: cmd.workdir || process.cwd(),
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to spawn process';
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: '',
+                    errors: errorMessage,
+                    result: ExecutionResult.Error,
+                    error: errorMessage,
+                };
+                onProgress?.(ExecutionStatus.Failed);
+                resolve(commandResult);
+                return;
+            }
+            // Handle timeout if specified
+            const SIGKILL_GRACE_PERIOD = 3000;
+            let timeoutId;
+            let killTimeoutId;
+            if (cmd.timeout && cmd.timeout > 0) {
+                timeoutId = setTimeout(() => {
+                    child.kill('SIGTERM');
+                    // Escalate to SIGKILL if process doesn't terminate
+                    killTimeoutId = setTimeout(() => {
+                        child.kill('SIGKILL');
+                    }, SIGKILL_GRACE_PERIOD);
+                }, cmd.timeout);
+            }
+            // Use OutputStreamer for buffered stdout streaming
+            const stdoutStreamer = new OutputStreamer(this.outputCallback);
+            child.stdout.on('data', (data) => {
+                stdoutStreamer.pushStdout(data.toString());
+            });
+            child.stderr.on('data', (data) => {
+                const text = data.toString();
+                stderr.push(text);
+                this.outputCallback?.(text, 'stderr');
+            });
+            child.on('error', (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (killTimeoutId)
+                    clearTimeout(killTimeoutId);
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: stdoutStreamer.getAccumulated(),
+                    errors: error.message,
+                    result: ExecutionResult.Error,
+                    error: error.message,
+                };
+                onProgress?.(ExecutionStatus.Failed);
+                resolve(commandResult);
+            });
+            child.on('close', (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (killTimeoutId)
+                    clearTimeout(killTimeoutId);
+                const success = code === 0;
+                const { output, workdir } = parseWorkdir(stdoutStreamer.getAccumulated());
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output,
+                    errors: stderr.join(''),
+                    result: success ? ExecutionResult.Success : ExecutionResult.Error,
+                    error: success ? undefined : `Exit code: ${code}`,
+                    workdir,
+                };
+                onProgress?.(success ? ExecutionStatus.Success : ExecutionStatus.Failed);
+                resolve(commandResult);
+            });
+        });
+    }
+}
+// Create real executor instance
+const realExecutor = new RealExecutor();
+// Default executor for production use
+const executor = realExecutor;
+/**
+ * Set a callback to receive command output in real-time
+ */
+export function setOutputCallback(callback) {
+    realExecutor.setOutputCallback(callback);
+}
 /**
  * Execute a single shell command
  */

package/dist/services/skills.js

@@ -1,5 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
+import { AppError, ErrorCode } from '../types/errors.js';
 import { defaultFileSystem } from './filesystem.js';
 import { displayWarning } from './logger.js';
 import { getUnknownSkillMessage } from './messages.js';
@@ -189,7 +190,7 @@ export function expandSkillReferences(execution, skillLookup, visited = new Set(
         }
         // Check for circular reference
         if (visited.has(skillName)) {
-            throw new Error(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`);
+            throw new AppError(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`, ErrorCode.CircularReference);
         }
         // Second: Match against skill name
         const skill = skillLookup(skillName);

package/dist/skills/answer.md

@@ -110,15 +110,17 @@ They enable cleaner, more reusable component logic.
 
 ## Common Mistakes to Avoid
 
-❌ Starting with "Here's the answer:" or "Let me explain:"
-❌ Exceeding 4 lines or 80 characters per line
-❌ Including unnecessary details
-❌ Using overly technical jargon without explanation
-❌ Repeating the question in the answer
-❌ Using citation tags like `<cite>` or any HTML/XML markup
-
-✅ Direct, concise answers
-✅ Proper line breaks at natural phrase boundaries
-✅ Essential information only
-✅ Clear, accessible language
-✅ Plain text only - no markup tags
+**DO NOT:**
+- Start with "Here's the answer:" or "Let me explain:"
+- Exceed 4 lines or 80 characters per line
+- Include unnecessary details
+- Use overly technical jargon without explanation
+- Repeat the question in the answer
+- Use citation tags like `<cite>` or any HTML/XML markup
+
+**DO:**
+- Give direct, concise answers
+- Use proper line breaks at natural phrase boundaries
+- Include essential information only
+- Use clear, accessible language
+- Use plain text only - no markup tags

package/dist/skills/execute.md

@@ -133,9 +133,26 @@ Given tasks from this skill:
 Do NOT invent different commands - use exactly what the skill specifies,
 with parameter placeholders replaced by actual values.
 
-**CRITICAL**: Take the exact command from the ### Execution section. Do
-not modify, improve, or rewrite the command in any way. The user wrote
-these commands specifically for their environment and workflow.
+**CRITICAL - VERBATIM EXECUTION**: Run shell commands EXACTLY as written in
+the ### Execution section. Do NOT:
+- Modify the command string in any way
+- Optimize or improve the command
+- Add flags or options
+- Change paths or filenames
+- Rewrite using different syntax
+- "Fix" perceived issues in the command
+- Expand aliases or shortcuts
+- Strip or modify escape characters (backslashes, quotes)
+- Convert `\"` to `"` or `\'` to `'`
+- Remove or change any escaping sequences
+
+The ONLY allowed change is replacing `{placeholder}` tokens with their
+resolved values. Everything else must remain character-for-character
+identical to what the user wrote in their skill definition.
+
+**PRESERVE ALL CHARACTERS**: If the skill has `x=\"y\"`, output `x=\"y\"`.
+If it has `path/to/file\ with\ spaces`, keep it exactly as written.
+Escape sequences are intentional - do not "clean" or "simplify" them.
 
 ## Response Format
 
@@ -350,34 +367,58 @@ For complex multi-step operations:
 4. **Error handling**: For non-critical cleanup steps, set critical:
    false
 
+## Handling Config Placeholders
+
+When substituting parameter placeholders in skill commands:
+
+1. **Known values**: Replace `{PARAM}` with the actual value from task params
+2. **Unknown values**: If a placeholder value is not available in task params,
+   **keep the original `{placeholder}` syntax** in the command. Do NOT replace
+   it with `<UNKNOWN>` or any other marker.
+
+**CRITICAL**: Never use `<UNKNOWN>`, `<MISSING>`, `<undefined>`, or similar
+markers in commands. The `<` and `>` characters break shell syntax. Always
+preserve the original `{placeholder}` format for unresolved values - this
+allows the system to detect and prompt for missing configuration.
+
+Example:
+- Command template: `process.py --output {settings.output}`
+- If `settings.output` is NOT in task params:
+  - WRONG: `process.py --output <UNKNOWN>`
+  - CORRECT: `process.py --output {settings.output}`
+
 ## Common Mistakes to Avoid
 
-❌ Generating commands that don't match the task description
-❌ Using platform-specific commands without consideration
-❌ Forgetting to quote paths with spaces
-❌ Setting unrealistic timeouts for long operations
-❌ Running destructive commands without safeguards
-❌ Ignoring task parameters when generating 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
-✅ Quote all file paths properly
-✅ 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
+**DO NOT:**
+- Generate commands that don't match the task description
+- Use platform-specific commands without consideration
+- Forget to quote paths with spaces
+- Set unrealistic timeouts for long operations
+- Run destructive commands without safeguards
+- Ignore task parameters when generating commands
+- **CRITICAL: Invent commands instead of using skill's Execution
+  section**
+- **CRITICAL: Ignore params.skill and make up your own commands**
+- **CRITICAL: Generate commands when the skill doesn't exist in
+  Available Skills**
+- Fail to substitute parameter placeholders in skill commands
+- **CRITICAL: Assume what commands to run when skill is missing**
+- **CRITICAL: Replace unknown placeholders with `<UNKNOWN>` - this breaks
+  shell syntax**
+
+**DO:**
+- Match commands precisely to task descriptions
+- Use task params to fill in specific values
+- Quote all file paths properly
+- 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
 
 ## Final Validation
 

package/dist/skills/introspect.md

@@ -64,7 +64,7 @@ capability list.
 
 ## Capabilities Structure
 
-**⚠️ CRITICAL ORDERING REQUIREMENT ⚠️**
+**CRITICAL ORDERING REQUIREMENT**
 
 You MUST present capabilities in the EXACT order specified below. This is
 NON-NEGOTIABLE and applies to EVERY response.
@@ -81,20 +81,20 @@ NON-NEGOTIABLE and applies to EVERY response.
 
 These MUST appear FIRST, in this EXACT sequence:
 
-1. **Introspect** ← ALWAYS FIRST
-2. **Configure** ← ALWAYS SECOND
-3. **Answer** ← ALWAYS THIRD
-4. **Execute** ← ALWAYS FOURTH
+1. **Introspect**
+2. **Configure**
+3. **Answer**
+4. **Execute**
 
 ### Position 5-7: meta workflow capabilities (origin: "meta")
 
 These MUST appear AFTER Execute and BEFORE user-provided skills:
 
-5. **Schedule** ← NEVER FIRST, ALWAYS position 5 (after Execute)
-6. **Validate** ← ALWAYS position 6 (after Schedule)
-7. **Report** ← NEVER FIRST, ALWAYS position 7 (after Validate)
+5. **Schedule**
+6. **Validate**
+7. **Report**
 
-### 3. user-provided skills (origin: "user")
+### Position 8+: user-provided skills (origin: "user")
 
 If skills are provided in the "Available Skills" section below, include
 them in the response. For each skill:

package/dist/skills/schedule.md

@@ -325,12 +325,6 @@ even if they use the same action verb.
   - Task 2: "Process data" (skill-based with subtasks)
   - Task 3: "Explain Kubernetes" (type: answer)
 
-- "explain tdd, process files, explain tbd" → THREE separate task
-  groups:
-  - Task 1: "Explain Test-Driven Development" (type: answer)
-  - Task 2: "Process files" (skill-based with subtasks)
-  - Task 3: "Explain TBD" (type: answer)
-
 - "process files and validate" where only "process" has a skill →
   - Task 1: "Process files" (skill-based with subtasks)
   - Task 2: type "ignore" for unmatched "validate"