prompt-language-shell 0.8.2 → 0.8.4

package/dist/services/router.js

@@ -20,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
@@ -28,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);
@@ -36,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
@@ -47,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);
     }
 }
 /**
@@ -88,13 +88,13 @@ 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 = asScheduledTasks(tasks);
@@ -117,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 = [];
     };
@@ -130,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 {
@@ -145,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
@@ -177,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) {
@@ -192,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';
 /**
@@ -48,14 +49,14 @@ export function getSkillsDirectory() {
  * Returns an array of objects with filename (key) and content
  * 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) => {
@@ -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/types/guards.js

@@ -1,4 +1,5 @@
 import { TaskType } from './types.js';
+import { TaskSchema } from './schemas.js';
 /**
  * Type guard to check if a task is a ScheduledTask
  * ScheduledTask has optional subtasks property or is a Group type
@@ -14,12 +15,9 @@ export function asScheduledTasks(tasks) {
     return tasks;
 }
 /**
- * Type guard to check if a value is a valid Task
+ * Type guard to check if a value is a valid Task.
+ * Uses Zod schema for comprehensive runtime validation.
  */
 export function isTask(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'action' in value &&
-        typeof value.action === 'string' &&
-        'type' in value);
+    return TaskSchema.safeParse(value).success;
 }

package/dist/types/handlers.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schemas.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { Origin, TaskType } from './types.js';
+/**
+ * Zod schema for TaskType enum values.
+ * Validates that task types match the expected enum values.
+ */
+export const TaskTypeSchema = z.enum([
+    TaskType.Config,
+    TaskType.Schedule,
+    TaskType.Execute,
+    TaskType.Answer,
+    TaskType.Introspect,
+    TaskType.Report,
+    TaskType.Define,
+    TaskType.Ignore,
+    TaskType.Select,
+    TaskType.Discard,
+    TaskType.Group,
+]);
+/**
+ * Zod schema for Origin enum values.
+ * Validates capability origin types.
+ */
+export const OriginSchema = z.enum([
+    Origin.BuiltIn,
+    Origin.UserProvided,
+    Origin.Indirect,
+]);
+/**
+ * Zod schema for base Task type.
+ * Validates task structure with required action and type fields.
+ */
+export const TaskSchema = z.object({
+    action: z.string().min(1),
+    type: TaskTypeSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
+    config: z.array(z.string()).optional(),
+});
+/**
+ * Zod schema for recursive ScheduledTask type.
+ * Uses z.lazy for self-referential subtasks validation.
+ */
+export const ScheduledTaskSchema = z.object({
+    action: z.string().min(1),
+    type: TaskTypeSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
+    config: z.array(z.string()).optional(),
+    subtasks: z.lazy(() => ScheduledTaskSchema.array()).optional(),
+});
+/**
+ * Zod schema for ExecuteCommand type.
+ * Validates shell command execution parameters.
+ */
+export const ExecuteCommandSchema = z.object({
+    description: z.string().min(1),
+    command: z.string().min(1),
+    workdir: z.string().optional(),
+    timeout: z.number().int().positive().optional(),
+    critical: z.boolean().optional(),
+});
+/**
+ * Zod schema for Capability type.
+ * Validates skill and capability definitions.
+ */
+export const CapabilitySchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    origin: OriginSchema,
+    isIncomplete: z.boolean().optional(),
+});
+/**
+ * Zod schema for ComponentDefinition type.
+ * Flexible schema for debug component validation.
+ * Accepts both stateless and stateful component structures.
+ */
+export const ComponentDefinitionSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    props: z.record(z.string(), z.unknown()),
+    state: z.record(z.string(), z.unknown()).optional(),
+    status: z.string().optional(),
+});
+/**
+ * Zod schema for CommandResult type.
+ * Validates LLM responses from execute, answer, and schedule tools.
+ */
+export const CommandResultSchema = z.object({
+    message: z.string(),
+    summary: z.string().optional(),
+    tasks: z.array(ScheduledTaskSchema),
+    answer: z.string().optional(),
+    commands: z.array(ExecuteCommandSchema).optional(),
+    debug: z.array(ComponentDefinitionSchema).optional(),
+});
+/**
+ * Zod schema for IntrospectResult type.
+ * Validates LLM responses from introspect tool.
+ */
+export const IntrospectResultSchema = z.object({
+    message: z.string(),
+    capabilities: z.array(CapabilitySchema),
+    debug: z.array(ComponentDefinitionSchema).optional(),
+});

package/dist/types/types.js

@@ -38,6 +38,7 @@ export var Origin;
 export var FeedbackType;
 (function (FeedbackType) {
     FeedbackType["Info"] = "info";
+    FeedbackType["Warning"] = "warning";
     FeedbackType["Succeeded"] = "succeeded";
     FeedbackType["Aborted"] = "aborted";
     FeedbackType["Failed"] = "failed";

package/dist/ui/Answer.js

@@ -3,19 +3,18 @@ import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { addDebugToTimeline } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { withMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export function Answer({ question, state, status, service, handlers, }) {
+export function Answer({ question, state, status, service, stateHandlers, lifecycleHandlers, errorHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [answer, setAnswer] = useState(state?.answer ?? null);
     useInput((input, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('answer');
+            errorHandlers?.onAborted('answer');
         }
     }, { isActive });
     useEffect(() => {
@@ -30,26 +29,28 @@ export function Answer({ question, state, status, service, handlers, }) {
                 const result = await withMinimumTime(() => svc.processWithTool(question, 'answer'), MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     // Add debug components to timeline if present
-                    addDebugToTimeline(result.debug, handlers);
+                    if (result.debug?.length) {
+                        workflowHandlers?.addToTimeline(...result.debug);
+                    }
                     // Extract answer from result
                     const answerText = result.answer || '';
                     setAnswer(answerText);
                     // Update component state so answer persists in timeline
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         answer: answerText,
                     });
                     // Signal completion
-                    handlers?.completeActive();
+                    lifecycleHandlers?.completeActive();
                 }
             }
             catch (err) {
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         error: errorMessage,
                     });
-                    handlers?.onError(errorMessage);
+                    errorHandlers?.onError(errorMessage);
                 }
             }
         }
@@ -57,7 +58,7 @@ export function Answer({ question, state, status, service, handlers, }) {
         return () => {
             mounted = false;
         };
-    }, [question, isActive, service, handlers]);
+    }, [question, isActive, service]);
     const lines = answer ? answer.split('\n') : [];
     return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !answer && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Finding answer. " }), _jsx(Spinner, {})] })), answer && (_jsxs(_Fragment, { children: [_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsx(Text, { color: getTextColor(isActive), children: question }) }), _jsx(Box, { flexDirection: "column", paddingLeft: 3, children: lines.map((line, index) => (_jsx(Text, { color: getTextColor(isActive), children: line }, index))) })] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Command.js

@@ -4,7 +4,7 @@ import { Box, Text } from 'ink';
 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';
+import { createScheduleDefinition } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { handleRefinement } from '../services/refinement.js';
@@ -13,12 +13,12 @@ import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 import { UserQuery } from './UserQuery.js';
 const MIN_PROCESSING_TIME = 400; // purely for visual effect
-export function Command({ command, state, status, service, handlers, onAborted, }) {
+export function Command({ command, state, status, service, stateHandlers, lifecycleHandlers, queueHandlers, errorHandlers, workflowHandlers, onAborted, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(state?.error ?? null);
     useInput((_, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('request');
+            errorHandlers?.onAborted('request');
             onAborted?.('request');
         }
     }, { isActive });
@@ -51,33 +51,39 @@ export function Command({ command, state, status, service, handlers, onAborted,
                     const debugComponents = allConfig
                         ? [...scheduleDebug, ...(result.debug || [])]
                         : scheduleDebug;
-                    addDebugToTimeline(debugComponents, handlers);
+                    if (debugComponents.length > 0) {
+                        workflowHandlers?.addToTimeline(...debugComponents);
+                    }
                     // Save result to state for timeline display
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         message: result.message,
                         tasks: result.tasks,
                     });
                     // Check if tasks contain DEFINE type (variant selection needed)
                     const hasDefineTask = result.tasks.some((task) => task.type === TaskType.Define);
-                    if (!handlers) {
+                    // Guard: ensure all required handlers are present
+                    if (!queueHandlers ||
+                        !lifecycleHandlers ||
+                        !workflowHandlers ||
+                        !errorHandlers) {
                         return;
                     }
                     // Create Schedule definition
                     const scheduleDefinition = createScheduleDefinition(result.message, result.tasks, hasDefineTask
                         ? async (selectedTasks) => {
                             // Refinement flow for DEFINE tasks
-                            await handleRefinement(selectedTasks, svc, command, handlers);
+                            await handleRefinement(selectedTasks, svc, command, queueHandlers, lifecycleHandlers, workflowHandlers, errorHandlers);
                         }
                         : undefined);
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
-                        handlers.completeActive();
-                        handlers.addToQueue(scheduleDefinition);
+                        lifecycleHandlers.completeActive();
+                        queueHandlers.addToQueue(scheduleDefinition);
                     }
                     else {
                         // No DEFINE tasks: Complete Command, then route to Confirm flow
-                        handlers.completeActive();
-                        routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false);
+                        lifecycleHandlers.completeActive();
+                        routeTasksWithConfirm(result.tasks, result.message, svc, command, queueHandlers, workflowHandlers, errorHandlers, false);
                     }
                 }
             }
@@ -86,10 +92,10 @@ export function Command({ command, state, status, service, handlers, onAborted,
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         error: errorMessage,
                     });
-                    handlers?.onError(errorMessage);
+                    errorHandlers?.onError(errorMessage);
                 }
             }
         }
@@ -97,6 +103,6 @@ export function Command({ command, state, status, service, handlers, onAborted,
         return () => {
             mounted = false;
         };
-    }, [command, isActive, service, handlers]);
+    }, [command, isActive, service]);
     return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [!isActive ? (_jsxs(UserQuery, { children: ["> pls ", command] })) : (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: Colors.Text.Active, children: ["> pls ", command] }), _jsx(Text, { children: " " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Config.js

@@ -78,7 +78,8 @@ function SelectionStep({ options, selectedIndex, isCurrentStep, }) {
             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { dimColor: !isSelected || !isCurrentStep, bold: isSelected, children: option.label }) }, option.value));
         }) }));
 }
-export function Config({ steps, state, status, debug = DebugLevel.None, handlers, onFinished, onAborted, }) {
+export function Config(props) {
+    const { steps, state, status, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, onFinished, onAborted, } = props;
     const isActive = status === ComponentStatus.Active;
     const [step, setStep] = useState(!isActive ? (state?.completedStep ?? steps.length) : 0);
     const [values, setValues] = useState(() => {
@@ -170,7 +171,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 setValues({ ...values, [configKey]: currentValue });
             }
             // Save state before aborting
-            handlers?.updateState({
+            stateHandlers?.updateState({
                 values,
                 completedStep: step,
                 selectedIndex,
@@ -179,7 +180,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 onAborted('configuration');
             }
             // Complete with abort feedback
-            handlers?.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
             return;
         }
         // Handle selection step navigation
@@ -236,19 +237,19 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 completedStep: steps.length,
                 selectedIndex,
             };
-            handlers?.updateState(stateUpdate);
+            stateHandlers?.updateState(stateUpdate);
             // Call onFinished callback and handle result
             try {
                 if (onFinished) {
                     onFinished(newValues);
                 }
                 // Success - complete with success feedback
-                handlers?.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
+                lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
             }
             catch (error) {
                 // Failure - complete with error feedback
                 const errorMessage = error instanceof Error ? error.message : 'Configuration failed';
-                handlers?.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
+                lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
             }
             setStep(steps.length);
         }
@@ -259,7 +260,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 completedStep: step + 1,
                 selectedIndex,
             };
-            handlers?.updateState(stateUpdate);
+            stateHandlers?.updateState(stateUpdate);
             const nextStep = step + 1;
             setStep(nextStep);
             // Reset selectedIndex for next step

package/dist/ui/Confirm.js

@@ -5,7 +5,7 @@ import { ComponentStatus } from '../types/components.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, }) {
+export function Confirm({ message, state, status, stateHandlers, onConfirmed, onCancelled, }) {
     const isActive = status === ComponentStatus.Active;
     const [selectedIndex, setSelectedIndex] = useState(state?.selectedIndex ?? 0); // 0 = Yes, 1 = No
     useInput((input, key) => {
@@ -14,18 +14,18 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
         if (key.escape) {
             // Escape: highlight "No" and cancel
             setSelectedIndex(1);
-            handlers?.updateState({ selectedIndex: 1 });
+            stateHandlers?.updateState({ selectedIndex: 1 });
             onCancelled();
         }
         else if (key.tab) {
             // Toggle between Yes (0) and No (1)
             const newIndex = selectedIndex === 0 ? 1 : 0;
             setSelectedIndex(newIndex);
-            handlers?.updateState({ selectedIndex: newIndex });
+            stateHandlers?.updateState({ selectedIndex: newIndex });
         }
         else if (key.return) {
             // Confirm selection
-            handlers?.updateState({ selectedIndex, confirmed: true });
+            stateHandlers?.updateState({ selectedIndex, confirmed: true });
             if (selectedIndex === 0) {
                 onConfirmed();
             }