prompt-language-shell 0.9.4 → 0.9.6

package/dist/components/Workflow.js

@@ -107,7 +107,18 @@ export const Workflow = ({ initialQueue, debug }) => {
             setQueue((queue) => [...queue, ...items]);
         },
         addToTimeline: (...items) => {
-            setTimeline((prev) => [...prev, ...items]);
+            // Flush pending to timeline first, then add new items
+            // Both are added in a SINGLE setTimeline call to guarantee order
+            setCurrent((curr) => {
+                const { active, pending } = curr;
+                if (pending) {
+                    const donePending = markAsDone(pending);
+                    setTimeline((prev) => [...prev, donePending, ...items]);
+                    return { active, pending: null };
+                }
+                setTimeline((prev) => [...prev, ...items]);
+                return curr;
+            });
         },
     }), []);
     // Global Esc handler removed - components handle their own Esc individually

package/dist/components/controllers/Schedule.js

@@ -37,8 +37,7 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
                 completedSelections,
             };
             requestHandlers.onCompleted(finalState);
-            // Complete the selection phase - it goes to timeline
-            // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
+            // Move Schedule to pending - callback will flush to timeline
             lifecycleHandlers.completeActive();
             void onSelectionConfirmed(concreteTasks);
         }
@@ -102,9 +101,9 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
                         const options = task.params.options;
                         const selectedIndex = newCompletedSelections[defineGroupIndex];
                         const selectedOption = options[selectedIndex];
-                        // Use Execute as default - LLM will properly classify during refinement
+                        // Use the command from the selected option
                         refinedTasks.push({
-                            action: selectedOption,
+                            action: selectedOption.command,
                             type: TaskType.Execute,
                             config: [],
                         });
@@ -122,16 +121,12 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
                     completedSelections: newCompletedSelections,
                 };
                 requestHandlers.onCompleted(finalState);
+                // Move Schedule to pending - refinement will flush it to timeline
+                // before adding Command, ensuring correct order
+                lifecycleHandlers.completeActive();
                 if (onSelectionConfirmed) {
-                    // Complete the selection phase - it goes to timeline
-                    // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
-                    lifecycleHandlers.completeActive();
                     void onSelectionConfirmed(refinedTasks);
                 }
-                else {
-                    // No selection callback, just complete normally
-                    lifecycleHandlers.completeActive();
-                }
             }
         }
     }, { isActive: isActive && defineTask !== null });

package/dist/components/views/Debug.js

@@ -3,5 +3,10 @@ import { Box, Text } from 'ink';
 const CONTENT_WIDTH = 80;
 const HORIZONTAL_PADDING = 2;
 export const Debug = ({ title, content, color }) => {
-    return (_jsxs(Box, { flexDirection: "column", paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, children: [_jsx(Text, { color: color, wrap: "wrap", children: title }), _jsx(Text, { color: color, wrap: "wrap", children: content })] }));
+    // Plain text content - single bordered box
+    if (typeof content === 'string') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, children: [_jsx(Text, { color: color, wrap: "wrap", children: title }), _jsx(Text, { color: color, wrap: "wrap", children: content })] }));
+    }
+    // Array content - table with one column, each item in bordered row
+    return (_jsxs(Box, { flexDirection: "column", width: CONTENT_WIDTH, children: [_jsx(Box, { paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, children: _jsx(Text, { color: color, wrap: "wrap", children: title }) }), content.map((section, index) => (_jsx(Box, { paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, marginTop: -1, children: _jsx(Text, { color: color, wrap: "wrap", children: section }) }, index)))] }));
 };

package/dist/components/views/Feedback.js

@@ -1,19 +1,8 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { 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) {
-    return {
-        [FeedbackType.Info]: 'ℹ',
-        [FeedbackType.Warning]: '⚠',
-        [FeedbackType.Succeeded]: '✓',
-        [FeedbackType.Aborted]: '⊘',
-        [FeedbackType.Failed]: '✗',
-    }[type];
-}
 export function Feedback({ type, message }) {
     const color = getFeedbackColor(type, ComponentStatus.Done);
-    const symbol = getSymbol(type);
-    return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
+    return (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: color, children: message }) }));
 }

package/dist/components/views/Schedule.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box } from 'ink';
 import { ComponentStatus } from '../../types/components.js';
-import { TaskType } from '../../types/types.js';
+import { TaskType, } from '../../types/types.js';
 import { DebugLevel } from '../../configuration/types.js';
 import { getTaskColors, getTaskTypeLabel, Palette, } from '../../services/colors.js';
 import { Label } from './Label.js';
@@ -28,7 +28,8 @@ export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskW
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
-        item.children = task.params.options.map((option, index) => {
+        const options = task.params.options;
+        item.children = options.map((option, index) => {
             // Determine the type based on selection state
             let childType = TaskType.Select;
             if (highlightedChildIndex !== null) {
@@ -40,7 +41,7 @@ export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskW
             const planColors = getTaskColors(TaskType.Schedule, status);
             return {
                 description: {
-                    text: option,
+                    text: option.name,
                     color: colors.description,
                     highlightedColor: planColors.description,
                 },

package/dist/components/views/Table.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+const DEFAULT_WIDTH = 80;
+const DEFAULT_PADDING = 1;
+export const Cell = ({ children, padding = DEFAULT_PADDING }) => (_jsx(Box, { paddingX: padding, children: _jsx(Text, { wrap: "wrap", children: children }) }));
+export const Column = ({ children, width }) => (_jsx(Box, { flexDirection: "column", width: width, children: children }));
+const Row = ({ children, color, innerWidth }) => (_jsxs(Box, { children: [_jsx(Text, { color: color, children: '│' }), _jsx(Box, { width: innerWidth, children: children }), _jsx(Text, { color: color, children: '│' })] }));
+export const Table = ({ data, width = DEFAULT_WIDTH, color }) => {
+    const innerWidth = width - 2;
+    const TOP = '┌' + '─'.repeat(innerWidth) + '┐';
+    const DIV = '├' + '─'.repeat(innerWidth) + '┤';
+    const BOT = '└' + '─'.repeat(innerWidth) + '┘';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: color, children: TOP }), data.map((content, index) => (_jsxs(React.Fragment, { children: [index > 0 && _jsx(Text, { color: color, children: DIV }), _jsx(Row, { color: color, innerWidth: innerWidth, children: _jsx(Cell, { children: content }) })] }, index))), _jsx(Text, { color: color, children: BOT })] }));
+};

package/dist/services/anthropic.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from '../configuration/schema.js';
 import { logPrompt, logResponse } from './logger.js';
-import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
+import { loadSkillsForPrompt } from './skills.js';
 import { toolRegistry } from './registry.js';
 import { CommandResultSchema, IntrospectResultSchema, } from '../types/schemas.js';
 /**
@@ -69,36 +69,32 @@ export class AnthropicService {
     async processWithTool(command, toolName, customInstructions) {
         // Load tool from registry
         const tool = toolRegistry.getSchema(toolName);
-        // Use custom instructions if provided, otherwise load from registry
-        let systemPrompt;
-        if (customInstructions) {
-            // Custom instructions provided (typically for testing)
-            systemPrompt = customInstructions;
+        // Check if this tool uses skills
+        const usesSkills = toolName === 'schedule' ||
+            toolName === 'introspect' ||
+            toolName === 'execute' ||
+            toolName === 'validate';
+        // Load base instructions and skills
+        const baseInstructions = customInstructions || toolRegistry.getInstructions(toolName);
+        let formattedSkills = '';
+        let skillDefinitions = [];
+        let systemPrompt = baseInstructions;
+        if (!customInstructions && usesSkills) {
+            const skillsResult = loadSkillsForPrompt();
+            formattedSkills = skillsResult.formatted;
+            skillDefinitions = skillsResult.definitions;
+            systemPrompt += formattedSkills;
         }
-        else {
-            // Load and build system prompt automatically (production)
-            const instructions = toolRegistry.getInstructions(toolName);
-            systemPrompt = instructions;
-            // Add skills section for applicable tools
-            if (toolName === 'schedule' ||
-                toolName === 'introspect' ||
-                toolName === 'execute' ||
-                toolName === 'validate') {
-                const skills = loadSkillsWithValidation();
-                const skillsSection = formatSkillsForPrompt(skills);
-                systemPrompt += skillsSection;
-            }
-            // Add config structure for configure tool only
-            if (toolName === 'configure') {
-                const configStructure = getAvailableConfigStructure();
-                const configuredKeys = getConfiguredKeys();
-                const configSection = '\n## Available Configuration\n\n' +
-                    'Config structure (key: description):\n' +
-                    JSON.stringify(configStructure, null, 2) +
-                    '\n\nConfigured keys (keys that exist in config file):\n' +
-                    JSON.stringify(configuredKeys, null, 2);
-                systemPrompt += configSection;
-            }
+        // Add config structure for configure tool only
+        if (!customInstructions && toolName === 'configure') {
+            const configStructure = getAvailableConfigStructure();
+            const configuredKeys = getConfiguredKeys();
+            const configSection = '\n## Available Configuration\n\n' +
+                'Config structure (key: description):\n' +
+                JSON.stringify(configStructure, null, 2) +
+                '\n\nConfigured keys (keys that exist in config file):\n' +
+                JSON.stringify(configuredKeys, null, 2);
+            systemPrompt += configSection;
         }
         // Build tools array - add web search for answer tool
         const tools = [tool];
@@ -111,7 +107,7 @@ export class AnthropicService {
         // Collect debug components
         const debug = [];
         // Log prompt at Verbose level
-        const promptDebug = logPrompt(toolName, command, systemPrompt);
+        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, skillDefinitions);
         if (promptDebug) {
             debug.push(promptDebug);
         }

package/dist/services/colors.js

@@ -20,6 +20,7 @@ export const Palette = {
     Yellow: '#cccc5c',
     Orange: '#f48c80',
     MediumOrange: '#d07560',
+    WarmOrange: '#ce985e',
     DarkOrange: '#ab5e40',
     BurntOrange: '#cc7a5c',
     Red: '#cc5c5c',
@@ -132,7 +133,7 @@ const taskColors = {
  */
 const feedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
-    [FeedbackType.Warning]: Palette.Yellow,
+    [FeedbackType.Warning]: Palette.WarmOrange,
     [FeedbackType.Succeeded]: Colors.Status.Success,
     [FeedbackType.Aborted]: Palette.MediumOrange,
     [FeedbackType.Failed]: Colors.Status.Error,

package/dist/services/logger.js

@@ -1,7 +1,19 @@
 import { DebugLevel } from '../configuration/types.js';
-import { createDebug } from './components.js';
 import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
+import { createDebug } from './components.js';
+/**
+ * Enum controlling what content is shown in debug prompt output
+ * - LLM: Exact prompt as sent to LLM (no display formatting)
+ * - Skills: Same content with visual separators for readability
+ * - Summary: Condensed view (Name, Steps, Execution only)
+ */
+export var PromptDisplay;
+(function (PromptDisplay) {
+    PromptDisplay["LLM"] = "llm";
+    PromptDisplay["Skills"] = "skills";
+    PromptDisplay["Summary"] = "summary";
+})(PromptDisplay || (PromptDisplay = {}));
 /**
  * Debug logger for the application
  * Logs information based on the current debug level setting
@@ -49,24 +61,125 @@ export function getWarnings() {
     warnings.length = 0;
     return result;
 }
+/**
+ * Content width for debug display (matches Debug component)
+ * Box width 80 - 2 borders - 4 padding = 74 chars
+ */
+const DISPLAY_CONTENT_WIDTH = 74;
+/**
+ * Join sections with separators matching display width
+ */
+function joinWithSeparators(sections) {
+    const separator = '-'.repeat(DISPLAY_CONTENT_WIDTH);
+    return sections.join('\n\n' + separator + '\n\n');
+}
+/**
+ * Format a single skill definition as summary markdown
+ */
+function formatSkillSummary(skill) {
+    const lines = [];
+    lines.push(`### Name`);
+    lines.push(skill.name);
+    lines.push('');
+    if (skill.steps.length > 0) {
+        lines.push(`### Steps`);
+        for (const step of skill.steps) {
+            lines.push(`- ${step}`);
+        }
+        lines.push('');
+    }
+    if (skill.execution.length > 0) {
+        lines.push(`### Execution`);
+        for (const cmd of skill.execution) {
+            lines.push(`- ${cmd}`);
+        }
+    }
+    return lines.join('\n').trim();
+}
+/**
+ * Format skill definitions as summary for debug display
+ * Shows only Name, Steps, and Execution with visual separators
+ */
+export function formatSkillsSummary(definitions) {
+    if (definitions.length === 0) {
+        return '(no skills)';
+    }
+    const header = '## Available Skills';
+    const skillSummaries = definitions.map(formatSkillSummary);
+    return joinWithSeparators([header, ...skillSummaries]);
+}
+/**
+ * Format skills section with visual separators for debug display
+ * Layout: Header description -> separator -> skills separated by lines
+ */
+function formatSkillsForDisplay(formattedSkills) {
+    if (!formattedSkills) {
+        return '(no skills)';
+    }
+    // Find the header (everything before first ### Name)
+    const firstNameIndex = formattedSkills.search(/^###\s+Name/m);
+    if (firstNameIndex === -1) {
+        return '(no skills)';
+    }
+    const header = formattedSkills.slice(0, firstNameIndex).trim();
+    const skillsContent = formattedSkills.slice(firstNameIndex);
+    // Split by ### Name to get individual skills
+    const skillParts = skillsContent
+        .split(/(?=^###\s+Name)/m)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (skillParts.length === 0) {
+        return '(no skills)';
+    }
+    // Join header and skills with separators
+    return joinWithSeparators([header, ...skillParts]);
+}
+/**
+ * Format prompt content based on the specified detail level
+ *
+ * - LLM: Returns header + base instructions + formatted skills (as sent to LLM)
+ * - Skills: Returns header + skills with visual separators (no base instructions)
+ * - Summary: Returns header + skill summaries (Name, Steps, Execution)
+ */
+export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, definitions) {
+    const header = ['', `Tool: ${toolName}`, `Command: ${command}`];
+    switch (mode) {
+        case PromptDisplay.LLM:
+            return [...header, '', baseInstructions + formattedSkills].join('\n');
+        case PromptDisplay.Skills: {
+            // Layout: header -> separator -> skills with visual separators
+            const headerString = header.join('\n');
+            const skillsDisplay = formatSkillsForDisplay(formattedSkills);
+            return joinWithSeparators([headerString, skillsDisplay]);
+        }
+        case PromptDisplay.Summary: {
+            const headerString = header.join('\n');
+            const summary = definitions
+                ? formatSkillsSummary(definitions)
+                : '(no skills)';
+            return joinWithSeparators([headerString, summary]);
+        }
+    }
+}
 /**
  * Create debug component for system prompts sent to the LLM
  * Only creates at Verbose level
+ *
+ * @param toolName - Name of the tool being invoked
+ * @param command - User command being processed
+ * @param baseInstructions - Base tool instructions (without skills)
+ * @param formattedSkills - Formatted skills section (as sent to LLM)
+ * @param definitions - Parsed skill definitions for summary display
  */
-export function logPrompt(toolName, command, instructions) {
+export function logPrompt(toolName, command, baseInstructions, formattedSkills, definitions = []) {
     if (currentDebugLevel !== DebugLevel.Verbose) {
         return null;
     }
-    const content = [
-        '',
-        `Tool: ${toolName}`,
-        `Command: ${command}`,
-        '',
-        instructions,
-    ].join('\n');
-    // Calculate stats for the instructions
-    const lines = instructions.split('\n').length;
-    const bytes = Buffer.byteLength(instructions, 'utf-8');
+    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, definitions);
+    // Calculate stats for the full prompt
+    const fullPrompt = baseInstructions + formattedSkills;
+    const lines = fullPrompt.split('\n').length;
+    const bytes = Buffer.byteLength(fullPrompt, 'utf-8');
     const title = `SYSTEM PROMPT (${String(lines)} lines, ${String(bytes)} bytes)`;
     return createDebug({ title, content, color: Palette.Gray });
 }
@@ -85,5 +198,5 @@ export function logResponse(toolName, response, durationMs) {
         JSON.stringify(response, null, 2),
     ].join('\n');
     const title = `LLM RESPONSE (${String(durationMs)} ms)`;
-    return createDebug({ title, content, color: Palette.AshGray });
+    return createDebug({ title, content, color: Palette.LightGray });
 }

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,105 +227,90 @@ 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];
+const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer, TaskType.Group];
 /**
- * Collect names of all upcoming execution units (groups and standalone tasks)
- * for display during task execution
+ * Collect action names for tasks that appear in upcoming display.
+ * Groups are included with their group name (not individual subtask names).
  */
-function collectUpcomingNames(scheduledTasks) {
-    const names = [];
-    for (const task of scheduledTasks) {
-        if (task.type === TaskType.Group && task.subtasks?.length) {
-            const subtasks = task.subtasks;
-            if (UPCOMING_TASK_TYPES.includes(subtasks[0].type)) {
-                names.push(task.action);
-            }
-        }
-        else if (UPCOMING_TASK_TYPES.includes(task.type)) {
-            names.push(task.action);
-        }
-    }
-    return 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) {
-    // Collect all unit names for upcoming display
-    const allUnitNames = collectUpcomingNames(scheduledTasks);
-    let currentUnitIndex = 0;
-    // 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] = [];
+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));
+            }
         }
-        for (const task of consecutiveStandaloneTasks) {
-            tasksByType[task.type].push(task);
+        if (typeTasks.length > 0) {
+            routeTasksByType(groupedType, typeTasks, context, []);
         }
-        // Route each type group
-        for (const [type, typeTasks] of Object.entries(tasksByType)) {
-            const taskType = type;
-            if (typeTasks.length === 0)
-                continue;
-            // For tasks that appear in upcoming, calculate from remaining units
-            if (UPCOMING_TASK_TYPES.includes(taskType)) {
-                // Each task advances the unit index
-                for (const task of typeTasks) {
-                    const upcoming = allUnitNames.slice(currentUnitIndex + 1);
-                    currentUnitIndex++;
-                    routeTasksByType(taskType, [task], context, upcoming);
-                }
+    }
+    // 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);
             }
-            else {
-                routeTasksByType(taskType, typeTasks, context, []);
+            // Route Answer subtasks individually
+            if (answerSubtasks.length > 0) {
+                routeAnswerTasks(answerSubtasks, context, upcoming);
             }
         }
-        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;
-                // Calculate upcoming (all units after this one)
-                const upcoming = UPCOMING_TASK_TYPES.includes(taskType)
-                    ? allUnitNames.slice(currentUnitIndex + 1)
-                    : [];
-                if (UPCOMING_TASK_TYPES.includes(taskType)) {
-                    currentUnitIndex++;
-                }
-                // Pass group name as label for Execute groups
-                if (taskType === TaskType.Execute) {
-                    routeExecuteTasks(subtasks, context, upcoming, task.action);
-                }
-                else {
-                    routeTasksByType(taskType, subtasks, 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

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/skills/schedule.md

@@ -14,6 +14,15 @@ behavior must adapt accordingly:
 - **Skills present**: Match user requests ONLY against listed skills
 - **Empty or missing**: Create "ignore" tasks for ALL action verbs
 
+**CRITICAL - Available Skills Section Takes Precedence**:
+
+Information provided in the "Available Skills" section is AUTHORITATIVE
+and OVERRIDES any default behavior in these instructions. When a skill's
+description specifies required parameters, error handling, or specific
+behaviors, those requirements MUST be followed exactly. Skill-specific
+rules always take precedence over general examples or default patterns
+in this document.
+
 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
@@ -268,6 +277,152 @@ User request with multiple config expressions
 - This applies to ALL placeholders in task actions, including those
   from skill references
 
+## Runtime Parameter Placeholders
+
+Skills may include runtime parameters in their Execution section using
+angle bracket syntax. These parameters MUST be resolved by the LLM
+during scheduling - they represent values extracted from the user's
+command, NOT from stored configuration.
+
+**Parameter Format:**
+
+- `<PARAM>` - Required parameter, extract from user command
+- `<PARAM=default>` - Parameter with default, use default if not specified
+- `<PARAM?>` - Optional parameter, omit entirely if not mentioned
+
+**Distinction from Config Placeholders:**
+
+- `{x.y.z}` - Config placeholder, resolved by system at execution from
+  ~/.plsrc
+- `{x.VARIANT.z}` - Variant config, LLM matches variant at schedule time,
+  system resolves from ~/.plsrc at execution
+- `<PARAM>` - Runtime parameter, resolved entirely by LLM at schedule time
+  from user command
+
+**Resolution Rules:**
+
+1. **Full resolution required**: All `<PARAM>` placeholders MUST be
+   resolved to concrete values before creating tasks. No angle-bracket
+   syntax should remain in task actions or params.
+
+2. **Space normalization**: When optional params are omitted, collapse
+   adjacent spaces to single space (e.g., `cmd <OPT?> file` → `cmd file`)
+
+3. **Complete descriptions**: Task actions must be human-readable with
+   all parameters filled in:
+   - CORRECT: "Process /data/report.csv in batch mode with JSON output"
+   - WRONG: "Process <SOURCE> in <MODE> mode"
+
+**Parameter Classification:**
+
+Runtime parameters fall into two categories:
+
+1. **Key parameters** - Essential to the operation, define WHAT to operate on
+   - Input files, paths, URLs, target names, identifiers
+   - The primary subject of the command
+   - Cannot be guessed or listed as options
+   - Examples: `<SOURCE>`, `<FILE>`, `<URL>`, `<TARGET>`
+
+2. **Modifier parameters** - Configure HOW the operation runs
+   - Have a finite set of valid options
+   - Affect behavior but not the primary subject
+   - Examples: `<MODE>`, `<QUALITY>`, `<FORMAT>`, `<VERBOSITY>`
+
+**Resolution Outcomes:**
+
+When processing runtime parameters, exactly ONE of these outcomes applies.
+**CRITICAL: Evaluate in this EXACT order - key param check MUST happen first:**
+
+1. **Key param missing** → Create IGNORE task (CHECK THIS FIRST!)
+   - **PREREQUISITE CHECK**: Before considering ANY other outcome, verify
+     ALL key parameters (input files, paths, URLs, targets) are present
+   - A key parameter is not specified → ALWAYS create IGNORE task
+   - **NEVER create a DEFINE task when key params are missing**, even if
+     modifier params could be listed as options
+   - NEVER offer options for key parameters - they cannot be guessed
+   - Use type `ignore` with descriptive action
+   - Action format: "Missing [param]: specify [what's needed]"
+   - Examples:
+     - "Missing input: specify which file to process"
+     - "Missing target: specify which server to deploy to"
+     - "Missing URL: specify which page to fetch"
+
+2. **All resolved** → Create normal execute/group task
+   - All key parameters are present AND extracted successfully
+   - All modifier parameters are extracted or defaulted
+   - Task action contains fully resolved description
+
+3. **Modifier param unclear (ALL key params present)** → Create DEFINE task
+   - **PREREQUISITE**: ALL key parameters MUST be present in user's command
+   - Only a modifier parameter is unclear but has finite options
+   - **NEVER use DEFINE when ANY key param is missing** - use IGNORE instead
+   - Use type `define` with params.skill and params.options
+   - MUST have more than one option (if only one option exists, use it
+     directly without refinement)
+   - Example: mode (batch/stream/interactive), format (json/xml/csv)
+   - Each option is an object: { name: string, command: string }
+     - name: readable display text for user selection
+     - command: user's natural language command with ALL params resolved
+   - Note: command is NOT the shell command - shell commands are generated
+     by EXECUTE in the next step
+
+**Examples:**
+
+Skill execution line:
+- `process <SOURCE> --mode <MODE> --format <FORMAT=json> <VERBOSE?>`
+
+Key param missing case (CHECK FIRST):
+- User: "process in batch mode"
+- Problem: SOURCE path not specified (key param, cannot be guessed)
+- Task: type `ignore`, action: "Missing source: specify which file to process"
+
+Key param missing with modifier specified:
+- User: "export in JSON format"
+- Problem: SOURCE file not specified (key param, cannot be guessed)
+- Task: type `ignore`, action: "Missing source: specify which data to export"
+- Note: Even though format IS specified, key param is missing → IGNORE, not
+  DEFINE. Key param check takes absolute precedence over DEFINE.
+
+Success case (all resolved):
+- User: "process /data/report.csv in batch mode"
+- Resolution:
+  - `<SOURCE>` → `/data/report.csv` (extracted)
+  - `<MODE>` → `batch` (extracted from "batch mode")
+  - `<FORMAT=json>` → `json` (default used)
+  - `<VERBOSE?>` → omitted (optional, not mentioned)
+- Task action: "Process /data/report.csv in batch mode with JSON format"
+
+Define case (modifier unclear, ALL key params present):
+- User: "process /data/report.csv"
+- Key params: SOURCE is present (/data/report.csv) ✓
+- Problem: MODE not specified but can be listed (3 options available)
+- Task: type `define`, params:
+  - skill: "Process Data"
+  - options:
+    - { name: "Process in batch mode",
+        command: "process /data/report.csv in batch mode" }
+    - { name: "Process in stream mode",
+        command: "process /data/report.csv in stream mode" }
+    - { name: "Process interactively",
+        command: "process /data/report.csv interactively" }
+- User selects "Process in batch mode"
+- SCHEDULE receives: "process /data/report.csv in batch mode"
+- EXECUTE then generates the appropriate shell command
+
+**Critical Rules:**
+- **KEY PARAM CHECK IS MANDATORY AND FIRST**: Before creating ANY task type,
+  verify ALL key parameters are present. This check takes absolute precedence.
+- IGNORE when ANY key param is missing (input, file, URL, target, etc.)
+- Key params cannot be guessed - always require IGNORE with clear error
+- **DEFINE is ONLY valid when ALL key params are present** - if any key param
+  is missing, DEFINE is NOT an option, regardless of modifier params
+- DEFINE tasks MUST have multiple options (2+); single option = use directly
+- NEVER leave `<PARAM>` unresolved in task output
+- NEVER use placeholder values like `<UNKNOWN>` or `<MISSING>`
+- option.command is user's natural language request, NOT shell command
+- Each option.command must include ALL user parameters (original + selected)
+- option.command must preserve exact paths, filenames, URLs (case-sensitive)
+
 ## Grouping Strategy
 
 Group subtasks under logical parent tasks based on:

package/dist/tools/schedule.tool.js

@@ -31,7 +31,7 @@ export const scheduleTool = {
                     },
                     params: {
                         type: 'object',
-                        description: 'Parameters for leaf tasks (e.g., command, path)',
+                        description: 'Parameters for leaf tasks. For "define" type: { skill: string, options: Array<{ name: string, command: string }> }. "name" is display text, "command" is full resolved command.',
                     },
                     config: {
                         type: 'array',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -17,9 +17,9 @@
     "dev": "npm run build && tsc --watch",
     "prepare": "husky",
     "prepublishOnly": "npm run check",
-    "test": "vitest run --exclude 'tests/integration/*.test.tsx'",
-    "test:watch": "vitest --exclude 'tests/integration/*.test.tsx'",
-    "test:llm": "vitest run tests/integration/schedule*.test.tsx",
+    "test": "vitest run --exclude 'tests/tools/schedule/*.test.tsx'",
+    "test:watch": "vitest --exclude 'tests/tools/schedule/*.test.tsx'",
+    "test:llm": "vitest run tests/tools/schedule/*.test.tsx",
     "format": "prettier --write '**/*.{ts,tsx}'",
     "format:check": "prettier --check '**/*.{ts,tsx}'",
     "lint": "eslint .",