prompt-language-shell 0.8.0 → 0.8.2

package/dist/services/anthropic.js

@@ -48,8 +48,8 @@ export function cleanAnswerText(text) {
 export class AnthropicService {
     client;
     model;
-    constructor(key, model = 'claude-haiku-4-5-20251001') {
-        this.client = new Anthropic({ apiKey: key });
+    constructor(key, model = 'claude-haiku-4-5', timeout = 30000) {
+        this.client = new Anthropic({ apiKey: key, timeout });
         this.model = model;
     }
     async processWithTool(command, toolName, customInstructions) {
@@ -186,7 +186,33 @@ export class AnthropicService {
                 debug,
             };
         }
-        // Handle schedule and introspect tool responses
+        // Handle introspect tool response
+        if (toolName === 'introspect') {
+            if (!input.message || typeof input.message !== 'string') {
+                throw new Error('Invalid tool response: missing or invalid message field');
+            }
+            if (!input.capabilities || !Array.isArray(input.capabilities)) {
+                throw new Error('Invalid tool response: missing or invalid capabilities array');
+            }
+            // Validate each capability has required fields
+            input.capabilities.forEach((cap, i) => {
+                if (!cap.name || typeof cap.name !== 'string') {
+                    throw new Error(`Invalid capability at index ${String(i)}: missing or invalid 'name' field`);
+                }
+                if (!cap.description || typeof cap.description !== 'string') {
+                    throw new Error(`Invalid capability at index ${String(i)}: missing or invalid 'description' field`);
+                }
+                if (typeof cap.origin !== 'string') {
+                    throw new Error(`Invalid capability at index ${String(i)}: invalid 'origin' field`);
+                }
+            });
+            return {
+                message: input.message,
+                capabilities: input.capabilities,
+                debug,
+            };
+        }
+        // Handle schedule tool responses
         if (input.message === undefined || typeof input.message !== 'string') {
             throw new Error('Invalid tool response: missing or invalid message field');
         }

package/dist/services/colors.js

@@ -1,4 +1,4 @@
-import { FeedbackType, TaskType } from '../types/types.js';
+import { FeedbackType, Origin, TaskType } from '../types/types.js';
 import { DebugLevel } from './configuration.js';
 import { ExecutionStatus } from './shell.js';
 /**
@@ -132,6 +132,14 @@ const feedbackColors = {
     [FeedbackType.Aborted]: Palette.MediumOrange,
     [FeedbackType.Failed]: Colors.Status.Error,
 };
+/**
+ * Origin-specific color mappings (internal)
+ */
+const originColors = {
+    [Origin.BuiltIn]: Colors.Origin.BuiltIn,
+    [Origin.UserProvided]: Colors.Origin.UserProvided,
+    [Origin.Indirect]: Colors.Origin.Indirect,
+};
 /**
  * Process null color values based on current/historical state.
  *
@@ -170,6 +178,17 @@ export function getTaskColors(type, isCurrent) {
 export function getFeedbackColor(type, isCurrent) {
     return processColor(feedbackColors[type], isCurrent);
 }
+/**
+ * Get color for capability origin.
+ *
+ * Returns the color associated with each origin type:
+ * - BuiltIn: Cyan
+ * - UserProvided: Green
+ * - Indirect: Purple
+ */
+export function getOriginColor(origin) {
+    return originColors[origin];
+}
 /**
  * Get text color based on current/historical state.
  *

package/dist/services/components.js

@@ -78,7 +78,7 @@ export function createConfigStepsFromSchema(keys) {
         // Config file doesn't exist or can't be parsed
     }
     return keys.map((key) => {
-        // Check if key is in schema (built-in config)
+        // Check if key is in schema (system config)
         if (!(key in schema)) {
             // Key is not in schema - it's from a skill or discovered config
             // Create a simple text step with the full path as description

package/dist/services/config-labels.js

@@ -0,0 +1,75 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Get the path to the config labels cache file
+ */
+export function getConfigLabelsCachePath() {
+    return join(homedir(), '.pls', 'cache', 'config.json');
+}
+/**
+ * Get the cache directory path
+ */
+function getCacheDirectoryPath() {
+    return join(homedir(), '.pls', 'cache');
+}
+/**
+ * Ensure the cache directory exists
+ */
+function ensureCacheDirectoryExists() {
+    const cacheDir = getCacheDirectoryPath();
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+    }
+}
+/**
+ * Load config labels from cache file
+ * Returns empty object if file doesn't exist or is corrupted
+ */
+export function loadConfigLabels() {
+    try {
+        const cachePath = getConfigLabelsCachePath();
+        if (!existsSync(cachePath)) {
+            return {};
+        }
+        const content = readFileSync(cachePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Validate that parsed content is an object
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        // Return empty object on any error (parse error, read error, etc.)
+        return {};
+    }
+}
+/**
+ * Save multiple config labels to cache
+ */
+export function saveConfigLabels(labels) {
+    ensureCacheDirectoryExists();
+    // Load existing labels and merge with new ones
+    const existing = loadConfigLabels();
+    const merged = { ...existing, ...labels };
+    const cachePath = getConfigLabelsCachePath();
+    const content = JSON.stringify(merged, null, 2);
+    writeFileSync(cachePath, content, 'utf-8');
+}
+/**
+ * Save a single config label to cache
+ */
+export function saveConfigLabel(key, label) {
+    saveConfigLabels({ [key]: label });
+}
+/**
+ * Get a config label from cache
+ * Returns undefined if label doesn't exist
+ */
+export function getConfigLabel(key) {
+    const labels = loadConfigLabels();
+    return labels[key];
+}

package/dist/services/config-utils.js

@@ -0,0 +1,20 @@
+/**
+ * Utility functions for config manipulation
+ */
+/**
+ * Flatten nested config object to dot notation
+ * Example: { a: { b: 1 } } => { 'a.b': 1 }
+ */
+export function flattenConfig(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(result, flattenConfig(value, fullKey));
+        }
+        else {
+            result[fullKey] = value;
+        }
+    }
+    return result;
+}

package/dist/services/configuration.js

@@ -2,6 +2,18 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
+import { getConfigLabel } from './config-labels.js';
+import { flattenConfig } from './config-utils.js';
+/**
+ * Convert a dotted config key to a readable label
+ * Example: "project.alpha.repo" -> "Project Alpha Repo"
+ */
+function keyToLabel(key) {
+    return key
+        .split('.')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
 export var AnthropicModel;
 (function (AnthropicModel) {
     AnthropicModel["Sonnet"] = "claude-sonnet-4-5";
@@ -192,7 +204,7 @@ export function getConfigurationRequiredMessage(forFutureUse = false) {
     return messages[Math.floor(Math.random() * messages.length)];
 }
 /**
- * Core configuration schema - defines structure and types for built-in settings
+ * Core configuration schema - defines structure and types for system settings
  */
 const coreConfigSchema = {
     'anthropic.key': {
@@ -301,19 +313,6 @@ export function getConfiguredKeys() {
         const content = readFileSync(configFile, 'utf-8');
         const parsed = YAML.parse(content);
         // Flatten nested config to dot notation
-        function flattenConfig(obj, prefix = '') {
-            const result = {};
-            for (const [key, value] of Object.entries(obj)) {
-                const fullKey = prefix ? `${prefix}.${key}` : key;
-                if (value && typeof value === 'object' && !Array.isArray(value)) {
-                    Object.assign(result, flattenConfig(value, fullKey));
-                }
-                else {
-                    result[fullKey] = value;
-                }
-            }
-            return result;
-        }
         const flatConfig = flattenConfig(parsed);
         return Object.keys(flatConfig);
     }
@@ -337,19 +336,6 @@ export function getAvailableConfigStructure() {
             const content = readFileSync(configFile, 'utf-8');
             const parsed = YAML.parse(content);
             // Flatten nested config to dot notation
-            function flattenConfig(obj, prefix = '') {
-                const result = {};
-                for (const [key, value] of Object.entries(obj)) {
-                    const fullKey = prefix ? `${prefix}.${key}` : key;
-                    if (value && typeof value === 'object' && !Array.isArray(value)) {
-                        Object.assign(result, flattenConfig(value, fullKey));
-                    }
-                    else {
-                        result[fullKey] = value;
-                    }
-                }
-                return result;
-            }
             flatConfig = flattenConfig(parsed);
         }
     }
@@ -357,20 +343,13 @@ export function getAvailableConfigStructure() {
         // Config file doesn't exist or can't be read
     }
     // Add schema keys with descriptions
-    // Mark optional keys as (optional)
     for (const [key, definition] of Object.entries(schema)) {
-        const isOptional = !definition.required;
-        if (isOptional) {
-            structure[key] = `${definition.description} (optional)`;
-        }
-        else {
-            structure[key] = definition.description;
-        }
+        structure[key] = definition.description;
     }
     // Add discovered keys that aren't in schema
     for (const key of Object.keys(flatConfig)) {
         if (!(key in structure)) {
-            structure[key] = `${key} (discovered)`;
+            structure[key] = getConfigLabel(key) || keyToLabel(key);
         }
     }
     return structure;

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';
@@ -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 &&
@@ -96,7 +97,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
         handlers.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 = [];

package/dist/services/skills.js

@@ -32,7 +32,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,7 +46,7 @@ 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() {
     const skillsDir = getSkillsDirectory();
@@ -65,7 +65,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;
             }

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'],
     },
 };

package/dist/types/guards.js

@@ -0,0 +1,25 @@
+import { TaskType } from './types.js';
+/**
+ * Type guard to check if a task is a ScheduledTask
+ * ScheduledTask has optional subtasks property or is a Group type
+ */
+export function isScheduledTask(task) {
+    return 'subtasks' in task || task.type === TaskType.Group;
+}
+/**
+ * Type-safe conversion of Task array to ScheduledTask array
+ * This is safe because Tasks can be treated as ScheduledTask when checking for Groups
+ */
+export function asScheduledTasks(tasks) {
+    return tasks;
+}
+/**
+ * Type guard to check if a value is a valid Task
+ */
+export function isTask(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'action' in value &&
+        typeof value.action === 'string' &&
+        'type' in value);
+}

package/dist/types/types.js

@@ -29,6 +29,12 @@ export var TaskType;
     TaskType["Discard"] = "discard";
     TaskType["Group"] = "group";
 })(TaskType || (TaskType = {}));
+export var Origin;
+(function (Origin) {
+    Origin["BuiltIn"] = "system";
+    Origin["UserProvided"] = "user";
+    Origin["Indirect"] = "meta";
+})(Origin || (Origin = {}));
 export var FeedbackType;
 (function (FeedbackType) {
     FeedbackType["Info"] = "info";

package/dist/ui/Answer.js

@@ -23,11 +23,6 @@ export function Answer({ question, state, status, service, handlers, }) {
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             try {
@@ -58,7 +53,7 @@ export function Answer({ question, state, status, service, handlers, }) {
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };

package/dist/ui/Command.js

@@ -1,7 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
+import { ComponentStatus } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
 import { addDebugToTimeline, createScheduleDefinition, } from '../services/components.js';
@@ -27,11 +27,6 @@ export function Command({ command, state, status, service, handlers, onAborted,
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -64,6 +59,9 @@ export function Command({ command, state, status, service, handlers, onAborted,
                     });
                     // Check if tasks contain DEFINE type (variant selection needed)
                     const hasDefineTask = result.tasks.some((task) => task.type === TaskType.Define);
+                    if (!handlers) {
+                        return;
+                    }
                     // Create Schedule definition
                     const scheduleDefinition = createScheduleDefinition(result.message, result.tasks, hasDefineTask
                         ? async (selectedTasks) => {
@@ -73,12 +71,12 @@ export function Command({ command, state, status, service, handlers, onAborted,
                         : undefined);
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
-                        handlers?.completeActive();
-                        handlers?.addToQueue(scheduleDefinition);
+                        handlers.completeActive();
+                        handlers.addToQueue(scheduleDefinition);
                     }
                     else {
                         // No DEFINE tasks: Complete Command, then route to Confirm flow
-                        handlers?.completeActive();
+                        handlers.completeActive();
                         routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false);
                     }
                 }
@@ -95,7 +93,7 @@ export function Command({ command, state, status, service, handlers, onAborted,
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };

package/dist/ui/Config.js

@@ -8,6 +8,19 @@ import { Colors } from '../services/colors.js';
 import { createFeedback } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
 import { useInput } from '../services/keyboard.js';
+/**
+ * Get postfix with debug brackets if debug is enabled
+ * Info: {key} | Verbose: {key} entry
+ */
+function getPostfix(text, debugLevel) {
+    if (debugLevel === DebugLevel.None || !text) {
+        return '';
+    }
+    if (debugLevel === DebugLevel.Info) {
+        return `{${text}}`;
+    }
+    return `{${text}} entry`;
+}
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";
@@ -89,8 +102,8 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                         stepConfig.options[stepConfig.defaultIndex].value;
                     break;
                 default: {
-                    const exhaustiveCheck = stepConfig;
-                    throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
+                    const _exhaustiveCheck = stepConfig;
+                    throw new Error('Unsupported step type');
                 }
             }
         });
@@ -132,7 +145,6 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             const value = values[configKey] || '';
             setInputValue(value);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [step, isActive, steps]);
     useInput((_, key) => {
         if (!isActive || step >= steps.length)
@@ -140,25 +152,23 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
         const currentStepConfig = steps[step];
         if (key.escape) {
             // Save current value before aborting
-            if (currentStepConfig) {
-                const configKey = currentStepConfig.path || currentStepConfig.key;
-                let currentValue = '';
-                switch (currentStepConfig.type) {
-                    case StepType.Text:
-                        currentValue = inputValue || values[configKey] || '';
-                        break;
-                    case StepType.Selection:
-                        currentValue = values[configKey] || '';
-                        break;
-                    default: {
-                        const exhaustiveCheck = currentStepConfig;
-                        throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
-                    }
-                }
-                if (currentValue) {
-                    setValues({ ...values, [configKey]: currentValue });
+            const configKey = currentStepConfig.path || currentStepConfig.key;
+            let currentValue = '';
+            switch (currentStepConfig.type) {
+                case StepType.Text:
+                    currentValue = inputValue || values[configKey] || '';
+                    break;
+                case StepType.Selection:
+                    currentValue = values[configKey] || '';
+                    break;
+                default: {
+                    const _exhaustiveCheck = currentStepConfig;
+                    throw new Error('Unsupported step type');
                 }
             }
+            if (currentValue) {
+                setValues({ ...values, [configKey]: currentValue });
+            }
             // Save state before aborting
             handlers?.updateState({
                 values,
@@ -204,8 +214,8 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 break;
             }
             default: {
-                const exhaustiveCheck = currentStepConfig;
-                throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
+                const _exhaustiveCheck = currentStepConfig;
+                throw new Error('Unsupported step type');
             }
         }
         // Don't allow empty or invalid value
@@ -278,8 +288,8 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 return (_jsx(SelectionStep, { options: stepConfig.options, selectedIndex: selectedIndex, isCurrentStep: true }));
             }
             default: {
-                const exhaustiveCheck = stepConfig;
-                throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
+                const _exhaustiveCheck = stepConfig;
+                throw new Error('Unsupported step type');
             }
         }
     };
@@ -291,6 +301,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             if (!shouldShow) {
                 return null;
             }
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), debug !== DebugLevel.None && stepConfig.path && (_jsxs(Text, { color: Colors.Type.Define, children: ['{', stepConfig.path, '}'] }))] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.path || stepConfig.key));
+            const postfix = getPostfix(stepConfig.path, debug);
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), postfix && _jsx(Text, { color: Colors.Type.Config, children: postfix })] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.path || stepConfig.key));
         }) }));
 }

package/dist/ui/Confirm.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus } from '../types/components.js';
-import { Colors, Palette } from '../services/colors.js';
+import { Colors, getTextColor, Palette } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { UserQuery } from './UserQuery.js';
 export function Confirm({ message, state, status, handlers, onConfirmed, onCancelled, }) {
@@ -15,7 +15,7 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
             // Escape: highlight "No" and cancel
             setSelectedIndex(1);
             handlers?.updateState({ selectedIndex: 1 });
-            onCancelled?.();
+            onCancelled();
         }
         else if (key.tab) {
             // Toggle between Yes (0) and No (1)
@@ -27,10 +27,10 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
             // Confirm selection
             handlers?.updateState({ selectedIndex, confirmed: true });
             if (selectedIndex === 0) {
-                onConfirmed?.();
+                onConfirmed();
             }
             else {
-                onCancelled?.();
+                onCancelled();
             }
         }
     }, { isActive });
@@ -42,7 +42,7 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
         // When done, show both the message and user's choice in timeline
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: isActive ? Colors.Text.Active : Colors.Text.Inactive, children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
                             const isSelected = index === selectedIndex;
                             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
                         }) })] })] }));

package/dist/ui/Execute.js

@@ -69,10 +69,6 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         if (!isActive || taskInfos.length > 0 || hasProcessed) {
             return;
         }
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -156,7 +152,7 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
@@ -186,7 +182,7 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         else {
             // All tasks complete
             const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-            const summaryText = summary?.trim() || 'Execution completed';
+            const summaryText = summary.trim() || 'Execution completed';
             const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
             setCompletionMessage(completion);
             handlers?.updateState({
@@ -203,7 +199,7 @@ export function Execute({ tasks, state, status, service, handlers, }) {
     }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
     const handleTaskError = useCallback((index, error, elapsed) => {
         const task = taskInfos[index];
-        const isCritical = task?.command.critical !== false; // Default to true
+        const isCritical = task.command.critical !== false; // Default to true
         // Update task with elapsed time and failed status
         const updatedTaskInfos = taskInfos.map((task, i) => i === index
             ? { ...task, status: ExecutionStatus.Failed, elapsed }
@@ -242,7 +238,7 @@ export function Execute({ tasks, state, status, service, handlers, }) {
             else {
                 // Last task, complete execution
                 const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-                const summaryText = summary?.trim() || 'Execution completed';
+                const summaryText = summary.trim() || 'Execution completed';
                 const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
                 setCompletionMessage(completion);
                 handlers?.updateState({

package/dist/ui/Introspect.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
+import { ComponentStatus } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
 import { addDebugToTimeline, createReportDefinition, } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
@@ -10,49 +10,7 @@ import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
-const BUILT_IN_CAPABILITIES = new Set([
-    'CONFIGURE',
-    'SCHEDULE',
-    'INTROSPECT',
-    'ANSWER',
-    'EXECUTE',
-    'VALIDATE',
-    'REPORT',
-]);
-const INDIRECT_CAPABILITIES = new Set(['SCHEDULE', 'VALIDATE', 'REPORT']);
-function parseCapabilityFromTask(task) {
-    // Parse "NAME: Description" format from task.action
-    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: 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();
-    // 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: cleanName,
-        description,
-        isBuiltIn,
-        isIndirect,
-        isIncomplete,
-    };
-}
-export function Introspect({ tasks, state, status, service, children, debug = DebugLevel.None, handlers, }) {
+export function Introspect({ tasks, state: _state, status, service, children, debug = DebugLevel.None, handlers, }) {
     const isActive = status === ComponentStatus.Active;
     // isActive passed as prop
     const [error, setError] = useState(null);
@@ -66,11 +24,6 @@ export function Introspect({ tasks, state, status, service, children, debug = De
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -83,8 +36,8 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                 if (mounted) {
                     // Add debug components to timeline if present
                     addDebugToTimeline(result.debug, handlers);
-                    // Parse capabilities from returned tasks
-                    let capabilities = result.tasks.map(parseCapabilityFromTask);
+                    // Capabilities come directly from result - no parsing needed
+                    let capabilities = result.capabilities;
                     // Filter out internal capabilities when not in debug mode
                     if (debug === DebugLevel.None) {
                         capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
@@ -115,7 +68,7 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };

package/dist/ui/Main.js

@@ -86,7 +86,7 @@ export const Main = ({ app, command }) => {
                     throw new Error(errorMessage);
                 }
             };
-            const handleConfigAborted = (operation) => {
+            const handleConfigAborted = (_operation) => {
                 // Config was cancelled
             };
             setInitialQueue([

package/dist/ui/Report.js

@@ -1,14 +1,10 @@
 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, isIncomplete, }) {
-    const color = isIndirect
-        ? Colors.Origin.Indirect
-        : isBuiltIn
-            ? Colors.Origin.BuiltIn
-            : Colors.Origin.UserProvided;
+import { Colors, getOriginColor } from '../services/colors.js';
+function CapabilityItem({ name, description, origin, isIncomplete, }) {
+    const color = getOriginColor(origin);
     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, isIncomplete: capability.isIncomplete }, 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, origin: capability.origin, isIncomplete: capability.isIncomplete }, index))) })] }));
 }

package/dist/ui/Schedule.js

@@ -37,7 +37,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
             const planColors = getTaskColors(TaskType.Schedule, isCurrent);
             return {
                 description: {
-                    text: String(option),
+                    text: option,
                     color: colors.description,
                     highlightedColor: planColors.description,
                 },
@@ -96,7 +96,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
             // Complete the selection phase - it goes to timeline
             // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
             handlers?.completeActive();
-            onSelectionConfirmed(concreteTasks);
+            void onSelectionConfirmed(concreteTasks);
         }
     }, [
         isActive,
@@ -153,7 +153,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                         // This is a Define task - only include the selected option
                         const options = task.params.options;
                         const selectedIndex = newCompletedSelections[defineGroupIndex];
-                        const selectedOption = String(options[selectedIndex]);
+                        const selectedOption = options[selectedIndex];
                         // Use Execute as default - LLM will properly classify during refinement
                         refinedTasks.push({
                             action: selectedOption,
@@ -171,7 +171,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                     // Complete the selection phase - it goes to timeline
                     // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
                     handlers?.completeActive();
-                    onSelectionConfirmed(refinedTasks);
+                    void onSelectionConfirmed(refinedTasks);
                 }
                 else {
                     // No selection callback, just complete normally

package/dist/ui/Spinner.js

@@ -17,7 +17,9 @@ export function Spinner() {
                 return next !== prev ? next : prev;
             });
         }, INTERVAL);
-        return () => clearInterval(timer);
+        return () => {
+            clearInterval(timer);
+        };
     }, []);
     return _jsx(Text, { color: Palette.Cyan, children: FRAMES[frame] });
 }

package/dist/ui/Subtask.js

@@ -4,7 +4,7 @@ import { getStatusColors, Palette, STATUS_ICONS } from '../services/colors.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
-export function Subtask({ label, command, status, isActive, startTime, endTime, elapsed, }) {
+export function Subtask({ label, command, status, isActive: _isActive, startTime, endTime, elapsed, }) {
     const colors = getStatusColors(status);
     const isCancelled = status === ExecutionStatus.Cancelled;
     const isAborted = status === ExecutionStatus.Aborted;

package/dist/ui/Task.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { ExecutionStatus, executeCommand, } from '../services/shell.js';
+import { ExecutionResult, ExecutionStatus, executeCommand, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
 import { Subtask } from './Subtask.js';
 export function Task({ label, command, isActive, index, initialStatus, initialElapsed, onComplete, onAbort, onError, }) {
@@ -19,7 +19,9 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 return next !== prev ? next : prev;
             });
         }, 1000);
-        return () => clearInterval(interval);
+        return () => {
+            clearInterval(interval);
+        };
     }, [status, startTime]);
     // Execute command when becoming active
     useEffect(() => {
@@ -43,10 +45,10 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 setEndTime(end);
                 const taskDuration = calculateElapsed(start);
                 setElapsed(taskDuration);
-                setStatus(output.result === 'success'
+                setStatus(output.result === ExecutionResult.Success
                     ? ExecutionStatus.Success
                     : ExecutionStatus.Failed);
-                if (output.result === 'success') {
+                if (output.result === ExecutionResult.Success) {
                     onComplete?.(index, output, taskDuration);
                 }
                 else {
@@ -64,11 +66,10 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 onError?.(index, err instanceof Error ? err.message : 'Unknown error', errorDuration);
             }
         }
-        execute();
+        void execute();
         return () => {
             mounted = false;
         };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isActive]);
     // Handle abort when task becomes inactive while running
     useEffect(() => {

package/dist/ui/Validate.js

@@ -6,6 +6,7 @@ import { TaskType } from '../types/types.js';
 import { Colors, getTextColor } from '../services/colors.js';
 import { addDebugToTimeline, createConfigStepsFromSchema, } from '../services/components.js';
 import { DebugLevel, saveConfig, unflattenConfig, } from '../services/configuration.js';
+import { saveConfigLabels } from '../services/config-labels.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
@@ -17,22 +18,16 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
     const [error, setError] = useState(state?.error ?? null);
     const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
     const [configRequirements, setConfigRequirements] = useState(state?.configRequirements ?? null);
-    const [showConfig, setShowConfig] = useState(false);
     useInput((_, key) => {
-        if (key.escape && isActive && !showConfig) {
+        if (key.escape && isActive) {
             onAborted('validation');
         }
-    }, { isActive: isActive && !showConfig });
+    }, { isActive });
     useEffect(() => {
         // Skip processing if not active
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -93,13 +88,11 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                         configRequirements: null,
                         validated: false,
                     });
-                    if (onError) {
-                        onError(errorMessage);
-                    }
+                    onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
@@ -133,6 +126,16 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
     const handleConfigFinished = (config) => {
         // Convert flat dotted keys to nested structure grouped by section
         const configBySection = unflattenConfig(config);
+        // Extract and save labels to cache
+        if (configRequirements) {
+            const labels = {};
+            for (const req of configRequirements) {
+                if (req.description) {
+                    labels[req.path] = req.description;
+                }
+            }
+            saveConfigLabels(labels);
+        }
         // Save each section
         for (const [section, sectionConfig] of Object.entries(configBySection)) {
             saveConfig(section, sectionConfig);
@@ -141,7 +144,9 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
         // This allows the workflow to proceed to execution
         handlers?.completeActive();
         // Invoke callback which will queue the Execute component
-        onComplete?.(configRequirements);
+        if (configRequirements) {
+            onComplete(configRequirements);
+        }
     };
     const handleConfigAborted = (operation) => {
         // Mark validation component as complete when aborted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",