prompt-language-shell 0.6.4 → 0.6.8

package/README.md

@@ -2,8 +2,8 @@
 
 Your personal command-line concierge. Ask politely, and it gets things done.
 
-> **Note:** This project is in early preview. Features and APIs may change as
-> development continues.
+> **Note:** This project is in early preview. Features and APIs will change.
+> See [roadmap](#roadmap).
 
 ## Installation
 
@@ -13,14 +13,14 @@ npm install -g prompt-language-shell
 
 ## Setup
 
-On first run, `pls` walks you through a quick setup. Your settings will be saved to `~/.plsrc`.
+On first run, `pls` walks you through a quick setup.
+Your settings will be saved to `~/.plsrc`.
 
 ## Usage
 
 Type `pls` followed by your request in natural language.
 
-To see what `pls` can
-do, start by listing available capabilities:
+To see what `pls` can do, start by listing available capabilities:
 
 ```
 $ pls list skills
@@ -98,6 +98,8 @@ Skills let you teach `pls` about your project-specific workflows. Create
 markdown files in `~/.pls/skills/` to define custom operations that `pls` can
 understand and execute.
 
+For complete documentation, see [docs/SKILLS.md](./docs/SKILLS.md).
+
 ### Structure
 
 Each skill file uses a simple markdown format:
@@ -155,6 +157,13 @@ $ pls build dev
 $ pls build test
 ```
 
+## Roadmap
+
+- **0.7** - Comprehend skill, simplified prompts, better debugging
+- **0.8** - Sequential and interlaced skill execution
+- **0.9** - Learn skill, codebase refinement, complex dependency handling
+- **1.0** - Production release
+
 ## Development
 
 See [CLAUDE.md](./CLAUDE.md) for development guidelines and architecture.

package/dist/services/anthropic.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration.js';
-import { formatSkillsForPrompt, loadSkills } from './skills.js';
-import { toolRegistry } from './tool-registry.js';
+import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
+import { toolRegistry } from './registry.js';
 /**
  * Wraps text to ensure no line exceeds the specified width.
  * Breaks at word boundaries to maintain readability.
@@ -62,7 +62,7 @@ export class AnthropicService {
             toolName === 'introspect' ||
             toolName === 'execute' ||
             toolName === 'validate') {
-            const skills = loadSkills();
+            const skills = loadSkillsWithValidation();
             const skillsSection = formatSkillsForPrompt(skills);
             systemPrompt += skillsSection;
         }

package/dist/services/messages.js

@@ -58,6 +58,21 @@ export function getUnknownRequestMessage() {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Returns an error message for unknown skill references.
+ * Randomly selects from variations to sound natural.
+ * Skill name should be a verb with details (e.g., "Deploy Application")
+ */
+export function getUnknownSkillMessage(skillName) {
+    const templates = [
+        `I don't know how to "${skillName}".`,
+        `I'm not familiar with the "${skillName}" command.`,
+        `I haven't learned how to "${skillName}" yet.`,
+        `I can't "${skillName}".`,
+        `I'm unable to "${skillName}".`,
+    ];
+    return templates[Math.floor(Math.random() * templates.length)];
+}
 /**
  * Returns an error message for mixed task types.
  */

package/dist/services/{skill-parser.js → parser.js}

@@ -1,40 +1,104 @@
 import YAML from 'yaml';
 /**
- * Parse a skill markdown file into structured definition
+ * 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 parseSkillMarkdown(content) {
+export function validateSkillStructure(content, key) {
     const sections = extractSections(content);
-    // Name is required
-    if (!sections.name) {
-        return null;
-    }
-    // Description is required
+    // Use key for error reporting if name not present
+    const skillName = sections.name || key;
+    // Check required sections (Name is now optional)
     if (!sections.description) {
-        return null;
+        return {
+            skillName,
+            error: 'The skill file is missing a Description section',
+        };
     }
-    // Steps are required
     if (!sections.steps || sections.steps.length === 0) {
-        return null;
-    }
-    // Validate execution and steps have same count (if execution exists)
-    if (sections.execution &&
-        sections.execution.length !== sections.steps.length) {
-        return null;
-    }
+        return {
+            skillName,
+            error: 'The skill file is missing a Steps section',
+        };
+    }
+    if (!sections.execution || sections.execution.length === 0) {
+        return {
+            skillName,
+            error: 'The skill file is missing an Execution section',
+        };
+    }
+    // Execution and steps must have same count
+    if (sections.execution.length !== sections.steps.length) {
+        return {
+            skillName,
+            error: `The skill has ${String(sections.steps.length)} steps but ${String(sections.execution.length)} execution lines`,
+        };
+    }
+    return null;
+}
+/**
+ * Convert kebab-case key to Title Case display name
+ * Examples: "deploy-app" -> "Deploy App", "build-project-2" -> "Build Project 2"
+ */
+function keyToDisplayName(key) {
+    return key
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Convert display name to kebab-case key
+ * Examples: "Deploy App" -> "deploy-app", "Navigate To Product" -> "navigate-to-product"
+ */
+export function displayNameToKey(name) {
+    return name
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+}
+/**
+ * Parse a skill markdown file into structured definition
+ */
+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);
+    // For invalid skills, return minimal definition with error
+    if (validationError) {
+        return {
+            key,
+            name: displayName,
+            description: sections.description || '',
+            steps: sections.steps || [],
+            execution: sections.execution || [],
+            isValid: false,
+            validationError: validationError.error,
+            isIncomplete: true,
+        };
+    }
+    // Valid skill - all required fields are present (validation passed)
+    const description = sections.description;
     const skill = {
-        name: sections.name,
-        description: sections.description,
+        key,
+        name: displayName,
+        description,
         steps: sections.steps,
+        execution: sections.execution,
+        isValid: true,
     };
+    // Check if skill is incomplete (valid but needs more documentation)
+    const MIN_DESCRIPTION_LENGTH = 20;
+    if (description.trim().length < MIN_DESCRIPTION_LENGTH) {
+        skill.isIncomplete = true;
+    }
     if (sections.aliases && sections.aliases.length > 0) {
         skill.aliases = sections.aliases;
     }
     if (sections.config) {
         skill.config = sections.config;
     }
-    if (sections.execution && sections.execution.length > 0) {
-        skill.execution = sections.execution;
-    }
     return skill;
 }
 /**
@@ -46,8 +110,8 @@ function extractSections(content) {
     let currentSection = null;
     let sectionLines = [];
     for (const line of lines) {
-        // Check for section headers (### SectionName)
-        const headerMatch = line.match(/^###\s+(.+)$/);
+        // Check for section headers (any valid markdown header: #, ##, ###, etc.)
+        const headerMatch = line.match(/^#{1,6}\s+(.+)$/);
         if (headerMatch) {
             // Process previous section
             if (currentSection) {

package/dist/services/refinement.js

@@ -1,6 +1,6 @@
 import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
-import { routeTasksWithConfirm } from './task-router.js';
+import { routeTasksWithConfirm } from './router.js';
 /**
  * Handle refinement flow for DEFINE tasks
  * Called when user selects options from a plan with DEFINE tasks

package/dist/services/{tool-registry.js → registry.js}

@@ -39,27 +39,17 @@ import { executeTool } from '../tools/execute.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 import { validateTool } from '../tools/validate.tool.js';
-toolRegistry.register('plan', {
-    schema: planTool,
-    instructionsPath: 'config/PLAN.md',
-});
-toolRegistry.register('introspect', {
-    schema: introspectTool,
-    instructionsPath: 'config/INTROSPECT.md',
-});
-toolRegistry.register('answer', {
-    schema: answerTool,
-    instructionsPath: 'config/ANSWER.md',
-});
-toolRegistry.register('config', {
-    schema: configTool,
-    instructionsPath: 'config/CONFIG.md',
-});
-toolRegistry.register('execute', {
-    schema: executeTool,
-    instructionsPath: 'config/EXECUTE.md',
-});
-toolRegistry.register('validate', {
-    schema: validateTool,
-    instructionsPath: 'config/VALIDATE.md',
-});
+const tools = {
+    answer: answerTool,
+    config: configTool,
+    execute: executeTool,
+    introspect: introspectTool,
+    plan: planTool,
+    validate: validateTool,
+};
+for (const [name, schema] of Object.entries(tools)) {
+    toolRegistry.register(name, {
+        schema,
+        instructionsPath: `skills/${name}.md`,
+    });
+}

package/dist/services/{task-router.js → router.js}

@@ -2,7 +2,7 @@ import { TaskType } from '../types/types.js';
 import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createPlanDefinition, createValidateDefinition, } from './components.js';
 import { saveConfig, unflattenConfig } from './configuration.js';
 import { FeedbackType } from '../types/types.js';
-import { validateExecuteTasks } from './execution-validator.js';
+import { validateExecuteTasks } from './validator.js';
 import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 /**
  * Determine the operation name based on task types
@@ -125,18 +125,36 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
     }
     else {
         // Execute tasks with validation
-        const missingConfig = validateExecuteTasks(tasks);
-        if (missingConfig.length > 0) {
-            handlers.addToQueue(createValidateDefinition(missingConfig, userRequest, service, (error) => {
-                handlers.onError(error);
-            }, () => {
+        try {
+            const validation = validateExecuteTasks(tasks);
+            if (validation.validationErrors.length > 0) {
+                // Show error feedback for invalid skills
+                const errorMessages = validation.validationErrors.map((error) => {
+                    const issuesList = error.issues
+                        .map((issue) => `  - ${issue}`)
+                        .join('\n');
+                    return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
+                });
+                handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+            }
+            else if (validation.missingConfig.length > 0) {
+                handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
+                    handlers.onError(error);
+                }, () => {
+                    handlers.addToQueue(createExecuteDefinition(tasks, service));
+                }, (operation) => {
+                    handlers.onAborted(operation);
+                }));
+            }
+            else {
                 handlers.addToQueue(createExecuteDefinition(tasks, service));
-            }, (operation) => {
-                handlers.onAborted(operation);
-            }));
+            }
         }
-        else {
-            handlers.addToQueue(createExecuteDefinition(tasks, service));
+        catch (error) {
+            // Handle skill reference errors (e.g., unknown skills)
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const message = createMessage(errorMessage);
+            handlers.addToQueue(message);
         }
     }
 }

package/dist/services/skills.js

@@ -1,7 +1,42 @@
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
-import { parseSkillMarkdown } from './skill-parser.js';
+import { getUnknownSkillMessage } from './messages.js';
+import { parseSkillMarkdown, displayNameToKey } from './parser.js';
+/**
+ * Built-in skill names that user skills cannot override
+ */
+const BUILT_IN_SKILLS = new Set([
+    'plan',
+    'execute',
+    'answer',
+    'config',
+    'validate',
+    'introspect',
+]);
+/**
+ * Validate filename follows kebab-case pattern
+ * Valid: deploy-app.md, build-project-2.md, copy-files.md
+ * Invalid: Deploy_App.md, buildProject.md, DEPLOY.md, file name.md
+ */
+export function isValidSkillFilename(filename) {
+    // Must end with .md or .MD extension
+    if (!filename.endsWith('.md') && !filename.endsWith('.MD')) {
+        return false;
+    }
+    // Extract name without extension
+    const name = filename.slice(0, -3);
+    // Must match kebab-case pattern: lowercase letters, numbers, and hyphens only
+    // Must start with a letter, and not start or end with a hyphen
+    const kebabCasePattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+    return kebabCasePattern.test(name);
+}
+/**
+ * Check if skill key conflicts with built-in skills
+ */
+export function conflictsWithBuiltIn(key) {
+    return BUILT_IN_SKILLS.has(key);
+}
 /**
  * Get the path to the skills directory
  */
@@ -10,7 +45,8 @@ export function getSkillsDirectory() {
 }
 /**
  * Load all skill markdown files from the skills directory
- * Returns an array of skill file contents
+ * Returns an array of objects with filename (key) and content
+ * Filters out invalid filenames and conflicts with built-in skills
  */
 export function loadSkills() {
     const skillsDir = getSkillsDirectory();
@@ -20,12 +56,27 @@ export function loadSkills() {
     }
     try {
         const files = readdirSync(skillsDir);
-        // Filter for markdown files
-        const skillFiles = files.filter((file) => file.endsWith('.md') || file.endsWith('.MD'));
-        // Read and return contents of each skill file
-        return skillFiles.map((file) => {
+        // Filter and map valid skill files
+        return files
+            .filter((file) => {
+            // Must follow kebab-case naming convention
+            if (!isValidSkillFilename(file)) {
+                return false;
+            }
+            // Extract key (filename without extension, handles both .md and .MD)
+            const key = file.slice(0, -3);
+            // Must not conflict with built-in skills
+            if (conflictsWithBuiltIn(key)) {
+                return false;
+            }
+            return true;
+        })
+            .map((file) => {
+            // Extract key (filename without extension, handles both .md and .MD)
+            const key = file.slice(0, -3);
             const filePath = join(skillsDir, file);
-            return readFileSync(filePath, 'utf-8');
+            const content = readFileSync(filePath, 'utf-8');
+            return { key, content };
         });
     }
     catch {
@@ -35,28 +86,42 @@ export function loadSkills() {
 }
 /**
  * Load and parse all skill definitions
- * Returns structured skill definitions
+ * Returns structured skill definitions (including invalid skills)
  */
 export function loadSkillDefinitions() {
-    const skillContents = loadSkills();
-    const definitions = [];
-    for (const content of skillContents) {
-        const parsed = parseSkillMarkdown(content);
-        if (parsed) {
-            definitions.push(parsed);
+    const skills = loadSkills();
+    return skills.map(({ key, content }) => parseSkillMarkdown(key, content));
+}
+/**
+ * Load skills and mark incomplete ones in their markdown
+ * Returns array of skill markdown with status markers
+ */
+export function loadSkillsWithValidation() {
+    const skills = loadSkills();
+    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 definitions;
+        return content;
+    });
 }
 /**
  * Create skill lookup function from definitions
+ * Lookup by key (display name is converted to kebab-case for matching)
+ * Example: "Deploy App" -> "deploy-app" -> matches skill with key "deploy-app"
  */
 export function createSkillLookup(definitions) {
-    const map = new Map();
+    const keyMap = new Map();
     for (const definition of definitions) {
-        map.set(definition.name, definition);
+        keyMap.set(definition.key, definition);
     }
-    return (name) => map.get(name) || null;
+    return (name) => {
+        // Convert display name to kebab-case key for lookup
+        const key = displayNameToKey(name);
+        return keyMap.get(key) || null;
+    };
 }
 /**
  * Format skills for inclusion in the planning prompt
@@ -72,6 +137,10 @@ export function formatSkillsForPrompt(skills) {
 The following skills define domain-specific workflows. When the user's
 query matches a skill, incorporate the skill's steps into your plan.
 
+Skills marked with (INCOMPLETE) have validation errors or need more
+documentation, and cannot be executed. These should be listed in
+introspection with their markers.
+
 **IMPORTANT**: When creating options from skill descriptions, do NOT use
 brackets for additional information. Use commas instead. For example:
 - CORRECT: "Build project Alpha, the legacy version"
@@ -81,3 +150,95 @@ brackets for additional information. Use commas instead. For example:
     const skillsContent = skills.join('\n\n');
     return header + skillsContent;
 }
+/**
+ * Parse skill reference from execution line
+ * Format: [ Display Name ] with mandatory spaces
+ * Returns display name if line matches format, otherwise null
+ * Example: "[ My Skill ]" -> "My Skill"
+ */
+export function parseSkillReference(line) {
+    // Must match format: [ content ] with at least one space before and after
+    const match = line.trim().match(/^\[\s+(.+?)\s+\]$/);
+    return match ? match[1] : null;
+}
+/**
+ * Check if execution line is a skill reference
+ * Must have format: [ content ] with spaces
+ */
+export function isSkillReference(line) {
+    return /^\[\s+.+?\s+\]$/.test(line.trim());
+}
+/**
+ * Expand skill references in execution commands
+ * Returns expanded execution lines with references replaced
+ * Throws error if circular reference detected or skill not found
+ * Reference format: [ Skill Name ]
+ */
+export function expandSkillReferences(execution, skillLookup, visited = new Set()) {
+    const expanded = [];
+    for (const line of execution) {
+        // First: Detect if line matches [ XXX ] format
+        const skillName = parseSkillReference(line);
+        if (!skillName) {
+            // Not a reference, keep command as-is
+            expanded.push(line);
+            continue;
+        }
+        // Check for circular reference
+        if (visited.has(skillName)) {
+            throw new Error(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`);
+        }
+        // Second: Match against skill name
+        const skill = skillLookup(skillName);
+        if (!skill) {
+            // Referenced skill not found - throw error to break execution
+            throw new Error(getUnknownSkillMessage(skillName));
+        }
+        // Recursively expand referenced skill's execution
+        const newVisited = new Set(visited);
+        newVisited.add(skillName);
+        const referencedExecution = expandSkillReferences(skill.execution, skillLookup, newVisited);
+        expanded.push(...referencedExecution);
+    }
+    return expanded;
+}
+/**
+ * Get all skill names referenced in execution (including nested)
+ * Returns unique set of skill names
+ */
+export function getReferencedSkills(execution, skillLookup, visited = new Set()) {
+    const referenced = new Set();
+    for (const line of execution) {
+        const skillName = parseSkillReference(line);
+        if (!skillName || visited.has(skillName)) {
+            continue;
+        }
+        referenced.add(skillName);
+        const skill = skillLookup(skillName);
+        if (skill) {
+            const newVisited = new Set(visited);
+            newVisited.add(skillName);
+            const nested = getReferencedSkills(skill.execution, skillLookup, newVisited);
+            for (const name of nested) {
+                referenced.add(name);
+            }
+        }
+    }
+    return referenced;
+}
+/**
+ * Validate skill references don't form cycles
+ * Returns true if valid, false if circular reference detected
+ */
+export function validateNoCycles(execution, skillLookup, visited = new Set()) {
+    try {
+        expandSkillReferences(execution, skillLookup, visited);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('Circular')) {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/services/{execution-validator.js → validator.js}

@@ -1,29 +1,49 @@
-import { extractPlaceholders, pathToString, resolveVariant, } from './placeholder-resolver.js';
-import { loadUserConfig, hasConfigPath } from './config-loader.js';
-import { loadSkills } from './skills.js';
-import { expandSkillReferences } from './skill-expander.js';
-import { getConfigType, parseSkillMarkdown } from './skill-parser.js';
+import { extractPlaceholders, pathToString, resolveVariant, } from './resolver.js';
+import { loadUserConfig, hasConfigPath } from './loader.js';
+import { loadSkillDefinitions, createSkillLookup, expandSkillReferences, } from './skills.js';
+import { getConfigType } from './parser.js';
 /**
  * Validate config requirements for execute tasks
- * Returns missing config requirements
+ * Returns validation result with missing config and validation errors
  */
 export function validateExecuteTasks(tasks) {
     const userConfig = loadUserConfig();
     const missing = [];
     const seenPaths = new Set();
-    // Load and parse all skills for validation
-    const skillContents = loadSkills();
-    const parsedSkills = skillContents
-        .map((content) => parseSkillMarkdown(content))
-        .filter((s) => s !== null);
-    const skillLookup = (name) => parsedSkills.find((s) => s.name === name) || null;
+    const validationErrors = [];
+    const seenSkills = new Set();
+    // Load all skills (including invalid ones for validation)
+    const parsedSkills = loadSkillDefinitions();
+    const skillLookup = createSkillLookup(parsedSkills);
+    // Check for invalid skills being used in tasks
+    for (const task of tasks) {
+        const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;
+        if (skillName && !seenSkills.has(skillName)) {
+            seenSkills.add(skillName);
+            // Check if this skill is invalid
+            const skill = skillLookup(skillName);
+            if (skill && !skill.isValid) {
+                validationErrors.push({
+                    skill: skill.name,
+                    issues: [skill.validationError || 'Unknown validation error'],
+                });
+            }
+        }
+    }
+    // If there are validation errors, return early
+    if (validationErrors.length > 0) {
+        return {
+            missingConfig: [],
+            validationErrors,
+        };
+    }
     for (const task of tasks) {
         // Check if task originates from a skill
         const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;
         if (skillName) {
             // Task comes from a skill - check skill's Execution section
             const skill = skillLookup(skillName);
-            if (!skill || !skill.execution) {
+            if (!skill) {
                 continue;
             }
             // Get variant from task params (if any)
@@ -106,5 +126,8 @@ export function validateExecuteTasks(tasks) {
             }
         }
     }
-    return missing;
+    return {
+        missingConfig: missing,
+        validationErrors: [],
+    };
 }

package/dist/{config/INTROSPECT.md → skills/introspect.md}

@@ -88,6 +88,8 @@ These MUST appear AFTER Execute and BEFORE user skills:
 If skills are provided in the "Available Skills" section below, include them
 in the response. For each skill:
 - Extract the skill name from the first heading (# Skill Name)
+- If the skill name contains "(INCOMPLETE)", preserve it exactly in the task
+  action
 - Extract a brief description from the Description or Overview section
 - Keep descriptions concise (1-2 lines maximum)
 - If the user specified a filter (e.g., "skills for deployment"), only include

package/dist/ui/Command.js

@@ -8,7 +8,7 @@ import { createPlanDefinition } from '../services/components.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { useInput } from '../services/keyboard.js';
 import { handleRefinement } from '../services/refinement.js';
-import { routeTasksWithConfirm } from '../services/task-router.js';
+import { routeTasksWithConfirm } from '../services/router.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 import { UserQuery } from './UserQuery.js';

package/dist/ui/Execute.js

@@ -7,8 +7,8 @@ import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecutionStatus, executeCommands, } from '../services/shell.js';
-import { replacePlaceholders } from '../services/placeholder-resolver.js';
-import { loadUserConfig } from '../services/config-loader.js';
+import { replacePlaceholders } from '../services/resolver.js';
+import { loadUserConfig } from '../services/loader.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;

package/dist/ui/Introspect.js

@@ -24,23 +24,31 @@ function parseCapabilityFromTask(task) {
     const colonIndex = task.action.indexOf(':');
     if (colonIndex === -1) {
         const upperName = task.action.toUpperCase();
+        // Check for status markers
+        const isIncomplete = task.action.includes('(INCOMPLETE)');
+        const cleanName = task.action.replace(/\s*\(INCOMPLETE\)\s*/gi, '').trim();
         return {
-            name: task.action,
+            name: cleanName,
             description: '',
             isBuiltIn: BUILT_IN_CAPABILITIES.has(upperName),
             isIndirect: INDIRECT_CAPABILITIES.has(upperName),
+            isIncomplete,
         };
     }
     const name = task.action.substring(0, colonIndex).trim();
     const description = task.action.substring(colonIndex + 1).trim();
-    const upperName = name.toUpperCase();
+    // Check for status markers
+    const isIncomplete = name.includes('(INCOMPLETE)');
+    const cleanName = name.replace(/\s*\(INCOMPLETE\)\s*/gi, '').trim();
+    const upperName = cleanName.toUpperCase();
     const isBuiltIn = BUILT_IN_CAPABILITIES.has(upperName);
     const isIndirect = INDIRECT_CAPABILITIES.has(upperName);
     return {
-        name,
+        name: cleanName,
         description,
         isBuiltIn,
         isIndirect,
+        isIncomplete,
     };
 }
 export function Introspect({ tasks, state, status, service, children, debug = false, handlers, }) {

package/dist/ui/Report.js

@@ -1,14 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Colors } from '../services/colors.js';
-function CapabilityItem({ name, description, isBuiltIn, isIndirect, }) {
+function CapabilityItem({ name, description, isBuiltIn, isIndirect, isIncomplete, }) {
     const color = isIndirect
         ? Colors.Origin.Indirect
         : isBuiltIn
             ? Colors.Origin.BuiltIn
             : Colors.Origin.UserProvided;
-    return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] })] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] }), isIncomplete && _jsx(Text, { color: Colors.Status.Warning, children: " (incomplete)" })] }));
 }
 export function Report({ message, capabilities }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect }, index))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect, isIncomplete: capability.isIncomplete }, index))) })] }));
 }

package/dist/ui/Validate.js

@@ -128,9 +128,15 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
         for (const [section, sectionConfig] of Object.entries(configBySection)) {
             saveConfig(section, sectionConfig);
         }
+        // Mark validation component as complete before invoking callback
+        // This allows the workflow to proceed to execution
+        handlers?.completeActive();
+        // Invoke callback which will queue the Execute component
         onComplete?.(configRequirements);
     };
     const handleConfigAborted = (operation) => {
+        // Mark validation component as complete when aborted
+        handlers?.completeActive();
         onAborted(operation);
     };
     return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), configSteps && !error && (_jsx(Box, { marginTop: 1, children: _jsx(Config, { steps: configSteps, status: status, debug: debug, onFinished: handleConfigFinished, onAborted: handleConfigAborted, handlers: handlers }) })), children] }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.6.4",
+  "version": "0.6.8",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "typecheck": "tsc --project tsconfig.eslint.json",
-    "build": "npm run typecheck && npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
+    "build": "npm run typecheck && npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/skills && cp src/skills/*.md dist/skills/",
     "dev": "npm run build && tsc --watch",
     "prepare": "husky",
     "prepublishOnly": "npm run check",

package/dist/services/skill-expander.js

@@ -1,91 +0,0 @@
-/**
- * Parse skill reference from execution line
- * Returns skill name if line is a reference, otherwise null
- */
-export function parseSkillReference(line) {
-    const match = line.match(/^\[(.+)\]$/);
-    return match ? match[1].trim() : null;
-}
-/**
- * Check if execution line is a skill reference
- */
-export function isSkillReference(line) {
-    return /^\[.+\]$/.test(line.trim());
-}
-/**
- * Expand skill references in execution commands
- * Returns expanded execution lines with references replaced
- * Throws error if circular reference detected
- */
-export function expandSkillReferences(execution, skillLookup, visited = new Set()) {
-    const expanded = [];
-    for (const line of execution) {
-        const skillName = parseSkillReference(line);
-        if (!skillName) {
-            // Not a reference, keep as-is
-            expanded.push(line);
-            continue;
-        }
-        // Check for circular reference
-        if (visited.has(skillName)) {
-            throw new Error(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`);
-        }
-        // Look up referenced skill
-        const skill = skillLookup(skillName);
-        if (!skill) {
-            // Referenced skill not found, keep as-is
-            expanded.push(line);
-            continue;
-        }
-        if (!skill.execution || skill.execution.length === 0) {
-            // Referenced skill has no execution, skip
-            continue;
-        }
-        // Recursively expand referenced skill's execution
-        const newVisited = new Set(visited);
-        newVisited.add(skillName);
-        const referencedExecution = expandSkillReferences(skill.execution, skillLookup, newVisited);
-        expanded.push(...referencedExecution);
-    }
-    return expanded;
-}
-/**
- * Get all skill names referenced in execution (including nested)
- * Returns unique set of skill names
- */
-export function getReferencedSkills(execution, skillLookup, visited = new Set()) {
-    const referenced = new Set();
-    for (const line of execution) {
-        const skillName = parseSkillReference(line);
-        if (!skillName || visited.has(skillName)) {
-            continue;
-        }
-        referenced.add(skillName);
-        const skill = skillLookup(skillName);
-        if (skill && skill.execution) {
-            const newVisited = new Set(visited);
-            newVisited.add(skillName);
-            const nested = getReferencedSkills(skill.execution, skillLookup, newVisited);
-            for (const name of nested) {
-                referenced.add(name);
-            }
-        }
-    }
-    return referenced;
-}
-/**
- * Validate skill references don't form cycles
- * Returns true if valid, false if circular reference detected
- */
-export function validateNoCycles(execution, skillLookup, visited = new Set()) {
-    try {
-        expandSkillReferences(execution, skillLookup, visited);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes('Circular')) {
-            return false;
-        }
-        throw error;
-    }
-}