prompt-language-shell 0.8.0 → 0.8.4

package/dist/services/logger.js

@@ -6,6 +6,10 @@ import { Palette } from './colors.js';
  * Logs information based on the current debug level setting
  */
 let currentDebugLevel = DebugLevel.None;
+/**
+ * Accumulated warnings to be displayed in the timeline
+ */
+const warnings = [];
 /**
  * Initialize the logger with the current debug level from config
  */
@@ -24,6 +28,26 @@ export function setDebugLevel(debug) {
 export function getDebugLevel() {
     return currentDebugLevel;
 }
+/**
+ * Store a warning message to be displayed in the timeline
+ * Only stores warnings at Info or Verbose debug levels
+ */
+export function displayWarning(message, error) {
+    if (currentDebugLevel === DebugLevel.None) {
+        return;
+    }
+    const errorDetails = error instanceof Error ? `: ${error.message}` : '';
+    warnings.push(`${message}${errorDetails}`);
+}
+/**
+ * Get all accumulated warnings and clear the list
+ * Returns array of warning messages
+ */
+export function getWarnings() {
+    const result = [...warnings];
+    warnings.length = 0;
+    return result;
+}
 /**
  * Create debug component for system prompts sent to the LLM
  * Only creates at Verbose level

package/dist/services/parser.js

@@ -1,4 +1,5 @@
 import YAML from 'yaml';
+import { displayWarning } from './logger.js';
 /**
  * Validate a skill without parsing it fully
  * Returns validation error if skill is invalid, null if valid
@@ -188,7 +189,8 @@ function parseConfigSchema(content) {
         }
         return parsed;
     }
-    catch {
+    catch (error) {
+        displayWarning('Failed to parse config schema in skill', error);
         return undefined;
     }
 }

package/dist/services/refinement.js

@@ -5,12 +5,12 @@ import { routeTasksWithConfirm } from './router.js';
  * Handle refinement flow for DEFINE tasks
  * Called when user selects options from a plan with DEFINE tasks
  */
-export async function handleRefinement(selectedTasks, service, originalCommand, handlers) {
+export async function handleRefinement(selectedTasks, service, originalCommand, queueHandlers, lifecycleHandlers, workflowHandlers, errorHandlers) {
     // Create and add refinement component to queue
     const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
-        handlers.onAborted(operation);
+        errorHandlers.onAborted(operation);
     });
-    handlers.addToQueue(refinementDef);
+    queueHandlers.addToQueue(refinementDef);
     try {
         // Build refined command from selected tasks
         const refinedCommand = selectedTasks
@@ -23,18 +23,18 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         // Call LLM to refine plan with selected tasks
         const refinedResult = await service.processWithTool(refinedCommand, 'schedule');
         // Complete the Refinement component
-        handlers.completeActive();
+        lifecycleHandlers.completeActive();
         // Add debug components to timeline if present
-        if (refinedResult.debug && refinedResult.debug.length > 0) {
-            handlers.addToTimeline(...refinedResult.debug);
+        if (refinedResult.debug?.length) {
+            workflowHandlers.addToTimeline(...refinedResult.debug);
         }
         // Route refined tasks to appropriate components
-        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, queueHandlers, workflowHandlers, errorHandlers, false // No DEFINE tasks in refined result
         );
     }
     catch (err) {
-        handlers.completeActive();
+        lifecycleHandlers.completeActive();
         const errorMessage = formatErrorMessage(err);
-        handlers.onError(errorMessage);
+        errorHandlers.onError(errorMessage);
     }
 }

package/dist/services/registry.js

@@ -32,7 +32,7 @@ class ToolRegistry {
 }
 // Create singleton instance
 export const toolRegistry = new ToolRegistry();
-// Register built-in tools
+// Register system tools
 import { answerTool } from '../tools/answer.tool.js';
 import { configureTool } from '../tools/configure.tool.js';
 import { executeTool } from '../tools/execute.tool.js';

package/dist/services/router.js

@@ -1,3 +1,4 @@
+import { asScheduledTasks } from '../types/guards.js';
 import { FeedbackType, TaskType } from '../types/types.js';
 import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
 import { saveConfig, unflattenConfig } from './configuration.js';
@@ -19,7 +20,7 @@ export function getOperationName(tasks) {
  * Route tasks to appropriate components with Confirm flow
  * Handles the complete flow: Plan → Confirm → Execute/Answer/Introspect
  */
-export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false) {
+export function routeTasksWithConfirm(tasks, message, service, userRequest, queueHandlers, workflowHandlers, errorHandlers, hasDefineTask = false) {
     if (tasks.length === 0)
         return;
     // Filter out ignore and discard tasks early
@@ -27,7 +28,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
         const message = createMessage(getUnknownRequestMessage());
-        handlers.addToQueue(message);
+        queueHandlers.addToQueue(message);
         return;
     }
     const operation = getOperationName(validTasks);
@@ -35,7 +36,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
         const scheduleDefinition = createScheduleDefinition(message, validTasks);
-        handlers.addToQueue(scheduleDefinition);
+        queueHandlers.addToQueue(scheduleDefinition);
     }
     else {
         // No DEFINE tasks - Schedule auto-completes and adds Confirm to queue
@@ -46,17 +47,17 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
             // Schedule completed - add Confirm to queue
             const confirmDefinition = createConfirmDefinition(() => {
                 // User confirmed - complete both Confirm and Schedule, then route to appropriate component
-                handlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
+                workflowHandlers.completeActiveAndPending();
+                executeTasksAfterConfirm(validTasks, service, userRequest, queueHandlers, errorHandlers);
             }, () => {
                 // User cancelled - complete both Confirm and Schedule, then show cancellation
-                handlers.completeActiveAndPending();
+                workflowHandlers.completeActiveAndPending();
                 const message = getCancellationMessage(operation);
-                handlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
+                queueHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
             });
-            handlers.addToQueue(confirmDefinition);
+            queueHandlers.addToQueue(confirmDefinition);
         });
-        handlers.addToQueue(scheduleDefinition);
+        queueHandlers.addToQueue(scheduleDefinition);
     }
 }
 /**
@@ -66,8 +67,8 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
 function validateTaskTypes(tasks) {
     if (tasks.length === 0)
         return;
-    // Cast to ScheduledTask to access subtasks property
-    const scheduledTasks = tasks;
+    // 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 &&
@@ -87,16 +88,16 @@ function validateTaskTypes(tasks) {
  * Validates task types and routes each type appropriately
  * Supports mixed types at top level with Groups
  */
-function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
+function executeTasksAfterConfirm(tasks, service, userRequest, queueHandlers, errorHandlers) {
     // Validate task types (Groups must have uniform subtasks)
     try {
         validateTaskTypes(tasks);
     }
     catch (error) {
-        handlers.onError(error instanceof Error ? error.message : String(error));
+        errorHandlers.onError(error instanceof Error ? error.message : String(error));
         return;
     }
-    const scheduledTasks = tasks;
+    const scheduledTasks = asScheduledTasks(tasks);
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -116,7 +117,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, service, userRequest, handlers);
+            routeTasksByType(taskType, typeTasks, service, userRequest, queueHandlers, errorHandlers);
         }
         consecutiveStandaloneTasks = [];
     };
@@ -129,7 +130,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, service, userRequest, handlers);
+                routeTasksByType(taskType, subtasks, service, userRequest, queueHandlers, errorHandlers);
             }
         }
         else {
@@ -144,22 +145,22 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
  * Route tasks by type to appropriate components
  * Extracted to allow reuse for both Groups and standalone tasks
  */
-function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
+function routeTasksByType(taskType, typeTasks, service, userRequest, queueHandlers, errorHandlers) {
     if (taskType === TaskType.Answer) {
         // Create separate Answer component for each question
         for (const task of typeTasks) {
-            handlers.addToQueue(createAnswerDefinition(task.action, service));
+            queueHandlers.addToQueue(createAnswerDefinition(task.action, service));
         }
     }
     else if (taskType === TaskType.Introspect) {
-        handlers.addToQueue(createIntrospectDefinition(typeTasks, service));
+        queueHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
     }
     else if (taskType === TaskType.Config) {
         // Route to Config flow - extract keys from task params
         const configKeys = typeTasks
             .map((task) => task.params?.key)
             .filter((key) => key !== undefined);
-        handlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
+        queueHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
             // Save config - Config component will handle completion and feedback
             try {
                 // Convert flat dotted keys to nested structure grouped by section
@@ -176,7 +177,7 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
                 throw new Error(errorMessage);
             }
         }, (operation) => {
-            handlers.onAborted(operation);
+            errorHandlers.onAborted(operation);
         }));
     }
     else if (taskType === TaskType.Execute) {
@@ -191,26 +192,26 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
                         .join('\n');
                     return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
                 });
-                handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                queueHandlers.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);
+                queueHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
+                    errorHandlers.onError(error);
                 }, () => {
-                    handlers.addToQueue(createExecuteDefinition(typeTasks, service));
+                    queueHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
                 }, (operation) => {
-                    handlers.onAborted(operation);
+                    errorHandlers.onAborted(operation);
                 }));
             }
             else {
-                handlers.addToQueue(createExecuteDefinition(typeTasks, service));
+                queueHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
             }
         }
         catch (error) {
             // Handle skill reference errors (e.g., unknown skills)
             const errorMessage = error instanceof Error ? error.message : String(error);
             const message = createMessage(errorMessage);
-            handlers.addToQueue(message);
+            queueHandlers.addToQueue(message);
         }
     }
 }

package/dist/services/skills.js

@@ -1,6 +1,7 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { defaultFileSystem } from './filesystem.js';
+import { displayWarning } from './logger.js';
 import { getUnknownSkillMessage } from './messages.js';
 import { parseSkillMarkdown, displayNameToKey } from './parser.js';
 /**
@@ -32,7 +33,7 @@ export function isValidSkillFilename(filename) {
     return kebabCasePattern.test(name);
 }
 /**
- * Check if skill key conflicts with built-in skills
+ * Check if skill key conflicts with system skills
  */
 export function conflictsWithBuiltIn(key) {
     return BUILT_IN_SKILLS.has(key);
@@ -46,16 +47,16 @@ export function getSkillsDirectory() {
 /**
  * Load all skill markdown files from the skills directory
  * Returns an array of objects with filename (key) and content
- * Filters out invalid filenames and conflicts with built-in skills
+ * Filters out invalid filenames and conflicts with system skills
  */
-export function loadSkills() {
+export function loadSkills(fs = defaultFileSystem) {
     const skillsDir = getSkillsDirectory();
     // Return empty array if directory doesn't exist
-    if (!existsSync(skillsDir)) {
+    if (!fs.exists(skillsDir)) {
         return [];
     }
     try {
-        const files = readdirSync(skillsDir);
+        const files = fs.readDirectory(skillsDir);
         // Filter and map valid skill files
         return files
             .filter((file) => {
@@ -65,7 +66,7 @@ export function loadSkills() {
             }
             // Extract key (filename without extension, handles both .md and .MD)
             const key = file.slice(0, -3);
-            // Must not conflict with built-in skills
+            // Must not conflict with system skills
             if (conflictsWithBuiltIn(key)) {
                 return false;
             }
@@ -75,12 +76,12 @@ export function loadSkills() {
             // Extract key (filename without extension, handles both .md and .MD)
             const key = file.slice(0, -3);
             const filePath = join(skillsDir, file);
-            const content = readFileSync(filePath, 'utf-8');
+            const content = fs.readFile(filePath, 'utf-8');
             return { key, content };
         });
     }
-    catch {
-        // Return empty array if there's any error reading the directory
+    catch (error) {
+        displayWarning('Failed to load skills directory', error);
         return [];
     }
 }
@@ -88,16 +89,16 @@ export function loadSkills() {
  * Load and parse all skill definitions
  * Returns structured skill definitions (including invalid skills)
  */
-export function loadSkillDefinitions() {
-    const skills = loadSkills();
+export function loadSkillDefinitions(fs = defaultFileSystem) {
+    const skills = loadSkills(fs);
     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();
+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

package/dist/services/validator.js

@@ -1,17 +1,18 @@
+import { defaultFileSystem } from './filesystem.js';
 import { loadUserConfig, hasConfigPath } from './loader.js';
 import { loadSkillDefinitions, createSkillLookup } from './skills.js';
 /**
  * Validate config requirements for execute tasks
  * Returns validation result with missing config and validation errors
  */
-export function validateExecuteTasks(tasks) {
-    const userConfig = loadUserConfig();
+export function validateExecuteTasks(tasks, fs = defaultFileSystem) {
+    const userConfig = loadUserConfig(fs);
     const missing = [];
     const seenPaths = new Set();
     const validationErrors = [];
     const seenSkills = new Set();
     // Load all skills (including invalid ones for validation)
-    const parsedSkills = loadSkillDefinitions();
+    const parsedSkills = loadSkillDefinitions(fs);
     const skillLookup = createSkillLookup(parsedSkills);
     // Check for invalid skills being used in tasks
     for (const task of tasks) {

package/dist/skills/introspect.md

@@ -26,8 +26,8 @@ You will receive:
 
 ## Task
 
-Present the concierge's capabilities as a list of tasks, each representing
-one capability.
+Present the concierge's capabilities as a list of capability objects, each
+with a name, description, and origin.
 
 ## Response Format
 
@@ -77,7 +77,7 @@ NON-NEGOTIABLE and applies to EVERY response.
 
 **CORRECT ORDER - FOLLOW EXACTLY:**
 
-### Position 1-4: Built-in Capabilities (Direct User Operations)
+### Position 1-4: system capabilities (origin: "system")
 
 These MUST appear FIRST, in this EXACT sequence:
 
@@ -86,47 +86,56 @@ These MUST appear FIRST, in this EXACT sequence:
 3. **Answer** ← ALWAYS THIRD
 4. **Execute** ← ALWAYS FOURTH
 
-### Position 5-7: Indirect Workflow Capabilities
+### Position 5-7: meta workflow capabilities (origin: "meta")
 
-These MUST appear AFTER Execute and BEFORE user skills:
+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)
 
-### 3. User-Defined Skills
+### 3. user-provided skills (origin: "user")
 
 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
+- Set origin to "user"
+- If the skill name contains "(INCOMPLETE)", set isIncomplete to true and
+  remove "(INCOMPLETE)" from the name
 - 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 skills whose name or description matches the filter
 
-## Task Definition Guidelines
+## Capability Object Guidelines
 
-Create tasks with type "introspect" for each capability. Each task should:
+Create capability objects for each capability. Each object should have:
 
-- **Action**: The capability name and a concise description
-  - Format: "Capability Name: description" (note: display format will use
-    " - " separator)
-  - **IMPORTANT**: Use title case for capability names (e.g., "Schedule",
-    "Execute"), NOT all uppercase (NOT "SCHEDULE", "EXECUTE")
+- **name**: The capability or skill name
+  - Use title case (e.g., "Schedule", "Execute", "Deploy Application")
+  - NOT all uppercase (NOT "SCHEDULE", "EXECUTE")
+  - Maximum 32 characters
+  - Examples: "Introspect", "Execute", "Deploy Application"
+
+- **description**: A concise description of what this capability does
+  - Maximum 64 characters
+  - Start with lowercase letter, no ending punctuation
+  - Focus on clarity and brevity
+  - Describe the core purpose in one short phrase
   - Examples:
-    - "Schedule: break down requests into actionable steps"
-    - "Execute: run shell commands and process operations"
-    - "Deploy Application: build and deploy to staging or production"
-- **Type**: Always use "introspect"
-- **Params**: Omit params field
-
-**Keep action descriptions concise:**
-- Maximum 60 characters for the description portion (after the colon)
-- Focus on clarity and brevity
-- Describe the core purpose in one short phrase
-- Start descriptions with a lowercase letter (they follow a colon)
+    - "break down requests into actionable steps"
+    - "run shell commands and process operations"
+    - "build and deploy to staging or production"
+
+- **origin**: The origin type of the capability
+  - Use "system" for system capabilities: Introspect, Configure, Answer,
+    Execute
+  - Use "meta" for meta workflow capabilities: Schedule, Validate, Report
+  - Use "user" for all user-provided skills
+
+- **isIncomplete**: Optional boolean flag
+  - Only include if the skill is marked as incomplete
+  - Set to true if skill name contained "(INCOMPLETE)"
 
 ## Filtering
 
@@ -134,48 +143,48 @@ When the user specifies a filter (e.g., "skills for deployment", "what
 can you do with files"):
 1. Parse the filter keyword(s) from the request
 2. Match against skill names and descriptions (case-insensitive)
-3. Include built-in capabilities if they match the filter
+3. Include system capabilities if they match the filter
 4. Only present capabilities that match the filter
 
 Examples:
 - "skills for deployment" → Only show skills with "deploy" in
   name/description
 - "what can you do with files" → Show EXECUTE and any file-related skills
-- "list all skills" → Show all built-in capabilities + all user skills
+- "list all skills" → Show all system capabilities + all user-provided skills
 
 ## Examples
 
 ### Example 1: List All Capabilities
 
 When user asks "list your skills", create an introductory message like
-"here are my capabilities:" followed by tasks for built-in capabilities
-(Introspect, Configure, Answer, Execute), then indirect workflow capabilities
-(Schedule, Validate, Report).
-
-Each task uses type "introspect" with an action describing the
-capability.
+"here are my capabilities:" followed by capability objects for system
+capabilities (Introspect, Configure, Answer, Execute with origin
+"system"), then meta workflow capabilities (Schedule, Validate, Report
+with origin "meta").
 
 ### Example 2: Filtered Skills
 
 When user asks "skills for deployment" and a "deploy app" skill exists,
 create an introductory message like "these skills match 'deployment':"
-followed by only the tasks that match the filter. In this case, show the
-deploy app skill with its description.
+followed by only the capabilities that match the filter. Show the deploy
+app skill with origin "user".
 
 ### Example 3: With User Skills
 
-When user asks "what can you do" and user-defined skills like "process
+When user asks "what can you do" and user-provided skills like "process
 data" and "backup files" exist, create an introductory message like "i can
-help with these operations:" followed by all built-in capabilities
-(Introspect, Configure, Answer, Execute, Validate, Schedule, Report) plus the
-user-defined skills. Each capability and skill becomes a task with type
-"introspect".
+help with these operations:" followed by all system capabilities
+(Introspect, Configure, Answer, Execute with origin "system"), meta
+capabilities (Schedule, Validate, Report with origin "meta"), plus the
+user-provided skills with origin "user".
 
 ## Final Validation
 
 Before finalizing:
-1. Ensure every task has type "introspect"
-2. Verify action descriptions are concise (≤64 characters)
+1. Ensure every capability has the correct origin value ("system",
+   "meta", or "user")
+2. Verify descriptions are concise (≤64 characters)
 3. Confirm the introductory message ends with a colon
 4. Check that filtering was applied correctly if specified
 5. Ensure no duplicate capabilities are listed
+6. Verify names use title case, not all uppercase

package/dist/skills/schedule.md

@@ -83,12 +83,17 @@ settings", type "configure", params { query: "app" }
 
 Before creating tasks, evaluate the request type:
 
-1. **Information requests** (questions) - Use question keywords:
+1. **Introspection requests** - User asks about your capabilities:
+   - "list your skills", "what can you do", "flex", "show off", "list
+     capabilities", "show skills"
+   - Example: "flex" → introspect type
+
+2. **Information requests** (questions) - Use question keywords:
    - "explain", "describe", "tell me", "what is", "how does", "find",
      "search"
    - Example: "explain docker" → answer type
 
-2. **Action requests** (commands) - Must match available skills:
+3. **Action requests** (commands) - Must match available skills:
    - Action verbs like "compile", "deploy", "process", "validate"
    - If verb matches a skill → extract skill steps as subtasks
    - If verb does NOT match any skill → ignore type with action
@@ -98,7 +103,7 @@ Before creating tasks, evaluate the request type:
    - Example: "validate" with no skill → action "Ignore unknown
      'validate' request"
 
-3. **Vague/ambiguous requests** without clear verb:
+4. **Vague/ambiguous requests** without clear verb:
    - Phrases like "do something", "handle it" → ignore type
    - Action format: "Ignore unknown 'X' request" where X is the phrase
 

package/dist/tools/introspect.tool.js

@@ -1,6 +1,6 @@
 export const introspectTool = {
     name: 'introspect',
-    description: 'Execute a task with type "introspect" to list available capabilities and skills. Called after SCHEDULE has identified an introspection request and user has confirmed. Takes the task action and optional filter parameter to present built-in capabilities and user-defined skills.',
+    description: 'Execute a task with type "introspect" to list available capabilities and skills. Called after SCHEDULE has identified an introspection request and user has confirmed. Takes the task action and optional filter parameter to present system capabilities and user-provided skills.',
     input_schema: {
         type: 'object',
         properties: {
@@ -8,25 +8,34 @@ export const introspectTool = {
                 type: 'string',
                 description: 'Introductory reply to display before the capabilities list. Must be a single sentence, maximum 64 characters (including the colon at the end). Vary this naturally - try to use a different phrase each time. Always end with a colon.',
             },
-            tasks: {
+            capabilities: {
                 type: 'array',
-                description: 'Array of capabilities, each with type "introspect". Include built-in capabilities (SCHEDULE, INTROSPECT, ANSWER, EXECUTE, REPORT, CONFIGURE) and user-defined skills from the Available Skills section.',
+                description: 'Array of capabilities and skills. Include system capabilities (Introspect, Configure, Answer, Execute) with origin "system", meta workflow capabilities (Schedule, Validate, Report) with origin "meta", and user-provided skills from the Available Skills section with origin "user".',
                 items: {
                     type: 'object',
                     properties: {
-                        action: {
+                        name: {
                             type: 'string',
-                            description: 'Capability name and description. Format: "NAME: Brief description". Maximum 64 characters. Examples: "SCHEDULE: Break down requests into steps", "Deploy App: Build and deploy application".',
+                            description: 'Capability or skill name. Use title case. Maximum 32 characters. Examples: "Execute", "Deploy Application", "Process Data".',
                         },
-                        type: {
+                        description: {
                             type: 'string',
-                            description: 'Always "introspect" for capability listings.',
+                            description: 'Brief description of what this capability does. Start with lowercase letter, no ending punctuation. Maximum 64 characters. Examples: "run shell commands and operations", "build and deploy to production".',
+                        },
+                        origin: {
+                            type: 'string',
+                            enum: ['system', 'user', 'meta'],
+                            description: 'Origin of the capability. Use "system" for system capabilities (Introspect, Configure, Answer, Execute), "meta" for meta workflow capabilities (Schedule, Validate, Report), and "user" for user-provided skills.',
+                        },
+                        isIncomplete: {
+                            type: 'boolean',
+                            description: 'Optional. Set to true if the skill is marked as incomplete.',
                         },
                     },
-                    required: ['action', 'type'],
+                    required: ['name', 'description', 'origin'],
                 },
             },
         },
-        required: ['message', 'tasks'],
+        required: ['message', 'capabilities'],
     },
 };